ppport.h

   1 #if 0
   2 <<'SKIP';
   3 #endif
   4 /*
   5 ----------------------------------------------------------------------
   6
   7     ppport.h -- Perl/Pollution/Portability Version 3.56
   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.56
  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
  50                               from 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_07, and has been tested up to 5.31.6.
  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 automagically 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_07. 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     caller_cx()               NEED_caller_cx               NEED_caller_cx_GLOBAL
 221     croak_xs_usage()          NEED_croak_xs_usage          NEED_croak_xs_usage_GLOBAL
 222     die_sv()                  NEED_die_sv                  NEED_die_sv_GLOBAL
 223     eval_pv()                 NEED_eval_pv                 NEED_eval_pv_GLOBAL
 224     grok_bin()                NEED_grok_bin                NEED_grok_bin_GLOBAL
 225     grok_hex()                NEED_grok_hex                NEED_grok_hex_GLOBAL
 226     grok_number()             NEED_grok_number             NEED_grok_number_GLOBAL
 227     grok_numeric_radix()      NEED_grok_numeric_radix      NEED_grok_numeric_radix_GLOBAL
 228     grok_oct()                NEED_grok_oct                NEED_grok_oct_GLOBAL
 229     load_module()             NEED_load_module             NEED_load_module_GLOBAL
 230     mess()                    NEED_mess                    NEED_mess_GLOBAL
 231     mess_nocontext()          NEED_mess_nocontext          NEED_mess_nocontext_GLOBAL
 232     mess_sv()                 NEED_mess_sv                 NEED_mess_sv_GLOBAL
 233     mg_findext()              NEED_mg_findext              NEED_mg_findext_GLOBAL
 234     my_snprintf()             NEED_my_snprintf             NEED_my_snprintf_GLOBAL
 235     my_sprintf()              NEED_my_sprintf              NEED_my_sprintf_GLOBAL
 236     my_strlcat()              NEED_my_strlcat              NEED_my_strlcat_GLOBAL
 237     my_strlcpy()              NEED_my_strlcpy              NEED_my_strlcpy_GLOBAL
 238     my_strnlen()              NEED_my_strnlen              NEED_my_strnlen_GLOBAL
 239     newCONSTSUB()             NEED_newCONSTSUB             NEED_newCONSTSUB_GLOBAL
 240     newSVpvn_share()          NEED_newSVpvn_share          NEED_newSVpvn_share_GLOBAL
 241     PL_parser                 NEED_PL_parser               NEED_PL_parser_GLOBAL
 242     PL_signals                NEED_PL_signals              NEED_PL_signals_GLOBAL
 243     pv_display()              NEED_pv_display              NEED_pv_display_GLOBAL
 244     pv_escape()               NEED_pv_escape               NEED_pv_escape_GLOBAL
 245     pv_pretty()               NEED_pv_pretty               NEED_pv_pretty_GLOBAL
 246     sv_catpvf_mg()            NEED_sv_catpvf_mg            NEED_sv_catpvf_mg_GLOBAL
 247     sv_catpvf_mg_nocontext()  NEED_sv_catpvf_mg_nocontext  NEED_sv_catpvf_mg_nocontext_GLOBAL
 248     sv_setpvf_mg()            NEED_sv_setpvf_mg            NEED_sv_setpvf_mg_GLOBAL
 249     sv_setpvf_mg_nocontext()  NEED_sv_setpvf_mg_nocontext  NEED_sv_setpvf_mg_nocontext_GLOBAL
 250     sv_unmagicext()           NEED_sv_unmagicext           NEED_sv_unmagicext_GLOBAL
 251     utf8_to_uvchr_buf()       NEED_utf8_to_uvchr_buf       NEED_utf8_to_uvchr_buf_GLOBAL
 252     vload_module()            NEED_vload_module            NEED_vload_module_GLOBAL
 253     vmess()                   NEED_vmess                   NEED_vmess_GLOBAL
 254     warner()                  NEED_warner                  NEED_warner_GLOBAL
 255
 256 To avoid namespace conflicts, you can change the namespace of the
 257 explicitly exported functions / variables using the C<DPPP_NAMESPACE>
 258 macro. Just C<#define> the macro before including C<ppport.h>:
 259
 260     #define DPPP_NAMESPACE MyOwnNamespace_
 261     #include "ppport.h"
 262
 263 The default namespace is C<DPPP_>.
 264
 265 =back
 266
 267 The good thing is that most of the above can be checked by running
 268 F<ppport.h> on your source code. See the next section for
 269 details.
 270
 271 =head1 EXAMPLES
 272
 273 To verify whether F<ppport.h> is needed for your module, whether you
 274 should make any changes to your code, and whether any special defines
 275 should be used, F<ppport.h> can be run as a Perl script to check your
 276 source code. Simply say:
 277
 278     perl ppport.h
 279
 280 The result will usually be a list of patches suggesting changes
 281 that should at least be acceptable, if not necessarily the most
 282 efficient solution, or a fix for all possible problems.
 283
 284 If you know that your XS module uses features only available in
 285 newer Perl releases, if you're aware that it uses C++ comments,
 286 and if you want all suggestions as a single patch file, you could
 287 use something like this:
 288
 289     perl ppport.h --compat-version=5.6.0 --cplusplus --patch=test.diff
 290
 291 If you only want your code to be scanned without any suggestions
 292 for changes, use:
 293
 294     perl ppport.h --nochanges
 295
 296 You can specify a different C<diff> program or options, using
 297 the C<--diff> option:
 298
 299     perl ppport.h --diff='diff -C 10'
 300
 301 This would output context diffs with 10 lines of context.
 302
 303 If you want to create patched copies of your files instead, use:
 304
 305     perl ppport.h --copy=.new
 306
 307 To display portability information for the C<newSVpvn> function,
 308 use:
 309
 310     perl ppport.h --api-info=newSVpvn
 311
 312 Since the argument to C<--api-info> can be a regular expression,
 313 you can use
 314
 315     perl ppport.h --api-info=/_nomg$/
 316
 317 to display portability information for all C<_nomg> functions or
 318
 319     perl ppport.h --api-info=/./
 320
 321 to display information for all known API elements.
 322
 323 =head1 BUGS
 324
 325 Some of the suggested edits and/or generated patches may not compile as-is
 326 without tweaking manually.  This is generally due to the need for an extra
 327 parameter to be added to the call to prevent buffer overflow.
 328
 329 If this version of F<ppport.h> is causing failure during
 330 the compilation of this module, please check if newer versions
 331 of either this module or C<Devel::PPPort> are available on CPAN
 332 before sending a bug report.
 333
 334 If F<ppport.h> was generated using the latest version of
 335 C<Devel::PPPort> and is causing failure of this module, please
 336 send a bug report to L<perlbug@perl.org|mailto:perlbug@perl.org>.
 337
 338 Please include the following information:
 339
 340 =over 4
 341
 342 =item 1.
 343
 344 The complete output from running "perl -V"
 345
 346 =item 2.
 347
 348 This file.
 349
 350 =item 3.
 351
 352 The name and version of the module you were trying to build.
 353
 354 =item 4.
 355
 356 A full log of the build that failed.
 357
 358 =item 5.
 359
 360 Any other information that you think could be relevant.
 361
 362 =back
 363
 364 For the latest version of this code, please get the C<Devel::PPPort>
 365 module from CPAN.
 366
 367 =head1 COPYRIGHT
 368
 369 Version 3.x, Copyright (c) 2004-2013, Marcus Holland-Moritz.
 370
 371 Version 2.x, Copyright (C) 2001, Paul Marquess.
 372
 373 Version 1.x, Copyright (C) 1999, Kenneth Albanowski.
 374
 375 This program is free software; you can redistribute it and/or
 376 modify it under the same terms as Perl itself.
 377
 378 =head1 SEE ALSO
 379
 380 See L<Devel::PPPort>.
 381
 382 =cut
 383
 384 # These are tools that must be included in ppport.h.  It doesn't work if given
 385 # a .pl suffix
 386
 387 sub format_version
 388 {
 389   # Given an input version that is acceptable to parse_version(), return a
 390   # string of the standard representation of it.
 391
 392   my($r,$v,$s) = parse_version(shift);
 393
 394   if ($r < 5 || ($r == 5 && $v < 6)) {
 395     my $ver = sprintf "%d.%03d", $r, $v;
 396     $s > 0 and $ver .= sprintf "_%02d", $s;
 397
 398     return $ver;
 399   }
 400
 401   return sprintf "%d.%d.%d", $r, $v, $s;
 402 }
 403
 404 sub parse_version
 405 {
 406   # Returns a triplet, (5, major, minor) from the input, treated as a string,
 407   # which can be in any of several typical formats.
 408
 409   my $ver = shift;
 410   $ver = "" unless defined $ver;
 411
 412   my($r,$v,$s);
 413
 414   if (   ($r, $v, $s) = $ver =~ /^(5)(\d{3})(\d{3})$/ # 5029010, from the file
 415                                                       # names in our
 416                                                       # parts/base/ and
 417                                                       # parts/todo directories
 418       or ($r, $v, $s) = $ver =~ /^(\d+)\.(\d+)\.(\d+)$/   # 5.25.7
 419       or ($r, $v, $s) = $ver =~ /^(\d+)\.(\d{3})(\d{3})$/ # 5.025008, from the
 420                                                           # output of $]
 421       or ($r, $v, $s) = $ver =~ /^(\d+)\.(\d{1,3})()$/    # 5.24, 5.004
 422       or ($r, $v, $s) = $ver =~ /^(\d+)\.(00[1-5])_?(\d{2})$/  # 5.003_07
 423   ) {
 424
 425     $s = 0 unless $s;
 426
 427     die "Only Perl 5 is supported '$ver'\n" if $r != 5;
 428     die "Invalid version number: $ver\n" if $v >= 1000 || $s >= 1000;
 429     return (5, 0 + $v, 0 + $s);
 430   }
 431
 432   # For some safety, don't assume something is a version number if it has a
 433   # literal dot as one of the three characters.  This will have to be fixed
 434   # when we reach 5.46
 435   if ($ver !~ /\./ && (($r, $v, $s) = $ver =~ /^(.)(.)(.)$/))  # vstring 5.25.7
 436   {
 437     $r = ord $r;
 438     $v = ord $v;
 439     $s = ord $s;
 440
 441     die "Only Perl 5 is supported '$ver'\n" if $r != 5;
 442     return (5, $v, $s);
 443   }
 444
 445   my $mesg = "";
 446   $mesg = ".  (In 5.00x_yz, x must be 1-5.)" if $ver =~ /_/;
 447   die "Invalid version number format: '$ver'$mesg\n";
 448 }
 449
 450 sub int_parse_version
 451 {
 452     # Returns integer 7 digit human-readable version, suitable for use in file
 453     # names in parts/todo parts/base.
 454
 455     return 0 + join "", map { sprintf("%03d", $_) } parse_version(shift);
 456 }
 457
 458 sub ivers    # Shorter name for int_parse_version
 459 {
 460     return int_parse_version(shift);
 461 }
 462
 463 sub format_version_line
 464 {
 465     # Returns a floating point representation of the input version
 466
 467     my $version = int_parse_version(shift);
 468     $version =~ s/^5\B/5./;
 469     return $version;
 470 }
 471
 472 sub dictionary_order($$)    # Sort caselessly, ignoring punct
 473 {
 474     my ($lc_a, $lc_b);
 475     my ($squeezed_a, $squeezed_b);
 476     my ($valid_a, $valid_b);    # Meaning valid for all releases
 477
 478     # On early perls, the implicit pass by reference doesn't work, so we have
 479     # to use the globals to initialize.
 480     if ("$]" < "5.006" ) {
 481         $valid_a = $a; $valid_b = $b;
 482     }
 483     else {
 484         ($valid_a, $valid_b) = @_;
 485     }
 486
 487     $lc_a = lc $valid_a;
 488     $lc_b = lc $valid_b;
 489
 490     $squeezed_a = $lc_a;
 491     $squeezed_a =~ s/[\W_]//g;   # No punct, including no underscore
 492     $squeezed_b = $lc_b;
 493     $squeezed_b =~ s/[\W_]//g;
 494
 495     return( $squeezed_a cmp $squeezed_b
 496          or       $lc_a cmp $lc_b
 497          or    $valid_a cmp $valid_b);
 498 }
 499
 500 sub sort_api_lines  # Sort lines of the form flags|return|name|args...
 501                     # by 'name'
 502 {
 503     $a =~ / ^ [^|]* \| [^|]* \| (\w+) /x; # 3rd field '|' is sep
 504     my $a_name = $1;
 505     $b =~ / ^ [^|]* \| [^|]* \| (\w+) /x;
 506     my $b_name = $1;
 507     return dictionary_order($a_name, $b_name);
 508 }
 509
 510 1;
 511
 512 use strict;
 513
 514 # Disable broken TRIE-optimization
 515 BEGIN { eval '${^RE_TRIE_MAXBUF} = -1' if "$]" >= 5.009004 && "$]" <= 5.009005 }
 516
 517 my $VERSION = 3.56;
 518
 519 my %opt = (
 520   quiet     => 0,
 521   diag      => 1,
 522   hints     => 1,
 523   changes   => 1,
 524   cplusplus => 0,
 525   filter    => 1,
 526   strip     => 0,
 527   version   => 0,
 528 );
 529
 530 my($ppport) = $0 =~ /([\w.]+)$/;
 531 my $LF = '(?:\r\n|[\r\n])';   # line feed
 532 my $HS = "[ \t]";             # horizontal whitespace
 533
 534 # Never use C comments in this file!
 535 my $ccs  = '/'.'*';
 536 my $cce  = '*'.'/';
 537 my $rccs = quotemeta $ccs;
 538 my $rcce = quotemeta $cce;
 539
 540 eval {
 541   require Getopt::Long;
 542   Getopt::Long::GetOptions(\%opt, qw(
 543     help quiet diag! filter! hints! changes! cplusplus strip version
 544     patch=s copy=s diff=s compat-version=s
 545     list-provided list-unsupported api-info=s
 546   )) or usage();
 547 };
 548
 549 if ($@ and grep /^-/, @ARGV) {
 550   usage() if "@ARGV" =~ /^--?h(?:elp)?$/;
 551   die "Getopt::Long not found. Please don't use any options.\n";
 552 }
 553
 554 if ($opt{version}) {
 555   print "This is $0 $VERSION.\n";
 556   exit 0;
 557 }
 558
 559 usage() if $opt{help};
 560 strip() if $opt{strip};
 561
 562 $opt{'compat-version'} = 5.003_07 unless exists $opt{'compat-version'};
 563 $opt{'compat-version'} = int_parse_version($opt{'compat-version'});
 564
 565 my $int_min_perl = int_parse_version(5.003_07);
 566
 567 # Each element of this hash looks something like:
 568 # 'Poison' => {
 569 #                         'base' => '5.008000',
 570 #                         'provided' => 1,
 571 #                         'todo' => '5.003007'
 572 #             },
 573 my %API = map { /^(\w+)\|([^|]*)\|([^|]*)\|(\w*)$/
 574                 ? ( $1 => {
 575                       ($2                  ? ( base     => $2 ) : ()),
 576                       ($3                  ? ( todo     => $3 ) : ()),
 577                       (index($4, 'v') >= 0 ? ( varargs  => 1  ) : ()),
 578                       (index($4, 'p') >= 0 ? ( provided => 1  ) : ()),
 579                       (index($4, 'n') >= 0 ? ( noTHXarg => 1  ) : ()),
 580                       (index($4, 'c') >= 0 ? ( core_only    => 1  ) : ()),
 581                       (index($4, 'd') >= 0 ? ( deprecated   => 1  ) : ()),
 582                       (index($4, 'i') >= 0 ? ( inaccessible => 1  ) : ()),
 583                       (index($4, 'x') >= 0 ? ( experimental => 1  ) : ()),
 584                       (index($4, 'u') >= 0 ? ( undocumented => 1  ) : ()),
 585                       (index($4, 'o') >= 0 ? ( ppport_fnc => 1  ) : ()),
 586                       (index($4, 'V') >= 0 ? ( unverified => 1  ) : ()),
 587                     } )
 588                 : die "invalid spec: $_" } qw(
 589 abort_execution|5.025010||Viu
 590 add_above_Latin1_folds|5.021001||Viu
 591 add_cp_to_invlist|5.013011||Viu
 592 add_data|5.005000||nViu
 593 add_multi_match|5.021004||Viu
 594 _add_range_to_invlist|5.016000||cViu
 595 add_utf16_textfilter|5.011001||Viu
 596 adjust_size_and_find_bucket|5.019003||nViu
 597 advance_one_LB|5.023007||Viu
 598 advance_one_SB|5.021009||Viu
 599 advance_one_WB|5.021009||Viu
 600 alloccopstash|5.017001|5.017001|x
 601 alloc_LOGOP|5.025004||xViu
 602 allocmy|5.008001||Viu
 603 amagic_call|5.003007|5.003007|u
 604 amagic_cmp|5.009003||Viu
 605 amagic_cmp_locale|5.009003||Viu
 606 amagic_deref_call|5.013007|5.013007|u
 607 amagic_i_ncmp|5.009003||Viu
 608 amagic_is_enabled|5.015008||Viu
 609 amagic_ncmp|5.009003||Viu
 610 _aMY_CXT|5.009000|5.009000|p
 611 aMY_CXT_|5.009000|5.009000|p
 612 aMY_CXT|5.009000|5.009000|p
 613 anonymise_cv_maybe|5.013003||Viu
 614 any_dup|5.006000||Vu
 615 ao|5.005000||Viu
 616 _append_range_to_invlist|5.013010||Viu
 617 append_utf8_from_native_byte|5.019004||ncViu
 618 apply|5.003007||Viu
 619 apply_attrs|5.006000||Viu
 620 apply_attrs_my|5.007003||Viu
 621 apply_attrs_string|5.006001|5.006001|xu
 622 ARCHNAME|5.004000|5.004000|
 623 argvout_final|5.029006||Viu
 624 ASCII_TO_NEED|5.019004||ndcVu
 625 __ASSERT_|5.019007|5.008008|p
 626 assert_uft8_cache_coherent|5.013003||Viu
 627 assignment_type|5.021005||Viu
 628 atfork_lock|5.007002|5.007002|nu
 629 atfork_unlock|5.007002|5.007002|nu
 630 aTHX_|5.006000|5.003007|p
 631 aTHX|5.006000|5.003007|p
 632 aTHXR_||5.003007|pou
 633 aTHXR||5.003007|pou
 634 av_arylen_p|5.009003|5.009003|u
 635 av_clear|5.003007|5.003007|
 636 av_create_and_push|5.009005|5.009005|x
 637 av_create_and_unshift_one|5.009005|5.009005|x
 638 av_delete|5.006000|5.006000|
 639 av_exists|5.006000|5.006000|
 640 av_extend|5.003007|5.003007|
 641 av_extend_guts|5.017004||Viu
 642 av_fetch|5.003007|5.003007|
 643 av_fill|5.003007|5.003007|
 644 AvFILL|5.003007|5.003007|
 645 AvFILLp|5.004005|5.003007|poV
 646 av_iter_p|5.011000|5.011000|u
 647 av_len|5.003007|5.003007|
 648 av_make|5.003007|5.003007|
 649 av_nonelem|5.027009||Viu
 650 av_pop|5.003007|5.003007|
 651 av_push|5.003007|5.003007|
 652 av_reify|5.004004||cViu
 653 av_shift|5.003007|5.003007|
 654 av_store|5.003007|5.003007|
 655 av_tindex|5.017009|5.003007|p
 656 av_top_index|5.017009|5.003007|p
 657 av_undef|5.003007|5.003007|
 658 av_unshift|5.003007|5.003007|
 659 ax|5.003007|5.003007|
 660 backup_one_GCB|5.025003||Viu
 661 backup_one_LB|5.023007||Viu
 662 backup_one_SB|5.021009||Viu
 663 backup_one_WB|5.021009||Viu
 664 bad_type_gv|5.019002||Viu
 665 bad_type_pv|5.016000||Viu
 666 BhkDISABLE|||x
 667 BhkENABLE|||x
 668 BhkENTRY_set|||x
 669 BhkENTRY|||xi
 670 BhkFLAGS|||xi
 671 BIN|5.003007|5.003007|
 672 bind_match|5.003007||Viu
 673 block_end|5.004000|5.004000|
 674 block_gimme|5.004000|5.004000|u
 675 blockhook_register|5.013003|5.013003|x
 676 block_start|5.004000|5.004000|
 677 BOM_UTF8|5.025005|5.003007|p
 678 boolSV|5.004000|5.003007|p
 679 boot_core_mro|5.009005||Viu
 680 boot_core_PerlIO|5.007002||Viu
 681 boot_core_UNIVERSAL|5.003007||Viu
 682 _byte_dump_string|5.025006||cViu
 683 BYTEORDER|5.003007|5.003007|
 684 bytes_cmp_utf8|5.013007|5.013007|
 685 bytes_from_utf8|5.007001|5.007001|x
 686 bytes_from_utf8_loc|5.027001|5.027001|nxu
 687 bytes_to_utf8|5.006001|5.006001|x
 688 call_argv|5.006000|5.003007|p
 689 call_atexit|5.006000|5.006000|u
 690 CALL_BLOCK_HOOKS|||xi
 691 caller_cx|5.013005|5.006000|p
 692 call_list|5.004000|5.004000|u
 693 call_method|5.006000|5.003007|p
 694 calloc|5.007002|5.007002|n
 695 call_pv|5.006000|5.003007|p
 696 call_sv|5.006000|5.003007|p
 697 cando|5.003007||Viu
 698 C_ARRAY_END|5.013002|5.003007|p
 699 C_ARRAY_LENGTH|5.008001|5.003007|p
 700 CASTFLAGS|5.003007|5.003007|
 701 cast_i32|5.006000|5.006000|nu
 702 cast_iv|5.006000|5.006000|nu
 703 cast_ulong|5.006000|5.006000|nu
 704 cast_uv|5.006000|5.006000|nu
 705 category_name|5.027008||nViu
 706 cBOOL|5.013000|5.003007|p
 707 change_engine_size|5.029004||Viu
 708 CHARBITS|5.011002|5.011002|
 709 checkcomma|5.003007||Viu
 710 check_locale_boundary_crossing|5.015006||Viu
 711 check_type_and_open|5.009003||Viu
 712 check_uni|5.003007||Viu
 713 check_utf8_print|5.013009||Viu
 714 ck_entersub_args_core|||iu
 715 ck_entersub_args_list|5.013006|5.013006|
 716 ck_entersub_args_proto|5.013006|5.013006|
 717 ck_entersub_args_proto_or_list|5.013006|5.013006|
 718 ckWARN2|5.006000|5.006000|
 719 ckWARN2_d|5.006000|5.006000|
 720 ckWARN3|5.007003|5.007003|
 721 ckWARN3_d|5.007003|5.007003|
 722 ckWARN4|5.007003|5.007003|
 723 ckWARN4_d|5.007003|5.007003|
 724 ckWARN|5.006000|5.003007|p
 725 ckwarn|5.009003|5.009003|u
 726 ckwarn_common|5.011001||Viu
 727 ckWARN_d|5.006000|5.006000|
 728 ckwarn_d|5.009003|5.009003|u
 729 ck_warner|5.011001|5.011001|vu
 730 ck_warner_d|5.011001|5.011001|vu
 731 CLASS||5.003007|
 732 clear_defarray|5.023008|5.023008|u
 733 CLEAR_ERRSV|5.025007|5.025007|
 734 clear_placeholders|5.009004||xViu
 735 clear_special_blocks|5.021003||Viu
 736 clone_params_del|5.013002|5.013002|nu
 737 clone_params_new|5.013002|5.013002|nu
 738 closest_cop|5.007002||Viu
 739 cntrl_to_mnemonic|5.021004||nViu
 740 compute_EXACTish|5.017003||nViu
 741 construct_ahocorasick_from_trie|5.021001||Viu
 742 cop_fetch_label|5.015001|5.015001|x
 743 CopFILE|5.006000||pVu
 744 CopFILEAV|5.006000||pVu
 745 CopFILEGV|5.006000||pVu
 746 CopFILEGV_set|5.006000||pVu
 747 CopFILE_set|5.006000||pVu
 748 CopFILESV|5.006000||pVu
 749 cop_free|5.006000||Viu
 750 cophh_2hv|5.013007|5.013007|x
 751 cophh_copy|5.013007|5.013007|x
 752 cophh_delete_pv|5.013007|5.013007|x
 753 cophh_delete_pvn|5.013007|5.013007|x
 754 cophh_delete_pvs|5.013007|5.013007|x
 755 cophh_delete_sv|5.013007|5.013007|x
 756 cophh_fetch_pv|5.013007|5.013007|x
 757 cophh_fetch_pvn|5.013007|5.013007|x
 758 cophh_fetch_pvs|5.013007|5.013007|x
 759 cophh_fetch_sv|5.013007|5.013007|x
 760 cophh_free|5.013007|5.013007|x
 761 cophh_new_empty|5.013007|5.013007|x
 762 cophh_store_pv|5.013007|5.013007|x
 763 cophh_store_pvn|5.013007|5.013007|x
 764 cophh_store_pvs|5.013007|5.013007|x
 765 cophh_store_sv|5.013007|5.013007|x
 766 cop_hints_2hv|5.013007|5.013007|
 767 cop_hints_fetch_pv|5.013007|5.013007|
 768 cop_hints_fetch_pvn|5.013007|5.013007|
 769 cop_hints_fetch_pvs|5.013007|5.013007|
 770 cop_hints_fetch_sv|5.013007|5.013007|
 771 CopLABEL|5.009005|5.009005|
 772 CopLABEL_len|5.016000|5.016000|
 773 CopLABEL_len_flags|5.016000|5.016000|
 774 CopSTASH|5.006000||pVu
 775 CopSTASH_eq|5.006000||pVu
 776 CopSTASHPV|5.006000||pVu
 777 CopSTASHPV_set|5.006000||pVu
 778 CopSTASH_set|5.006000||pVu
 779 cop_store_label|5.015001|5.015001|x
 780 Copy|5.003007|5.003007|
 781 CopyD|5.009002|5.003007|p
 782 core_prototype|5.015002||Vi
 783 coresub_op|5.015003||Viu
 784 CPERLscope|5.005000||pVu
 785 CPPLAST|5.006000|5.006000|
 786 CPPMINUS|5.003007|5.003007|
 787 CPPRUN|5.006000|5.006000|
 788 CPPSTDIN|5.003007|5.003007|
 789 create_eval_scope|5.009004||xViu
 790 croak|5.006000|5.003007|v
 791 croak_caller|5.025004||vnViu
 792 croak_memory_wrap|5.017006|5.003007|pnu
 793 croak_nocontext|5.006000||pvnVu
 794 croak_no_mem|5.017006||nViu
 795 croak_no_modify|5.013003|5.003007|pn
 796 croak_popstack|5.017008||ncViu
 797 croak_sv|5.013001|5.003007|p
 798 croak_xs_usage|5.010001|5.003007|pn
 799 cr_textfilter|5.006000||Viu
 800 csighandler1|||nu
 801 csighandler3|||nu
 802 csighandler|||nu
 803 current_re_engine|5.017001||cViu
 804 curse|5.013009||Viu
 805 custom_op_desc|5.007003|5.007003|d
 806 custom_op_get_field|5.019006||cViu
 807 custom_op_name|5.007003|5.007003|d
 808 custom_op_register|5.013007|5.013007|
 809 cv_ckproto_len_flags|5.015004||xcViu
 810 cv_clone|5.003007|5.003007|
 811 cv_clone_into|5.017004||Viu
 812 cv_const_sv|5.003007|5.003007|n
 813 cv_const_sv_or_av|5.019003||nViu
 814 CvDEPTH|5.003007|5.003007|nu
 815 cv_dump|5.006000||Vi
 816 cv_forget_slab|5.017002||Vi
 817 cv_get_call_checker|5.013006|5.013006|
 818 cv_get_call_checker_flags|5.027003|5.027003|
 819 CvGV|5.003007|5.003007|u
 820 cvgv_from_hek|||ciu
 821 cvgv_set|5.013003||cViu
 822 cv_name|5.021005|5.021005|
 823 CvPADLIST|5.008001|5.008001|x
 824 cv_set_call_checker|5.013006|5.013006|
 825 cv_set_call_checker_flags|5.021004|5.021004|
 826 CvSTASH|5.003007|5.003007|
 827 cvstash_set|5.013007||cViu
 828 cv_undef|5.003007|5.003007|
 829 cv_undef_flags|5.021004||Viu
 830 CvWEAKOUTSIDE|||i
 831 CX_CURPAD_SAVE|||i
 832 CX_CURPAD_SV|||i
 833 cx_dump|5.005000|5.005000|u
 834 cx_dup|5.007003|5.007003|u
 835 cxinc|5.003007|5.003007|u
 836 cx_popblock|5.023008|5.023008|xu
 837 cx_popeval|5.023008|5.023008|xu
 838 cx_popformat|5.023008|5.023008|xu
 839 cx_popgiven|5.027008|5.027008|xu
 840 cx_poploop|5.023008|5.023008|xu
 841 cx_popsub|5.023008|5.023008|xu
 842 cx_popsub_args|5.023008|5.023008|xu
 843 cx_popsub_common|5.023008|5.023008|xu
 844 cx_popwhen|5.027008|5.027008|xu
 845 cx_pushblock|5.023008|5.023008|xu
 846 cx_pusheval|5.023008|5.023008|xu
 847 cx_pushformat|5.023008|5.023008|xu
 848 cx_pushgiven|5.027008|5.027008|xu
 849 cx_pushloop_for|5.023008|5.023008|xu
 850 cx_pushloop_plain|5.023008|5.023008|xu
 851 cx_pushsub|5.023008|5.023008|xu
 852 cx_pushwhen|5.027008|5.027008|xu
 853 cx_topblock|5.023008|5.023008|xu
 854 dAX|5.007002|5.003007|p
 855 dAXMARK|5.009003|5.003007|p
 856 deb|5.007003|5.007003|vu
 857 deb_curcv|5.007002||Viu
 858 deb_nocontext|5.007003|5.007003|vnu
 859 debop|5.005000|5.005000|u
 860 debprof|5.005000||Viu
 861 debprofdump|5.005000|5.005000|u
 862 debstack|5.007003|5.007003|u
 863 deb_stack_all|5.008001||Viu
 864 deb_stack_n|5.008001||Viu
 865 debstackptrs|5.007003|5.007003|u
 866 debug_start_match|5.009004||Viu
 867 DECLARATION_FOR_LC_NUMERIC_MANIPULATION|5.021010|5.021010|
 868 defelem_target|5.019002||Viu
 869 DEFSV|5.004005|5.003007|poVu
 870 DEFSV_set|5.010001||pVu
 871 delete_eval_scope|5.009004||xViu
 872 delimcpy|5.004000|5.004000|nu
 873 delimcpy_no_escape|5.025005||nViu
 874 del_sv|5.005000||Viu
 875 despatch_signals|5.007001|5.007001|u
 876 destroy_matcher|5.027008||Viu
 877 die|5.006000|5.003007|v
 878 die_nocontext|5.006000||vnVu
 879 die_sv|5.013001|5.003007|p
 880 die_unwind|5.013001||Viu
 881 dirp_dup|5.013007|5.013007|u
 882 dITEMS|5.007002|5.003007|p
 883 div128|5.005000||Viu
 884 djSP|||i
 885 dMARK|5.003007|5.003007|
 886 dMULTICALL|5.009003|5.009003|
 887 dMY_CXT|5.009000|5.009000|p
 888 dMY_CXT_SV|5.007003||poVu
 889 dNOOP|5.006000|5.003007|poVu
 890 do_aexec5|5.006000||Viu
 891 do_aexec|||iu
 892 do_aspawn|5.008000||Vu
 893 do_binmode|5.004005|5.004005|du
 894 docatch|5.005000||Vi
 895 do_chomp|5.003007||Viu
 896 do_close|5.003007|5.003007|u
 897 do_delete_local|5.011000||Viu
 898 do_dump_pad|5.008001||Vi
 899 do_eof|5.003007||Viu
 900 does_utf8_overflow|5.025006||nViu
 901 doeval_compile|5.023008||Viu
 902 do_exec3|5.006000||Viu
 903 do_exec|5.003007||Viu
 904 dofile|5.005003||Viu
 905 dofindlabel|5.003007||Viu
 906 doform|5.005000||Viu
 907 do_gv_dump|5.006000|5.006000|u
 908 do_gvgv_dump|5.006000|5.006000|u
 909 do_hv_dump|5.006000|5.006000|u
 910 doing_taint|5.008001|5.008001|nu
 911 do_ipcctl|5.003007||Viu
 912 do_ipcget|5.003007||Viu
 913 do_join|5.003007|5.003007|u
 914 do_magic_dump|5.006000|5.006000|u
 915 do_msgrcv|5.003007||Viu
 916 do_msgsnd|5.003007||Viu
 917 do_ncmp|5.015001||Viu
 918 do_oddball|5.006000||Viu
 919 dooneliner|5.006000||Viu
 920 do_op_dump|5.006000|5.006000|u
 921 do_open|5.003007|5.003007|u
 922 do_open6|5.019010||xViu
 923 do_open9|5.006000|5.006000|du
 924 do_openn|5.007001|5.007001|u
 925 doopen_pm|5.008001||Viu
 926 do_open_raw|5.019010||xViu
 927 doparseform|5.005000||Viu
 928 do_pmop_dump|5.006000|5.006000|u
 929 dopoptoeval|5.003007||Viu
 930 dopoptogivenfor|5.027008||Viu
 931 dopoptolabel|5.005000||Viu
 932 dopoptoloop|5.005000||Viu
 933 dopoptosub_at|5.005000||Viu
 934 dopoptowhen|5.027008||Viu
 935 do_print|5.003007||Viu
 936 do_readline|5.003007||Viu
 937 doref|5.009003|5.009003|u
 938 dORIGMARK|5.003007|5.003007|
 939 do_seek|5.003007||Viu
 940 do_semop|5.003007||Viu
 941 do_shmio|5.003007||Viu
 942 do_smartmatch|5.027008||Viu
 943 do_spawn|5.008000||Vu
 944 do_spawn_nowait|5.008000||Vu
 945 do_sprintf|5.003007|5.003007|u
 946 do_sv_dump|5.006000|5.006000|u
 947 do_sysseek|5.004000||Viu
 948 do_tell|5.003007||Viu
 949 do_trans|5.003007||Viu
 950 do_trans_complex|5.006001||Viu
 951 do_trans_count|5.006001||Viu
 952 do_trans_count_invmap|5.031006||Viu
 953 do_trans_invmap|5.031006||Viu
 954 do_trans_simple|5.006001||Viu
 955 DOUBLEINFBYTES|5.023000|5.023000|
 956 DOUBLEKIND|5.021006|5.021006|
 957 DOUBLEMANTBITS|5.023000|5.023000|
 958 DOUBLENANBYTES|5.023000|5.023000|
 959 DOUBLESIZE|5.005000|5.005000|
 960 dounwind|5.003007|5.003007|u
 961 DO_UTF8|5.006000|5.006000|
 962 do_vecget|5.006000||Viu
 963 do_vecset|5.003007||Viu
 964 do_vop|5.003007||Viu
 965 dowantarray|5.003007|5.003007|u
 966 drand48_init_r|||nciu
 967 drand48_r|||nciu
 968 dSAVEDERRNO|||i
 969 dSAVE_ERRNO|||i
 970 dSP|5.003007|5.003007|
 971 dTHR|5.004005|5.003007|p
 972 dTHX|5.003007|5.003007|p
 973 dTHXa|5.006000||pVu
 974 dTHXoa|5.006000||pVu
 975 dTHXR||5.003007|pou
 976 dtrace_probe_call|||ciu
 977 dtrace_probe_load|||ciu
 978 dtrace_probe_op|||ciu
 979 dtrace_probe_phase|||ciu
 980 dump_all|5.006000|5.006000|
 981 dump_all_perl|5.011000||Viu
 982 dump_c_backtrace|5.021001||V
 983 dump_eval|5.006000|5.006000|u
 984 dump_exec_pos|5.009004||Viu
 985 dump_form|5.006000|5.006000|u
 986 dump_indent|5.006000|5.006000|vu
 987 dump_mstats|5.003007||Vu
 988 dump_packsubs|5.006000|5.006000|
 989 dump_packsubs_perl|5.011000||Viu
 990 dump_regex_sets_structures|5.025006||Viu
 991 dump_sub|5.006000|5.006000|u
 992 dump_sub_perl|5.011000||Viu
 993 dump_sv_child|5.009003||Viu
 994 dump_trie|5.009004||Viu
 995 dump_trie_interim_list|5.009004||Viu
 996 dump_trie_interim_table|5.009004||Viu
 997 dumpuntil|5.005000||Viu
 998 dump_vindent|5.006000|5.006000|u
 999 dUNDERBAR|5.009002|5.003007|p
1000 dup_attrlist|5.006000||Viu
1001 dup_warnings|||ciu
1002 dVAR|5.009003|5.003007|p
1003 dXCPT|5.009002|5.003007|p
1004 dXSARGS|5.003007|5.003007|
1005 dXSI32|5.003007|5.003007|V
1006 dXSTARG|5.006000|5.003007|poVu
1007 edit_distance|5.023008||nViu
1008 emulate_cop_io|||xciu
1009 emulate_setlocale|5.027009||nViu
1010 END_EXTERN_C|5.005000|5.003007|poVu
1011 ENTER|5.003007|5.003007|
1012 ENTER_with_name|5.011002|5.011002|
1013 ERRSV|5.004005|5.003007|p
1014 eval_pv|5.006000|5.003007|p
1015 eval_sv|5.006000|5.003007|p
1016 exec_failed|5.009004||Viu
1017 expect_number|5.007001||Viu
1018 EXTEND|5.003007|5.003007|
1019 EXTERN_C|5.005000|5.003007|poVu
1020 F0convert|5.009003||nViu
1021 fbm_compile|5.005000|5.005000|
1022 fbm_instr|5.005000|5.005000|
1023 filter_add|5.003007|5.003007|
1024 filter_del|5.003007|5.003007|u
1025 filter_gets|5.005000||Viu
1026 filter_read|5.003007|5.003007|
1027 finalize_op|5.015002||Viu
1028 finalize_optree|5.015002||Vi
1029 find_and_forget_pmops|5.009005||Viu
1030 find_array_subscript|5.009004||Viu
1031 find_beginning|5.005000||Viu
1032 find_byclass|5.006000||Viu
1033 find_default_stash|5.019004||Viu
1034 find_first_differing_byte_pos|||nViu
1035 find_hash_subscript|5.009004||Viu
1036 find_in_my_stash|5.006001||Viu
1037 find_lexical_cv|5.019001||Viu
1038 find_next_masked|5.027009||nViu
1039 find_runcv|5.008001|5.008001|
1040 find_runcv_where|5.017002||Viu
1041 find_rundefsv|5.013002|5.013002|
1042 find_rundefsvoffset|5.009002|5.009002|d
1043 find_script|5.004005||Viu
1044 find_span_end|5.027009||nViu
1045 find_span_end_mask|5.027009||nViu
1046 find_uninit_var|5.009002||xVi
1047 first_symbol|5.009003||nViu
1048 fixup_errno_string|5.019007||Viu
1049 fold_constants|5.003007||Viu
1050 foldEQ|5.013002|5.013002|n
1051 foldEQ_latin1|5.013008|5.013008|nu
1052 foldEQ_latin1_s2_folded|5.029007||nViu
1053 foldEQ_locale|5.013002|5.013002|n
1054 foldEQ_utf8|5.013002|5.007003|p
1055 foldEQ_utf8_flags|5.013010||cVu
1056 forbid_setid|5.005000||Viu
1057 force_ident|5.003007||Viu
1058 force_ident_maybe_lex|5.017004||Viu
1059 force_list|5.003007||Viu
1060 force_next|5.003007||Viu
1061 _force_out_malformed_utf8_message|5.025009||cVu
1062 force_strict_version|5.011004||Viu
1063 force_version|5.005000||Viu
1064 force_word|5.003007||Viu
1065 forget_pmop|5.017007||Viu
1066 form|5.006000|5.004000|v
1067 form_nocontext|5.006000||vnVu
1068 form_short_octal_warning|5.017008||Viu
1069 fp_dup|5.007003|5.007003|u
1070 fprintf_nocontext|5.006000||vndVu
1071 free_c_backtrace|5.021001||Vi
1072 free_global_struct|5.009003||Vu
1073 free_tied_hv_pool|5.008001||Viu
1074 FREETMPS|5.003007|5.003007|
1075 free_tmps|5.003007|5.003007|u
1076 G_ARRAY|5.003007|5.003007|
1077 G_DISCARD|5.003007|5.003007|
1078 gen_constant_list|5.003007||Viu
1079 get_and_check_backslash_N_name|5.017006||cViu
1080 get_and_check_backslash_N_name_wrapper|5.029009||Viu
1081 get_ANYOF_cp_list_for_ssc|5.019005||Viu
1082 get_ANYOFM_contents|5.027009||Viu
1083 get_aux_mg|5.011000||Viu
1084 get_av|5.006000|5.003007|p
1085 get_c_backtrace|5.021001||Vi
1086 get_c_backtrace_dump|5.021001||V
1087 get_context|5.006000|5.006000|nu
1088 get_cv|5.006000|5.003007|p
1089 get_cvn_flags|5.009005|5.003007|p
1090 get_cvs|5.011000||pVu
1091 getcwd_sv|5.007002|5.007002|
1092 get_db_sub|||iu
1093 get_debug_opts|5.008001||Viu
1094 getenv_len|5.006000||Viu
1095 get_hash_seed|5.008001||Viu
1096 get_hv|5.006000|5.003007|p
1097 get_invlist_iter_addr|5.015001||nViu
1098 get_invlist_offset_addr|5.019002||nViu
1099 get_invlist_previous_index_addr|5.017004||nViu
1100 get_mstats|5.006000||Vu
1101 get_no_modify|5.005000||Viu
1102 get_num|5.008001||Viu
1103 get_opargs|5.005000||Viu
1104 get_op_descs|5.005000|5.005000|u
1105 get_op_names|5.005000|5.005000|u
1106 get_ppaddr|5.006000|5.006000|u
1107 get_re_arg|||xciu
1108 _get_regclass_nonbitmap_data|5.019009||cViu
1109 get_regex_charset_name|5.031004||nViu
1110 get_sv|5.006000|5.003007|p
1111 GetVars|5.006000||Vu
1112 get_vtbl|5.005003|5.005003|u
1113 G_EVAL|5.003007|5.003007|
1114 GIMME|5.003007|5.003007|
1115 GIMME_V|5.004000|5.004000|
1116 gimme_V|5.031005|5.031005|xu
1117 glob_2number|5.009004||Viu
1118 glob_assign_glob|5.009004||Viu
1119 G_METHOD|5.006001|5.003007|p
1120 G_METHOD_NAMED|5.019002|5.019002|
1121 G_NOARGS|5.003007|5.003007|
1122 gp_dup|5.007003|5.007003|u
1123 gp_free|5.003007|5.003007|u
1124 gp_ref|5.003007|5.003007|u
1125 G_RETHROW||5.003007|p
1126 grok_atoUV|5.021010||ncVi
1127 grok_bin|5.007003|5.003007|p
1128 grok_bslash_c|5.013001||cViu
1129 grok_bslash_N|5.017003||Viu
1130 grok_bslash_o|5.013003||cViu
1131 grok_bslash_x|5.017002||cViu
1132 grok_hex|5.007003|5.003007|p
1133 grok_infnan|5.021004|5.021004|
1134 grok_number|5.007002|5.003007|p
1135 grok_number_flags|5.021002|5.021002|
1136 GROK_NUMERIC_RADIX|5.007002|5.003007|p
1137 grok_numeric_radix|5.007002|5.003007|p
1138 grok_oct|5.007003|5.003007|p
1139 group_end|5.007003||Viu
1140 G_SCALAR|5.003007|5.003007|
1141 GV_ADD|5.003007|5.003007|
1142 gv_add_by_type|5.011000|5.011000|u
1143 Gv_AMupdate|5.011000|5.011000|u
1144 gv_autoload4|5.004000|5.004000|u
1145 gv_autoload_pv|5.015004|5.015004|u
1146 gv_autoload_pvn|5.015004|5.015004|u
1147 gv_autoload_sv|5.015004|5.015004|u
1148 GvAV|5.003007|5.003007|
1149 gv_AVadd|5.003007|5.003007|u
1150 gv_check|5.003007|5.003007|u
1151 gv_const_sv|5.009003|5.009003|
1152 GvCV|5.003007|5.003007|
1153 gv_dump|5.006000|5.006000|u
1154 gv_efullname3|5.003007|5.003007|u
1155 gv_efullname4|5.006001|5.006001|u
1156 gv_efullname|5.003007|5.003007|du
1157 gv_fetchfile|5.003007|5.003007|u
1158 gv_fetchfile_flags|5.009005|5.009005|u
1159 gv_fetchmeth|5.003007|5.003007|
1160 gv_fetchmeth_autoload|5.007003|5.007003|
1161 gv_fetchmeth_internal|5.021007||Viu
1162 gv_fetchmethod|5.003007|5.003007|
1163 gv_fetchmethod_autoload|5.004000|5.004000|
1164 gv_fetchmethod_pv_flags|5.015004|5.015004|xu
1165 gv_fetchmethod_pvn_flags|5.015004|5.015004|xu
1166 gv_fetchmethod_sv_flags|5.015004|5.015004|xu
1167 gv_fetchmeth_pv|5.015004|5.015004|
1168 gv_fetchmeth_pv_autoload|5.015004|5.015004|
1169 gv_fetchmeth_pvn|5.015004|5.015004|
1170 gv_fetchmeth_pvn_autoload|5.015004|5.015004|
1171 gv_fetchmeth_sv|5.015004|5.015004|
1172 gv_fetchmeth_sv_autoload|5.015004|5.015004|
1173 gv_fetchpv|5.003007|5.003007|u
1174 gv_fetchpvn_flags|5.009002|5.003007|pu
1175 gv_fetchpvs|5.009004||pVu
1176 gv_fetchsv|5.009002|5.003007|pu
1177 gv_fullname3|5.003007|5.003007|u
1178 gv_fullname4|5.006001|5.006001|u
1179 gv_fullname|5.003007|5.003007|du
1180 gv_handler|5.007001|5.007001|u
1181 GvHV|5.003007|5.003007|
1182 gv_HVadd|5.003007|5.003007|u
1183 gv_init|5.003007|5.003007|
1184 gv_init_pv|5.015004|5.015004|
1185 gv_init_pvn|5.015004|5.003007|p
1186 gv_init_sv|5.015004|5.015004|
1187 gv_init_svtype|5.015004||Viu
1188 gv_IOadd|5.003007|5.003007|u
1189 gv_is_in_main|5.019004||Viu
1190 gv_magicalize|5.019004||Viu
1191 gv_magicalize_isa|5.013005||Viu
1192 gv_name_set|5.009004|5.009004|u
1193 GV_NOADD_MASK|5.009005|5.003007|poVu
1194 G_VOID|5.004000|5.004000|
1195 gv_override|5.019006||Viu
1196 gv_setref|5.021005||Viu
1197 gv_stashpv|5.003007|5.003007|
1198 gv_stashpvn|5.003007|5.003007|p
1199 gv_stashpvn_internal|5.021004||Viu
1200 gv_stashpvs|5.009003|5.003007|p
1201 gv_stashsv|5.003007|5.003007|
1202 gv_stashsvpvn_cached|5.021004||Viu
1203 GV_SUPER|5.017004|5.017004|
1204 GvSV|5.003007|5.003007|
1205 gv_SVadd|||u
1206 GvSVn|5.009003||pVu
1207 gv_try_downgrade|5.011002||xcVi
1208 handle_named_backref|5.023008||Viu
1209 handle_possible_posix|5.023008||Viu
1210 handle_regex_sets|5.017009||Viu
1211 handle_user_defined_property|5.029008||cViu
1212 he_dup|5.007003|5.007003|u
1213 HEf_SVKEY|5.003007|5.003007|p
1214 HeHASH|5.003007|5.003007|
1215 hek_dup|5.009000|5.009000|u
1216 HeKEY|5.003007|5.003007|
1217 HeKLEN|5.003007|5.003007|
1218 HePV|5.004000|5.004000|
1219 HeSVKEY|5.003007|5.003007|
1220 HeSVKEY_force|5.003007|5.003007|
1221 HeSVKEY_set|5.004000|5.004000|
1222 HeUTF8|5.010001|5.008000|p
1223 HeVAL|5.003007|5.003007|
1224 hfree_next_entry|||iu
1225 hsplit|5.005000||Viu
1226 hv_assert|5.008009|5.008009|
1227 hv_auxinit|5.009003||Viu
1228 hv_auxinit_internal|5.019010||nViu
1229 hv_backreferences_p|||xiu
1230 hv_bucket_ratio|5.025003|5.025003|x
1231 hv_clear|5.003007|5.003007|
1232 hv_clear_placeholders|5.009001|5.009001|
1233 hv_common|5.010000|5.010000|u
1234 hv_common_key_len|5.010000|5.010000|u
1235 hv_copy_hints_hv|5.009004|5.009004|
1236 hv_delayfree_ent|5.004000|5.004000|u
1237 hv_delete|5.003007|5.003007|
1238 hv_delete_common|5.009001||xViu
1239 hv_delete_ent|5.003007|5.003007|
1240 hv_eiter_p|5.009003|5.009003|u
1241 hv_eiter_set|5.009003|5.009003|u
1242 HvENAME|5.013007|5.013007|
1243 hv_ename_add|5.013007||Vi
1244 hv_ename_delete|5.013007||Vi
1245 HvENAMELEN|5.015004|5.015004|
1246 HvENAMEUTF8|5.015004|5.015004|
1247 hv_exists|5.003007|5.003007|
1248 hv_exists_ent|5.003007|5.003007|
1249 hv_fetch|5.003007|5.003007|
1250 hv_fetch_ent|5.003007|5.003007|
1251 hv_fetchs|5.009003|5.003007|p
1252 HvFILL|5.003007|5.003007|
1253 hv_fill|5.013002|5.013002|
1254 hv_free_ent|5.004000|5.004000|u
1255 hv_free_ent_ret|5.015000||Viu
1256 hv_free_entries|5.027002||Viu
1257 hv_iterinit|5.003007|5.003007|
1258 hv_iterkey|5.003007|5.003007|
1259 hv_iterkeysv|5.003007|5.003007|
1260 hv_iternext|5.003007|5.003007|
1261 hv_iternext_flags|5.008000|5.008000|x
1262 hv_iternextsv|5.003007|5.003007|
1263 hv_iterval|5.003007|5.003007|
1264 hv_kill_backrefs|||xiu
1265 hv_ksplit|5.003007|5.003007|u
1266 hv_magic|5.003007|5.003007|
1267 hv_magic_check|5.006000||nViu
1268 HvNAME|5.003007|5.003007|
1269 HvNAME_get|5.009003||pVu
1270 HvNAMELEN|5.015004|5.015004|
1271 HvNAMELEN_get|5.009003||pVu
1272 hv_name_set|5.009003|5.009003|u
1273 HvNAMEUTF8|5.015004|5.015004|
1274 hv_notallowed|5.008000||Viu
1275 hv_placeholders_get|5.009003|5.009003|u
1276 hv_placeholders_p|||ciu
1277 hv_placeholders_set|5.009003|5.009003|u
1278 hv_pushkv|5.027003||Viu
1279 hv_rand_set|5.018000|5.018000|u
1280 hv_riter_p|5.009003|5.009003|u
1281 hv_riter_set|5.009003|5.009003|u
1282 hv_scalar|5.009001|5.009001|
1283 hv_store|5.003007|5.003007|
1284 hv_store_ent|5.003007|5.003007|
1285 hv_store_flags|5.008000|5.008000|xu
1286 hv_stores|5.009004|5.003007|p
1287 hv_undef|5.003007|5.003007|
1288 hv_undef_flags|||ciu
1289 I16SIZE|5.006000|5.006000|
1290 I16TYPE|5.006000|5.006000|
1291 I32SIZE|5.006000|5.006000|
1292 I32TYPE|5.006000|5.006000|
1293 I8SIZE|5.006000|5.006000|
1294 I8TYPE|5.006000|5.006000|
1295 ibcmp|5.003007|5.003007|
1296 ibcmp_locale|5.004000|5.004000|
1297 ibcmp_utf8|5.007003|5.007003|u
1298 incline|5.005000||Viu
1299 incpush|5.005000||Viu
1300 incpush_if_exists|5.009003||Viu
1301 incpush_use_sep|5.011000||Viu
1302 ingroup|5.003007||Viu
1303 init_argv_symbols|5.007003||Viu
1304 init_constants|5.017003||Viu
1305 init_dbargs|||iu
1306 init_debugger|5.005000||Viu
1307 init_global_struct|5.009003||Vu
1308 init_i18nl10n|5.006000||cVu
1309 init_i18nl14n|5.006000||dcVu
1310 initialize_invlist_guts|5.029002||Viu
1311 init_ids|5.005000||Viu
1312 init_interp|5.005000||Viu
1313 init_main_stash|5.005000||Viu
1314 init_named_cv|5.027010||cViu
1315 init_perllib|5.005000||Viu
1316 init_postdump_symbols|5.005000||Viu
1317 init_predump_symbols|5.005000||Viu
1318 init_stacks|5.005000|5.005000|u
1319 init_tm|5.007002|5.007002|u
1320 init_uniprops|5.027011||Viu
1321 IN_LOCALE|5.007002|5.004000|p
1322 IN_LOCALE_COMPILETIME|5.007002|5.004000|p
1323 IN_LOCALE_RUNTIME|5.007002|5.004000|p
1324 IN_PERL_COMPILETIME|5.008001|5.003007|poVu
1325 inplace_aassign|5.015003||Viu
1326 instr|5.003007|5.003007|n
1327 INT2PTR|5.006000|5.003007|p
1328 intro_my|5.004000|5.004000|
1329 INTSIZE|5.003007|5.003007|
1330 intuit_method|5.005000||Viu
1331 intuit_more|5.003007||Viu
1332 _inverse_folds|5.027011||cViu
1333 invert|5.003007||Viu
1334 invlist_array|5.013010||nViu
1335 _invlist_array_init|5.015001||nViu
1336 invlist_clear|5.023009||Viu
1337 invlist_clone|5.015001||cViu
1338 _invlist_contains_cp|5.017003||nViu
1339 invlist_contents|5.023008||Viu
1340 _invlist_dump|5.019003||cViu
1341 _invlistEQ|5.023006||cViu
1342 invlist_extend|5.013010||Viu
1343 invlist_highest|5.017002||nViu
1344 _invlist_intersection|5.015001||Viu
1345 _invlist_intersection_maybe_complement_2nd|5.015008||cViu
1346 _invlist_invert|5.015001||cViu
1347 invlist_is_iterating|5.017008||nViu
1348 invlist_iterfinish|5.017008||nViu
1349 invlist_iterinit|5.015001||nViu
1350 invlist_iternext|5.015001||nViu
1351 _invlist_len|5.017004||nViu
1352 invlist_lowest|||nxViu
1353 invlist_max|5.013010||nViu
1354 invlist_previous_index|5.017004||nViu
1355 invlist_replace_list_destroys_src|5.023009||Viu
1356 _invlist_search|5.017003||ncViu
1357 invlist_set_len|5.013010||Viu
1358 invlist_set_previous_index|5.017004||nViu
1359 _invlist_subtract|5.015001||Viu
1360 invlist_trim|5.013010||nViu
1361 _invlist_union|5.015001||cVu
1362 _invlist_union_maybe_complement_2nd|5.015008||cViu
1363 invmap_dump|5.031006||Viu
1364 invoke_exception_hook|5.013001||Viu
1365 io_close|5.003007||Viu
1366 isALNUM|5.003007|5.003007|p
1367 isALNUM_A|5.031003|5.003007|p
1368 isALNUMC|5.006000|5.003007|p
1369 isALNUMC_A|5.013006|5.003007|p
1370 isALNUMC_L1|5.013006|5.003007|p
1371 isALNUMC_LC|5.006000|5.006000|
1372 isALNUMC_LC_uvchr|5.017007|5.017007|
1373 isALNUM_LC|5.004000|5.004000|
1374 isALNUM_LC_uvchr|5.007001|5.007001|
1375 isa_lookup|5.005000||Viu
1376 isALPHA|5.003007|5.003007|p
1377 isALPHA_A|5.013006|5.003007|p
1378 isALPHA_L1|5.013006|5.003007|p
1379 isALPHA_LC|5.004000|5.004000|
1380 isALPHA_LC_utf8_safe|5.025009|5.006000|p
1381 isALPHA_LC_uvchr|5.007001|5.007001|
1382 isALPHANUMERIC|5.017008|5.003007|p
1383 isALPHANUMERIC_A|5.017008|5.003007|p
1384 isALPHANUMERIC_L1|5.017008|5.003007|p
1385 isALPHANUMERIC_LC|5.017008|5.004000|p
1386 isALPHANUMERIC_LC_utf8_safe|5.025009|5.006000|p
1387 isALPHANUMERIC_LC_uvchr|5.017008|5.017008|
1388 isALPHANUMERIC_utf8|5.031005|5.031005|
1389 isALPHANUMERIC_utf8_safe|5.025009|5.006000|p
1390 isALPHANUMERIC_uvchr|5.023009|5.006000|p
1391 isALPHA_utf8|5.031005|5.031005|
1392 isALPHA_utf8_safe|5.025009|5.006000|p
1393 isALPHA_uvchr|5.023009|5.006000|p
1394 is_an_int|5.005000||Viu
1395 isASCII|5.006000|5.003007|p
1396 isASCII_A|5.013006|5.003007|p
1397 isASCII_L1|5.015004|5.003007|p
1398 isASCII_LC|5.015008|5.003007|p
1399 isASCII_LC_utf8_safe|5.025009|5.025009|
1400 isASCII_LC_uvchr|5.017007|5.017007|
1401 is_ascii_string|5.011000|5.011000|n
1402 isASCII_utf8|5.031005|5.031005|
1403 isASCII_utf8_safe|5.025009|5.003007|p
1404 isASCII_uvchr|5.023009|5.003007|p
1405 isBLANK|5.006001|5.003007|p
1406 isBLANK_A|5.013006|5.003007|p
1407 isBLANK_L1|5.013006|5.003007|p
1408 isBLANK_LC|5.006001|5.003007|p
1409 isBLANK_LC_utf8_safe|5.025009|5.006000|p
1410 isBLANK_LC_uvchr|5.017007|5.017007|
1411 isBLANK_utf8|5.031005|5.031005|
1412 isBLANK_utf8_safe|5.025009|5.006000|p
1413 isBLANK_uvchr|5.023009|5.006000|p
1414 isC9_STRICT_UTF8_CHAR|5.025005|5.025005|n
1415 is_c9strict_utf8_string|5.025006|5.025006|n
1416 is_c9strict_utf8_string_loc|5.025006|5.025006|n
1417 is_c9strict_utf8_string_loclen|5.025006|5.025006|n
1418 isCNTRL|5.006000|5.003007|p
1419 isCNTRL_A|5.013006|5.003007|p
1420 isCNTRL_L1|5.013006|5.003007|p
1421 isCNTRL_LC|5.006000|5.006000|
1422 isCNTRL_LC_utf8_safe|5.025009|5.006000|p
1423 isCNTRL_LC_uvchr|5.007001|5.007001|
1424 isCNTRL_utf8|5.031005|5.031005|
1425 isCNTRL_utf8_safe|5.025009|5.006000|p
1426 isCNTRL_uvchr|5.023009|5.006000|p
1427 _is_cur_LC_category_utf8|5.021001||cVu
1428 isDIGIT|5.003007|5.003007|p
1429 isDIGIT_A|5.013006|5.003007|p
1430 isDIGIT_L1|5.013006|5.003007|p
1431 isDIGIT_LC|5.004000|5.004000|
1432 isDIGIT_LC_utf8_safe|5.025009|5.006000|p
1433 isDIGIT_LC_uvchr|5.007001|5.007001|
1434 isDIGIT_utf8|5.031005|5.031005|
1435 isDIGIT_utf8_safe|5.025009|5.006000|p
1436 isDIGIT_uvchr|5.023009|5.006000|p
1437 isFF_OVERLONG|5.025007||nViu
1438 isFOO_lc|5.017007||cViu
1439 isFOO_utf8_lc|5.017008||Viu
1440 isGCB|5.021009||Viu
1441 isGRAPH|5.006000|5.003007|p
1442 isGRAPH_A|5.013006|5.003007|p
1443 _is_grapheme|5.025009||Viu
1444 isGRAPH_L1|5.013006|5.003007|p
1445 isGRAPH_LC|5.006000|5.006000|
1446 isGRAPH_LC_utf8_safe|5.025009|5.006000|p
1447 isGRAPH_LC_uvchr|5.007001|5.007001|
1448 isGRAPH_utf8|5.031005|5.031005|
1449 isGRAPH_utf8_safe|5.025009|5.006000|p
1450 isGRAPH_uvchr|5.023009|5.006000|p
1451 isGV_with_GP|5.009004||pVu
1452 is_handle_constructor|5.006000||nViu
1453 isIDCONT|5.017008|5.003007|p
1454 isIDCONT_A|5.017008|5.003007|p
1455 isIDCONT_L1|5.017008|5.003007|p
1456 isIDCONT_LC|5.017008|5.004000|p
1457 isIDCONT_LC_utf8_safe|5.025009|5.006000|p
1458 isIDCONT_LC_uvchr|5.017008|5.017008|
1459 isIDCONT_utf8|5.031005|5.031005|
1460 isIDCONT_utf8_safe|5.025009|5.006000|p
1461 isIDCONT_uvchr|5.023009|5.006000|p
1462 isIDFIRST|5.003007|5.003007|p
1463 isIDFIRST_A|5.013006|5.003007|p
1464 isIDFIRST_L1|5.013006|5.003007|p
1465 isIDFIRST_LC|5.004000|5.004000|p
1466 isIDFIRST_LC_utf8_safe|5.025009|5.006000|p
1467 isIDFIRST_LC_uvchr|5.007001|5.007001|
1468 isIDFIRST_utf8|5.031005|5.031005|
1469 isIDFIRST_utf8_safe|5.025009|5.006000|p
1470 isIDFIRST_uvchr|5.023009|5.006000|p
1471 isinfnan|5.021004|5.021004|n
1472 isinfnansv|5.021005||Viu
1473 _is_in_locale_category|5.021001||cViu
1474 is_invariant_string|5.021007|5.011000|pn
1475 is_invlist|5.029002||nViu
1476 isLB|5.023007||Viu
1477 isLOWER|5.003007|5.003007|p
1478 isLOWER_A|5.013006|5.003007|p
1479 isLOWER_L1|5.013006|5.003007|p
1480 isLOWER_LC|5.004000|5.004000|
1481 isLOWER_LC_utf8_safe|5.025009|5.006000|p
1482 isLOWER_LC_uvchr|5.007001|5.007001|
1483 isLOWER_utf8|5.031005|5.031005|
1484 isLOWER_utf8_safe|5.025009|5.006000|p
1485 isLOWER_uvchr|5.023009|5.006000|p
1486 is_lvalue_sub|5.007001|5.007001|u
1487 IS_NUMBER_GREATER_THAN_UV_MAX|5.007002|5.003007|p
1488 IS_NUMBER_INFINITY|5.007002|5.003007|p
1489 IS_NUMBER_IN_UV|5.007002|5.003007|p
1490 IS_NUMBER_NAN|5.007003|5.003007|p
1491 IS_NUMBER_NEG|5.007002|5.003007|p
1492 IS_NUMBER_NOT_INT|5.007002|5.003007|p
1493 isOCTAL|5.013005|5.003007|p
1494 isOCTAL_A|5.013006|5.003007|p
1495 isOCTAL_L1|5.013006|5.003007|p
1496 isPRINT|5.004000|5.003007|p
1497 isPRINT_A|5.013006|5.003007|p
1498 isPRINT_L1|5.013006|5.003007|p
1499 isPRINT_LC|5.004000|5.004000|
1500 isPRINT_LC_utf8_safe|5.025009|5.006000|p
1501 isPRINT_LC_uvchr|5.007001|5.007001|
1502 isPRINT_utf8|5.031005|5.031005|
1503 isPRINT_utf8_safe|5.025009|5.006000|p
1504 isPRINT_uvchr|5.023009|5.006000|p
1505 isPSXSPC|5.006001|5.003007|p
1506 isPSXSPC_A|5.013006|5.003007|p
1507 isPSXSPC_L1|5.013006|5.003007|p
1508 isPSXSPC_LC|5.006001|5.006001|
1509 isPSXSPC_LC_utf8_safe|5.025009|5.006000|p
1510 isPSXSPC_LC_uvchr|5.017007|5.017007|
1511 isPSXSPC_utf8|5.031005|5.031005|
1512 isPSXSPC_utf8_safe|5.025009|5.006000|p
1513 isPSXSPC_uvchr|5.023009|5.006000|p
1514 isPUNCT|5.006000|5.003007|p
1515 isPUNCT_A|5.013006|5.003007|p
1516 isPUNCT_L1|5.013006|5.003007|p
1517 isPUNCT_LC|5.006000|5.006000|
1518 isPUNCT_LC_utf8_safe|5.025009|5.006000|p
1519 isPUNCT_LC_uvchr|5.007001|5.007001|
1520 isPUNCT_utf8|5.031005|5.031005|
1521 isPUNCT_utf8_safe|5.025009|5.006000|p
1522 isPUNCT_uvchr|5.023009|5.006000|p
1523 IS_SAFE_SYSCALL|5.019004|5.019004|
1524 is_safe_syscall|5.019004|5.019004|
1525 isSB|5.021009||Viu
1526 isSCRIPT_RUN|5.027008||cVi
1527 isSPACE|5.003007|5.003007|p
1528 isSPACE_A|5.013006|5.003007|p
1529 isSPACE_L1|5.013006|5.003007|p
1530 isSPACE_LC|5.004000|5.004000|
1531 isSPACE_LC_utf8_safe|5.025009|5.006000|p
1532 isSPACE_LC_uvchr|5.007001|5.007001|
1533 isSPACE_utf8|5.031005|5.031005|
1534 isSPACE_utf8_safe|5.025009|5.006000|p
1535 isSPACE_uvchr|5.023009|5.006000|p
1536 is_ssc_worth_it|5.021005||nViu
1537 isSTRICT_UTF8_CHAR|5.025005|5.025005|n
1538 is_strict_utf8_string|5.025006|5.025006|n
1539 is_strict_utf8_string_loc|5.025006|5.025006|n
1540 is_strict_utf8_string_loclen|5.025006|5.025006|n
1541 _is_uni_FOO|5.017008||cVu
1542 _is_uni_perl_idcont|5.017008||cVu
1543 _is_uni_perl_idstart|5.017007||cVu
1544 isUPPER|5.003007|5.003007|p
1545 isUPPER_A|5.013006|5.003007|p
1546 isUPPER_L1|5.013006|5.003007|p
1547 isUPPER_LC|5.004000|5.004000|
1548 isUPPER_LC_utf8_safe|5.025009|5.006000|p
1549 isUPPER_LC_uvchr|5.007001|5.007001|
1550 isUPPER_utf8|5.031005|5.031005|
1551 isUPPER_utf8_safe|5.025009|5.006000|p
1552 isUPPER_uvchr|5.023009|5.006000|p
1553 is_utf8_char|5.006000|5.006000|nd
1554 isUTF8_CHAR|5.021001|5.006001|pn
1555 is_utf8_char_buf|5.015008|5.015008|n
1556 isUTF8_CHAR_flags|5.025005|5.025005|
1557 is_utf8_char_helper|5.031004||ncVu
1558 is_utf8_common|5.009003||Viu
1559 is_utf8_cp_above_31_bits|5.025005||nViu
1560 is_utf8_fixed_width_buf_flags|5.025006|5.025006|n
1561 is_utf8_fixed_width_buf_loc_flags|5.025006|5.025006|n
1562 is_utf8_fixed_width_buf_loclen_flags|5.025006|5.025006|n
1563 _is_utf8_FOO|5.031006||cVu
1564 is_utf8_invariant_string|5.025005|5.011000|pn
1565 is_utf8_invariant_string_loc|5.027001|5.027001|n
1566 is_utf8_non_invariant_string|5.027007||ncVi
1567 is_utf8_overlong_given_start_byte_ok|5.025006||nViu
1568 _is_utf8_perl_idcont|5.031006||cVu
1569 _is_utf8_perl_idstart|5.031006||cVu
1570 is_utf8_string|5.006001|5.006001|n
1571 is_utf8_string_flags|5.025006|5.025006|n
1572 is_utf8_string_loc|5.008001|5.008001|n
1573 is_utf8_string_loc_flags|5.025006|5.025006|n
1574 is_utf8_string_loclen|5.009003|5.009003|n
1575 is_utf8_string_loclen_flags|5.025006|5.025006|n
1576 is_utf8_valid_partial_char|5.025005|5.025005|n
1577 is_utf8_valid_partial_char_flags|5.025005|5.025005|n
1578 isWB|5.021009||Viu
1579 isWORDCHAR|5.013006|5.003007|p
1580 isWORDCHAR_A|5.013006|5.003007|p
1581 isWORDCHAR_L1|5.013006|5.003007|p
1582 isWORDCHAR_LC|5.017007|5.004000|p
1583 isWORDCHAR_LC_utf8_safe|5.025009|5.006000|p
1584 isWORDCHAR_LC_uvchr|5.017007|5.017007|
1585 isWORDCHAR_utf8|5.031005|5.031005|
1586 isWORDCHAR_utf8_safe|5.025009|5.006000|p
1587 isWORDCHAR_uvchr|5.023009|5.006000|p
1588 isXDIGIT|5.006000|5.003007|p
1589 isXDIGIT_A|5.013006|5.003007|p
1590 isXDIGIT_L1|5.013006|5.003007|p
1591 isXDIGIT_LC|5.017007|5.003007|p
1592 isXDIGIT_LC_utf8_safe|5.025009|5.006000|p
1593 isXDIGIT_LC_uvchr|5.017007|5.017007|
1594 isXDIGIT_utf8|5.031005|5.031005|
1595 isXDIGIT_utf8_safe|5.025009|5.006000|p
1596 isXDIGIT_uvchr|5.023009|5.006000|p
1597 items|5.003007|5.003007|V
1598 IVdf|5.006000|5.003007|p
1599 IVSIZE|5.006000|5.003007|p
1600 IVTYPE|5.006000|5.003007|p
1601 ix|5.003007|5.003007|V
1602 jmaybe|5.003007||Viu
1603 join_exact|5.009004||Viu
1604 keyword|5.003007||Viu
1605 keyword_plugin_standard|||iu
1606 LATIN1_TO_NATIVE|5.019004|5.003007|p
1607 LEAVE|5.003007|5.003007|
1608 leave_adjust_stacks|5.023008|5.023008|xu
1609 leave_scope|5.003007|5.003007|u
1610 LEAVE_with_name|5.011002|5.011002|
1611 lex_bufutf8|5.011002|5.011002|x
1612 lex_discard_to|5.011002|5.011002|x
1613 lex_grow_linestr|5.011002|5.011002|x
1614 lex_next_chunk|5.011002|5.011002|x
1615 lex_peek_unichar|5.011002|5.011002|x
1616 lex_read_space|5.011002|5.011002|x
1617 lex_read_to|5.011002|5.011002|x
1618 lex_read_unichar|5.011002|5.011002|x
1619 lex_start|5.009005|5.009005|x
1620 lex_stuff_pv|5.013006|5.013006|x
1621 lex_stuff_pvn|5.011002|5.011002|x
1622 lex_stuff_pvs|5.013005|5.013005|x
1623 lex_stuff_sv|5.011002|5.011002|x
1624 lex_unstuff|5.011002|5.011002|x
1625 LIKELY|5.009004|5.003007|p
1626 LINKLIST|5.013006|5.013006|
1627 list|5.003007||Viu
1628 listkids|5.003007||Viu
1629 load_module|5.006000|5.003007|pv
1630 load_module_nocontext|5.006000||vnVu
1631 localize|5.003007||Viu
1632 LONGDBLINFBYTES|5.023000|5.023000|
1633 LONGDBLMANTBITS|5.023000|5.023000|
1634 LONGDBLNANBYTES|5.023000|5.023000|
1635 LONGSIZE|5.004000|5.003007|
1636 looks_like_bool|5.027008||Viu
1637 looks_like_number|5.003007|5.003007|
1638 lop|5.005000||Viu
1639 lossless_NV_to_IV|5.031001||nViu
1640 LSEEKSIZE|5.006000|5.006000|
1641 LVRET|||i
1642 magic_clear_all_env|5.004001||Viu
1643 magic_cleararylen_p|5.017002||Viu
1644 magic_clearenv|5.003007||Viu
1645 magic_clearhint|5.009004||Vi
1646 magic_clearhints|5.011000||Vi
1647 magic_clearisa|5.010001||Viu
1648 magic_clearpack|5.003007||Viu
1649 magic_clearsig|5.003007||Viu
1650 magic_copycallchecker|5.017000||Viu
1651 magic_dump|5.006000|5.006000|u
1652 magic_existspack|5.003007||Viu
1653 magic_freearylen_p|5.009003||Viu
1654 magic_freeovrld|5.007001||Viu
1655 magic_get|5.003007||Viu
1656 magic_getarylen|5.003007||Viu
1657 magic_getdebugvar|5.021005||Viu
1658 magic_getdefelem|5.004000||Viu
1659 magic_getnkeys|5.004005||Viu
1660 magic_getpack|5.003007||Viu
1661 magic_getpos|5.003007||Viu
1662 magic_getsig|5.003007||Viu
1663 magic_getsubstr|5.004005||Viu
1664 magic_gettaint|5.003007||Viu
1665 magic_getuvar|5.003007||Viu
1666 magic_getvec|5.004005||Viu
1667 magic_killbackrefs|5.006000||Viu
1668 magic_methcall1|5.013001||Viu
1669 magic_methcall|||vi
1670 magic_methpack|5.005000||Viu
1671 magic_nextpack|5.003007||Viu
1672 magic_regdata_cnt|5.006000||Viu
1673 magic_regdatum_get|5.006000||Viu
1674 magic_regdatum_set|5.006001||Viu
1675 magic_scalarpack|5.009001||Viu
1676 magic_set|5.003007||Viu
1677 magic_set_all_env|5.004004||Viu
1678 magic_setarylen|5.003007||Viu
1679 magic_setcollxfrm|5.004000||Viu
1680 magic_setdbline|5.003007||Viu
1681 magic_setdebugvar|5.021005||Viu
1682 magic_setdefelem|5.004000||Viu
1683 magic_setenv|5.003007||Viu
1684 magic_sethint|5.009004||Vi
1685 magic_setisa|5.003007||Viu
1686 magic_setlvref|5.021005||Viu
1687 magic_setmglob|5.003007||Viu
1688 magic_setnkeys|5.003007||Viu
1689 magic_setnonelem|5.027009||Viu
1690 magic_setpack|5.003007||Viu
1691 magic_setpos|5.003007||Viu
1692 magic_setregexp|5.008001||Viu
1693 magic_setsig|5.003007||Viu
1694 magic_setsubstr|5.003007||Viu
1695 magic_settaint|5.003007||Viu
1696 magic_setutf8|5.008001||Viu
1697 magic_setuvar|5.003007||Viu
1698 magic_setvec|5.003007||Viu
1699 magic_sizepack|5.005000||Viu
1700 magic_wipepack|5.003007||Viu
1701 make_exactf_invlist|5.031006||Viu
1702 make_matcher|5.027008||Viu
1703 make_trie|5.009002||Viu
1704 malloc|5.007002|5.007002|n
1705 malloced_size|5.005000||nViu
1706 malloc_good_size|5.010001||nViu
1707 MARK|5.003007|5.003007|
1708 markstack_grow|5.021001|5.021001|u
1709 matcher_matches_sv|5.027008||Viu
1710 maybe_multimagic_gv|5.019004||Viu
1711 mayberelocate|5.015006||Viu
1712 measure_struct|5.007003||Viu
1713 mem_collxfrm|5.003007||dViu
1714 _mem_collxfrm|5.025002||Viu
1715 memEQ|5.004000|5.003007|p
1716 memEQs|5.009005|5.003007|p
1717 mem_log_alloc|5.024000||nViu
1718 mem_log_common|5.010001||nViu
1719 mem_log_free|5.024000||nViu
1720 mem_log_realloc|5.024000||nViu
1721 memNE|5.004000|5.003007|p
1722 memNEs|5.009005|5.003007|p
1723 mess|5.006000|5.004000|pv
1724 mess_alloc|5.005000||Viu
1725 mess_nocontext|5.006000||pvnVu
1726 mess_sv|5.013001|5.004000|p
1727 mfree|5.007002|5.007002|nu
1728 mg_clear|5.003007|5.003007|
1729 mg_copy|5.003007|5.003007|
1730 mg_dup|5.007003|5.007003|u
1731 mg_find|5.003007|5.003007|n
1732 mg_findext|5.013008|5.003007|pn
1733 mg_find_mglob|5.019002||cViu
1734 mg_free|5.003007|5.003007|
1735 mg_freeext|5.027004|5.027004|
1736 mg_free_type|5.013006|5.013006|
1737 mg_get|5.003007|5.003007|
1738 mg_length|5.005000|5.005000|d
1739 mg_localize|5.009003||Vi
1740 mg_magical|5.003007|5.003007|n
1741 mg_set|5.003007|5.003007|
1742 mg_size|5.005000|5.005000|u
1743 mini_mktime|5.007002|5.007002|nu
1744 minus_v|5.015006||Viu
1745 missingterm|5.005000||Viu
1746 mode_from_discipline|5.006000||Viu
1747 modkids|5.003007||Viu
1748 more_bodies|||iu
1749 more_sv|5.009004||Viu
1750 moreswitches|5.003007|5.003007|u
1751 Move|5.003007|5.003007|
1752 MoveD|5.009002|5.003007|p
1753 move_proto_attr|5.019005||Viu
1754 mPUSHi|5.009002|5.003007|p
1755 mPUSHn|5.009002|5.003007|p
1756 mPUSHp|5.009002|5.003007|p
1757 mPUSHs|5.010001|5.003007|p
1758 mPUSHu|5.009002|5.003007|p
1759 mro_clean_isarev|5.013007||Viu
1760 mro_gather_and_rename|5.013007||Viu
1761 mro_get_from_name|5.010001|5.010001|u
1762 mro_get_linear_isa|5.009005|5.009005|
1763 mro_get_linear_isa_dfs|5.009005||Vi
1764 mro_get_private_data|5.010001|5.010001|
1765 mro_isa_changed_in|5.009005||Vi
1766 mro_meta_dup|5.009005||Viu
1767 mro_meta_init|||ciu
1768 mro_method_changed_in|5.009005|5.009005|
1769 mro_package_moved|5.013006||Vi
1770 mro_register|5.010001|5.010001|
1771 mro_set_mro|5.010001|5.010001|u
1772 mro_set_private_data|5.010001|5.010001|
1773 mul128|5.005000||Viu
1774 MULTICALL|5.009003|5.009003|
1775 multiconcat_stringify|5.027006||cViu
1776 multideref_stringify|5.021009||cViu
1777 MUTABLE_PTR|5.010001||pVu
1778 MUTABLE_SV|5.010001||pVu
1779 mXPUSHi|5.009002|5.003007|p
1780 mXPUSHn|5.009002|5.003007|p
1781 mXPUSHp|5.009002|5.003007|p
1782 mXPUSHs|5.010001|5.003007|p
1783 mXPUSHu|5.009002|5.003007|p
1784 my_atof2|||cu
1785 my_atof3|5.029000||cVu
1786 my_atof|5.006000|5.006000|u
1787 my_attrs|5.006000||Viu
1788 my_bytes_to_utf8|5.021009||nViu
1789 my_chsize|5.003007||Vu
1790 my_clearenv|5.009003||Viu
1791 MY_CXT|5.009000|5.009000|p
1792 MY_CXT_CLONE|5.009002|5.009000|p
1793 my_cxt_index|||u
1794 MY_CXT_INIT|5.009000|5.009000|p
1795 my_cxt_init|5.009000|5.009000|u
1796 my_dirfd|5.009005|5.009005|nu
1797 my_exit|5.003007|5.003007|
1798 my_exit_jump|5.005000||Viu
1799 my_failure_exit|5.004000|5.004000|u
1800 my_fflush_all|5.006000|5.006000|u
1801 my_fork|5.007003|5.007003|nu
1802 my_kid|5.006000||Viu
1803 my_lstat_flags|5.013003||cViu
1804 my_lstat|||u
1805 my_memrchr|5.027006||nViu
1806 my_mkostemp_cloexec|||niu
1807 my_mkostemp|||niu
1808 my_mkstemp_cloexec|||niu
1809 my_mkstemp|||niu
1810 my_nl_langinfo|5.027006||nViu
1811 my_pclose|5.003007|5.003007|u
1812 my_popen|5.003007|5.003007|u
1813 my_popen_list|5.007001|5.007001|u
1814 my_setenv|5.003007|5.003007|
1815 my_snprintf|5.009004|5.003007|pvn
1816 my_socketpair|5.007003|5.007003|nu
1817 my_sprintf|5.009003|5.003007|pnd
1818 my_stat_flags|5.013003||cViu
1819 my_stat|||u
1820 my_strerror|5.021001||Viu
1821 my_strftime|5.007002|5.007002|u
1822 my_strlcat|5.009004|5.003007|pn
1823 my_strlcpy|5.009004|5.003007|pn
1824 my_strnlen|5.027006|5.003007|pn
1825 my_strtod|5.029010|5.029010|n
1826 my_unexec|5.003007||Viu
1827 my_vsnprintf|5.009004|5.009004|n
1828 NATIVE_TO_LATIN1|5.019004|5.003007|p
1829 NATIVE_TO_NEED|5.019004||ndcVu
1830 NATIVE_TO_UNI|5.007001|5.003007|p
1831 need_utf8|5.009003||nViu
1832 newANONATTRSUB|5.006000|5.006000|u
1833 newANONHASH|5.003007|5.003007|u
1834 newANONLIST|5.003007|5.003007|u
1835 newANONSUB|5.003007|5.003007|u
1836 newASSIGNOP|5.003007|5.003007|
1837 newATTRSUB|5.006000|5.006000|u
1838 newATTRSUB_x|5.019008||cVi
1839 newAV|5.003007|5.003007|
1840 newAVREF|5.003007|5.003007|u
1841 newBINOP|5.003007|5.003007|
1842 new_collate|5.006000||Viu
1843 newCONDOP|5.003007|5.003007|
1844 new_constant|||iu
1845 newCONSTSUB|5.004005|5.003007|p
1846 newCONSTSUB_flags|5.015006|5.015006|
1847 new_ctype|5.006000||Viu
1848 newCVREF|5.003007|5.003007|u
1849 newDEFSVOP|5.021006|5.021006|
1850 newFORM|5.003007|5.003007|u
1851 newFOROP|5.013007|5.013007|
1852 newGIVENOP|5.009003|5.009003|
1853 newGIVWHENOP|5.027008||Viu
1854 newGP|||xiu
1855 newGVgen|5.003007|5.003007|u
1856 newGVgen_flags|5.015004|5.015004|u
1857 newGVOP|5.003007|5.003007|
1858 newGVREF|5.003007|5.003007|u
1859 new_he|5.005000||Viu
1860 newHV|5.003007|5.003007|
1861 newHVhv|5.005000|5.005000|u
1862 newHVREF|5.003007|5.003007|u
1863 _new_invlist|5.013010||cViu
1864 _new_invlist_C_array|5.015008||cViu
1865 newIO|5.003007|5.003007|u
1866 newLISTOP|5.003007|5.003007|
1867 newLOGOP|5.003007|5.003007|
1868 new_logop|5.005000||Viu
1869 newLOOPEX|5.003007|5.003007|
1870 newLOOPOP|5.003007|5.003007|
1871 newMETHOP|5.021005|5.021005|
1872 newMETHOP_internal|5.021005||Viu
1873 newMETHOP_named|5.021005|5.021005|
1874 new_msg_hv|5.027009||Viu
1875 newMYSUB|5.017004|5.017004|u
1876 newNULLLIST|5.003007|5.003007|
1877 new_numeric|5.006000||Viu
1878 newOP|5.003007|5.003007|
1879 newPADNAMELIST|5.021007|5.021007|nx
1880 newPADNAMEouter|5.021007|5.021007|nx
1881 newPADNAMEpvn|5.021007|5.021007|nx
1882 newPADOP|5.006000||V
1883 newPMOP|5.003007|5.003007|
1884 newPROG|5.003007|5.003007|u
1885 newPVOP|5.003007|5.003007|
1886 newRANGE|5.003007|5.003007|
1887 new_regcurly|5.027001||nViu
1888 newRV|5.003007|5.003007|u
1889 newRV_inc|5.004000|5.003007|p
1890 newRV_noinc|5.004000|5.003007|p
1891 newSLICEOP|5.003007|5.003007|
1892 new_stackinfo|5.005000|5.005000|u
1893 newSTATEOP|5.003007|5.003007|
1894 newSTUB|5.017001||Viu
1895 newSUB|5.003007|5.003007|u
1896 newSV|5.003007|5.003007|
1897 newSVavdefelem|5.019004||Viu
1898 newSVhek|5.009003|5.009003|
1899 newSViv|5.003007|5.003007|
1900 newSVnv|5.006000|5.003007|
1901 newSVOP|5.003007|5.003007|
1902 newSVpadname|5.017004|5.017004|x
1903 newSVpv|5.003007|5.003007|
1904 newSVpvf|5.006000|5.004000|v
1905 newSVpvf_nocontext|5.006000||vnVu
1906 newSVpvn|5.004005|5.003007|p
1907 newSVpvn_flags|5.010001|5.003007|p
1908 newSVpvn_share|5.007001|5.003007|p
1909 newSVpvn_utf8|5.010001|5.003007|p
1910 newSVpvs|5.009003|5.003007|p
1911 newSVpvs_flags|5.010001|5.003007|p
1912 newSVpv_share|5.013006|5.013006|
1913 newSVpvs_share|5.009003|5.003007|p
1914 newSVREF|5.003007|5.003007|u
1915 newSVrv|5.003007|5.003007|
1916 newSVsv|5.003007|5.003007|
1917 newSVsv_flags|5.029009|5.007002|pu
1918 newSVsv_nomg|5.029009|5.007003|p
1919 newSV_type|5.009005|5.003007|p
1920 newSVuv|5.006000|5.003007|p
1921 newUNOP|5.003007|5.003007|
1922 newUNOP_AUX|5.021007|5.021007|
1923 new_version|5.009000|5.009000|
1924 new_warnings_bitfield|||xciu
1925 newWHENOP|5.027008|5.027008|
1926 newWHILEOP|5.013007|5.013007|
1927 Newx|5.009003|5.003007|p
1928 Newxc|5.009003|5.003007|p
1929 newXS|5.006000|5.006000|
1930 newXS_deffile|5.021006||cViu
1931 newXS_flags|5.009004|5.009004|xu
1932 newXS_len_flags|5.015006||Vi
1933 newXSproto|5.006000|5.006000|
1934 Newxz|5.009003|5.003007|p
1935 nextargv|5.003007||Viu
1936 nextchar|5.005000||Viu
1937 next_symbol|5.007003||Viu
1938 ninstr|5.003007|5.003007|n
1939 no_bareword_allowed|5.005004||Viu
1940 no_fh_allowed|5.003007||Viu
1941 no_op|5.003007||Viu
1942 NOOP|5.005000|5.003007|poVu
1943 noperl_die|5.021006||vnViu
1944 not_a_number|5.005000||Viu
1945 nothreadhook|5.008000|5.008000|
1946 notify_parser_that_changed_to_utf8|5.025010||Viu
1947 not_incrementable|5.021002||Viu
1948 nuke_stacks|5.005000||Viu
1949 Nullav|5.003007|5.003007|d
1950 Nullch|5.003007|5.003007|
1951 Nullcv|5.003007|5.003007|d
1952 Nullhv|5.003007|5.003007|d
1953 Nullsv|5.003007|5.003007|
1954 NUM2PTR|5.006000||pVu
1955 num_overflow|5.009001||nViu
1956 NVef|5.006001|5.003007|p
1957 NVff|5.006001|5.003007|p
1958 NVgf|5.006001|5.003007|p
1959 NVMANTBITS|5.023000|5.023000|
1960 NVSIZE|5.006001|5.006001|
1961 NVTYPE|5.006000|5.003007|p
1962 oopsAV|5.003007||Viu
1963 oopsHV|5.003007||Viu
1964 op_append_elem|5.013006|5.013006|
1965 op_append_list|5.013006|5.013006|
1966 OP_CLASS|5.013007|5.013007|
1967 op_class|5.025010|5.025010|
1968 op_clear|5.006000||cViu
1969 op_contextualize|5.013006|5.013006|
1970 op_convert_list|5.021006|5.021006|
1971 OP_DESC|5.007003|5.007003|
1972 op_dump|5.006000|5.006000|
1973 openn_cleanup|5.019010||Viu
1974 openn_setup|5.019010||Viu
1975 open_script|5.005000||Viu
1976 op_free|5.003007|5.003007|
1977 OpHAS_SIBLING|5.021007|5.003007|p
1978 op_integerize|5.015003||Viu
1979 OpLASTSIB_set|5.021011|5.003007|p
1980 op_linklist|5.013006|5.013006|
1981 op_lvalue|5.013007|5.013007|x
1982 op_lvalue_flags|||ciu
1983 OpMAYBESIB_set|5.021011|5.003007|p
1984 opmethod_stash|5.021007||Viu
1985 OpMORESIB_set|5.021011|5.003007|p
1986 OP_NAME|5.007003|5.007003|
1987 op_null|5.007002|5.007002|
1988 op_parent|5.025001|5.025001|n
1989 op_prepend_elem|5.013006|5.013006|
1990 op_refcnt_dec|||xiu
1991 op_refcnt_inc|||xiu
1992 op_refcnt_lock|5.009002|5.009002|u
1993 op_refcnt_unlock|5.009002|5.009002|u
1994 op_relocate_sv|5.021005||Viu
1995 op_scope|5.013007|5.013007|x
1996 OpSIBLING|5.021007|5.003007|p
1997 op_sibling_splice|5.021002|5.021002|n
1998 opslab_force_free|5.017002||Viu
1999 opslab_free|5.017002||Viu
2000 opslab_free_nopad|5.017002||Viu
2001 op_std_init|5.015003||Viu
2002 optimize_op|5.027006||Viu
2003 optimize_optree|5.027006||Vi
2004 OP_TYPE_IS|5.019007|5.019007|
2005 OP_TYPE_IS_OR_WAS|5.019010|5.019010|
2006 op_unscope|5.017003||xViu
2007 ORIGMARK|5.003007|5.003007|
2008 OSNAME|5.003007|5.003007|
2009 OSVERS|5.007002|5.007002|
2010 output_posix_warnings|5.029005||Viu
2011 package|5.003007||Viu
2012 package_version|5.011001||Viu
2013 pack_cat|||
2014 packlist|5.008001|5.008001|
2015 pack_rec|5.008001||Viu
2016 packWARN|5.007003||pVu
2017 pad_add_anon|5.008001|5.008001|
2018 pad_add_name_pv|5.015001|5.015001|
2019 pad_add_name_pvn|5.015001|5.015001|
2020 pad_add_name_pvs|5.015001|5.015001|
2021 pad_add_name_sv|5.015001|5.015001|
2022 pad_add_weakref|5.021007||Viu
2023 pad_alloc|5.003007|5.003007|x
2024 pad_alloc_name|5.015001||Vi
2025 PadARRAY|5.017004|5.017004|x
2026 PAD_BASE_SV|||i
2027 pad_block_start|5.008001||Vi
2028 pad_check_dup|5.008001||Vi
2029 PAD_CLONE_VARS|||i
2030 PAD_COMPNAME_FLAGS|||i
2031 PAD_COMPNAME_GEN|||i
2032 PAD_COMPNAME_GEN_set|||i
2033 PAD_COMPNAME_OURSTASH|||i
2034 PAD_COMPNAME_PV|||i
2035 pad_compname_type|||
2036 PAD_COMPNAME_TYPE|||i
2037 pad_findlex|5.005000||Vi
2038 pad_findmy_pv|5.015001|5.015001|
2039 pad_findmy_pvn|5.015001|5.015001|
2040 pad_findmy_pvs|5.015001|5.015001|
2041 pad_findmy_sv|5.015001|5.015001|
2042 pad_fixup_inner_anons|5.008001||Vi
2043 pad_free|5.003007||Vi
2044 pad_leavemy|5.003007||Vi
2045 PadlistARRAY|5.017004|5.017004|x
2046 padlist_dup|5.013002||Vi
2047 PadlistMAX|5.017004|5.017004|x
2048 PadlistNAMES|5.017004|5.017004|x
2049 PadlistNAMESARRAY|5.017004|5.017004|x
2050 PadlistNAMESMAX|5.017004|5.017004|x
2051 PadlistREFCNT|5.017004|5.017004|x
2052 padlist_store|5.017004||Viu
2053 PadMAX|5.017004|5.017004|x
2054 padname_dup|5.021007||Vi
2055 padname_free|||ciu
2056 PadnameIN_SCOPE|5.031004||nViu
2057 PadnameIsOUR|||i
2058 PadnameIsSTATE|||i
2059 PadnameLEN|5.017004|5.017004|x
2060 PadnamelistARRAY|5.017004|5.017004|x
2061 padnamelist_dup|5.021007||Vi
2062 padnamelist_fetch|5.021007|5.021007|nx
2063 padnamelist_free|||ciu
2064 PadnamelistMAX|5.017004|5.017004|x
2065 PadnamelistREFCNT|5.021007|5.021007|x
2066 PadnamelistREFCNT_dec|5.021007|5.021007|x
2067 padnamelist_store|5.021007|5.021007|x
2068 PadnameOURSTASH|||i
2069 PadnameOUTER|||i
2070 PadnamePV|5.017004|5.017004|x
2071 PadnameREFCNT|5.021007|5.021007|x
2072 PadnameREFCNT_dec|5.021007|5.021007|x
2073 PadnameSV|5.017004|5.017004|x
2074 PadnameTYPE|||i
2075 PadnameUTF8|5.017004|5.017004|x
2076 pad_new|5.008001|5.008001|
2077 pad_push|5.008001||cVi
2078 pad_reset|5.003007||Vi
2079 PAD_RESTORE_LOCAL|||i
2080 PAD_SAVE_LOCAL|||i
2081 PAD_SAVE_SETNULLPAD|||i
2082 PAD_SET_CUR|||i
2083 PAD_SET_CUR_NOSAVE|||i
2084 pad_setsv|5.008001|5.008001|
2085 PAD_SETSV|||i
2086 pad_sv|5.003007||V
2087 PAD_SV|||i
2088 PAD_SVl|||i
2089 pad_swipe|5.003007||Vi
2090 pad_tidy|5.008001|5.008001|x
2091 parse_arithexpr|5.013008|5.013008|x
2092 parse_barestmt|5.013007|5.013007|x
2093 parse_block|5.013007|5.013007|x
2094 parse_body|5.006000||Viu
2095 parse_fullexpr|5.013008|5.013008|x
2096 parse_fullstmt|5.013005|5.013005|x
2097 parse_gv_stash_name|5.019004||Viu
2098 parse_ident|5.017010||Viu
2099 parse_label|5.013007|5.013007|x
2100 parse_listexpr|5.013008|5.013008|x
2101 parse_lparen_question_flags|5.017009||Viu
2102 parser_dup|5.009000|5.009000|u
2103 parser_free|5.009005||Viu
2104 parser_free_nexttoke_ops|5.017006||Viu
2105 parse_stmtseq|5.013006|5.013006|x
2106 parse_subsignature|5.031003|5.031003|x
2107 parse_termexpr|5.013008|5.013008|x
2108 parse_unicode_opts|5.008001||Viu
2109 parse_uniprop_string|5.027011||cViu
2110 path_is_searchable|5.019001||nViu
2111 peep|5.003007||Viu
2112 pending_ident|5.017004||Viu
2113 PERL_ABS|5.008001|5.003007|p
2114 perl_alloc|5.003007|5.003007|n
2115 perl_alloc_using|5.006000||nVu
2116 PERL_BCDVERSION||5.003007|pou
2117 perl_clone|5.006000||nV
2118 perl_clone_using|5.006000||nVu
2119 perl_construct|5.003007|5.003007|n
2120 Perl_custom_op_xop|5.013007||V
2121 perl_destruct|5.007003|5.007003|n
2122 perl_free|5.003007|5.003007|n
2123 PERL_HASH|5.003007|5.003007|p
2124 PERL_INT_MAX|5.003007|5.003007|p
2125 PERL_INT_MIN|5.003007|5.003007|p
2126 PerlIO_apply_layers|5.007001|5.007001|
2127 PerlIO_binmode|5.007001|5.007001|
2128 PerlIO_canset_cnt|5.003007|5.003007|n
2129 PerlIO_clearerr|5.007003|5.007003|
2130 PerlIO_close|5.007003|5.007003|
2131 PerlIO_context_layers|5.009004|5.009004|u
2132 PerlIO_debug|5.007001|5.007001|
2133 PerlIO_eof|5.007003|5.007003|
2134 PerlIO_error|5.007003|5.007003|
2135 PerlIO_exportFILE|5.003007|5.003007|n
2136 PerlIO_fast_gets|5.003007|5.003007|n
2137 PerlIO_fdopen|5.003007|5.003007|n
2138 PerlIO_fileno|5.007003|5.007003|
2139 PerlIO_fill|5.007003|5.007003|u
2140 PerlIO_findFILE|5.003007|5.003007|n
2141 PerlIO_flush|5.007003|5.007003|
2142 PERLIO_FUNCS_CAST|5.009003||pVu
2143 PERLIO_FUNCS_DECL|5.009003||pVu
2144 PerlIO_get_base|5.007003|5.007003|
2145 PerlIO_get_bufsiz|5.007003|5.007003|
2146 PerlIO_getc|5.003007|5.003007|n
2147 PerlIO_get_cnt|5.007003|5.007003|
2148 PerlIO_getpos|5.003007|5.003007|n
2149 PerlIO_get_ptr|5.007003|5.007003|
2150 PerlIO_has_base|5.003007|5.003007|n
2151 PerlIO_has_cntptr|5.003007|5.003007|n
2152 PerlIO_importFILE|5.003007|5.003007|n
2153 PerlIO_open|5.003007|5.003007|n
2154 PerlIO_printf|5.006000|5.003007|
2155 PerlIO_putc|5.003007|5.003007|n
2156 PerlIO_puts|5.003007|5.003007|n
2157 PerlIO_read|5.007003|5.007003|
2158 PerlIO_releaseFILE|5.003007|5.003007|n
2159 PerlIO_reopen|5.003007|5.003007|
2160 PerlIO_restore_errno|5.021006||cViu
2161 PerlIO_rewind|5.003007|5.003007|n
2162 PerlIO_save_errno|5.021006||cViu
2163 PerlIO_seek|5.007003|5.007003|
2164 PerlIO_set_cnt|5.007003|5.007003|
2165 PerlIO_setlinebuf|5.007003|5.007003|
2166 PerlIO_setpos|5.003007|5.003007|n
2167 PerlIO_set_ptrcnt|5.007003|5.007003|
2168 PerlIO_stderr|5.007003|5.007003|
2169 PerlIO_stdin|5.007003|5.007003|
2170 PerlIO_stdout|5.007003|5.007003|
2171 PerlIO_stdoutf|5.006000|5.003007|
2172 PerlIO_tell|5.007003|5.007003|
2173 PerlIO_ungetc|5.003007|5.003007|n
2174 PerlIO_unread|5.007003|5.007003|u
2175 PerlIO_vprintf|5.003007|5.003007|n
2176 PerlIO_write|5.007003|5.007003|
2177 Perl_langinfo|5.027004|5.027004|n
2178 PerlLIO_dup2_cloexec|5.027008||Viu
2179 PerlLIO_dup_cloexec|5.027008||Viu
2180 PerlLIO_open3_cloexec|5.027008||Viu
2181 PerlLIO_open_cloexec|5.027008||Viu
2182 PERL_LOADMOD_DENY||5.003007|ou
2183 PERL_LOADMOD_IMPORT_OPS||5.003007|ou
2184 PERL_LOADMOD_NOIMPORT||5.003007|ou
2185 PERL_LONG_MAX|5.003007|5.003007|p
2186 PERL_LONG_MIN|5.003007|5.003007|p
2187 PERL_MAGIC_arylen|5.007002|5.003007|p
2188 PERL_MAGIC_arylen_p|5.009003|5.009003|
2189 PERL_MAGIC_backref|5.007002|5.003007|p
2190 PERL_MAGIC_bm|5.007002|5.003007|p
2191 PERL_MAGIC_checkcall|5.013006|5.013006|
2192 PERL_MAGIC_collxfrm|5.007002|5.003007|p
2193 PERL_MAGIC_dbfile|5.007002|5.003007|p
2194 PERL_MAGIC_dbline|5.007002|5.003007|p
2195 PERL_MAGIC_debugvar|5.021005|5.021005|
2196 PERL_MAGIC_defelem|5.007002|5.003007|p
2197 PERL_MAGIC_env|5.007002|5.003007|p
2198 PERL_MAGIC_envelem|5.007002|5.003007|p
2199 PERL_MAGIC_ext|5.007002|5.003007|p
2200 PERL_MAGIC_fm|5.007002|5.003007|p
2201 PERL_MAGIC_glob||5.003007|pou
2202 PERL_MAGIC_hints|5.009004|5.009004|
2203 PERL_MAGIC_hintselem|5.009004|5.009004|
2204 PERL_MAGIC_isa|5.007002|5.003007|p
2205 PERL_MAGIC_isaelem|5.007002|5.003007|p
2206 PERL_MAGIC_lvref|5.021005|5.021005|
2207 PERL_MAGIC_mutex||5.003007|pou
2208 PERL_MAGIC_nkeys|5.007002|5.003007|p
2209 PERL_MAGIC_nonelem|5.027009|5.027009|
2210 PERL_MAGIC_overload||5.003007|pou
2211 PERL_MAGIC_overload_elem||5.003007|pou
2212 PERL_MAGIC_overload_table|5.007002|5.003007|p
2213 PERL_MAGIC_pos|5.007002|5.003007|p
2214 PERL_MAGIC_qr|5.007002|5.003007|p
2215 PERL_MAGIC_regdata|5.007002|5.003007|p
2216 PERL_MAGIC_regdatum|5.007002|5.003007|p
2217 PERL_MAGIC_regex_global|5.007002|5.003007|p
2218 PERL_MAGIC_rhash|5.009003|5.009003|
2219 PERL_MAGIC_shared|5.007003|5.003007|p
2220 PERL_MAGIC_shared_scalar|5.007003|5.003007|p
2221 PERL_MAGIC_sig|5.007002|5.003007|p
2222 PERL_MAGIC_sigelem|5.007002|5.003007|p
2223 PERL_MAGIC_substr|5.007002|5.003007|p
2224 PERL_MAGIC_sv|5.007002|5.003007|p
2225 PERL_MAGIC_symtab|5.009003|5.009003|
2226 PERL_MAGIC_taint|5.007002|5.003007|p
2227 PERL_MAGIC_tied|5.007002|5.003007|p
2228 PERL_MAGIC_tiedelem|5.007002|5.003007|p
2229 PERL_MAGIC_tiedscalar|5.007002|5.003007|p
2230 PERL_MAGIC_utf8|5.008001|5.003007|p
2231 PERL_MAGIC_uvar|5.007002|5.003007|p
2232 PERL_MAGIC_uvar_elem|5.007003|5.003007|p
2233 PERL_MAGIC_vec|5.007002|5.003007|p
2234 PERL_MAGIC_vstring|5.008001|5.003007|p
2235 perl_parse|5.006000|5.006000|n
2236 PerlProc_pipe_cloexec|5.027008||Viu
2237 PERL_PV_ESCAPE_ALL|5.009004|5.003007|p
2238 PERL_PV_ESCAPE_FIRSTCHAR|5.009004|5.003007|p
2239 PERL_PV_ESCAPE_NOBACKSLASH|5.009004|5.003007|p
2240 PERL_PV_ESCAPE_NOCLEAR|5.009004|5.003007|p
2241 PERL_PV_ESCAPE_NONASCII|5.013009|5.013009|
2242 PERL_PV_ESCAPE_QUOTE|5.009004|5.003007|p
2243 PERL_PV_ESCAPE_RE|5.009005|5.003007|p
2244 PERL_PV_ESCAPE_UNI|5.009004|5.003007|p
2245 PERL_PV_ESCAPE_UNI_DETECT|5.009004|5.003007|p
2246 PERL_PV_PRETTY_DUMP|5.009004|5.003007|poVu
2247 PERL_PV_PRETTY_ELLIPSES|5.010000|5.003007|p
2248 PERL_PV_PRETTY_LTGT|5.009004|5.003007|p
2249 PERL_PV_PRETTY_NOCLEAR|5.010000|5.003007|poVu
2250 PERL_PV_PRETTY_QUOTE|5.009004|5.003007|p
2251 PERL_PV_PRETTY_REGPROP|5.009004|5.003007|poVu
2252 PERL_QUAD_MAX|5.003007|5.003007|p
2253 PERL_QUAD_MIN|5.003007|5.003007|p
2254 PERL_REVISION|5.006000|5.003007|p
2255 perl_run|5.003007|5.003007|n
2256 PERL_SCAN_ALLOW_UNDERSCORES|5.007003|5.003007|p
2257 PERL_SCAN_DISALLOW_PREFIX|5.007003|5.003007|p
2258 PERL_SCAN_GREATER_THAN_UV_MAX|5.007003|5.003007|p
2259 PERL_SCAN_SILENT_ILLDIGIT|5.008001|5.003007|p
2260 PERL_SCAN_TRAILING|5.021002|5.021002|
2261 Perl_setlocale|5.027002|5.027002|n
2262 PERL_SHORT_MAX|5.003007|5.003007|p
2263 PERL_SHORT_MIN|5.003007|5.003007|p
2264 PERL_SIGNALS_UNSAFE_FLAG|5.008001|5.003007|poVu
2265 Perl_signbit|5.009005|5.009005|nx
2266 PerlSock_accept_cloexec|5.027008||Viu
2267 PerlSock_socket_cloexec|5.027008||Viu
2268 PerlSock_socketpair_cloexec|5.027008||Viu
2269 PERL_SUBVERSION|5.006000|5.003007|p
2270 PERL_SYS_INIT3|5.006000|5.006000|
2271 PERL_SYS_INIT|5.003007|5.003007|
2272 PERL_SYS_TERM|5.003007|5.003007|
2273 PERL_UCHAR_MAX|5.003007|5.003007|p
2274 PERL_UCHAR_MIN|5.003007|5.003007|p
2275 PERL_UINT_MAX|5.003007|5.003007|p
2276 PERL_UINT_MIN|5.003007|5.003007|poVu
2277 PERL_ULONG_MAX|5.003007|5.003007|p
2278 PERL_ULONG_MIN|5.003007|5.003007|p
2279 PERL_UNUSED_ARG|5.009003||pVu
2280 PERL_UNUSED_CONTEXT|5.009004|5.003007|poVu
2281 PERL_UNUSED_DECL|5.007002|5.003007|poVu
2282 PERL_UNUSED_RESULT|5.021001||pVu
2283 PERL_UNUSED_VAR|5.007002||pVu
2284 PERL_UQUAD_MAX|5.003007|5.003007|p
2285 PERL_UQUAD_MIN|5.003007|5.003007|p
2286 PERL_USE_GCC_BRACE_GROUPS|5.009004|5.004000|poVu
2287 PERL_USHORT_MAX|5.003007|5.003007|p
2288 PERL_USHORT_MIN|5.003007|5.003007|p
2289 PERL_VERSION|5.006000|5.003007|p
2290 perly_sighandler|||nu
2291 pidgone|5.003007||Viu
2292 PL_bufend||5.003007|pou
2293 PL_bufptr||5.003007|pou
2294 PL_check|5.009003|5.006000|
2295 PL_compiling|5.004005|5.003007|poVu
2296 PL_comppad|5.008001|5.008001|x
2297 PL_comppad_name|5.017004|5.017004|x
2298 PL_copline||5.003007|pou
2299 PL_curcop|5.004005|5.003007|p
2300 PL_curpad|5.005000|5.005000|x
2301 PL_curstash|5.004005|5.003007|p
2302 PL_DBsignal|5.005000|5.003007|poVu
2303 PL_DBsingle|5.004005|5.003007|poV
2304 PL_DBsub|5.004005|5.003007|poV
2305 PL_DBtrace|5.005000|5.003007|poV
2306 PL_debstash|5.004005|5.003007|poVu
2307 PL_defgv|5.004005|5.003007|p
2308 PL_diehook|5.004005|5.003007|poVu
2309 PL_dirty|5.004005|5.003007|poVu
2310 PL_dowarn|5.004005|5.003007|poV
2311 PL_errgv|5.004005|5.003007|p
2312 PL_error_count||5.003007|pou
2313 PL_exit_flags|5.006000|5.006000|
2314 PL_expect||5.003007|pou
2315 PL_hexdigit|5.005000|5.003007|poVu
2316 PL_hints|5.005000|5.003007|poVu
2317 PL_in_my||5.003007|pou
2318 PL_in_my_stash||5.005000|pou
2319 PL_keyword_plugin|5.011002|5.011002|x
2320 PL_last_in_gv|||i
2321 PL_laststatval|5.005000|5.003007|poVu
2322 PL_lex_state||5.003007|pou
2323 PL_lex_stuff||5.003007|pou
2324 PL_linestr||5.003007|pou
2325 PL_mess_sv|5.005000|5.004000|poVu
2326 PL_modglobal|5.005000|5.005000|
2327 PL_na|5.004005|5.003007|p
2328 PL_no_modify|5.006000|5.003007|poVu
2329 PL_ofsgv|||i
2330 PL_opfreehook|5.011000|5.011000|
2331 PL_parser|5.009005|5.003007|p
2332 PL_peepp|5.007003|5.007003|
2333 PL_perldb|5.004005|5.003007|poVu
2334 PL_perl_destruct_level|5.004005|5.003007|p
2335 PL_ppaddr|5.006000|5.003007|poVu
2336 PL_rpeepp|5.013005|5.013005|
2337 PL_rsfp||5.003007|pou
2338 PL_rsfp_filters||5.003007|pou
2339 PL_rs|||i
2340 PL_runops|5.006000|5.006000|
2341 PL_signals|5.008001||pVu
2342 PL_stack_base|5.004005|5.003007|poVu
2343 PL_stack_sp|5.004005|5.003007|poVu
2344 PL_statcache|5.005000|5.003007|poVu
2345 PL_stdingv|5.004005|5.003007|poVu
2346 PL_Sv|5.005000|5.003007|poVu
2347 PL_sv_arenaroot|5.004005|5.003007|poVu
2348 PL_sv_no|5.004005|5.003007|p
2349 PL_sv_undef|5.004005|5.003007|p
2350 PL_sv_yes|5.004005|5.003007|p
2351 PL_sv_zero|5.027003|5.027003|
2352 PL_tainted|5.004005|5.003007|poVu
2353 PL_tainting|5.004005|5.003007|poVu
2354 PL_tokenbuf||5.003007|pou
2355 pm_description|5.009004||Viu
2356 pmop_dump|5.006000|5.006000|u
2357 pmruntime|5.003007||Viu
2358 pmtrans|5.003007||Viu
2359 _pMY_CXT|5.007003|5.009000|pV
2360 pMY_CXT_|5.007003|5.009000|pV
2361 pMY_CXT|5.009000|5.009000|p
2362 Poison|5.008000|5.003007|p
2363 PoisonFree|5.009004|5.003007|p
2364 PoisonNew|5.009004|5.003007|p
2365 PoisonWith|5.009004|5.003007|p
2366 POPi|5.003007|5.003007|
2367 POPl|5.003007|5.003007|
2368 POPMARK|||ciu
2369 POP_MULTICALL|5.009003|5.009003|
2370 POPn|5.006000|5.003007|
2371 POPp|5.003007|5.003007|
2372 POPpbytex|5.007001|5.007001|
2373 POPpx|5.005003|5.005003|
2374 POPs|5.003007|5.003007|
2375 pop_scope|5.003007|5.003007|u
2376 POPu|5.004000|5.004000|
2377 POPul|5.006000|5.006000|
2378 populate_ANYOF_from_invlist|5.019005||Viu
2379 populate_isa|||viu
2380 pregcomp|5.009005|5.009005|u
2381 pregexec|5.003007|5.003007|u
2382 pregfree2|5.011000|5.011000|u
2383 pregfree|5.003007|5.003007|u
2384 prescan_version|5.011004|5.011004|
2385 printbuf|5.009004||Viu
2386 print_bytes_for_locale|5.027002||Viu
2387 print_collxfrm_input_and_return|5.025004||Viu
2388 printf_nocontext|5.007001|5.007001|vndu
2389 PRIVLIB|5.003007|5.003007|
2390 process_special_blocks|5.009005||Viu
2391 pTHX|5.006000|5.003007|p
2392 pTHX_|5.006000|5.003007|pV
2393 PTR2IV|5.006000|5.003007|p
2394 PTR2nat|5.009003||pVu
2395 PTR2NV|5.006000|5.003007|p
2396 PTR2ul|5.007001||pVu
2397 PTR2UV|5.006000|5.003007|p
2398 ptr_hash|5.017010||nViu
2399 PTRSIZE|5.005000|5.005000|
2400 ptr_table_clear|5.009005|5.009005|du
2401 ptr_table_fetch|5.009005|5.009005|u
2402 ptr_table_find|5.009004||nViu
2403 ptr_table_free|5.009005|5.009005|u
2404 ptr_table_new|5.009005|5.009005|u
2405 ptr_table_split|5.009005|5.009005|u
2406 ptr_table_store|5.009005|5.009005|u
2407 PTRV|5.006000|5.003007|poVu
2408 PUSHi|5.003007|5.003007|
2409 PUSHMARK|5.003007|5.003007|
2410 PUSHmortal|5.009002|5.003007|p
2411 PUSH_MULTICALL|5.011000|5.011000|
2412 PUSHn|5.006000|5.003007|
2413 PUSHp|5.003007|5.003007|
2414 PUSHs|5.003007|5.003007|
2415 push_scope|5.003007|5.003007|u
2416 PUSHu|5.004000|5.003007|p
2417 PUTBACK|5.003007|5.003007|
2418 put_charclass_bitmap_innards|5.021004||Viu
2419 put_charclass_bitmap_innards_common|5.023008||Viu
2420 put_charclass_bitmap_innards_invlist|5.023008||Viu
2421 put_code_point|5.021004||Viu
2422 put_range|5.019009||Viu
2423 pv_display|5.006000|5.003007|p
2424 pv_escape|5.009004|5.003007|p
2425 pv_pretty|5.009004|5.003007|p
2426 pv_uni_display|5.007003|5.007003|
2427 qerror|5.006000||cViu
2428 quadmath_format_needed|5.021004||nVi
2429 quadmath_format_valid|||nVi
2430 RANDBITS|5.003007|5.003007|
2431 READ_XDIGIT|5.017006|5.017006|
2432 realloc|5.007002|5.007002|n
2433 ReANY|||ncu
2434 re_compile|5.009005|5.009005|u
2435 re_croak2|||iu
2436 re_dup_guts|5.011000|5.011000|u
2437 reentrant_free|5.010000|5.010000|u
2438 reentrant_init|5.010000|5.010000|u
2439 reentrant_retry|5.010000|5.010000|vnu
2440 reentrant_size|5.010000|5.010000|u
2441 re_exec_indentf|5.023009||vViu
2442 ref|5.003007||Vu
2443 ref_array_or_hash|5.027008||Viu
2444 refcounted_he_chain_2hv|5.013007||cVi
2445 refcounted_he_fetch_pv|5.013007||cVi
2446 refcounted_he_fetch_pvn|5.013007||cVi
2447 refcounted_he_fetch_pvs|||i
2448 refcounted_he_fetch_sv|5.013007||cVi
2449 refcounted_he_free|5.013007||cVi
2450 refcounted_he_inc|5.013007||cVi
2451 refcounted_he_new_pv|5.013007||cVi
2452 refcounted_he_new_pvn|5.013007||cVi
2453 refcounted_he_new_pvs|||i
2454 refcounted_he_new_sv|5.013007||cVi
2455 refcounted_he_value|5.009004||Viu
2456 refkids|5.003007||Viu
2457 refto|5.005000||Viu
2458 reg2Lanode|5.021005||Viu
2459 reg|5.005000||Viu
2460 reganode|5.005000||Viu
2461 regatom|5.005000||Viu
2462 regbranch|5.005000||Viu
2463 reg_check_named_buff_matched|5.009005||nViu
2464 regclass|5.005000||Viu
2465 regcppop|5.005000||Viu
2466 regcppush|5.005000||Viu
2467 regcp_restore|5.025006||Viu
2468 regcurly|5.013010||nViu
2469 regdump|5.005000|5.005000|u
2470 regdump_extflags|5.009005||Viu
2471 regdump_intflags|5.019002||Viu
2472 regdupe_internal|5.009000|5.009000|u
2473 regexec_flags|5.005000|5.005000|u
2474 regex_set_precedence|5.021010||nViu
2475 regfree_internal|5.009005|5.009005|u
2476 reghop3|5.007001||nViu
2477 reghop4|5.009005||nViu
2478 reghopmaybe3|5.007001||nViu
2479 reginclass|5.005000||Viu
2480 reginitcolors|5.006000|5.006000|u
2481 reginsert|5.005000||Viu
2482 regmatch|5.005000||Viu
2483 reg_named_buff|5.009005||cViu
2484 reg_named_buff_all|5.009005|5.009005|u
2485 reg_named_buff_exists|5.009005|5.009005|u
2486 reg_named_buff_fetch|5.009005|5.009005|u
2487 reg_named_buff_firstkey|5.009005|5.009005|u
2488 reg_named_buff_iter|5.009005||cViu
2489 reg_named_buff_nextkey|5.009005|5.009005|u
2490 reg_named_buff_scalar|5.009005|5.009005|u
2491 regnext|5.005000|5.005000|u
2492 reg_node|5.005000||Viu
2493 regnode_guts|5.021005||Viu
2494 reg_numbered_buff_fetch|5.009005||cViu
2495 reg_numbered_buff_length|5.009005||cViu
2496 reg_numbered_buff_store|5.009005||cViu
2497 regpiece|5.005000||Viu
2498 regprop|5.003007||Viu
2499 reg_qr_package|5.009005||cViu
2500 regrepeat|5.005000||Viu
2501 reg_scan_name|5.009005||Viu
2502 reg_skipcomment|5.009005||nViu
2503 regtail|5.005000||Viu
2504 regtail_study|5.009004||Viu
2505 reg_temp_copy|5.009005||cViu
2506 regtry|5.005000||Viu
2507 re_indentf|5.023009||vViu
2508 re_intuit_start|5.006000||cVu
2509 re_intuit_string|5.006000||cVu
2510 Renew|5.003007|5.003007|
2511 Renewc|5.003007|5.003007|
2512 re_op_compile|5.017001||Viu
2513 repeatcpy|5.003007|5.003007|nu
2514 REPLACEMENT_CHARACTER_UTF8|5.025005|5.003007|p
2515 report_evil_fh|5.006001||Viu
2516 report_redefined_cv|5.015006||Viu
2517 report_uninit|5.006000||cVi
2518 report_wrongway_fh|5.013009||Viu
2519 re_printf|5.023009||vViu
2520 require_pv|5.006000|5.006000|
2521 require_tie_mod|5.009005||Viu
2522 RESTORE_ERRNO|||i
2523 RESTORE_LC_NUMERIC|5.021010|5.021010|
2524 restore_magic|5.009003||Viu
2525 restore_switched_locale|5.027009||Viu
2526 RETVAL|5.003007|5.003007|V
2527 rninstr|5.003007|5.003007|n
2528 rpeep|5.013005||Viu
2529 rsignal|5.004000|5.004000|
2530 rsignal_restore|5.004000||Viu
2531 rsignal_save|5.004000||Viu
2532 rsignal_state|5.004000|5.004000|u
2533 run_body|5.006000||Viu
2534 runops_debug|5.005000|5.005000|u
2535 runops_standard|5.005000|5.005000|u
2536 run_user_filter|5.009003||Viu
2537 rv2cv_op_cv|5.013006|5.013006|
2538 rvpv_dup|5.007003|5.007003|u
2539 rxres_free|5.004000||Viu
2540 rxres_restore|5.004000||Viu
2541 rxres_save|5.004000||Viu
2542 Safefree|5.003007|5.003007|
2543 safesyscalloc|5.006000|5.006000|nu
2544 safesysfree|5.006000|5.006000|nu
2545 safesysmalloc|5.006000|5.006000|nu
2546 safesysrealloc|5.006000|5.006000|nu
2547 same_dirent|5.003007||Viu
2548 SANE_ERRSV|5.031003|5.031003|
2549 save_adelete|5.011000|5.011000|u
2550 save_aelem|5.004005|5.004005|u
2551 save_aelem_flags|5.011000|5.011000|u
2552 save_alloc|5.006000|5.006000|u
2553 save_aptr|5.003007|5.003007|
2554 save_ary|5.003007|5.003007|
2555 save_bool|5.008001|5.008001|u
2556 save_clearsv|5.003007|5.003007|u
2557 SAVECLEARSV|||i
2558 SAVECOMPPAD|||i
2559 SAVE_DEFSV|5.004005|5.003007|poVu
2560 save_delete|5.003007|5.003007|u
2561 save_destructor|5.006000|5.006000|u
2562 save_destructor_x|5.006000|5.006000|u
2563 SAVE_ERRNO|||i
2564 save_freeop|5.010001|5.010001|u
2565 save_freepv|5.003007|5.003007|u
2566 save_freesv|5.003007|5.003007|u
2567 save_generic_pvref|5.006001|5.006001|u
2568 save_generic_svref|5.005003|5.005003|u
2569 save_gp|5.004000|5.004000|
2570 save_hash|5.003007|5.003007|
2571 save_hdelete|5.011000|5.011000|u
2572 save_hek_flags|5.008000||nViu
2573 save_helem|5.004005|5.004005|u
2574 save_helem_flags|5.011000|5.011000|u
2575 save_hints|5.010001|5.010001|u
2576 save_hptr|5.003007|5.003007|
2577 save_I16|5.004000|5.004000|u
2578 save_I32|5.003007|5.003007|u
2579 save_I8|5.006000|5.006000|u
2580 save_int|5.003007|5.003007|u
2581 save_item|5.003007|5.003007|
2582 save_iv|5.005000|5.005000|u
2583 save_lines|5.005000||Viu
2584 save_list|5.003007|5.003007|d
2585 save_long|5.003007|5.003007|du
2586 save_magic_flags|5.019002||Viu
2587 save_mortalizesv|5.007001|5.007001|u
2588 save_nogv|5.003007|5.003007|du
2589 save_op|5.010001|5.010001|u
2590 save_padsv_and_mortalize|5.010001|5.010001|u
2591 SAVEPADSV|||i
2592 save_pptr|5.003007|5.003007|u
2593 save_pushi32ptr|5.010001|5.010001|u
2594 save_pushptr|5.010001|5.010001|u
2595 save_pushptri32ptr|5.010001||Viu
2596 save_pushptrptr|5.010001|5.010001|u
2597 savepv|5.003007|5.003007|
2598 savepvn|5.003007|5.003007|
2599 savepvs|5.009003|5.009003|
2600 save_re_context|5.006000|5.006000|u
2601 save_scalar|5.003007|5.003007|
2602 save_scalar_at|5.005000||Viu
2603 save_set_svflags|5.009000|5.009000|u
2604 savesharedpv|5.007003|5.007003|
2605 savesharedpvn|5.009005|5.009005|
2606 save_shared_pvref|5.007003|5.007003|u
2607 savesharedpvs|5.013006|5.013006|
2608 savesharedsvpv|5.013006|5.013006|
2609 save_sptr|5.003007|5.003007|u
2610 savestack_grow|5.003007|5.003007|u
2611 savestack_grow_cnt|5.008001|5.008001|u
2612 save_strlen|5.019004||cViu
2613 savesvpv|5.009002|5.009002|
2614 save_svref|5.003007|5.003007|
2615 SAVETMPS|5.003007|5.003007|
2616 savetmps|5.023008|5.023008|xu
2617 save_to_buffer|5.027004||nViu
2618 save_vptr|5.006000|5.006000|u
2619 sawparens|5.003007||Viu
2620 scalar|5.003007||Viu
2621 scalarboolean|5.005000||Viu
2622 scalarkids|5.003007||Viu
2623 scalar_mod_type|5.006000||nViu
2624 scalarseq|5.003007||Viu
2625 scalarvoid|5.003007||Viu
2626 scan_bin|5.006000|5.006000|
2627 scan_commit|5.005000||Viu
2628 scan_const|5.003007||Viu
2629 scan_formline|5.003007||Viu
2630 scan_heredoc|5.003007||Viu
2631 scan_hex|5.006000|5.003007|
2632 scan_ident|5.003007||Viu
2633 scan_inputsymbol|5.003007||Viu
2634 scan_num|5.007001|5.007001|u
2635 scan_oct|5.006000|5.003007|
2636 scan_pat|5.003007||Viu
2637 scan_str|5.003007||xcViu
2638 scan_subst|5.003007||Viu
2639 scan_trans|5.003007||Viu
2640 scan_version|5.009001|5.009001|
2641 scan_vstring|5.009005|5.009005|u
2642 scan_word|5.003007||xcViu
2643 search_const|5.010001||Viu
2644 seed|5.008001|5.008001|u
2645 sequence_num|5.009003||Viu
2646 set_ANYOF_arg|5.019005||Viu
2647 set_caret_X|5.019006||Viu
2648 set_context|5.006000|5.006000|nu
2649 setdefout|5.003007|5.003007|
2650 SETERRNO|||i
2651 setfd_cloexec|5.027008||nViu
2652 setfd_cloexec_for_nonsysfd|5.027008||Viu
2653 setfd_cloexec_or_inhexec_by_sysfdness|5.027008||Viu
2654 setfd_inhexec|5.027008||nViu
2655 setfd_inhexec_for_sysfd|5.027008||Viu
2656 setlocale_debug_string|5.027002||nViu
2657 set_numeric_radix|5.006000||Viu
2658 set_numeric_standard|5.006000||cViu
2659 set_numeric_underlying|5.027006||cViu
2660 set_padlist|5.021006||ncViu
2661 set_regex_pv|5.029004||Viu
2662 _setup_canned_invlist|5.019008||cViu
2663 share_hek|5.004000|5.004000|u
2664 share_hek_flags|5.008000||Viu
2665 SHORTSIZE|5.004000|5.004000|
2666 should_warn_nl|5.021001||nViu
2667 si_dup|5.007003|5.007003|u
2668 sighandler1|||nViu
2669 sighandler3|||nViu
2670 sighandler|5.003007||nViu
2671 simplify_sort|5.006000||Viu
2672 SITELIB|5.003007|5.003007|
2673 skipspace_flags|5.019002||xcViu
2674 skip_to_be_ignored_text|5.023004||Viu
2675 Slab_Alloc|5.006000||cViu
2676 Slab_Free|5.007003||cViu
2677 Slab_to_ro|5.017002||Viu
2678 Slab_to_rw|5.009005||Viu
2679 softref2xv|||iu
2680 sortcv|5.009003||Viu
2681 sortcv_stacked|5.009003||Viu
2682 sortcv_xsub|5.009003||Viu
2683 sortsv|5.007003|5.007003|
2684 sortsv_flags|5.009003|5.009003|
2685 SP|5.003007|5.003007|
2686 space_join_names_mortal|5.009004||Viu
2687 SPAGAIN|5.003007|5.003007|
2688 ssc_add_range|5.019005||Viu
2689 ssc_and|5.019005||Viu
2690 ssc_anything|5.019005||Viu
2691 ssc_clear_locale|5.019005||nViu
2692 ssc_cp_and|5.019005||Viu
2693 ssc_finalize|5.019005||Viu
2694 ssc_init|5.019005||Viu
2695 ssc_intersection|5.019005||Viu
2696 ssc_is_anything|5.019005||nViu
2697 ssc_is_cp_posixl_init|5.019005||nViu
2698 ssc_or|5.019005||Viu
2699 ssc_union|5.019005||Viu
2700 ss_dup|5.007003|5.007003|u
2701 ST|5.003007|5.003007|
2702 stack_grow|5.003007|5.003007|u
2703 START_EXTERN_C|5.005000|5.003007|poVu
2704 start_glob|||xi
2705 START_MY_CXT|5.010000|5.010000|p
2706 STARTPERL|5.003007|5.003007|
2707 start_subparse|5.004000|5.003007|pu
2708 STDCHAR|5.003007|5.003007|
2709 stdize_locale|5.007001||Viu
2710 STMT_END|5.003007|5.003007|pV
2711 STMT_START|5.003007|5.003007|pV
2712 STORE_LC_NUMERIC_FORCE_TO_UNDERLYING|5.021010|5.021010|
2713 STORE_LC_NUMERIC_SET_TO_NEEDED|5.021010|5.021010|
2714 STORE_LC_NUMERIC_SET_TO_NEEDED_IN|5.031003|5.031003|
2715 strEQ|5.003007|5.003007|
2716 strGE|5.003007|5.003007|
2717 strGT|5.003007|5.003007|
2718 strip_return|5.009003||Viu
2719 strLE|5.003007|5.003007|
2720 strLT|5.003007|5.003007|
2721 strNE|5.003007|5.003007|
2722 strnEQ|5.003007|5.003007|
2723 strnNE|5.003007|5.003007|
2724 Strtod|5.029010|5.029010|n
2725 Strtol|5.006000|5.006000|n
2726 Strtoul|5.006000|5.006000|n
2727 str_to_version|5.006000|5.006000|u
2728 StructCopy|5.003007|5.003007|V
2729 STR_WITH_LEN|5.009003|5.003007|pV
2730 study_chunk|5.005000||Viu
2731 sub_crush_depth|5.004000||Viu
2732 sublex_done|5.005000||Viu
2733 sublex_push|5.005000||Viu
2734 sublex_start|5.005000||Viu
2735 sv_2bool|5.003007|5.003007|
2736 sv_2bool_flags|5.013006|5.013006|
2737 sv_2cv|5.003007|5.003007|
2738 sv_2io|5.003007|5.003007|
2739 sv_2iuv_common|5.009004||Viu
2740 sv_2iuv_non_preserve|5.007001||Viu
2741 sv_2iv|5.003007|5.003007|u
2742 sv_2iv_flags|5.009001|5.009001|
2743 sv_2mortal|5.003007|5.003007|
2744 sv_2num|5.010000||xVi
2745 sv_2nv_flags|5.013001|5.013001|
2746 sv_2pv|5.003007|5.003007|u
2747 sv_2pvbyte|5.006000|5.003007|p
2748 sv_2pvbyte_flags|5.031004|5.031004|u
2749 sv_2pvbyte_nolen|5.006000|5.003007|p
2750 sv_2pv_flags|5.007002|5.003007|p
2751 sv_2pv_nolen|5.006000|5.003007|p
2752 sv_2pvutf8|5.006000|5.006000|
2753 sv_2pvutf8_flags|5.031004|5.031004|u
2754 sv_2pvutf8_nolen|5.006000|5.006000|
2755 sv_2uv|5.004000|5.003007|pu
2756 sv_2uv_flags|5.009001|5.009001|
2757 sv_add_arena|5.003007||Vi
2758 sv_add_backref|||iu
2759 SvAMAGIC_off|5.031004|5.031004|nu
2760 SvAMAGIC_on|5.031004|5.031004|nu
2761 sv_backoff|5.003007|5.003007|n
2762 sv_bless|5.003007|5.003007|
2763 sv_buf_to_ro|5.019008||Viu
2764 sv_buf_to_rw|5.019008||Viu
2765 sv_cat_decode|5.008001|5.008001|
2766 sv_catpv|5.003007|5.003007|
2767 sv_catpvf|5.006000|5.004000|v
2768 sv_catpv_flags|5.013006|5.013006|
2769 sv_catpvf_mg|5.006000|5.004000|pv
2770 sv_catpvf_mg_nocontext|5.006000||pvnVu
2771 sv_catpvf_nocontext|5.006000||vnVu
2772 sv_catpv_mg|5.004005|5.003007|p
2773 sv_catpvn|5.003007|5.003007|
2774 sv_catpvn_flags|5.007002|5.007002|
2775 sv_catpvn_mg|5.004005|5.003007|p
2776 sv_catpvn_nomg|5.007002|5.003007|p
2777 sv_catpv_nomg|5.013006|5.013006|
2778 sv_catpvs|5.009003|5.003007|p
2779 sv_catpvs_flags|5.013006|5.013006|
2780 sv_catpvs_mg|5.013006|5.013006|
2781 sv_catpvs_nomg|5.013006|5.013006|
2782 sv_catsv|5.003007|5.003007|
2783 sv_catsv_flags|5.007002|5.007002|
2784 sv_catsv_mg|5.004005|5.003007|p
2785 sv_catsv_nomg|5.007002|5.003007|p
2786 sv_chop|5.003007|5.003007|
2787 sv_clean_all|5.003007||Vi
2788 sv_clean_objs|5.003007||Vi
2789 sv_clear|5.003007|5.003007|
2790 sv_cmp|5.003007|5.003007|
2791 sv_cmp_flags|5.013006|5.013006|
2792 sv_cmp_locale|5.004000|5.004000|
2793 sv_cmp_locale_flags|5.013006|5.013006|
2794 sv_collxfrm|||
2795 sv_collxfrm_flags|5.013006|5.013006|
2796 SV_CONST_RETURN|5.009003|5.003007|poVu
2797 sv_copypv|5.007003|5.007003|
2798 sv_copypv_flags|5.017002|5.017002|
2799 sv_copypv_nomg|5.017002|5.017002|
2800 SV_COW_DROP_PV|5.008001|5.003007|p
2801 SV_COW_SHARED_HASH_KEYS|5.009005|5.003007|poVu
2802 SvCUR|5.003007|5.003007|
2803 SvCUR_set|5.003007|5.003007|
2804 sv_dec|5.003007|5.003007|
2805 sv_dec_nomg|5.013002|5.013002|
2806 sv_del_backref|5.006000||cViu
2807 sv_derived_from|5.004000|5.004000|
2808 sv_derived_from_pv|5.015004|5.015004|
2809 sv_derived_from_pvn|5.015004|5.015004|
2810 sv_derived_from_sv|5.015004|5.015004|
2811 sv_derived_from_svpvn|5.031006||Viu
2812 sv_destroyable|5.010000|5.010000|
2813 sv_display|5.021002||Viu
2814 sv_does|5.009004|5.009004|
2815 sv_does_pv|5.015004|5.015004|
2816 sv_does_pvn|5.015004|5.015004|
2817 sv_does_sv|5.015004|5.015004|
2818 sv_dump|5.003007|5.003007|
2819 sv_dup|5.007003|5.007003|u
2820 sv_dup_common|5.013002||Viu
2821 sv_dup_inc|5.013002|5.013002|u
2822 sv_dup_inc_multiple|5.011000||Viu
2823 SvEND|5.003007|5.003007|
2824 sv_eq|5.003007|5.003007|
2825 sv_eq_flags|5.013006|5.013006|
2826 sv_exp_grow|5.009003||Viu
2827 SVf|5.006000|5.003007|poVu
2828 SVfARG|5.009005|5.003007|pV
2829 sv_force_normal|5.006000|5.006000|
2830 sv_force_normal_flags|5.007001|5.007001|
2831 sv_free2|||xciu
2832 sv_free|5.003007|5.003007|
2833 sv_free_arenas|5.003007||Vi
2834 SVf_UTF8|5.006000|5.003007|p
2835 SvGAMAGIC|5.006001|5.006001|
2836 sv_get_backrefs|5.021008|5.021008|nx
2837 SvGETMAGIC|5.004005|5.003007|p
2838 sv_gets|5.003007|5.003007|
2839 SV_GMAGIC|5.007002|5.003007|p
2840 sv_grow|5.003007|5.003007|
2841 SvGROW|5.003007|5.003007|
2842 SV_HAS_TRAILING_NUL|5.009004|5.003007|p
2843 SV_IMMEDIATE_UNREF|5.007001|5.003007|p
2844 sv_inc|5.003007|5.003007|
2845 sv_i_ncmp|5.009003||Viu
2846 sv_inc_nomg|5.013002|5.013002|
2847 sv_insert|5.003007|5.003007|
2848 sv_insert_flags|5.010001|5.010001|
2849 SvIOK|5.003007|5.003007|
2850 SvIOK_notUV|5.006000|5.006000|
2851 SvIOK_off|5.003007|5.003007|
2852 SvIOK_on|5.003007|5.003007|
2853 SvIOK_only|5.003007|5.003007|
2854 SvIOK_only_UV|5.006000|5.006000|
2855 SvIOKp|5.003007|5.003007|
2856 SvIOK_UV|5.006000|5.006000|
2857 sv_isa|5.003007|5.003007|
2858 SvIsCOW|5.008003|5.008003|
2859 SvIsCOW_shared_hash|5.008003|5.008003|
2860 sv_isobject|5.003007|5.003007|
2861 SvIV|5.003007|5.003007|
2862 sv_iv|5.005000|5.005000|d
2863 SvIV_nomg|5.009001|5.007003|p
2864 SvIV_set|5.003007|5.003007|
2865 SvIVX|5.003007|5.003007|
2866 SvIVx|5.003007|5.003007|
2867 sv_kill_backrefs|||xiu
2868 sv_len|5.003007|5.003007|
2869 SvLEN|5.003007|5.003007|
2870 SvLEN_set|5.003007|5.003007|
2871 sv_len_utf8|5.006000|5.006000|p
2872 sv_len_utf8_nomg|5.017004||pVu
2873 SvLOCK|5.007003|5.007003|
2874 sv_magic|5.003007|5.003007|
2875 sv_magicext|5.007003|5.007003|
2876 sv_magicext_mglob|5.019002||cViu
2877 sv_magic_portable||5.004000|pou
2878 SvMAGIC_set|5.009003|5.003007|p
2879 sv_mortalcopy|5.003007|5.003007|
2880 sv_mortalcopy_flags|5.017005|5.007002|p
2881 SV_MUTABLE_RETURN|5.009003|5.003007|poVu
2882 sv_ncmp|5.009003||Viu
2883 sv_newmortal|5.003007|5.003007|
2884 sv_newref|5.003007|5.003007|
2885 SvNIOK|5.003007|5.003007|
2886 SvNIOK_off|5.003007|5.003007|
2887 SvNIOKp|5.003007|5.003007|
2888 SvNOK|5.003007|5.003007|
2889 SvNOK_off|5.003007|5.003007|
2890 SvNOK_on|5.003007|5.003007|
2891 SvNOK_only|5.003007|5.003007|
2892 SvNOKp|5.003007|5.003007|
2893 sv_nolocking|5.007003|5.007003|d
2894 sv_nosharing|5.007003|5.007003|
2895 SV_NOSTEAL|5.009002|5.007003|p
2896 sv_nounlocking|5.007003|5.007003|d
2897 SvNV|5.006000|5.003007|
2898 sv_nv|5.006000|5.005000|d
2899 SvNV_nomg|5.013002|5.007003|p
2900 SvNV_set|5.006000|5.003007|
2901 SvNVX|5.006000|5.003007|
2902 SvNVx|5.006000|5.003007|
2903 SvOK|5.003007|5.003007|
2904 sv_only_taint_gmagic|5.021010||nViu
2905 SvOOK|5.003007|5.003007|
2906 SvOOK_offset|5.011000|5.011000|
2907 sv_or_pv_pos_u2b|5.019004||Viu
2908 sv_peek|5.005000|5.005000|u
2909 SvPOK|5.003007|5.003007|
2910 SvPOK_off|5.003007|5.003007|
2911 SvPOK_on|5.003007|5.003007|
2912 SvPOK_only|5.003007|5.003007|
2913 SvPOK_only_UTF8|5.006000|5.006000|
2914 SvPOKp|5.003007|5.003007|
2915 sv_pos_b2u|5.006000|5.006000|
2916 sv_pos_b2u_flags|5.019003|5.019003|
2917 sv_pos_b2u_midway|5.009004||Viu
2918 sv_pos_u2b|5.006000|5.006000|
2919 sv_pos_u2b_cached|5.009004||Viu
2920 sv_pos_u2b_flags|5.011005|5.011005|
2921 sv_pos_u2b_forwards|5.009004||nViu
2922 sv_pos_u2b_midway|5.009004||nViu
2923 SvPV|5.003007|5.003007|
2924 sv_pv|5.006000|5.006000|
2925 SvPVbyte|5.006000|5.003007|p
2926 sv_pvbyte|5.006000|5.006000|
2927 SvPVbyte_force|5.009002|5.009002|
2928 sv_pvbyten|5.006000|5.006000|d
2929 sv_pvbyten_force|5.006000|5.006000|
2930 SvPVbyte_nolen|5.006000|5.006000|
2931 SvPVbyte_nomg|5.031004|5.031004|
2932 SvPVbyte_or_null|5.031004|5.031004|
2933 SvPVbyte_or_null_nomg|5.031004|5.031004|
2934 SvPVbytex|5.006000|5.006000|
2935 SvPVbytex_force|5.006000|5.006000|
2936 SvPVCLEAR|5.025006|5.025006|
2937 SvPV_const|5.009003||pVu
2938 SvPV_flags|5.007002||pVu
2939 SvPV_flags_const|5.009003||pVu
2940 SvPV_flags_const_nolen|5.009003||pVu
2941 SvPV_flags_mutable|5.009003||pVu
2942 SvPV_force|5.003007|5.003007|p
2943 SvPV_force_flags|5.007002||pVu
2944 SvPV_force_flags_mutable|5.009003||pVu
2945 SvPV_force_flags_nolen|5.009003||pVu
2946 SvPV_force_mutable|5.009003||pVu
2947 SvPV_force_nolen|5.009003||pVu
2948 SvPV_force_nomg|5.007002|5.003007|p
2949 SvPV_force_nomg_nolen|5.009003||pVu
2950 SvPV_mutable|5.009003||pVu
2951 sv_pvn|5.005000|5.005000|d
2952 sv_pvn_force|5.003007|5.003007|
2953 sv_pvn_force_flags|5.007002|5.003007|p
2954 sv_pvn_nomg|5.007003|5.005000|pdu
2955 SvPV_nolen|5.006000|5.003007|p
2956 SvPV_nolen_const|5.009003||pVu
2957 SvPV_nomg|5.007002|5.003007|p
2958 SvPV_nomg_const|5.009003||pVu
2959 SvPV_nomg_const_nolen|5.009003||pVu
2960 SvPV_nomg_nolen|5.013007|5.003007|p
2961 SvPV_renew|5.009003||pVu
2962 SvPV_set|5.003007|5.003007|
2963 sv_pvutf8|5.006000|5.006000|
2964 SvPVutf8|5.006000|5.006000|
2965 SvPVutf8_force|5.006000|5.006000|
2966 sv_pvutf8n|5.006000|5.006000|d
2967 sv_pvutf8n_force|5.006000|5.006000|
2968 SvPVutf8_nolen|5.006000|5.006000|
2969 SvPVutf8_nomg|5.031004|5.031004|
2970 SvPVutf8_or_null|5.031004|5.031004|
2971 SvPVutf8_or_null_nomg|5.031004|5.031004|
2972 SvPVutf8x|5.006000|5.006000|
2973 SvPVutf8x_force|5.006000|5.006000|
2974 SvPVX|5.003007|5.003007|
2975 SvPVx|5.003007|5.003007|
2976 SvPVX_const|5.009003||pVu
2977 SvPVX_mutable|5.009003||pVu
2978 SvREADONLY|5.003007|5.003007|
2979 SvREADONLY_off|5.003007|5.003007|
2980 SvREADONLY_on|5.003007|5.003007|
2981 sv_recode_to_utf8|5.007003|5.007003|
2982 sv_ref|5.015004|5.015004|
2983 SvREFCNT|5.003007|5.003007|
2984 SvREFCNT_dec|5.003007|5.003007|
2985 SvREFCNT_dec_NN|5.017007|5.017007|
2986 SvREFCNT_inc|5.003007|5.003007|pn
2987 SvREFCNT_inc_NN|5.009004|5.003007|pn
2988 SvREFCNT_inc_simple|5.009004|5.003007|p
2989 SvREFCNT_inc_simple_NN|5.009004|5.003007|p
2990 SvREFCNT_inc_simple_void|5.009004|5.003007|p
2991 SvREFCNT_inc_simple_void_NN|5.009004|5.003007|p
2992 SvREFCNT_inc_void|5.009004|5.003007|pn
2993 SvREFCNT_inc_void_NN|5.009004|5.003007|p
2994 sv_reftype|5.003007|5.003007|
2995 sv_replace|5.003007|5.003007|
2996 sv_report_used|5.003007|5.003007|
2997 sv_reset|5.003007|5.003007|
2998 sv_resetpvn|5.017005||Viu
2999 SvROK|5.003007|5.003007|
3000 SvROK_off|5.003007|5.003007|
3001 SvROK_on|5.003007|5.003007|
3002 SvRV|5.003007|5.003007|
3003 SvRV_set|5.009003|5.003007|p
3004 sv_rvunweaken|5.027004|5.027004|
3005 sv_rvweaken|5.006000|5.006000|
3006 SvRX|5.009005|5.003007|p
3007 SvRXOK|5.009005|5.003007|p
3008 sv_sethek|5.015004||cViu
3009 sv_setiv|5.003007|5.003007|
3010 sv_setiv_mg|5.004005|5.003007|p
3011 SvSETMAGIC|5.003007|5.003007|
3012 SvSetMagicSV|5.004000|5.004000|
3013 SvSetMagicSV_nosteal|5.004000|5.004000|
3014 sv_setnv|5.006000|5.003007|
3015 sv_setnv_mg|5.006000|5.003007|p
3016 sv_setpv|5.003007|5.003007|
3017 sv_setpv_bufsize|5.025006|5.025006|
3018 sv_setpvf|5.006000|5.004000|v
3019 sv_setpvf_mg|5.006000|5.004000|pv
3020 sv_setpvf_mg_nocontext|5.006000||pvnVu
3021 sv_setpvf_nocontext|5.006000||vnVu
3022 sv_setpviv|5.008001|5.008001|d
3023 sv_setpviv_mg|5.008001|5.008001|d
3024 sv_setpv_mg|5.004005|5.003007|p
3025 sv_setpvn|5.003007|5.003007|
3026 sv_setpvn_mg|5.004005|5.003007|p
3027 sv_setpvs|5.009004|5.003007|p
3028 sv_setpvs_mg|5.013006|5.013006|
3029 sv_setref_iv|5.003007|5.003007|
3030 sv_setref_nv|5.006000|5.003007|
3031 sv_setref_pv|5.003007|5.003007|
3032 sv_setref_pvn|5.003007|5.003007|
3033 sv_setref_pvs|5.013006|5.013006|
3034 sv_setref_uv|5.007001|5.007001|
3035 sv_setsv|5.003007|5.003007|
3036 SvSetSV|5.003007|5.003007|
3037 sv_setsv_cow|5.009000||xcViu
3038 sv_setsv_flags|5.007002|5.007002|p
3039 sv_setsv_mg|5.004005|5.003007|p
3040 sv_setsv_nomg|5.007002|5.003007|p
3041 SvSetSV_nosteal|5.004000|5.004000|
3042 sv_set_undef|5.025008|5.025008|
3043 sv_setuv|5.004000|5.003007|p
3044 sv_setuv_mg|5.004005|5.003007|p
3045 SvSHARE|5.007003|5.007003|
3046 SvSHARED_HASH|5.009003||pVu
3047 SV_SMAGIC|5.009003|5.003007|p
3048 SvSTASH|5.003007|5.003007|
3049 SvSTASH_set|5.009003|5.003007|p
3050 SVs_TEMP|5.003007|5.003007|
3051 sv_string_from_errnum|5.027003|5.027003|
3052 SvTAINT|5.003007|5.003007|
3053 sv_taint|5.004000|5.004000|
3054 sv_tainted|5.004000|5.004000|
3055 SvTAINTED|5.004000|5.004000|
3056 SvTAINTED_off|5.004000|5.004000|
3057 SvTAINTED_on|5.004000|5.004000|
3058 SvTHINKFIRST|||i
3059 SVt_INVLIST|||c
3060 SVt_IV|5.003007|5.003007|
3061 SVt_NULL|5.003007|5.003007|
3062 SVt_NV|5.003007|5.003007|
3063 SVt_PV|5.003007|5.003007|
3064 SVt_PVAV|5.003007|5.003007|
3065 SVt_PVCV|5.003007|5.003007|
3066 SVt_PVFM|5.003007|5.003007|
3067 SVt_PVGV|5.003007|5.003007|
3068 SVt_PVHV|5.003007|5.003007|
3069 SVt_PVIO|5.003007|5.003007|
3070 SVt_PVIV|5.003007|5.003007|
3071 SVt_PVLV|5.003007|5.003007|
3072 SVt_PVMG|5.003007|5.003007|
3073 SVt_PVNV|5.003007|5.003007|
3074 SVt_REGEXP|5.011000|5.011000|
3075 SvTRUE|5.003007|5.003007|
3076 sv_true|5.005000|5.005000|
3077 SvTRUE_nomg|5.013006|5.007003|p
3078 SvTRUEx|5.003007|5.003007|
3079 SvTYPE|5.003007|5.003007|
3080 svtype|5.003007|5.003007|V
3081 sv_unglob|5.005000||Viu
3082 sv_uni_display|5.007003|5.007003|
3083 SvUNLOCK|5.007003|5.007003|
3084 sv_unmagic|5.003007|5.003007|
3085 sv_unmagicext|5.013008|5.003007|p
3086 sv_unref|5.003007|5.003007|
3087 sv_unref_flags|5.007001|5.007001|
3088 sv_untaint|5.004000|5.004000|
3089 SvUOK|5.007001|5.006000|p
3090 sv_upgrade|5.003007|5.003007|
3091 SvUPGRADE|5.003007|5.003007|
3092 sv_usepvn|5.003007|5.003007|
3093 sv_usepvn_flags|5.009004|5.009004|
3094 sv_usepvn_mg|5.004005|5.003007|p
3095 SvUTF8|5.006000|5.006000|
3096 sv_utf8_decode|5.006000|5.006000|
3097 sv_utf8_downgrade|5.006000|5.006000|
3098 sv_utf8_downgrade_flags|5.031004|5.031004|
3099 sv_utf8_downgrade_nomg|5.031004|5.031004|
3100 sv_utf8_encode|5.006000|5.006000|
3101 SV_UTF8_NO_ENCODING|5.008001|5.003007|poVu
3102 SvUTF8_off|5.006000|5.006000|
3103 SvUTF8_on|5.006000|5.006000|
3104 sv_utf8_upgrade|5.007001|5.007001|
3105 sv_utf8_upgrade_flags|5.007002|5.007002|
3106 sv_utf8_upgrade_flags_grow|5.011000|5.011000|
3107 sv_utf8_upgrade_nomg|5.007002|5.007002|
3108 SvUV|5.004000|5.003007|p
3109 sv_uv|5.005000|5.003007|pd
3110 SvUV_nomg|5.009001|5.007003|p
3111 SvUV_set|5.009003|5.003007|p
3112 SvUVX|5.004000|5.003007|p
3113 SvUVx|5.004000|5.003007|p
3114 SvUVXx|5.004000|5.003007|pd
3115 sv_vcatpvf|5.006000|5.004000|p
3116 sv_vcatpvf_mg|5.006000|5.004000|p
3117 sv_vcatpvfn|5.004000|5.004000|
3118 sv_vcatpvfn_flags|5.017002|5.017002|
3119 SvVOK|5.008001|5.008001|
3120 sv_vsetpvf|5.006000|5.004000|p
3121 sv_vsetpvf_mg|5.006000|5.004000|p
3122 sv_vsetpvfn|5.004000|5.004000|
3123 SvVSTRING_mg|5.009004||pVu
3124 swallow_bom|5.006001||Viu
3125 switch_category_locale_to_template|5.027009||Viu
3126 switch_to_global_locale|5.027009|5.003007|pn
3127 sync_locale|5.027009|5.003007|pn
3128 sys_init3|5.010000|5.010000|nu
3129 sys_init|5.010000|5.010000|nu
3130 sys_intern_clear|5.006001||Vu
3131 sys_intern_dup|5.006000||Vu
3132 sys_intern_init|5.006001||Vu
3133 sys_term|5.010000|5.010000|nu
3134 taint_env|5.003007|5.003007|u
3135 taint_proper|5.003007|5.003007|u
3136 THIS|5.003007|5.003007|V
3137 thread_locale_init|5.027009|5.027009|nxu
3138 thread_locale_term|5.027009|5.027009|nxu
3139 tied_method|5.013009||vViu
3140 tmps_grow_p|5.021005||cViu
3141 to_byte_substr|5.008000||Viu
3142 toFOLD|5.019001|5.019001|
3143 _to_fold_latin1|5.015005||ncViu
3144 toFOLD_utf8|5.031005|5.031005|
3145 toFOLD_utf8_safe|5.025009|5.006000|p
3146 toFOLD_uvchr|5.023009|5.006000|p
3147 tokenize_use|5.009003||Viu
3148 tokeq|5.005000||Viu
3149 tokereport|5.007001||Viu
3150 toLOWER|5.003007|5.003007|
3151 toLOWER_L1|5.019001|5.019001|
3152 to_lower_latin1|5.015005||nViu
3153 toLOWER_LC|5.004000|5.004000|
3154 toLOWER_utf8|5.031005|5.031005|
3155 toLOWER_utf8_safe|5.025009|5.006000|p
3156 toLOWER_uvchr|5.023009|5.006000|p
3157 too_few_arguments_pv|5.016000||Viu
3158 too_many_arguments_pv|5.016000||Viu
3159 TOPMARK|||ciu
3160 toTITLE|5.019001|5.019001|
3161 toTITLE_utf8|5.031005|5.031005|
3162 toTITLE_utf8_safe|5.025009|5.006000|p
3163 toTITLE_uvchr|5.023009|5.006000|p
3164 to_uni_fold|5.031004||cVu
3165 _to_uni_fold_flags|5.014000||cVu
3166 to_uni_lower|5.006000||cVu
3167 to_uni_title|5.006000||cVu
3168 to_uni_upper|5.006000||cVu
3169 toUPPER|5.003007|5.003007|
3170 _to_upper_title_latin1|5.015005||Viu
3171 toUPPER_utf8|5.031005|5.031005|
3172 toUPPER_utf8_safe|5.025009|5.006000|p
3173 toUPPER_uvchr|5.023009|5.006000|p
3174 _to_utf8_case|5.023006||Viu
3175 _to_utf8_fold_flags|5.014000||cVu
3176 _to_utf8_lower_flags|5.015006||cVu
3177 to_utf8_substr|5.008000||Viu
3178 _to_utf8_title_flags|5.015006||cVu
3179 _to_utf8_upper_flags|5.015006||cVu
3180 translate_substr_offsets|5.015006||nViu
3181 traverse_op_tree|5.029008||Vi
3182 try_amagic_bin|||ciu
3183 try_amagic_un|||ciu
3184 turkic_fc|5.029008||Viu
3185 turkic_lc|5.029008||Viu
3186 turkic_uc|5.029008||Viu
3187 U16SIZE|5.006000|5.006000|
3188 U16TYPE|5.006000|5.006000|
3189 U32SIZE|5.006000|5.006000|
3190 U32TYPE|5.006000|5.006000|
3191 U8SIZE|5.006000|5.006000|
3192 U8TYPE|5.006000|5.006000|
3193 uiv_2buf|5.009003||nViu
3194 UNDERBAR|5.009002|5.003007|p
3195 unexpected_non_continuation_text|5.025006||Viu
3196 UNICODE_REPLACEMENT|5.007001|5.003007|p
3197 UNI_TO_NATIVE|5.007001|5.003007|p
3198 UNLIKELY|5.009004|5.003007|p
3199 unlnk|5.003007||Vu
3200 unpack_rec|5.008001||Viu
3201 unpack_str|5.007003|5.007003|d
3202 unpackstring|5.008001|5.008001|
3203 unreferenced_to_tmp_stack|5.013002||Viu
3204 unshare_hek|5.004000||Viu
3205 unshare_hek_or_pvn|5.008000||Viu
3206 unsharepvn|5.003007|5.003007|u
3207 unwind_handler_stack|5.009003||Viu
3208 update_debugger_info|5.009005||Viu
3209 upg_version|5.009005|5.009005|
3210 usage|5.005000||Viu
3211 utf16_textfilter|5.011001||Viu
3212 utf16_to_utf8|5.006000||cViu
3213 utf16_to_utf8_reversed|5.006000||cViu
3214 UTF8_CHK_SKIP|5.031006|5.006000|p
3215 utf8_distance|5.006000|5.006000|
3216 UTF8f|5.019001|5.019001|
3217 UTF8fARG|5.019002|5.019002|
3218 utf8_hop|5.006000|5.006000|n
3219 utf8_hop_back|5.025007|5.025007|n
3220 utf8_hop_forward|5.025007|5.025007|n
3221 utf8_hop_safe|5.025007|5.025007|n
3222 UTF8_IS_INVARIANT|5.007001|5.003007|p
3223 UTF8_IS_NONCHAR|5.023002|5.023002|
3224 UTF8_IS_SUPER|5.023002|5.023002|
3225 UTF8_IS_SURROGATE|5.023002|5.023002|
3226 utf8_length|5.007001|5.007001|
3227 UTF8_MAXBYTES|5.009002|5.006000|p
3228 UTF8_MAXBYTES_CASE|5.009002|5.003007|p
3229 utf8_mg_len_cache_update|5.013003||Viu
3230 utf8_mg_pos_cache_update|5.009004||Viu
3231 utf8n_to_uvchr|5.007001|5.007001|n
3232 utf8n_to_uvchr_error|5.025006|5.025006|n
3233 utf8n_to_uvchr_msgs|5.027009|5.027009|nx
3234 _utf8n_to_uvchr_msgs_helper|5.029001||ncVu
3235 utf8n_to_uvuni|5.007001||cV
3236 UTF8_SAFE_SKIP|5.029009|5.006000|p
3237 UTF8SKIP|5.006000|5.006000|
3238 UTF8_SKIP|5.023002|5.006000|p
3239 utf8_to_bytes|5.006001|5.006001|x
3240 utf8_to_uvchr|5.007001|5.006001|pd
3241 utf8_to_uvchr_buf|5.015009|5.006001|p
3242 utf8_to_uvchr_buf_helper|5.031004||cVu
3243 utf8_to_uvuni|5.007001||dcV
3244 utf8_to_uvuni_buf|5.015009||dcV
3245 utilize|5.003007||Viu
3246 UVCHR_IS_INVARIANT|5.019004|5.003007|p
3247 UVCHR_SKIP|5.022000|5.003007|p
3248 uvchr_to_utf8|5.007001|5.007001|
3249 uvchr_to_utf8_flags|5.007003|5.007003|
3250 uvchr_to_utf8_flags_msgs|5.027009|5.027009|x
3251 UVof|5.006000|5.003007|p
3252 uvoffuni_to_utf8_flags|||c
3253 uvoffuni_to_utf8_flags_msgs|5.027009||cVu
3254 UVSIZE|5.006000|5.003007|p
3255 UVTYPE|5.006000|5.003007|p
3256 UVuf|5.006000|5.003007|p
3257 uvuni_to_utf8|5.019004||cVu
3258 uvuni_to_utf8_flags|5.007003||cV
3259 UVxf|5.006000|5.003007|p
3260 UVXf|5.007001|5.007001|p
3261 validate_proto|5.019002||xcVi
3262 validate_suid|||iu
3263 valid_utf8_to_uvchr|5.015009||ncV
3264 valid_utf8_to_uvuni|5.015009||dcVu
3265 variant_byte_number|5.031004||ncVu
3266 variant_under_utf8_count|5.027007||nVi
3267 varname|5.009003||Viu
3268 vcmp|5.009000|5.009000|
3269 vcroak|5.006000|5.006000|
3270 vdeb|5.007003|5.007003|u
3271 vform|5.006000|5.006000|u
3272 visit|5.005000||Viu
3273 vivify_defelem|5.004000||cViu
3274 vivify_ref|5.004000||Viu
3275 vload_module|5.006000|5.003007|pu
3276 vmess|5.006000|5.004000|p
3277 vnewSVpvf|5.006000|5.004000|pu
3278 vnormal|5.009002|5.009002|
3279 vnumify|5.009000|5.009000|
3280 vstringify|5.009000|5.009000|
3281 vverify|5.009003|5.009003|
3282 vwarn|5.006000|5.006000|
3283 vwarner|5.006000|5.006000|u
3284 wait4pid|5.003007||Viu
3285 warn|5.006000|5.003007|v
3286 WARN_ALL|5.006000|5.003007|p
3287 WARN_AMBIGUOUS|5.006000|5.003007|p
3288 WARN_ASSERTIONS||5.003007|pou
3289 WARN_BAREWORD|5.006000|5.003007|p
3290 WARN_CLOSED|5.006000|5.003007|p
3291 WARN_CLOSURE|5.006000|5.003007|p
3292 WARN_DEBUGGING|5.006000|5.003007|p
3293 WARN_DEPRECATED|5.006000|5.003007|p
3294 WARN_DIGIT|5.006000|5.003007|p
3295 warner|5.006000|5.004000|pvu
3296 warner_nocontext|5.006000||vnVu
3297 WARN_EXEC|5.006000|5.003007|p
3298 WARN_EXITING|5.006000|5.003007|p
3299 WARN_EXPERIMENTAL|5.017004|5.017004|
3300 WARN_EXPERIMENTAL__ALPHA_ASSERTIONS|5.027009|5.027009|
3301 WARN_EXPERIMENTAL__BITWISE|5.021009|5.021009|
3302 WARN_EXPERIMENTAL__CONST_ATTR|5.021008|5.021008|
3303 WARN_EXPERIMENTAL__DECLARED_REFS|5.025003|5.025003|
3304 WARN_EXPERIMENTAL__LEXICAL_SUBS|5.017005|5.017005|
3305 WARN_EXPERIMENTAL__POSTDEREF|5.019005|5.019005|
3306 WARN_EXPERIMENTAL__PRIVATE_USE|5.029009|5.029009|
3307 WARN_EXPERIMENTAL__REFALIASING|5.021005|5.021005|
3308 WARN_EXPERIMENTAL__REGEX_SETS|5.017008|5.017008|
3309 WARN_EXPERIMENTAL__RE_STRICT|5.021008|5.021008|
3310 WARN_EXPERIMENTAL__SCRIPT_RUN|5.027008|5.027008|
3311 WARN_EXPERIMENTAL__SIGNATURES|5.019009|5.019009|
3312 WARN_EXPERIMENTAL__SMARTMATCH|5.017011|5.017011|
3313 WARN_EXPERIMENTAL__UNIPROP_WILDCARDS|5.029009|5.029009|
3314 WARN_EXPERIMENTAL__VLB|5.029009|5.029009|
3315 WARN_EXPERIMENTAL__WIN32_PERLIO|5.021001|5.021001|
3316 WARN_GLOB|5.006000|5.003007|p
3317 WARN_ILLEGALPROTO|5.011004|5.011004|
3318 WARN_IMPRECISION|5.011000|5.011000|
3319 WARN_INPLACE|5.006000|5.003007|p
3320 WARN_INTERNAL|5.006000|5.003007|p
3321 WARN_IO|5.006000|5.003007|p
3322 WARN_LAYER|5.008000|5.003007|p
3323 WARN_LOCALE|5.021006|5.021006|
3324 WARN_MALLOC|5.006000|5.003007|p
3325 WARN_MISC|5.006000|5.003007|p
3326 WARN_MISSING|5.021002|5.021002|
3327 WARN_NEWLINE|5.006000|5.003007|p
3328 warn_nocontext|5.006000||pvnVu
3329 WARN_NONCHAR|5.013010|5.013010|
3330 WARN_NON_UNICODE|5.013010|5.013010|
3331 WARN_NUMERIC|5.006000|5.003007|p
3332 WARN_ONCE|5.006000|5.003007|p
3333 warn_on_first_deprecated_use|5.025009||Viu
3334 WARN_OVERFLOW|5.006000|5.003007|p
3335 WARN_PACK|5.006000|5.003007|p
3336 WARN_PARENTHESIS|5.006000|5.003007|p
3337 WARN_PIPE|5.006000|5.003007|p
3338 WARN_PORTABLE|5.006000|5.003007|p
3339 WARN_PRECEDENCE|5.006000|5.003007|p
3340 WARN_PRINTF|5.006000|5.003007|p
3341 _warn_problematic_locale|5.021008||ncViu
3342 WARN_PROTOTYPE|5.006000|5.003007|p
3343 WARN_QW|5.006000|5.003007|p
3344 WARN_RECURSION|5.006000|5.003007|p
3345 WARN_REDEFINE|5.006000|5.003007|p
3346 WARN_REDUNDANT|5.021002|5.021002|
3347 WARN_REGEXP|5.006000|5.003007|p
3348 WARN_RESERVED|5.006000|5.003007|p
3349 WARN_SEMICOLON|5.006000|5.003007|p
3350 WARN_SEVERE|5.006000|5.003007|p
3351 WARN_SHADOW|5.027007|5.027007|
3352 WARN_SIGNAL|5.006000|5.003007|p
3353 WARN_SUBSTR|5.006000|5.003007|p
3354 WARN_SURROGATE|5.013010|5.013010|
3355 warn_sv|5.013001|5.003007|p
3356 WARN_SYNTAX|5.006000|5.003007|p
3357 WARN_SYSCALLS|5.019004|5.019004|
3358 WARN_TAINT|5.006000|5.003007|p
3359 WARN_THREADS|5.008000|5.003007|p
3360 WARN_UNINITIALIZED|5.006000|5.003007|p
3361 WARN_UNOPENED|5.006000|5.003007|p
3362 WARN_UNPACK|5.006000|5.003007|p
3363 WARN_UNTIE|5.006000|5.003007|p
3364 WARN_UTF8|5.006000|5.003007|p
3365 WARN_VOID|5.006000|5.003007|p
3366 was_lvalue_sub|||ciu
3367 watch|5.003007||Viu
3368 whichsig|5.003007|5.003007|u
3369 whichsig_pv|5.015004|5.015004|u
3370 whichsig_pvn|5.015004|5.015004|u
3371 whichsig_sv|5.015004|5.015004|u
3372 WIDEST_UTYPE|5.015004|5.003007|p
3373 win32_croak_not_implemented|5.017006||nViu
3374 win32_setlocale|5.027006||Viu
3375 WITH_LC_NUMERIC_SET_TO_NEEDED|5.031003|5.031003|
3376 WITH_LC_NUMERIC_SET_TO_NEEDED_IN|5.031003|5.031003|
3377 with_queued_errors|5.013001||Viu
3378 wrap_keyword_plugin|5.027006|5.027006|x
3379 wrap_op_checker|5.015008|5.015008|
3380 write_to_stderr|5.008001||Viu
3381 XCPT_CATCH|5.009002|5.003007|p
3382 XCPT_RETHROW|5.009002|5.003007|p
3383 XCPT_TRY_END|5.009002|5.003007|p
3384 XCPT_TRY_START|5.009002|5.003007|p
3385 XopDISABLE|5.013007|5.013007|V
3386 XopENABLE|5.013007|5.013007|V
3387 XopENTRY|5.013007|5.013007|V
3388 XopENTRYCUSTOM|5.019006|5.013007|V
3389 XopENTRY_set|5.013007|5.013007|V
3390 XopFLAGS|5.013007|5.013007|
3391 XPUSHi|5.003007|5.003007|
3392 XPUSHmortal|5.009002|5.003007|p
3393 XPUSHn|5.006000|5.003007|
3394 XPUSHp|5.003007|5.003007|
3395 XPUSHs|5.003007|5.003007|
3396 XPUSHu|5.004000|5.003007|p
3397 XS|5.003007|5.003007|V
3398 XS_APIVERSION_BOOTCHECK|5.013004|5.013004|
3399 xs_boot_epilog|5.021006||cViu
3400 XS_EXTERNAL|5.015002|5.015002|V
3401 xs_handshake|||vnciu
3402 XS_INTERNAL|5.015002|5.015002|V
3403 XSprePUSH|5.006000|5.003007|poVu
3404 XSPROTO|5.010000||pVu
3405 XSRETURN|5.003007|5.003007|p
3406 XSRETURN_EMPTY|5.003007|5.003007|
3407 XSRETURN_IV|5.003007|5.003007|
3408 XSRETURN_NO|5.003007|5.003007|
3409 XSRETURN_NV|5.006000|5.003007|
3410 XSRETURN_PV|5.003007|5.003007|
3411 XSRETURN_UNDEF|5.003007|5.003007|
3412 XSRETURN_UV|5.008001|5.003007|p
3413 XSRETURN_YES|5.003007|5.003007|
3414 XST_mIV|5.003007|5.003007|
3415 XST_mNO|5.003007|5.003007|
3416 XST_mNV|5.006000|5.003007|
3417 XST_mPV|5.003007|5.003007|
3418 XST_mUNDEF|5.003007|5.003007|
3419 XST_mUV|5.008001|5.003007|p
3420 XST_mYES|5.003007|5.003007|
3421 XS_VERSION|5.003007|5.003007|
3422 XS_VERSION_BOOTCHECK|5.003007|5.003007|
3423 xs_version_bootcheck|||iu
3424 yyerror|5.003007||Viu
3425 yyerror_pv|5.016000||Viu
3426 yyerror_pvn|5.016000||Viu
3427 yylex|5.003007||cViu
3428 yyparse|5.003007||Viu
3429 yyquit|5.025010||Viu
3430 yyunlex|5.013005||Viu
3431 yywarn|5.003007||Viu
3432 Zero|5.003007|5.003007|
3433 ZeroD|5.009002|5.003007|p
3434 );
3435
3436 if (exists $opt{'list-unsupported'}) {
3437   my $f;
3438   for $f (sort dictionary_order keys %API) {
3439     next if $API{$f}{core_only};
3440     next if $API{$f}{beyond_depr};
3441     next if $API{$f}{inaccessible};
3442     next if $API{$f}{experimental};
3443     next unless $API{$f}{todo};
3444     next if int_parse_version($API{$f}{todo}) <= $int_min_perl;
3445     print "$f ", '.'x(40-length($f)), " ", format_version($API{$f}{todo}), "\n";
3446   }
3447   exit 0;
3448 }
3449
3450 # Scan for hints, possible replacement candidates, etc.
3451
3452 my(%replace, %need, %hints, %warnings, %depends);
3453 my $replace = 0;
3454 my($hint, $define, $function);
3455
3456 sub find_api
3457 {
3458   my $code = shift;
3459   no warnings 'uninitialized';
3460   $code =~ s{
3461     / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*)
3462   | "[^"\\]*(?:\\.[^"\\]*)*"
3463   | '[^'\\]*(?:\\.[^'\\]*)*' }{}egsx;
3464   grep { exists $API{$_} } $code =~ /(\w+)/mg;
3465 }
3466
3467 while (<DATA>) {
3468   if ($hint) {
3469
3470     # Here, we are in the middle of accumulating a hint or warning.
3471     my $end_of_hint = 0;
3472
3473     # A line containing a comment end marker closes the hint.  Remove that
3474     # marker for processing below.
3475     if (s/\s*$rcce(.*?)\s*$//) {
3476         die "Nothing can follow the end of comment in '$_'\n" if length $1 > 0;
3477         $end_of_hint = 1;
3478     }
3479
3480     # Set $h to the hash of which type.
3481     my $h = $hint->[0] eq 'Hint' ? \%hints : \%warnings;
3482
3483     # Ignore any leading and trailing white space, and an optional star comment
3484     # continuation marker, then place the meat of the line into $1
3485     m/^\s*(?:\*\s*)?(.*?)\s*$/;
3486
3487     # Add the meat of this line to the hash value of each API element it
3488     # applies to
3489     for (@{$hint->[1]}) {
3490       $h->{$_} ||= '';  # avoid the warning older perls generate
3491       $h->{$_} .= "$1\n";
3492     }
3493
3494     # If the line had a comment close, we are through with this hint
3495     undef $hint if $end_of_hint;
3496
3497     next;
3498   }
3499
3500   # Set up $hint if this is the beginning of a Hint: or Warning:
3501   # These are from a multi-line C comment in the file, with the first line
3502   # looking like (a space has been inserted because this file can't have C
3503   # comment markers in it):
3504   #   / * Warning: PL_expect, PL_copline, PL_rsfp
3505   #
3506   # $hint becomes
3507   #     [
3508   #      'Warning',
3509   #                [
3510   #                  'PL_expect',
3511   #                  'PL_copline',
3512   #                  'PL_rsfp',
3513   #                ],
3514   #     ]
3515   if (m{^\s*$rccs\s+(Hint|Warning):\s+(\w+(?:,?\s+\w+)*)\s*$}) {
3516       $hint = [$1, [split /,?\s+/, $2]];
3517       next;
3518   }
3519
3520   if ($define) { # If in the middle of a definition...
3521
3522     # append a continuation line ending with backslash.
3523     if ($define->[1] =~ /\\$/) {
3524       $define->[1] .= $_;
3525     }
3526     else {  # Otherwise this line ends the definition, make foo depend on bar
3527             # (and what bar depends on) if its not one of ppp's own constructs
3528       if (exists $API{$define->[0]} && $define->[1] !~ /^DPPP_\(/) {
3529         my @n = find_api($define->[1]);
3530         push @{$depends{$define->[0]}}, @n if @n
3531       }
3532       undef $define;
3533     }
3534   }
3535
3536   # For '#define foo bar' or '#define foo(a,b,c) bar', $define becomes a
3537   # reference to [ foo, bar ]
3538   $define = [$1, $2] if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(.*)};
3539
3540   if ($function) {
3541     if (/^}/) {
3542       if (exists $API{$function->[0]}) {
3543         my @n = find_api($function->[1]);
3544         push @{$depends{$function->[0]}}, @n if @n
3545       }
3546       undef $function;
3547     }
3548     else {
3549       $function->[1] .= $_;
3550     }
3551   }
3552
3553   $function = [$1, ''] if m{^DPPP_\(my_(\w+)\)};
3554
3555   # Set $replace to the number given for lines that look like
3556   # / * Replace: \d+ * /
3557   # (blanks added to keep real C comments from appearing in this file)
3558   # Thus setting it to 1 starts a region where replacements are automatically
3559   # done, and setting it to 0 ends that region.
3560   $replace     = $1 if m{^\s*$rccs\s+Replace:\s+(\d+)\s+$rcce\s*$};
3561
3562   # Add bar => foo to %replace  for lines like '#define foo bar in a region
3563   # where $replace is non-zero
3564   $replace{$2} = $1 if $replace and m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+)};
3565
3566   # Add bar => foo to %replace for lines like '#define foo bar  / * Replace * /
3567   # (blanks added to keep real C comments from appearing in this file)
3568   $replace{$2} = $1 if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+).*$rccs\s+Replace\s+$rcce};
3569
3570   # Add foo => bar to %replace for lines like / * Replace foo with bar * /
3571   # (blanks added to keep real C comments from appearing in this file)
3572   $replace{$1} = $2 if m{^\s*$rccs\s+Replace (\w+) with (\w+)\s+$rcce\s*$};
3573
3574   # For lines like / * foo, bar depends on baz, bat * /
3575   # create a list of the elements on the rhs, and make that list apply to each
3576   # element in the lhs, which becomes a key in \%depends.
3577   # (blanks added to keep real C comments from appearing in this file)
3578   if (m{^\s*$rccs\s+(\w+(\s*,\s*\w+)*)\s+depends\s+on\s+(\w+(\s*,\s*\w+)*)\s+$rcce\s*$}) {
3579     my @deps = map { s/\s+//g; $_ } split /,/, $3;
3580     my $d;
3581     for $d (map { s/\s+//g; $_ } split /,/, $1) {
3582       push @{$depends{$d}}, @deps;
3583     }
3584   }
3585
3586   $need{$1} = 1 if m{^#if\s+defined\(NEED_(\w+)(?:_GLOBAL)?\)};
3587 }
3588
3589 for (values %depends) {
3590   my %seen;
3591   $_ = [sort dictionary_order grep !$seen{$_}++, @$_];
3592 }
3593
3594 if (exists $opt{'api-info'}) {
3595   my $f;
3596   my $count = 0;
3597   my $match = $opt{'api-info'} =~ m!^/(.*)/$! ? $1 : "^\Q$opt{'api-info'}\E\$";
3598   for $f (sort dictionary_order keys %API) {
3599     next unless $f =~ /$match/;
3600     print "\n=== $f ===\n";
3601     my $info = 0;
3602     my $base;
3603     $base = int_parse_version($API{$f}{base}) if $API{$f}{base};
3604     my $todo;
3605     $todo = int_parse_version($API{$f}{todo}) if $API{$f}{todo};
3606
3607     # Output information if it is generally publicly usable
3608     if ($base && ! $API{$f}{inaccessible} && ! $API{$f}{core_only}) {
3609         my $with_or= "";
3610         if (    $base <= $int_min_perl
3611             || (   (! $API{$f}{provided} && ! $todo)
3612                 || ($todo && $todo >= $base)))
3613         {
3614             $with_or= " with or";
3615         }
3616         print "\nSupported at least since perl-",
3617               format_version($base), ",$with_or without $ppport.";
3618         if ($API{$f}{unverified}) {
3619             print "\nThis information is based on inspection of the source code",
3620                   " and has not been\n",
3621                   "verified by successful compilation.";
3622         }
3623         print "\n";
3624         $info++;
3625      }
3626      if ($API{$f}{provided} || $todo) {
3627         print "\nThis is only supported by $ppport, and NOT by perl versions going forward.\n" unless $base;
3628         if ($todo) {
3629             if (! $base || $todo < $base) {
3630                 my $additionally = "";
3631                 $additionally .= " additionally" if $base;
3632                 print "$ppport$additionally provides support at least back to perl-",
3633                     format_version($todo),
3634                     ".\n";
3635             }
3636         }
3637         elsif (! $base || $base > $int_min_perl) {
3638             if (exists $depends{$f}) {
3639                 my $max = 0;
3640                 for (@{$depends{$f}}) {
3641                     $max = int_parse_version($API{$_}{todo}) if $API{$_}{todo} && $API{$_}{todo} > $max;
3642                     # XXX What to assume unspecified values are?  This effectively makes them MIN_PERL
3643                 }
3644                 $todo = $max if $max;
3645             }
3646             print "\n$ppport provides support for this, but ironically, does not",
3647                   " currently know,\n",
3648                   "for this report, the minimum version it supports for this";
3649             if ($API{$f}{undocumented}) {
3650                 print " and many things\n",
3651                       "it provides that are implemented as macros and aren't",
3652                       " documented.  You can\n",
3653                       "help by submitting a documentation patch";
3654             }
3655             print ".\n";
3656             if ($todo) {
3657                 if ($todo <= $int_min_perl) {
3658                     print "It may very well be supported all the way back to ",
3659                           format_version(5.003_07), ".\n";
3660                 }
3661                 else {
3662                     print "But given the things $f depends on, it's a good",
3663                           " guess that it isn't\n",
3664                           "supported prior to ", format_version($todo), ".\n";
3665                 }
3666             }
3667         }
3668     }
3669     if ($API{$f}{provided}) {
3670       print "Support needs to be explicitly requested by #define NEED_$f\n",
3671             "(or #define NEED_${f}_GLOBAL).\n"              if exists $need{$f};
3672       $info++;
3673     }
3674
3675     if ($base || ! $API{$f}{ppport_fnc}) {
3676       my $email = "Send email to perl5-porters\@perl.org if you need to have this functionality.\n";
3677       if ($API{$f}{inaccessible}) {
3678         print "\nThis is not part of the public API, and may not even be accessible to XS code.\n";
3679         $info++;
3680       }
3681       elsif ($API{$f}{core_only}) {
3682         print "\nThis is not part of the public API, and should not be used by XS code.\n";
3683         $info++;
3684       }
3685       elsif ($API{$f}{deprecated}) {
3686         print "\nThis is deprecated and should not be used.  Convert existing uses.\n";
3687         $info++;
3688       }
3689       elsif ($API{$f}{experimental}) {
3690         print "\nThe API for this is unstable and should not be used by XS code.\n", $email;
3691         $info++;
3692       }
3693       elsif ($API{$f}{undocumented}) {
3694         print "\nSince this is undocumented, the API should be considered unstable.\n";
3695         if ($API{$f}{provided}) {
3696             print "Consider bringing this up on the list: perl5-porters\@perl.org.\n";
3697         }
3698         else {
3699             print "It may be that this is not intended for XS use, or it may just be\n",
3700                   "that no one has gotten around to documenting it.\n", $email;
3701         }
3702         $info++;
3703       }
3704       unless ($info) {
3705         print "No portability information available.  Check your spelling; or",
3706               " this could be\na bug in Devel::PPPort.  To report an issue:\n",
3707               "https://github.com/Dual-Life/Devel-PPPort/issues/new\n";
3708       }
3709     }
3710
3711     print "\nDepends on: ", join(', ', @{$depends{$f}}), ".\n"
3712                                                          if exists $depends{$f};
3713     if (exists $hints{$f} || exists $warnings{$f}) {
3714       print "\n$hints{$f}" if exists $hints{$f};
3715       print "\nWARNING:\n$warnings{$f}" if exists $warnings{$f};
3716       $info++;
3717     }
3718     $count++;
3719   }
3720
3721   $count or print "\nFound no API matching '$opt{'api-info'}'.";
3722   print "\n";
3723   exit 0;
3724 }
3725
3726 if (exists $opt{'list-provided'}) {
3727   my $f;
3728   for $f (sort dictionary_order keys %API) {
3729     next unless $API{$f}{provided};
3730     my @flags;
3731     push @flags, 'explicit' if exists $need{$f};
3732     push @flags, 'depend'   if exists $depends{$f};
3733     push @flags, 'hint'     if exists $hints{$f};
3734     push @flags, 'warning'  if exists $warnings{$f};
3735     my $flags = @flags ? '  ['.join(', ', @flags).']' : '';
3736     print "$f$flags\n";
3737   }
3738   exit 0;
3739 }
3740
3741 my @files;
3742 my @srcext = qw( .xs .c .h .cc .cpp -c.inc -xs.inc );
3743 my $srcext = join '|', map { quotemeta $_ } @srcext;
3744
3745 if (@ARGV) {
3746   my %seen;
3747   for (@ARGV) {
3748     if (-e) {
3749       if (-f) {
3750         push @files, $_ unless $seen{$_}++;
3751       }
3752       else { warn "'$_' is not a file.\n" }
3753     }
3754     else {
3755       my @new = grep { -f } glob $_
3756           or warn "'$_' does not exist.\n";
3757       push @files, grep { !$seen{$_}++ } @new;
3758     }
3759   }
3760 }
3761 else {
3762   eval {
3763     require File::Find;
3764     File::Find::find(sub {
3765       $File::Find::name =~ /($srcext)$/i
3766           and push @files, $File::Find::name;
3767     }, '.');
3768   };
3769   if ($@) {
3770     @files = map { glob "*$_" } @srcext;
3771   }
3772 }
3773
3774 if (!@ARGV || $opt{filter}) {
3775   my(@in, @out);
3776   my %xsc = map { /(.*)\.xs$/ ? ("$1.c" => 1, "$1.cc" => 1) : () } @files;
3777   for (@files) {
3778     my $out = exists $xsc{$_} || /\b\Q$ppport\E$/i || !/($srcext)$/i;
3779     push @{ $out ? \@out : \@in }, $_;
3780   }
3781   if (@ARGV && @out) {
3782     warning("Skipping the following files (use --nofilter to avoid this):\n| ", join "\n| ", @out);
3783   }
3784   @files = @in;
3785 }
3786
3787 die "No input files given!\n" unless @files;
3788
3789 my(%files, %global, %revreplace);
3790 %revreplace = reverse %replace;
3791 my $filename;
3792 my $patch_opened = 0;
3793
3794 for $filename (@files) {
3795   unless (open IN, "<$filename") {
3796     warn "Unable to read from $filename: $!\n";
3797     next;
3798   }
3799
3800   info("Scanning $filename ...");
3801
3802   my $c = do { local $/; <IN> };
3803   close IN;
3804
3805   my %file = (orig => $c, changes => 0);
3806
3807   # Temporarily remove C/XS comments and strings from the code
3808   my @ccom;
3809
3810   $c =~ s{
3811     ( ^$HS*\#$HS*include\b[^\r\n]+\b(?:\Q$ppport\E|XSUB\.h)\b[^\r\n]*
3812     | ^$HS*\#$HS*(?:define|elif|if(?:def)?)\b[^\r\n]* )
3813   | ( ^$HS*\#[^\r\n]*
3814     | "[^"\\]*(?:\\.[^"\\]*)*"
3815     | '[^'\\]*(?:\\.[^'\\]*)*'
3816     | / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]* ) )
3817   }{ defined $2 and push @ccom, $2;
3818      defined $1 ? $1 : "$ccs$#ccom$cce" }mgsex;
3819
3820   $file{ccom} = \@ccom;
3821   $file{code} = $c;
3822   $file{has_inc_ppport} = $c =~ /^$HS*#$HS*include[^\r\n]+\b\Q$ppport\E\b/m;
3823
3824   my $func;
3825
3826   for $func (keys %API) {
3827     my $match = $func;
3828     $match .= "|$revreplace{$func}" if exists $revreplace{$func};
3829     if ($c =~ /\b(?:Perl_)?($match)\b/) {
3830       $file{uses_replace}{$1}++ if exists $revreplace{$func} && $1 eq $revreplace{$func};
3831       $file{uses_Perl}{$func}++ if $c =~ /\bPerl_$func\b/;
3832       if (exists $API{$func}{provided}) {
3833         $file{uses_provided}{$func}++;
3834         if ( ! exists $API{$func}{base}
3835             || int_parse_version($API{$func}{base}) > $opt{'compat-version'})
3836         {
3837           $file{uses}{$func}++;
3838           my @deps = rec_depend($func);
3839           if (@deps) {
3840             $file{uses_deps}{$func} = \@deps;
3841             for (@deps) {
3842               $file{uses}{$_} = 0 unless exists $file{uses}{$_};
3843             }
3844           }
3845           for ($func, @deps) {
3846             $file{needs}{$_} = 'static' if exists $need{$_};
3847           }
3848         }
3849       }
3850       if (   exists $API{$func}{todo}
3851           && int_parse_version($API{$func}{todo}) > $opt{'compat-version'})
3852       {
3853         if ($c =~ /\b$func\b/) {
3854           $file{uses_todo}{$func}++;
3855         }
3856       }
3857     }
3858   }
3859
3860   while ($c =~ /^$HS*#$HS*define$HS+(NEED_(\w+?)(_GLOBAL)?)\b/mg) {
3861     if (exists $need{$2}) {
3862       $file{defined $3 ? 'needed_global' : 'needed_static'}{$2}++;
3863     }
3864     else { warning("Possibly wrong #define $1 in $filename") }
3865   }
3866
3867   for (qw(uses needs uses_todo needed_global needed_static)) {
3868     for $func (keys %{$file{$_}}) {
3869       push @{$global{$_}{$func}}, $filename;
3870     }
3871   }
3872
3873   $files{$filename} = \%file;
3874 }
3875
3876 # Globally resolve NEED_'s
3877 my $need;
3878 for $need (keys %{$global{needs}}) {
3879   if (@{$global{needs}{$need}} > 1) {
3880     my @targets = @{$global{needs}{$need}};
3881     my @t = grep $files{$_}{needed_global}{$need}, @targets;
3882     @targets = @t if @t;
3883     @t = grep /\.xs$/i, @targets;
3884     @targets = @t if @t;
3885     my $target = shift @targets;
3886     $files{$target}{needs}{$need} = 'global';
3887     for (@{$global{needs}{$need}}) {
3888       $files{$_}{needs}{$need} = 'extern' if $_ ne $target;
3889     }
3890   }
3891 }
3892
3893 for $filename (@files) {
3894   exists $files{$filename} or next;
3895
3896   info("=== Analyzing $filename ===");
3897
3898   my %file = %{$files{$filename}};
3899   my $func;
3900   my $c = $file{code};
3901   my $warnings = 0;
3902
3903   for $func (sort dictionary_order keys %{$file{uses_Perl}}) {
3904     if ($API{$func}{varargs}) {
3905       unless ($API{$func}{noTHXarg}) {
3906         my $changes = ($c =~ s{\b(Perl_$func\s*\(\s*)(?!aTHX_?)(\)|[^\s)]*\))}
3907                               { $1 . ($2 eq ')' ? 'aTHX' : 'aTHX_ ') . $2 }ge);
3908         if ($changes) {
3909           warning("Doesn't pass interpreter argument aTHX to Perl_$func");
3910           $file{changes} += $changes;
3911         }
3912       }
3913     }
3914     else {
3915       warning("Uses Perl_$func instead of $func");
3916       $file{changes} += ($c =~ s{\bPerl_$func(\s*)\((\s*aTHX_?)?\s*}
3917                                 {$func$1(}g);
3918     }
3919   }
3920
3921   for $func (sort dictionary_order keys %{$file{uses_replace}}) {
3922     warning("Uses $func instead of $replace{$func}");
3923     $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g);
3924   }
3925
3926   for $func (sort dictionary_order keys %{$file{uses_provided}}) {
3927     if ($file{uses}{$func}) {
3928       if (exists $file{uses_deps}{$func}) {
3929         diag("Uses $func, which depends on ", join(', ', @{$file{uses_deps}{$func}}));
3930       }
3931       else {
3932         diag("Uses $func");
3933       }
3934     }
3935     $warnings += hint($func);
3936   }
3937
3938   unless ($opt{quiet}) {
3939     for $func (sort dictionary_order keys %{$file{uses_todo}}) {
3940       next if int_parse_version($API{$func}{todo}) <= $int_min_perl;
3941       print "*** WARNING: Uses $func, which may not be portable below perl ",
3942             format_version($API{$func}{todo}), ", even with '$ppport'\n";
3943       $warnings++;
3944     }
3945   }
3946
3947   for $func (sort dictionary_order keys %{$file{needed_static}}) {
3948     my $message = '';
3949     if (not exists $file{uses}{$func}) {
3950       $message = "No need to define NEED_$func if $func is never used";
3951     }
3952     elsif (exists $file{needs}{$func} && $file{needs}{$func} ne 'static') {
3953       $message = "No need to define NEED_$func when already needed globally";
3954     }
3955     if ($message) {
3956       diag($message);
3957       $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_$func\b.*$LF//mg);
3958     }
3959   }
3960
3961   for $func (sort dictionary_order keys %{$file{needed_global}}) {
3962     my $message = '';
3963     if (not exists $global{uses}{$func}) {
3964       $message = "No need to define NEED_${func}_GLOBAL if $func is never used";
3965     }
3966     elsif (exists $file{needs}{$func}) {
3967       if ($file{needs}{$func} eq 'extern') {
3968         $message = "No need to define NEED_${func}_GLOBAL when already needed globally";
3969       }
3970       elsif ($file{needs}{$func} eq 'static') {
3971         $message = "No need to define NEED_${func}_GLOBAL when only used in this file";
3972       }
3973     }
3974     if ($message) {
3975       diag($message);
3976       $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_${func}_GLOBAL\b.*$LF//mg);
3977     }
3978   }
3979
3980   $file{needs_inc_ppport} = keys %{$file{uses}};
3981
3982   if ($file{needs_inc_ppport}) {
3983     my $pp = '';
3984
3985     for $func (sort dictionary_order keys %{$file{needs}}) {
3986       my $type = $file{needs}{$func};
3987       next if $type eq 'extern';
3988       my $suffix = $type eq 'global' ? '_GLOBAL' : '';
3989       unless (exists $file{"needed_$type"}{$func}) {
3990         if ($type eq 'global') {
3991           diag("Files [@{$global{needs}{$func}}] need $func, adding global request");
3992         }
3993         else {
3994           diag("File needs $func, adding static request");
3995         }
3996         $pp .= "#define NEED_$func$suffix\n";
3997       }
3998     }
3999
4000     if ($pp && ($c =~ s/^(?=$HS*#$HS*define$HS+NEED_\w+)/$pp/m)) {
4001       $pp = '';
4002       $file{changes}++;
4003     }
4004
4005     unless ($file{has_inc_ppport}) {
4006       diag("Needs to include '$ppport'");
4007       $pp .= qq(#include "$ppport"\n)
4008     }
4009
4010     if ($pp) {
4011       $file{changes} += ($c =~ s/^($HS*#$HS*define$HS+NEED_\w+.*?)^/$1$pp/ms)
4012                      || ($c =~ s/^(?=$HS*#$HS*include.*\Q$ppport\E)/$pp/m)
4013                      || ($c =~ s/^($HS*#$HS*include.*XSUB.*\s*?)^/$1$pp/m)
4014                      || ($c =~ s/^/$pp/);
4015     }
4016   }
4017   else {
4018     if ($file{has_inc_ppport}) {
4019       diag("No need to include '$ppport'");
4020       $file{changes} += ($c =~ s/^$HS*?#$HS*include.*\Q$ppport\E.*?$LF//m);
4021     }
4022   }
4023
4024   # put back in our C comments
4025   my $ix;
4026   my $cppc = 0;
4027   my @ccom = @{$file{ccom}};
4028   for $ix (0 .. $#ccom) {
4029     if (!$opt{cplusplus} && $ccom[$ix] =~ s!^//!!) {
4030       $cppc++;
4031       $file{changes} += $c =~ s/$rccs$ix$rcce/$ccs$ccom[$ix] $cce/;
4032     }
4033     else {
4034       $c =~ s/$rccs$ix$rcce/$ccom[$ix]/;
4035     }
4036   }
4037
4038   if ($cppc) {
4039     my $s = $cppc != 1 ? 's' : '';
4040     warning("Uses $cppc C++ style comment$s, which is not portable");
4041   }
4042
4043   my $s = $warnings != 1 ? 's' : '';
4044   my $warn = $warnings ? " ($warnings warning$s)" : '';
4045   info("Analysis completed$warn");
4046
4047   if ($file{changes}) {
4048     if (exists $opt{copy}) {
4049       my $newfile = "$filename$opt{copy}";
4050       if (-e $newfile) {
4051         error("'$newfile' already exists, refusing to write copy of '$filename'");
4052       }
4053       else {
4054         local *F;
4055         if (open F, ">$newfile") {
4056           info("Writing copy of '$filename' with changes to '$newfile'");
4057           print F $c;
4058           close F;
4059         }
4060         else {
4061           error("Cannot open '$newfile' for writing: $!");
4062         }
4063       }
4064     }
4065     elsif (exists $opt{patch} || $opt{changes}) {
4066       if (exists $opt{patch}) {
4067         unless ($patch_opened) {
4068           if (open PATCH, ">$opt{patch}") {
4069             $patch_opened = 1;
4070           }
4071           else {
4072             error("Cannot open '$opt{patch}' for writing: $!");
4073             delete $opt{patch};
4074             $opt{changes} = 1;
4075             goto fallback;
4076           }
4077         }
4078         mydiff(\*PATCH, $filename, $c);
4079       }
4080       else {
4081 fallback:
4082         info("Suggested changes:");
4083         mydiff(\*STDOUT, $filename, $c);
4084       }
4085     }
4086     else {
4087       my $s = $file{changes} == 1 ? '' : 's';
4088       info("$file{changes} potentially required change$s detected");
4089     }
4090   }
4091   else {
4092     info("Looks good");
4093   }
4094 }
4095
4096 close PATCH if $patch_opened;
4097
4098 exit 0;
4099
4100
4101 sub try_use { eval "use @_;"; return $@ eq '' }
4102
4103 sub mydiff
4104 {
4105   local *F = shift;
4106   my($file, $str) = @_;
4107   my $diff;
4108
4109   if (exists $opt{diff}) {
4110     $diff = run_diff($opt{diff}, $file, $str);
4111   }
4112
4113   if (!defined $diff and try_use('Text::Diff')) {
4114     $diff = Text::Diff::diff($file, \$str, { STYLE => 'Unified' });
4115     $diff = <<HEADER . $diff;
4116 --- $file
4117 +++ $file.patched
4118 HEADER
4119   }
4120
4121   if (!defined $diff) {
4122     $diff = run_diff('diff -u', $file, $str);
4123   }
4124
4125   if (!defined $diff) {
4126     $diff = run_diff('diff', $file, $str);
4127   }
4128
4129   if (!defined $diff) {
4130     error("Cannot generate a diff. Please install Text::Diff or use --copy.");
4131     return;
4132   }
4133
4134   print F $diff;
4135 }
4136
4137 sub run_diff
4138 {
4139   my($prog, $file, $str) = @_;
4140   my $tmp = 'dppptemp';
4141   my $suf = 'aaa';
4142   my $diff = '';
4143   local *F;
4144
4145   while (-e "$tmp.$suf") { $suf++ }
4146   $tmp = "$tmp.$suf";
4147
4148   if (open F, ">$tmp") {
4149     print F $str;
4150     close F;
4151
4152     if (open F, "$prog $file $tmp |") {
4153       while (<F>) {
4154         s/\Q$tmp\E/$file.patched/;
4155         $diff .= $_;
4156       }
4157       close F;
4158       unlink $tmp;
4159       return $diff;
4160     }
4161
4162     unlink $tmp;
4163   }
4164   else {
4165     error("Cannot open '$tmp' for writing: $!");
4166   }
4167
4168   return undef;
4169 }
4170
4171 sub rec_depend
4172 {
4173   my($func, $seen) = @_;
4174   return () unless exists $depends{$func};
4175   $seen = {%{$seen||{}}};
4176   return () if $seen->{$func}++;
4177   my %s;
4178   grep !$s{$_}++, map { ($_, rec_depend($_, $seen)) } @{$depends{$func}};
4179 }
4180
4181 sub info
4182 {
4183   $opt{quiet} and return;
4184   print @_, "\n";
4185 }
4186
4187 sub diag
4188 {
4189   $opt{quiet} and return;
4190   $opt{diag} and print @_, "\n";
4191 }
4192
4193 sub warning
4194 {
4195   $opt{quiet} and return;
4196   print "*** ", @_, "\n";
4197 }
4198
4199 sub error
4200 {
4201   print "*** ERROR: ", @_, "\n";
4202 }
4203
4204 my %given_hints;
4205 my %given_warnings;
4206 sub hint
4207 {
4208   $opt{quiet} and return;
4209   my $func = shift;
4210   my $rv = 0;
4211   if (exists $warnings{$func} && !$given_warnings{$func}++) {
4212     my $warn = $warnings{$func};
4213     $warn =~ s!^!*** !mg;
4214     print "*** WARNING: $func\n", $warn;
4215     $rv++;
4216   }
4217   if ($opt{hints} && exists $hints{$func} && !$given_hints{$func}++) {
4218     my $hint = $hints{$func};
4219     $hint =~ s/^/   /mg;
4220     print "   --- hint for $func ---\n", $hint;
4221   }
4222   $rv;
4223 }
4224
4225 sub usage
4226 {
4227   my($usage) = do { local(@ARGV,$/)=($0); <> } =~ /^=head\d$HS+SYNOPSIS\s*^(.*?)\s*^=/ms;
4228   my %M = ( 'I' => '*' );
4229   $usage =~ s/^\s*perl\s+\S+/$^X $0/;
4230   $usage =~ s/([A-Z])<([^>]+)>/$M{$1}$2$M{$1}/g;
4231
4232   print <<ENDUSAGE;
4233
4234 Usage: $usage
4235
4236 See perldoc $0 for details.
4237
4238 ENDUSAGE
4239
4240   exit 2;
4241 }
4242
4243 sub strip
4244 {
4245   my $self = do { local(@ARGV,$/)=($0); <> };
4246   my($copy) = $self =~ /^=head\d\s+COPYRIGHT\s*^(.*?)^=\w+/ms;
4247   $copy =~ s/^(?=\S+)/    /gms;
4248   $self =~ s/^$HS+Do NOT edit.*?(?=^-)/$copy/ms;
4249   $self =~ s/^SKIP.*(?=^__DATA__)/SKIP
4250 if (\@ARGV && \$ARGV[0] eq '--unstrip') {
4251   eval { require Devel::PPPort };
4252   \$@ and die "Cannot require Devel::PPPort, please install.\\n";
4253   if (eval \$Devel::PPPort::VERSION < $VERSION) {
4254     die "$0 was originally generated with Devel::PPPort $VERSION.\\n"
4255       . "Your Devel::PPPort is only version \$Devel::PPPort::VERSION.\\n"
4256       . "Please install a newer version, or --unstrip will not work.\\n";
4257   }
4258   Devel::PPPort::WriteFile(\$0);
4259   exit 0;
4260 }
4261 print <<END;
4262
4263 Sorry, but this is a stripped version of \$0.
4264
4265 To be able to use its original script and doc functionality,
4266 please try to regenerate this file using:
4267
4268   \$^X \$0 --unstrip
4269
4270 END
4271 /ms;
4272   my($pl, $c) = $self =~ /(.*^__DATA__)(.*)/ms;
4273   $c =~ s{
4274     / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*)
4275   | ( "[^"\\]*(?:\\.[^"\\]*)*"
4276     | '[^'\\]*(?:\\.[^'\\]*)*' )
4277   | ($HS+) }{ defined $2 ? ' ' : ($1 || '') }gsex;
4278   $c =~ s!\s+$!!mg;
4279   $c =~ s!^$LF!!mg;
4280   $c =~ s!^\s*#\s*!#!mg;
4281   $c =~ s!^\s+!!mg;
4282
4283   open OUT, ">$0" or die "cannot strip $0: $!\n";
4284   print OUT "$pl$c\n";
4285
4286   exit 0;
4287 }
4288
4289 __DATA__
4290 */
4291
4292 #ifndef _P_P_PORTABILITY_H_
4293 #define _P_P_PORTABILITY_H_
4294
4295 #ifndef DPPP_NAMESPACE
4296 #  define DPPP_NAMESPACE DPPP_
4297 #endif
4298
4299 #define DPPP_CAT2(x,y) CAT2(x,y)
4300 #define DPPP_(name) DPPP_CAT2(DPPP_NAMESPACE, name)
4301
4302 #ifndef PERL_REVISION
4303 #  if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
4304 #    define PERL_PATCHLEVEL_H_IMPLICIT
4305 #    include <patchlevel.h>
4306 #  endif
4307 #  if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
4308 #    include <could_not_find_Perl_patchlevel.h>
4309 #  endif
4310 #  ifndef PERL_REVISION
4311 #    define PERL_REVISION       (5)
4312      /* Replace: 1 */
4313 #    define PERL_VERSION        PATCHLEVEL
4314 #    define PERL_SUBVERSION     SUBVERSION
4315      /* Replace PERL_PATCHLEVEL with PERL_VERSION */
4316      /* Replace: 0 */
4317 #  endif
4318 #endif
4319
4320 #define D_PPP_DEC2BCD(dec) ((((dec)/100)<<8)|((((dec)%100)/10)<<4)|((dec)%10))
4321 #define PERL_BCDVERSION ((D_PPP_DEC2BCD(PERL_REVISION)<<24)|(D_PPP_DEC2BCD(PERL_VERSION)<<12)|D_PPP_DEC2BCD(PERL_SUBVERSION))
4322
4323 /* It is very unlikely that anyone will try to use this with Perl 6
4324    (or greater), but who knows.
4325  */
4326 #if PERL_REVISION != 5
4327 #  error ppport.h only works with Perl version 5
4328 #endif /* PERL_REVISION != 5 */
4329 #ifndef dTHR
4330 #  define dTHR                           dNOOP
4331 #endif
4332 #ifndef dTHX
4333 #  define dTHX                           dNOOP
4334 #endif
4335
4336 /* Hint: dTHX
4337
4338   For pre-5.6.0 thread compatibility, instead use dTHXR, available only through
4339   ppport.h */
4340 #ifndef dTHXa
4341 #  define dTHXa(x)                       dNOOP
4342 #endif
4343 #ifndef pTHX
4344 #  define pTHX                           void
4345 #endif
4346
4347 #ifndef pTHX_
4348 #  define pTHX_
4349 #endif
4350
4351 #ifndef aTHX
4352 #  define aTHX
4353 #endif
4354
4355 /* Hint: aTHX
4356
4357   For pre-5.6.0 thread compatibility, instead use aTHXR, available only through
4358   ppport.h */
4359 #ifndef aTHX_
4360 #  define aTHX_
4361 #endif
4362
4363 /* Hint: aTHX_
4364
4365   For pre-5.6.0 thread compatibility, instead use aTHXR_, available only
4366   through ppport.h */
4367
4368 #if (PERL_BCDVERSION < 0x5006000)
4369 #  ifdef USE_THREADS
4370 #    define aTHXR  thr
4371 #    define aTHXR_ thr,
4372 #  else
4373 #    define aTHXR
4374 #    define aTHXR_
4375 #  endif
4376 #  define dTHXR  dTHR
4377 #else
4378 #  define aTHXR  aTHX
4379 #  define aTHXR_ aTHX_
4380 #  define dTHXR  dTHX
4381 #endif
4382 #ifndef dTHXoa
4383 #  define dTHXoa(x)                      dTHXa(x)
4384 #endif
4385
4386 #ifdef I_LIMITS
4387 #  include <limits.h>
4388 #endif
4389
4390 #ifndef PERL_UCHAR_MIN
4391 #  define PERL_UCHAR_MIN ((unsigned char)0)
4392 #endif
4393
4394 #ifndef PERL_UCHAR_MAX
4395 #  ifdef UCHAR_MAX
4396 #    define PERL_UCHAR_MAX ((unsigned char)UCHAR_MAX)
4397 #  else
4398 #    ifdef MAXUCHAR
4399 #      define PERL_UCHAR_MAX ((unsigned char)MAXUCHAR)
4400 #    else
4401 #      define PERL_UCHAR_MAX ((unsigned char)~(unsigned)0)
4402 #    endif
4403 #  endif
4404 #endif
4405
4406 #ifndef PERL_USHORT_MIN
4407 #  define PERL_USHORT_MIN ((unsigned short)0)
4408 #endif
4409
4410 #ifndef PERL_USHORT_MAX
4411 #  ifdef USHORT_MAX
4412 #    define PERL_USHORT_MAX ((unsigned short)USHORT_MAX)
4413 #  else
4414 #    ifdef MAXUSHORT
4415 #      define PERL_USHORT_MAX ((unsigned short)MAXUSHORT)
4416 #    else
4417 #      ifdef USHRT_MAX
4418 #        define PERL_USHORT_MAX ((unsigned short)USHRT_MAX)
4419 #      else
4420 #        define PERL_USHORT_MAX ((unsigned short)~(unsigned)0)
4421 #      endif
4422 #    endif
4423 #  endif
4424 #endif
4425
4426 #ifndef PERL_SHORT_MAX
4427 #  ifdef SHORT_MAX
4428 #    define PERL_SHORT_MAX ((short)SHORT_MAX)
4429 #  else
4430 #    ifdef MAXSHORT    /* Often used in <values.h> */
4431 #      define PERL_SHORT_MAX ((short)MAXSHORT)
4432 #    else
4433 #      ifdef SHRT_MAX
4434 #        define PERL_SHORT_MAX ((short)SHRT_MAX)
4435 #      else
4436 #        define PERL_SHORT_MAX ((short) (PERL_USHORT_MAX >> 1))
4437 #      endif
4438 #    endif
4439 #  endif
4440 #endif
4441
4442 #ifndef PERL_SHORT_MIN
4443 #  ifdef SHORT_MIN
4444 #    define PERL_SHORT_MIN ((short)SHORT_MIN)
4445 #  else
4446 #    ifdef MINSHORT
4447 #      define PERL_SHORT_MIN ((short)MINSHORT)
4448 #    else
4449 #      ifdef SHRT_MIN
4450 #        define PERL_SHORT_MIN ((short)SHRT_MIN)
4451 #      else
4452 #        define PERL_SHORT_MIN (-PERL_SHORT_MAX - ((3 & -1) == 3))
4453 #      endif
4454 #    endif
4455 #  endif
4456 #endif
4457
4458 #ifndef PERL_UINT_MAX
4459 #  ifdef UINT_MAX
4460 #    define PERL_UINT_MAX ((unsigned int)UINT_MAX)
4461 #  else
4462 #    ifdef MAXUINT
4463 #      define PERL_UINT_MAX ((unsigned int)MAXUINT)
4464 #    else
4465 #      define PERL_UINT_MAX (~(unsigned int)0)
4466 #    endif
4467 #  endif
4468 #endif
4469
4470 #ifndef PERL_UINT_MIN
4471 #  define PERL_UINT_MIN ((unsigned int)0)
4472 #endif
4473
4474 #ifndef PERL_INT_MAX
4475 #  ifdef INT_MAX
4476 #    define PERL_INT_MAX ((int)INT_MAX)
4477 #  else
4478 #    ifdef MAXINT    /* Often used in <values.h> */
4479 #      define PERL_INT_MAX ((int)MAXINT)
4480 #    else
4481 #      define PERL_INT_MAX ((int)(PERL_UINT_MAX >> 1))
4482 #    endif
4483 #  endif
4484 #endif
4485
4486 #ifndef PERL_INT_MIN
4487 #  ifdef INT_MIN
4488 #    define PERL_INT_MIN ((int)INT_MIN)
4489 #  else
4490 #    ifdef MININT
4491 #      define PERL_INT_MIN ((int)MININT)
4492 #    else
4493 #      define PERL_INT_MIN (-PERL_INT_MAX - ((3 & -1) == 3))
4494 #    endif
4495 #  endif
4496 #endif
4497
4498 #ifndef PERL_ULONG_MAX
4499 #  ifdef ULONG_MAX
4500 #    define PERL_ULONG_MAX ((unsigned long)ULONG_MAX)
4501 #  else
4502 #    ifdef MAXULONG
4503 #      define PERL_ULONG_MAX ((unsigned long)MAXULONG)
4504 #    else
4505 #      define PERL_ULONG_MAX (~(unsigned long)0)
4506 #    endif
4507 #  endif
4508 #endif
4509
4510 #ifndef PERL_ULONG_MIN
4511 #  define PERL_ULONG_MIN ((unsigned long)0L)
4512 #endif
4513
4514 #ifndef PERL_LONG_MAX
4515 #  ifdef LONG_MAX
4516 #    define PERL_LONG_MAX ((long)LONG_MAX)
4517 #  else
4518 #    ifdef MAXLONG
4519 #      define PERL_LONG_MAX ((long)MAXLONG)
4520 #    else
4521 #      define PERL_LONG_MAX ((long) (PERL_ULONG_MAX >> 1))
4522 #    endif
4523 #  endif
4524 #endif
4525
4526 #ifndef PERL_LONG_MIN
4527 #  ifdef LONG_MIN
4528 #    define PERL_LONG_MIN ((long)LONG_MIN)
4529 #  else
4530 #    ifdef MINLONG
4531 #      define PERL_LONG_MIN ((long)MINLONG)
4532 #    else
4533 #      define PERL_LONG_MIN (-PERL_LONG_MAX - ((3 & -1) == 3))
4534 #    endif
4535 #  endif
4536 #endif
4537
4538 #if defined(HAS_QUAD) && (defined(convex) || defined(uts))
4539 #  ifndef PERL_UQUAD_MAX
4540 #    ifdef ULONGLONG_MAX
4541 #      define PERL_UQUAD_MAX ((unsigned long long)ULONGLONG_MAX)
4542 #    else
4543 #      ifdef MAXULONGLONG
4544 #        define PERL_UQUAD_MAX ((unsigned long long)MAXULONGLONG)
4545 #      else
4546 #        define PERL_UQUAD_MAX (~(unsigned long long)0)
4547 #      endif
4548 #    endif
4549 #  endif
4550
4551 #  ifndef PERL_UQUAD_MIN
4552 #    define PERL_UQUAD_MIN ((unsigned long long)0L)
4553 #  endif
4554
4555 #  ifndef PERL_QUAD_MAX
4556 #    ifdef LONGLONG_MAX
4557 #      define PERL_QUAD_MAX ((long long)LONGLONG_MAX)
4558 #    else
4559 #      ifdef MAXLONGLONG
4560 #        define PERL_QUAD_MAX ((long long)MAXLONGLONG)
4561 #      else
4562 #        define PERL_QUAD_MAX ((long long) (PERL_UQUAD_MAX >> 1))
4563 #      endif
4564 #    endif
4565 #  endif
4566
4567 #  ifndef PERL_QUAD_MIN
4568 #    ifdef LONGLONG_MIN
4569 #      define PERL_QUAD_MIN ((long long)LONGLONG_MIN)
4570 #    else
4571 #      ifdef MINLONGLONG
4572 #        define PERL_QUAD_MIN ((long long)MINLONGLONG)
4573 #      else
4574 #        define PERL_QUAD_MIN (-PERL_QUAD_MAX - ((3 & -1) == 3))
4575 #      endif
4576 #    endif
4577 #  endif
4578 #endif
4579
4580 /* This is based on code from 5.003 perl.h */
4581 #ifdef HAS_QUAD
4582 #  ifdef cray
4583 #ifndef IVTYPE
4584 #  define IVTYPE                         int
4585 #endif
4586
4587 #ifndef IV_MIN
4588 #  define IV_MIN                         PERL_INT_MIN
4589 #endif
4590
4591 #ifndef IV_MAX
4592 #  define IV_MAX                         PERL_INT_MAX
4593 #endif
4594
4595 #ifndef UV_MIN
4596 #  define UV_MIN                         PERL_UINT_MIN
4597 #endif
4598
4599 #ifndef UV_MAX
4600 #  define UV_MAX                         PERL_UINT_MAX
4601 #endif
4602
4603 #    ifdef INTSIZE
4604 #ifndef IVSIZE
4605 #  define IVSIZE                         INTSIZE
4606 #endif
4607
4608 #    endif
4609 #  else
4610 #    if defined(convex) || defined(uts)
4611 #ifndef IVTYPE
4612 #  define IVTYPE                         long long
4613 #endif
4614
4615 #ifndef IV_MIN
4616 #  define IV_MIN                         PERL_QUAD_MIN
4617 #endif
4618
4619 #ifndef IV_MAX
4620 #  define IV_MAX                         PERL_QUAD_MAX
4621 #endif
4622
4623 #ifndef UV_MIN
4624 #  define UV_MIN                         PERL_UQUAD_MIN
4625 #endif
4626
4627 #ifndef UV_MAX
4628 #  define UV_MAX                         PERL_UQUAD_MAX
4629 #endif
4630
4631 #      ifdef LONGLONGSIZE
4632 #ifndef IVSIZE
4633 #  define IVSIZE                         LONGLONGSIZE
4634 #endif
4635
4636 #      endif
4637 #    else
4638 #ifndef IVTYPE
4639 #  define IVTYPE                         long
4640 #endif
4641
4642 #ifndef IV_MIN
4643 #  define IV_MIN                         PERL_LONG_MIN
4644 #endif
4645
4646 #ifndef IV_MAX
4647 #  define IV_MAX                         PERL_LONG_MAX
4648 #endif
4649
4650 #ifndef UV_MIN
4651 #  define UV_MIN                         PERL_ULONG_MIN
4652 #endif
4653
4654 #ifndef UV_MAX
4655 #  define UV_MAX                         PERL_ULONG_MAX
4656 #endif
4657
4658 #      ifdef LONGSIZE
4659 #ifndef IVSIZE
4660 #  define IVSIZE                         LONGSIZE
4661 #endif
4662
4663 #      endif
4664 #    endif
4665 #  endif
4666 #ifndef IVSIZE
4667 #  define IVSIZE                         8
4668 #endif
4669
4670 #ifndef LONGSIZE
4671 #  define LONGSIZE                       8
4672 #endif
4673
4674 #ifndef PERL_QUAD_MIN
4675 #  define PERL_QUAD_MIN                  IV_MIN
4676 #endif
4677
4678 #ifndef PERL_QUAD_MAX
4679 #  define PERL_QUAD_MAX                  IV_MAX
4680 #endif
4681
4682 #ifndef PERL_UQUAD_MIN
4683 #  define PERL_UQUAD_MIN                 UV_MIN
4684 #endif
4685
4686 #ifndef PERL_UQUAD_MAX
4687 #  define PERL_UQUAD_MAX                 UV_MAX
4688 #endif
4689
4690 #else
4691 #ifndef IVTYPE
4692 #  define IVTYPE                         long
4693 #endif
4694
4695 #ifndef LONGSIZE
4696 #  define LONGSIZE                       4
4697 #endif
4698
4699 #ifndef IV_MIN
4700 #  define IV_MIN                         PERL_LONG_MIN
4701 #endif
4702
4703 #ifndef IV_MAX
4704 #  define IV_MAX                         PERL_LONG_MAX
4705 #endif
4706
4707 #ifndef UV_MIN
4708 #  define UV_MIN                         PERL_ULONG_MIN
4709 #endif
4710
4711 #ifndef UV_MAX
4712 #  define UV_MAX                         PERL_ULONG_MAX
4713 #endif
4714
4715 #endif
4716
4717 #ifndef IVSIZE
4718 #  ifdef LONGSIZE
4719 #    define IVSIZE LONGSIZE
4720 #  else
4721 #    define IVSIZE 4 /* A bold guess, but the best we can make. */
4722 #  endif
4723 #endif
4724 #ifndef UVTYPE
4725 #  define UVTYPE                         unsigned IVTYPE
4726 #endif
4727
4728 #ifndef UVSIZE
4729 #  define UVSIZE                         IVSIZE
4730 #endif
4731
4732 #ifndef PERL_SIGNALS_UNSAFE_FLAG
4733
4734 #define PERL_SIGNALS_UNSAFE_FLAG 0x0001
4735
4736 #if (PERL_BCDVERSION < 0x5008000)
4737 #  define D_PPP_PERL_SIGNALS_INIT   PERL_SIGNALS_UNSAFE_FLAG
4738 #else
4739 #  define D_PPP_PERL_SIGNALS_INIT   0
4740 #endif
4741
4742 #if defined(NEED_PL_signals)
4743 static U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
4744 #elif defined(NEED_PL_signals_GLOBAL)
4745 U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
4746 #else
4747 extern U32 DPPP_(my_PL_signals);
4748 #endif
4749 #define PL_signals DPPP_(my_PL_signals)
4750
4751 #endif
4752
4753 /* Hint: PL_ppaddr
4754  * Calling an op via PL_ppaddr requires passing a context argument
4755  * for threaded builds. Since the context argument is different for
4756  * 5.005 perls, you can use aTHXR (supplied by ppport.h), which will
4757  * automatically be defined as the correct argument.
4758  */
4759
4760 #if (PERL_BCDVERSION <= 0x5005005)
4761 /* Replace: 1 */
4762 #  define PL_ppaddr                 ppaddr
4763 #  define PL_no_modify              no_modify
4764 /* Replace: 0 */
4765 #endif
4766
4767 #if (PERL_BCDVERSION <= 0x5004005)
4768 /* Replace: 1 */
4769 #  define PL_DBsignal               DBsignal
4770 #  define PL_DBsingle               DBsingle
4771 #  define PL_DBsub                  DBsub
4772 #  define PL_DBtrace                DBtrace
4773 #  define PL_Sv                     Sv
4774 #  define PL_bufend                 bufend
4775 #  define PL_bufptr                 bufptr
4776 #  define PL_compiling              compiling
4777 #  define PL_copline                copline
4778 #  define PL_curcop                 curcop
4779 #  define PL_curstash               curstash
4780 #  define PL_debstash               debstash
4781 #  define PL_defgv                  defgv
4782 #  define PL_diehook                diehook
4783 #  define PL_dirty                  dirty
4784 #  define PL_dowarn                 dowarn
4785 #  define PL_errgv                  errgv
4786 #  define PL_error_count            error_count
4787 #  define PL_expect                 expect
4788 #  define PL_hexdigit               hexdigit
4789 #  define PL_hints                  hints
4790 #  define PL_in_my                  in_my
4791 #  define PL_laststatval            laststatval
4792 #  define PL_lex_state              lex_state
4793 #  define PL_lex_stuff              lex_stuff
4794 #  define PL_linestr                linestr
4795 #  define PL_na                     na
4796 #  define PL_perl_destruct_level    perl_destruct_level
4797 #  define PL_perldb                 perldb
4798 #  define PL_rsfp_filters           rsfp_filters
4799 #  define PL_rsfp                   rsfp
4800 #  define PL_stack_base             stack_base
4801 #  define PL_stack_sp               stack_sp
4802 #  define PL_statcache              statcache
4803 #  define PL_stdingv                stdingv
4804 #  define PL_sv_arenaroot           sv_arenaroot
4805 #  define PL_sv_no                  sv_no
4806 #  define PL_sv_undef               sv_undef
4807 #  define PL_sv_yes                 sv_yes
4808 #  define PL_tainted                tainted
4809 #  define PL_tainting               tainting
4810 #  define PL_tokenbuf               tokenbuf
4811 #  define PL_mess_sv                mess_sv
4812 /* Replace: 0 */
4813 #endif
4814
4815 /* Warning: PL_parser
4816  * For perl versions earlier than 5.9.5, this is an always
4817  * non-NULL dummy. Also, it cannot be dereferenced. Don't
4818  * use it if you can avoid it, and unless you absolutely know
4819  * what you're doing.
4820  * If you always check that PL_parser is non-NULL, you can
4821  * define DPPP_PL_parser_NO_DUMMY to avoid the creation of
4822  * a dummy parser structure.
4823  */
4824
4825 #if (PERL_BCDVERSION >= 0x5009005)
4826 # ifdef DPPP_PL_parser_NO_DUMMY
4827 #  define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \
4828                 (croak("panic: PL_parser == NULL in %s:%d", \
4829                        __FILE__, __LINE__), (yy_parser *) NULL))->var)
4830 # else
4831 #  ifdef DPPP_PL_parser_NO_DUMMY_WARNING
4832 #   define D_PPP_parser_dummy_warning(var)
4833 #  else
4834 #   define D_PPP_parser_dummy_warning(var) \
4835              warn("warning: dummy PL_" #var " used in %s:%d", __FILE__, __LINE__),
4836 #  endif
4837 #  define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \
4838                 (D_PPP_parser_dummy_warning(var) &DPPP_(dummy_PL_parser)))->var)
4839 #if defined(NEED_PL_parser)
4840 static yy_parser DPPP_(dummy_PL_parser);
4841 #elif defined(NEED_PL_parser_GLOBAL)
4842 yy_parser DPPP_(dummy_PL_parser);
4843 #else
4844 extern yy_parser DPPP_(dummy_PL_parser);
4845 #endif
4846
4847 # endif
4848
4849 /* 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 */
4850 /* Warning: PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf
4851  * Do not use this variable unless you know exactly what you're
4852  * doing. It is internal to the perl parser and may change or even
4853  * be removed in the future. As of perl 5.9.5, you have to check
4854  * for (PL_parser != NULL) for this variable to have any effect.
4855  * An always non-NULL PL_parser dummy is provided for earlier
4856  * perl versions.
4857  * If PL_parser is NULL when you try to access this variable, a
4858  * dummy is being accessed instead and a warning is issued unless
4859  * you define DPPP_PL_parser_NO_DUMMY_WARNING.
4860  * If DPPP_PL_parser_NO_DUMMY is defined, the code trying to access
4861  * this variable will croak with a panic message.
4862  */
4863
4864 # define PL_expect         D_PPP_my_PL_parser_var(expect)
4865 # define PL_copline        D_PPP_my_PL_parser_var(copline)
4866 # define PL_rsfp           D_PPP_my_PL_parser_var(rsfp)
4867 # define PL_rsfp_filters   D_PPP_my_PL_parser_var(rsfp_filters)
4868 # define PL_linestr        D_PPP_my_PL_parser_var(linestr)
4869 # define PL_bufptr         D_PPP_my_PL_parser_var(bufptr)
4870 # define PL_bufend         D_PPP_my_PL_parser_var(bufend)
4871 # define PL_lex_state      D_PPP_my_PL_parser_var(lex_state)
4872 # define PL_lex_stuff      D_PPP_my_PL_parser_var(lex_stuff)
4873 # define PL_tokenbuf       D_PPP_my_PL_parser_var(tokenbuf)
4874 # define PL_in_my          D_PPP_my_PL_parser_var(in_my)
4875 # define PL_in_my_stash    D_PPP_my_PL_parser_var(in_my_stash)
4876 # define PL_error_count    D_PPP_my_PL_parser_var(error_count)
4877
4878
4879 #else
4880
4881 /* ensure that PL_parser != NULL and cannot be dereferenced */
4882 # define PL_parser         ((void *) 1)
4883
4884 #endif
4885
4886 #if   (PERL_BCDVERSION <= 0x5003022)
4887 #  undef start_subparse
4888 #  if (PERL_BCDVERSION < 0x5003022)
4889 #ifndef start_subparse
4890 #  define start_subparse(a, b)           Perl_start_subparse()
4891 #endif
4892
4893 #  else
4894 #ifndef start_subparse
4895 #  define start_subparse(a, b)           Perl_start_subparse(b)
4896 #endif
4897
4898 #  endif
4899
4900 #if (PERL_BCDVERSION < 0x5003007)
4901 foo
4902 #endif
4903 #endif
4904
4905 /* Hint: newCONSTSUB
4906  * Returns a CV* as of perl-5.7.1. This return value is not supported
4907  * by Devel::PPPort.
4908  */
4909
4910 /* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */
4911 #if (PERL_BCDVERSION < 0x5004063) && (PERL_BCDVERSION != 0x5004005)
4912
4913 /* And before that, we need to make sure this gets compiled for the functions
4914  * that rely on it */
4915 #define NEED_newCONSTSUB
4916
4917 #if defined(NEED_newCONSTSUB)
4918 static void DPPP_(my_newCONSTSUB)(HV * stash, const char * name, SV * sv);
4919 static
4920 #else
4921 extern void DPPP_(my_newCONSTSUB)(HV * stash, const char * name, SV * sv);
4922 #endif
4923
4924 #if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL)
4925
4926 #ifdef newCONSTSUB
4927 #  undef newCONSTSUB
4928 #endif
4929 #define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c)
4930 #define Perl_newCONSTSUB DPPP_(my_newCONSTSUB)
4931
4932
4933 /* This is just a trick to avoid a dependency of newCONSTSUB on PL_parser */
4934 /* (There's no PL_parser in perl < 5.005, so this is completely safe)     */
4935 #define D_PPP_PL_copline PL_copline
4936
4937 void
4938 DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv)
4939 {
4940         U32 oldhints = PL_hints;
4941         HV *old_cop_stash = PL_curcop->cop_stash;
4942         HV *old_curstash = PL_curstash;
4943         line_t oldline = PL_curcop->cop_line;
4944         PL_curcop->cop_line = D_PPP_PL_copline;
4945
4946         PL_hints &= ~HINT_BLOCK_SCOPE;
4947         if (stash)
4948                 PL_curstash = PL_curcop->cop_stash = stash;
4949
4950         newSUB(
4951
4952                 start_subparse(FALSE, 0),
4953
4954                 newSVOP(OP_CONST, 0, newSVpv((char *) name, 0)),
4955                 newSVOP(OP_CONST, 0, &PL_sv_no),   /* SvPV(&PL_sv_no) == "" -- GMB */
4956                 newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))
4957         );
4958
4959         PL_hints = oldhints;
4960         PL_curcop->cop_stash = old_cop_stash;
4961         PL_curstash = old_curstash;
4962         PL_curcop->cop_line = oldline;
4963 }
4964 #endif
4965 #endif
4966 #ifndef PERL_MAGIC_sv
4967 #  define PERL_MAGIC_sv                  '\0'
4968 #endif
4969
4970 #ifndef PERL_MAGIC_overload
4971 #  define PERL_MAGIC_overload            'A'
4972 #endif
4973
4974 #ifndef PERL_MAGIC_overload_elem
4975 #  define PERL_MAGIC_overload_elem       'a'
4976 #endif
4977
4978 #ifndef PERL_MAGIC_overload_table
4979 #  define PERL_MAGIC_overload_table      'c'
4980 #endif
4981
4982 #ifndef PERL_MAGIC_bm
4983 #  define PERL_MAGIC_bm                  'B'
4984 #endif
4985
4986 #ifndef PERL_MAGIC_regdata
4987 #  define PERL_MAGIC_regdata             'D'
4988 #endif
4989
4990 #ifndef PERL_MAGIC_regdatum
4991 #  define PERL_MAGIC_regdatum            'd'
4992 #endif
4993
4994 #ifndef PERL_MAGIC_env
4995 #  define PERL_MAGIC_env                 'E'
4996 #endif
4997
4998 #ifndef PERL_MAGIC_envelem
4999 #  define PERL_MAGIC_envelem             'e'
5000 #endif
5001
5002 #ifndef PERL_MAGIC_fm
5003 #  define PERL_MAGIC_fm                  'f'
5004 #endif
5005
5006 #ifndef PERL_MAGIC_regex_global
5007 #  define PERL_MAGIC_regex_global        'g'
5008 #endif
5009
5010 #ifndef PERL_MAGIC_isa
5011 #  define PERL_MAGIC_isa                 'I'
5012 #endif
5013
5014 #ifndef PERL_MAGIC_isaelem
5015 #  define PERL_MAGIC_isaelem             'i'
5016 #endif
5017
5018 #ifndef PERL_MAGIC_nkeys
5019 #  define PERL_MAGIC_nkeys               'k'
5020 #endif
5021
5022 #ifndef PERL_MAGIC_dbfile
5023 #  define PERL_MAGIC_dbfile              'L'
5024 #endif
5025
5026 #ifndef PERL_MAGIC_dbline
5027 #  define PERL_MAGIC_dbline              'l'
5028 #endif
5029
5030 #ifndef PERL_MAGIC_mutex
5031 #  define PERL_MAGIC_mutex               'm'
5032 #endif
5033
5034 #ifndef PERL_MAGIC_shared
5035 #  define PERL_MAGIC_shared              'N'
5036 #endif
5037
5038 #ifndef PERL_MAGIC_shared_scalar
5039 #  define PERL_MAGIC_shared_scalar       'n'
5040 #endif
5041
5042 #ifndef PERL_MAGIC_collxfrm
5043 #  define PERL_MAGIC_collxfrm            'o'
5044 #endif
5045
5046 #ifndef PERL_MAGIC_tied
5047 #  define PERL_MAGIC_tied                'P'
5048 #endif
5049
5050 #ifndef PERL_MAGIC_tiedelem
5051 #  define PERL_MAGIC_tiedelem            'p'
5052 #endif
5053
5054 #ifndef PERL_MAGIC_tiedscalar
5055 #  define PERL_MAGIC_tiedscalar          'q'
5056 #endif
5057
5058 #ifndef PERL_MAGIC_qr
5059 #  define PERL_MAGIC_qr                  'r'
5060 #endif
5061
5062 #ifndef PERL_MAGIC_sig
5063 #  define PERL_MAGIC_sig                 'S'
5064 #endif
5065
5066 #ifndef PERL_MAGIC_sigelem
5067 #  define PERL_MAGIC_sigelem             's'
5068 #endif
5069
5070 #ifndef PERL_MAGIC_taint
5071 #  define PERL_MAGIC_taint               't'
5072 #endif
5073
5074 #ifndef PERL_MAGIC_uvar
5075 #  define PERL_MAGIC_uvar                'U'
5076 #endif
5077
5078 #ifndef PERL_MAGIC_uvar_elem
5079 #  define PERL_MAGIC_uvar_elem           'u'
5080 #endif
5081
5082 #ifndef PERL_MAGIC_vstring
5083 #  define PERL_MAGIC_vstring             'V'
5084 #endif
5085
5086 #ifndef PERL_MAGIC_vec
5087 #  define PERL_MAGIC_vec                 'v'
5088 #endif
5089
5090 #ifndef PERL_MAGIC_utf8
5091 #  define PERL_MAGIC_utf8                'w'
5092 #endif
5093
5094 #ifndef PERL_MAGIC_substr
5095 #  define PERL_MAGIC_substr              'x'
5096 #endif
5097
5098 #ifndef PERL_MAGIC_defelem
5099 #  define PERL_MAGIC_defelem             'y'
5100 #endif
5101
5102 #ifndef PERL_MAGIC_glob
5103 #  define PERL_MAGIC_glob                '*'
5104 #endif
5105
5106 #ifndef PERL_MAGIC_arylen
5107 #  define PERL_MAGIC_arylen              '#'
5108 #endif
5109
5110 #ifndef PERL_MAGIC_pos
5111 #  define PERL_MAGIC_pos                 '.'
5112 #endif
5113
5114 #ifndef PERL_MAGIC_backref
5115 #  define PERL_MAGIC_backref             '<'
5116 #endif
5117
5118 #ifndef PERL_MAGIC_ext
5119 #  define PERL_MAGIC_ext                 '~'
5120 #endif
5121 #ifndef cBOOL
5122 #  define cBOOL(cbool)                   ((cbool) ? (bool)1 : (bool)0)
5123 #endif
5124
5125 #ifndef OpHAS_SIBLING
5126 #  define OpHAS_SIBLING(o)               (cBOOL((o)->op_sibling))
5127 #endif
5128
5129 #ifndef OpSIBLING
5130 #  define OpSIBLING(o)                   (0 + (o)->op_sibling)
5131 #endif
5132
5133 #ifndef OpMORESIB_set
5134 #  define OpMORESIB_set(o, sib)          ((o)->op_sibling = (sib))
5135 #endif
5136
5137 #ifndef OpLASTSIB_set
5138 #  define OpLASTSIB_set(o, parent)       ((o)->op_sibling = NULL)
5139 #endif
5140
5141 #ifndef OpMAYBESIB_set
5142 #  define OpMAYBESIB_set(o, sib, parent) ((o)->op_sibling = (sib))
5143 #endif
5144
5145 #ifndef HEf_SVKEY
5146 #  define HEf_SVKEY                      -2
5147 #endif
5148
5149 #if defined(DEBUGGING) && !defined(__COVERITY__)
5150 #ifndef __ASSERT_
5151 #  define __ASSERT_(statement)           assert(statement),
5152 #endif
5153
5154 #else
5155 #ifndef __ASSERT_
5156 #  define __ASSERT_(statement)
5157 #endif
5158
5159 #endif
5160
5161 /* These could become provided when they become part of the public API */
5162 #ifndef withinCOUNT
5163 #  define withinCOUNT(c, l, n)           \
5164    (((WIDEST_UTYPE) (((c)) - ((l) | 0))) <= (((WIDEST_UTYPE) ((n) | 0))))
5165 #endif
5166
5167 #ifndef inRANGE
5168 #  define inRANGE(c, l, u)               \
5169    (  (sizeof(c) == sizeof(U8))  ? withinCOUNT(((U8)  (c)), (l), ((u) - (l)))  \
5170     : (sizeof(c) == sizeof(U16)) ? withinCOUNT(((U16) (c)), (l), ((u) - (l)))  \
5171     : (sizeof(c) == sizeof(U32)) ? withinCOUNT(((U32) (c)), (l), ((u) - (l)))  \
5172     : (withinCOUNT(((WIDEST_UTYPE) (c)), (l), ((u) - (l)))))
5173 #endif
5174
5175 /* Create the macro for "is'macro'_utf8_safe(s, e)".  For code points below
5176  * 256, it calls the equivalent _L1 macro by converting the UTF-8 to code
5177  * point.  That is so that it can automatically get the bug fixes done in this
5178  * file. */
5179 #define D_PPP_IS_GENERIC_UTF8_SAFE(s, e, macro)                             \
5180    (((e) - (s)) <= 0                                                        \
5181      ? 0                                                                    \
5182      : UTF8_IS_INVARIANT((s)[0])                                            \
5183        ? is ## macro ## _L1((s)[0])                                         \
5184        : (((e) - (s)) < UTF8SKIP(s))                                        \
5185           ? 0                                                               \
5186           : UTF8_IS_DOWNGRADEABLE_START((s)[0])                             \
5187               /* The cast in the line below is only to silence warnings */  \
5188             ? is ## macro ## _L1((WIDEST_UTYPE) LATIN1_TO_NATIVE(           \
5189                                   UTF8_ACCUMULATE(NATIVE_UTF8_TO_I8((s)[0]) \
5190                                                      & UTF_START_MASK(2),   \
5191                                                   (s)[1])))                 \
5192             : is ## macro ## _utf8(s))
5193
5194 /* Create the macro for "is'macro'_LC_utf8_safe(s, e)".  For code points below
5195  * 256, it calls the equivalent _L1 macro by converting the UTF-8 to code
5196  * point.  That is so that it can automatically get the bug fixes done in this
5197  * file. */
5198 #define D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, macro)                          \
5199    (((e) - (s)) <= 0                                                        \
5200      ? 0                                                                    \
5201      : UTF8_IS_INVARIANT((s)[0])                                            \
5202        ? is ## macro ## _LC((s)[0])                                         \
5203        : (((e) - (s)) < UTF8SKIP(s))                                        \
5204           ? 0                                                               \
5205           : UTF8_IS_DOWNGRADEABLE_START((s)[0])                             \
5206               /* The cast in the line below is only to silence warnings */  \
5207             ? is ## macro ## _LC((WIDEST_UTYPE) LATIN1_TO_NATIVE(           \
5208                                   UTF8_ACCUMULATE(NATIVE_UTF8_TO_I8((s)[0]) \
5209                                                      & UTF_START_MASK(2),   \
5210                                                   (s)[1])))                 \
5211             : is ## macro ## _utf8(s))
5212
5213 /* A few of the early functions are broken.  For these and the non-LC case,
5214  * machine generated code is substituted.  But that code doesn't work for
5215  * locales.  This is just like the above macro, but at the end, we call the
5216  * macro we've generated for the above 255 case, which is correct since locale
5217  * isn't involved.  This will generate extra code to handle the 0-255 inputs,
5218  * but hopefully it will be optimized out by the C compiler.  But just in case
5219  * it isn't, this macro is only used on the few versions that are broken */
5220
5221 #define D_PPP_IS_GENERIC_LC_UTF8_SAFE_BROKEN(s, e, macro)                   \
5222    (((e) - (s)) <= 0                                                        \
5223      ? 0                                                                    \
5224      : UTF8_IS_INVARIANT((s)[0])                                            \
5225        ? is ## macro ## _LC((s)[0])                                         \
5226        : (((e) - (s)) < UTF8SKIP(s))                                        \
5227           ? 0                                                               \
5228           : UTF8_IS_DOWNGRADEABLE_START((s)[0])                             \
5229               /* The cast in the line below is only to silence warnings */  \
5230             ? is ## macro ## _LC((WIDEST_UTYPE) LATIN1_TO_NATIVE(           \
5231                                   UTF8_ACCUMULATE(NATIVE_UTF8_TO_I8((s)[0]) \
5232                                                      & UTF_START_MASK(2),   \
5233                                                   (s)[1])))                 \
5234             : is ## macro ## _utf8_safe(s, e))
5235 #ifndef SvRX
5236 #  define SvRX(rv)                       (SvROK((rv)) ? (SvMAGICAL(SvRV((rv))) ? (mg_find(SvRV((rv)), PERL_MAGIC_qr) ? mg_find(SvRV((rv)), PERL_MAGIC_qr)->mg_obj : NULL) : NULL) : NULL)
5237 #endif
5238
5239 #ifndef SvRXOK
5240 #  define SvRXOK(sv)                     (!!SvRX(sv))
5241 #endif
5242
5243 #ifndef PERL_UNUSED_DECL
5244 #  ifdef HASATTRIBUTE
5245 #    if (defined(__GNUC__) && defined(__cplusplus)) || defined(__INTEL_COMPILER)
5246 #      define PERL_UNUSED_DECL
5247 #    else
5248 #      define PERL_UNUSED_DECL __attribute__((unused))
5249 #    endif
5250 #  else
5251 #    define PERL_UNUSED_DECL
5252 #  endif
5253 #endif
5254
5255 #ifndef PERL_UNUSED_ARG
5256 #  if defined(lint) && defined(S_SPLINT_S) /* www.splint.org */
5257 #    include <note.h>
5258 #    define PERL_UNUSED_ARG(x) NOTE(ARGUNUSED(x))
5259 #  else
5260 #    define PERL_UNUSED_ARG(x) ((void)x)
5261 #  endif
5262 #endif
5263
5264 #ifndef PERL_UNUSED_VAR
5265 #  define PERL_UNUSED_VAR(x) ((void)x)
5266 #endif
5267
5268 #ifndef PERL_UNUSED_CONTEXT
5269 #  ifdef USE_ITHREADS
5270 #    define PERL_UNUSED_CONTEXT PERL_UNUSED_ARG(my_perl)
5271 #  else
5272 #    define PERL_UNUSED_CONTEXT
5273 #  endif
5274 #endif
5275
5276 #ifndef PERL_UNUSED_RESULT
5277 #  if defined(__GNUC__) && defined(HASATTRIBUTE_WARN_UNUSED_RESULT)
5278 #    define PERL_UNUSED_RESULT(v) STMT_START { __typeof__(v) z = (v); (void)sizeof(z); } STMT_END
5279 #  else
5280 #    define PERL_UNUSED_RESULT(v) ((void)(v))
5281 #  endif
5282 #endif
5283 #ifndef NOOP
5284 #  define NOOP                           /*EMPTY*/(void)0
5285 #endif
5286
5287 #ifndef dNOOP
5288 #  define dNOOP                          extern int /*@unused@*/ Perl___notused PERL_UNUSED_DECL
5289 #endif
5290
5291 #ifndef NVTYPE
5292 #  if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE)
5293 #    define NVTYPE long double
5294 #  else
5295 #    define NVTYPE double
5296 #  endif
5297 typedef NVTYPE NV;
5298 #endif
5299
5300 #ifndef INT2PTR
5301 #  if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
5302 #    define PTRV                  UV
5303 #    define INT2PTR(any,d)        (any)(d)
5304 #  else
5305 #    if PTRSIZE == LONGSIZE
5306 #      define PTRV                unsigned long
5307 #    else
5308 #      define PTRV                unsigned
5309 #    endif
5310 #    define INT2PTR(any,d)        (any)(PTRV)(d)
5311 #  endif
5312 #endif
5313
5314 #ifndef PTR2ul
5315 #  if PTRSIZE == LONGSIZE
5316 #    define PTR2ul(p)     (unsigned long)(p)
5317 #  else
5318 #    define PTR2ul(p)     INT2PTR(unsigned long,p)
5319 #  endif
5320 #endif
5321 #ifndef PTR2nat
5322 #  define PTR2nat(p)                     (PTRV)(p)
5323 #endif
5324
5325 #ifndef NUM2PTR
5326 #  define NUM2PTR(any,d)                 (any)PTR2nat(d)
5327 #endif
5328
5329 #ifndef PTR2IV
5330 #  define PTR2IV(p)                      INT2PTR(IV,p)
5331 #endif
5332
5333 #ifndef PTR2UV
5334 #  define PTR2UV(p)                      INT2PTR(UV,p)
5335 #endif
5336
5337 #ifndef PTR2NV
5338 #  define PTR2NV(p)                      NUM2PTR(NV,p)
5339 #endif
5340
5341 #undef START_EXTERN_C
5342 #undef END_EXTERN_C
5343 #undef EXTERN_C
5344 #ifdef __cplusplus
5345 #  define START_EXTERN_C extern "C" {
5346 #  define END_EXTERN_C }
5347 #  define EXTERN_C extern "C"
5348 #else
5349 #  define START_EXTERN_C
5350 #  define END_EXTERN_C
5351 #  define EXTERN_C extern
5352 #endif
5353
5354 #if (PERL_BCDVERSION < 0x5004000) || defined(PERL_GCC_PEDANTIC)
5355 #  ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN
5356 #ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN
5357 #  define PERL_GCC_BRACE_GROUPS_FORBIDDEN
5358 #endif
5359
5360 #  endif
5361 #endif
5362
5363 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) && !defined(__cplusplus)
5364 #  ifndef PERL_USE_GCC_BRACE_GROUPS
5365 #    define PERL_USE_GCC_BRACE_GROUPS
5366 #  endif
5367 #endif
5368
5369 #undef STMT_START
5370 #undef STMT_END
5371 #ifdef PERL_USE_GCC_BRACE_GROUPS
5372 #  define STMT_START    (void)( /* gcc supports ``({ STATEMENTS; })'' */
5373 #  define STMT_END      )
5374 #else
5375 #  if defined(VOIDFLAGS) && (VOIDFLAGS) && (defined(sun) || defined(__sun__)) && !defined(__GNUC__)
5376 #    define STMT_START  if (1)
5377 #    define STMT_END    else (void)0
5378 #  else
5379 #    define STMT_START  do
5380 #    define STMT_END    while (0)
5381 #  endif
5382 #endif
5383 #ifndef boolSV
5384 #  define boolSV(b)                      ((b) ? &PL_sv_yes : &PL_sv_no)
5385 #endif
5386
5387 /* DEFSV appears first in 5.004_56 */
5388 #ifndef DEFSV
5389 #  define DEFSV                          GvSV(PL_defgv)
5390 #endif
5391
5392 #ifndef SAVE_DEFSV
5393 #  define SAVE_DEFSV                     SAVESPTR(GvSV(PL_defgv))
5394 #endif
5395
5396 #ifndef DEFSV_set
5397 #  define DEFSV_set(sv)                  (DEFSV = (sv))
5398 #endif
5399
5400 /* Older perls (<=5.003) lack AvFILLp */
5401 #ifndef AvFILLp
5402 #  define AvFILLp                        AvFILL
5403 #endif
5404 #ifndef av_tindex
5405 #  define av_tindex                      AvFILL
5406 #endif
5407
5408 #ifndef av_top_index
5409 #  define av_top_index                   AvFILL
5410 #endif
5411 #ifndef ERRSV
5412 #  define ERRSV                          get_sv("@",FALSE)
5413 #endif
5414
5415 /* Hint: gv_stashpvn
5416  * This function's backport doesn't support the length parameter, but
5417  * rather ignores it. Portability can only be ensured if the length
5418  * parameter is used for speed reasons, but the length can always be
5419  * correctly computed from the string argument.
5420  */
5421 #ifndef gv_stashpvn
5422 #  define gv_stashpvn(str,len,create)    gv_stashpv(str,create)
5423 #endif
5424
5425 /* Replace: 1 */
5426 #ifndef get_cv
5427 #  define get_cv                         perl_get_cv
5428 #endif
5429
5430 #ifndef get_sv
5431 #  define get_sv                         perl_get_sv
5432 #endif
5433
5434 #ifndef get_av
5435 #  define get_av                         perl_get_av
5436 #endif
5437
5438 #ifndef get_hv
5439 #  define get_hv                         perl_get_hv
5440 #endif
5441
5442 /* Replace: 0 */
5443 #ifndef dUNDERBAR
5444 #  define dUNDERBAR                      dNOOP
5445 #endif
5446
5447 #ifndef UNDERBAR
5448 #  define UNDERBAR                       DEFSV
5449 #endif
5450 #ifndef dAX
5451 #  define dAX                            I32 ax = MARK - PL_stack_base + 1
5452 #endif
5453
5454 #ifndef dITEMS
5455 #  define dITEMS                         I32 items = SP - MARK
5456 #endif
5457 #ifndef dXSTARG
5458 #  define dXSTARG                        SV * targ = sv_newmortal()
5459 #endif
5460 #ifndef dAXMARK
5461 #  define dAXMARK                        I32 ax = POPMARK; \
5462                                register SV ** const mark = PL_stack_base + ax++
5463 #endif
5464 #ifndef XSprePUSH
5465 #  define XSprePUSH                      (sp = PL_stack_base + ax - 1)
5466 #endif
5467
5468 #if (PERL_BCDVERSION < 0x5005000)
5469 #  undef XSRETURN
5470 #  define XSRETURN(off)                                   \
5471       STMT_START {                                        \
5472           PL_stack_sp = PL_stack_base + ax + ((off) - 1); \
5473           return;                                         \
5474       } STMT_END
5475 #endif
5476 #ifndef XSPROTO
5477 #  define XSPROTO(name)                  void name(pTHX_ CV* cv)
5478 #endif
5479
5480 #ifndef SVfARG
5481 #  define SVfARG(p)                      ((void*)(p))
5482 #endif
5483 #ifndef PERL_ABS
5484 #  define PERL_ABS(x)                    ((x) < 0 ? -(x) : (x))
5485 #endif
5486 #ifndef dVAR
5487 #  define dVAR                           dNOOP
5488 #endif
5489 #ifndef SVf
5490 #  define SVf                            "_"
5491 #endif
5492 #ifndef CPERLscope
5493 #  define CPERLscope(x)                  x
5494 #endif
5495 #ifndef PERL_HASH
5496 #  define PERL_HASH(hash,str,len)        \
5497      STMT_START { \
5498         const char *s_PeRlHaSh = str; \
5499         I32 i_PeRlHaSh = len; \
5500         U32 hash_PeRlHaSh = 0; \
5501         while (i_PeRlHaSh--) \
5502             hash_PeRlHaSh = hash_PeRlHaSh * 33 + *s_PeRlHaSh++; \
5503         (hash) = hash_PeRlHaSh; \
5504     } STMT_END
5505 #endif
5506
5507 #ifndef PERLIO_FUNCS_DECL
5508 # ifdef PERLIO_FUNCS_CONST
5509 #  define PERLIO_FUNCS_DECL(funcs) const PerlIO_funcs funcs
5510 #  define PERLIO_FUNCS_CAST(funcs) (PerlIO_funcs*)(funcs)
5511 # else
5512 #  define PERLIO_FUNCS_DECL(funcs) PerlIO_funcs funcs
5513 #  define PERLIO_FUNCS_CAST(funcs) (funcs)
5514 # endif
5515 #endif
5516
5517 /* provide these typedefs for older perls */
5518 #if (PERL_BCDVERSION < 0x5009003)
5519
5520 # ifdef ARGSproto
5521 typedef OP* (CPERLscope(*Perl_ppaddr_t))(ARGSproto);
5522 # else
5523 typedef OP* (CPERLscope(*Perl_ppaddr_t))(pTHX);
5524 # endif
5525
5526 typedef OP* (CPERLscope(*Perl_check_t)) (pTHX_ OP*);
5527
5528 #endif
5529
5530 #ifndef WIDEST_UTYPE
5531 # ifdef QUADKIND
5532 #  ifdef U64TYPE
5533 #   define WIDEST_UTYPE U64TYPE
5534 #  else
5535 #   define WIDEST_UTYPE Quad_t
5536 #  endif
5537 # else
5538 #  define WIDEST_UTYPE U32
5539 # endif
5540 #endif
5541
5542 /* On versions without NATIVE_TO_ASCII, only ASCII is supported */
5543 #if defined(EBCDIC) && defined(NATIVE_TO_ASCI)
5544 #ifndef NATIVE_TO_LATIN1
5545 #  define NATIVE_TO_LATIN1(c)            NATIVE_TO_ASCII(c)
5546 #endif
5547
5548 #ifndef LATIN1_TO_NATIVE
5549 #  define LATIN1_TO_NATIVE(c)            ASCII_TO_NATIVE(c)
5550 #endif
5551
5552 #ifndef NATIVE_TO_UNI
5553 #  define NATIVE_TO_UNI(c)               ((c) > 255 ? (c) : NATIVE_TO_LATIN1(c))
5554 #endif
5555
5556 #ifndef UNI_TO_NATIVE
5557 #  define UNI_TO_NATIVE(c)               ((c) > 255 ? (c) : LATIN1_TO_NATIVE(c))
5558 #endif
5559
5560 #else
5561 #ifndef NATIVE_TO_LATIN1
5562 #  define NATIVE_TO_LATIN1(c)            (c)
5563 #endif
5564
5565 #ifndef LATIN1_TO_NATIVE
5566 #  define LATIN1_TO_NATIVE(c)            (c)
5567 #endif
5568
5569 #ifndef NATIVE_TO_UNI
5570 #  define NATIVE_TO_UNI(c)               (c)
5571 #endif
5572
5573 #ifndef UNI_TO_NATIVE
5574 #  define UNI_TO_NATIVE(c)               (c)
5575 #endif
5576
5577 #endif
5578
5579 /* Warning: LATIN1_TO_NATIVE, NATIVE_TO_LATIN1 NATIVE_TO_UNI UNI_TO_NATIVE
5580    EBCDIC is not supported on versions earlier than 5.7.1
5581  */
5582
5583 /* The meaning of this changed; use the modern version */
5584 #undef isPSXSPC
5585 #undef isPSXSPC_A
5586 #undef isPSXSPC_L1
5587
5588 /* Hint: isPSXSPC, isPSXSPC_A, isPSXSPC_L1, isPSXSPC_utf8_safe
5589     This is equivalent to the corresponding isSPACE-type macro.  On perls
5590     before 5.18, this matched a vertical tab and SPACE didn't.  But the
5591     ppport.h SPACE version does match VT in all perl releases.  Since VT's are
5592     extremely rarely found in real-life files, this difference effectively
5593     doesn't matter */
5594
5595 /* Hint: isSPACE, isSPACE_A, isSPACE_L1, isSPACE_utf8_safe
5596     Until Perl 5.18, this did not match the vertical tab (VT).  The ppport.h
5597     version does match it in all perl releases. Since VT's are extremely rarely
5598     found in real-life files, this difference effectively doesn't matter */
5599
5600 #ifdef EBCDIC
5601
5602 /* This is the first version where these macros are fully correct on EBCDIC
5603  * platforms.  Relying on * the C library functions, as earlier releases did,
5604  * causes problems with * locales */
5605 # if (PERL_BCDVERSION < 0x5022000)
5606 #  undef isALNUM
5607 #  undef isALNUM_A
5608 #  undef isALNUM_L1
5609 #  undef isALNUMC
5610 #  undef isALNUMC_A
5611 #  undef isALNUMC_L1
5612 #  undef isALPHA
5613 #  undef isALPHA_A
5614 #  undef isALPHA_L1
5615 #  undef isALPHANUMERIC
5616 #  undef isALPHANUMERIC_A
5617 #  undef isALPHANUMERIC_L1
5618 #  undef isASCII
5619 #  undef isASCII_A
5620 #  undef isASCII_L1
5621 #  undef isBLANK
5622 #  undef isBLANK_A
5623 #  undef isBLANK_L1
5624 #  undef isCNTRL
5625 #  undef isCNTRL_A
5626 #  undef isCNTRL_L1
5627 #  undef isDIGIT
5628 #  undef isDIGIT_A
5629 #  undef isDIGIT_L1
5630 #  undef isGRAPH
5631 #  undef isGRAPH_A
5632 #  undef isGRAPH_L1
5633 #  undef isIDCONT
5634 #  undef isIDCONT_A
5635 #  undef isIDCONT_L1
5636 #  undef isIDFIRST
5637 #  undef isIDFIRST_A
5638 #  undef isIDFIRST_L1
5639 #  undef isLOWER
5640 #  undef isLOWER_A
5641 #  undef isLOWER_L1
5642 #  undef isOCTAL
5643 #  undef isOCTAL_A
5644 #  undef isOCTAL_L1
5645 #  undef isPRINT
5646 #  undef isPRINT_A
5647 #  undef isPRINT_L1
5648 #  undef isPUNCT
5649 #  undef isPUNCT_A
5650 #  undef isPUNCT_L1
5651 #  undef isSPACE
5652 #  undef isSPACE_A
5653 #  undef isSPACE_L1
5654 #  undef isUPPER
5655 #  undef isUPPER_A
5656 #  undef isUPPER_L1
5657 #  undef isWORDCHAR
5658 #  undef isWORDCHAR_A
5659 #  undef isWORDCHAR_L1
5660 #  undef isXDIGIT
5661 #  undef isXDIGIT_A
5662 #  undef isXDIGIT_L1
5663 # endif
5664 #ifndef isASCII
5665 #  define isASCII(c)                     (isCNTRL(c) || isPRINT(c))
5666 #endif
5667
5668         /* The below is accurate for all EBCDIC code pages supported by
5669          * all the versions of Perl overridden by this */
5670 #ifndef isCNTRL
5671 #  define isCNTRL(c)                     (    (c) == '\0' || (c) == '\a' || (c) == '\b'      \
5672                              ||  (c) == '\f' || (c) == '\n' || (c) == '\r'      \
5673                              ||  (c) == '\t' || (c) == '\v'                     \
5674                              || ((c) <= 3 && (c) >= 1) /* SOH, STX, ETX */      \
5675                              ||  (c) == 7    /* U+7F DEL */                     \
5676                              || ((c) <= 0x13 && (c) >= 0x0E) /* SO, SI */       \
5677                                                       /* DLE, DC[1-3] */        \
5678                              ||  (c) == 0x18 /* U+18 CAN */                     \
5679                              ||  (c) == 0x19 /* U+19 EOM */                     \
5680                              || ((c) <= 0x1F && (c) >= 0x1C) /* [FGRU]S */      \
5681                              ||  (c) == 0x26 /* U+17 ETB */                     \
5682                              ||  (c) == 0x27 /* U+1B ESC */                     \
5683                              ||  (c) == 0x2D /* U+05 ENQ */                     \
5684                              ||  (c) == 0x2E /* U+06 ACK */                     \
5685                              ||  (c) == 0x32 /* U+16 SYN */                     \
5686                              ||  (c) == 0x37 /* U+04 EOT */                     \
5687                              ||  (c) == 0x3C /* U+14 DC4 */                     \
5688                              ||  (c) == 0x3D /* U+15 NAK */                     \
5689                              ||  (c) == 0x3F /* U+1A SUB */                     \
5690                             )
5691 #endif
5692
5693 #if '^' == 106    /* EBCDIC POSIX-BC */
5694 #  define D_PPP_OUTLIER_CONTROL 0x5F
5695 #else   /* EBCDIC 1047 037 */
5696 #  define D_PPP_OUTLIER_CONTROL 0xFF
5697 #endif
5698
5699 /* The controls are everything below blank, plus one outlier */
5700 #ifndef isCNTRL_L1
5701 #  define isCNTRL_L1(c)                  ((WIDEST_UTYPE) (c) < ' '                           \
5702                           || (WIDEST_UTYPE) (c) == D_PPP_OUTLIER_CONTROL)
5703 #endif
5704
5705 /* The ordering of the tests in this and isUPPER are to exclude most characters
5706  * early */
5707 #ifndef isLOWER
5708 #  define isLOWER(c)                     (        (c) >= 'a' && (c) <= 'z'                   \
5709                              &&  (   (c) <= 'i'                                 \
5710                                  || ((c) >= 'j' && (c) <= 'r')                  \
5711                                  ||  (c) >= 's'))
5712 #endif
5713
5714 #ifndef isUPPER
5715 #  define isUPPER(c)                     (        (c) >= 'A' && (c) <= 'Z'                   \
5716                              && (    (c) <= 'I'                                 \
5717                                  || ((c) >= 'J' && (c) <= 'R')                  \
5718                                  ||  (c) >= 'S'))
5719 #endif
5720
5721 #else   /* Above is EBCDIC; below is ASCII */
5722
5723 # if (PERL_BCDVERSION < 0x5004000)
5724 /* The implementation of these in older perl versions can give wrong results if
5725  * the C program locale is set to other than the C locale */
5726 #  undef isALNUM
5727 #  undef isALNUM_A
5728 #  undef isALPHA
5729 #  undef isALPHA_A
5730 #  undef isDIGIT
5731 #  undef isDIGIT_A
5732 #  undef isIDFIRST
5733 #  undef isIDFIRST_A
5734 #  undef isLOWER
5735 #  undef isLOWER_A
5736 #  undef isUPPER
5737 #  undef isUPPER_A
5738 # endif
5739
5740 #  if (PERL_BCDVERSION == 0x5007000) /* this perl made space GRAPH */
5741 #    undef isGRAPH
5742 #  endif
5743
5744 # if (PERL_BCDVERSION < 0x5008000) /* earlier perls omitted DEL */
5745 #  undef isCNTRL
5746 # endif
5747
5748 # if (PERL_BCDVERSION < 0x5010000)
5749 /* earlier perls included all of the isSPACE() characters, which is wrong. The
5750  * version provided by Devel::PPPort always overrides an existing buggy
5751  * version. */
5752 #  undef isPRINT
5753 #  undef isPRINT_A
5754 # endif
5755
5756 # if (PERL_BCDVERSION < 0x5014000)
5757 /* earlier perls always returned true if the parameter was a signed char */
5758 #  undef isASCII
5759 #  undef isASCII_A
5760 # endif
5761
5762 # if (PERL_BCDVERSION < 0x5017008) /* earlier perls didn't include PILCROW, SECTION SIGN */
5763 #  undef isPUNCT_L1
5764 # endif
5765
5766 # if (PERL_BCDVERSION < 0x5013007) /* khw didn't investigate why this failed */
5767 #  undef isALNUMC_L1
5768 #endif
5769
5770 # if (PERL_BCDVERSION < 0x5020000) /* earlier perls didn't include \v */
5771 #  undef isSPACE
5772 #  undef isSPACE_A
5773 #  undef isSPACE_L1
5774
5775 # endif
5776 #ifndef isASCII
5777 #  define isASCII(c)                     ((WIDEST_UTYPE) (c) <= 127)
5778 #endif
5779
5780 #ifndef isCNTRL
5781 #  define isCNTRL(c)                     ((WIDEST_UTYPE) (c) < ' ' || (c) == 127)
5782 #endif
5783
5784 #ifndef isCNTRL_L1
5785 #  define isCNTRL_L1(c)                  (isCNTRL(c) || (   (WIDEST_UTYPE) (c) <= 0x9F  \
5786                                                 && (WIDEST_UTYPE) (c) >= 0x80))
5787 #endif
5788
5789 #ifndef isLOWER
5790 #  define isLOWER(c)                     ((c) >= 'a' && (c) <= 'z')
5791 #endif
5792
5793 #ifndef isUPPER
5794 #  define isUPPER(c)                     ((c) <= 'Z' && (c) >= 'A')
5795 #endif
5796
5797 #endif /* Below are definitions common to EBCDIC and ASCII */
5798 #ifndef isASCII_L1
5799 #  define isASCII_L1(c)                  isASCII(c)
5800 #endif
5801
5802 #ifndef isASCII_LC
5803 #  define isASCII_LC(c)                  isASCII(c)
5804 #endif
5805
5806 #ifndef isALNUM
5807 #  define isALNUM(c)                     isWORDCHAR(c)
5808 #endif
5809
5810 #ifndef isALNUMC
5811 #  define isALNUMC(c)                    isALPHANUMERIC(c)
5812 #endif
5813
5814 #ifndef isALNUMC_L1
5815 #  define isALNUMC_L1(c)                 isALPHANUMERIC_L1(c)
5816 #endif
5817
5818 #ifndef isALPHA
5819 #  define isALPHA(c)                     (isUPPER(c) || isLOWER(c))
5820 #endif
5821
5822 #ifndef isALPHA_L1
5823 #  define isALPHA_L1(c)                  (isUPPER_L1(c) || isLOWER_L1(c))
5824 #endif
5825
5826 #ifndef isALPHANUMERIC
5827 #  define isALPHANUMERIC(c)              (isALPHA(c) || isDIGIT(c))
5828 #endif
5829
5830 #ifndef isALPHANUMERIC_L1
5831 #  define isALPHANUMERIC_L1(c)           (isALPHA_L1(c) || isDIGIT(c))
5832 #endif
5833
5834 #ifndef isALPHANUMERIC_LC
5835 #  define isALPHANUMERIC_LC(c)           (isALPHA_LC(c) || isDIGIT_LC(c))
5836 #endif
5837
5838 #ifndef isBLANK
5839 #  define isBLANK(c)                     ((c) == ' ' || (c) == '\t')
5840 #endif
5841
5842 #ifndef isBLANK_L1
5843 #  define isBLANK_L1(c)                  (    isBLANK(c)                                    \
5844                              || (   (WIDEST_UTYPE) (c) < 256                   \
5845                                  && NATIVE_TO_LATIN1((U8) c) == 0xA0))
5846 #endif
5847
5848 #ifndef isBLANK_LC
5849 #  define isBLANK_LC(c)                  isBLANK(c)
5850 #endif
5851
5852 #ifndef isDIGIT
5853 #  define isDIGIT(c)                     ((c) <= '9' && (c) >= '0')
5854 #endif
5855
5856 #ifndef isDIGIT_L1
5857 #  define isDIGIT_L1(c)                  isDIGIT(c)
5858 #endif
5859
5860 #ifndef isGRAPH
5861 #  define isGRAPH(c)                     (isWORDCHAR(c) || isPUNCT(c))
5862 #endif
5863
5864 #ifndef isGRAPH_L1
5865 #  define isGRAPH_L1(c)                  (   isPRINT_L1(c)                              \
5866                                  && (c) != ' '                                 \
5867                                  && NATIVE_TO_LATIN1((U8) c) != 0xA0)
5868 #endif
5869
5870 #ifndef isIDCONT
5871 #  define isIDCONT(c)                    isWORDCHAR(c)
5872 #endif
5873
5874 #ifndef isIDCONT_L1
5875 #  define isIDCONT_L1(c)                 isWORDCHAR_L1(c)
5876 #endif
5877
5878 #ifndef isIDCONT_LC
5879 #  define isIDCONT_LC(c)                 isWORDCHAR_LC(c)
5880 #endif
5881
5882 #ifndef isIDFIRST
5883 #  define isIDFIRST(c)                   (isALPHA(c) || (c) == '_')
5884 #endif
5885
5886 #ifndef isIDFIRST_L1
5887 #  define isIDFIRST_L1(c)                (isALPHA_L1(c) || (U8) (c) == '_')
5888 #endif
5889
5890 #ifndef isIDFIRST_LC
5891 #  define isIDFIRST_LC(c)                (isALPHA_LC(c) || (U8) (c) == '_')
5892 #endif
5893
5894 #ifndef isLOWER_L1
5895 #  define isLOWER_L1(c)                  (    isLOWER(c)                                    \
5896                              || (   (WIDEST_UTYPE) (c) < 256                   \
5897                                  && (  (   NATIVE_TO_LATIN1((U8) c) >= 0xDF    \
5898                                         && NATIVE_TO_LATIN1((U8) c) != 0xF7)   \
5899                                      || NATIVE_TO_LATIN1((U8) c) == 0xAA       \
5900                                      || NATIVE_TO_LATIN1((U8) c) == 0xBA       \
5901                                      || NATIVE_TO_LATIN1((U8) c) == 0xB5)))
5902 #endif
5903
5904 #ifndef isOCTAL
5905 #  define isOCTAL(c)                     (((WIDEST_UTYPE)((c)) & ~7) == '0')
5906 #endif
5907
5908 #ifndef isOCTAL_L1
5909 #  define isOCTAL_L1(c)                  isOCTAL(c)
5910 #endif
5911
5912 #ifndef isPRINT
5913 #  define isPRINT(c)                     (isGRAPH(c) || (c) == ' ')
5914 #endif
5915
5916 #ifndef isPRINT_L1
5917 #  define isPRINT_L1(c)                  ((WIDEST_UTYPE) (c) < 256 && ! isCNTRL_L1(c))
5918 #endif
5919
5920 #ifndef isPSXSPC
5921 #  define isPSXSPC(c)                    isSPACE(c)
5922 #endif
5923
5924 #ifndef isPSXSPC_L1
5925 #  define isPSXSPC_L1(c)                 isSPACE_L1(c)
5926 #endif
5927
5928 #ifndef isPUNCT
5929 #  define isPUNCT(c)                     (   (c) == '-' || (c) == '!' || (c) == '"'         \
5930                              || (c) == '#' || (c) == '$' || (c) == '%'         \
5931                              || (c) == '&' || (c) == '\'' || (c) == '('        \
5932                              || (c) == ')' || (c) == '*' || (c) == '+'         \
5933                              || (c) == ',' || (c) == '.' || (c) == '/'         \
5934                              || (c) == ':' || (c) == ';' || (c) == '<'         \
5935                              || (c) == '=' || (c) == '>' || (c) == '?'         \
5936                              || (c) == '@' || (c) == '[' || (c) == '\\'        \
5937                              || (c) == ']' || (c) == '^' || (c) == '_'         \
5938                              || (c) == '`' || (c) == '{' || (c) == '|'         \
5939                              || (c) == '}' || (c) == '~')
5940 #endif
5941
5942 #ifndef isPUNCT_L1
5943 #  define isPUNCT_L1(c)                  (    isPUNCT(c)                                   \
5944                               || (   (WIDEST_UTYPE) (c) < 256                  \
5945                                   && (   NATIVE_TO_LATIN1((U8) c) == 0xA1      \
5946                                       || NATIVE_TO_LATIN1((U8) c) == 0xA7      \
5947                                       || NATIVE_TO_LATIN1((U8) c) == 0xAB      \
5948                                       || NATIVE_TO_LATIN1((U8) c) == 0xB6      \
5949                                       || NATIVE_TO_LATIN1((U8) c) == 0xB7      \
5950                                       || NATIVE_TO_LATIN1((U8) c) == 0xBB      \
5951                                       || NATIVE_TO_LATIN1((U8) c) == 0xBF)))
5952 #endif
5953
5954 #ifndef isSPACE
5955 #  define isSPACE(c)                     (   isBLANK(c) || (c) == '\n' || (c) == '\r'   \
5956                                  || (c) == '\v' || (c) == '\f')
5957 #endif
5958
5959 #ifndef isSPACE_L1
5960 #  define isSPACE_L1(c)                  (    isSPACE(c)                                    \
5961                              || (   (WIDEST_UTYPE) (c) < 256                   \
5962                                  && (   NATIVE_TO_LATIN1((U8) c) == 0x85       \
5963                                      || NATIVE_TO_LATIN1((U8) c) == 0xA0)))
5964 #endif
5965
5966 #ifndef isUPPER_L1
5967 #  define isUPPER_L1(c)                  (   isUPPER(c)                                     \
5968                              || (   (WIDEST_UTYPE) (c) < 256                   \
5969                                  && (   NATIVE_TO_LATIN1((U8) c) >= 0xC0       \
5970                                      && NATIVE_TO_LATIN1((U8) c) <= 0xDE       \
5971                                      && NATIVE_TO_LATIN1((U8) c) != 0xD7)))
5972 #endif
5973
5974 #ifndef isWORDCHAR
5975 #  define isWORDCHAR(c)                  (isALPHANUMERIC(c) || (c) == '_')
5976 #endif
5977
5978 #ifndef isWORDCHAR_L1
5979 #  define isWORDCHAR_L1(c)               (isIDFIRST_L1(c) || isDIGIT(c))
5980 #endif
5981
5982 #ifndef isWORDCHAR_LC
5983 #  define isWORDCHAR_LC(c)               (isIDFIRST_LC(c) || isDIGIT_LC(c))
5984 #endif
5985
5986 #ifndef isXDIGIT
5987 #  define isXDIGIT(c)                    (   isDIGIT(c)                                 \
5988                                  || ((c) >= 'a' && (c) <= 'f')                 \
5989                                  || ((c) >= 'A' && (c) <= 'F'))
5990 #endif
5991
5992 #ifndef isXDIGIT_L1
5993 #  define isXDIGIT_L1(c)                 isXDIGIT(c)
5994 #endif
5995
5996 #ifndef isXDIGIT_LC
5997 #  define isXDIGIT_LC(c)                 isxdigit(c)
5998 #endif
5999 #ifndef isALNUM_A
6000 #  define isALNUM_A(c)                   isALNUM(c)
6001 #endif
6002
6003 #ifndef isALNUMC_A
6004 #  define isALNUMC_A(c)                  isALNUMC(c)
6005 #endif
6006
6007 #ifndef isALPHA_A
6008 #  define isALPHA_A(c)                   isALPHA(c)
6009 #endif
6010
6011 #ifndef isALPHANUMERIC_A
6012 #  define isALPHANUMERIC_A(c)            isALPHANUMERIC(c)
6013 #endif
6014
6015 #ifndef isASCII_A
6016 #  define isASCII_A(c)                   isASCII(c)
6017 #endif
6018
6019 #ifndef isBLANK_A
6020 #  define isBLANK_A(c)                   isBLANK(c)
6021 #endif
6022
6023 #ifndef isCNTRL_A
6024 #  define isCNTRL_A(c)                   isCNTRL(c)
6025 #endif
6026
6027 #ifndef isDIGIT_A
6028 #  define isDIGIT_A(c)                   isDIGIT(c)
6029 #endif
6030
6031 #ifndef isGRAPH_A
6032 #  define isGRAPH_A(c)                   isGRAPH(c)
6033 #endif
6034
6035 #ifndef isIDCONT_A
6036 #  define isIDCONT_A(c)                  isIDCONT(c)
6037 #endif
6038
6039 #ifndef isIDFIRST_A
6040 #  define isIDFIRST_A(c)                 isIDFIRST(c)
6041 #endif
6042
6043 #ifndef isLOWER_A
6044 #  define isLOWER_A(c)                   isLOWER(c)
6045 #endif
6046
6047 #ifndef isOCTAL_A
6048 #  define isOCTAL_A(c)                   isOCTAL(c)
6049 #endif
6050
6051 #ifndef isPRINT_A
6052 #  define isPRINT_A(c)                   isPRINT(c)
6053 #endif
6054
6055 #ifndef isPSXSPC_A
6056 #  define isPSXSPC_A(c)                  isPSXSPC(c)
6057 #endif
6058
6059 #ifndef isPUNCT_A
6060 #  define isPUNCT_A(c)                   isPUNCT(c)
6061 #endif
6062
6063 #ifndef isSPACE_A
6064 #  define isSPACE_A(c)                   isSPACE(c)
6065 #endif
6066
6067 #ifndef isUPPER_A
6068 #  define isUPPER_A(c)                   isUPPER(c)
6069 #endif
6070
6071 #ifndef isWORDCHAR_A
6072 #  define isWORDCHAR_A(c)                isWORDCHAR(c)
6073 #endif
6074
6075 #ifndef isXDIGIT_A
6076 #  define isXDIGIT_A(c)                  isXDIGIT(c)
6077 #endif
6078 #ifndef isASCII_utf8_safe
6079 #  define isASCII_utf8_safe(s,e)         (((e) - (s)) <= 0 ? 0 : isASCII(*(s)))
6080 #endif
6081
6082 #ifndef isASCII_uvchr
6083 #  define isASCII_uvchr(c)               ((WIDEST_UTYPE) (c) < 256                 \
6084                                    ? isASCII_L1(c) : 0)
6085 #endif
6086
6087 #if (PERL_BCDVERSION >= 0x5006000)
6088 #ifndef isALPHA_uvchr
6089 #  define isALPHA_uvchr(c)               ((WIDEST_UTYPE) (c) < 256                 \
6090                                    ? isALPHA_L1(c) : is_uni_alpha((UV) (c)))
6091 #endif
6092
6093 #ifndef isALPHANUMERIC_uvchr
6094 #  define isALPHANUMERIC_uvchr(c)        ((WIDEST_UTYPE) (c) < 256                 \
6095     ? isALPHANUMERIC_L1(c) : (is_uni_alpha((UV) (c)) || is_uni_digit((UV) (c))))
6096 #endif
6097
6098 #  ifdef is_uni_blank
6099 #ifndef isBLANK_uvchr
6100 #  define isBLANK_uvchr(c)               ((WIDEST_UTYPE) (c) < 256                 \
6101                                    ? isBLANK_L1(c) : is_uni_blank((UV) (c)))
6102 #endif
6103
6104 #  else
6105 #ifndef isBLANK_uvchr
6106 #  define isBLANK_uvchr(c)               ((WIDEST_UTYPE) (c) < 256                   \
6107                                  ? isBLANK_L1(c)                            \
6108                                  : (   (UV) (c) == 0x1680 /* Unicode 3.0 */ \
6109                                     || inRANGE((UV) (c), 0x2000, 0x200A)    \
6110                                     || (UV) (c) == 0x202F  /* Unicode 3.0 */\
6111                                     || (UV) (c) == 0x205F  /* Unicode 3.2 */\
6112                                     || (UV) (c) == 0x3000))
6113 #endif
6114
6115 #  endif
6116 #ifndef isCNTRL_uvchr
6117 #  define isCNTRL_uvchr(c)               ((WIDEST_UTYPE) (c) < 256                 \
6118                                    ? isCNTRL_L1(c) : is_uni_cntrl((UV) (c)))
6119 #endif
6120
6121 #ifndef isDIGIT_uvchr
6122 #  define isDIGIT_uvchr(c)               ((WIDEST_UTYPE) (c) < 256                 \
6123                                    ? isDIGIT_L1(c) : is_uni_digit((UV) (c)))
6124 #endif
6125
6126 #ifndef isGRAPH_uvchr
6127 #  define isGRAPH_uvchr(c)               ((WIDEST_UTYPE) (c) < 256                 \
6128                                    ? isGRAPH_L1(c) : is_uni_graph((UV) (c)))
6129 #endif
6130
6131 #ifndef isIDCONT_uvchr
6132 #  define isIDCONT_uvchr(c)              isWORDCHAR_uvchr(c)
6133 #endif
6134
6135 #ifndef isIDFIRST_uvchr
6136 #  define isIDFIRST_uvchr(c)             ((WIDEST_UTYPE) (c) < 256                 \
6137                                    ? isIDFIRST_L1(c) : is_uni_idfirst((UV) (c)))
6138 #endif
6139
6140 #ifndef isLOWER_uvchr
6141 #  define isLOWER_uvchr(c)               ((WIDEST_UTYPE) (c) < 256                 \
6142                                    ? isLOWER_L1(c) : is_uni_lower((UV) (c)))
6143 #endif
6144
6145 #ifndef isPRINT_uvchr
6146 #  define isPRINT_uvchr(c)               ((WIDEST_UTYPE) (c) < 256                 \
6147                                    ? isPRINT_L1(c) : is_uni_print((UV) (c)))
6148 #endif
6149
6150 #ifndef isPSXSPC_uvchr
6151 #  define isPSXSPC_uvchr(c)              isSPACE_uvchr(c)
6152 #endif
6153
6154 #ifndef isPUNCT_uvchr
6155 #  define isPUNCT_uvchr(c)               ((WIDEST_UTYPE) (c) < 256                 \
6156                                    ? isPUNCT_L1(c) : is_uni_punct((UV) (c)))
6157 #endif
6158
6159 #ifndef isSPACE_uvchr
6160 #  define isSPACE_uvchr(c)               ((WIDEST_UTYPE) (c) < 256                 \
6161                                    ? isSPACE_L1(c) : is_uni_space((UV) (c)))
6162 #endif
6163
6164 #ifndef isUPPER_uvchr
6165 #  define isUPPER_uvchr(c)               ((WIDEST_UTYPE) (c) < 256                 \
6166                                    ? isUPPER_L1(c) : is_uni_upper((UV) (c)))
6167 #endif
6168
6169 #ifndef isXDIGIT_uvchr
6170 #  define isXDIGIT_uvchr(c)              ((WIDEST_UTYPE) (c) < 256                 \
6171                                    ? isXDIGIT_L1(c) : is_uni_xdigit((UV) (c)))
6172 #endif
6173
6174 #ifndef isWORDCHAR_uvchr
6175 #  define isWORDCHAR_uvchr(c)            ((WIDEST_UTYPE) (c) < 256                 \
6176                                    ? isWORDCHAR_L1(c) : is_uni_alnum((UV) (c)))
6177 #endif
6178 #ifndef isALPHA_utf8_safe
6179 #  define isALPHA_utf8_safe(s,e)         D_PPP_IS_GENERIC_UTF8_SAFE(s, e, ALPHA)
6180 #endif
6181
6182 #  ifdef isALPHANUMERIC_utf8
6183 #ifndef isALPHANUMERIC_utf8_safe
6184 #  define isALPHANUMERIC_utf8_safe(s,e)  \
6185                                 D_PPP_IS_GENERIC_UTF8_SAFE(s, e, ALPHANUMERIC)
6186 #endif
6187
6188 #  else
6189 #ifndef isALPHANUMERIC_utf8_safe
6190 #  define isALPHANUMERIC_utf8_safe(s,e)  \
6191                         (isALPHA_utf8_safe(s,e) || isDIGIT_utf8_safe(s,e))
6192 #endif
6193
6194 #  endif
6195
6196 /* This was broken before 5.18, and just use this instead of worrying about
6197  * which releases the official works on */
6198 #  if 'A' == 65
6199 #ifndef isBLANK_utf8_safe
6200 #  define isBLANK_utf8_safe(s,e)         \
6201 ( ( LIKELY((e) > (s)) ) ?   /* Machine generated */                         \
6202     ( ( 0x09 == ((const U8*)s)[0] || 0x20 == ((const U8*)s)[0] ) ? 1        \
6203     : ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) ?                              \
6204             ( ( 0xC2 == ((const U8*)s)[0] ) ?                               \
6205                 ( ( 0xA0 == ((const U8*)s)[1] ) ? 2 : 0 )                   \
6206             : ( 0xE1 == ((const U8*)s)[0] ) ?                               \
6207                 ( ( ( 0x9A == ((const U8*)s)[1] ) && ( 0x80 == ((const U8*)s)[2] ) ) ? 3 : 0 )\
6208             : ( 0xE2 == ((const U8*)s)[0] ) ?                               \
6209                 ( ( 0x80 == ((const U8*)s)[1] ) ?                           \
6210                     ( ( inRANGE(((const U8*)s)[2], 0x80, 0x8A ) || 0xAF == ((const U8*)s)[2] ) ? 3 : 0 )\
6211                 : ( ( 0x81 == ((const U8*)s)[1] ) && ( 0x9F == ((const U8*)s)[2] ) ) ? 3 : 0 )\
6212             : ( ( ( 0xE3 == ((const U8*)s)[0] ) && ( 0x80 == ((const U8*)s)[1] ) ) && ( 0x80 == ((const U8*)s)[2] ) ) ? 3 : 0 )\
6213         : 0 )                                                               \
6214  : 0 )
6215 #endif
6216
6217 #  elif 'A' == 193  && '^' == 95 /* EBCDIC 1047 */
6218 #ifndef isBLANK_utf8_safe
6219 #  define isBLANK_utf8_safe(s,e)         \
6220 ( ( LIKELY((e) > (s)) ) ?                                                   \
6221     ( ( 0x05 == ((const U8*)s)[0] || 0x40 == ((const U8*)s)[0] ) ? 1        \
6222     : ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) ?                              \
6223             ( ( 0x80 == ((const U8*)s)[0] ) ?                               \
6224                 ( ( 0x41 == ((const U8*)s)[1] ) ? 2 : 0 )                   \
6225             : ( 0xBC == ((const U8*)s)[0] ) ?                               \
6226                 ( ( ( 0x63 == ((const U8*)s)[1] ) && ( 0x41 == ((const U8*)s)[2] ) ) ? 3 : 0 )\
6227             : ( 0xCA == ((const U8*)s)[0] ) ?                               \
6228                 ( ( 0x41 == ((const U8*)s)[1] ) ?                           \
6229                     ( ( inRANGE(((const U8*)s)[2], 0x41, 0x4A ) || 0x51 == ((const U8*)s)[2] ) ? 3 : 0 )\
6230                 : ( 0x42 == ((const U8*)s)[1] ) ?                           \
6231                     ( ( 0x56 == ((const U8*)s)[2] ) ? 3 : 0 )               \
6232                 : ( ( 0x43 == ((const U8*)s)[1] ) && ( 0x73 == ((const U8*)s)[2] ) ) ? 3 : 0 )\
6233             : ( ( ( 0xCE == ((const U8*)s)[0] ) && ( 0x41 == ((const U8*)s)[1] ) ) && ( 0x41 == ((const U8*)s)[2] ) ) ? 3 : 0 )\
6234         : 0 )                                                               \
6235 : 0 )
6236 #endif
6237
6238 #  elif 'A' == 193  && '^' == 176 /* EBCDIC 037 */
6239 #ifndef isBLANK_utf8_safe
6240 #  define isBLANK_utf8_safe(s,e)         \
6241 ( ( LIKELY((e) > (s)) ) ?                                                   \
6242     ( ( 0x05 == ((const U8*)s)[0] || 0x40 == ((const U8*)s)[0] ) ? 1        \
6243     : ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) ?                              \
6244             ( ( 0x78 == ((const U8*)s)[0] ) ?                               \
6245                 ( ( 0x41 == ((const U8*)s)[1] ) ? 2 : 0 )                   \
6246             : ( 0xBD == ((const U8*)s)[0] ) ?                               \
6247                 ( ( ( 0x62 == ((const U8*)s)[1] ) && ( 0x41 == ((const U8*)s)[2] ) ) ? 3 : 0 )\
6248             : ( 0xCA == ((const U8*)s)[0] ) ?                               \
6249                 ( ( 0x41 == ((const U8*)s)[1] ) ?                           \
6250                     ( ( inRANGE(((const U8*)s)[2], 0x41, 0x4A ) || 0x51 == ((const U8*)s)[2] ) ? 3 : 0 )\
6251                 : ( 0x42 == ((const U8*)s)[1] ) ?                           \
6252                     ( ( 0x56 == ((const U8*)s)[2] ) ? 3 : 0 )               \
6253                 : ( ( 0x43 == ((const U8*)s)[1] ) && ( 0x72 == ((const U8*)s)[2] ) ) ? 3 : 0 )\
6254             : ( ( ( 0xCE == ((const U8*)s)[0] ) && ( 0x41 == ((const U8*)s)[1] ) ) && ( 0x41 == ((const U8*)s)[2] ) ) ? 3 : 0 )\
6255         : 0 )                                                               \
6256 : 0 )
6257 #endif
6258
6259 #  else
6260 #    error Unknown character set
6261 #  endif
6262 #ifndef isCNTRL_utf8_safe
6263 #  define isCNTRL_utf8_safe(s,e)         D_PPP_IS_GENERIC_UTF8_SAFE(s, e, CNTRL)
6264 #endif
6265
6266 #ifndef isDIGIT_utf8_safe
6267 #  define isDIGIT_utf8_safe(s,e)         D_PPP_IS_GENERIC_UTF8_SAFE(s, e, DIGIT)
6268 #endif
6269
6270 #ifndef isGRAPH_utf8_safe
6271 #  define isGRAPH_utf8_safe(s,e)         D_PPP_IS_GENERIC_UTF8_SAFE(s, e, GRAPH)
6272 #endif
6273
6274 #  ifdef isIDCONT_utf8
6275 #ifndef isIDCONT_utf8_safe
6276 #  define isIDCONT_utf8_safe(s,e)        D_PPP_IS_GENERIC_UTF8_SAFE(s, e, IDCONT)
6277 #endif
6278
6279 #  else
6280 #ifndef isIDCONT_utf8_safe
6281 #  define isIDCONT_utf8_safe(s,e)        isWORDCHAR_utf8_safe(s,e)
6282 #endif
6283
6284 #  endif
6285 #ifndef isIDFIRST_utf8_safe
6286 #  define isIDFIRST_utf8_safe(s,e)       D_PPP_IS_GENERIC_UTF8_SAFE(s, e, IDFIRST)
6287 #endif
6288
6289 #ifndef isLOWER_utf8_safe
6290 #  define isLOWER_utf8_safe(s,e)         D_PPP_IS_GENERIC_UTF8_SAFE(s, e, LOWER)
6291 #endif
6292
6293 #ifndef isPRINT_utf8_safe
6294 #  define isPRINT_utf8_safe(s,e)         D_PPP_IS_GENERIC_UTF8_SAFE(s, e, PRINT)
6295 #endif
6296
6297 #  undef isPSXSPC_utf8_safe   /* Use the modern definition */
6298 #ifndef isPSXSPC_utf8_safe
6299 #  define isPSXSPC_utf8_safe(s,e)        isSPACE_utf8_safe(s,e)
6300 #endif
6301 #ifndef isPUNCT_utf8_safe
6302 #  define isPUNCT_utf8_safe(s,e)         D_PPP_IS_GENERIC_UTF8_SAFE(s, e, PUNCT)
6303 #endif
6304
6305 #ifndef isSPACE_utf8_safe
6306 #  define isSPACE_utf8_safe(s,e)         D_PPP_IS_GENERIC_UTF8_SAFE(s, e, SPACE)
6307 #endif
6308
6309 #ifndef isUPPER_utf8_safe
6310 #  define isUPPER_utf8_safe(s,e)         D_PPP_IS_GENERIC_UTF8_SAFE(s, e, UPPER)
6311 #endif
6312
6313 #  ifdef isWORDCHAR_utf8
6314 #ifndef isWORDCHAR_utf8_safe
6315 #  define isWORDCHAR_utf8_safe(s,e)      D_PPP_IS_GENERIC_UTF8_SAFE(s, e, WORDCHAR)
6316 #endif
6317
6318 #  else
6319 #ifndef isWORDCHAR_utf8_safe
6320 #  define isWORDCHAR_utf8_safe(s,e)      \
6321                                (isALPHANUMERIC_utf8_safe(s,e) || (*(s)) == '_')
6322 #endif
6323
6324 #  endif
6325
6326 /* This was broken before 5.12, and just use this instead of worrying about
6327  * which releases the official works on */
6328 #  if 'A' == 65
6329 #ifndef isXDIGIT_utf8_safe
6330 #  define isXDIGIT_utf8_safe(s,e)        \
6331 ( ( LIKELY((e) > (s)) ) ?                                                   \
6332     ( ( inRANGE(((const U8*)s)[0], 0x30, 0x39 ) || inRANGE(((const U8*)s)[0], 0x41, 0x46 ) || inRANGE(((const U8*)s)[0], 0x61, 0x66 ) ) ? 1\
6333     : ( ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) && ( 0xEF == ((const U8*)s)[0] ) ) ? ( ( 0xBC == ((const U8*)s)[1] ) ?\
6334                     ( ( inRANGE(((const U8*)s)[2], 0x90, 0x99 ) || inRANGE(((const U8*)s)[2], 0xA1, 0xA6 ) ) ? 3 : 0 )\
6335                 : ( ( 0xBD == ((const U8*)s)[1] ) && ( inRANGE(((const U8*)s)[2], 0x81, 0x86 ) ) ) ? 3 : 0 ) : 0 )\
6336 : 0 )
6337 #endif
6338
6339 #  elif 'A' == 193  && '^' == 95 /* EBCDIC 1047 */
6340 #ifndef isXDIGIT_utf8_safe
6341 #  define isXDIGIT_utf8_safe(s,e)        \
6342 ( ( LIKELY((e) > (s)) ) ?                                                   \
6343     ( ( inRANGE(((const U8*)s)[0], 0x81, 0x86 ) || inRANGE(((const U8*)s)[0], 0xC1, 0xC6 ) || inRANGE(((const U8*)s)[0], 0xF0, 0xF9 ) ) ? 1\
6344     : ( ( ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) && ( 0xDD == ((const U8*)s)[0] ) ) && ( 0x73 == ((const U8*)s)[1] ) ) ? ( ( 0x67 == ((const U8*)s)[2] ) ?\
6345                         ( ( inRANGE(((const U8*)s)[3], 0x57, 0x59 ) || inRANGE(((const U8*)s)[3], 0x62, 0x68 ) ) ? 4 : 0 )\
6346                     : ( ( inRANGE(((const U8*)s)[2], 0x68, 0x69 ) ) && ( inRANGE(((const U8*)s)[3], 0x42, 0x47 ) ) ) ? 4 : 0 ) : 0 )\
6347 : 0 )
6348 #endif
6349
6350 #  elif 'A' == 193  && '^' == 176 /* EBCDIC 037 */
6351 #ifndef isXDIGIT_utf8_safe
6352 #  define isXDIGIT_utf8_safe(s,e)        \
6353 ( ( LIKELY((e) > (s)) ) ?                                                   \
6354     ( ( inRANGE(((const U8*)s)[0], 0x81, 0x86 ) || inRANGE(((const U8*)s)[0], 0xC1, 0xC6 ) || inRANGE(((const U8*)s)[0], 0xF0, 0xF9 ) ) ? 1\
6355     : ( ( ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) && ( 0xDD == ((const U8*)s)[0] ) ) && ( 0x72 == ((const U8*)s)[1] ) ) ? ( ( 0x66 == ((const U8*)s)[2] ) ?\
6356                         ( ( inRANGE(((const U8*)s)[3], 0x57, 0x59 ) || 0x5F == ((const U8*)s)[3] || inRANGE(((const U8*)s)[3], 0x62, 0x67 ) ) ? 4 : 0 )\
6357                     : ( ( inRANGE(((const U8*)s)[2], 0x67, 0x68 ) ) && ( inRANGE(((const U8*)s)[3], 0x42, 0x47 ) ) ) ? 4 : 0 ) : 0 )\
6358 : 0 )
6359 #endif
6360
6361 #  else
6362 #    error Unknown character set
6363 #  endif
6364 #ifndef isALPHA_LC_utf8_safe
6365 #  define isALPHA_LC_utf8_safe(s,e)      D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, ALPHA)
6366 #endif
6367
6368 #  ifdef isALPHANUMERIC_utf8
6369 #ifndef isALPHANUMERIC_LC_utf8_safe
6370 #  define isALPHANUMERIC_LC_utf8_safe(s,e) \
6371                                 D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, ALPHANUMERIC)
6372 #endif
6373
6374 #  else
6375 #ifndef isALPHANUMERIC_LC_utf8_safe
6376 #  define isALPHANUMERIC_LC_utf8_safe(s,e) \
6377                         (isALPHA_LC_utf8_safe(s,e) || isDIGIT_LC_utf8_safe(s,e))
6378 #endif
6379
6380 #  endif
6381 #ifndef isBLANK_LC_utf8_safe
6382 #  define isBLANK_LC_utf8_safe(s,e)      \
6383                             D_PPP_IS_GENERIC_LC_UTF8_SAFE_BROKEN(s, e, BLANK)
6384 #endif
6385
6386 #ifndef isCNTRL_LC_utf8_safe
6387 #  define isCNTRL_LC_utf8_safe(s,e)      D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, CNTRL)
6388 #endif
6389
6390 #ifndef isDIGIT_LC_utf8_safe
6391 #  define isDIGIT_LC_utf8_safe(s,e)      D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, DIGIT)
6392 #endif
6393
6394 #ifndef isGRAPH_LC_utf8_safe
6395 #  define isGRAPH_LC_utf8_safe(s,e)      D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, GRAPH)
6396 #endif
6397
6398 #  ifdef isIDCONT_utf8
6399 #ifndef isIDCONT_LC_utf8_safe
6400 #  define isIDCONT_LC_utf8_safe(s,e)     D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, IDCONT)
6401 #endif
6402
6403 #  else
6404 #ifndef isIDCONT_LC_utf8_safe
6405 #  define isIDCONT_LC_utf8_safe(s,e)     isWORDCHAR_LC_utf8_safe(s,e)
6406 #endif
6407
6408 #  endif
6409 #ifndef isIDFIRST_LC_utf8_safe
6410 #  define isIDFIRST_LC_utf8_safe(s,e)    D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, IDFIRST)
6411 #endif
6412
6413 #ifndef isLOWER_LC_utf8_safe
6414 #  define isLOWER_LC_utf8_safe(s,e)      D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, LOWER)
6415 #endif
6416
6417 #ifndef isPRINT_LC_utf8_safe
6418 #  define isPRINT_LC_utf8_safe(s,e)      D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, PRINT)
6419 #endif
6420
6421 #  undef isPSXSPC_LC_utf8_safe   /* Use the modern definition */
6422 #ifndef isPSXSPC_LC_utf8_safe
6423 #  define isPSXSPC_LC_utf8_safe(s,e)     isSPACE_LC_utf8_safe(s,e)
6424 #endif
6425 #ifndef isPUNCT_LC_utf8_safe
6426 #  define isPUNCT_LC_utf8_safe(s,e)      D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, PUNCT)
6427 #endif
6428
6429 #ifndef isSPACE_LC_utf8_safe
6430 #  define isSPACE_LC_utf8_safe(s,e)      D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, SPACE)
6431 #endif
6432
6433 #ifndef isUPPER_LC_utf8_safe
6434 #  define isUPPER_LC_utf8_safe(s,e)      D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, UPPER)
6435 #endif
6436
6437 #  ifdef isWORDCHAR_utf8
6438 #ifndef isWORDCHAR_LC_utf8_safe
6439 #  define isWORDCHAR_LC_utf8_safe(s,e)   D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, WORDCHAR)
6440 #endif
6441
6442 #  else
6443 #ifndef isWORDCHAR_LC_utf8_safe
6444 #  define isWORDCHAR_LC_utf8_safe(s,e)   \
6445                                (isALPHANUMERIC_LC_utf8_safe(s,e) || (*(s)) == '_')
6446 #endif
6447
6448 #  endif
6449 #ifndef isXDIGIT_LC_utf8_safe
6450 #  define isXDIGIT_LC_utf8_safe(s,e)     \
6451                             D_PPP_IS_GENERIC_LC_UTF8_SAFE_BROKEN(s, e, XDIGIT)
6452 #endif
6453
6454 /* Warning: isALPHANUMERIC_utf8_safe, isALPHA_utf8_safe, isASCII_utf8_safe,
6455  * isBLANK_utf8_safe, isCNTRL_utf8_safe, isDIGIT_utf8_safe, isGRAPH_utf8_safe,
6456  * isIDCONT_utf8_safe, isIDFIRST_utf8_safe, isLOWER_utf8_safe,
6457  * isPRINT_utf8_safe, isPSXSPC_utf8_safe, isPUNCT_utf8_safe, isSPACE_utf8_safe,
6458  * isUPPER_utf8_safe, isWORDCHAR_utf8_safe, isWORDCHAR_utf8_safe,
6459  * isXDIGIT_utf8_safe,
6460  * isALPHANUMERIC_LC_utf8_safe, isALPHA_LC_utf8_safe, isASCII_LC_utf8_safe,
6461  * isBLANK_LC_utf8_safe, isCNTRL_LC_utf8_safe, isDIGIT_LC_utf8_safe,
6462  * isGRAPH_LC_utf8_safe, isIDCONT_LC_utf8_safe, isIDFIRST_LC_utf8_safe,
6463  * isLOWER_LC_utf8_safe, isPRINT_LC_utf8_safe, isPSXSPC_LC_utf8_safe,
6464  * isPUNCT_LC_utf8_safe, isSPACE_LC_utf8_safe, isUPPER_LC_utf8_safe,
6465  * isWORDCHAR_LC_utf8_safe, isWORDCHAR_LC_utf8_safe, isXDIGIT_LC_utf8_safe,
6466  * isALPHANUMERIC_uvchr, isALPHA_uvchr, isASCII_uvchr, isBLANK_uvchr,
6467  * isCNTRL_uvchr, isDIGIT_uvchr, isGRAPH_uvchr, isIDCONT_uvchr,
6468  * isIDFIRST_uvchr, isLOWER_uvchr, isPRINT_uvchr, isPSXSPC_uvchr,
6469  * isPUNCT_uvchr, isSPACE_uvchr, isUPPER_uvchr, isWORDCHAR_uvchr,
6470  * isWORDCHAR_uvchr, isXDIGIT_uvchr
6471  *
6472  * The UTF-8 handling is buggy in early Perls, and this can give inaccurate
6473  * results for code points above 0xFF, until the implementation started
6474  * settling down in 5.12 and 5.14 */
6475
6476 #endif
6477
6478 #define D_PPP_TOO_SHORT_MSG  "Malformed UTF-8 character starting with:"      \
6479                              " \\x%02x (too short; %d bytes available, need" \
6480                              " %d)\n"
6481 /* Perls starting here had a new API which handled multi-character results */
6482 #if (PERL_BCDVERSION >= 0x5007003)
6483 #ifndef toLOWER_uvchr
6484 #  define toLOWER_uvchr(c, s, l)         UNI_TO_NATIVE(to_uni_lower(NATIVE_TO_UNI(c), s, l))
6485 #endif
6486
6487 #ifndef toUPPER_uvchr
6488 #  define toUPPER_uvchr(c, s, l)         UNI_TO_NATIVE(to_uni_upper(NATIVE_TO_UNI(c), s, l))
6489 #endif
6490
6491 #ifndef toTITLE_uvchr
6492 #  define toTITLE_uvchr(c, s, l)         UNI_TO_NATIVE(to_uni_title(NATIVE_TO_UNI(c), s, l))
6493 #endif
6494
6495 #ifndef toFOLD_uvchr
6496 #  define toFOLD_uvchr(c, s, l)          UNI_TO_NATIVE(to_uni_fold( NATIVE_TO_UNI(c), s, l))
6497 #endif
6498
6499 #  if (PERL_BCDVERSION != 0x5015006)     /* Just this version is broken */
6500
6501       /* Prefer the macro to the function */
6502 #    if defined toLOWER_utf8
6503 #      define D_PPP_TO_LOWER_CALLEE(s,r,l)    toLOWER_utf8(s,r,l)
6504 #    else
6505 #      define D_PPP_TO_LOWER_CALLEE(s,r,l)    to_utf8_lower(s,r,l)
6506 #    endif
6507 #    if defined toTITLE_utf8
6508 #      define D_PPP_TO_TITLE_CALLEE(s,r,l)    toTITLE_utf8(s,r,l)
6509 #    else
6510 #      define D_PPP_TO_TITLE_CALLEE(s,r,l)    to_utf8_title(s,r,l)
6511 #    endif
6512 #    if defined toUPPER_utf8
6513 #      define D_PPP_TO_UPPER_CALLEE(s,r,l)    toUPPER_utf8(s,r,l)
6514 #    else
6515 #      define D_PPP_TO_UPPER_CALLEE(s,r,l)    to_utf8_upper(s,r,l)
6516 #    endif
6517 #    if defined toFOLD_utf8
6518 #      define D_PPP_TO_FOLD_CALLEE(s,r,l)     toFOLD_utf8(s,r,l)
6519 #    else
6520 #      define D_PPP_TO_FOLD_CALLEE(s,r,l)     to_utf8_fold(s,r,l)
6521 #    endif
6522 #  else     /* Below is 5.15.6, which failed to make the macros available
6523 #              outside of core, so we have to use the 'Perl_' form.  khw
6524 #              decided it was easier to just handle this case than have to
6525 #              document the exception, and make an exception in the tests below
6526 #              */
6527 #    define D_PPP_TO_LOWER_CALLEE(s,r,l)                                    \
6528                         Perl__to_utf8_lower_flags(aTHX_ s, r, l, 0, NULL)
6529 #    define D_PPP_TO_TITLE_CALLEE(s,r,l)                                    \
6530                         Perl__to_utf8_title_flags(aTHX_ s, r, l, 0, NULL)
6531 #    define D_PPP_TO_UPPER_CALLEE(s,r,l)                                    \
6532                         Perl__to_utf8_upper_flags(aTHX_ s, r, l, 0, NULL)
6533 #    define D_PPP_TO_FOLD_CALLEE(s,r,l)                                     \
6534             Perl__to_utf8_fold_flags(aTHX_ s, r, l, FOLD_FLAGS_FULL, NULL)
6535 #  endif
6536
6537 /* The actual implementation of the backported macros.  If too short, croak,
6538  * otherwise call the original that doesn't have an upper limit parameter */
6539 #  define D_PPP_GENERIC_MULTI_ARG_TO(name, s, e,r,l)                        \
6540     (((((e) - (s)) <= 0)                                                    \
6541          /* We could just do nothing, but modern perls croak */             \
6542       ? (croak("Attempting case change on zero length string"),             \
6543          0) /* So looks like it returns something, and will compile */      \
6544       : ((e) - (s)) < UTF8SKIP(s))                                          \
6545         ? (croak(D_PPP_TOO_SHORT_MSG,                                       \
6546                                s[0], (int) ((e) - (s)), (int) UTF8SKIP(s)), \
6547            0)                                                               \
6548         : D_PPP_TO_ ## name ## _CALLEE(s,r,l))
6549 #ifndef toUPPER_utf8_safe
6550 #  define toUPPER_utf8_safe(s,e,r,l)     \
6551                         D_PPP_GENERIC_MULTI_ARG_TO(UPPER,s,e,r,l)
6552 #endif
6553
6554 #ifndef toLOWER_utf8_safe
6555 #  define toLOWER_utf8_safe(s,e,r,l)     \
6556                         D_PPP_GENERIC_MULTI_ARG_TO(LOWER,s,e,r,l)
6557 #endif
6558
6559 #ifndef toTITLE_utf8_safe
6560 #  define toTITLE_utf8_safe(s,e,r,l)     \
6561                         D_PPP_GENERIC_MULTI_ARG_TO(TITLE,s,e,r,l)
6562 #endif
6563
6564 #ifndef toFOLD_utf8_safe
6565 #  define toFOLD_utf8_safe(s,e,r,l)      \
6566                         D_PPP_GENERIC_MULTI_ARG_TO(FOLD,s,e,r,l)
6567 #endif
6568
6569 #elif (PERL_BCDVERSION >= 0x5006000)
6570
6571 /* Here we have UTF-8 support, but using the original API where the case
6572  * changing functions merely returned the changed code point; hence they
6573  * couldn't handle multi-character results. */
6574
6575 #  ifdef uvchr_to_utf8
6576 #    define D_PPP_UV_TO_UTF8 uvchr_to_utf8
6577 #  else
6578 #    define D_PPP_UV_TO_UTF8 uv_to_utf8
6579 #  endif
6580
6581    /* Get the utf8 of the case changed value, and store its length; then have
6582     * to re-calculate the changed case value in order to return it */
6583 #  define D_PPP_GENERIC_SINGLE_ARG_TO_UVCHR(name, c, s, l)                  \
6584         (*(l) = (D_PPP_UV_TO_UTF8(s,                                        \
6585                  UNI_TO_NATIVE(to_uni_ ## name(NATIVE_TO_UNI(c)))) - (s)),  \
6586         UNI_TO_NATIVE(to_uni_ ## name(NATIVE_TO_UNI(c))))
6587 #ifndef toLOWER_uvchr
6588 #  define toLOWER_uvchr(c, s, l)         \
6589                         D_PPP_GENERIC_SINGLE_ARG_TO_UVCHR(lower, c, s, l)
6590 #endif
6591
6592 #ifndef toUPPER_uvchr
6593 #  define toUPPER_uvchr(c, s, l)         \
6594                         D_PPP_GENERIC_SINGLE_ARG_TO_UVCHR(upper, c, s, l)
6595 #endif
6596
6597 #ifndef toTITLE_uvchr
6598 #  define toTITLE_uvchr(c, s, l)         \
6599                         D_PPP_GENERIC_SINGLE_ARG_TO_UVCHR(title, c, s, l)
6600 #endif
6601
6602 #ifndef toFOLD_uvchr
6603 #  define toFOLD_uvchr(c, s, l)          toLOWER_uvchr(c, s, l)
6604 #endif
6605
6606 #  define D_PPP_GENERIC_SINGLE_ARG_TO_UTF8(name, s, e, r, l)                \
6607     (((((e) - (s)) <= 0)                                                    \
6608       ? (croak("Attempting case change on zero length string"),             \
6609          0) /* So looks like it returns something, and will compile */      \
6610       : ((e) - (s)) < UTF8SKIP(s))                                          \
6611         ? (croak(D_PPP_TOO_SHORT_MSG,                                       \
6612                                s[0], (int) ((e) - (s)), (int) UTF8SKIP(s)), \
6613            0)                                                               \
6614           /* Get the changed code point and store its UTF-8 */              \
6615         : D_PPP_UV_TO_UTF8(r, to_utf8_ ## name(s)),                         \
6616             /* Then store its length, and re-get code point for return */   \
6617             *(l) = UTF8SKIP(r), to_utf8_ ## name(r))
6618
6619 /* Warning: toUPPER_utf8_safe, toLOWER_utf8_safe, toTITLE_utf8_safe,
6620  * toUPPER_uvchr, toLOWER_uvchr, toTITLE_uvchr
6621     The UTF-8 case changing operations had bugs before around 5.12 or 5.14;
6622     this backport does not correct them.
6623
6624     In perls before 7.3, multi-character case changing is not implemented; this
6625     backport uses the simple case changes available in those perls. */
6626 #ifndef toUPPER_utf8_safe
6627 #  define toUPPER_utf8_safe(s,e,r,l)     \
6628                         D_PPP_GENERIC_SINGLE_ARG_TO_UTF8(upper, s, e, r, l)
6629 #endif
6630
6631 #ifndef toLOWER_utf8_safe
6632 #  define toLOWER_utf8_safe(s,e,r,l)     \
6633                         D_PPP_GENERIC_SINGLE_ARG_TO_UTF8(lower, s, e, r, l)
6634 #endif
6635
6636 #ifndef toTITLE_utf8_safe
6637 #  define toTITLE_utf8_safe(s,e,r,l)     \
6638                         D_PPP_GENERIC_SINGLE_ARG_TO_UTF8(title, s, e, r, l)
6639 #endif
6640
6641  /* Warning: toFOLD_utf8_safe, toFOLD_uvchr
6642     The UTF-8 case changing operations had bugs before around 5.12 or 5.14;
6643     this backport does not correct them.
6644
6645     In perls before 7.3, case folding is not implemented; instead, this
6646     backport substitutes simple (not multi-character, which isn't available)
6647     lowercasing.  This gives the correct result in most, but not all, instances
6648     */
6649 #ifndef toFOLD_utf8_safe
6650 #  define toFOLD_utf8_safe(s,e,r,l)      toLOWER_utf8_safe(s,e,r,l)
6651 #endif
6652
6653 #endif
6654
6655 /* Until we figure out how to support this in older perls... */
6656 #if (PERL_BCDVERSION >= 0x5008000)
6657 #ifndef HeUTF8
6658 #  define HeUTF8(he)                     ((HeKLEN(he) == HEf_SVKEY) ?            \
6659                                  SvUTF8(HeKEY_sv(he)) :                 \
6660                                  (U32)HeKUTF8(he))
6661 #endif
6662
6663 #endif
6664 #ifndef C_ARRAY_LENGTH
6665 #  define C_ARRAY_LENGTH(a)              (sizeof(a)/sizeof((a)[0]))
6666 #endif
6667
6668 #ifndef C_ARRAY_END
6669 #  define C_ARRAY_END(a)                 ((a) + C_ARRAY_LENGTH(a))
6670 #endif
6671 #ifndef LIKELY
6672 #  define LIKELY(x)                      (x)
6673 #endif
6674
6675 #ifndef UNLIKELY
6676 #  define UNLIKELY(x)                    (x)
6677 #endif
6678
6679 #ifndef MUTABLE_PTR
6680 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
6681 #  define MUTABLE_PTR(p) ({ void *_p = (p); _p; })
6682 #else
6683 #  define MUTABLE_PTR(p) ((void *) (p))
6684 #endif
6685 #endif
6686 #ifndef MUTABLE_SV
6687 #  define MUTABLE_SV(p)                  ((SV *)MUTABLE_PTR(p))
6688 #endif
6689
6690 #if (PERL_BCDVERSION >= 0x5004000) && !defined(vnewSVpvf)
6691 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
6692 #  define vnewSVpvf(pat, args) ({ SV *_sv = newSV(0); sv_vsetpvfn(_sv, (pat), strlen((pat)), (args), Null(SV**), 0, Null(bool*)); _sv; })
6693 #else
6694 #  define vnewSVpvf(pat, args) ((PL_Sv = newSV(0)), sv_vsetpvfn(PL_Sv, (pat), strlen((pat)), (args), Null(SV**), 0, Null(bool*)), PL_Sv)
6695 #endif
6696 #endif
6697
6698 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf)
6699 #  define sv_vcatpvf(sv, pat, args)  sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
6700 #endif
6701
6702 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf)
6703 #  define sv_vsetpvf(sv, pat, args)  sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
6704 #endif
6705
6706 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg)
6707 #if defined(NEED_sv_catpvf_mg)
6708 static void DPPP_(my_sv_catpvf_mg)(pTHX_ SV * const sv, const char * const pat, ...);
6709 static
6710 #else
6711 extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV * const sv, const char * const pat, ...);
6712 #endif
6713
6714 #if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL)
6715
6716 #define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg)
6717
6718
6719 void
6720 DPPP_(my_sv_catpvf_mg)(pTHX_ SV * const sv, const char * const pat, ...)
6721 {
6722   va_list args;
6723   va_start(args, pat);
6724   sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
6725   SvSETMAGIC(sv);
6726   va_end(args);
6727 }
6728
6729 #endif
6730 #endif
6731
6732 #ifdef PERL_IMPLICIT_CONTEXT
6733 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg_nocontext)
6734 #if defined(NEED_sv_catpvf_mg_nocontext)
6735 static void DPPP_(my_sv_catpvf_mg_nocontext)(SV * const sv, const char * const pat, ...);
6736 static
6737 #else
6738 extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV * const sv, const char * const pat, ...);
6739 #endif
6740
6741 #if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL)
6742
6743 #define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
6744 #define Perl_sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
6745
6746
6747 void
6748 DPPP_(my_sv_catpvf_mg_nocontext)(SV * const sv, const char * const pat, ...)
6749 {
6750   dTHX;
6751   va_list args;
6752   va_start(args, pat);
6753   sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
6754   SvSETMAGIC(sv);
6755   va_end(args);
6756 }
6757
6758 #endif
6759 #endif
6760 #endif
6761
6762 /* sv_catpvf_mg depends on sv_catpvf_mg_nocontext */
6763 #ifndef sv_catpvf_mg
6764 #  ifdef PERL_IMPLICIT_CONTEXT
6765 #    define sv_catpvf_mg   Perl_sv_catpvf_mg_nocontext
6766 #  else
6767 #    define sv_catpvf_mg   Perl_sv_catpvf_mg
6768 #  endif
6769 #endif
6770
6771 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf_mg)
6772 #  define sv_vcatpvf_mg(sv, pat, args)                                     \
6773    STMT_START {                                                            \
6774      sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));  \
6775      SvSETMAGIC(sv);                                                       \
6776    } STMT_END
6777 #endif
6778
6779 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg)
6780 #if defined(NEED_sv_setpvf_mg)
6781 static void DPPP_(my_sv_setpvf_mg)(pTHX_ SV * const sv, const char * const pat, ...);
6782 static
6783 #else
6784 extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV * const sv, const char * const pat, ...);
6785 #endif
6786
6787 #if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL)
6788
6789 #define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg)
6790
6791
6792 void
6793 DPPP_(my_sv_setpvf_mg)(pTHX_ SV * const sv, const char * const pat, ...)
6794 {
6795   va_list args;
6796   va_start(args, pat);
6797   sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
6798   SvSETMAGIC(sv);
6799   va_end(args);
6800 }
6801
6802 #endif
6803 #endif
6804
6805 #ifdef PERL_IMPLICIT_CONTEXT
6806 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg_nocontext)
6807 #if defined(NEED_sv_setpvf_mg_nocontext)
6808 static void DPPP_(my_sv_setpvf_mg_nocontext)(SV * const sv, const char * const pat, ...);
6809 static
6810 #else
6811 extern void DPPP_(my_sv_setpvf_mg_nocontext)(SV * const sv, const char * const pat, ...);
6812 #endif
6813
6814 #if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL)
6815
6816 #define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)
6817 #define Perl_sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)
6818
6819
6820 void
6821 DPPP_(my_sv_setpvf_mg_nocontext)(SV * const sv, const char * const pat, ...)
6822 {
6823   dTHX;
6824   va_list args;
6825   va_start(args, pat);
6826   sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
6827   SvSETMAGIC(sv);
6828   va_end(args);
6829 }
6830
6831 #endif
6832 #endif
6833 #endif
6834
6835 /* sv_setpvf_mg depends on sv_setpvf_mg_nocontext */
6836 #ifndef sv_setpvf_mg
6837 #  ifdef PERL_IMPLICIT_CONTEXT
6838 #    define sv_setpvf_mg   Perl_sv_setpvf_mg_nocontext
6839 #  else
6840 #    define sv_setpvf_mg   Perl_sv_setpvf_mg
6841 #  endif
6842 #endif
6843
6844 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf_mg)
6845 #  define sv_vsetpvf_mg(sv, pat, args)                                     \
6846    STMT_START {                                                            \
6847      sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));  \
6848      SvSETMAGIC(sv);                                                       \
6849    } STMT_END
6850 #endif
6851
6852 /* Hint: sv_2pv_nolen
6853  * Use the SvPV_nolen() or SvPV_nolen_const() macros instead of sv_2pv_nolen().
6854  */
6855 #ifndef sv_2pv_nolen
6856 #  define sv_2pv_nolen(sv)               SvPV_nolen(sv)
6857 #endif
6858
6859 #ifdef SvPVbyte
6860
6861 /* Hint: SvPVbyte
6862  * Does not work in perl-5.6.1, ppport.h implements a version
6863  * borrowed from perl-5.7.3.
6864  */
6865
6866 #if (PERL_BCDVERSION < 0x5007000)
6867 #ifndef sv_2pvbyte
6868 #  define sv_2pvbyte(sv, lp)             (sv_utf8_downgrade((sv), 0), SvPV((sv), *(lp)))
6869 #endif
6870
6871 /* Hint: sv_2pvbyte
6872  * Use the SvPVbyte() macro instead of sv_2pvbyte().
6873  */
6874
6875 /* Replace sv_2pvbyte with SvPVbyte */
6876
6877 #undef SvPVbyte
6878
6879 #define SvPVbyte(sv, lp)                                                \
6880         ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK)                \
6881          ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp))
6882
6883 #endif
6884
6885 #else
6886
6887 #  define SvPVbyte          SvPV
6888 #  define sv_2pvbyte        sv_2pv
6889
6890 #endif
6891 #ifndef sv_2pvbyte_nolen
6892 #  define sv_2pvbyte_nolen(sv)           sv_2pv_nolen(sv)
6893 #endif
6894
6895 /* Hint: sv_pvn
6896  * Always use the SvPV() macro instead of sv_pvn().
6897  */
6898
6899 /* Replace sv_pvn with SvPV */
6900
6901 /* Hint: sv_pvn_force
6902  * Always use the SvPV_force() macro instead of sv_pvn_force().
6903  */
6904
6905 /* Replace sv_pvn_force with SvPV_force */
6906
6907 /* If these are undefined, they're not handled by the core anyway */
6908 #ifndef SV_IMMEDIATE_UNREF
6909 #  define SV_IMMEDIATE_UNREF             0
6910 #endif
6911
6912 #ifndef SV_GMAGIC
6913 #  define SV_GMAGIC                      0
6914 #endif
6915
6916 #ifndef SV_COW_DROP_PV
6917 #  define SV_COW_DROP_PV                 0
6918 #endif
6919
6920 #ifndef SV_UTF8_NO_ENCODING
6921 #  define SV_UTF8_NO_ENCODING            0
6922 #endif
6923
6924 #ifndef SV_CONST_RETURN
6925 #  define SV_CONST_RETURN                0
6926 #endif
6927
6928 #ifndef SV_MUTABLE_RETURN
6929 #  define SV_MUTABLE_RETURN              0
6930 #endif
6931
6932 #ifndef SV_SMAGIC
6933 #  define SV_SMAGIC                      0
6934 #endif
6935
6936 #ifndef SV_HAS_TRAILING_NUL
6937 #  define SV_HAS_TRAILING_NUL            0
6938 #endif
6939
6940 #ifndef SV_COW_SHARED_HASH_KEYS
6941 #  define SV_COW_SHARED_HASH_KEYS        0
6942 #endif
6943
6944 #if (PERL_BCDVERSION < 0x5007002)
6945 #ifndef sv_2pv_flags
6946 #  define sv_2pv_flags(sv, lp, flags)    sv_2pv((sv), (lp) ? (lp) : &PL_na)
6947 #endif
6948
6949 #ifndef sv_pvn_force_flags
6950 #  define sv_pvn_force_flags(sv, lp, flags) sv_pvn_force((sv), (lp) ? (lp) : &PL_na)
6951 #endif
6952
6953 #endif
6954
6955 #if (PERL_BCDVERSION < 0x5008008) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009003) )
6956 # define D_PPP_SVPV_NOLEN_LP_ARG &PL_na
6957 #else
6958 # define D_PPP_SVPV_NOLEN_LP_ARG 0
6959 #endif
6960 #ifndef SvPV_const
6961 #  define SvPV_const(sv, lp)             SvPV_flags_const(sv, lp, SV_GMAGIC)
6962 #endif
6963
6964 #ifndef SvPV_mutable
6965 #  define SvPV_mutable(sv, lp)           SvPV_flags_mutable(sv, lp, SV_GMAGIC)
6966 #endif
6967 #ifndef SvPV_flags
6968 #  define SvPV_flags(sv, lp, flags)      \
6969                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
6970                   ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags))
6971 #endif
6972 #ifndef SvPV_flags_const
6973 #  define SvPV_flags_const(sv, lp, flags) \
6974                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
6975                   ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \
6976                   (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN))
6977 #endif
6978 #ifndef SvPV_flags_const_nolen
6979 #  define SvPV_flags_const_nolen(sv, flags) \
6980                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
6981                   ? SvPVX_const(sv) : \
6982                   (const char*) sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, flags|SV_CONST_RETURN))
6983 #endif
6984 #ifndef SvPV_flags_mutable
6985 #  define SvPV_flags_mutable(sv, lp, flags) \
6986                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
6987                   ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \
6988                   sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
6989 #endif
6990 #ifndef SvPV_force
6991 #  define SvPV_force(sv, lp)             SvPV_force_flags(sv, lp, SV_GMAGIC)
6992 #endif
6993
6994 #ifndef SvPV_force_nolen
6995 #  define SvPV_force_nolen(sv)           SvPV_force_flags_nolen(sv, SV_GMAGIC)
6996 #endif
6997
6998 #ifndef SvPV_force_mutable
6999 #  define SvPV_force_mutable(sv, lp)     SvPV_force_flags_mutable(sv, lp, SV_GMAGIC)
7000 #endif
7001
7002 #ifndef SvPV_force_nomg
7003 #  define SvPV_force_nomg(sv, lp)        SvPV_force_flags(sv, lp, 0)
7004 #endif
7005
7006 #ifndef SvPV_force_nomg_nolen
7007 #  define SvPV_force_nomg_nolen(sv)      SvPV_force_flags_nolen(sv, 0)
7008 #endif
7009 #ifndef SvPV_force_flags
7010 #  define SvPV_force_flags(sv, lp, flags) \
7011                  ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
7012                  ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags))
7013 #endif
7014 #ifndef SvPV_force_flags_nolen
7015 #  define SvPV_force_flags_nolen(sv, flags) \
7016                  ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
7017                  ? SvPVX(sv) : sv_pvn_force_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, flags))
7018 #endif
7019 #ifndef SvPV_force_flags_mutable
7020 #  define SvPV_force_flags_mutable(sv, lp, flags) \
7021                  ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
7022                  ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \
7023                   : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
7024 #endif
7025 #ifndef SvPV_nolen
7026 #  define SvPV_nolen(sv)                 \
7027                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
7028                   ? SvPVX(sv) : sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC))
7029 #endif
7030 #ifndef SvPV_nolen_const
7031 #  define SvPV_nolen_const(sv)           \
7032                  ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
7033                   ? SvPVX_const(sv) : sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC|SV_CONST_RETURN))
7034 #endif
7035 #ifndef SvPV_nomg
7036 #  define SvPV_nomg(sv, lp)              SvPV_flags(sv, lp, 0)
7037 #endif
7038
7039 #ifndef SvPV_nomg_const
7040 #  define SvPV_nomg_const(sv, lp)        SvPV_flags_const(sv, lp, 0)
7041 #endif
7042
7043 #ifndef SvPV_nomg_const_nolen
7044 #  define SvPV_nomg_const_nolen(sv)      SvPV_flags_const_nolen(sv, 0)
7045 #endif
7046
7047 #ifndef SvPV_nomg_nolen
7048 #  define SvPV_nomg_nolen(sv)            ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
7049                                     ? SvPVX(sv) : sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, 0))
7050 #endif
7051 #ifndef SvPV_renew
7052 #  define SvPV_renew(sv,n)               STMT_START { SvLEN_set(sv, n); \
7053                  SvPV_set((sv), (char *) saferealloc(          \
7054                        (Malloc_t)SvPVX(sv), (MEM_SIZE)((n)))); \
7055                } STMT_END
7056 #endif
7057 #ifndef WARN_ALL
7058 #  define WARN_ALL                       0
7059 #endif
7060
7061 #ifndef WARN_CLOSURE
7062 #  define WARN_CLOSURE                   1
7063 #endif
7064
7065 #ifndef WARN_DEPRECATED
7066 #  define WARN_DEPRECATED                2
7067 #endif
7068
7069 #ifndef WARN_EXITING
7070 #  define WARN_EXITING                   3
7071 #endif
7072
7073 #ifndef WARN_GLOB
7074 #  define WARN_GLOB                      4
7075 #endif
7076
7077 #ifndef WARN_IO
7078 #  define WARN_IO                        5
7079 #endif
7080
7081 #ifndef WARN_CLOSED
7082 #  define WARN_CLOSED                    6
7083 #endif
7084
7085 #ifndef WARN_EXEC
7086 #  define WARN_EXEC                      7
7087 #endif
7088
7089 #ifndef WARN_LAYER
7090 #  define WARN_LAYER                     8
7091 #endif
7092
7093 #ifndef WARN_NEWLINE
7094 #  define WARN_NEWLINE                   9
7095 #endif
7096
7097 #ifndef WARN_PIPE
7098 #  define WARN_PIPE                      10
7099 #endif
7100
7101 #ifndef WARN_UNOPENED
7102 #  define WARN_UNOPENED                  11
7103 #endif
7104
7105 #ifndef WARN_MISC
7106 #  define WARN_MISC                      12
7107 #endif
7108
7109 #ifndef WARN_NUMERIC
7110 #  define WARN_NUMERIC                   13
7111 #endif
7112
7113 #ifndef WARN_ONCE
7114 #  define WARN_ONCE                      14
7115 #endif
7116
7117 #ifndef WARN_OVERFLOW
7118 #  define WARN_OVERFLOW                  15
7119 #endif
7120
7121 #ifndef WARN_PACK
7122 #  define WARN_PACK                      16
7123 #endif
7124
7125 #ifndef WARN_PORTABLE
7126 #  define WARN_PORTABLE                  17
7127 #endif
7128
7129 #ifndef WARN_RECURSION
7130 #  define WARN_RECURSION                 18
7131 #endif
7132
7133 #ifndef WARN_REDEFINE
7134 #  define WARN_REDEFINE                  19
7135 #endif
7136
7137 #ifndef WARN_REGEXP
7138 #  define WARN_REGEXP                    20
7139 #endif
7140
7141 #ifndef WARN_SEVERE
7142 #  define WARN_SEVERE                    21
7143 #endif
7144
7145 #ifndef WARN_DEBUGGING
7146 #  define WARN_DEBUGGING                 22
7147 #endif
7148
7149 #ifndef WARN_INPLACE
7150 #  define WARN_INPLACE                   23
7151 #endif
7152
7153 #ifndef WARN_INTERNAL
7154 #  define WARN_INTERNAL                  24
7155 #endif
7156
7157 #ifndef WARN_MALLOC
7158 #  define WARN_MALLOC                    25
7159 #endif
7160
7161 #ifndef WARN_SIGNAL
7162 #  define WARN_SIGNAL                    26
7163 #endif
7164
7165 #ifndef WARN_SUBSTR
7166 #  define WARN_SUBSTR                    27
7167 #endif
7168
7169 #ifndef WARN_SYNTAX
7170 #  define WARN_SYNTAX                    28
7171 #endif
7172
7173 #ifndef WARN_AMBIGUOUS
7174 #  define WARN_AMBIGUOUS                 29
7175 #endif
7176
7177 #ifndef WARN_BAREWORD
7178 #  define WARN_BAREWORD                  30
7179 #endif
7180
7181 #ifndef WARN_DIGIT
7182 #  define WARN_DIGIT                     31
7183 #endif
7184
7185 #ifndef WARN_PARENTHESIS
7186 #  define WARN_PARENTHESIS               32
7187 #endif
7188
7189 #ifndef WARN_PRECEDENCE
7190 #  define WARN_PRECEDENCE                33
7191 #endif
7192
7193 #ifndef WARN_PRINTF
7194 #  define WARN_PRINTF                    34
7195 #endif
7196
7197 #ifndef WARN_PROTOTYPE
7198 #  define WARN_PROTOTYPE                 35
7199 #endif
7200
7201 #ifndef WARN_QW
7202 #  define WARN_QW                        36
7203 #endif
7204
7205 #ifndef WARN_RESERVED
7206 #  define WARN_RESERVED                  37
7207 #endif
7208
7209 #ifndef WARN_SEMICOLON
7210 #  define WARN_SEMICOLON                 38
7211 #endif
7212
7213 #ifndef WARN_TAINT
7214 #  define WARN_TAINT                     39
7215 #endif
7216
7217 #ifndef WARN_THREADS
7218 #  define WARN_THREADS                   40
7219 #endif
7220
7221 #ifndef WARN_UNINITIALIZED
7222 #  define WARN_UNINITIALIZED             41
7223 #endif
7224
7225 #ifndef WARN_UNPACK
7226 #  define WARN_UNPACK                    42
7227 #endif
7228
7229 #ifndef WARN_UNTIE
7230 #  define WARN_UNTIE                     43
7231 #endif
7232
7233 #ifndef WARN_UTF8
7234 #  define WARN_UTF8                      44
7235 #endif
7236
7237 #ifndef WARN_VOID
7238 #  define WARN_VOID                      45
7239 #endif
7240
7241 #ifndef WARN_ASSERTIONS
7242 #  define WARN_ASSERTIONS                46
7243 #endif
7244 #ifndef packWARN
7245 #  define packWARN(a)                    (a)
7246 #endif
7247
7248 #ifndef ckWARN
7249 #  ifdef G_WARN_ON
7250 #    define  ckWARN(a)                  (PL_dowarn & G_WARN_ON)
7251 #  else
7252 #    define  ckWARN(a)                  PL_dowarn
7253 #  endif
7254 #endif
7255
7256 #if (PERL_BCDVERSION >= 0x5004000) && !defined(warner)
7257 #if defined(NEED_warner)
7258 static void DPPP_(my_warner)(U32 err, const char * pat, ...);
7259 static
7260 #else
7261 extern void DPPP_(my_warner)(U32 err, const char * pat, ...);
7262 #endif
7263
7264 #if defined(NEED_warner) || defined(NEED_warner_GLOBAL)
7265
7266 #define Perl_warner DPPP_(my_warner)
7267
7268
7269 void
7270 DPPP_(my_warner)(U32 err, const char *pat, ...)
7271 {
7272   SV *sv;
7273   va_list args;
7274
7275   PERL_UNUSED_ARG(err);
7276
7277   va_start(args, pat);
7278   sv = vnewSVpvf(pat, &args);
7279   va_end(args);
7280   sv_2mortal(sv);
7281   warn("%s", SvPV_nolen(sv));
7282 }
7283
7284 #define warner  Perl_warner
7285
7286 #define Perl_warner_nocontext  Perl_warner
7287
7288 #endif
7289 #endif
7290
7291 #ifndef IVdf
7292 #  if IVSIZE == LONGSIZE
7293 #    define     IVdf      "ld"
7294 #    define     UVuf      "lu"
7295 #    define     UVof      "lo"
7296 #    define     UVxf      "lx"
7297 #    define     UVXf      "lX"
7298 #  elif IVSIZE == INTSIZE
7299 #    define   IVdf      "d"
7300 #    define   UVuf      "u"
7301 #    define   UVof      "o"
7302 #    define   UVxf      "x"
7303 #    define   UVXf      "X"
7304 #  else
7305 #    error "cannot define IV/UV formats"
7306 #  endif
7307 #endif
7308
7309 #ifndef NVef
7310 #  if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \
7311       defined(PERL_PRIfldbl) && (PERL_BCDVERSION != 0x5006000)
7312             /* Not very likely, but let's try anyway. */
7313 #    define NVef          PERL_PRIeldbl
7314 #    define NVff          PERL_PRIfldbl
7315 #    define NVgf          PERL_PRIgldbl
7316 #  else
7317 #    define NVef          "e"
7318 #    define NVff          "f"
7319 #    define NVgf          "g"
7320 #  endif
7321 #endif
7322 #ifndef sv_setuv
7323 #  define sv_setuv(sv, uv)               \
7324                STMT_START {                         \
7325                  UV TeMpUv = uv;                    \
7326                  if (TeMpUv <= IV_MAX)              \
7327                    sv_setiv(sv, TeMpUv);            \
7328                  else                               \
7329                    sv_setnv(sv, (double)TeMpUv);    \
7330                } STMT_END
7331 #endif
7332 #ifndef newSVuv
7333 #  define newSVuv(uv)                    ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv))
7334 #endif
7335
7336 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
7337 #ifndef sv_2uv
7338 #  define sv_2uv(sv)                     ({ SV *_sv = (sv); (UV) (SvNOK(_sv) ? SvNV(_sv) : sv_2nv(_sv)); })
7339 #endif
7340
7341 #else
7342 #ifndef sv_2uv
7343 #  define sv_2uv(sv)                     ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv)))
7344 #endif
7345
7346 #endif
7347 #ifndef SvUVX
7348 #  define SvUVX(sv)                      ((UV)SvIVX(sv))
7349 #endif
7350
7351 #ifndef SvUVXx
7352 #  define SvUVXx(sv)                     SvUVX(sv)
7353 #endif
7354
7355 #ifndef SvUV
7356 #  define SvUV(sv)                       (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv))
7357 #endif
7358
7359 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
7360 #ifndef SvUVx
7361 #  define SvUVx(sv)                      ({ SV *_sv = (sv)); SvUV(_sv); })
7362 #endif
7363
7364 #else
7365 #ifndef SvUVx
7366 #  define SvUVx(sv)                      ((PL_Sv = (sv)), SvUV(PL_Sv))
7367 #endif
7368
7369 #endif
7370
7371 /* Hint: sv_uv
7372  * Always use the SvUVx() macro instead of sv_uv().
7373  */
7374 /* Replace sv_uv with SvUVx */
7375 #ifndef sv_uv
7376 #  define sv_uv(sv)                      SvUVx(sv)
7377 #endif
7378
7379 #if !defined(SvUOK) && defined(SvIOK_UV)
7380 #  define SvUOK(sv) SvIOK_UV(sv)
7381 #endif
7382 #ifndef XST_mUV
7383 #  define XST_mUV(i,v)                   (ST(i) = sv_2mortal(newSVuv(v))  )
7384 #endif
7385
7386 #ifndef XSRETURN_UV
7387 #  define XSRETURN_UV(v)                 STMT_START { XST_mUV(0,v);  XSRETURN(1); } STMT_END
7388 #endif
7389 #ifndef PUSHu
7390 #  define PUSHu(u)                       STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG;  } STMT_END
7391 #endif
7392
7393 #ifndef XPUSHu
7394 #  define XPUSHu(u)                      STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END
7395 #endif
7396
7397 #if !defined(my_strnlen)
7398 #if defined(NEED_my_strnlen)
7399 static Size_t DPPP_(my_my_strnlen)(const char * str, Size_t maxlen);
7400 static
7401 #else
7402 extern Size_t DPPP_(my_my_strnlen)(const char * str, Size_t maxlen);
7403 #endif
7404
7405 #if defined(NEED_my_strnlen) || defined(NEED_my_strnlen_GLOBAL)
7406
7407 #define my_strnlen DPPP_(my_my_strnlen)
7408 #define Perl_my_strnlen DPPP_(my_my_strnlen)
7409
7410
7411 Size_t
7412 DPPP_(my_my_strnlen)(const char *str, Size_t maxlen)
7413 {
7414     const char *p = str;
7415
7416     while(maxlen-- && *p)
7417         p++;
7418
7419     return p - str;
7420 }
7421
7422 #endif
7423 #endif
7424
7425 #ifdef HAS_MEMCMP
7426 #ifndef memNE
7427 #  define memNE(s1,s2,l)                 (memcmp(s1,s2,l))
7428 #endif
7429
7430 #ifndef memEQ
7431 #  define memEQ(s1,s2,l)                 (!memcmp(s1,s2,l))
7432 #endif
7433
7434 #else
7435 #ifndef memNE
7436 #  define memNE(s1,s2,l)                 (bcmp(s1,s2,l))
7437 #endif
7438
7439 #ifndef memEQ
7440 #  define memEQ(s1,s2,l)                 (!bcmp(s1,s2,l))
7441 #endif
7442
7443 #endif
7444 #ifndef memEQs
7445 #  define memEQs(s1, l, s2)              \
7446                    (sizeof(s2)-1 == l && memEQ(s1, (s2 ""), (sizeof(s2)-1)))
7447 #endif
7448
7449 #ifndef memNEs
7450 #  define memNEs(s1, l, s2)              !memEQs(s1, l, s2)
7451 #endif
7452 #ifndef MoveD
7453 #  define MoveD(s,d,n,t)                 memmove((char*)(d),(char*)(s), (n) * sizeof(t))
7454 #endif
7455
7456 #ifndef CopyD
7457 #  define CopyD(s,d,n,t)                 memcpy((char*)(d),(char*)(s), (n) * sizeof(t))
7458 #endif
7459
7460 #ifdef HAS_MEMSET
7461 #ifndef ZeroD
7462 #  define ZeroD(d,n,t)                   memzero((char*)(d), (n) * sizeof(t))
7463 #endif
7464
7465 #else
7466 #ifndef ZeroD
7467 #  define ZeroD(d,n,t)                   ((void)memzero((char*)(d), (n) * sizeof(t)), d)
7468 #endif
7469
7470 #endif
7471 #ifndef PoisonWith
7472 #  define PoisonWith(d,n,t,b)            (void)memset((char*)(d), (U8)(b), (n) * sizeof(t))
7473 #endif
7474
7475 #ifndef PoisonNew
7476 #  define PoisonNew(d,n,t)               PoisonWith(d,n,t,0xAB)
7477 #endif
7478
7479 #ifndef PoisonFree
7480 #  define PoisonFree(d,n,t)              PoisonWith(d,n,t,0xEF)
7481 #endif
7482
7483 #ifndef Poison
7484 #  define Poison(d,n,t)                  PoisonFree(d,n,t)
7485 #endif
7486 #ifndef Newx
7487 #  define Newx(v,n,t)                    New(0,v,n,t)
7488 #endif
7489
7490 #ifndef Newxc
7491 #  define Newxc(v,n,t,c)                 Newc(0,v,n,t,c)
7492 #endif
7493
7494 #ifndef Newxz
7495 #  define Newxz(v,n,t)                   Newz(0,v,n,t)
7496 #endif
7497
7498 #ifdef NEED_mess_sv
7499 #define NEED_mess
7500 #endif
7501
7502 #ifdef NEED_mess
7503 #define NEED_mess_nocontext
7504 #define NEED_vmess
7505 #endif
7506
7507 #ifndef croak_sv
7508 #if (PERL_BCDVERSION >= 0x5007003) || ( (PERL_BCDVERSION >= 0x5006001) && (PERL_BCDVERSION < 0x5007000) )
7509 #  if ( (PERL_BCDVERSION >= 0x5008000) && (PERL_BCDVERSION < 0x5008009) ) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5010001) )
7510 #    define D_PPP_FIX_UTF8_ERRSV_FOR_SV(sv)                    \
7511         STMT_START {                                           \
7512             SV *_errsv = ERRSV;                                \
7513             SvFLAGS(_errsv) = (SvFLAGS(_errsv) & ~SVf_UTF8) |  \
7514                               (SvFLAGS(sv) & SVf_UTF8);        \
7515         } STMT_END
7516 #  else
7517 #    define D_PPP_FIX_UTF8_ERRSV_FOR_SV(sv) STMT_START {} STMT_END
7518 #  endif
7519 #  define croak_sv(sv)                         \
7520     STMT_START {                               \
7521         SV *_sv = (sv);                        \
7522         if (SvROK(_sv)) {                      \
7523             sv_setsv(ERRSV, _sv);              \
7524             croak(NULL);                       \
7525         } else {                               \
7526             D_PPP_FIX_UTF8_ERRSV_FOR_SV(_sv);  \
7527             croak("%" SVf, SVfARG(_sv));       \
7528         }                                      \
7529     } STMT_END
7530 #elif (PERL_BCDVERSION >= 0x5004000)
7531 #  define croak_sv(sv) croak("%" SVf, SVfARG(sv))
7532 #else
7533 #  define croak_sv(sv) croak("%s", SvPV_nolen(sv))
7534 #endif
7535 #endif
7536
7537 #ifndef die_sv
7538 #if defined(NEED_die_sv)
7539 static OP * DPPP_(my_die_sv)(pTHX_ SV * baseex);
7540 static
7541 #else
7542 extern OP * DPPP_(my_die_sv)(pTHX_ SV * baseex);
7543 #endif
7544
7545 #if defined(NEED_die_sv) || defined(NEED_die_sv_GLOBAL)
7546
7547 #ifdef die_sv
7548 #  undef die_sv
7549 #endif
7550 #define die_sv(a) DPPP_(my_die_sv)(aTHX_ a)
7551 #define Perl_die_sv DPPP_(my_die_sv)
7552
7553 OP *
7554 DPPP_(my_die_sv)(pTHX_ SV *baseex)
7555 {
7556     croak_sv(baseex);
7557     return (OP *)NULL;
7558 }
7559 #endif
7560 #endif
7561
7562 #ifndef warn_sv
7563 #if (PERL_BCDVERSION >= 0x5004000)
7564 #  define warn_sv(sv) warn("%" SVf, SVfARG(sv))
7565 #else
7566 #  define warn_sv(sv) warn("%s", SvPV_nolen(sv))
7567 #endif
7568 #endif
7569
7570 #if ! defined vmess && (PERL_BCDVERSION >= 0x5004000)
7571 #  if defined(NEED_vmess)
7572 static SV * DPPP_(my_vmess)(pTHX_ const char * pat, va_list * args);
7573 static
7574 #else
7575 extern SV * DPPP_(my_vmess)(pTHX_ const char * pat, va_list * args);
7576 #endif
7577
7578 #if defined(NEED_vmess) || defined(NEED_vmess_GLOBAL)
7579
7580 #ifdef vmess
7581 #  undef vmess
7582 #endif
7583 #define vmess(a,b) DPPP_(my_vmess)(aTHX_ a,b)
7584 #define Perl_vmess DPPP_(my_vmess)
7585
7586
7587 SV*
7588 DPPP_(my_vmess)(pTHX_ const char* pat, va_list* args)
7589 {
7590     mess(pat, args);
7591     return PL_mess_sv;
7592 }
7593 #  endif
7594 #endif
7595
7596 #if (PERL_BCDVERSION < 0x5006000) && (PERL_BCDVERSION >= 0x5004000)
7597 #undef mess
7598 #endif
7599
7600 #if !defined(mess_nocontext) && !defined(Perl_mess_nocontext) && (PERL_BCDVERSION >= 0x5004000)
7601 #if defined(NEED_mess_nocontext)
7602 static SV * DPPP_(my_mess_nocontext)(const char * pat, ...);
7603 static
7604 #else
7605 extern SV * DPPP_(my_mess_nocontext)(const char * pat, ...);
7606 #endif
7607
7608 #if defined(NEED_mess_nocontext) || defined(NEED_mess_nocontext_GLOBAL)
7609
7610 #define mess_nocontext DPPP_(my_mess_nocontext)
7611 #define Perl_mess_nocontext DPPP_(my_mess_nocontext)
7612
7613 SV*
7614 DPPP_(my_mess_nocontext)(const char* pat, ...)
7615 {
7616     dTHX;
7617     SV *sv;
7618     va_list args;
7619     va_start(args, pat);
7620     sv = vmess(pat, &args);
7621     va_end(args);
7622     return sv;
7623 }
7624 #endif
7625 #endif
7626
7627 #ifndef mess
7628 #if defined(NEED_mess)
7629 static SV * DPPP_(my_mess)(pTHX_ const char * pat, ...);
7630 static
7631 #else
7632 extern SV * DPPP_(my_mess)(pTHX_ const char * pat, ...);
7633 #endif
7634
7635 #if defined(NEED_mess) || defined(NEED_mess_GLOBAL)
7636
7637 #define Perl_mess DPPP_(my_mess)
7638
7639 SV*
7640 DPPP_(my_mess)(pTHX_ const char* pat, ...)
7641 {
7642     SV *sv;
7643     va_list args;
7644     va_start(args, pat);
7645     sv = vmess(pat, &args);
7646     va_end(args);
7647     return sv;
7648 }
7649 #ifdef mess_nocontext
7650 #define mess mess_nocontext
7651 #else
7652 #define mess Perl_mess_nocontext
7653 #endif
7654 #endif
7655 #endif
7656
7657 #if ! defined mess_sv && (PERL_BCDVERSION >= 0x5004000)
7658 #if defined(NEED_mess_sv)
7659 static SV * DPPP_(my_mess_sv)(pTHX_ SV * basemsg, bool consume);
7660 static
7661 #else
7662 extern SV * DPPP_(my_mess_sv)(pTHX_ SV * basemsg, bool consume);
7663 #endif
7664
7665 #if defined(NEED_mess_sv) || defined(NEED_mess_sv_GLOBAL)
7666
7667 #ifdef mess_sv
7668 #  undef mess_sv
7669 #endif
7670 #define mess_sv(a,b) DPPP_(my_mess_sv)(aTHX_ a,b)
7671 #define Perl_mess_sv DPPP_(my_mess_sv)
7672
7673 SV *
7674 DPPP_(my_mess_sv)(pTHX_ SV *basemsg, bool consume)
7675 {
7676     SV *tmp;
7677     SV *ret;
7678
7679     if (SvPOK(basemsg) && SvCUR(basemsg) && *(SvEND(basemsg)-1) == '\n') {
7680         if (consume)
7681             return basemsg;
7682         ret = mess("");
7683         SvSetSV_nosteal(ret, basemsg);
7684         return ret;
7685     }
7686
7687     if (consume) {
7688         sv_catsv(basemsg, mess(""));
7689         return basemsg;
7690     }
7691
7692     ret = mess("");
7693     tmp = newSVsv(ret);
7694     SvSetSV_nosteal(ret, basemsg);
7695     sv_catsv(ret, tmp);
7696     sv_dec(tmp);
7697     return ret;
7698 }
7699 #endif
7700 #endif
7701
7702 #ifndef warn_nocontext
7703 #define warn_nocontext warn
7704 #endif
7705
7706 #ifndef croak_nocontext
7707 #define croak_nocontext croak
7708 #endif
7709
7710 #ifndef croak_no_modify
7711 #define croak_no_modify() croak_nocontext("%s", PL_no_modify)
7712 #define Perl_croak_no_modify() croak_no_modify()
7713 #endif
7714
7715 #ifndef croak_memory_wrap
7716 #if (PERL_BCDVERSION >= 0x5009002) || ( (PERL_BCDVERSION >= 0x5008006) && (PERL_BCDVERSION < 0x5009000) )
7717 #  define croak_memory_wrap() croak_nocontext("%s", PL_memory_wrap)
7718 #else
7719 #  define croak_memory_wrap() croak_nocontext("panic: memory wrap")
7720 #endif
7721 #endif
7722
7723 #ifndef croak_xs_usage
7724 #if defined(NEED_croak_xs_usage)
7725 static void DPPP_(my_croak_xs_usage)(const CV * const cv, const char * const params);
7726 static
7727 #else
7728 extern void DPPP_(my_croak_xs_usage)(const CV * const cv, const char * const params);
7729 #endif
7730
7731 #if defined(NEED_croak_xs_usage) || defined(NEED_croak_xs_usage_GLOBAL)
7732
7733 #define croak_xs_usage DPPP_(my_croak_xs_usage)
7734 #define Perl_croak_xs_usage DPPP_(my_croak_xs_usage)
7735
7736
7737
7738 void
7739 DPPP_(my_croak_xs_usage)(const CV *const cv, const char *const params)
7740 {
7741     dTHX;
7742     const GV *const gv = CvGV(cv);
7743
7744 #ifdef PERL_ARGS_ASSERT_CROAK_XS_USAGE
7745     PERL_ARGS_ASSERT_CROAK_XS_USAGE;
7746 #else
7747      assert(cv); assert(params);
7748 #endif
7749
7750     if (gv) {
7751         const char *const gvname = GvNAME(gv);
7752         const HV *const stash = GvSTASH(gv);
7753         const char *const hvname = stash ? HvNAME(stash) : NULL;
7754
7755         if (hvname)
7756             croak("Usage: %s::%s(%s)", hvname, gvname, params);
7757         else
7758             croak("Usage: %s(%s)", gvname, params);
7759     } else {
7760         /* Pants. I don't think that it should be possible to get here. */
7761         croak("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params);
7762     }
7763 }
7764 #endif
7765 #endif
7766 #ifndef mPUSHs
7767 #  define mPUSHs(s)                      PUSHs(sv_2mortal(s))
7768 #endif
7769
7770 #ifndef PUSHmortal
7771 #  define PUSHmortal                     PUSHs(sv_newmortal())
7772 #endif
7773
7774 #ifndef mPUSHp
7775 #  define mPUSHp(p,l)                    sv_setpvn(PUSHmortal, (p), (l))
7776 #endif
7777
7778 #ifndef mPUSHn
7779 #  define mPUSHn(n)                      sv_setnv(PUSHmortal, (NV)(n))
7780 #endif
7781
7782 #ifndef mPUSHi
7783 #  define mPUSHi(i)                      sv_setiv(PUSHmortal, (IV)(i))
7784 #endif
7785
7786 #ifndef mPUSHu
7787 #  define mPUSHu(u)                      sv_setuv(PUSHmortal, (UV)(u))
7788 #endif
7789 #ifndef mXPUSHs
7790 #  define mXPUSHs(s)                     XPUSHs(sv_2mortal(s))
7791 #endif
7792
7793 #ifndef XPUSHmortal
7794 #  define XPUSHmortal                    XPUSHs(sv_newmortal())
7795 #endif
7796
7797 #ifndef mXPUSHp
7798 #  define mXPUSHp(p,l)                   STMT_START { EXTEND(sp,1); sv_setpvn(PUSHmortal, (p), (l)); } STMT_END
7799 #endif
7800
7801 #ifndef mXPUSHn
7802 #  define mXPUSHn(n)                     STMT_START { EXTEND(sp,1); sv_setnv(PUSHmortal, (NV)(n)); } STMT_END
7803 #endif
7804
7805 #ifndef mXPUSHi
7806 #  define mXPUSHi(i)                     STMT_START { EXTEND(sp,1); sv_setiv(PUSHmortal, (IV)(i)); } STMT_END
7807 #endif
7808
7809 #ifndef mXPUSHu
7810 #  define mXPUSHu(u)                     STMT_START { EXTEND(sp,1); sv_setuv(PUSHmortal, (UV)(u)); } STMT_END
7811 #endif
7812
7813 /* Replace: 1 */
7814 #ifndef call_sv
7815 #  define call_sv                        perl_call_sv
7816 #endif
7817
7818 #ifndef call_pv
7819 #  define call_pv                        perl_call_pv
7820 #endif
7821
7822 #ifndef call_argv
7823 #  define call_argv                      perl_call_argv
7824 #endif
7825
7826 #ifndef call_method
7827 #  define call_method                    perl_call_method
7828 #endif
7829 #ifndef eval_sv
7830 #  define eval_sv                        perl_eval_sv
7831 #endif
7832
7833 /* Replace: 0 */
7834 #ifndef PERL_LOADMOD_DENY
7835 #  define PERL_LOADMOD_DENY              0x1
7836 #endif
7837
7838 #ifndef PERL_LOADMOD_NOIMPORT
7839 #  define PERL_LOADMOD_NOIMPORT          0x2
7840 #endif
7841
7842 #ifndef PERL_LOADMOD_IMPORT_OPS
7843 #  define PERL_LOADMOD_IMPORT_OPS        0x4
7844 #endif
7845
7846 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
7847 # define D_PPP_CROAK_IF_ERROR(cond) ({ SV *_errsv; ((cond) && (_errsv = ERRSV) && (SvROK(_errsv) || SvTRUE(_errsv)) && (croak_sv(_errsv), 1)); })
7848 #else
7849 # define D_PPP_CROAK_IF_ERROR(cond) ((cond) && (SvROK(ERRSV) || SvTRUE(ERRSV)) && (croak_sv(ERRSV), 1))
7850 #endif
7851
7852 #ifndef G_METHOD
7853 # define G_METHOD               64
7854 # ifdef call_sv
7855 #  undef call_sv
7856 # endif
7857 # if (PERL_BCDVERSION < 0x5006000)
7858 #  define call_sv(sv, flags)  ((flags) & G_METHOD ? perl_call_method((char *) SvPV_nolen_const(sv), \
7859                                 (flags) & ~G_METHOD) : perl_call_sv(sv, flags))
7860 # else
7861 #  define call_sv(sv, flags)  ((flags) & G_METHOD ? Perl_call_method(aTHX_ (char *) SvPV_nolen_const(sv), \
7862                                 (flags) & ~G_METHOD) : Perl_call_sv(aTHX_ sv, flags))
7863 # endif
7864 #endif
7865
7866 #ifndef G_RETHROW
7867 # define G_RETHROW 8192
7868 # ifdef eval_sv
7869 #  undef eval_sv
7870 # endif
7871 # if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
7872 #  define eval_sv(sv, flags) ({ I32 _flags = (flags); I32 _ret = Perl_eval_sv(aTHX_ sv, (_flags & ~G_RETHROW)); D_PPP_CROAK_IF_ERROR(_flags & G_RETHROW); _ret; })
7873 # else
7874 #  define eval_sv(sv, flags) ((PL_na = Perl_eval_sv(aTHX_ sv, ((flags) & ~G_RETHROW))), D_PPP_CROAK_IF_ERROR((flags) & G_RETHROW), (I32)PL_na)
7875 # endif
7876 #endif
7877
7878 /* Older Perl versions have broken croak_on_error=1 */
7879 #if (PERL_BCDVERSION < 0x5031002)
7880 # ifdef eval_pv
7881 #  undef eval_pv
7882 #  if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
7883 #   define eval_pv(p, croak_on_error) ({ SV *_sv = Perl_eval_pv(aTHX_ p, 0); D_PPP_CROAK_IF_ERROR(croak_on_error); _sv; })
7884 #  else
7885 #   define eval_pv(p, croak_on_error) ((PL_Sv = Perl_eval_pv(aTHX_ p, 0)), D_PPP_CROAK_IF_ERROR(croak_on_error), PL_Sv)
7886 #  endif
7887 # endif
7888 #endif
7889
7890 /* Replace perl_eval_pv with eval_pv */
7891
7892 #ifndef eval_pv
7893 #if defined(NEED_eval_pv)
7894 static SV * DPPP_(my_eval_pv)(const char * p, I32 croak_on_error);
7895 static
7896 #else
7897 extern SV * DPPP_(my_eval_pv)(const char * p, I32 croak_on_error);
7898 #endif
7899
7900 #if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL)
7901
7902 #ifdef eval_pv
7903 #  undef eval_pv
7904 #endif
7905 #define eval_pv(a,b) DPPP_(my_eval_pv)(aTHX_ a,b)
7906 #define Perl_eval_pv DPPP_(my_eval_pv)
7907
7908
7909 SV*
7910 DPPP_(my_eval_pv)(const char *p, I32 croak_on_error)
7911 {
7912     dSP;
7913     SV* sv = newSVpv(p, 0);
7914
7915     PUSHMARK(sp);
7916     eval_sv(sv, G_SCALAR);
7917     SvREFCNT_dec(sv);
7918
7919     SPAGAIN;
7920     sv = POPs;
7921     PUTBACK;
7922
7923     D_PPP_CROAK_IF_ERROR(croak_on_error);
7924
7925     return sv;
7926 }
7927
7928 #endif
7929 #endif
7930
7931 #if ! defined(vload_module) && defined(start_subparse)
7932 #if defined(NEED_vload_module)
7933 static void DPPP_(my_vload_module)(U32 flags, SV * name, SV * ver, va_list * args);
7934 static
7935 #else
7936 extern void DPPP_(my_vload_module)(U32 flags, SV * name, SV * ver, va_list * args);
7937 #endif
7938
7939 #if defined(NEED_vload_module) || defined(NEED_vload_module_GLOBAL)
7940
7941 #ifdef vload_module
7942 #  undef vload_module
7943 #endif
7944 #define vload_module(a,b,c,d) DPPP_(my_vload_module)(aTHX_ a,b,c,d)
7945 #define Perl_vload_module DPPP_(my_vload_module)
7946
7947
7948 void
7949 DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args)
7950 {
7951     dTHR;
7952     dVAR;
7953     OP *veop, *imop;
7954
7955     OP * const modname = newSVOP(OP_CONST, 0, name);
7956     /* 5.005 has a somewhat hacky force_normal that doesn't croak on
7957        SvREADONLY() if PL_compling is true. Current perls take care in
7958        ck_require() to correctly turn off SvREADONLY before calling
7959        force_normal_flags(). This seems a better fix than fudging PL_compling
7960      */
7961     SvREADONLY_off(((SVOP*)modname)->op_sv);
7962     modname->op_private |= OPpCONST_BARE;
7963     if (ver) {
7964         veop = newSVOP(OP_CONST, 0, ver);
7965     }
7966     else
7967         veop = NULL;
7968     if (flags & PERL_LOADMOD_NOIMPORT) {
7969         imop = sawparens(newNULLLIST());
7970     }
7971     else if (flags & PERL_LOADMOD_IMPORT_OPS) {
7972         imop = va_arg(*args, OP*);
7973     }
7974     else {
7975         SV *sv;
7976         imop = NULL;
7977         sv = va_arg(*args, SV*);
7978         while (sv) {
7979             imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));
7980             sv = va_arg(*args, SV*);
7981         }
7982     }
7983     {
7984         const line_t ocopline = PL_copline;
7985         COP * const ocurcop = PL_curcop;
7986         const int oexpect = PL_expect;
7987
7988         utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0),
7989 #if (PERL_BCDVERSION > 0x5003000)
7990                 veop,
7991 #endif
7992                 modname, imop);
7993         PL_expect = oexpect;
7994         PL_copline = ocopline;
7995         PL_curcop = ocurcop;
7996     }
7997 }
7998
7999 #endif
8000 #endif
8001
8002 #ifndef load_module
8003 #if defined(NEED_load_module)
8004 static void DPPP_(my_load_module)(U32 flags, SV * name, SV * ver, ...);
8005 static
8006 #else
8007 extern void DPPP_(my_load_module)(U32 flags, SV * name, SV * ver, ...);
8008 #endif
8009
8010 #if defined(NEED_load_module) || defined(NEED_load_module_GLOBAL)
8011
8012 #ifdef load_module
8013 #  undef load_module
8014 #endif
8015 #define load_module DPPP_(my_load_module)
8016 #define Perl_load_module DPPP_(my_load_module)
8017
8018
8019 void
8020 DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...)
8021 {
8022     va_list args;
8023     va_start(args, ver);
8024     vload_module(flags, name, ver, &args);
8025     va_end(args);
8026 }
8027
8028 #endif
8029 #endif
8030 #ifndef newRV_inc
8031 #  define newRV_inc(sv)                  newRV(sv)   /* Replace */
8032 #endif
8033
8034 #ifndef newRV_noinc
8035 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
8036 #  define newRV_noinc(sv) ({ SV *_sv = (SV *)newRV((sv)); SvREFCNT_dec((sv)); _sv; })
8037 #else
8038 #  define newRV_noinc(sv) ((PL_Sv = (SV *)newRV((sv))), SvREFCNT_dec((sv)), PL_Sv)
8039 #endif
8040 #endif
8041
8042 /*
8043  * Boilerplate macros for initializing and accessing interpreter-local
8044  * data from C.  All statics in extensions should be reworked to use
8045  * this, if you want to make the extension thread-safe.  See ext/re/re.xs
8046  * for an example of the use of these macros.
8047  *
8048  * Code that uses these macros is responsible for the following:
8049  * 1. #define MY_CXT_KEY to a unique string, e.g. "DynaLoader_guts"
8050  * 2. Declare a typedef named my_cxt_t that is a structure that contains
8051  *    all the data that needs to be interpreter-local.
8052  * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t.
8053  * 4. Use the MY_CXT_INIT macro such that it is called exactly once
8054  *    (typically put in the BOOT: section).
8055  * 5. Use the members of the my_cxt_t structure everywhere as
8056  *    MY_CXT.member.
8057  * 6. Use the dMY_CXT macro (a declaration) in all the functions that
8058  *    access MY_CXT.
8059  */
8060
8061 #if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \
8062     defined(PERL_CAPI)    || defined(PERL_IMPLICIT_CONTEXT)
8063
8064 #ifndef START_MY_CXT
8065
8066 /* This must appear in all extensions that define a my_cxt_t structure,
8067  * right after the definition (i.e. at file scope).  The non-threads
8068  * case below uses it to declare the data as static. */
8069 #define START_MY_CXT
8070
8071 #if (PERL_BCDVERSION < 0x5004068)
8072 /* Fetches the SV that keeps the per-interpreter data. */
8073 #define dMY_CXT_SV \
8074         SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE)
8075 #else /* >= perl5.004_68 */
8076 #define dMY_CXT_SV \
8077         SV *my_cxt_sv = *hv_fetch(PL_modglobal, MY_CXT_KEY,             \
8078                                   sizeof(MY_CXT_KEY)-1, TRUE)
8079 #endif /* < perl5.004_68 */
8080
8081 /* This declaration should be used within all functions that use the
8082  * interpreter-local data. */
8083 #define dMY_CXT \
8084         dMY_CXT_SV;                                                     \
8085         my_cxt_t *my_cxtp = INT2PTR(my_cxt_t*,SvUV(my_cxt_sv))
8086
8087 /* Creates and zeroes the per-interpreter data.
8088  * (We allocate my_cxtp in a Perl SV so that it will be released when
8089  * the interpreter goes away.) */
8090 #define MY_CXT_INIT \
8091         dMY_CXT_SV;                                                     \
8092         /* newSV() allocates one more than needed */                    \
8093         my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
8094         Zero(my_cxtp, 1, my_cxt_t);                                     \
8095         sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
8096
8097 /* This macro must be used to access members of the my_cxt_t structure.
8098  * e.g. MYCXT.some_data */
8099 #define MY_CXT          (*my_cxtp)
8100
8101 /* Judicious use of these macros can reduce the number of times dMY_CXT
8102  * is used.  Use is similar to pTHX, aTHX etc. */
8103 #define pMY_CXT         my_cxt_t *my_cxtp
8104 #define pMY_CXT_        pMY_CXT,
8105 #define _pMY_CXT        ,pMY_CXT
8106 #define aMY_CXT         my_cxtp
8107 #define aMY_CXT_        aMY_CXT,
8108 #define _aMY_CXT        ,aMY_CXT
8109
8110 #endif /* START_MY_CXT */
8111
8112 #ifndef MY_CXT_CLONE
8113 /* Clones the per-interpreter data. */
8114 #define MY_CXT_CLONE \
8115         dMY_CXT_SV;                                                     \
8116         my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
8117         Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t);\
8118         sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
8119 #endif
8120
8121 #else /* single interpreter */
8122
8123 #ifndef START_MY_CXT
8124
8125 #define START_MY_CXT    static my_cxt_t my_cxt;
8126 #define dMY_CXT_SV      dNOOP
8127 #define dMY_CXT         dNOOP
8128 #define MY_CXT_INIT     NOOP
8129 #define MY_CXT          my_cxt
8130
8131 #define pMY_CXT         void
8132 #define pMY_CXT_
8133 #define _pMY_CXT
8134 #define aMY_CXT
8135 #define aMY_CXT_
8136 #define _aMY_CXT
8137
8138 #endif /* START_MY_CXT */
8139
8140 #ifndef MY_CXT_CLONE
8141 #define MY_CXT_CLONE    NOOP
8142 #endif
8143
8144 #endif
8145
8146 #ifndef SvREFCNT_inc
8147 #  ifdef PERL_USE_GCC_BRACE_GROUPS
8148 #    define SvREFCNT_inc(sv)            \
8149       ({                                \
8150           SV * const _sv = (SV*)(sv);   \
8151           if (_sv)                      \
8152                (SvREFCNT(_sv))++;       \
8153           _sv;                          \
8154       })
8155 #  else
8156 #    define SvREFCNT_inc(sv)    \
8157           ((PL_Sv=(SV*)(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL)
8158 #  endif
8159 #endif
8160
8161 #ifndef SvREFCNT_inc_simple
8162 #  ifdef PERL_USE_GCC_BRACE_GROUPS
8163 #    define SvREFCNT_inc_simple(sv)     \
8164       ({                                        \
8165           if (sv)                               \
8166                (SvREFCNT(sv))++;                \
8167           (SV *)(sv);                           \
8168       })
8169 #  else
8170 #    define SvREFCNT_inc_simple(sv) \
8171           ((sv) ? (SvREFCNT(sv)++,(SV*)(sv)) : NULL)
8172 #  endif
8173 #endif
8174
8175 #ifndef SvREFCNT_inc_NN
8176 #  ifdef PERL_USE_GCC_BRACE_GROUPS
8177 #    define SvREFCNT_inc_NN(sv)         \
8178       ({                                        \
8179           SV * const _sv = (SV*)(sv);   \
8180           SvREFCNT(_sv)++;              \
8181           _sv;                          \
8182       })
8183 #  else
8184 #    define SvREFCNT_inc_NN(sv) \
8185           (PL_Sv=(SV*)(sv),++(SvREFCNT(PL_Sv)),PL_Sv)
8186 #  endif
8187 #endif
8188
8189 #ifndef SvREFCNT_inc_void
8190 #  ifdef PERL_USE_GCC_BRACE_GROUPS
8191 #    define SvREFCNT_inc_void(sv)               \
8192       ({                                        \
8193           SV * const _sv = (SV*)(sv);   \
8194           if (_sv)                      \
8195               (void)(SvREFCNT(_sv)++);  \
8196       })
8197 #  else
8198 #    define SvREFCNT_inc_void(sv) \
8199           (void)((PL_Sv=(SV*)(sv)) ? ++(SvREFCNT(PL_Sv)) : 0)
8200 #  endif
8201 #endif
8202 #ifndef SvREFCNT_inc_simple_void
8203 #  define SvREFCNT_inc_simple_void(sv)   STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END
8204 #endif
8205
8206 #ifndef SvREFCNT_inc_simple_NN
8207 #  define SvREFCNT_inc_simple_NN(sv)     (++SvREFCNT(sv), (SV*)(sv))
8208 #endif
8209
8210 #ifndef SvREFCNT_inc_void_NN
8211 #  define SvREFCNT_inc_void_NN(sv)       (void)(++SvREFCNT((SV*)(sv)))
8212 #endif
8213
8214 #ifndef SvREFCNT_inc_simple_void_NN
8215 #  define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv)))
8216 #endif
8217
8218 #ifndef newSV_type
8219 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
8220 #  define newSV_type(t) ({ SV *_sv = newSV(0); sv_upgrade(_sv, (t)); _sv; })
8221 #else
8222 #  define newSV_type(t) ((PL_Sv = newSV(0)), sv_upgrade(PL_Sv, (t)), PL_Sv)
8223 #endif
8224 #endif
8225
8226 #if (PERL_BCDVERSION < 0x5006000)
8227 # define D_PPP_CONSTPV_ARG(x)  ((char *) (x))
8228 #else
8229 # define D_PPP_CONSTPV_ARG(x)  (x)
8230 #endif
8231 #ifndef newSVpvn
8232 #  define newSVpvn(data,len)             ((data)                                              \
8233                                     ? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \
8234                                     : newSV(0))
8235 #endif
8236 #ifndef newSVpvn_utf8
8237 #  define newSVpvn_utf8(s, len, u)       newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0)
8238 #endif
8239 #ifndef SVf_UTF8
8240 #  define SVf_UTF8                       0
8241 #endif
8242
8243 #ifndef newSVpvn_flags
8244 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
8245 # define newSVpvn_flags(s, len, flags) ({ SV *_sv = newSVpvn(D_PPP_CONSTPV_ARG((s)), (len)); SvFLAGS(_sv) |= ((flags) & SVf_UTF8); ((flags) & SVs_TEMP) ? sv_2mortal(_sv) : _sv; })
8246 #else
8247 # define newSVpvn_flags(s, len, flags) ((PL_Sv = newSVpvn(D_PPP_CONSTPV_ARG((s)), (len))), SvFLAGS(PL_Sv) |= ((flags) & SVf_UTF8), (((flags) & SVs_TEMP) ? sv_2mortal(PL_Sv) : PL_Sv))
8248 #endif
8249 #endif
8250
8251 #if ( (PERL_BCDVERSION >= 0x5007003) && (PERL_BCDVERSION < 0x5008007) ) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009002) )
8252 #undef sv_setsv_flags
8253 #define SV_NOSTEAL 16
8254 #define sv_setsv_flags(dstr, sstr, flags)                                          \
8255   STMT_START {                                                                     \
8256     if (((flags) & SV_NOSTEAL) && (sstr) && (SvFLAGS((SV *)(sstr)) & SVs_TEMP)) {  \
8257       SvTEMP_off((SV *)(sstr));                                                    \
8258       Perl_sv_setsv_flags(aTHX_ (dstr), (sstr), (flags) & ~SV_NOSTEAL);            \
8259       SvTEMP_on((SV *)(sstr));                                                     \
8260     } else {                                                                       \
8261       Perl_sv_setsv_flags(aTHX_ (dstr), (sstr), (flags) & ~SV_NOSTEAL);            \
8262     }                                                                              \
8263   } STMT_END
8264 #endif
8265
8266 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
8267 #ifndef newSVsv_flags
8268 #  define newSVsv_flags(sv, flags)       ({ SV *_sv = newSV(0); sv_setsv_flags(_sv, (sv), (flags)); _sv; })
8269 #endif
8270
8271 #else
8272 #ifndef newSVsv_flags
8273 #  define newSVsv_flags(sv, flags)       ((PL_Sv = newSV(0)), sv_setsv_flags(PL_Sv, (sv), (flags)), PL_Sv)
8274 #endif
8275
8276 #endif
8277
8278 #ifdef SV_NOSTEAL
8279 #ifndef newSVsv_nomg
8280 #  define newSVsv_nomg(sv)               newSVsv_flags((sv), SV_NOSTEAL)
8281 #endif
8282
8283 #endif
8284
8285 #if (PERL_BCDVERSION >= 0x5017005)
8286 #ifndef sv_mortalcopy_flags
8287 #  define sv_mortalcopy_flags(sv, flags) Perl_sv_mortalcopy_flags(aTHX_ (sv), (flags))
8288 #endif
8289
8290 #else
8291 #ifndef sv_mortalcopy_flags
8292 #  define sv_mortalcopy_flags(sv, flags) sv_2mortal(newSVsv_flags((sv), (flags)))
8293 #endif
8294
8295 #endif
8296 #ifndef SvMAGIC_set
8297 #  define SvMAGIC_set(sv, val)           \
8298                 STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
8299                 (((XPVMG*) SvANY(sv))->xmg_magic = (val)); } STMT_END
8300 #endif
8301
8302 #if (PERL_BCDVERSION < 0x5009003)
8303 #ifndef SvPVX_const
8304 #  define SvPVX_const(sv)                ((const char*) (0 + SvPVX(sv)))
8305 #endif
8306
8307 #ifndef SvPVX_mutable
8308 #  define SvPVX_mutable(sv)              (0 + SvPVX(sv))
8309 #endif
8310 #ifndef SvRV_set
8311 #  define SvRV_set(sv, val)              \
8312                 STMT_START { assert(SvTYPE(sv) >=  SVt_RV); \
8313                 (((XRV*) SvANY(sv))->xrv_rv = (val)); } STMT_END
8314 #endif
8315
8316 #else
8317 #ifndef SvPVX_const
8318 #  define SvPVX_const(sv)                ((const char*)((sv)->sv_u.svu_pv))
8319 #endif
8320
8321 #ifndef SvPVX_mutable
8322 #  define SvPVX_mutable(sv)              ((sv)->sv_u.svu_pv)
8323 #endif
8324 #ifndef SvRV_set
8325 #  define SvRV_set(sv, val)              \
8326                 STMT_START { assert(SvTYPE(sv) >=  SVt_RV); \
8327                 ((sv)->sv_u.svu_rv = (val)); } STMT_END
8328 #endif
8329
8330 #endif
8331 #ifndef SvSTASH_set
8332 #  define SvSTASH_set(sv, val)           \
8333                 STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
8334                 (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END
8335 #endif
8336
8337 #if (PERL_BCDVERSION < 0x5004000)
8338 #ifndef SvUV_set
8339 #  define SvUV_set(sv, val)              \
8340                 STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
8341                 (((XPVIV*) SvANY(sv))->xiv_iv = (IV) (val)); } STMT_END
8342 #endif
8343
8344 #else
8345 #ifndef SvUV_set
8346 #  define SvUV_set(sv, val)              \
8347                 STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
8348                 (((XPVUV*) SvANY(sv))->xuv_uv = (val)); } STMT_END
8349 #endif
8350
8351 #endif
8352
8353 /* Hint: newSVpvn_share
8354  * The SVs created by this function only mimic the behaviour of
8355  * shared PVs without really being shared. Only use if you know
8356  * what you're doing.
8357  */
8358
8359 #ifndef newSVpvn_share
8360
8361 #if defined(NEED_newSVpvn_share)
8362 static SV * DPPP_(my_newSVpvn_share)(pTHX_ const char * s, I32 len, U32 hash);
8363 static
8364 #else
8365 extern SV * DPPP_(my_newSVpvn_share)(pTHX_ const char * s, I32 len, U32 hash);
8366 #endif
8367
8368 #if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL)
8369
8370 #ifdef newSVpvn_share
8371 #  undef newSVpvn_share
8372 #endif
8373 #define newSVpvn_share(a,b,c) DPPP_(my_newSVpvn_share)(aTHX_ a,b,c)
8374 #define Perl_newSVpvn_share DPPP_(my_newSVpvn_share)
8375
8376
8377 SV *
8378 DPPP_(my_newSVpvn_share)(pTHX_ const char *s, I32 len, U32 hash)
8379 {
8380   SV *sv;
8381   if (len < 0)
8382     len = -len;
8383   if (!hash)
8384     PERL_HASH(hash, (char*) s, len);
8385   sv = newSVpvn((char *) s, len);
8386   sv_upgrade(sv, SVt_PVIV);
8387   SvIVX(sv) = hash;
8388   SvREADONLY_on(sv);
8389   SvPOK_on(sv);
8390   return sv;
8391 }
8392
8393 #endif
8394
8395 #endif
8396 #ifndef SvSHARED_HASH
8397 #  define SvSHARED_HASH(sv)              (0 + SvUVX(sv))
8398 #endif
8399 #ifndef HvNAME_get
8400 #  define HvNAME_get(hv)                 HvNAME(hv)
8401 #endif
8402 #ifndef HvNAMELEN_get
8403 #  define HvNAMELEN_get(hv)              (HvNAME_get(hv) ? (I32)strlen(HvNAME_get(hv)) : 0)
8404 #endif
8405
8406 #if (PERL_BCDVERSION >= 0x5009002) && (PERL_BCDVERSION <= 0x5009003) /* 5.9.2 and 5.9.3 ignore the length param */
8407 #undef gv_fetchpvn_flags
8408 #endif
8409 #ifndef GV_NOADD_MASK
8410 #  define GV_NOADD_MASK                  0xE0
8411 #endif
8412
8413 #ifndef gv_fetchpvn_flags
8414 #  define gv_fetchpvn_flags(name, len, flags, sv_type) gv_fetchpv(SvPVX(sv_2mortal(newSVpvn((name), (len)))), ((flags) & GV_NOADD_MASK) ? FALSE : TRUE, (I32)(sv_type))
8415 #endif
8416 #ifndef GvSVn
8417 #  define GvSVn(gv)                      GvSV(gv)
8418 #endif
8419
8420 #ifndef isGV_with_GP
8421 #  define isGV_with_GP(gv)               isGV(gv)
8422 #endif
8423
8424 #ifndef gv_fetchsv
8425 #  define gv_fetchsv(name, flags, svt)   gv_fetchpv(SvPV_nolen_const(name), flags, svt)
8426 #endif
8427 #ifndef get_cvn_flags
8428 #  define get_cvn_flags(name, namelen, flags) get_cv(name, flags)
8429 #endif
8430
8431 #ifndef gv_init_pvn
8432 #  define gv_init_pvn(gv, stash, ptr, len, flags) gv_init(gv, stash, ptr, len, flags & GV_ADDMULTI ? TRUE : FALSE)
8433 #endif
8434
8435 /* concatenating with "" ensures that only literal strings are accepted as argument
8436  * note that STR_WITH_LEN() can't be used as argument to macros or functions that
8437  * under some configurations might be macros
8438  */
8439 #ifndef STR_WITH_LEN
8440 #  define STR_WITH_LEN(s)                (s ""), (sizeof(s)-1)
8441 #endif
8442 #ifndef newSVpvs
8443 #  define newSVpvs(str)                  newSVpvn(str "", sizeof(str) - 1)
8444 #endif
8445
8446 #ifndef newSVpvs_flags
8447 #  define newSVpvs_flags(str, flags)     newSVpvn_flags(str "", sizeof(str) - 1, flags)
8448 #endif
8449
8450 #ifndef newSVpvs_share
8451 #  define newSVpvs_share(str)            newSVpvn_share(str "", sizeof(str) - 1, 0)
8452 #endif
8453
8454 #ifndef sv_catpvs
8455 #  define sv_catpvs(sv, str)             sv_catpvn(sv, str "", sizeof(str) - 1)
8456 #endif
8457
8458 #ifndef sv_setpvs
8459 #  define sv_setpvs(sv, str)             sv_setpvn(sv, str "", sizeof(str) - 1)
8460 #endif
8461
8462 #ifndef hv_fetchs
8463 #  define hv_fetchs(hv, key, lval)       hv_fetch(hv, key "", sizeof(key) - 1, lval)
8464 #endif
8465
8466 #ifndef hv_stores
8467 #  define hv_stores(hv, key, val)        hv_store(hv, key "", sizeof(key) - 1, val, 0)
8468 #endif
8469 #ifndef gv_fetchpvs
8470 #  define gv_fetchpvs(name, flags, svt)  gv_fetchpvn_flags(name "", sizeof(name) - 1, flags, svt)
8471 #endif
8472
8473 #ifndef gv_stashpvs
8474 #  define gv_stashpvs(name, flags)       gv_stashpvn(name "", sizeof(name) - 1, flags)
8475 #endif
8476 #ifndef get_cvs
8477 #  define get_cvs(name, flags)           get_cvn_flags(name "", sizeof(name)-1, flags)
8478 #endif
8479 #ifndef SvGETMAGIC
8480 #  define SvGETMAGIC(x)                  STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
8481 #endif
8482
8483 /* That's the best we can do... */
8484 #ifndef sv_catpvn_nomg
8485 #  define sv_catpvn_nomg                 sv_catpvn
8486 #endif
8487
8488 #ifndef sv_catsv_nomg
8489 #  define sv_catsv_nomg                  sv_catsv
8490 #endif
8491
8492 #ifndef sv_setsv_nomg
8493 #  define sv_setsv_nomg                  sv_setsv
8494 #endif
8495
8496 #ifndef sv_pvn_nomg
8497 #  define sv_pvn_nomg                    sv_pvn
8498 #endif
8499
8500 #ifdef SV_NOSTEAL
8501 #ifndef SvIV_nomg
8502 #  define SvIV_nomg(sv)                  (!SvGMAGICAL((sv)) ? SvIV((sv)) : SvIVx(sv_mortalcopy_flags((sv), SV_NOSTEAL)))
8503 #endif
8504
8505 #ifndef SvUV_nomg
8506 #  define SvUV_nomg(sv)                  (!SvGMAGICAL((sv)) ? SvUV((sv)) : SvUVx(sv_mortalcopy_flags((sv), SV_NOSTEAL)))
8507 #endif
8508
8509 #ifndef SvNV_nomg
8510 #  define SvNV_nomg(sv)                  (!SvGMAGICAL((sv)) ? SvNV((sv)) : SvNVx(sv_mortalcopy_flags((sv), SV_NOSTEAL)))
8511 #endif
8512
8513 #ifndef SvTRUE_nomg
8514 #  define SvTRUE_nomg(sv)                (!SvGMAGICAL((sv)) ? SvTRUE((sv)) : SvTRUEx(sv_mortalcopy_flags((sv), SV_NOSTEAL)))
8515 #endif
8516
8517 #endif
8518
8519 #ifndef sv_catpv_mg
8520 #  define sv_catpv_mg(sv, ptr)          \
8521    STMT_START {                         \
8522      SV *TeMpSv = sv;                   \
8523      sv_catpv(TeMpSv,ptr);              \
8524      SvSETMAGIC(TeMpSv);                \
8525    } STMT_END
8526 #endif
8527
8528 #ifndef sv_catpvn_mg
8529 #  define sv_catpvn_mg(sv, ptr, len)    \
8530    STMT_START {                         \
8531      SV *TeMpSv = sv;                   \
8532      sv_catpvn(TeMpSv,ptr,len);         \
8533      SvSETMAGIC(TeMpSv);                \
8534    } STMT_END
8535 #endif
8536
8537 #ifndef sv_catsv_mg
8538 #  define sv_catsv_mg(dsv, ssv)         \
8539    STMT_START {                         \
8540      SV *TeMpSv = dsv;                  \
8541      sv_catsv(TeMpSv,ssv);              \
8542      SvSETMAGIC(TeMpSv);                \
8543    } STMT_END
8544 #endif
8545
8546 #ifndef sv_setiv_mg
8547 #  define sv_setiv_mg(sv, i)            \
8548    STMT_START {                         \
8549      SV *TeMpSv = sv;                   \
8550      sv_setiv(TeMpSv,i);                \
8551      SvSETMAGIC(TeMpSv);                \
8552    } STMT_END
8553 #endif
8554
8555 #ifndef sv_setnv_mg
8556 #  define sv_setnv_mg(sv, num)          \
8557    STMT_START {                         \
8558      SV *TeMpSv = sv;                   \
8559      sv_setnv(TeMpSv,num);              \
8560      SvSETMAGIC(TeMpSv);                \
8561    } STMT_END
8562 #endif
8563
8564 #ifndef sv_setpv_mg
8565 #  define sv_setpv_mg(sv, ptr)          \
8566    STMT_START {                         \
8567      SV *TeMpSv = sv;                   \
8568      sv_setpv(TeMpSv,ptr);              \
8569      SvSETMAGIC(TeMpSv);                \
8570    } STMT_END
8571 #endif
8572
8573 #ifndef sv_setpvn_mg
8574 #  define sv_setpvn_mg(sv, ptr, len)    \
8575    STMT_START {                         \
8576      SV *TeMpSv = sv;                   \
8577      sv_setpvn(TeMpSv,ptr,len);         \
8578      SvSETMAGIC(TeMpSv);                \
8579    } STMT_END
8580 #endif
8581
8582 #ifndef sv_setsv_mg
8583 #  define sv_setsv_mg(dsv, ssv)         \
8584    STMT_START {                         \
8585      SV *TeMpSv = dsv;                  \
8586      sv_setsv(TeMpSv,ssv);              \
8587      SvSETMAGIC(TeMpSv);                \
8588    } STMT_END
8589 #endif
8590
8591 #ifndef sv_setuv_mg
8592 #  define sv_setuv_mg(sv, i)            \
8593    STMT_START {                         \
8594      SV *TeMpSv = sv;                   \
8595      sv_setuv(TeMpSv,i);                \
8596      SvSETMAGIC(TeMpSv);                \
8597    } STMT_END
8598 #endif
8599
8600 #ifndef sv_usepvn_mg
8601 #  define sv_usepvn_mg(sv, ptr, len)    \
8602    STMT_START {                         \
8603      SV *TeMpSv = sv;                   \
8604      sv_usepvn(TeMpSv,ptr,len);         \
8605      SvSETMAGIC(TeMpSv);                \
8606    } STMT_END
8607 #endif
8608 #ifndef SvVSTRING_mg
8609 #  define SvVSTRING_mg(sv)               (SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_vstring) : NULL)
8610 #endif
8611
8612 /* Hint: sv_magic_portable
8613  * This is a compatibility function that is only available with
8614  * Devel::PPPort. It is NOT in the perl core.
8615  * Its purpose is to mimic the 5.8.0 behaviour of sv_magic() when
8616  * it is being passed a name pointer with namlen == 0. In that
8617  * case, perl 5.8.0 and later store the pointer, not a copy of it.
8618  * The compatibility can be provided back to perl 5.004. With
8619  * earlier versions, the code will not compile.
8620  */
8621
8622 #if (PERL_BCDVERSION < 0x5004000)
8623
8624   /* code that uses sv_magic_portable will not compile */
8625
8626 #elif (PERL_BCDVERSION < 0x5008000)
8627
8628 #  define sv_magic_portable(sv, obj, how, name, namlen)     \
8629    STMT_START {                                             \
8630      SV *SvMp_sv = (sv);                                    \
8631      char *SvMp_name = (char *) (name);                     \
8632      I32 SvMp_namlen = (namlen);                            \
8633      if (SvMp_name && SvMp_namlen == 0)                     \
8634      {                                                      \
8635        MAGIC *mg;                                           \
8636        sv_magic(SvMp_sv, obj, how, 0, 0);                   \
8637        mg = SvMAGIC(SvMp_sv);                               \
8638        mg->mg_len = -42; /* XXX: this is the tricky part */ \
8639        mg->mg_ptr = SvMp_name;                              \
8640      }                                                      \
8641      else                                                   \
8642      {                                                      \
8643        sv_magic(SvMp_sv, obj, how, SvMp_name, SvMp_namlen); \
8644      }                                                      \
8645    } STMT_END
8646
8647 #else
8648
8649 #  define sv_magic_portable(a, b, c, d, e)  sv_magic(a, b, c, d, e)
8650
8651 #endif
8652
8653 #if !defined(mg_findext)
8654 #if defined(NEED_mg_findext)
8655 static MAGIC * DPPP_(my_mg_findext)(const SV * sv, int type, const MGVTBL * vtbl);
8656 static
8657 #else
8658 extern MAGIC * DPPP_(my_mg_findext)(const SV * sv, int type, const MGVTBL * vtbl);
8659 #endif
8660
8661 #if defined(NEED_mg_findext) || defined(NEED_mg_findext_GLOBAL)
8662
8663 #define mg_findext DPPP_(my_mg_findext)
8664 #define Perl_mg_findext DPPP_(my_mg_findext)
8665
8666
8667 MAGIC *
8668 DPPP_(my_mg_findext)(const SV * sv, int type, const MGVTBL *vtbl) {
8669     if (sv) {
8670         MAGIC *mg;
8671
8672 #ifdef AvPAD_NAMELIST
8673         assert(!(SvTYPE(sv) == SVt_PVAV && AvPAD_NAMELIST(sv)));
8674 #endif
8675
8676         for (mg = SvMAGIC (sv); mg; mg = mg->mg_moremagic) {
8677             if (mg->mg_type == type && mg->mg_virtual == vtbl)
8678                 return mg;
8679         }
8680     }
8681
8682     return NULL;
8683 }
8684
8685 #endif
8686 #endif
8687
8688 #if !defined(sv_unmagicext)
8689 #if defined(NEED_sv_unmagicext)
8690 static int DPPP_(my_sv_unmagicext)(pTHX_ SV * const sv, const int type, MGVTBL * vtbl);
8691 static
8692 #else
8693 extern int DPPP_(my_sv_unmagicext)(pTHX_ SV * const sv, const int type, MGVTBL * vtbl);
8694 #endif
8695
8696 #if defined(NEED_sv_unmagicext) || defined(NEED_sv_unmagicext_GLOBAL)
8697
8698 #ifdef sv_unmagicext
8699 #  undef sv_unmagicext
8700 #endif
8701 #define sv_unmagicext(a,b,c) DPPP_(my_sv_unmagicext)(aTHX_ a,b,c)
8702 #define Perl_sv_unmagicext DPPP_(my_sv_unmagicext)
8703
8704
8705 int
8706 DPPP_(my_sv_unmagicext)(pTHX_ SV *const sv, const int type, MGVTBL *vtbl)
8707 {
8708     MAGIC* mg;
8709     MAGIC** mgp;
8710
8711     if (SvTYPE(sv) < SVt_PVMG || !SvMAGIC(sv))
8712         return 0;
8713     mgp = &(SvMAGIC(sv));
8714     for (mg = *mgp; mg; mg = *mgp) {
8715         const MGVTBL* const virt = mg->mg_virtual;
8716         if (mg->mg_type == type && virt == vtbl) {
8717             *mgp = mg->mg_moremagic;
8718             if (virt && virt->svt_free)
8719                 virt->svt_free(aTHX_ sv, mg);
8720             if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) {
8721                 if (mg->mg_len > 0)
8722                     Safefree(mg->mg_ptr);
8723                 else if (mg->mg_len == HEf_SVKEY) /* Questionable on older perls... */
8724                     SvREFCNT_dec(MUTABLE_SV(mg->mg_ptr));
8725                 else if (mg->mg_type == PERL_MAGIC_utf8)
8726                     Safefree(mg->mg_ptr);
8727             }
8728             if (mg->mg_flags & MGf_REFCOUNTED)
8729                 SvREFCNT_dec(mg->mg_obj);
8730             Safefree(mg);
8731         }
8732         else
8733             mgp = &mg->mg_moremagic;
8734     }
8735     if (SvMAGIC(sv)) {
8736         if (SvMAGICAL(sv))      /* if we're under save_magic, wait for restore_magic; */
8737             mg_magical(sv);     /*    else fix the flags now */
8738     }
8739     else {
8740         SvMAGICAL_off(sv);
8741         SvFLAGS(sv) |= (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT;
8742     }
8743     return 0;
8744 }
8745
8746 #endif
8747 #endif
8748
8749 #ifdef USE_ITHREADS
8750 #ifndef CopFILE
8751 #  define CopFILE(c)                     ((c)->cop_file)
8752 #endif
8753
8754 #ifndef CopFILEGV
8755 #  define CopFILEGV(c)                   (CopFILE(c) ? gv_fetchfile(CopFILE(c)) : Nullgv)
8756 #endif
8757
8758 #ifndef CopFILE_set
8759 #  define CopFILE_set(c,pv)              ((c)->cop_file = savepv(pv))
8760 #endif
8761
8762 #ifndef CopFILESV
8763 #  define CopFILESV(c)                   (CopFILE(c) ? GvSV(gv_fetchfile(CopFILE(c))) : Nullsv)
8764 #endif
8765
8766 #ifndef CopFILEAV
8767 #  define CopFILEAV(c)                   (CopFILE(c) ? GvAV(gv_fetchfile(CopFILE(c))) : Nullav)
8768 #endif
8769
8770 #ifndef CopSTASHPV
8771 #  define CopSTASHPV(c)                  ((c)->cop_stashpv)
8772 #endif
8773
8774 #ifndef CopSTASHPV_set
8775 #  define CopSTASHPV_set(c,pv)           ((c)->cop_stashpv = ((pv) ? savepv(pv) : Nullch))
8776 #endif
8777
8778 #ifndef CopSTASH
8779 #  define CopSTASH(c)                    (CopSTASHPV(c) ? gv_stashpv(CopSTASHPV(c),GV_ADD) : Nullhv)
8780 #endif
8781
8782 #ifndef CopSTASH_set
8783 #  define CopSTASH_set(c,hv)             CopSTASHPV_set(c, (hv) ? HvNAME(hv) : Nullch)
8784 #endif
8785
8786 #ifndef CopSTASH_eq
8787 #  define CopSTASH_eq(c,hv)              ((hv) && (CopSTASHPV(c) == HvNAME(hv) \
8788                                         || (CopSTASHPV(c) && HvNAME(hv) \
8789                                         && strEQ(CopSTASHPV(c), HvNAME(hv)))))
8790 #endif
8791
8792 #else
8793 #ifndef CopFILEGV
8794 #  define CopFILEGV(c)                   ((c)->cop_filegv)
8795 #endif
8796
8797 #ifndef CopFILEGV_set
8798 #  define CopFILEGV_set(c,gv)            ((c)->cop_filegv = (GV*)SvREFCNT_inc(gv))
8799 #endif
8800
8801 #ifndef CopFILE_set
8802 #  define CopFILE_set(c,pv)              CopFILEGV_set((c), gv_fetchfile(pv))
8803 #endif
8804
8805 #ifndef CopFILESV
8806 #  define CopFILESV(c)                   (CopFILEGV(c) ? GvSV(CopFILEGV(c)) : Nullsv)
8807 #endif
8808
8809 #ifndef CopFILEAV
8810 #  define CopFILEAV(c)                   (CopFILEGV(c) ? GvAV(CopFILEGV(c)) : Nullav)
8811 #endif
8812
8813 #ifndef CopFILE
8814 #  define CopFILE(c)                     (CopFILESV(c) ? SvPVX(CopFILESV(c)) : Nullch)
8815 #endif
8816
8817 #ifndef CopSTASH
8818 #  define CopSTASH(c)                    ((c)->cop_stash)
8819 #endif
8820
8821 #ifndef CopSTASH_set
8822 #  define CopSTASH_set(c,hv)             ((c)->cop_stash = (hv))
8823 #endif
8824
8825 #ifndef CopSTASHPV
8826 #  define CopSTASHPV(c)                  (CopSTASH(c) ? HvNAME(CopSTASH(c)) : Nullch)
8827 #endif
8828
8829 #ifndef CopSTASHPV_set
8830 #  define CopSTASHPV_set(c,pv)           CopSTASH_set((c), gv_stashpv(pv,GV_ADD))
8831 #endif
8832
8833 #ifndef CopSTASH_eq
8834 #  define CopSTASH_eq(c,hv)              (CopSTASH(c) == (hv))
8835 #endif
8836
8837 #endif /* USE_ITHREADS */
8838
8839 #if (PERL_BCDVERSION >= 0x5006000)
8840 #ifndef caller_cx
8841
8842 # if defined(NEED_caller_cx) || defined(NEED_caller_cx_GLOBAL)
8843 static I32
8844 DPPP_dopoptosub_at(const PERL_CONTEXT *cxstk, I32 startingblock)
8845 {
8846     I32 i;
8847
8848     for (i = startingblock; i >= 0; i--) {
8849         register const PERL_CONTEXT * const cx = &cxstk[i];
8850         switch (CxTYPE(cx)) {
8851         default:
8852             continue;
8853         case CXt_EVAL:
8854         case CXt_SUB:
8855         case CXt_FORMAT:
8856             return i;
8857         }
8858     }
8859     return i;
8860 }
8861 # endif
8862
8863 # if defined(NEED_caller_cx)
8864 static const PERL_CONTEXT * DPPP_(my_caller_cx)(pTHX_ I32 level, const PERL_CONTEXT *  * dbcxp);
8865 static
8866 #else
8867 extern const PERL_CONTEXT * DPPP_(my_caller_cx)(pTHX_ I32 level, const PERL_CONTEXT *  * dbcxp);
8868 #endif
8869
8870 #if defined(NEED_caller_cx) || defined(NEED_caller_cx_GLOBAL)
8871
8872 #ifdef caller_cx
8873 #  undef caller_cx
8874 #endif
8875 #define caller_cx(a,b) DPPP_(my_caller_cx)(aTHX_ a,b)
8876 #define Perl_caller_cx DPPP_(my_caller_cx)
8877
8878
8879 const PERL_CONTEXT *
8880 DPPP_(my_caller_cx)(pTHX_ I32 level, const PERL_CONTEXT **dbcxp)
8881 {
8882     register I32 cxix = DPPP_dopoptosub_at(cxstack, cxstack_ix);
8883     register const PERL_CONTEXT *cx;
8884     register const PERL_CONTEXT *ccstack = cxstack;
8885     const PERL_SI *top_si = PL_curstackinfo;
8886
8887     for (;;) {
8888         /* we may be in a higher stacklevel, so dig down deeper */
8889         while (cxix < 0 && top_si->si_type != PERLSI_MAIN) {
8890             top_si = top_si->si_prev;
8891             ccstack = top_si->si_cxstack;
8892             cxix = DPPP_dopoptosub_at(ccstack, top_si->si_cxix);
8893         }
8894         if (cxix < 0)
8895             return NULL;
8896         /* caller() should not report the automatic calls to &DB::sub */
8897         if (PL_DBsub && GvCV(PL_DBsub) && cxix >= 0 &&
8898                 ccstack[cxix].blk_sub.cv == GvCV(PL_DBsub))
8899             level++;
8900         if (!level--)
8901             break;
8902         cxix = DPPP_dopoptosub_at(ccstack, cxix - 1);
8903     }
8904
8905     cx = &ccstack[cxix];
8906     if (dbcxp) *dbcxp = cx;
8907
8908     if (CxTYPE(cx) == CXt_SUB || CxTYPE(cx) == CXt_FORMAT) {
8909         const I32 dbcxix = DPPP_dopoptosub_at(ccstack, cxix - 1);
8910         /* We expect that ccstack[dbcxix] is CXt_SUB, anyway, the
8911            field below is defined for any cx. */
8912         /* caller() should not report the automatic calls to &DB::sub */
8913         if (PL_DBsub && GvCV(PL_DBsub) && dbcxix >= 0 && ccstack[dbcxix].blk_sub.cv == GvCV(PL_DBsub))
8914             cx = &ccstack[dbcxix];
8915     }
8916
8917     return cx;
8918 }
8919
8920 # endif
8921 #endif /* caller_cx */
8922 #endif /* 5.6.0 */
8923 #ifndef IN_PERL_COMPILETIME
8924 #  define IN_PERL_COMPILETIME            (PL_curcop == &PL_compiling)
8925 #endif
8926
8927 #ifndef IN_LOCALE_RUNTIME
8928 #  define IN_LOCALE_RUNTIME              (PL_curcop->op_private & HINT_LOCALE)
8929 #endif
8930
8931 #ifndef IN_LOCALE_COMPILETIME
8932 #  define IN_LOCALE_COMPILETIME          (PL_hints & HINT_LOCALE)
8933 #endif
8934
8935 #ifndef IN_LOCALE
8936 #  define IN_LOCALE                      (IN_PERL_COMPILETIME ? IN_LOCALE_COMPILETIME : IN_LOCALE_RUNTIME)
8937 #endif
8938 #ifndef IS_NUMBER_IN_UV
8939 #  define IS_NUMBER_IN_UV                0x01
8940 #endif
8941
8942 #ifndef IS_NUMBER_GREATER_THAN_UV_MAX
8943 #  define IS_NUMBER_GREATER_THAN_UV_MAX  0x02
8944 #endif
8945
8946 #ifndef IS_NUMBER_NOT_INT
8947 #  define IS_NUMBER_NOT_INT              0x04
8948 #endif
8949
8950 #ifndef IS_NUMBER_NEG
8951 #  define IS_NUMBER_NEG                  0x08
8952 #endif
8953
8954 #ifndef IS_NUMBER_INFINITY
8955 #  define IS_NUMBER_INFINITY             0x10
8956 #endif
8957
8958 #ifndef IS_NUMBER_NAN
8959 #  define IS_NUMBER_NAN                  0x20
8960 #endif
8961 #ifndef GROK_NUMERIC_RADIX
8962 #  define GROK_NUMERIC_RADIX(sp, send)   grok_numeric_radix(sp, send)
8963 #endif
8964 #ifndef PERL_SCAN_GREATER_THAN_UV_MAX
8965 #  define PERL_SCAN_GREATER_THAN_UV_MAX  0x02
8966 #endif
8967
8968 #ifndef PERL_SCAN_SILENT_ILLDIGIT
8969 #  define PERL_SCAN_SILENT_ILLDIGIT      0x04
8970 #endif
8971
8972 #ifndef PERL_SCAN_ALLOW_UNDERSCORES
8973 #  define PERL_SCAN_ALLOW_UNDERSCORES    0x01
8974 #endif
8975
8976 #ifndef PERL_SCAN_DISALLOW_PREFIX
8977 #  define PERL_SCAN_DISALLOW_PREFIX      0x02
8978 #endif
8979
8980 #ifndef grok_numeric_radix
8981 #if defined(NEED_grok_numeric_radix)
8982 static bool DPPP_(my_grok_numeric_radix)(pTHX_ const char *  * sp, const char * send);
8983 static
8984 #else
8985 extern bool DPPP_(my_grok_numeric_radix)(pTHX_ const char *  * sp, const char * send);
8986 #endif
8987
8988 #if defined(NEED_grok_numeric_radix) || defined(NEED_grok_numeric_radix_GLOBAL)
8989
8990 #ifdef grok_numeric_radix
8991 #  undef grok_numeric_radix
8992 #endif
8993 #define grok_numeric_radix(a,b) DPPP_(my_grok_numeric_radix)(aTHX_ a,b)
8994 #define Perl_grok_numeric_radix DPPP_(my_grok_numeric_radix)
8995
8996 bool
8997 DPPP_(my_grok_numeric_radix)(pTHX_ const char **sp, const char *send)
8998 {
8999 #ifdef USE_LOCALE_NUMERIC
9000 #ifdef PL_numeric_radix_sv
9001     if (PL_numeric_radix_sv && IN_LOCALE) {
9002         STRLEN len;
9003         char* radix = SvPV(PL_numeric_radix_sv, len);
9004         if (*sp + len <= send && memEQ(*sp, radix, len)) {
9005             *sp += len;
9006             return TRUE;
9007         }
9008     }
9009 #else
9010     /* older perls don't have PL_numeric_radix_sv so the radix
9011      * must manually be requested from locale.h
9012      */
9013 #include <locale.h>
9014     dTHR;  /* needed for older threaded perls */
9015     struct lconv *lc = localeconv();
9016     char *radix = lc->decimal_point;
9017     if (radix && IN_LOCALE) {
9018         STRLEN len = strlen(radix);
9019         if (*sp + len <= send && memEQ(*sp, radix, len)) {
9020             *sp += len;
9021             return TRUE;
9022         }
9023     }
9024 #endif
9025 #endif /* USE_LOCALE_NUMERIC */
9026     /* always try "." if numeric radix didn't match because
9027      * we may have data from different locales mixed */
9028     if (*sp < send && **sp == '.') {
9029         ++*sp;
9030         return TRUE;
9031     }
9032     return FALSE;
9033 }
9034 #endif
9035 #endif
9036
9037 #ifndef grok_number
9038 #if defined(NEED_grok_number)
9039 static int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep);
9040 static
9041 #else
9042 extern int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep);
9043 #endif
9044
9045 #if defined(NEED_grok_number) || defined(NEED_grok_number_GLOBAL)
9046
9047 #ifdef grok_number
9048 #  undef grok_number
9049 #endif
9050 #define grok_number(a,b,c) DPPP_(my_grok_number)(aTHX_ a,b,c)
9051 #define Perl_grok_number DPPP_(my_grok_number)
9052
9053 int
9054 DPPP_(my_grok_number)(pTHX_ const char *pv, STRLEN len, UV *valuep)
9055 {
9056   const char *s = pv;
9057   const char *send = pv + len;
9058   const UV max_div_10 = UV_MAX / 10;
9059   const char max_mod_10 = UV_MAX % 10;
9060   int numtype = 0;
9061   int sawinf = 0;
9062   int sawnan = 0;
9063
9064   while (s < send && isSPACE(*s))
9065     s++;
9066   if (s == send) {
9067     return 0;
9068   } else if (*s == '-') {
9069     s++;
9070     numtype = IS_NUMBER_NEG;
9071   }
9072   else if (*s == '+')
9073   s++;
9074
9075   if (s == send)
9076     return 0;
9077
9078   /* next must be digit or the radix separator or beginning of infinity */
9079   if (isDIGIT(*s)) {
9080     /* UVs are at least 32 bits, so the first 9 decimal digits cannot
9081        overflow.  */
9082     UV value = *s - '0';
9083     /* This construction seems to be more optimiser friendly.
9084        (without it gcc does the isDIGIT test and the *s - '0' separately)
9085        With it gcc on arm is managing 6 instructions (6 cycles) per digit.
9086        In theory the optimiser could deduce how far to unroll the loop
9087        before checking for overflow.  */
9088     if (++s < send) {
9089       int digit = *s - '0';
9090       if (digit >= 0 && digit <= 9) {
9091         value = value * 10 + digit;
9092         if (++s < send) {
9093           digit = *s - '0';
9094           if (digit >= 0 && digit <= 9) {
9095             value = value * 10 + digit;
9096             if (++s < send) {
9097               digit = *s - '0';
9098               if (digit >= 0 && digit <= 9) {
9099                 value = value * 10 + digit;
9100                 if (++s < send) {
9101                   digit = *s - '0';
9102                   if (digit >= 0 && digit <= 9) {
9103                     value = value * 10 + digit;
9104                     if (++s < send) {
9105                       digit = *s - '0';
9106                       if (digit >= 0 && digit <= 9) {
9107                         value = value * 10 + digit;
9108                         if (++s < send) {
9109                           digit = *s - '0';
9110                           if (digit >= 0 && digit <= 9) {
9111                             value = value * 10 + digit;
9112                             if (++s < send) {
9113                               digit = *s - '0';
9114                               if (digit >= 0 && digit <= 9) {
9115                                 value = value * 10 + digit;
9116                                 if (++s < send) {
9117                                   digit = *s - '0';
9118                                   if (digit >= 0 && digit <= 9) {
9119                                     value = value * 10 + digit;
9120                                     if (++s < send) {
9121                                       /* Now got 9 digits, so need to check
9122                                          each time for overflow.  */
9123                                       digit = *s - '0';
9124                                       while (digit >= 0 && digit <= 9
9125                                              && (value < max_div_10
9126                                                  || (value == max_div_10
9127                                                      && digit <= max_mod_10))) {
9128                                         value = value * 10 + digit;
9129                                         if (++s < send)
9130                                           digit = *s - '0';
9131                                         else
9132                                           break;
9133                                       }
9134                                       if (digit >= 0 && digit <= 9
9135                                           && (s < send)) {
9136                                         /* value overflowed.
9137                                            skip the remaining digits, don't
9138                                            worry about setting *valuep.  */
9139                                         do {
9140                                           s++;
9141                                         } while (s < send && isDIGIT(*s));
9142                                         numtype |=
9143                                           IS_NUMBER_GREATER_THAN_UV_MAX;
9144                                         goto skip_value;
9145                                       }
9146                                     }
9147                                   }
9148                                 }
9149                               }
9150                             }
9151                           }
9152                         }
9153                       }
9154                     }
9155                   }
9156                 }
9157               }
9158             }
9159           }
9160         }
9161       }
9162     }
9163     numtype |= IS_NUMBER_IN_UV;
9164     if (valuep)
9165       *valuep = value;
9166
9167   skip_value:
9168     if (GROK_NUMERIC_RADIX(&s, send)) {
9169       numtype |= IS_NUMBER_NOT_INT;
9170       while (s < send && isDIGIT(*s))  /* optional digits after the radix */
9171         s++;
9172     }
9173   }
9174   else if (GROK_NUMERIC_RADIX(&s, send)) {
9175     numtype |= IS_NUMBER_NOT_INT | IS_NUMBER_IN_UV; /* valuep assigned below */
9176     /* no digits before the radix means we need digits after it */
9177     if (s < send && isDIGIT(*s)) {
9178       do {
9179         s++;
9180       } while (s < send && isDIGIT(*s));
9181       if (valuep) {
9182         /* integer approximation is valid - it's 0.  */
9183         *valuep = 0;
9184       }
9185     }
9186     else
9187       return 0;
9188   } else if (*s == 'I' || *s == 'i') {
9189     s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
9190     s++; if (s == send || (*s != 'F' && *s != 'f')) return 0;
9191     s++; if (s < send && (*s == 'I' || *s == 'i')) {
9192       s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
9193       s++; if (s == send || (*s != 'I' && *s != 'i')) return 0;
9194       s++; if (s == send || (*s != 'T' && *s != 't')) return 0;
9195       s++; if (s == send || (*s != 'Y' && *s != 'y')) return 0;
9196       s++;
9197     }
9198     sawinf = 1;
9199   } else if (*s == 'N' || *s == 'n') {
9200     /* XXX TODO: There are signaling NaNs and quiet NaNs. */
9201     s++; if (s == send || (*s != 'A' && *s != 'a')) return 0;
9202     s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
9203     s++;
9204     sawnan = 1;
9205   } else
9206     return 0;
9207
9208   if (sawinf) {
9209     numtype &= IS_NUMBER_NEG; /* Keep track of sign  */
9210     numtype |= IS_NUMBER_INFINITY | IS_NUMBER_NOT_INT;
9211   } else if (sawnan) {
9212     numtype &= IS_NUMBER_NEG; /* Keep track of sign  */
9213     numtype |= IS_NUMBER_NAN | IS_NUMBER_NOT_INT;
9214   } else if (s < send) {
9215     /* we can have an optional exponent part */
9216     if (*s == 'e' || *s == 'E') {
9217       /* The only flag we keep is sign.  Blow away any "it's UV"  */
9218       numtype &= IS_NUMBER_NEG;
9219       numtype |= IS_NUMBER_NOT_INT;
9220       s++;
9221       if (s < send && (*s == '-' || *s == '+'))
9222         s++;
9223       if (s < send && isDIGIT(*s)) {
9224         do {
9225           s++;
9226         } while (s < send && isDIGIT(*s));
9227       }
9228       else
9229       return 0;
9230     }
9231   }
9232   while (s < send && isSPACE(*s))
9233     s++;
9234   if (s >= send)
9235     return numtype;
9236   if (len == 10 && memEQ(pv, "0 but true", 10)) {
9237     if (valuep)
9238       *valuep = 0;
9239     return IS_NUMBER_IN_UV;
9240   }
9241   return 0;
9242 }
9243 #endif
9244 #endif
9245
9246 /*
9247  * The grok_* routines have been modified to use warn() instead of
9248  * Perl_warner(). Also, 'hexdigit' was the former name of PL_hexdigit,
9249  * which is why the stack variable has been renamed to 'xdigit'.
9250  */
9251
9252 #ifndef grok_bin
9253 #if defined(NEED_grok_bin)
9254 static UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
9255 static
9256 #else
9257 extern UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
9258 #endif
9259
9260 #if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL)
9261
9262 #ifdef grok_bin
9263 #  undef grok_bin
9264 #endif
9265 #define grok_bin(a,b,c,d) DPPP_(my_grok_bin)(aTHX_ a,b,c,d)
9266 #define Perl_grok_bin DPPP_(my_grok_bin)
9267
9268 UV
9269 DPPP_(my_grok_bin)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
9270 {
9271     const char *s = start;
9272     STRLEN len = *len_p;
9273     UV value = 0;
9274     NV value_nv = 0;
9275
9276     const UV max_div_2 = UV_MAX / 2;
9277     bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;
9278     bool overflowed = FALSE;
9279
9280     if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) {
9281         /* strip off leading b or 0b.
9282            for compatibility silently suffer "b" and "0b" as valid binary
9283            numbers. */
9284         if (len >= 1) {
9285             if (s[0] == 'b') {
9286                 s++;
9287                 len--;
9288             }
9289             else if (len >= 2 && s[0] == '0' && s[1] == 'b') {
9290                 s+=2;
9291                 len-=2;
9292             }
9293         }
9294     }
9295
9296     for (; len-- && *s; s++) {
9297         char bit = *s;
9298         if (bit == '0' || bit == '1') {
9299             /* Write it in this wonky order with a goto to attempt to get the
9300                compiler to make the common case integer-only loop pretty tight.
9301                With gcc seems to be much straighter code than old scan_bin.  */
9302           redo:
9303             if (!overflowed) {
9304                 if (value <= max_div_2) {
9305                     value = (value << 1) | (bit - '0');
9306                     continue;
9307                 }
9308                 /* Bah. We're just overflowed.  */
9309                 warn("Integer overflow in binary number");
9310                 overflowed = TRUE;
9311                 value_nv = (NV) value;
9312             }
9313             value_nv *= 2.0;
9314             /* If an NV has not enough bits in its mantissa to
9315              * represent a UV this summing of small low-order numbers
9316              * is a waste of time (because the NV cannot preserve
9317              * the low-order bits anyway): we could just remember when
9318              * did we overflow and in the end just multiply value_nv by the
9319              * right amount. */
9320             value_nv += (NV)(bit - '0');
9321             continue;
9322         }
9323         if (bit == '_' && len && allow_underscores && (bit = s[1])
9324             && (bit == '0' || bit == '1'))
9325             {
9326                 --len;
9327                 ++s;
9328                 goto redo;
9329             }
9330         if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))
9331             warn("Illegal binary digit '%c' ignored", *s);
9332         break;
9333     }
9334
9335     if (   ( overflowed && value_nv > 4294967295.0)
9336 #if UVSIZE > 4
9337         || (!overflowed && value > 0xffffffff  )
9338 #endif
9339         ) {
9340         warn("Binary number > 0b11111111111111111111111111111111 non-portable");
9341     }
9342     *len_p = s - start;
9343     if (!overflowed) {
9344         *flags = 0;
9345         return value;
9346     }
9347     *flags = PERL_SCAN_GREATER_THAN_UV_MAX;
9348     if (result)
9349         *result = value_nv;
9350     return UV_MAX;
9351 }
9352 #endif
9353 #endif
9354
9355 #ifndef grok_hex
9356 #if defined(NEED_grok_hex)
9357 static UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
9358 static
9359 #else
9360 extern UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
9361 #endif
9362
9363 #if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL)
9364
9365 #ifdef grok_hex
9366 #  undef grok_hex
9367 #endif
9368 #define grok_hex(a,b,c,d) DPPP_(my_grok_hex)(aTHX_ a,b,c,d)
9369 #define Perl_grok_hex DPPP_(my_grok_hex)
9370
9371 UV
9372 DPPP_(my_grok_hex)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
9373 {
9374     const char *s = start;
9375     STRLEN len = *len_p;
9376     UV value = 0;
9377     NV value_nv = 0;
9378
9379     const UV max_div_16 = UV_MAX / 16;
9380     bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;
9381     bool overflowed = FALSE;
9382     const char *xdigit;
9383
9384     if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) {
9385         /* strip off leading x or 0x.
9386            for compatibility silently suffer "x" and "0x" as valid hex numbers.
9387         */
9388         if (len >= 1) {
9389             if (s[0] == 'x') {
9390                 s++;
9391                 len--;
9392             }
9393             else if (len >= 2 && s[0] == '0' && s[1] == 'x') {
9394                 s+=2;
9395                 len-=2;
9396             }
9397         }
9398     }
9399
9400     for (; len-- && *s; s++) {
9401         xdigit = strchr((char *) PL_hexdigit, *s);
9402         if (xdigit) {
9403             /* Write it in this wonky order with a goto to attempt to get the
9404                compiler to make the common case integer-only loop pretty tight.
9405                With gcc seems to be much straighter code than old scan_hex.  */
9406           redo:
9407             if (!overflowed) {
9408                 if (value <= max_div_16) {
9409                     value = (value << 4) | ((xdigit - PL_hexdigit) & 15);
9410                     continue;
9411                 }
9412                 warn("Integer overflow in hexadecimal number");
9413                 overflowed = TRUE;
9414                 value_nv = (NV) value;
9415             }
9416             value_nv *= 16.0;
9417             /* If an NV has not enough bits in its mantissa to
9418              * represent a UV this summing of small low-order numbers
9419              * is a waste of time (because the NV cannot preserve
9420              * the low-order bits anyway): we could just remember when
9421              * did we overflow and in the end just multiply value_nv by the
9422              * right amount of 16-tuples. */
9423             value_nv += (NV)((xdigit - PL_hexdigit) & 15);
9424             continue;
9425         }
9426         if (*s == '_' && len && allow_underscores && s[1]
9427                 && (xdigit = strchr((char *) PL_hexdigit, s[1])))
9428             {
9429                 --len;
9430                 ++s;
9431                 goto redo;
9432             }
9433         if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))
9434             warn("Illegal hexadecimal digit '%c' ignored", *s);
9435         break;
9436     }
9437
9438     if (   ( overflowed && value_nv > 4294967295.0)
9439 #if UVSIZE > 4
9440         || (!overflowed && value > 0xffffffff  )
9441 #endif
9442         ) {
9443         warn("Hexadecimal number > 0xffffffff non-portable");
9444     }
9445     *len_p = s - start;
9446     if (!overflowed) {
9447         *flags = 0;
9448         return value;
9449     }
9450     *flags = PERL_SCAN_GREATER_THAN_UV_MAX;
9451     if (result)
9452         *result = value_nv;
9453     return UV_MAX;
9454 }
9455 #endif
9456 #endif
9457
9458 #ifndef grok_oct
9459 #if defined(NEED_grok_oct)
9460 static UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
9461 static
9462 #else
9463 extern UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
9464 #endif
9465
9466 #if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL)
9467
9468 #ifdef grok_oct
9469 #  undef grok_oct
9470 #endif
9471 #define grok_oct(a,b,c,d) DPPP_(my_grok_oct)(aTHX_ a,b,c,d)
9472 #define Perl_grok_oct DPPP_(my_grok_oct)
9473
9474 UV
9475 DPPP_(my_grok_oct)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
9476 {
9477     const char *s = start;
9478     STRLEN len = *len_p;
9479     UV value = 0;
9480     NV value_nv = 0;
9481
9482     const UV max_div_8 = UV_MAX / 8;
9483     bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;
9484     bool overflowed = FALSE;
9485
9486     for (; len-- && *s; s++) {
9487          /* gcc 2.95 optimiser not smart enough to figure that this subtraction
9488             out front allows slicker code.  */
9489         int digit = *s - '0';
9490         if (digit >= 0 && digit <= 7) {
9491             /* Write it in this wonky order with a goto to attempt to get the
9492                compiler to make the common case integer-only loop pretty tight.
9493             */
9494           redo:
9495             if (!overflowed) {
9496                 if (value <= max_div_8) {
9497                     value = (value << 3) | digit;
9498                     continue;
9499                 }
9500                 /* Bah. We're just overflowed.  */
9501                 warn("Integer overflow in octal number");
9502                 overflowed = TRUE;
9503                 value_nv = (NV) value;
9504             }
9505             value_nv *= 8.0;
9506             /* If an NV has not enough bits in its mantissa to
9507              * represent a UV this summing of small low-order numbers
9508              * is a waste of time (because the NV cannot preserve
9509              * the low-order bits anyway): we could just remember when
9510              * did we overflow and in the end just multiply value_nv by the
9511              * right amount of 8-tuples. */
9512             value_nv += (NV)digit;
9513             continue;
9514         }
9515         if (digit == ('_' - '0') && len && allow_underscores
9516             && (digit = s[1] - '0') && (digit >= 0 && digit <= 7))
9517             {
9518                 --len;
9519                 ++s;
9520                 goto redo;
9521             }
9522         /* Allow \octal to work the DWIM way (that is, stop scanning
9523          * as soon as non-octal characters are seen, complain only iff
9524          * someone seems to want to use the digits eight and nine). */
9525         if (digit == 8 || digit == 9) {
9526             if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))
9527                 warn("Illegal octal digit '%c' ignored", *s);
9528         }
9529         break;
9530     }
9531
9532     if (   ( overflowed && value_nv > 4294967295.0)
9533 #if UVSIZE > 4
9534         || (!overflowed && value > 0xffffffff  )
9535 #endif
9536         ) {
9537         warn("Octal number > 037777777777 non-portable");
9538     }
9539     *len_p = s - start;
9540     if (!overflowed) {
9541         *flags = 0;
9542         return value;
9543     }
9544     *flags = PERL_SCAN_GREATER_THAN_UV_MAX;
9545     if (result)
9546         *result = value_nv;
9547     return UV_MAX;
9548 }
9549 #endif
9550 #endif
9551
9552 #if !defined(my_snprintf)
9553 #if defined(NEED_my_snprintf)
9554 static int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...);
9555 static
9556 #else
9557 extern int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...);
9558 #endif
9559
9560 #if defined(NEED_my_snprintf) || defined(NEED_my_snprintf_GLOBAL)
9561
9562 #define my_snprintf DPPP_(my_my_snprintf)
9563 #define Perl_my_snprintf DPPP_(my_my_snprintf)
9564
9565
9566 int
9567 DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...)
9568 {
9569     dTHX;
9570     int retval;
9571     va_list ap;
9572     va_start(ap, format);
9573 #ifdef HAS_VSNPRINTF
9574     retval = vsnprintf(buffer, len, format, ap);
9575 #else
9576     retval = vsprintf(buffer, format, ap);
9577 #endif
9578     va_end(ap);
9579     if (retval < 0 || (len > 0 && (Size_t)retval >= len))
9580         Perl_croak(aTHX_ "panic: my_snprintf buffer overflow");
9581     return retval;
9582 }
9583
9584 #endif
9585 #endif
9586
9587 #if !defined(my_sprintf)
9588 #if defined(NEED_my_sprintf)
9589 static int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...);
9590 static
9591 #else
9592 extern int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...);
9593 #endif
9594
9595 #if defined(NEED_my_sprintf) || defined(NEED_my_sprintf_GLOBAL)
9596
9597 #define my_sprintf DPPP_(my_my_sprintf)
9598
9599
9600 /* Warning: my_sprintf
9601    It's safer to use my_snprintf instead
9602 */
9603
9604 /* Replace my_sprintf with my_snprintf */
9605
9606 int
9607 DPPP_(my_my_sprintf)(char *buffer, const char* pat, ...)
9608 {
9609     va_list args;
9610     va_start(args, pat);
9611     vsprintf(buffer, pat, args);
9612     va_end(args);
9613     return strlen(buffer);
9614 }
9615
9616 #endif
9617 #endif
9618
9619 #ifdef NO_XSLOCKS
9620 #  ifdef dJMPENV
9621 #    define dXCPT             dJMPENV; int rEtV = 0
9622 #    define XCPT_TRY_START    JMPENV_PUSH(rEtV); if (rEtV == 0)
9623 #    define XCPT_TRY_END      JMPENV_POP;
9624 #    define XCPT_CATCH        if (rEtV != 0)
9625 #    define XCPT_RETHROW      JMPENV_JUMP(rEtV)
9626 #  else
9627 #    define dXCPT             Sigjmp_buf oldTOP; int rEtV = 0
9628 #    define XCPT_TRY_START    Copy(top_env, oldTOP, 1, Sigjmp_buf); rEtV = Sigsetjmp(top_env, 1); if (rEtV == 0)
9629 #    define XCPT_TRY_END      Copy(oldTOP, top_env, 1, Sigjmp_buf);
9630 #    define XCPT_CATCH        if (rEtV != 0)
9631 #    define XCPT_RETHROW      Siglongjmp(top_env, rEtV)
9632 #  endif
9633 #endif
9634
9635 #if !defined(my_strlcat)
9636 #if defined(NEED_my_strlcat)
9637 static Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size);
9638 static
9639 #else
9640 extern Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size);
9641 #endif
9642
9643 #if defined(NEED_my_strlcat) || defined(NEED_my_strlcat_GLOBAL)
9644
9645 #define my_strlcat DPPP_(my_my_strlcat)
9646 #define Perl_my_strlcat DPPP_(my_my_strlcat)
9647
9648
9649 Size_t
9650 DPPP_(my_my_strlcat)(char *dst, const char *src, Size_t size)
9651 {
9652     Size_t used, length, copy;
9653
9654     used = strlen(dst);
9655     length = strlen(src);
9656     if (size > 0 && used < size - 1) {
9657         copy = (length >= size - used) ? size - used - 1 : length;
9658         memcpy(dst + used, src, copy);
9659         dst[used + copy] = '\0';
9660     }
9661     return used + length;
9662 }
9663 #endif
9664 #endif
9665
9666 #if !defined(my_strlcpy)
9667 #if defined(NEED_my_strlcpy)
9668 static Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size);
9669 static
9670 #else
9671 extern Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size);
9672 #endif
9673
9674 #if defined(NEED_my_strlcpy) || defined(NEED_my_strlcpy_GLOBAL)
9675
9676 #define my_strlcpy DPPP_(my_my_strlcpy)
9677 #define Perl_my_strlcpy DPPP_(my_my_strlcpy)
9678
9679
9680 Size_t
9681 DPPP_(my_my_strlcpy)(char *dst, const char *src, Size_t size)
9682 {
9683     Size_t length, copy;
9684
9685     length = strlen(src);
9686     if (size > 0) {
9687         copy = (length >= size) ? size - 1 : length;
9688         memcpy(dst, src, copy);
9689         dst[copy] = '\0';
9690     }
9691     return length;
9692 }
9693
9694 #endif
9695 #endif
9696
9697 #define D_PPP_MIN(a,b) (((a) <= (b)) ? (a) : (b))
9698 #ifndef UNICODE_REPLACEMENT
9699 #  define UNICODE_REPLACEMENT            0xFFFD
9700 #endif
9701
9702 #ifdef UTF8_MAXLEN
9703 #ifndef UTF8_MAXBYTES
9704 #  define UTF8_MAXBYTES                  UTF8_MAXLEN
9705 #endif
9706
9707 #endif
9708 #ifndef UTF_START_MARK
9709 #  define UTF_START_MARK(len)            \
9710                     (((len) >  7) ? 0xFF : (0xFF & (0xFE << (7-(len)))))
9711 #endif
9712
9713 #if (PERL_BCDVERSION < 0x5018000)     /* On non-EBCDIC was valid before this, */
9714                             /* but easier to just do one check */
9715 #  undef UTF8_MAXBYTES_CASE
9716 #endif
9717
9718 #if 'A' == 65
9719 #  define D_PPP_BYTE_INFO_BITS 6  /* 6 bits meaningful in continuation bytes */
9720 #ifndef UTF8_MAXBYTES_CASE
9721 #  define UTF8_MAXBYTES_CASE             13
9722 #endif
9723
9724 #else
9725 #  define D_PPP_BYTE_INFO_BITS 5  /* 5 bits meaningful in continuation bytes */
9726 #ifndef UTF8_MAXBYTES_CASE
9727 #  define UTF8_MAXBYTES_CASE             15
9728 #endif
9729
9730 #endif
9731 #ifndef UTF_ACCUMULATION_SHIFT
9732 #  define UTF_ACCUMULATION_SHIFT         D_PPP_BYTE_INFO_BITS
9733 #endif
9734
9735 #ifdef NATIVE_TO_UTF
9736 #ifndef NATIVE_UTF8_TO_I8
9737 #  define NATIVE_UTF8_TO_I8(c)           NATIVE_TO_UTF(c)
9738 #endif
9739
9740 #else   /* System doesn't support EBCDIC */
9741 #ifndef NATIVE_UTF8_TO_I8
9742 #  define NATIVE_UTF8_TO_I8(c)           (c)
9743 #endif
9744
9745 #endif
9746
9747 #ifdef UTF_TO_NATIVE
9748 #ifndef I8_TO_NATIVE_UTF8
9749 #  define I8_TO_NATIVE_UTF8(c)           UTF_TO_NATIVE(c)
9750 #endif
9751
9752 #else   /* System doesn't support EBCDIC */
9753 #ifndef I8_TO_NATIVE_UTF8
9754 #  define I8_TO_NATIVE_UTF8(c)           (c)
9755 #endif
9756
9757 #endif
9758 #ifndef UTF_START_MASK
9759 #  define UTF_START_MASK(len)            \
9760                                 (((len) >= 7) ? 0x00 : (0x1F >> ((len)-2)))
9761 #endif
9762
9763 #ifndef UTF_IS_CONTINUATION_MASK
9764 #  define UTF_IS_CONTINUATION_MASK       \
9765                                     ((U8) (0xFF << UTF_ACCUMULATION_SHIFT))
9766 #endif
9767
9768 #ifndef UTF_CONTINUATION_MARK
9769 #  define UTF_CONTINUATION_MARK          \
9770                                           (UTF_IS_CONTINUATION_MASK & 0xB0)
9771 #endif
9772
9773 #ifndef UTF_MIN_START_BYTE
9774 #  define UTF_MIN_START_BYTE             \
9775     ((UTF_CONTINUATION_MARK >> UTF_ACCUMULATION_SHIFT) | UTF_START_MARK(2))
9776 #endif
9777 #ifndef UTF_MIN_ABOVE_LATIN1_BYTE
9778 #  define UTF_MIN_ABOVE_LATIN1_BYTE      \
9779                     ((0x100 >> UTF_ACCUMULATION_SHIFT) | UTF_START_MARK(2))
9780 #endif
9781
9782 #if (PERL_BCDVERSION < 0x5007000)     /* Was the complement of what should have been */
9783 #  undef UTF8_IS_DOWNGRADEABLE_START
9784 #endif
9785 #ifndef UTF8_IS_DOWNGRADEABLE_START
9786 #  define UTF8_IS_DOWNGRADEABLE_START(c) \
9787                 inRANGE(NATIVE_UTF8_TO_I8(c),                               \
9788                         UTF_MIN_START_BYTE, UTF_MIN_ABOVE_LATIN1_BYTE - 1)
9789 #endif
9790
9791 #ifndef UTF_CONTINUATION_MASK
9792 #  define UTF_CONTINUATION_MASK          \
9793                                 ((U8) ((1U << UTF_ACCUMULATION_SHIFT) - 1))
9794 #endif
9795 #ifndef UTF8_ACCUMULATE
9796 #  define UTF8_ACCUMULATE(base, added)   \
9797                                   (((base) << UTF_ACCUMULATION_SHIFT)       \
9798                                    | ((NATIVE_UTF8_TO_I8(added))            \
9799                                        & UTF_CONTINUATION_MASK))
9800 #endif
9801 #ifndef UTF8_ALLOW_ANYUV
9802 #  define UTF8_ALLOW_ANYUV               0
9803 #endif
9804
9805 #ifndef UTF8_ALLOW_EMPTY
9806 #  define UTF8_ALLOW_EMPTY               0x0001
9807 #endif
9808
9809 #ifndef UTF8_ALLOW_CONTINUATION
9810 #  define UTF8_ALLOW_CONTINUATION        0x0002
9811 #endif
9812
9813 #ifndef UTF8_ALLOW_NON_CONTINUATION
9814 #  define UTF8_ALLOW_NON_CONTINUATION    0x0004
9815 #endif
9816
9817 #ifndef UTF8_ALLOW_SHORT
9818 #  define UTF8_ALLOW_SHORT               0x0008
9819 #endif
9820
9821 #ifndef UTF8_ALLOW_LONG
9822 #  define UTF8_ALLOW_LONG                0x0010
9823 #endif
9824
9825 #ifndef UTF8_ALLOW_OVERFLOW
9826 #  define UTF8_ALLOW_OVERFLOW            0x0080
9827 #endif
9828
9829 #ifndef UTF8_ALLOW_ANY
9830 #  define UTF8_ALLOW_ANY                 ( UTF8_ALLOW_CONTINUATION      \
9831                                         |UTF8_ALLOW_NON_CONTINUATION  \
9832                                         |UTF8_ALLOW_SHORT             \
9833                                         |UTF8_ALLOW_LONG              \
9834                                         |UTF8_ALLOW_OVERFLOW)
9835 #endif
9836
9837 #if defined UTF8SKIP
9838
9839 /* Don't use official versions because they use MIN, which may not be available */
9840 #undef UTF8_SAFE_SKIP
9841 #undef UTF8_CHK_SKIP
9842 #ifndef UTF8_SAFE_SKIP
9843 #  define UTF8_SAFE_SKIP(s, e)           (                                          \
9844                                       ((((e) - (s)) <= 0)                       \
9845                                       ? 0                                       \
9846                                       : D_PPP_MIN(((e) - (s)), UTF8SKIP(s))))
9847 #endif
9848 #ifndef UTF8_CHK_SKIP
9849 #  define UTF8_CHK_SKIP(s)               \
9850     (s[0] == '\0' ? 1 : ((U8) D_PPP_MIN(my_strnlen((char *) (s), UTF8SKIP(s)),  \
9851                                       UTF8SKIP(s))))
9852 #endif
9853
9854 #ifndef UTF8_SKIP
9855 #  define UTF8_SKIP(s)                   UTF8SKIP(s)
9856 #endif
9857
9858 #endif
9859
9860 #if 'A' == 65
9861 #ifndef UTF8_IS_INVARIANT
9862 #  define UTF8_IS_INVARIANT(c)           isASCII(c)
9863 #endif
9864
9865 #else
9866 #ifndef UTF8_IS_INVARIANT
9867 #  define UTF8_IS_INVARIANT(c)           (isASCII(c) || isCNTRL_L1(c))
9868 #endif
9869
9870 #endif
9871 #ifndef UVCHR_IS_INVARIANT
9872 #  define UVCHR_IS_INVARIANT(c)          UTF8_IS_INVARIANT(c)
9873 #endif
9874
9875 #ifdef UVCHR_IS_INVARIANT
9876 #  if 'A' == 65
9877 #    ifdef QUADKIND
9878 #      define D_PPP_UVCHR_SKIP_UPPER(c)                                         \
9879           (WIDEST_UTYPE) (c) <                                                  \
9880         (((WIDEST_UTYPE) 1) << (6 * D_PPP_BYTE_INFO_BITS)) ? 7 : 13
9881 #    else
9882 #      define D_PPP_UVCHR_SKIP_UPPER(c) 7  /* 32 bit platform */
9883 #    endif
9884 #  else
9885      /* In the releases this is backported to, UTF-EBCDIC had a max of 2**31-1 */
9886 #    define D_PPP_UVCHR_SKIP_UPPER(c) 7
9887 #  endif
9888 #ifndef UVCHR_SKIP
9889 #  define UVCHR_SKIP(c)                  \
9890           UVCHR_IS_INVARIANT(c)                                          ? 1 :  \
9891           (WIDEST_UTYPE) (c) < (32 * (1U << (    D_PPP_BYTE_INFO_BITS))) ? 2 :  \
9892           (WIDEST_UTYPE) (c) < (16 * (1U << (2 * D_PPP_BYTE_INFO_BITS))) ? 3 :  \
9893           (WIDEST_UTYPE) (c) < ( 8 * (1U << (3 * D_PPP_BYTE_INFO_BITS))) ? 4 :  \
9894           (WIDEST_UTYPE) (c) < ( 4 * (1U << (4 * D_PPP_BYTE_INFO_BITS))) ? 5 :  \
9895           (WIDEST_UTYPE) (c) < ( 2 * (1U << (5 * D_PPP_BYTE_INFO_BITS))) ? 6 :  \
9896           D_PPP_UVCHR_SKIP_UPPER(c)
9897 #endif
9898
9899 #endif
9900
9901 #ifdef is_ascii_string
9902 #ifndef is_invariant_string
9903 #  define is_invariant_string(s,l)       is_ascii_string(s,l)
9904 #endif
9905
9906 #ifndef is_utf8_invariant_string
9907 #  define is_utf8_invariant_string(s,l)  is_ascii_string(s,l)
9908 #endif
9909
9910 /* Hint: is_ascii_string, is_invariant_string
9911    is_utf8_invariant_string() does the same thing and is preferred because its
9912    name is more accurate as to what it does */
9913 #endif
9914
9915 #ifdef ibcmp_utf8
9916 #ifndef foldEQ_utf8
9917 #  define foldEQ_utf8(s1,pe1,l1,u1,s2,pe2,l2,u2) \
9918                                 cBOOL(! ibcmp_utf8(s1,pe1,l1,u1,s2,pe2,l2,u2))
9919 #endif
9920
9921 #endif
9922
9923 #if defined(is_utf8_string) && defined(UTF8SKIP)
9924 #ifndef isUTF8_CHAR
9925 #  define isUTF8_CHAR(s, e)              (                                            \
9926     (e) <= (s) || ! is_utf8_string(s, UTF8_SAFE_SKIP(s, e))                     \
9927     ? 0                                                                         \
9928     : UTF8SKIP(s))
9929 #endif
9930
9931 #endif
9932
9933 #if 'A' == 65
9934 #ifndef BOM_UTF8
9935 #  define BOM_UTF8                       "\xEF\xBB\xBF"
9936 #endif
9937
9938 #ifndef REPLACEMENT_CHARACTER_UTF8
9939 #  define REPLACEMENT_CHARACTER_UTF8     "\xEF\xBF\xBD"
9940 #endif
9941
9942 #elif '^' == 95
9943 #ifndef BOM_UTF8
9944 #  define BOM_UTF8                       "\xDD\x73\x66\x73"
9945 #endif
9946
9947 #ifndef REPLACEMENT_CHARACTER_UTF8
9948 #  define REPLACEMENT_CHARACTER_UTF8     "\xDD\x73\x73\x71"
9949 #endif
9950
9951 #elif '^' == 176
9952 #ifndef BOM_UTF8
9953 #  define BOM_UTF8                       "\xDD\x72\x65\x72"
9954 #endif
9955
9956 #ifndef REPLACEMENT_CHARACTER_UTF8
9957 #  define REPLACEMENT_CHARACTER_UTF8     "\xDD\x72\x72\x70"
9958 #endif
9959
9960 #else
9961 #  error Unknown character set
9962 #endif
9963
9964 #if (PERL_BCDVERSION < 0x5031004)
9965         /* Versions prior to this accepted things that are now considered
9966          * malformations, and didn't return -1 on error with warnings enabled
9967          * */
9968 #  undef utf8_to_uvchr_buf
9969 #endif
9970
9971 /* This implementation brings modern, generally more restricted standards to
9972  * utf8_to_uvchr_buf.  Some of these are security related, and clearly must
9973  * be done.  But its arguable that the others need not, and hence should not.
9974  * The reason they're here is that a module that intends to play with the
9975  * latest perls should be able to work the same in all releases.  An example is
9976  * that perl no longer accepts any UV for a code point, but limits them to
9977  * IV_MAX or below.  This is for future internal use of the larger code points.
9978  * If it turns out that some of these changes are breaking code that isn't
9979  * intended to work with modern perls, the tighter restrictions could be
9980  * relaxed.  khw thinks this is unlikely, but has been wrong in the past. */
9981
9982 /* 5.6.0 is the first release with UTF-8, and we don't implement this function
9983  * there due to its likely lack of still being in use, and the underlying
9984  * implementation is very different from later ones, without the later
9985  * safeguards, so would require extra work to deal with */
9986 #if (PERL_BCDVERSION >= 0x5006001) && ! defined(utf8_to_uvchr_buf)
9987    /* Choose which underlying implementation to use.  At least one must be
9988     * present or the perl is too early to handle this function */
9989 #  if defined(utf8n_to_uvchr) || defined(utf8_to_uvchr) || defined(utf8_to_uv)
9990 #    if defined(utf8n_to_uvchr)   /* This is the preferred implementation */
9991 #      define D_PPP_utf8_to_uvchr_buf_callee utf8n_to_uvchr
9992 #    elif /* Must be at least 5.6.1 from #if above;                             \
9993              If have both regular and _simple, regular has all args */          \
9994           defined(utf8_to_uv) && defined(utf8_to_uv_simple)
9995 #      define D_PPP_utf8_to_uvchr_buf_callee utf8_to_uv
9996 #    elif defined(utf8_to_uvchr)  /* The below won't work well on error input */
9997 #      define D_PPP_utf8_to_uvchr_buf_callee(s, curlen, retlen, flags)          \
9998                                             utf8_to_uvchr((U8 *)(s), (retlen))
9999 #    else
10000 #      define D_PPP_utf8_to_uvchr_buf_callee(s, curlen, retlen, flags)          \
10001                                             utf8_to_uv((U8 *)(s), (retlen))
10002 #    endif
10003 #  endif
10004
10005 #  if defined(NEED_utf8_to_uvchr_buf)
10006 static UV DPPP_(my_utf8_to_uvchr_buf)(pTHX_ const U8 * s, const U8 * send, STRLEN * retlen);
10007 static
10008 #else
10009 extern UV DPPP_(my_utf8_to_uvchr_buf)(pTHX_ const U8 * s, const U8 * send, STRLEN * retlen);
10010 #endif
10011
10012 #if defined(NEED_utf8_to_uvchr_buf) || defined(NEED_utf8_to_uvchr_buf_GLOBAL)
10013
10014 #ifdef utf8_to_uvchr_buf
10015 #  undef utf8_to_uvchr_buf
10016 #endif
10017 #define utf8_to_uvchr_buf(a,b,c) DPPP_(my_utf8_to_uvchr_buf)(aTHX_ a,b,c)
10018 #define Perl_utf8_to_uvchr_buf DPPP_(my_utf8_to_uvchr_buf)
10019
10020
10021 UV
10022 DPPP_(my_utf8_to_uvchr_buf)(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen)
10023 {
10024     UV ret;
10025     STRLEN curlen;
10026     bool overflows = 0;
10027     const U8 *cur_s = s;
10028     const bool do_warnings = ckWARN_d(WARN_UTF8);
10029 #    if (PERL_BCDVERSION < 0x5026000) && ! defined(EBCDIC)
10030     STRLEN overflow_length = 0;
10031 #    endif
10032
10033     if (send > s) {
10034         curlen = send - s;
10035     }
10036     else {
10037         assert(0);  /* Modern perls die under this circumstance */
10038         curlen = 0;
10039         if (! do_warnings) {    /* Handle empty here if no warnings needed */
10040             if (retlen) *retlen = 0;
10041             return UNICODE_REPLACEMENT;
10042         }
10043     }
10044
10045 #    if (PERL_BCDVERSION < 0x5026000) && ! defined(EBCDIC)
10046
10047     /* Perl did not properly detect overflow for much of its history on
10048      * non-EBCDIC platforms, often returning an overlong value which may or may
10049      * not have been tolerated in the call.  Also, earlier versions, when they
10050      * did detect overflow, may have disallowed it completely.  Modern ones can
10051      * replace it with the REPLACEMENT CHARACTER, depending on calling
10052      * parameters.  Therefore detect it ourselves in  releases it was
10053      * problematic in. */
10054
10055     if (curlen > 0 && UNLIKELY(*s >= 0xFE)) {
10056
10057         /* First, on a 32-bit machine the first byte being at least \xFE
10058          * automatically is overflow, as it indicates something requiring more
10059          * than 31 bits */
10060         if (sizeof(ret) < 8) {
10061             overflows = 1;
10062             overflow_length = (*s == 0xFE) ? 7 : 13;
10063         }
10064         else {
10065             const U8 highest[] =    /* 2*63-1 */
10066                         "\xFF\x80\x87\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF";
10067             const U8 *cur_h = highest;
10068
10069             for (cur_s = s; cur_s < send; cur_s++, cur_h++) {
10070                 if (UNLIKELY(*cur_s == *cur_h)) {
10071                     continue;
10072                 }
10073
10074                 /* If this byte is larger than the corresponding highest UTF-8
10075                  * byte, the sequence overflows; otherwise the byte is less
10076                  * than (as we handled the equality case above), and so the
10077                  * sequence doesn't overflow */
10078                 overflows = *cur_s > *cur_h;
10079                 break;
10080
10081             }
10082
10083             /* Here, either we set the bool and broke out of the loop, or got
10084              * to the end and all bytes are the same which indicates it doesn't
10085              * overflow.  If it did overflow, it would be this number of bytes
10086              * */
10087             overflow_length = 13;
10088         }
10089     }
10090
10091     if (UNLIKELY(overflows)) {
10092         ret = 0;
10093
10094         if (! do_warnings && retlen) {
10095             *retlen = overflow_length;
10096         }
10097     }
10098     else
10099
10100 #    endif  /* < 5.26 */
10101
10102         /* Here, we are either in a release that properly detects overflow, or
10103          * we have checked for overflow and the next statement is executing as
10104          * part of the above conditional where we know we don't have overflow.
10105          *
10106          * The modern versions allow anything that evaluates to a legal UV, but
10107          * not overlongs nor an empty input */
10108         ret = D_PPP_utf8_to_uvchr_buf_callee(
10109                 s, curlen, retlen,   (UTF8_ALLOW_ANYUV
10110                                   & ~(UTF8_ALLOW_LONG|UTF8_ALLOW_EMPTY)));
10111
10112 #    if (PERL_BCDVERSION >= 0x5026000) && (PERL_BCDVERSION < 0x5028000)
10113
10114     /* But actually, more modern versions restrict the UV to being no more than
10115      * what an IV can hold, so it could still have gotten it wrong about
10116      * overflowing. */
10117     if (UNLIKELY(ret > IV_MAX)) {
10118         overflows = 1;
10119     }
10120
10121 #    endif
10122
10123     if (UNLIKELY(overflows)) {
10124         if (! do_warnings) {
10125             if (retlen) {
10126                 *retlen = D_PPP_MIN(*retlen, UTF8SKIP(s));
10127                 *retlen = D_PPP_MIN(*retlen, curlen);
10128             }
10129             return UNICODE_REPLACEMENT;
10130         }
10131         else {
10132
10133             /* We use the error message in use from 5.8-5.26 */
10134             Perl_warner(aTHX_ packWARN(WARN_UTF8),
10135                 "Malformed UTF-8 character (overflow at 0x%" UVxf
10136                 ", byte 0x%02x, after start byte 0x%02x)",
10137                 ret, *cur_s, *s);
10138             if (retlen) {
10139                 *retlen = (STRLEN) -1;
10140             }
10141             return 0;
10142         }
10143     }
10144
10145     /* Here, did not overflow, but if it failed for some other reason, and
10146      * warnings are off, to emulate the behavior of the real utf8_to_uvchr(),
10147      * try again, allowing anything.  (Note a return of 0 is ok if the input
10148      * was '\0') */
10149     if (UNLIKELY(ret == 0 && (curlen == 0 || *s != '\0'))) {
10150
10151         /* If curlen is 0, we already handled the case where warnings are
10152          * disabled, so this 'if' will be true, and so later on, we know that
10153          * 's' is dereferencible */
10154         if (do_warnings) {
10155             *retlen = (STRLEN) -1;
10156         }
10157         else {
10158             ret = D_PPP_utf8_to_uvchr_buf_callee(
10159                                             s, curlen, retlen, UTF8_ALLOW_ANY);
10160             /* Override with the REPLACEMENT character, as that is what the
10161              * modern version of this function returns */
10162             ret = UNICODE_REPLACEMENT;
10163
10164 #    if (PERL_BCDVERSION < 0x5016000)
10165
10166             /* Versions earlier than this don't necessarily return the proper
10167              * length.  It should not extend past the end of string, nor past
10168              * what the first byte indicates the length is, nor past the
10169              * continuation characters */
10170             if (retlen && *retlen >= 0) {
10171                 unsigned int i = 1;
10172
10173                 *retlen = D_PPP_MIN(*retlen, curlen);
10174                 *retlen = D_PPP_MIN(*retlen, UTF8SKIP(s));
10175                 do {
10176 #      ifdef UTF8_IS_CONTINUATION
10177                     if (! UTF8_IS_CONTINUATION(s[i]))
10178 #      else       /* Versions without the above don't support EBCDIC anyway */
10179                     if (s[i] < 0x80 || s[i] > 0xBF)
10180 #      endif
10181                     {
10182                         *retlen = i;
10183                         break;
10184                     }
10185                 } while (++i < *retlen);
10186             }
10187
10188 #    endif
10189
10190         }
10191     }
10192
10193     return ret;
10194 }
10195
10196 #  endif
10197 #endif
10198
10199 #if defined(UTF8SKIP) && defined(utf8_to_uvchr_buf)
10200 #undef utf8_to_uvchr /* Always redefine this unsafe function so that it refuses
10201                         to read past a NUL, making it much less likely to read
10202                         off the end of the buffer.  A NUL indicates the start
10203                         of the next character anyway.  If the input isn't
10204                         NUL-terminated, the function remains unsafe, as it
10205                         always has been. */
10206 #ifndef utf8_to_uvchr
10207 #  define utf8_to_uvchr(s, lp)           \
10208     ((*(s) == '\0')                                                             \
10209     ? utf8_to_uvchr_buf(s,((s)+1), lp) /* Handle single NUL specially */        \
10210     : utf8_to_uvchr_buf(s, (s) + UTF8_CHK_SKIP(s), (lp)))
10211 #endif
10212
10213 #endif
10214
10215 /* Hint: utf8_to_uvchr
10216     Use utf8_to_uvchr_buf() instead.  But ONLY if you KNOW the upper bound
10217     of the input string (not resorting to using UTF8SKIP, etc., to infer it).
10218     The backported utf8_to_uvchr() will do a better job to prevent most cases
10219     of trying to read beyond the end of the buffer */
10220
10221 /* Replace utf8_to_uvchr with utf8_to_uvchr_buf */
10222
10223 #ifdef SV_NOSTEAL
10224    /* Older Perl versions have broken sv_len_utf8() when passed sv does not have SVf_UTF8 flag set */
10225    /* Also note that SvGETMAGIC() may change presence of SVf_UTF8 flag */
10226 #  if (PERL_BCDVERSION < 0x5017005)
10227 #    undef sv_len_utf8
10228 #    if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
10229 #      define sv_len_utf8_nomg(sv) ({ SV *_sv2 = (sv); (SvUTF8(_sv2) ? Perl_sv_len_utf8(aTHX_ (!SvGMAGICAL(_sv2) ? _sv2 : sv_mortalcopy_flags(_sv2, SV_NOSTEAL))) : ({ STRLEN _len; SvPV_nomg(_sv2, _len); _len; })); })
10230 #      define sv_len_utf8(sv) ({ SV *_sv1 = (sv); SvGETMAGIC(_sv1); sv_len_utf8_nomg(_sv1); })
10231 #    else
10232 #      define sv_len_utf8_nomg(sv) (PL_Sv = (sv), (SvUTF8(PL_Sv) ? Perl_sv_len_utf8(aTHX_ (!SvGMAGICAL(PL_Sv) ? PL_Sv : sv_mortalcopy_flags(PL_Sv, SV_NOSTEAL))) : (SvPV_nomg(PL_Sv, PL_na), PL_na)))
10233 #      define sv_len_utf8(sv) (PL_Sv = (sv), SvGETMAGIC(PL_Sv), sv_len_utf8_nomg(PL_Sv))
10234 #    endif
10235 #  endif
10236 #  if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
10237 #ifndef sv_len_utf8_nomg
10238 #  define sv_len_utf8_nomg(sv)           ({ SV *_sv = (sv); sv_len_utf8(!SvGMAGICAL(_sv) ? _sv : sv_mortalcopy_flags(_sv, SV_NOSTEAL)); })
10239 #endif
10240
10241 #  else
10242 #ifndef sv_len_utf8_nomg
10243 #  define sv_len_utf8_nomg(sv)           ((PL_Sv = (sv)), sv_len_utf8(!SvGMAGICAL(PL_Sv) ? PL_Sv : sv_mortalcopy_flags(PL_Sv, SV_NOSTEAL)))
10244 #endif
10245
10246 #  endif
10247 #endif
10248 #ifndef PERL_PV_ESCAPE_QUOTE
10249 #  define PERL_PV_ESCAPE_QUOTE           0x0001
10250 #endif
10251
10252 #ifndef PERL_PV_PRETTY_QUOTE
10253 #  define PERL_PV_PRETTY_QUOTE           PERL_PV_ESCAPE_QUOTE
10254 #endif
10255
10256 #ifndef PERL_PV_PRETTY_ELLIPSES
10257 #  define PERL_PV_PRETTY_ELLIPSES        0x0002
10258 #endif
10259
10260 #ifndef PERL_PV_PRETTY_LTGT
10261 #  define PERL_PV_PRETTY_LTGT            0x0004
10262 #endif
10263
10264 #ifndef PERL_PV_ESCAPE_FIRSTCHAR
10265 #  define PERL_PV_ESCAPE_FIRSTCHAR       0x0008
10266 #endif
10267
10268 #ifndef PERL_PV_ESCAPE_UNI
10269 #  define PERL_PV_ESCAPE_UNI             0x0100
10270 #endif
10271
10272 #ifndef PERL_PV_ESCAPE_UNI_DETECT
10273 #  define PERL_PV_ESCAPE_UNI_DETECT      0x0200
10274 #endif
10275
10276 #ifndef PERL_PV_ESCAPE_ALL
10277 #  define PERL_PV_ESCAPE_ALL             0x1000
10278 #endif
10279
10280 #ifndef PERL_PV_ESCAPE_NOBACKSLASH
10281 #  define PERL_PV_ESCAPE_NOBACKSLASH     0x2000
10282 #endif
10283
10284 #ifndef PERL_PV_ESCAPE_NOCLEAR
10285 #  define PERL_PV_ESCAPE_NOCLEAR         0x4000
10286 #endif
10287
10288 #ifndef PERL_PV_ESCAPE_RE
10289 #  define PERL_PV_ESCAPE_RE              0x8000
10290 #endif
10291
10292 #ifndef PERL_PV_PRETTY_NOCLEAR
10293 #  define PERL_PV_PRETTY_NOCLEAR         PERL_PV_ESCAPE_NOCLEAR
10294 #endif
10295 #ifndef PERL_PV_PRETTY_DUMP
10296 #  define PERL_PV_PRETTY_DUMP            PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_QUOTE
10297 #endif
10298
10299 #ifndef PERL_PV_PRETTY_REGPROP
10300 #  define PERL_PV_PRETTY_REGPROP         PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_LTGT|PERL_PV_ESCAPE_RE
10301 #endif
10302
10303 /* Hint: pv_escape
10304  * Note that unicode functionality is only backported to
10305  * those perl versions that support it. For older perl
10306  * versions, the implementation will fall back to bytes.
10307  */
10308
10309 #ifndef pv_escape
10310 #if defined(NEED_pv_escape)
10311 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);
10312 static
10313 #else
10314 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);
10315 #endif
10316
10317 #if defined(NEED_pv_escape) || defined(NEED_pv_escape_GLOBAL)
10318
10319 #ifdef pv_escape
10320 #  undef pv_escape
10321 #endif
10322 #define pv_escape(a,b,c,d,e,f) DPPP_(my_pv_escape)(aTHX_ a,b,c,d,e,f)
10323 #define Perl_pv_escape DPPP_(my_pv_escape)
10324
10325
10326 char *
10327 DPPP_(my_pv_escape)(pTHX_ SV *dsv, char const * const str,
10328   const STRLEN count, const STRLEN max,
10329   STRLEN * const escaped, const U32 flags)
10330 {
10331     const char esc = flags & PERL_PV_ESCAPE_RE ? '%' : '\\';
10332     const char dq = flags & PERL_PV_ESCAPE_QUOTE ? '"' : esc;
10333     char octbuf[32] = "%123456789ABCDF";
10334     STRLEN wrote = 0;
10335     STRLEN chsize = 0;
10336     STRLEN readsize = 1;
10337 #if defined(is_utf8_string) && defined(utf8_to_uvchr_buf)
10338     bool isuni = flags & PERL_PV_ESCAPE_UNI ? 1 : 0;
10339 #endif
10340     const char *pv  = str;
10341     const char * const end = pv + count;
10342     octbuf[0] = esc;
10343
10344     if (!(flags & PERL_PV_ESCAPE_NOCLEAR))
10345         sv_setpvs(dsv, "");
10346
10347 #if defined(is_utf8_string) && defined(utf8_to_uvchr_buf)
10348     if ((flags & PERL_PV_ESCAPE_UNI_DETECT) && is_utf8_string((U8*)pv, count))
10349         isuni = 1;
10350 #endif
10351
10352     for (; pv < end && (!max || wrote < max) ; pv += readsize) {
10353         const UV u =
10354 #if defined(is_utf8_string) && defined(utf8_to_uvchr_buf)
10355                      isuni ? utf8_to_uvchr_buf((U8*)pv, end, &readsize) :
10356 #endif
10357                              (U8)*pv;
10358         const U8 c = (U8)u & 0xFF;
10359
10360         if (u > 255 || (flags & PERL_PV_ESCAPE_ALL)) {
10361             if (flags & PERL_PV_ESCAPE_FIRSTCHAR)
10362                 chsize = my_snprintf(octbuf, sizeof octbuf,
10363                                       "%" UVxf, u);
10364             else
10365                 chsize = my_snprintf(octbuf, sizeof octbuf,
10366                                       "%cx{%" UVxf "}", esc, u);
10367         } else if (flags & PERL_PV_ESCAPE_NOBACKSLASH) {
10368             chsize = 1;
10369         } else {
10370             if (c == dq || c == esc || !isPRINT(c)) {
10371                 chsize = 2;
10372                 switch (c) {
10373                 case '\\' : /* fallthrough */
10374                 case '%'  : if (c == esc)
10375                                 octbuf[1] = esc;
10376                             else
10377                                 chsize = 1;
10378                             break;
10379                 case '\v' : octbuf[1] = 'v'; break;
10380                 case '\t' : octbuf[1] = 't'; break;
10381                 case '\r' : octbuf[1] = 'r'; break;
10382                 case '\n' : octbuf[1] = 'n'; break;
10383                 case '\f' : octbuf[1] = 'f'; break;
10384                 case '"'  : if (dq == '"')
10385                                 octbuf[1] = '"';
10386                             else
10387                                 chsize = 1;
10388                             break;
10389                 default:    chsize = my_snprintf(octbuf, sizeof octbuf,
10390                                 pv < end && isDIGIT((U8)*(pv+readsize))
10391                                 ? "%c%03o" : "%c%o", esc, c);
10392                 }
10393             } else {
10394                 chsize = 1;
10395             }
10396         }
10397         if (max && wrote + chsize > max) {
10398             break;
10399         } else if (chsize > 1) {
10400             sv_catpvn(dsv, octbuf, chsize);
10401             wrote += chsize;
10402         } else {
10403             char tmp[2];
10404             my_snprintf(tmp, sizeof tmp, "%c", c);
10405             sv_catpvn(dsv, tmp, 1);
10406             wrote++;
10407         }
10408         if (flags & PERL_PV_ESCAPE_FIRSTCHAR)
10409             break;
10410     }
10411     if (escaped != NULL)
10412         *escaped= pv - str;
10413     return SvPVX(dsv);
10414 }
10415
10416 #endif
10417 #endif
10418
10419 #ifndef pv_pretty
10420 #if defined(NEED_pv_pretty)
10421 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);
10422 static
10423 #else
10424 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);
10425 #endif
10426
10427 #if defined(NEED_pv_pretty) || defined(NEED_pv_pretty_GLOBAL)
10428
10429 #ifdef pv_pretty
10430 #  undef pv_pretty
10431 #endif
10432 #define pv_pretty(a,b,c,d,e,f,g) DPPP_(my_pv_pretty)(aTHX_ a,b,c,d,e,f,g)
10433 #define Perl_pv_pretty DPPP_(my_pv_pretty)
10434
10435
10436 char *
10437 DPPP_(my_pv_pretty)(pTHX_ SV *dsv, char const * const str, const STRLEN count,
10438   const STRLEN max, char const * const start_color, char const * const end_color,
10439   const U32 flags)
10440 {
10441     const U8 dq = (flags & PERL_PV_PRETTY_QUOTE) ? '"' : '%';
10442     STRLEN escaped;
10443
10444     if (!(flags & PERL_PV_PRETTY_NOCLEAR))
10445         sv_setpvs(dsv, "");
10446
10447     if (dq == '"')
10448         sv_catpvs(dsv, "\"");
10449     else if (flags & PERL_PV_PRETTY_LTGT)
10450         sv_catpvs(dsv, "<");
10451
10452     if (start_color != NULL)
10453         sv_catpv(dsv, D_PPP_CONSTPV_ARG(start_color));
10454
10455     pv_escape(dsv, str, count, max, &escaped, flags | PERL_PV_ESCAPE_NOCLEAR);
10456
10457     if (end_color != NULL)
10458         sv_catpv(dsv, D_PPP_CONSTPV_ARG(end_color));
10459
10460     if (dq == '"')
10461         sv_catpvs(dsv, "\"");
10462     else if (flags & PERL_PV_PRETTY_LTGT)
10463         sv_catpvs(dsv, ">");
10464
10465     if ((flags & PERL_PV_PRETTY_ELLIPSES) && escaped < count)
10466         sv_catpvs(dsv, "...");
10467
10468     return SvPVX(dsv);
10469 }
10470
10471 #endif
10472 #endif
10473
10474 #ifndef pv_display
10475 #if defined(NEED_pv_display)
10476 static char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim);
10477 static
10478 #else
10479 extern char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim);
10480 #endif
10481
10482 #if defined(NEED_pv_display) || defined(NEED_pv_display_GLOBAL)
10483
10484 #ifdef pv_display
10485 #  undef pv_display
10486 #endif
10487 #define pv_display(a,b,c,d,e) DPPP_(my_pv_display)(aTHX_ a,b,c,d,e)
10488 #define Perl_pv_display DPPP_(my_pv_display)
10489
10490
10491 char *
10492 DPPP_(my_pv_display)(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)
10493 {
10494     pv_pretty(dsv, pv, cur, pvlim, NULL, NULL, PERL_PV_PRETTY_DUMP);
10495     if (len > cur && pv[cur] == '\0')
10496         sv_catpvs(dsv, "\\0");
10497     return SvPVX(dsv);
10498 }
10499
10500 #endif
10501 #endif
10502
10503 /* If this doesn't exist, it's not needed, so noop */
10504 #ifndef switch_to_global_locale
10505 #  define switch_to_global_locale()
10506 #endif
10507
10508 /* Originally, this didn't return a value, but in perls like that, the value
10509  * should always be TRUE.  Add a return to Perl_sync_locale() when it's
10510  * available.  And actually do a sync when its not, if locales are available on
10511  * this system. */
10512 #ifdef sync_locale
10513 #  if (PERL_BCDVERSION < 0x5027009)
10514 #    if (PERL_BCDVERSION >= 0x5021003)
10515 #      undef sync_locale
10516 #      define sync_locale() (Perl_sync_locale(aTHX), 1)
10517 #    elif defined(sync_locale)  /* These should be the 5.20 maints*/
10518 #      undef sync_locale        /* Just copy their defn and return 1 */
10519 #      define sync_locale() (new_ctype(setlocale(LC_CTYPE, NULL)),        \
10520                              new_collate(setlocale(LC_COLLATE, NULL)),    \
10521                              set_numeric_local(),                         \
10522                              new_numeric(setlocale(LC_NUMERIC, NULL)),    \
10523                              1)
10524 #    elif defined(new_ctype) && defined(LC_CTYPE)
10525 #      define sync_locale() (new_ctype(setlocale(LC_CTYPE, NULL)), 1)
10526 #    endif
10527 #  endif
10528 #endif
10529 #ifndef sync_locale
10530 #  define sync_locale()                  1
10531 #endif
10532
10533 #endif /* _P_P_PORTABILITY_H_ */
10534
10535 /* End of File ppport.h */