/[net-ssleay]/trunk/ppport.h
ViewVC logotype

Diff of /trunk/ppport.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 230 by florian-guest, Fri Jul 14 08:46:50 2006 UTC revision 231 by florian-guest, Thu Aug 14 11:21:37 2008 UTC
# Line 4  Line 4 
4  /*  /*
5  ----------------------------------------------------------------------  ----------------------------------------------------------------------
6    
7      ppport.h -- Perl/Pollution/Portability Version 3.06_01      ppport.h -- Perl/Pollution/Portability Version 3.14
8    
9      Automatically created by Devel::PPPort running under      Automatically created by Devel::PPPort running under perl 5.010000.
     perl 5.008008 on Fri Jul 14 08:18:30 2006.  
10    
11      Do NOT edit this file directly! -- Edit PPPort_pm.PL and the      Do NOT edit this file directly! -- Edit PPPort_pm.PL and the
12      includes in parts/inc/ instead.      includes in parts/inc/ instead.
# Line 22  SKIP Line 21  SKIP
21    
22  =head1 NAME  =head1 NAME
23    
24  ppport.h - Perl/Pollution/Portability version 3.06_01  ppport.h - Perl/Pollution/Portability version 3.14
25    
26  =head1 SYNOPSIS  =head1 SYNOPSIS
27    
# Line 32  ppport.h - Perl/Pollution/Portability ve Line 31  ppport.h - Perl/Pollution/Portability ve
31    
32    --help                      show short help    --help                      show short help
33    
34      --version                   show version
35    
36    --patch=file                write one patch file with changes    --patch=file                write one patch file with changes
37    --copy=suffix               write changed copies with suffix    --copy=suffix               write changed copies with suffix
38    --diff=program              use diff program and options    --diff=program              use diff program and options
# Line 45  ppport.h - Perl/Pollution/Portability ve Line 46  ppport.h - Perl/Pollution/Portability ve
46    --nochanges                 don't suggest changes    --nochanges                 don't suggest changes
47    --nofilter                  don't filter input files    --nofilter                  don't filter input files
48    
49      --strip                     strip all script and doc functionality from
50                                  ppport.h
51    
52    --list-provided             list provided API    --list-provided             list provided API
53    --list-unsupported          list unsupported API    --list-unsupported          list unsupported API
54    --api-info=name             show Perl API portability information    --api-info=name             show Perl API portability information
# Line 52  ppport.h - Perl/Pollution/Portability ve Line 56  ppport.h - Perl/Pollution/Portability ve
56  =head1 COMPATIBILITY  =head1 COMPATIBILITY
57    
58  This version of F<ppport.h> is designed to support operation with Perl  This version of F<ppport.h> is designed to support operation with Perl
59  installations back to 5.003, and has been tested up to 5.9.3.  installations back to 5.003, and has been tested up to 5.10.0.
60    
61  =head1 OPTIONS  =head1 OPTIONS
62    
# Line 60  installations back to 5.003, and has bee Line 64  installations back to 5.003, and has bee
64    
65  Display a brief usage summary.  Display a brief usage summary.
66    
67    =head2 --version
68    
69    Display the version of F<ppport.h>.
70    
71  =head2 --patch=I<file>  =head2 --patch=I<file>
72    
73  If this option is given, a single patch file will be created if  If this option is given, a single patch file will be created if
# Line 70  to be installed on your system. Line 78  to be installed on your system.
78    
79  If this option is given, a copy of each file will be saved with  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  the given suffix that contains the suggested changes. This does
81  not require any external programs.  not require any external programs. Note that this does not
82    automagially add a dot between the original filename and the
83    suffix. If you want the dot, you have to include it in the option
84    argument.
85    
86  If neither C<--patch> or C<--copy> are given, the default is to  If neither C<--patch> or C<--copy> are given, the default is to
87  simply print the diffs for each file. This requires either  simply print the diffs for each file. This requires either
# Line 88  Tell F<ppport.h> to check for compatibil Line 99  Tell F<ppport.h> to check for compatibil
99  Perl version. The default is to check for compatibility with Perl  Perl version. The default is to check for compatibility with Perl
100  version 5.003. You can use this option to reduce the output  version 5.003. You can use this option to reduce the output
101  of F<ppport.h> if you intend to be backward compatible only  of F<ppport.h> if you intend to be backward compatible only
102  up to a certain Perl version.  down to a certain Perl version.
103    
104  =head2 --cplusplus  =head2 --cplusplus
105    
# Line 109  alerts will be printed. Line 120  alerts will be printed.
120  =head2 --nohints  =head2 --nohints
121    
122  Don't output any hints. Hints often contain useful portability  Don't output any hints. Hints often contain useful portability
123  notes.  notes. Warnings will still be displayed.
124    
125  =head2 --nochanges  =head2 --nochanges
126    
# Line 121  unless these are also deactivated. Line 132  unless these are also deactivated.
132  Don't filter the list of input files. By default, files not looking  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.  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  =head2 --list-provided
147    
148  Lists the API elements for which compatibility is provided by  Lists the API elements for which compatibility is provided by
149  F<ppport.h>. Also lists if it must be explicitly requested,  F<ppport.h>. Also lists if it must be explicitly requested,
150  if it has dependencies, and if there are hints for it.  if it has dependencies, and if there are hints or warnings for it.
151    
152  =head2 --list-unsupported  =head2 --list-unsupported
153    
# Line 166  will provide wrappers for older Perl ver Line 188  will provide wrappers for older Perl ver
188    
189  =item *  =item *
190    
191  If you use one of a few functions that were not present in earlier  If you use one of a few functions or variables that were not present in
192  versions of Perl, and that can't be provided using a macro, you have  earlier versions of Perl, and that can't be provided using a macro, you
193  to explicitly request support for these functions by adding one or  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>.  more C<#define>s in your source code before the inclusion of F<ppport.h>.
195    
196  These functions will be marked C<explicit> in the list shown by  These functions or variables will be marked C<explicit> in the list shown
197  C<--list-provided>.  by C<--list-provided>.
198    
199  Depending on whether you module has a single or multiple files that  Depending on whether you module has a single or multiple files that
200  use such functions, you want either C<static> or global variants.  use such functions or variables, you want either C<static> or global
201    variants.
202    
203  For a C<static> function, use:  For a C<static> function or variable (used only in a single source
204    file), use:
205    
206      #define NEED_function      #define NEED_function
207        #define NEED_variable
208    
209  For a global function, use:  For a global function or variable (used in multiple source files),
210    use:
211    
212      #define NEED_function_GLOBAL      #define NEED_function_GLOBAL
213        #define NEED_variable_GLOBAL
214    
215  Note that you mustn't have more than one global request for one  Note that you mustn't have more than one global request for the
216  function in your project.  same function or variable in your project.
217    
218      Function                  Static Request               Global Request      Function / Variable       Static Request               Global Request
219      -----------------------------------------------------------------------------------------      -----------------------------------------------------------------------------------------
220        PL_signals                NEED_PL_signals              NEED_PL_signals_GLOBAL
221      eval_pv()                 NEED_eval_pv                 NEED_eval_pv_GLOBAL      eval_pv()                 NEED_eval_pv                 NEED_eval_pv_GLOBAL
222      grok_bin()                NEED_grok_bin                NEED_grok_bin_GLOBAL      grok_bin()                NEED_grok_bin                NEED_grok_bin_GLOBAL
223      grok_hex()                NEED_grok_hex                NEED_grok_hex_GLOBAL      grok_hex()                NEED_grok_hex                NEED_grok_hex_GLOBAL
224      grok_number()             NEED_grok_number             NEED_grok_number_GLOBAL      grok_number()             NEED_grok_number             NEED_grok_number_GLOBAL
225      grok_numeric_radix()      NEED_grok_numeric_radix      NEED_grok_numeric_radix_GLOBAL      grok_numeric_radix()      NEED_grok_numeric_radix      NEED_grok_numeric_radix_GLOBAL
226      grok_oct()                NEED_grok_oct                NEED_grok_oct_GLOBAL      grok_oct()                NEED_grok_oct                NEED_grok_oct_GLOBAL
227        load_module()             NEED_load_module             NEED_load_module_GLOBAL
228        my_snprintf()             NEED_my_snprintf             NEED_my_snprintf_GLOBAL
229        my_strlcat()              NEED_my_strlcat              NEED_my_strlcat_GLOBAL
230        my_strlcpy()              NEED_my_strlcpy              NEED_my_strlcpy_GLOBAL
231      newCONSTSUB()             NEED_newCONSTSUB             NEED_newCONSTSUB_GLOBAL      newCONSTSUB()             NEED_newCONSTSUB             NEED_newCONSTSUB_GLOBAL
232      newRV_noinc()             NEED_newRV_noinc             NEED_newRV_noinc_GLOBAL      newRV_noinc()             NEED_newRV_noinc             NEED_newRV_noinc_GLOBAL
233      sv_2pv_nolen()            NEED_sv_2pv_nolen            NEED_sv_2pv_nolen_GLOBAL      newSVpvn_flags()          NEED_newSVpvn_flags          NEED_newSVpvn_flags_GLOBAL
234        newSVpvn_share()          NEED_newSVpvn_share          NEED_newSVpvn_share_GLOBAL
235        sv_2pv_flags()            NEED_sv_2pv_flags            NEED_sv_2pv_flags_GLOBAL
236      sv_2pvbyte()              NEED_sv_2pvbyte              NEED_sv_2pvbyte_GLOBAL      sv_2pvbyte()              NEED_sv_2pvbyte              NEED_sv_2pvbyte_GLOBAL
237      sv_catpvf_mg()            NEED_sv_catpvf_mg            NEED_sv_catpvf_mg_GLOBAL      sv_catpvf_mg()            NEED_sv_catpvf_mg            NEED_sv_catpvf_mg_GLOBAL
238      sv_catpvf_mg_nocontext()  NEED_sv_catpvf_mg_nocontext  NEED_sv_catpvf_mg_nocontext_GLOBAL      sv_catpvf_mg_nocontext()  NEED_sv_catpvf_mg_nocontext  NEED_sv_catpvf_mg_nocontext_GLOBAL
239        sv_pvn_force_flags()      NEED_sv_pvn_force_flags      NEED_sv_pvn_force_flags_GLOBAL
240      sv_setpvf_mg()            NEED_sv_setpvf_mg            NEED_sv_setpvf_mg_GLOBAL      sv_setpvf_mg()            NEED_sv_setpvf_mg            NEED_sv_setpvf_mg_GLOBAL
241      sv_setpvf_mg_nocontext()  NEED_sv_setpvf_mg_nocontext  NEED_sv_setpvf_mg_nocontext_GLOBAL      sv_setpvf_mg_nocontext()  NEED_sv_setpvf_mg_nocontext  NEED_sv_setpvf_mg_nocontext_GLOBAL
242        vload_module()            NEED_vload_module            NEED_vload_module_GLOBAL
243      vnewSVpvf()               NEED_vnewSVpvf               NEED_vnewSVpvf_GLOBAL      vnewSVpvf()               NEED_vnewSVpvf               NEED_vnewSVpvf_GLOBAL
244        warner()                  NEED_warner                  NEED_warner_GLOBAL
245    
246  To avoid namespace conflicts, you can change the namespace of the  To avoid namespace conflicts, you can change the namespace of the
247  explicitly exported functions using the C<DPPP_NAMESPACE> macro.  explicitly exported functions / variables using the C<DPPP_NAMESPACE>
248  Just C<#define> the macro before including C<ppport.h>:  macro. Just C<#define> the macro before including C<ppport.h>:
249    
250      #define DPPP_NAMESPACE MyOwnNamespace_      #define DPPP_NAMESPACE MyOwnNamespace_
251      #include "ppport.h"      #include "ppport.h"
# Line 253  the C<--diff> option: Line 290  the C<--diff> option:
290    
291  This would output context diffs with 10 lines of context.  This would output context diffs with 10 lines of context.
292    
293    If you want to create patched copies of your files instead, use:
294    
295        perl ppport.h --copy=.new
296    
297  To display portability information for the C<newSVpvn> function,  To display portability information for the C<newSVpvn> function,
298  use:  use:
299    
# Line 311  module from CPAN. Line 352  module from CPAN.
352    
353  =head1 COPYRIGHT  =head1 COPYRIGHT
354    
355  Version 3.x, Copyright (c) 2004-2005, Marcus Holland-Moritz.  Version 3.x, Copyright (c) 2004-2008, Marcus Holland-Moritz.
356    
357  Version 2.x, Copyright (C) 2001, Paul Marquess.  Version 2.x, Copyright (C) 2001, Paul Marquess.
358    
# Line 328  See L<Devel::PPPort>. Line 369  See L<Devel::PPPort>.
369    
370  use strict;  use strict;
371    
372    # Disable broken TRIE-optimization
373    BEGIN { eval '${^RE_TRIE_MAXBUF} = -1' if $] >= 5.009004 && $] <= 5.009005 }
374    
375    my $VERSION = 3.14;
376    
377  my %opt = (  my %opt = (
378    quiet     => 0,    quiet     => 0,
379    diag      => 1,    diag      => 1,
# Line 335  my %opt = ( Line 381  my %opt = (
381    changes   => 1,    changes   => 1,
382    cplusplus => 0,    cplusplus => 0,
383    filter    => 1,    filter    => 1,
384      strip     => 0,
385      version   => 0,
386  );  );
387    
388  my($ppport) = $0 =~ /([\w.]+)$/;  my($ppport) = $0 =~ /([\w.]+)$/;
389  my $LF = '(?:\r\n|[\r\n])';   # line feed  my $LF = '(?:\r\n|[\r\n])';   # line feed
390  my $HS = "[ \t]";             # horizontal whitespace  my $HS = "[ \t]";             # horizontal whitespace
391    
392    # Never use C comments in this file!
393    my $ccs  = '/'.'*';
394    my $cce  = '*'.'/';
395    my $rccs = quotemeta $ccs;
396    my $rcce = quotemeta $cce;
397    
398  eval {  eval {
399    require Getopt::Long;    require Getopt::Long;
400    Getopt::Long::GetOptions(\%opt, qw(    Getopt::Long::GetOptions(\%opt, qw(
401      help quiet diag! filter! hints! changes! cplusplus      help quiet diag! filter! hints! changes! cplusplus strip version
402      patch=s copy=s diff=s compat-version=s      patch=s copy=s diff=s compat-version=s
403      list-provided list-unsupported api-info=s      list-provided list-unsupported api-info=s
404    )) or usage();    )) or usage();
# Line 355  if ($@ and grep /^-/, @ARGV) { Line 409  if ($@ and grep /^-/, @ARGV) {
409    die "Getopt::Long not found. Please don't use any options.\n";    die "Getopt::Long not found. Please don't use any options.\n";
410  }  }
411    
412    if ($opt{version}) {
413      print "This is $0 $VERSION.\n";
414      exit 0;
415    }
416    
417  usage() if $opt{help};  usage() if $opt{help};
418    strip() if $opt{strip};
419    
420  if (exists $opt{'compat-version'}) {  if (exists $opt{'compat-version'}) {
421    my($r,$v,$s) = eval { parse_version($opt{'compat-version'}) };    my($r,$v,$s) = eval { parse_version($opt{'compat-version'}) };
# Line 370  else { Line 430  else {
430    $opt{'compat-version'} = 5;    $opt{'compat-version'} = 5;
431  }  }
432    
 # Never use C comments in this file!!!!!  
 my $ccs  = '/'.'*';  
 my $cce  = '*'.'/';  
 my $rccs = quotemeta $ccs;  
 my $rcce = quotemeta $cce;  
   
433  my %API = map { /^(\w+)\|([^|]*)\|([^|]*)\|(\w*)$/  my %API = map { /^(\w+)\|([^|]*)\|([^|]*)\|(\w*)$/
434                  ? ( $1 => {                  ? ( $1 => {
435                        ($2                  ? ( base     => $2 ) : ()),                        ($2                  ? ( base     => $2 ) : ()),
# Line 412  ENTER||| Line 466  ENTER|||
466  ERRSV|5.004050||p  ERRSV|5.004050||p
467  EXTEND|||  EXTEND|||
468  EXTERN_C|5.005000||p  EXTERN_C|5.005000||p
469    F0convert|||n
470  FREETMPS|||  FREETMPS|||
471  GIMME_V||5.004000|n  GIMME_V||5.004000|n
472  GIMME|||n  GIMME|||n
# Line 433  HePV||5.004000| Line 488  HePV||5.004000|
488  HeSVKEY_force||5.004000|  HeSVKEY_force||5.004000|
489  HeSVKEY_set||5.004000|  HeSVKEY_set||5.004000|
490  HeSVKEY||5.004000|  HeSVKEY||5.004000|
491    HeUTF8||5.011000|
492  HeVAL||5.004000|  HeVAL||5.004000|
493  HvNAME|||  HvNAME|||
494  INT2PTR|5.006000||p  INT2PTR|5.006000||p
# Line 452  IVdf|5.006000||p Line 508  IVdf|5.006000||p
508  LEAVE|||  LEAVE|||
509  LVRET|||  LVRET|||
510  MARK|||  MARK|||
511    MULTICALL||5.011000|
512  MY_CXT_CLONE|5.009002||p  MY_CXT_CLONE|5.009002||p
513  MY_CXT_INIT|5.007003||p  MY_CXT_INIT|5.007003||p
514  MY_CXT|5.007003||p  MY_CXT|5.007003||p
515  MoveD|5.009002||p  MoveD|5.009002||p
516  Move|||  Move|||
 NEWSV|||  
517  NOOP|5.005000||p  NOOP|5.005000||p
518  NUM2PTR|5.006000||p  NUM2PTR|5.006000||p
519  NVTYPE|5.006000||p  NVTYPE|5.006000||p
520  NVef|5.006001||p  NVef|5.006001||p
521  NVff|5.006001||p  NVff|5.006001||p
522  NVgf|5.006001||p  NVgf|5.006001||p
523  Newc|||  Newxc|5.009003||p
524  Newz|||  Newxz|5.009003||p
525  New|||  Newx|5.009003||p
526  Nullav|||  Nullav|||
527  Nullch|||  Nullch|||
528  Nullcv|||  Nullcv|||
# Line 489  PAD_SET_CUR_NOSAVE||| Line 545  PAD_SET_CUR_NOSAVE|||
545  PAD_SET_CUR|||  PAD_SET_CUR|||
546  PAD_SVl|||  PAD_SVl|||
547  PAD_SV|||  PAD_SV|||
548  PERL_BCDVERSION|5.009003||p  PERL_ABS|5.008001||p
549    PERL_BCDVERSION|5.011000||p
550  PERL_GCC_BRACE_GROUPS_FORBIDDEN|5.008001||p  PERL_GCC_BRACE_GROUPS_FORBIDDEN|5.008001||p
551    PERL_HASH|5.004000||p
552  PERL_INT_MAX|5.004000||p  PERL_INT_MAX|5.004000||p
553  PERL_INT_MIN|5.004000||p  PERL_INT_MIN|5.004000||p
554  PERL_LONG_MAX|5.004000||p  PERL_LONG_MAX|5.004000||p
# Line 506  PERL_MAGIC_envelem|5.007002||p Line 564  PERL_MAGIC_envelem|5.007002||p
564  PERL_MAGIC_env|5.007002||p  PERL_MAGIC_env|5.007002||p
565  PERL_MAGIC_ext|5.007002||p  PERL_MAGIC_ext|5.007002||p
566  PERL_MAGIC_fm|5.007002||p  PERL_MAGIC_fm|5.007002||p
567  PERL_MAGIC_glob|5.007002||p  PERL_MAGIC_glob|5.011000||p
568  PERL_MAGIC_isaelem|5.007002||p  PERL_MAGIC_isaelem|5.007002||p
569  PERL_MAGIC_isa|5.007002||p  PERL_MAGIC_isa|5.007002||p
570  PERL_MAGIC_mutex|5.007002||p  PERL_MAGIC_mutex|5.011000||p
571  PERL_MAGIC_nkeys|5.007002||p  PERL_MAGIC_nkeys|5.007002||p
572  PERL_MAGIC_overload_elem|5.007002||p  PERL_MAGIC_overload_elem|5.007002||p
573  PERL_MAGIC_overload_table|5.007002||p  PERL_MAGIC_overload_table|5.007002||p
# Line 543  PERL_SCAN_GREATER_THAN_UV_MAX|5.007003|| Line 601  PERL_SCAN_GREATER_THAN_UV_MAX|5.007003||
601  PERL_SCAN_SILENT_ILLDIGIT|5.008001||p  PERL_SCAN_SILENT_ILLDIGIT|5.008001||p
602  PERL_SHORT_MAX|5.004000||p  PERL_SHORT_MAX|5.004000||p
603  PERL_SHORT_MIN|5.004000||p  PERL_SHORT_MIN|5.004000||p
604    PERL_SIGNALS_UNSAFE_FLAG|5.008001||p
605  PERL_SUBVERSION|5.006000||p  PERL_SUBVERSION|5.006000||p
606  PERL_UCHAR_MAX|5.004000||p  PERL_UCHAR_MAX|5.004000||p
607  PERL_UCHAR_MIN|5.004000||p  PERL_UCHAR_MIN|5.004000||p
# Line 550  PERL_UINT_MAX|5.004000||p Line 609  PERL_UINT_MAX|5.004000||p
609  PERL_UINT_MIN|5.004000||p  PERL_UINT_MIN|5.004000||p
610  PERL_ULONG_MAX|5.004000||p  PERL_ULONG_MAX|5.004000||p
611  PERL_ULONG_MIN|5.004000||p  PERL_ULONG_MIN|5.004000||p
612    PERL_UNUSED_ARG|5.009003||p
613    PERL_UNUSED_CONTEXT|5.009004||p
614  PERL_UNUSED_DECL|5.007002||p  PERL_UNUSED_DECL|5.007002||p
615    PERL_UNUSED_VAR|5.007002||p
616  PERL_UQUAD_MAX|5.004000||p  PERL_UQUAD_MAX|5.004000||p
617  PERL_UQUAD_MIN|5.004000||p  PERL_UQUAD_MIN|5.004000||p
618    PERL_USE_GCC_BRACE_GROUPS|5.009004||p
619  PERL_USHORT_MAX|5.004000||p  PERL_USHORT_MAX|5.004000||p
620  PERL_USHORT_MIN|5.004000||p  PERL_USHORT_MIN|5.004000||p
621  PERL_VERSION|5.006000||p  PERL_VERSION|5.006000||p
622    PL_DBsignal|5.005000||p
623  PL_DBsingle|||pn  PL_DBsingle|||pn
624  PL_DBsub|||pn  PL_DBsub|||pn
625  PL_DBtrace|||n  PL_DBtrace|||pn
626  PL_Sv|5.005000||p  PL_Sv|5.005000||p
627  PL_compiling|5.004050||p  PL_compiling|5.004050||p
628  PL_copline|5.005000||p  PL_copline|5.011000||p
629  PL_curcop|5.004050||p  PL_curcop|5.004050||p
630  PL_curstash|5.004050||p  PL_curstash|5.004050||p
631  PL_debstash|5.004050||p  PL_debstash|5.004050||p
# Line 570  PL_diehook|5.004050||p Line 634  PL_diehook|5.004050||p
634  PL_dirty|5.004050||p  PL_dirty|5.004050||p
635  PL_dowarn|||pn  PL_dowarn|||pn
636  PL_errgv|5.004050||p  PL_errgv|5.004050||p
637    PL_expect|5.011000||p
638  PL_hexdigit|5.005000||p  PL_hexdigit|5.005000||p
639  PL_hints|5.005000||p  PL_hints|5.005000||p
640  PL_last_in_gv|||n  PL_last_in_gv|||n
641    PL_laststatval|5.005000||p
642  PL_modglobal||5.005000|n  PL_modglobal||5.005000|n
643  PL_na|5.004050||pn  PL_na|5.004050||pn
644  PL_no_modify|5.006000||p  PL_no_modify|5.006000||p
# Line 583  PL_ppaddr|5.006000||p Line 649  PL_ppaddr|5.006000||p
649  PL_rsfp_filters|5.004050||p  PL_rsfp_filters|5.004050||p
650  PL_rsfp|5.004050||p  PL_rsfp|5.004050||p
651  PL_rs|||n  PL_rs|||n
652    PL_signals|5.008001||p
653  PL_stack_base|5.004050||p  PL_stack_base|5.004050||p
654  PL_stack_sp|5.004050||p  PL_stack_sp|5.004050||p
655    PL_statcache|5.005000||p
656  PL_stdingv|5.004050||p  PL_stdingv|5.004050||p
657  PL_sv_arenaroot|5.004050||p  PL_sv_arenaroot|5.004050||p
658  PL_sv_no|5.004050||pn  PL_sv_no|5.004050||pn
# Line 592  PL_sv_undef|5.004050||pn Line 660  PL_sv_undef|5.004050||pn
660  PL_sv_yes|5.004050||pn  PL_sv_yes|5.004050||pn
661  PL_tainted|5.004050||p  PL_tainted|5.004050||p
662  PL_tainting|5.004050||p  PL_tainting|5.004050||p
663    POP_MULTICALL||5.011000|
664  POPi|||n  POPi|||n
665  POPl|||n  POPl|||n
666  POPn|||n  POPn|||n
# Line 605  PTR2UV|5.006000||p Line 674  PTR2UV|5.006000||p
674  PTR2ul|5.007001||p  PTR2ul|5.007001||p
675  PTRV|5.006000||p  PTRV|5.006000||p
676  PUSHMARK|||  PUSHMARK|||
677    PUSH_MULTICALL||5.011000|
678  PUSHi|||  PUSHi|||
679  PUSHmortal|5.009002||p  PUSHmortal|5.009002||p
680  PUSHn|||  PUSHn|||
# Line 614  PUSHu|5.004000||p Line 684  PUSHu|5.004000||p
684  PUTBACK|||  PUTBACK|||
685  PerlIO_clearerr||5.007003|  PerlIO_clearerr||5.007003|
686  PerlIO_close||5.007003|  PerlIO_close||5.007003|
687    PerlIO_context_layers||5.009004|
688  PerlIO_eof||5.007003|  PerlIO_eof||5.007003|
689  PerlIO_error||5.007003|  PerlIO_error||5.007003|
690  PerlIO_fileno||5.007003|  PerlIO_fileno||5.007003|
# Line 634  PerlIO_stdout||5.007003| Line 705  PerlIO_stdout||5.007003|
705  PerlIO_tell||5.007003|  PerlIO_tell||5.007003|
706  PerlIO_unread||5.007003|  PerlIO_unread||5.007003|
707  PerlIO_write||5.007003|  PerlIO_write||5.007003|
708    Perl_signbit||5.009005|n
709    PoisonFree|5.009004||p
710    PoisonNew|5.009004||p
711    PoisonWith|5.009004||p
712  Poison|5.008000||p  Poison|5.008000||p
713  RETVAL|||n  RETVAL|||n
714  Renewc|||  Renewc|||
# Line 649  START_EXTERN_C|5.005000||p Line 724  START_EXTERN_C|5.005000||p
724  START_MY_CXT|5.007003||p  START_MY_CXT|5.007003||p
725  STMT_END|||p  STMT_END|||p
726  STMT_START|||p  STMT_START|||p
727    STR_WITH_LEN|5.009003||p
728  ST|||  ST|||
729    SV_CONST_RETURN|5.009003||p
730    SV_COW_DROP_PV|5.008001||p
731    SV_COW_SHARED_HASH_KEYS|5.009005||p
732    SV_GMAGIC|5.007002||p
733    SV_HAS_TRAILING_NUL|5.009004||p
734    SV_IMMEDIATE_UNREF|5.007001||p
735    SV_MUTABLE_RETURN|5.009003||p
736    SV_NOSTEAL|5.009002||p
737    SV_SMAGIC|5.009003||p
738    SV_UTF8_NO_ENCODING|5.008001||p
739    SVf_UTF8|5.006000||p
740    SVf|5.006000||p
741  SVt_IV|||  SVt_IV|||
742  SVt_NV|||  SVt_NV|||
743  SVt_PVAV|||  SVt_PVAV|||
# Line 660  SVt_PV||| Line 748  SVt_PV|||
748  Safefree|||  Safefree|||
749  Slab_Alloc|||  Slab_Alloc|||
750  Slab_Free|||  Slab_Free|||
751    Slab_to_rw|||
752  StructCopy|||  StructCopy|||
753  SvCUR_set|||  SvCUR_set|||
754  SvCUR|||  SvCUR|||
755  SvEND|||  SvEND|||
756    SvGAMAGIC||5.006001|
757  SvGETMAGIC|5.004050||p  SvGETMAGIC|5.004050||p
758  SvGROW|||  SvGROW|||
759  SvIOK_UV||5.006000|  SvIOK_UV||5.006000|
# Line 684  SvIsCOW||5.008003| Line 774  SvIsCOW||5.008003|
774  SvLEN_set|||  SvLEN_set|||
775  SvLEN|||  SvLEN|||
776  SvLOCK||5.007003|  SvLOCK||5.007003|
777  SvMAGIC_set||5.009003|  SvMAGIC_set|5.009003||p
778  SvNIOK_off|||  SvNIOK_off|||
779  SvNIOKp|||  SvNIOKp|||
780  SvNIOK|||  SvNIOK|||
# Line 705  SvPOK_only||| Line 795  SvPOK_only|||
795  SvPOK_on|||  SvPOK_on|||
796  SvPOKp|||  SvPOKp|||
797  SvPOK|||  SvPOK|||
798    SvPVX_const|5.009003||p
799    SvPVX_mutable|5.009003||p
800  SvPVX|||  SvPVX|||
801    SvPV_const|5.009003||p
802    SvPV_flags_const_nolen|5.009003||p
803    SvPV_flags_const|5.009003||p
804    SvPV_flags_mutable|5.009003||p
805    SvPV_flags|5.007002||p
806    SvPV_force_flags_mutable|5.009003||p
807    SvPV_force_flags_nolen|5.009003||p
808    SvPV_force_flags|5.007002||p
809    SvPV_force_mutable|5.009003||p
810    SvPV_force_nolen|5.009003||p
811    SvPV_force_nomg_nolen|5.009003||p
812  SvPV_force_nomg|5.007002||p  SvPV_force_nomg|5.007002||p
813  SvPV_force|||  SvPV_force|||p
814    SvPV_mutable|5.009003||p
815    SvPV_nolen_const|5.009003||p
816  SvPV_nolen|5.006000||p  SvPV_nolen|5.006000||p
817    SvPV_nomg_const_nolen|5.009003||p
818    SvPV_nomg_const|5.009003||p
819  SvPV_nomg|5.007002||p  SvPV_nomg|5.007002||p
820  SvPV_set|||  SvPV_set|||
821  SvPVbyte_force||5.009002|  SvPVbyte_force||5.009002|
# Line 724  SvPVutf8||5.006000| Line 831  SvPVutf8||5.006000|
831  SvPVx|||  SvPVx|||
832  SvPV|||  SvPV|||
833  SvREFCNT_dec|||  SvREFCNT_dec|||
834  SvREFCNT_inc|||  SvREFCNT_inc_NN|5.009004||p
835    SvREFCNT_inc_simple_NN|5.009004||p
836    SvREFCNT_inc_simple_void_NN|5.009004||p
837    SvREFCNT_inc_simple_void|5.009004||p
838    SvREFCNT_inc_simple|5.009004||p
839    SvREFCNT_inc_void_NN|5.009004||p
840    SvREFCNT_inc_void|5.009004||p
841    SvREFCNT_inc|||p
842  SvREFCNT|||  SvREFCNT|||
843  SvROK_off|||  SvROK_off|||
844  SvROK_on|||  SvROK_on|||
845  SvROK|||  SvROK|||
846  SvRV_set||5.009003|  SvRV_set|5.009003||p
847  SvRV|||  SvRV|||
848    SvRXOK||5.009005|
849    SvRX||5.009005|
850  SvSETMAGIC|||  SvSETMAGIC|||
851    SvSHARED_HASH|5.009003||p
852  SvSHARE||5.007003|  SvSHARE||5.007003|
853  SvSTASH_set||5.009003|  SvSTASH_set|5.009003||p
854  SvSTASH|||  SvSTASH|||
855  SvSetMagicSV_nosteal||5.004000|  SvSetMagicSV_nosteal||5.004000|
856  SvSetMagicSV||5.004000|  SvSetMagicSV||5.004000|
# Line 746  SvTAINT||| Line 863  SvTAINT|||
863  SvTRUE|||  SvTRUE|||
864  SvTYPE|||  SvTYPE|||
865  SvUNLOCK||5.007003|  SvUNLOCK||5.007003|
866  SvUOK||5.007001|  SvUOK|5.007001|5.006000|p
867  SvUPGRADE|||  SvUPGRADE|||
868  SvUTF8_off||5.006000|  SvUTF8_off||5.006000|
869  SvUTF8_on||5.006000|  SvUTF8_on||5.006000|
# Line 754  SvUTF8||5.006000| Line 871  SvUTF8||5.006000|
871  SvUVXx|5.004000||p  SvUVXx|5.004000||p
872  SvUVX|5.004000||p  SvUVX|5.004000||p
873  SvUV_nomg|5.009001||p  SvUV_nomg|5.009001||p
874  SvUV_set||5.009003|  SvUV_set|5.009003||p
875  SvUVx|5.004000||p  SvUVx|5.004000||p
876  SvUV|5.004000||p  SvUV|5.004000||p
877  SvVOK||5.008001|  SvVOK||5.008001|
878    SvVSTRING_mg|5.009004||p
879  THIS|||n  THIS|||n
880  UNDERBAR|5.009002||p  UNDERBAR|5.009002||p
881    UTF8_MAXBYTES|5.009002||p
882  UVSIZE|5.006000||p  UVSIZE|5.006000||p
883  UVTYPE|5.006000||p  UVTYPE|5.006000||p
884  UVXf|5.007001||p  UVXf|5.007001||p
885  UVof|5.006000||p  UVof|5.006000||p
886  UVuf|5.006000||p  UVuf|5.006000||p
887  UVxf|5.006000||p  UVxf|5.006000||p
888    WARN_ALL|5.006000||p
889    WARN_AMBIGUOUS|5.006000||p
890    WARN_ASSERTIONS|5.011000||p
891    WARN_BAREWORD|5.006000||p
892    WARN_CLOSED|5.006000||p
893    WARN_CLOSURE|5.006000||p
894    WARN_DEBUGGING|5.006000||p
895    WARN_DEPRECATED|5.006000||p
896    WARN_DIGIT|5.006000||p
897    WARN_EXEC|5.006000||p
898    WARN_EXITING|5.006000||p
899    WARN_GLOB|5.006000||p
900    WARN_INPLACE|5.006000||p
901    WARN_INTERNAL|5.006000||p
902    WARN_IO|5.006000||p
903    WARN_LAYER|5.008000||p
904    WARN_MALLOC|5.006000||p
905    WARN_MISC|5.006000||p
906    WARN_NEWLINE|5.006000||p
907    WARN_NUMERIC|5.006000||p
908    WARN_ONCE|5.006000||p
909    WARN_OVERFLOW|5.006000||p
910    WARN_PACK|5.006000||p
911    WARN_PARENTHESIS|5.006000||p
912    WARN_PIPE|5.006000||p
913    WARN_PORTABLE|5.006000||p
914    WARN_PRECEDENCE|5.006000||p
915    WARN_PRINTF|5.006000||p
916    WARN_PROTOTYPE|5.006000||p
917    WARN_QW|5.006000||p
918    WARN_RECURSION|5.006000||p
919    WARN_REDEFINE|5.006000||p
920    WARN_REGEXP|5.006000||p
921    WARN_RESERVED|5.006000||p
922    WARN_SEMICOLON|5.006000||p
923    WARN_SEVERE|5.006000||p
924    WARN_SIGNAL|5.006000||p
925    WARN_SUBSTR|5.006000||p
926    WARN_SYNTAX|5.006000||p
927    WARN_TAINT|5.006000||p
928    WARN_THREADS|5.008000||p
929    WARN_UNINITIALIZED|5.006000||p
930    WARN_UNOPENED|5.006000||p
931    WARN_UNPACK|5.006000||p
932    WARN_UNTIE|5.006000||p
933    WARN_UTF8|5.006000||p
934    WARN_VOID|5.006000||p
935  XCPT_CATCH|5.009002||p  XCPT_CATCH|5.009002||p
936  XCPT_RETHROW|5.009002||p  XCPT_RETHROW|5.009002||p
937  XCPT_TRY_END|5.009002||p  XCPT_TRY_END|5.009002||p
# Line 784  XSRETURN_PV||| Line 950  XSRETURN_PV|||
950  XSRETURN_UNDEF|||  XSRETURN_UNDEF|||
951  XSRETURN_UV|5.008001||p  XSRETURN_UV|5.008001||p
952  XSRETURN_YES|||  XSRETURN_YES|||
953  XSRETURN|||  XSRETURN|||p
954  XST_mIV|||  XST_mIV|||
955  XST_mNO|||  XST_mNO|||
956  XST_mNV|||  XST_mNV|||
# Line 794  XST_mUV|5.008001||p Line 960  XST_mUV|5.008001||p
960  XST_mYES|||  XST_mYES|||
961  XS_VERSION_BOOTCHECK|||  XS_VERSION_BOOTCHECK|||
962  XS_VERSION|||  XS_VERSION|||
963    XSprePUSH|5.006000||p
964  XS|||  XS|||
965  ZeroD|5.009002||p  ZeroD|5.009002||p
966  Zero|||  Zero|||
# Line 801  _aMY_CXT|5.007003||p Line 968  _aMY_CXT|5.007003||p
968  _pMY_CXT|5.007003||p  _pMY_CXT|5.007003||p
969  aMY_CXT_|5.007003||p  aMY_CXT_|5.007003||p
970  aMY_CXT|5.007003||p  aMY_CXT|5.007003||p
971    aTHXR_|5.011000||p
972    aTHXR|5.011000||p
973  aTHX_|5.006000||p  aTHX_|5.006000||p
974  aTHX|5.006000||p  aTHX|5.006000||p
975  add_data|||  add_data|||n
976    addmad|||
977  allocmy|||  allocmy|||
978  amagic_call|||  amagic_call|||
979    amagic_cmp_locale|||
980    amagic_cmp|||
981    amagic_i_ncmp|||
982    amagic_ncmp|||
983  any_dup|||  any_dup|||
984  ao|||  ao|||
985  append_elem|||  append_elem|||
986  append_list|||  append_list|||
987    append_madprops|||
988  apply_attrs_my|||  apply_attrs_my|||
989  apply_attrs_string||5.006001|  apply_attrs_string||5.006001|
990  apply_attrs|||  apply_attrs|||
991  apply|||  apply|||
 asIV|||  
 asUV|||  
992  atfork_lock||5.007003|n  atfork_lock||5.007003|n
993  atfork_unlock||5.007003|n  atfork_unlock||5.007003|n
994  av_arylen_p||5.009003|  av_arylen_p||5.009003|
995  av_clear|||  av_clear|||
996    av_create_and_push||5.009005|
997    av_create_and_unshift_one||5.009005|
998  av_delete||5.006000|  av_delete||5.006000|
999  av_exists||5.006000|  av_exists||5.006000|
1000  av_extend|||  av_extend|||
1001  av_fake|||  av_fake|||
1002  av_fetch|||  av_fetch|||
1003  av_fill|||  av_fill|||
1004    av_iter_p||5.011000|
1005  av_len|||  av_len|||
1006  av_make|||  av_make|||
1007  av_pop|||  av_pop|||
# Line 844  block_start||| Line 1020  block_start|||
1020  boolSV|5.004000||p  boolSV|5.004000||p
1021  boot_core_PerlIO|||  boot_core_PerlIO|||
1022  boot_core_UNIVERSAL|||  boot_core_UNIVERSAL|||
1023    boot_core_mro|||
1024  boot_core_xsutils|||  boot_core_xsutils|||
1025  bytes_from_utf8||5.007001|  bytes_from_utf8||5.007001|
1026    bytes_to_uni|||n
1027  bytes_to_utf8||5.006001|  bytes_to_utf8||5.006001|
 cache_re|||  
1028  call_argv|5.006000||p  call_argv|5.006000||p
1029  call_atexit||5.006000|  call_atexit||5.006000|
 call_body|||  
 call_list_body|||  
1030  call_list||5.004000|  call_list||5.004000|
1031  call_method|5.006000||p  call_method|5.006000||p
1032  call_pv|5.006000||p  call_pv|5.006000||p
# Line 862  cast_i32||5.006000| Line 1037  cast_i32||5.006000|
1037  cast_iv||5.006000|  cast_iv||5.006000|
1038  cast_ulong||5.006000|  cast_ulong||5.006000|
1039  cast_uv||5.006000|  cast_uv||5.006000|
1040    check_type_and_open|||
1041  check_uni|||  check_uni|||
1042  checkcomma|||  checkcomma|||
1043  checkposixcc|||  checkposixcc|||
1044    ckWARN|5.006000||p
1045  ck_anoncode|||  ck_anoncode|||
1046  ck_bitop|||  ck_bitop|||
1047  ck_concat|||  ck_concat|||
1048  ck_defined|||  ck_defined|||
1049  ck_delete|||  ck_delete|||
1050  ck_die|||  ck_die|||
1051    ck_each|||
1052  ck_eof|||  ck_eof|||
1053  ck_eval|||  ck_eval|||
1054  ck_exec|||  ck_exec|||
# Line 889  ck_match||| Line 1067  ck_match|||
1067  ck_method|||  ck_method|||
1068  ck_null|||  ck_null|||
1069  ck_open|||  ck_open|||
1070    ck_readline|||
1071  ck_repeat|||  ck_repeat|||
1072  ck_require|||  ck_require|||
1073  ck_retarget|||  ck_retarget|||
# Line 906  ck_substr||| Line 1085  ck_substr|||
1085  ck_svconst|||  ck_svconst|||
1086  ck_trunc|||  ck_trunc|||
1087  ck_unpack|||  ck_unpack|||
1088  cl_and|||  ckwarn_d||5.009003|
1089  cl_anything|||  ckwarn||5.009003|
1090  cl_init_zero|||  cl_and|||n
1091  cl_init|||  cl_anything|||n
1092  cl_is_anything|||  cl_init_zero|||n
1093  cl_or|||  cl_init|||n
1094    cl_is_anything|||n
1095    cl_or|||n
1096    clear_placeholders|||
1097  closest_cop|||  closest_cop|||
1098  convert|||  convert|||
1099  cop_free|||  cop_free|||
1100  cr_textfilter|||  cr_textfilter|||
1101    create_eval_scope|||
1102  croak_nocontext|||vn  croak_nocontext|||vn
1103  croak|||v  croak|||v
1104  csighandler||5.007001|n  csighandler||5.009003|n
1105    curmad|||
1106  custom_op_desc||5.007003|  custom_op_desc||5.007003|
1107  custom_op_name||5.007003|  custom_op_name||5.007003|
1108    cv_ckproto_len|||
1109  cv_ckproto|||  cv_ckproto|||
1110  cv_clone|||  cv_clone|||
1111  cv_const_sv||5.004000|  cv_const_sv||5.004000|
# Line 929  cv_undef||| Line 1114  cv_undef|||
1114  cx_dump||5.005000|  cx_dump||5.005000|
1115  cx_dup|||  cx_dup|||
1116  cxinc|||  cxinc|||
1117  dAXMARK||5.009003|  dAXMARK|5.009003||p
1118  dAX|5.007002||p  dAX|5.007002||p
1119  dITEMS|5.007002||p  dITEMS|5.007002||p
1120  dMARK|||  dMARK|||
1121    dMULTICALL||5.009003|
1122  dMY_CXT_SV|5.007003||p  dMY_CXT_SV|5.007003||p
1123  dMY_CXT|5.007003||p  dMY_CXT|5.007003||p
1124  dNOOP|5.006000||p  dNOOP|5.006000||p
1125  dORIGMARK|||  dORIGMARK|||
1126  dSP|||  dSP|||
1127  dTHR|5.004050||p  dTHR|5.004050||p
1128    dTHXR|5.011000||p
1129  dTHXa|5.006000||p  dTHXa|5.006000||p
1130  dTHXoa|5.006000||p  dTHXoa|5.006000||p
1131  dTHX|5.006000||p  dTHX|5.006000||p
1132  dUNDERBAR|5.009002||p  dUNDERBAR|5.009002||p
1133    dVAR|5.009003||p
1134  dXCPT|5.009002||p  dXCPT|5.009002||p
1135  dXSARGS|||  dXSARGS|||
1136  dXSI32|||  dXSI32|||
# Line 956  debprofdump||5.005000| Line 1144  debprofdump||5.005000|
1144  debprof|||  debprof|||
1145  debstackptrs||5.007003|  debstackptrs||5.007003|
1146  debstack||5.007003|  debstack||5.007003|
1147    debug_start_match|||
1148  deb||5.007003|v  deb||5.007003|v
 del_he|||  
1149  del_sv|||  del_sv|||
1150    delete_eval_scope|||
1151  delimcpy||5.004000|  delimcpy||5.004000|
 depcom|||  
1152  deprecate_old|||  deprecate_old|||
1153  deprecate|||  deprecate|||
1154  despatch_signals||5.007001|  despatch_signals||5.007001|
1155    destroy_matcher|||
1156  die_nocontext|||vn  die_nocontext|||vn
1157  die_where|||  die_where|||
1158  die|||v  die|||v
# Line 994  do_msgrcv||| Line 1183  do_msgrcv|||
1183  do_msgsnd|||  do_msgsnd|||
1184  do_oddball|||  do_oddball|||
1185  do_op_dump||5.006000|  do_op_dump||5.006000|
1186    do_op_xmldump|||
1187  do_open9||5.006000|  do_open9||5.006000|
1188  do_openn||5.007001|  do_openn||5.007001|
1189  do_open||5.004000|  do_open||5.004000|
 do_pipe|||  
1190  do_pmop_dump||5.006000|  do_pmop_dump||5.006000|
1191    do_pmop_xmldump|||
1192  do_print|||  do_print|||
1193  do_readline|||  do_readline|||
1194  do_seek|||  do_seek|||
1195  do_semop|||  do_semop|||
1196  do_shmio|||  do_shmio|||
1197    do_smartmatch|||
1198  do_spawn_nowait|||  do_spawn_nowait|||
1199  do_spawn|||  do_spawn|||
1200  do_sprintf|||  do_sprintf|||
# Line 1020  do_trans||| Line 1211  do_trans|||
1211  do_vecget|||  do_vecget|||
1212  do_vecset|||  do_vecset|||
1213  do_vop|||  do_vop|||
 docatch_body|||  
1214  docatch|||  docatch|||
1215  doeval|||  doeval|||
1216  dofile|||  dofile|||
# Line 1031  dooneliner||| Line 1221  dooneliner|||
1221  doopen_pm|||  doopen_pm|||
1222  doparseform|||  doparseform|||
1223  dopoptoeval|||  dopoptoeval|||
1224    dopoptogiven|||
1225  dopoptolabel|||  dopoptolabel|||
1226  dopoptoloop|||  dopoptoloop|||
1227  dopoptosub_at|||  dopoptosub_at|||
1228  dopoptosub|||  dopoptowhen|||
1229    doref||5.009003|
1230  dounwind|||  dounwind|||
1231  dowantarray|||  dowantarray|||
1232  dump_all||5.006000|  dump_all||5.006000|
1233  dump_eval||5.006000|  dump_eval||5.006000|
1234    dump_exec_pos|||
1235  dump_fds|||  dump_fds|||
1236  dump_form||5.006000|  dump_form||5.006000|
1237  dump_indent||5.006000|v  dump_indent||5.006000|v
1238  dump_mstats|||  dump_mstats|||
1239  dump_packsubs||5.006000|  dump_packsubs||5.006000|
1240  dump_sub||5.006000|  dump_sub||5.006000|
1241    dump_sv_child|||
1242    dump_trie_interim_list|||
1243    dump_trie_interim_table|||
1244    dump_trie|||
1245  dump_vindent||5.006000|  dump_vindent||5.006000|
1246  dumpuntil|||  dumpuntil|||
1247  dup_attrlist|||  dup_attrlist|||
1248  emulate_eaccess|||  emulate_cop_io|||
1249  eval_pv|5.006000||p  eval_pv|5.006000||p
1250  eval_sv|5.006000||p  eval_sv|5.006000||p
1251    exec_failed|||
1252  expect_number|||  expect_number|||
1253  fbm_compile||5.005000|  fbm_compile||5.005000|
1254  fbm_instr||5.005000|  fbm_instr||5.005000|
1255  fd_on_nosuid_fs|||  fd_on_nosuid_fs|||
1256    feature_is_enabled|||
1257  filter_add|||  filter_add|||
1258  filter_del|||  filter_del|||
1259  filter_gets|||  filter_gets|||
1260  filter_read|||  filter_read|||
1261    find_and_forget_pmops|||
1262    find_array_subscript|||
1263  find_beginning|||  find_beginning|||
1264  find_byclass|||  find_byclass|||
1265    find_hash_subscript|||
1266  find_in_my_stash|||  find_in_my_stash|||
1267  find_runcv|||  find_runcv||5.008001|
1268  find_rundefsvoffset||5.009002|  find_rundefsvoffset||5.009002|
1269  find_script|||  find_script|||
1270  find_uninit_var|||  find_uninit_var|||
1271    first_symbol|||n
1272  fold_constants|||  fold_constants|||
1273  forbid_setid|||  forbid_setid|||
1274  force_ident|||  force_ident|||
# Line 1073  force_list||| Line 1276  force_list|||
1276  force_next|||  force_next|||
1277  force_version|||  force_version|||
1278  force_word|||  force_word|||
1279    forget_pmop|||
1280  form_nocontext|||vn  form_nocontext|||vn
1281  form||5.004000|v  form||5.004000|v
1282  fp_dup|||  fp_dup|||
# Line 1081  free_global_struct||| Line 1285  free_global_struct|||
1285  free_tied_hv_pool|||  free_tied_hv_pool|||
1286  free_tmps|||  free_tmps|||
1287  gen_constant_list|||  gen_constant_list|||
1288    get_arena|||
1289    get_aux_mg|||
1290  get_av|5.006000||p  get_av|5.006000||p
1291  get_context||5.006000|n  get_context||5.006000|n
1292    get_cvn_flags||5.009005|
1293  get_cv|5.006000||p  get_cv|5.006000||p
1294  get_db_sub|||  get_db_sub|||
1295  get_debug_opts|||  get_debug_opts|||
# Line 1095  get_op_descs||5.005000| Line 1302  get_op_descs||5.005000|
1302  get_op_names||5.005000|  get_op_names||5.005000|
1303  get_opargs|||  get_opargs|||
1304  get_ppaddr||5.006000|  get_ppaddr||5.006000|
1305    get_re_arg|||
1306  get_sv|5.006000||p  get_sv|5.006000||p
1307  get_vtbl||5.005030|  get_vtbl||5.005030|
1308  getcwd_sv||5.007002|  getcwd_sv||5.007002|
1309  getenv_len|||  getenv_len|||
1310    glob_2number|||
1311    glob_2pv|||
1312    glob_assign_glob|||
1313    glob_assign_ref|||
1314  gp_dup|||  gp_dup|||
1315  gp_free|||  gp_free|||
1316  gp_ref|||  gp_ref|||
# Line 1111  group_end||| Line 1323  group_end|||
1323  gv_AVadd|||  gv_AVadd|||
1324  gv_HVadd|||  gv_HVadd|||
1325  gv_IOadd|||  gv_IOadd|||
1326    gv_SVadd|||
1327  gv_autoload4||5.004000|  gv_autoload4||5.004000|
1328  gv_check|||  gv_check|||
1329    gv_const_sv||5.009003|
1330  gv_dump||5.006000|  gv_dump||5.006000|
1331  gv_efullname3||5.004000|  gv_efullname3||5.004000|
1332  gv_efullname4||5.006001|  gv_efullname4||5.006001|
1333  gv_efullname|||  gv_efullname|||
1334  gv_ename|||  gv_ename|||
1335    gv_fetchfile_flags||5.009005|
1336  gv_fetchfile|||  gv_fetchfile|||
1337  gv_fetchmeth_autoload||5.007003|  gv_fetchmeth_autoload||5.007003|
1338  gv_fetchmethod_autoload||5.004000|  gv_fetchmethod_autoload||5.004000|
# Line 1129  gv_fetchsv||5.009002| Line 1344  gv_fetchsv||5.009002|
1344  gv_fullname3||5.004000|  gv_fullname3||5.004000|
1345  gv_fullname4||5.006001|  gv_fullname4||5.006001|
1346  gv_fullname|||  gv_fullname|||
1347    gv_get_super_pkg|||
1348  gv_handler||5.007001|  gv_handler||5.007001|
1349  gv_init_sv|||  gv_init_sv|||
1350  gv_init|||  gv_init|||
1351  gv_share|||  gv_name_set||5.009004|
1352  gv_stashpvn|5.006000||p  gv_stashpvn|5.004000||p
1353    gv_stashpvs||5.009003|
1354  gv_stashpv|||  gv_stashpv|||
1355  gv_stashsv|||  gv_stashsv|||
1356  he_dup|||  he_dup|||
1357  hek_dup|||  hek_dup|||
1358  hfreeentries|||  hfreeentries|||
1359  hsplit|||  hsplit|||
1360  hv_assert||5.009001|  hv_assert||5.011000|
1361  hv_auxinit|||  hv_auxinit|||n
1362    hv_backreferences_p|||
1363  hv_clear_placeholders||5.009001|  hv_clear_placeholders||5.009001|
1364  hv_clear|||  hv_clear|||
1365    hv_common_key_len||5.010000|
1366    hv_common||5.010000|
1367    hv_copy_hints_hv|||
1368  hv_delayfree_ent||5.004000|  hv_delayfree_ent||5.004000|
1369  hv_delete_common|||  hv_delete_common|||
1370  hv_delete_ent||5.004000|  hv_delete_ent||5.004000|
# Line 1152  hv_eiter_p||5.009003| Line 1373  hv_eiter_p||5.009003|
1373  hv_eiter_set||5.009003|  hv_eiter_set||5.009003|
1374  hv_exists_ent||5.004000|  hv_exists_ent||5.004000|
1375  hv_exists|||  hv_exists|||
 hv_fetch_common|||  
1376  hv_fetch_ent||5.004000|  hv_fetch_ent||5.004000|
1377    hv_fetchs|5.009003||p
1378  hv_fetch|||  hv_fetch|||
1379  hv_free_ent||5.004000|  hv_free_ent||5.004000|
1380  hv_iterinit|||  hv_iterinit|||
# Line 1163  hv_iternext_flags||5.008000| Line 1384  hv_iternext_flags||5.008000|
1384  hv_iternextsv|||  hv_iternextsv|||
1385  hv_iternext|||  hv_iternext|||
1386  hv_iterval|||  hv_iterval|||
1387    hv_kill_backrefs|||
1388  hv_ksplit||5.004000|  hv_ksplit||5.004000|
1389  hv_magic_check|||  hv_magic_check|||n
1390  hv_magic|||  hv_magic|||
1391  hv_name_set||5.009003|  hv_name_set||5.009003|
1392  hv_notallowed|||  hv_notallowed|||
# Line 1176  hv_riter_set||5.009003| Line 1398  hv_riter_set||5.009003|
1398  hv_scalar||5.009001|  hv_scalar||5.009001|
1399  hv_store_ent||5.004000|  hv_store_ent||5.004000|
1400  hv_store_flags||5.008000|  hv_store_flags||5.008000|
1401    hv_stores|5.009004||p
1402  hv_store|||  hv_store|||
1403  hv_undef|||  hv_undef|||
1404  ibcmp_locale||5.004000|  ibcmp_locale||5.004000|
1405  ibcmp_utf8||5.007003|  ibcmp_utf8||5.007003|
1406  ibcmp|||  ibcmp|||
 incl_perldb|||  
1407  incline|||  incline|||
1408    incpush_if_exists|||
1409  incpush|||  incpush|||
1410  ingroup|||  ingroup|||
1411  init_argv_symbols|||  init_argv_symbols|||
# Line 1192  init_i18nl10n||5.006000| Line 1415  init_i18nl10n||5.006000|
1415  init_i18nl14n||5.006000|  init_i18nl14n||5.006000|
1416  init_ids|||  init_ids|||
1417  init_interp|||  init_interp|||
 init_lexer|||  
1418  init_main_stash|||  init_main_stash|||
1419  init_perllib|||  init_perllib|||
1420  init_postdump_symbols|||  init_postdump_symbols|||
# Line 1214  isUPPER||| Line 1436  isUPPER|||
1436  is_an_int|||  is_an_int|||
1437  is_gv_magical_sv|||  is_gv_magical_sv|||
1438  is_gv_magical|||  is_gv_magical|||
1439  is_handle_constructor|||  is_handle_constructor|||n
1440  is_list_assignment|||  is_list_assignment|||
1441  is_lvalue_sub||5.007001|  is_lvalue_sub||5.007001|
1442  is_uni_alnum_lc||5.006000|  is_uni_alnum_lc||5.006000|
# Line 1249  is_utf8_alnumc||5.006000| Line 1471  is_utf8_alnumc||5.006000|
1471  is_utf8_alnum||5.006000|  is_utf8_alnum||5.006000|
1472  is_utf8_alpha||5.006000|  is_utf8_alpha||5.006000|
1473  is_utf8_ascii||5.006000|  is_utf8_ascii||5.006000|
1474  is_utf8_char_slow|||  is_utf8_char_slow|||n
1475  is_utf8_char||5.006000|  is_utf8_char||5.006000|
1476  is_utf8_cntrl||5.006000|  is_utf8_cntrl||5.006000|
1477    is_utf8_common|||
1478  is_utf8_digit||5.006000|  is_utf8_digit||5.006000|
1479  is_utf8_graph||5.006000|  is_utf8_graph||5.006000|
1480  is_utf8_idcont||5.008000|  is_utf8_idcont||5.008000|
# Line 1270  isa_lookup||| Line 1493  isa_lookup|||
1493  items|||n  items|||n
1494  ix|||n  ix|||n
1495  jmaybe|||  jmaybe|||
1496    join_exact|||
1497  keyword|||  keyword|||
1498  leave_scope|||  leave_scope|||
1499  lex_end|||  lex_end|||
# Line 1278  linklist||| Line 1502  linklist|||
1502  listkids|||  listkids|||
1503  list|||  list|||
1504  load_module_nocontext|||vn  load_module_nocontext|||vn
1505  load_module||5.006000|v  load_module|5.006000||pv
1506  localize|||  localize|||
1507    looks_like_bool|||
1508  looks_like_number|||  looks_like_number|||
1509  lop|||  lop|||
1510  mPUSHi|5.009002||p  mPUSHi|5.009002||p
1511  mPUSHn|5.009002||p  mPUSHn|5.009002||p
1512  mPUSHp|5.009002||p  mPUSHp|5.009002||p
1513    mPUSHs|5.011000||p
1514  mPUSHu|5.009002||p  mPUSHu|5.009002||p
1515  mXPUSHi|5.009002||p  mXPUSHi|5.009002||p
1516  mXPUSHn|5.009002||p  mXPUSHn|5.009002||p
1517  mXPUSHp|5.009002||p  mXPUSHp|5.009002||p
1518    mXPUSHs|5.011000||p
1519  mXPUSHu|5.009002||p  mXPUSHu|5.009002||p
1520    mad_free|||
1521    madlex|||
1522    madparse|||
1523  magic_clear_all_env|||  magic_clear_all_env|||
1524  magic_clearenv|||  magic_clearenv|||
1525    magic_clearhint|||
1526  magic_clearpack|||  magic_clearpack|||
1527  magic_clearsig|||  magic_clearsig|||
1528  magic_dump||5.006000|  magic_dump||5.006000|
1529  magic_existspack|||  magic_existspack|||
1530  magic_freearylen_p|||  magic_freearylen_p|||
1531  magic_freeovrld|||  magic_freeovrld|||
 magic_freeregexp|||  
1532  magic_getarylen|||  magic_getarylen|||
1533  magic_getdefelem|||  magic_getdefelem|||
 magic_getglob|||  
1534  magic_getnkeys|||  magic_getnkeys|||
1535  magic_getpack|||  magic_getpack|||
1536  magic_getpos|||  magic_getpos|||
# Line 1323  magic_scalarpack||| Line 1552  magic_scalarpack|||
1552  magic_set_all_env|||  magic_set_all_env|||
1553  magic_setamagic|||  magic_setamagic|||
1554  magic_setarylen|||  magic_setarylen|||
 magic_setbm|||  
1555  magic_setcollxfrm|||  magic_setcollxfrm|||
1556  magic_setdbline|||  magic_setdbline|||
1557  magic_setdefelem|||  magic_setdefelem|||
1558  magic_setenv|||  magic_setenv|||
1559  magic_setfm|||  magic_sethint|||
 magic_setglob|||  
1560  magic_setisa|||  magic_setisa|||
1561  magic_setmglob|||  magic_setmglob|||
1562  magic_setnkeys|||  magic_setnkeys|||
# Line 1346  magic_set||| Line 1573  magic_set|||
1573  magic_sizepack|||  magic_sizepack|||
1574  magic_wipepack|||  magic_wipepack|||
1575  magicname|||  magicname|||
1576    make_matcher|||
1577    make_trie_failtable|||
1578  make_trie|||  make_trie|||
1579  malloced_size|||n  malloced_size|||n
1580  malloc||5.007002|n  malloc||5.007002|n
1581  markstack_grow|||  markstack_grow|||
1582    matcher_matches_sv|||
1583  measure_struct|||  measure_struct|||
1584  memEQ|5.004000||p  memEQ|5.004000||p
1585  memNE|5.004000||p  memNE|5.004000||p
# Line 1375  missingterm||| Line 1605  missingterm|||
1605  mode_from_discipline|||  mode_from_discipline|||
1606  modkids|||  modkids|||
1607  mod|||  mod|||
1608    more_bodies|||
1609    more_sv|||
1610  moreswitches|||  moreswitches|||
1611    mro_get_linear_isa_c3|||
1612    mro_get_linear_isa_dfs|||
1613    mro_get_linear_isa||5.009005|
1614    mro_isa_changed_in|||
1615    mro_meta_dup|||
1616    mro_meta_init|||
1617    mro_method_changed_in||5.009005|
1618  mul128|||  mul128|||
1619  mulexp10|||n  mulexp10|||n
1620  my_atof2||5.007002|  my_atof2||5.007002|
# Line 1390  my_betohl|||n Line 1629  my_betohl|||n
1629  my_betohs|||n  my_betohs|||n
1630  my_bzero|||n  my_bzero|||n
1631  my_chsize|||  my_chsize|||
1632    my_clearenv|||
1633    my_cxt_index|||
1634    my_cxt_init|||
1635    my_dirfd||5.009005|
1636  my_exit_jump|||  my_exit_jump|||
1637  my_exit|||  my_exit|||
1638  my_failure_exit||5.004000|  my_failure_exit||5.004000|
# Line 1423  my_pclose||5.004000| Line 1666  my_pclose||5.004000|
1666  my_popen_list||5.007001|  my_popen_list||5.007001|
1667  my_popen||5.004000|  my_popen||5.004000|
1668  my_setenv|||  my_setenv|||
1669    my_snprintf|5.009004||pvn
1670  my_socketpair||5.007003|n  my_socketpair||5.007003|n
1671    my_sprintf||5.009003|vn
1672  my_stat|||  my_stat|||
1673  my_strftime||5.007002|  my_strftime||5.007002|
1674    my_strlcat|5.009004||pn
1675    my_strlcpy|5.009004||pn
1676  my_swabn|||n  my_swabn|||n
1677  my_swap|||  my_swap|||
1678  my_unexec|||  my_unexec|||
1679    my_vsnprintf||5.009004|n
1680  my|||  my|||
1681    need_utf8|||n
1682  newANONATTRSUB||5.006000|  newANONATTRSUB||5.006000|
1683  newANONHASH|||  newANONHASH|||
1684  newANONLIST|||  newANONLIST|||
# Line 1440  newAVREF||| Line 1689  newAVREF|||
1689  newAV|||  newAV|||
1690  newBINOP|||  newBINOP|||
1691  newCONDOP|||  newCONDOP|||
1692  newCONSTSUB|5.006000||p  newCONSTSUB|5.004050||p
1693  newCVREF|||  newCVREF|||
1694  newDEFSVOP|||  newDEFSVOP|||
1695  newFORM|||  newFORM|||
1696  newFOROP|||  newFOROP|||
1697    newGIVENOP||5.009003|
1698    newGIVWHENOP|||
1699    newGP|||
1700  newGVOP|||  newGVOP|||
1701  newGVREF|||  newGVREF|||
1702  newGVgen|||  newGVgen|||
# Line 1456  newLISTOP||| Line 1708  newLISTOP|||
1708  newLOGOP|||  newLOGOP|||
1709  newLOOPEX|||  newLOOPEX|||
1710  newLOOPOP|||  newLOOPOP|||
1711  newMYSUB||5.006000|  newMADPROP|||
1712    newMADsv|||
1713    newMYSUB|||
1714  newNULLLIST|||  newNULLLIST|||
1715  newOP|||  newOP|||
1716  newPADOP||5.006000|  newPADOP|||
1717  newPMOP|||  newPMOP|||
1718  newPROG|||  newPROG|||
1719  newPVOP|||  newPVOP|||
1720  newRANGE|||  newRANGE|||
1721  newRV_inc|5.004000||p  newRV_inc|5.004000||p
1722  newRV_noinc|5.006000||p  newRV_noinc|5.004000||p
1723  newRV|||  newRV|||
1724  newSLICEOP|||  newSLICEOP|||
1725  newSTATEOP|||  newSTATEOP|||
1726  newSUB|||  newSUB|||
1727  newSVOP|||  newSVOP|||
1728  newSVREF|||  newSVREF|||
1729    newSV_type||5.009005|
1730  newSVhek||5.009003|  newSVhek||5.009003|
1731  newSViv|||  newSViv|||
1732  newSVnv|||  newSVnv|||
1733  newSVpvf_nocontext|||vn  newSVpvf_nocontext|||vn
1734  newSVpvf||5.004000|v  newSVpvf||5.004000|v
1735  newSVpvn_share||5.007001|  newSVpvn_flags|5.011000||p
1736  newSVpvn|5.006000||p  newSVpvn_share|5.007001||p
1737    newSVpvn_utf8|5.011000||p
1738    newSVpvn|5.004050||p
1739    newSVpvs_flags|5.011000||p
1740    newSVpvs_share||5.009003|
1741    newSVpvs|5.009003||p
1742  newSVpv|||  newSVpv|||
1743  newSVrv|||  newSVrv|||
1744  newSVsv|||  newSVsv|||
1745  newSVuv|5.006000||p  newSVuv|5.006000||p
1746  newSV|||  newSV|||
1747    newTOKEN|||
1748  newUNOP|||  newUNOP|||
1749    newWHENOP||5.009003|
1750  newWHILEOP||5.009003|  newWHILEOP||5.009003|
1751    newXS_flags||5.009004|
1752  newXSproto||5.006000|  newXSproto||5.006000|
1753  newXS||5.006000|  newXS||5.006000|
1754  new_collate||5.006000|  new_collate||5.006000|
# Line 1496  new_logop||| Line 1759  new_logop|||
1759  new_numeric||5.006000|  new_numeric||5.006000|
1760  new_stackinfo||5.005000|  new_stackinfo||5.005000|
1761  new_version||5.009000|  new_version||5.009000|
1762    new_warnings_bitfield|||
1763  next_symbol|||  next_symbol|||
1764  nextargv|||  nextargv|||
1765  nextchar|||  nextchar|||
# Line 1507  not_a_number||| Line 1771  not_a_number|||
1771  nothreadhook||5.008000|  nothreadhook||5.008000|
1772  nuke_stacks|||  nuke_stacks|||
1773  num_overflow|||n  num_overflow|||n
1774    offer_nice_chunk|||
1775  oopsAV|||  oopsAV|||
1776  oopsCV|||  oopsCV|||
1777  oopsHV|||  oopsHV|||
# Line 1514  op_clear||| Line 1779  op_clear|||
1779  op_const_sv|||  op_const_sv|||
1780  op_dump||5.006000|  op_dump||5.006000|
1781  op_free|||  op_free|||
1782    op_getmad_weak|||
1783    op_getmad|||
1784  op_null||5.007002|  op_null||5.007002|
1785    op_refcnt_dec|||
1786    op_refcnt_inc|||
1787  op_refcnt_lock||5.009002|  op_refcnt_lock||5.009002|
1788  op_refcnt_unlock||5.009002|  op_refcnt_unlock||5.009002|
1789    op_xmldump|||
1790  open_script|||  open_script|||
1791  pMY_CXT_|5.007003||p  pMY_CXT_|5.007003||p
1792  pMY_CXT|5.007003||p  pMY_CXT|5.007003||p
1793  pTHX_|5.006000||p  pTHX_|5.006000||p
1794  pTHX|5.006000||p  pTHX|5.006000||p
1795    packWARN|5.007003||p
1796  pack_cat||5.007003|  pack_cat||5.007003|
1797  pack_rec|||  pack_rec|||
1798  package|||  package|||
# Line 1538  pad_fixup_inner_anons||| Line 1809  pad_fixup_inner_anons|||
1809  pad_free|||  pad_free|||
1810  pad_leavemy|||  pad_leavemy|||
1811  pad_new|||  pad_new|||
1812    pad_peg|||n
1813  pad_push|||  pad_push|||
1814  pad_reset|||  pad_reset|||
1815  pad_setsv|||  pad_setsv|||
1816  pad_sv|||  pad_sv||5.011000|
1817  pad_swipe|||  pad_swipe|||
1818  pad_tidy|||  pad_tidy|||
1819  pad_undef|||  pad_undef|||
1820  parse_body|||  parse_body|||
1821  parse_unicode_opts|||  parse_unicode_opts|||
1822  path_is_absolute|||  parser_dup|||
1823    parser_free|||
1824    path_is_absolute|||n
1825  peep|||  peep|||
1826  pending_ident|||  pending_Slabs_to_ro|||
1827  perl_alloc_using|||n  perl_alloc_using|||n
1828  perl_alloc|||n  perl_alloc|||n
1829  perl_clone_using|||n  perl_clone_using|||n
# Line 1560  perl_free|||n Line 1834  perl_free|||n
1834  perl_parse||5.006000|n  perl_parse||5.006000|n
1835  perl_run|||n  perl_run|||n
1836  pidgone|||  pidgone|||
1837    pm_description|||
1838  pmflag|||  pmflag|||
1839  pmop_dump||5.006000|  pmop_dump||5.006000|
1840    pmop_xmldump|||
1841  pmruntime|||  pmruntime|||
1842  pmtrans|||  pmtrans|||
1843  pop_scope|||  pop_scope|||
1844  pregcomp|||  pregcomp||5.009005|
1845  pregexec|||  pregexec|||
1846    pregfree2||5.011000|
1847  pregfree|||  pregfree|||
1848  prepend_elem|||  prepend_elem|||
1849    prepend_madprops|||
1850    printbuf|||
1851  printf_nocontext|||vn  printf_nocontext|||vn
1852  ptr_table_clear|||  process_special_blocks|||
1853  ptr_table_fetch|||  ptr_table_clear||5.009005|
1854  ptr_table_free|||  ptr_table_fetch||5.009005|
1855  ptr_table_new|||  ptr_table_find|||n
1856  ptr_table_split|||  ptr_table_free||5.009005|
1857  ptr_table_store|||  ptr_table_new||5.009005|
1858    ptr_table_split||5.009005|
1859    ptr_table_store||5.009005|
1860  push_scope|||  push_scope|||
1861  put_byte|||  put_byte|||
1862  pv_display||5.006000|  pv_display||5.006000|
1863    pv_escape||5.009004|
1864    pv_pretty||5.009004|
1865  pv_uni_display||5.007003|  pv_uni_display||5.007003|
1866  qerror|||  qerror|||
1867    qsortsvu|||
1868    re_compile||5.009005|
1869  re_croak2|||  re_croak2|||
1870  re_dup|||  re_dup_guts|||
1871  re_intuit_start||5.006000|  re_intuit_start||5.009005|
1872  re_intuit_string||5.006000|  re_intuit_string||5.006000|
1873    readpipe_override|||
1874  realloc||5.007002|n  realloc||5.007002|n
1875  reentrant_free|||  reentrant_free|||
1876  reentrant_init|||  reentrant_init|||
1877  reentrant_retry|||vn  reentrant_retry|||vn
1878  reentrant_size|||  reentrant_size|||
1879    ref_array_or_hash|||
1880    refcounted_he_chain_2hv|||
1881    refcounted_he_fetch|||
1882    refcounted_he_free|||
1883    refcounted_he_new|||
1884    refcounted_he_value|||
1885  refkids|||  refkids|||
1886  refto|||  refto|||
1887  ref|||  ref||5.011000|
1888    reg_check_named_buff_matched|||
1889    reg_named_buff_all||5.009005|
1890    reg_named_buff_exists||5.009005|
1891    reg_named_buff_fetch||5.009005|
1892    reg_named_buff_firstkey||5.009005|
1893    reg_named_buff_iter|||
1894    reg_named_buff_nextkey||5.009005|
1895    reg_named_buff_scalar||5.009005|
1896    reg_named_buff|||
1897    reg_namedseq|||
1898  reg_node|||  reg_node|||
1899    reg_numbered_buff_fetch|||
1900    reg_numbered_buff_length|||
1901    reg_numbered_buff_store|||
1902    reg_qr_package|||
1903    reg_recode|||
1904    reg_scan_name|||
1905    reg_skipcomment|||
1906    reg_stringify||5.009005|
1907    reg_temp_copy|||
1908  reganode|||  reganode|||
1909  regatom|||  regatom|||
1910  regbranch|||  regbranch|||
1911  regclass_swash||5.007003|  regclass_swash||5.009004|
1912  regclass|||  regclass|||
 regcp_set_to|||  
1913  regcppop|||  regcppop|||
1914  regcppush|||  regcppush|||
1915  regcurly|||  regcurly|||n
1916    regdump_extflags|||
1917  regdump||5.005000|  regdump||5.005000|
1918    regdupe_internal|||
1919  regexec_flags||5.005000|  regexec_flags||5.005000|
1920  reghop3|||  regfree_internal||5.009005|
1921  reghopmaybe3|||  reghop3|||n
1922  reghopmaybe|||  reghop4|||n
1923  reghop|||  reghopmaybe3|||n
1924  reginclass|||  reginclass|||
1925  reginitcolors||5.006000|  reginitcolors||5.006000|
1926  reginsert|||  reginsert|||
1927  regmatch|||  regmatch|||
1928  regnext||5.005000|  regnext||5.005000|
 regoptail|||  
1929  regpiece|||  regpiece|||
1930  regpposixcc|||  regpposixcc|||
1931  regprop|||  regprop|||
 regrepeat_hard|||  
1932  regrepeat|||  regrepeat|||
1933    regtail_study|||
1934  regtail|||  regtail|||
1935  regtry|||  regtry|||
1936  reguni|||  reguni|||
1937  regwhite|||  regwhite|||n
1938  reg|||  reg|||
1939  repeatcpy|||  repeatcpy|||
1940  report_evil_fh|||  report_evil_fh|||
1941  report_uninit|||  report_uninit|||
 require_errno|||  
1942  require_pv||5.006000|  require_pv||5.006000|
1943    require_tie_mod|||
1944    restore_magic|||
1945  rninstr|||  rninstr|||
1946  rsignal_restore|||  rsignal_restore|||
1947  rsignal_save|||  rsignal_save|||
1948  rsignal_state||5.004000|  rsignal_state||5.004000|
1949  rsignal||5.004000|  rsignal||5.004000|
1950  run_body|||  run_body|||
1951    run_user_filter|||
1952  runops_debug||5.005000|  runops_debug||5.005000|
1953  runops_standard||5.005000|  runops_standard||5.005000|
1954  rvpv_dup|||  rvpv_dup|||
# Line 1666  save_generic_pvref||5.006001| Line 1979  save_generic_pvref||5.006001|
1979  save_generic_svref||5.005030|  save_generic_svref||5.005030|
1980  save_gp||5.004000|  save_gp||5.004000|
1981  save_hash|||  save_hash|||
1982  save_hek_flags|||  save_hek_flags|||n
1983  save_helem||5.004050|  save_helem||5.004050|
 save_hints||5.005000|  
1984  save_hptr|||  save_hptr|||
1985  save_int|||  save_int|||
1986  save_item|||  save_item|||
# Line 1689  save_set_svflags||5.009000| Line 2001  save_set_svflags||5.009000|
2001  save_shared_pvref||5.007003|  save_shared_pvref||5.007003|
2002  save_sptr|||  save_sptr|||
2003  save_svref|||  save_svref|||
 save_threadsv||5.005000|  
2004  save_vptr||5.006000|  save_vptr||5.006000|
2005  savepvn|||  savepvn|||
2006    savepvs||5.009003|
2007  savepv|||  savepv|||
2008    savesharedpvn||5.009005|
2009  savesharedpv||5.007003|  savesharedpv||5.007003|
2010  savestack_grow_cnt||5.008001|  savestack_grow_cnt||5.008001|
2011  savestack_grow|||  savestack_grow|||
2012  savesvpv||5.009002|  savesvpv||5.009002|
2013  sawparens|||  sawparens|||
2014  scalar_mod_type|||  scalar_mod_type|||n
2015  scalarboolean|||  scalarboolean|||
2016  scalarkids|||  scalarkids|||
2017  scalarseq|||  scalarseq|||
# Line 1719  scan_str||| Line 2032  scan_str|||
2032  scan_subst|||  scan_subst|||
2033  scan_trans|||  scan_trans|||
2034  scan_version||5.009001|  scan_version||5.009001|
2035  scan_vstring||5.008001|  scan_vstring||5.009005|
2036  scan_word|||  scan_word|||
2037  scope|||  scope|||
2038  screaminstr||5.005000|  screaminstr||5.005000|
2039  seed|||  seed||5.008001|
2040    sequence_num|||
2041    sequence_tail|||
2042    sequence|||
2043  set_context||5.006000|n  set_context||5.006000|n
 set_csh|||  
2044  set_numeric_local||5.006000|  set_numeric_local||5.006000|
2045  set_numeric_radix||5.006000|  set_numeric_radix||5.006000|
2046  set_numeric_standard||5.006000|  set_numeric_standard||5.006000|
2047  setdefout|||  setdefout|||
2048  setenv_getix|||  setenv_getix|||
2049  share_hek_flags|||  share_hek_flags|||
2050  share_hek|||  share_hek||5.004000|
2051  si_dup|||  si_dup|||
2052  sighandler|||n  sighandler|||n
2053  simplify_sort|||  simplify_sort|||
2054    skipspace0|||
2055    skipspace1|||
2056    skipspace2|||
2057  skipspace|||  skipspace|||
2058    softref2xv|||
2059    sortcv_stacked|||
2060    sortcv_xsub|||
2061    sortcv|||
2062    sortsv_flags||5.009003|
2063  sortsv||5.007003|  sortsv||5.007003|
2064    space_join_names_mortal|||
2065  ss_dup|||  ss_dup|||
2066  stack_grow|||  stack_grow|||
2067    start_force|||
2068  start_glob|||  start_glob|||
2069  start_subparse||5.004000|  start_subparse||5.004000|
2070  stashpv_hvname_match||5.009003|  stashpv_hvname_match||5.011000|
2071  stdize_locale|||  stdize_locale|||
2072  strEQ|||  strEQ|||
2073  strGE|||  strGE|||
# Line 1751  strLE||| Line 2076  strLE|||
2076  strLT|||  strLT|||
2077  strNE|||  strNE|||
2078  str_to_version||5.006000|  str_to_version||5.006000|
2079    strip_return|||
2080  strnEQ|||  strnEQ|||
2081  strnNE|||  strnNE|||
2082  study_chunk|||  study_chunk|||
# Line 1761  sublex_start||| Line 2087  sublex_start|||
2087  sv_2bool|||  sv_2bool|||
2088  sv_2cv|||  sv_2cv|||
2089  sv_2io|||  sv_2io|||
2090    sv_2iuv_common|||
2091  sv_2iuv_non_preserve|||  sv_2iuv_non_preserve|||
2092  sv_2iv_flags||5.009001|  sv_2iv_flags||5.009001|
2093  sv_2iv|||  sv_2iv|||
2094  sv_2mortal|||  sv_2mortal|||
2095    sv_2num|||
2096  sv_2nv|||  sv_2nv|||
2097  sv_2pv_flags||5.007002|  sv_2pv_flags|5.007002||p
2098  sv_2pv_nolen|5.006000||p  sv_2pv_nolen|5.006000||p
2099  sv_2pvbyte_nolen|||  sv_2pvbyte_nolen|5.006000||p
2100  sv_2pvbyte|5.006000||p  sv_2pvbyte|5.006000||p
2101  sv_2pvutf8_nolen||5.006000|  sv_2pvutf8_nolen||5.006000|
2102  sv_2pvutf8||5.006000|  sv_2pvutf8||5.006000|
# Line 1780  sv_add_backref||| Line 2108  sv_add_backref|||
2108  sv_backoff|||  sv_backoff|||
2109  sv_bless|||  sv_bless|||
2110  sv_cat_decode||5.008001|  sv_cat_decode||5.008001|
2111  sv_catpv_mg|5.006000||p  sv_catpv_mg|5.004050||p
2112  sv_catpvf_mg_nocontext|||pvn  sv_catpvf_mg_nocontext|||pvn
2113  sv_catpvf_mg|5.006000|5.004000|pv  sv_catpvf_mg|5.006000|5.004000|pv
2114  sv_catpvf_nocontext|||vn  sv_catpvf_nocontext|||vn
2115  sv_catpvf||5.004000|v  sv_catpvf||5.004000|v
2116  sv_catpvn_flags||5.007002|  sv_catpvn_flags||5.007002|
2117  sv_catpvn_mg|5.006000||p  sv_catpvn_mg|5.004050||p
2118  sv_catpvn_nomg|5.007002||p  sv_catpvn_nomg|5.007002||p
2119  sv_catpvn|||  sv_catpvn|||
2120    sv_catpvs|5.009003||p
2121  sv_catpv|||  sv_catpv|||
2122  sv_catsv_flags||5.007002|  sv_catsv_flags||5.007002|
2123  sv_catsv_mg|5.006000||p  sv_catsv_mg|5.004050||p
2124  sv_catsv_nomg|5.007002||p  sv_catsv_nomg|5.007002||p
2125  sv_catsv|||  sv_catsv|||
2126    sv_catxmlpvn|||
2127    sv_catxmlsv|||
2128  sv_chop|||  sv_chop|||
2129  sv_clean_all|||  sv_clean_all|||
2130  sv_clean_objs|||  sv_clean_objs|||
# Line 1806  sv_copypv||5.007003| Line 2137  sv_copypv||5.007003|
2137  sv_dec|||  sv_dec|||
2138  sv_del_backref|||  sv_del_backref|||
2139  sv_derived_from||5.004000|  sv_derived_from||5.004000|
2140    sv_destroyable||5.010000|
2141    sv_does||5.009004|
2142  sv_dump|||  sv_dump|||
2143  sv_dup|||  sv_dup|||
2144  sv_eq|||  sv_eq|||
2145    sv_exp_grow|||
2146  sv_force_normal_flags||5.007001|  sv_force_normal_flags||5.007001|
2147  sv_force_normal||5.006000|  sv_force_normal||5.006000|
2148  sv_free2|||  sv_free2|||
# Line 1816  sv_free_arenas||| Line 2150  sv_free_arenas|||
2150  sv_free|||  sv_free|||
2151  sv_gets||5.004000|  sv_gets||5.004000|
2152  sv_grow|||  sv_grow|||
2153    sv_i_ncmp|||
2154  sv_inc|||  sv_inc|||
2155  sv_insert|||  sv_insert|||
2156  sv_isa|||  sv_isa|||
2157  sv_isobject|||  sv_isobject|||
2158  sv_iv||5.005000|  sv_iv||5.005000|
2159    sv_kill_backrefs|||
2160  sv_len_utf8||5.006000|  sv_len_utf8||5.006000|
2161  sv_len|||  sv_len|||
2162    sv_magic_portable|5.011000|5.004000|p
2163  sv_magicext||5.007003|  sv_magicext||5.007003|
2164  sv_magic|||  sv_magic|||
2165  sv_mortalcopy|||  sv_mortalcopy|||
2166    sv_ncmp|||
2167  sv_newmortal|||  sv_newmortal|||
2168  sv_newref|||  sv_newref|||
2169  sv_nolocking||5.007003|  sv_nolocking||5.007003|
2170  sv_nosharing||5.007003|  sv_nosharing||5.007003|
2171  sv_nounlocking||5.007003|  sv_nounlocking|||
2172  sv_nv||5.005000|  sv_nv||5.005000|
2173  sv_peek||5.005000|  sv_peek||5.005000|
2174    sv_pos_b2u_midway|||
2175  sv_pos_b2u||5.006000|  sv_pos_b2u||5.006000|
2176    sv_pos_u2b_cached|||
2177    sv_pos_u2b_forwards|||n
2178    sv_pos_u2b_midway|||n
2179  sv_pos_u2b||5.006000|  sv_pos_u2b||5.006000|
2180  sv_pvbyten_force||5.006000|  sv_pvbyten_force||5.006000|
2181  sv_pvbyten||5.006000|  sv_pvbyten||5.006000|
2182  sv_pvbyte||5.006000|  sv_pvbyte||5.006000|
2183  sv_pvn_force_flags||5.007002|  sv_pvn_force_flags|5.007002||p
2184  sv_pvn_force|||p  sv_pvn_force|||
2185  sv_pvn_nomg|5.007003||p  sv_pvn_nomg|5.007003|5.005000|p
2186  sv_pvn|5.006000||p  sv_pvn||5.005000|
2187  sv_pvutf8n_force||5.006000|  sv_pvutf8n_force||5.006000|
2188  sv_pvutf8n||5.006000|  sv_pvutf8n||5.006000|
2189  sv_pvutf8||5.006000|  sv_pvutf8||5.006000|
# Line 1849  sv_pv||5.006000| Line 2191  sv_pv||5.006000|
2191  sv_recode_to_utf8||5.007003|  sv_recode_to_utf8||5.007003|
2192  sv_reftype|||  sv_reftype|||
2193  sv_release_COW|||  sv_release_COW|||
 sv_release_IVX|||  
2194  sv_replace|||  sv_replace|||
2195  sv_report_used|||  sv_report_used|||
2196  sv_reset|||  sv_reset|||
2197  sv_rvweaken||5.006000|  sv_rvweaken||5.006000|
2198  sv_setiv_mg|5.006000||p  sv_setiv_mg|5.004050||p
2199  sv_setiv|||  sv_setiv|||
2200  sv_setnv_mg|5.006000||p  sv_setnv_mg|5.006000||p
2201  sv_setnv|||  sv_setnv|||
2202  sv_setpv_mg|5.006000||p  sv_setpv_mg|5.004050||p
2203  sv_setpvf_mg_nocontext|||pvn  sv_setpvf_mg_nocontext|||pvn
2204  sv_setpvf_mg|5.006000|5.004000|pv  sv_setpvf_mg|5.006000|5.004000|pv
2205  sv_setpvf_nocontext|||vn  sv_setpvf_nocontext|||vn
2206  sv_setpvf||5.004000|v  sv_setpvf||5.004000|v
2207  sv_setpviv_mg||5.008001|  sv_setpviv_mg||5.008001|
2208  sv_setpviv||5.008001|  sv_setpviv||5.008001|
2209  sv_setpvn_mg|5.006000||p  sv_setpvn_mg|5.004050||p
2210  sv_setpvn|||  sv_setpvn|||
2211    sv_setpvs|5.009004||p
2212  sv_setpv|||  sv_setpv|||
2213  sv_setref_iv|||  sv_setref_iv|||
2214  sv_setref_nv|||  sv_setref_nv|||
# Line 1875  sv_setref_pv||| Line 2217  sv_setref_pv|||
2217  sv_setref_uv||5.007001|  sv_setref_uv||5.007001|
2218  sv_setsv_cow|||  sv_setsv_cow|||
2219  sv_setsv_flags||5.007002|  sv_setsv_flags||5.007002|
2220  sv_setsv_mg|5.006000||p  sv_setsv_mg|5.004050||p
2221  sv_setsv_nomg|5.007002||p  sv_setsv_nomg|5.007002||p
2222  sv_setsv|||  sv_setsv|||
2223  sv_setuv_mg|5.006000||p  sv_setuv_mg|5.004050||p
2224  sv_setuv|5.006000||p  sv_setuv|5.004000||p
2225  sv_tainted||5.004000|  sv_tainted||5.004000|
2226  sv_taint||5.004000|  sv_taint||5.004000|
2227  sv_true||5.005000|  sv_true||5.005000|
# Line 1890  sv_unref_flags||5.007001| Line 2232  sv_unref_flags||5.007001|
2232  sv_unref|||  sv_unref|||
2233  sv_untaint||5.004000|  sv_untaint||5.004000|
2234  sv_upgrade|||  sv_upgrade|||
2235  sv_usepvn_mg|5.006000||p  sv_usepvn_flags||5.009004|
2236    sv_usepvn_mg|5.004050||p
2237  sv_usepvn|||  sv_usepvn|||
2238  sv_utf8_decode||5.006000|  sv_utf8_decode||5.006000|
2239  sv_utf8_downgrade||5.006000|  sv_utf8_downgrade||5.006000|
2240  sv_utf8_encode||5.006000|  sv_utf8_encode||5.006000|
2241  sv_utf8_upgrade_flags||5.007002|  sv_utf8_upgrade_flags||5.007002|
2242  sv_utf8_upgrade||5.007001|  sv_utf8_upgrade||5.007001|
2243  sv_uv|5.006000||p  sv_uv|5.005000||p
2244  sv_vcatpvf_mg|5.006000|5.004000|p  sv_vcatpvf_mg|5.006000|5.004000|p
2245  sv_vcatpvfn||5.004000|  sv_vcatpvfn||5.004000|
2246  sv_vcatpvf|5.006000|5.004000|p  sv_vcatpvf|5.006000|5.004000|p
2247  sv_vsetpvf_mg|5.006000|5.004000|p  sv_vsetpvf_mg|5.006000|5.004000|p
2248  sv_vsetpvfn||5.004000|  sv_vsetpvfn||5.004000|
2249  sv_vsetpvf|5.006000|5.004000|p  sv_vsetpvf|5.006000|5.004000|p
2250    sv_xmlpeek|||
2251  svtype|||  svtype|||
2252  swallow_bom|||  swallow_bom|||
2253    swap_match_buff|||
2254  swash_fetch||5.007002|  swash_fetch||5.007002|
2255    swash_get|||
2256  swash_init||5.006000|  swash_init||5.006000|
2257    sys_init3||5.010000|n
2258    sys_init||5.010000|n
2259  sys_intern_clear|||  sys_intern_clear|||
2260  sys_intern_dup|||  sys_intern_dup|||
2261  sys_intern_init|||  sys_intern_init|||
2262    sys_term||5.010000|n
2263  taint_env|||  taint_env|||
2264  taint_proper|||  taint_proper|||
2265  tmps_grow||5.006000|  tmps_grow||5.006000|
# Line 1930  to_utf8_lower||5.007003| Line 2279  to_utf8_lower||5.007003|
2279  to_utf8_substr|||  to_utf8_substr|||
2280  to_utf8_title||5.007003|  to_utf8_title||5.007003|
2281  to_utf8_upper||5.007003|  to_utf8_upper||5.007003|
2282    token_free|||
2283    token_getmad|||
2284    tokenize_use|||
2285  tokeq|||  tokeq|||
2286  tokereport|||  tokereport|||
2287  too_few_arguments|||  too_few_arguments|||
2288  too_many_arguments|||  too_many_arguments|||
2289    uiv_2buf|||n
2290  unlnk|||  unlnk|||
2291  unpack_rec|||  unpack_rec|||
2292  unpack_str||5.007003|  unpack_str||5.007003|
# Line 1941  unpackstring||5.008001| Line 2294  unpackstring||5.008001|
2294  unshare_hek_or_pvn|||  unshare_hek_or_pvn|||
2295  unshare_hek|||  unshare_hek|||
2296  unsharepvn||5.004000|  unsharepvn||5.004000|
2297  upg_version||5.009000|  unwind_handler_stack|||
2298    update_debugger_info|||
2299    upg_version||5.009005|
2300  usage|||  usage|||
 utf16_textfilter|||  
2301  utf16_to_utf8_reversed||5.006001|  utf16_to_utf8_reversed||5.006001|
2302  utf16_to_utf8||5.006001|  utf16_to_utf8||5.006001|
 utf16rev_textfilter|||  
2303  utf8_distance||5.006000|  utf8_distance||5.006000|
2304  utf8_hop||5.006000|  utf8_hop||5.006000|
2305  utf8_length||5.007001|  utf8_length||5.007001|
2306  utf8_mg_pos_init|||  utf8_mg_pos_cache_update|||
 utf8_mg_pos|||  
2307  utf8_to_bytes||5.006001|  utf8_to_bytes||5.006001|
2308  utf8_to_uvchr||5.007001|  utf8_to_uvchr||5.007001|
2309  utf8_to_uvuni||5.007001|  utf8_to_uvuni||5.007001|
2310  utf8n_to_uvchr||5.007001|  utf8n_to_uvchr|||
2311  utf8n_to_uvuni||5.007001|  utf8n_to_uvuni||5.007001|
2312  utilize|||  utilize|||
2313  uvchr_to_utf8_flags||5.007003|  uvchr_to_utf8_flags||5.007003|
2314  uvchr_to_utf8||5.007001|  uvchr_to_utf8|||
2315  uvuni_to_utf8_flags||5.007003|  uvuni_to_utf8_flags||5.007003|
2316  uvuni_to_utf8||5.007001|  uvuni_to_utf8||5.007001|
2317  validate_suid|||  validate_suid|||
# Line 1967  varname||| Line 2319  varname|||
2319  vcmp||5.009000|  vcmp||5.009000|
2320  vcroak||5.006000|  vcroak||5.006000|
2321  vdeb||5.007003|  vdeb||5.007003|
2322    vdie_common|||
2323    vdie_croak_common|||
2324  vdie|||  vdie|||
2325  vform||5.006000|  vform||5.006000|
2326  visit|||  visit|||
2327  vivify_defelem|||  vivify_defelem|||
2328  vivify_ref|||  vivify_ref|||
2329  vload_module||5.006000|  vload_module|5.006000||p
2330  vmess||5.006000|  vmess||5.006000|
2331  vnewSVpvf|5.006000|5.004000|p  vnewSVpvf|5.006000|5.004000|p
2332  vnormal||5.009002|  vnormal||5.009002|
2333  vnumify||5.009000|  vnumify||5.009000|
2334  vstringify||5.009000|  vstringify||5.009000|
2335    vverify||5.009003|
2336  vwarner||5.006000|  vwarner||5.006000|
2337  vwarn||5.006000|  vwarn||5.006000|
2338  wait4pid|||  wait4pid|||
2339  warn_nocontext|||vn  warn_nocontext|||vn
2340  warner_nocontext|||vn  warner_nocontext|||vn
2341  warner||5.006000|v  warner|5.006000|5.004000|pv
2342  warn|||v  warn|||v
2343  watch|||  watch|||
2344  whichsig|||  whichsig|||
2345    write_no_mem|||
2346  write_to_stderr|||  write_to_stderr|||
2347    xmldump_all|||
2348    xmldump_attr|||
2349    xmldump_eval|||
2350    xmldump_form|||
2351    xmldump_indent|||v
2352    xmldump_packsubs|||
2353    xmldump_sub|||
2354    xmldump_vindent|||
2355  yyerror|||  yyerror|||
2356  yylex|||  yylex|||
2357  yyparse|||  yyparse|||
# Line 2005  if (exists $opt{'list-unsupported'}) { Line 2369  if (exists $opt{'list-unsupported'}) {
2369    
2370  # Scan for possible replacement candidates  # Scan for possible replacement candidates
2371    
2372  my(%replace, %need, %hints, %depends);  my(%replace, %need, %hints, %warnings, %depends);
2373  my $replace = 0;  my $replace = 0;
2374  my $hint = '';  my($hint, $define, $function);
2375    
2376    sub find_api
2377    {
2378      my $code = shift;
2379      $code =~ s{
2380        / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*)
2381      | "[^"\\]*(?:\\.[^"\\]*)*"
2382      | '[^'\\]*(?:\\.[^'\\]*)*' }{}egsx;
2383      grep { exists $API{$_} } $code =~ /(\w+)/mg;
2384    }
2385    
2386  while (<DATA>) {  while (<DATA>) {
2387    if ($hint) {    if ($hint) {
2388        my $h = $hint->[0] eq 'Hint' ? \%hints : \%warnings;
2389      if (m{^\s*\*\s(.*?)\s*$}) {      if (m{^\s*\*\s(.*?)\s*$}) {
2390        $hints{$hint} ||= '';  # suppress warning with older perls        for (@{$hint->[1]}) {
2391        $hints{$hint} .= "$1\n";          $h->{$_} ||= '';  # suppress warning with older perls
2392            $h->{$_} .= "$1\n";
2393          }
2394        }
2395        else { undef $hint }
2396      }
2397    
2398      $hint = [$1, [split /,?\s+/, $2]]
2399          if m{^\s*$rccs\s+(Hint|Warning):\s+(\w+(?:,?\s+\w+)*)\s*$};
2400    
2401      if ($define) {
2402        if ($define->[1] =~ /\\$/) {
2403          $define->[1] .= $_;
2404      }      }
2405      else {      else {
2406        $hint = '';        if (exists $API{$define->[0]} && $define->[1] !~ /^DPPP_\(/) {
2407            my @n = find_api($define->[1]);
2408            push @{$depends{$define->[0]}}, @n if @n
2409          }
2410          undef $define;
2411        }
2412      }
2413    
2414      $define = [$1, $2] if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(.*)};
2415    
2416      if ($function) {
2417        if (/^}/) {
2418          if (exists $API{$function->[0]}) {
2419            my @n = find_api($function->[1]);
2420            push @{$depends{$function->[0]}}, @n if @n
2421          }
2422          undef $function;
2423        }
2424        else {
2425          $function->[1] .= $_;
2426      }      }
2427    }    }
2428    $hint = $1 if m{^\s*$rccs\sHint:\s+(\w+)\s*$};  
2429      $function = [$1, ''] if m{^DPPP_\(my_(\w+)\)};
2430    
2431    $replace     = $1 if m{^\s*$rccs\s+Replace:\s+(\d+)\s+$rcce\s*$};    $replace     = $1 if m{^\s*$rccs\s+Replace:\s+(\d+)\s+$rcce\s*$};
2432    $replace{$2} = $1 if $replace and m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+)};    $replace{$2} = $1 if $replace and m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+)};
# Line 2033  while (<DATA>) { Line 2440  while (<DATA>) {
2440    $need{$1} = 1 if m{^#if\s+defined\(NEED_(\w+)(?:_GLOBAL)?\)};    $need{$1} = 1 if m{^#if\s+defined\(NEED_(\w+)(?:_GLOBAL)?\)};
2441  }  }
2442    
2443    for (values %depends) {
2444      my %s;
2445      $_ = [sort grep !$s{$_}++, @$_];
2446    }
2447    
2448  if (exists $opt{'api-info'}) {  if (exists $opt{'api-info'}) {
2449    my $f;    my $f;
2450    my $count = 0;    my $count = 0;
# Line 2051  if (exists $opt{'api-info'}) { Line 2463  if (exists $opt{'api-info'}) {
2463        print "Support by $ppport provided back to perl-$todo.\n";        print "Support by $ppport provided back to perl-$todo.\n";
2464        print "Support needs to be explicitly requested by NEED_$f.\n" if exists $need{$f};        print "Support needs to be explicitly requested by NEED_$f.\n" if exists $need{$f};
2465        print "Depends on: ", join(', ', @{$depends{$f}}), ".\n" if exists $depends{$f};        print "Depends on: ", join(', ', @{$depends{$f}}), ".\n" if exists $depends{$f};
2466        print "$hints{$f}" if exists $hints{$f};        print "\n$hints{$f}" if exists $hints{$f};
2467          print "\nWARNING:\n$warnings{$f}" if exists $warnings{$f};
2468        $info++;        $info++;
2469      }      }
2470      unless ($info) {      print "No portability information available.\n" unless $info;
       print "No portability information available.\n";  
     }  
2471      $count++;      $count++;
2472    }    }
2473    if ($count > 0) {    $count or print "Found no API matching '$opt{'api-info'}'.";
2474      print "\n";    print "\n";
   }  
   else {  
     print "Found no API matching '$opt{'api-info'}'.\n";  
   }  
2475    exit 0;    exit 0;
2476  }  }
2477    
# Line 2076  if (exists $opt{'list-provided'}) { Line 2483  if (exists $opt{'list-provided'}) {
2483      push @flags, 'explicit' if exists $need{$f};      push @flags, 'explicit' if exists $need{$f};
2484      push @flags, 'depend'   if exists $depends{$f};      push @flags, 'depend'   if exists $depends{$f};
2485      push @flags, 'hint'     if exists $hints{$f};      push @flags, 'hint'     if exists $hints{$f};
2486        push @flags, 'warning'  if exists $warnings{$f};
2487      my $flags = @flags ? '  ['.join(', ', @flags).']' : '';      my $flags = @flags ? '  ['.join(', ', @flags).']' : '';
2488      print "$f$flags\n";      print "$f$flags\n";
2489    }    }
# Line 2083  if (exists $opt{'list-provided'}) { Line 2491  if (exists $opt{'list-provided'}) {
2491  }  }
2492    
2493  my @files;  my @files;
2494  my @srcext = qw( xs c h cc cpp );  my @srcext = qw( .xs .c .h .cc .cpp -c.inc -xs.inc );
2495  my $srcext = join '|', @srcext;  my $srcext = join '|', map { quotemeta $_ } @srcext;
2496    
2497  if (@ARGV) {  if (@ARGV) {
2498    my %seen;    my %seen;
2499    @files = grep { -f && !exists $seen{$_} } map { glob $_ } @ARGV;    for (@ARGV) {
2500        if (-e) {
2501          if (-f) {
2502            push @files, $_ unless $seen{$_}++;
2503          }
2504          else { warn "'$_' is not a file.\n" }
2505        }
2506        else {
2507          my @new = grep { -f } glob $_
2508              or warn "'$_' does not exist.\n";
2509          push @files, grep { !$seen{$_}++ } @new;
2510        }
2511      }
2512  }  }
2513  else {  else {
2514    eval {    eval {
2515      require File::Find;      require File::Find;
2516      File::Find::find(sub {      File::Find::find(sub {
2517        $File::Find::name =~ /\.($srcext)$/i        $File::Find::name =~ /($srcext)$/i
2518            and push @files, $File::Find::name;            and push @files, $File::Find::name;
2519      }, '.');      }, '.');
2520    };    };
2521    if ($@) {    if ($@) {
2522      @files = map { glob "*.$_" } @srcext;      @files = map { glob "*$_" } @srcext;
2523    }    }
2524  }  }
2525    
# Line 2107  if (!@ARGV || $opt{filter}) { Line 2527  if (!@ARGV || $opt{filter}) {
2527    my(@in, @out);    my(@in, @out);
2528    my %xsc = map { /(.*)\.xs$/ ? ("$1.c" => 1, "$1.cc" => 1) : () } @files;    my %xsc = map { /(.*)\.xs$/ ? ("$1.c" => 1, "$1.cc" => 1) : () } @files;
2529    for (@files) {    for (@files) {
2530      my $out = exists $xsc{$_} || /\b\Q$ppport\E$/i || !/\.($srcext)$/i;      my $out = exists $xsc{$_} || /\b\Q$ppport\E$/i || !/($srcext)$/i;
2531      push @{ $out ? \@out : \@in }, $_;      push @{ $out ? \@out : \@in }, $_;
2532    }    }
2533    if (@ARGV && @out) {    if (@ARGV && @out) {
# Line 2116  if (!@ARGV || $opt{filter}) { Line 2536  if (!@ARGV || $opt{filter}) {
2536    @files = @in;    @files = @in;
2537  }  }
2538    
2539  unless (@files) {  die "No input files given!\n" unless @files;
   die "No input files given!\n";  
 }  
2540    
2541  my(%files, %global, %revreplace);  my(%files, %global, %revreplace);
2542  %revreplace = reverse %replace;  %revreplace = reverse %replace;
# Line 2138  for $filename (@files) { Line 2556  for $filename (@files) {
2556    
2557    my %file = (orig => $c, changes => 0);    my %file = (orig => $c, changes => 0);
2558    
2559    # temporarily remove C comments from the code    # Temporarily remove C/XS comments and strings from the code
2560    my @ccom;    my @ccom;
2561    
2562    $c =~ s{    $c =~ s{
2563      (      ( ^$HS*\#$HS*include\b[^\r\n]+\b(?:\Q$ppport\E|XSUB\.h)\b[^\r\n]*
2564          [^"'/]+      | ^$HS*\#$HS*(?:define|elif|if(?:def)?)\b[^\r\n]* )
2565        |    | ( ^$HS*\#[^\r\n]*
2566          (?:"[^"\\]*(?:\\.[^"\\]*)*" [^"'/]*)+      | "[^"\\]*(?:\\.[^"\\]*)*"
2567        |      | '[^'\\]*(?:\\.[^'\\]*)*'
2568          (?:'[^'\\]*(?:\\.[^'\\]*)*' [^"'/]*)+      | / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]* ) )
2569      )    }{ defined $2 and push @ccom, $2;
2570    |       defined $1 ? $1 : "$ccs$#ccom$cce" }mgsex;
     (/ (?:  
         \*[^*]*\*+(?:[^$ccs][^*]*\*+)* /  
         |  
         /[^\r\n]*  
       ))  
   }{  
     defined $2 and push @ccom, $2;  
     defined $1 ? $1 : "$ccs$#ccom$cce";  
   }egsx;  
2571    
2572    $file{ccom} = \@ccom;    $file{ccom} = \@ccom;
2573    $file{code} = $c;    $file{code} = $c;
2574    $file{has_inc_ppport} = ($c =~ /#.*include.*\Q$ppport\E/);    $file{has_inc_ppport} = $c =~ /^$HS*#$HS*include[^\r\n]+\b\Q$ppport\E\b/m;
2575    
2576    my $func;    my $func;
2577    
# Line 2172  for $filename (@files) { Line 2582  for $filename (@files) {
2582        $file{uses_replace}{$1}++ if exists $revreplace{$func} && $1 eq $revreplace{$func};        $file{uses_replace}{$1}++ if exists $revreplace{$func} && $1 eq $revreplace{$func};
2583        $file{uses_Perl}{$func}++ if $c =~ /\bPerl_$func\b/;        $file{uses_Perl}{$func}++ if $c =~ /\bPerl_$func\b/;
2584        if (exists $API{$func}{provided}) {        if (exists $API{$func}{provided}) {
2585            $file{uses_provided}{$func}++;
2586          if (!exists $API{$func}{base} || $API{$func}{base} > $opt{'compat-version'}) {          if (!exists $API{$func}{base} || $API{$func}{base} > $opt{'compat-version'}) {
2587            $file{uses}{$func}++;            $file{uses}{$func}++;
2588            my @deps = rec_depend($func);            my @deps = rec_depend($func);
# Line 2182  for $filename (@files) { Line 2593  for $filename (@files) {
2593              }              }
2594            }            }
2595            for ($func, @deps) {            for ($func, @deps) {
2596              if (exists $need{$_}) {              $file{needs}{$_} = 'static' if exists $need{$_};
               $file{needs}{$_} = 'static';  
             }  
2597            }            }
2598          }          }
2599        }        }
# Line 2200  for $filename (@files) { Line 2609  for $filename (@files) {
2609      if (exists $need{$2}) {      if (exists $need{$2}) {
2610        $file{defined $3 ? 'needed_global' : 'needed_static'}{$2}++;        $file{defined $3 ? 'needed_global' : 'needed_static'}{$2}++;
2611      }      }
2612      else {      else { warning("Possibly wrong #define $1 in $filename") }
       warning("Possibly wrong #define $1 in $filename");  
     }  
2613    }    }
2614    
2615    for (qw(uses needs uses_todo needed_global needed_static)) {    for (qw(uses needs uses_todo needed_global needed_static)) {
# Line 2239  for $filename (@files) { Line 2646  for $filename (@files) {
2646    my %file = %{$files{$filename}};    my %file = %{$files{$filename}};
2647    my $func;    my $func;
2648    my $c = $file{code};    my $c = $file{code};
2649      my $warnings = 0;
2650    
2651    for $func (sort keys %{$file{uses_Perl}}) {    for $func (sort keys %{$file{uses_Perl}}) {
2652      if ($API{$func}{varargs}) {      if ($API{$func}{varargs}) {
2653        my $changes = ($c =~ s{\b(Perl_$func\s*\(\s*)(?!aTHX_?)(\)|[^\s)]*\))}        unless ($API{$func}{nothxarg}) {
2654                              { $1 . ($2 eq ')' ? 'aTHX' : 'aTHX_ ') . $2 }ge);          my $changes = ($c =~ s{\b(Perl_$func\s*\(\s*)(?!aTHX_?)(\)|[^\s)]*\))}
2655        if ($changes) {                                { $1 . ($2 eq ')' ? 'aTHX' : 'aTHX_ ') . $2 }ge);
2656          warning("Doesn't pass interpreter argument aTHX to Perl_$func");          if ($changes) {
2657          $file{changes} += $changes;            warning("Doesn't pass interpreter argument aTHX to Perl_$func");
2658              $file{changes} += $changes;
2659            }
2660        }        }
2661      }      }
2662      else {      else {
# Line 2261  for $filename (@files) { Line 2671  for $filename (@files) {
2671      $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g);      $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g);
2672    }    }
2673    
2674    for $func (sort keys %{$file{uses}}) {    for $func (sort keys %{$file{uses_provided}}) {
2675      next unless $file{uses}{$func};   # if it's only a dependency      if ($file{uses}{$func}) {
2676      if (exists $file{uses_deps}{$func}) {        if (exists $file{uses_deps}{$func}) {
2677        diag("Uses $func, which depends on ", join(', ', @{$file{uses_deps}{$func}}));          diag("Uses $func, which depends on ", join(', ', @{$file{uses_deps}{$func}}));
2678      }        }
2679      elsif (exists $replace{$func}) {        else {
2680        warning("Uses $func instead of $replace{$func}");          diag("Uses $func");
2681        $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g);        }
     }  
     else {  
       diag("Uses $func");  
2682      }      }
2683      hint($func);      $warnings += hint($func);
2684    }    }
2685    
2686    for $func (sort keys %{$file{uses_todo}}) {    unless ($opt{quiet}) {
2687      warning("Uses $func, which may not be portable below perl ",      for $func (sort keys %{$file{uses_todo}}) {
2688              format_version($API{$func}{todo}));        print "*** WARNING: Uses $func, which may not be portable below perl ",
2689                format_version($API{$func}{todo}), ", even with '$ppport'\n";
2690          $warnings++;
2691        }
2692    }    }
2693    
2694    for $func (sort keys %{$file{needed_static}}) {    for $func (sort keys %{$file{needed_static}}) {
# Line 2377  for $filename (@files) { Line 2787  for $filename (@files) {
2787      warning("Uses $cppc C++ style comment$s, which is not portable");      warning("Uses $cppc C++ style comment$s, which is not portable");
2788    }    }
2789    
2790      my $s = $warnings != 1 ? 's' : '';
2791      my $warn = $warnings ? " ($warnings warning$s)" : '';
2792      info("Analysis completed$warn");
2793    
2794    if ($file{changes}) {    if ($file{changes}) {
2795      if (exists $opt{copy}) {      if (exists $opt{copy}) {
2796        my $newfile = "$filename$opt{copy}";        my $newfile = "$filename$opt{copy}";
# Line 2431  close PATCH if $patch_opened; Line 2845  close PATCH if $patch_opened;
2845  exit 0;  exit 0;
2846    
2847    
2848    sub try_use { eval "use @_;"; return $@ eq '' }
2849    
2850  sub mydiff  sub mydiff
2851  {  {
2852    local *F = shift;    local *F = shift;
# Line 2441  sub mydiff Line 2857  sub mydiff
2857      $diff = run_diff($opt{diff}, $file, $str);      $diff = run_diff($opt{diff}, $file, $str);
2858    }    }
2859    
2860    if (!defined $diff and can_use('Text::Diff')) {    if (!defined $diff and try_use('Text::Diff')) {
2861      $diff = Text::Diff::diff($file, \$str, { STYLE => 'Unified' });      $diff = Text::Diff::diff($file, \$str, { STYLE => 'Unified' });
2862      $diff = <<HEADER . $diff;      $diff = <<HEADER . $diff;
2863  --- $file  --- $file
# Line 2463  HEADER Line 2879  HEADER
2879    }    }
2880    
2881    print F $diff;    print F $diff;
   
2882  }  }
2883    
2884  sub run_diff  sub run_diff
# Line 2500  sub run_diff Line 2915  sub run_diff
2915    return undef;    return undef;
2916  }  }
2917    
 sub can_use  
 {  
   eval "use @_;";  
   return $@ eq '';  
 }  
   
2918  sub rec_depend  sub rec_depend
2919  {  {
2920    my $func = shift;    my($func, $seen) = @_;
   my %seen;  
2921    return () unless exists $depends{$func};    return () unless exists $depends{$func};
2922    grep !$seen{$_}++, map { ($_, rec_depend($_)) } @{$depends{$func}};    $seen = {%{$seen||{}}};
2923      return () if $seen->{$func}++;
2924      my %s;
2925      grep !$s{$_}++, map { ($_, rec_depend($_, $seen)) } @{$depends{$func}};
2926  }  }
2927    
2928  sub parse_version  sub parse_version
# Line 2591  sub error Line 3002  sub error
3002  }  }
3003    
3004  my %given_hints;  my %given_hints;
3005    my %given_warnings;
3006  sub hint  sub hint
3007  {  {
3008    $opt{quiet} and return;    $opt{quiet} and return;
   $opt{hints} or return;  
3009    my $func = shift;    my $func = shift;
3010    exists $hints{$func} or return;    my $rv = 0;
3011    $given_hints{$func}++ and return;    if (exists $warnings{$func} && !$given_warnings{$func}++) {
3012    my $hint = $hints{$func};      my $warn = $warnings{$func};
3013    $hint =~ s/^/   /mg;      $warn =~ s!^!*** !mg;
3014    print "   --- hint for $func ---\n", $hint;      print "*** WARNING: $func\n", $warn;
3015        $rv++;
3016      }
3017      if ($opt{hints} && exists $hints{$func} && !$given_hints{$func}++) {
3018        my $hint = $hints{$func};
3019        $hint =~ s/^/   /mg;
3020        print "   --- hint for $func ---\n", $hint;
3021      }
3022      $rv;
3023  }  }
3024    
3025  sub usage  sub usage
# Line 2621  ENDUSAGE Line 3040  ENDUSAGE
3040    exit 2;    exit 2;
3041  }  }
3042    
3043    sub strip
3044    {
3045      my $self = do { local(@ARGV,$/)=($0); <> };
3046      my($copy) = $self =~ /^=head\d\s+COPYRIGHT\s*^(.*?)^=\w+/ms;
3047      $copy =~ s/^(?=\S+)/    /gms;
3048      $self =~ s/^$HS+Do NOT edit.*?(?=^-)/$copy/ms;
3049      $self =~ s/^SKIP.*(?=^__DATA__)/SKIP
3050    if (\@ARGV && \$ARGV[0] eq '--unstrip') {
3051      eval { require Devel::PPPort };
3052      \$@ and die "Cannot require Devel::PPPort, please install.\\n";
3053      if (\$Devel::PPPort::VERSION < $VERSION) {
3054        die "$0 was originally generated with Devel::PPPort $VERSION.\\n"
3055          . "Your Devel::PPPort is only version \$Devel::PPPort::VERSION.\\n"
3056          . "Please install a newer version, or --unstrip will not work.\\n";
3057      }
3058      Devel::PPPort::WriteFile(\$0);
3059      exit 0;
3060    }
3061    print <<END;
3062    
3063    Sorry, but this is a stripped version of \$0.
3064    
3065    To be able to use its original script and doc functionality,
3066    please try to regenerate this file using:
3067    
3068      \$^X \$0 --unstrip
3069    
3070    END
3071    /ms;
3072      my($pl, $c) = $self =~ /(.*^__DATA__)(.*)/ms;
3073      $c =~ s{
3074        / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*)
3075      | ( "[^"\\]*(?:\\.[^"\\]*)*"
3076        | '[^'\\]*(?:\\.[^'\\]*)*' )
3077      | ($HS+) }{ defined $2 ? ' ' : ($1 || '') }gsex;
3078      $c =~ s!\s+$!!mg;
3079      $c =~ s!^$LF!!mg;
3080      $c =~ s!^\s*#\s*!#!mg;
3081      $c =~ s!^\s+!!mg;
3082    
3083      open OUT, ">$0" or die "cannot strip $0: $!\n";
3084      print OUT "$pl$c\n";
3085    
3086      exit 0;
3087    }
3088    
3089  __DATA__  __DATA__
3090  */  */
3091    
# Line 2652  __DATA__ Line 3117  __DATA__
3117  #  endif  #  endif
3118  #endif  #endif
3119    
3120  #define PERL_BCDVERSION ((PERL_REVISION * 0x1000000L) + (PERL_VERSION * 0x1000L) + PERL_SUBVERSION)  #define _dpppDEC2BCD(dec) ((((dec)/100)<<8)|((((dec)%100)/10)<<4)|((dec)%10))
3121    #define PERL_BCDVERSION ((_dpppDEC2BCD(PERL_REVISION)<<24)|(_dpppDEC2BCD(PERL_VERSION)<<12)|_dpppDEC2BCD(PERL_SUBVERSION))
3122    
3123  /* It is very unlikely that anyone will try to use this with Perl 6  /* It is very unlikely that anyone will try to use this with Perl 6
3124     (or greater), but who knows.     (or greater), but who knows.
# Line 2998  __DATA__ Line 3464  __DATA__
3464  #ifndef UVSIZE  #ifndef UVSIZE
3465  #  define UVSIZE                         IVSIZE  #  define UVSIZE                         IVSIZE
3466  #endif  #endif
   
3467  #ifndef sv_setuv  #ifndef sv_setuv
3468  #  define sv_setuv(sv, uv)                  \  #  define sv_setuv(sv, uv)               \
3469     STMT_START {                             \                 STMT_START {                         \
3470         UV TeMpUv = uv;                      \                   UV TeMpUv = uv;                    \
3471         if (TeMpUv <= IV_MAX)                \                   if (TeMpUv <= IV_MAX)              \
3472             sv_setiv(sv, TeMpUv);            \                     sv_setiv(sv, TeMpUv);            \
3473         else                                 \                   else                               \
3474             sv_setnv(sv, (double)TeMpUv);    \                     sv_setnv(sv, (double)TeMpUv);    \
3475     } STMT_END                 } STMT_END
3476  #endif  #endif
   
3477  #ifndef newSVuv  #ifndef newSVuv
3478  #  define newSVuv(uv) ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv))  #  define newSVuv(uv)                    ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv))
3479  #endif  #endif
3480  #ifndef sv_2uv  #ifndef sv_2uv
3481  #  define sv_2uv(sv)                     ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv)))  #  define sv_2uv(sv)                     ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv)))
# Line 3039  __DATA__ Line 3503  __DATA__
3503  #ifndef sv_uv  #ifndef sv_uv
3504  #  define sv_uv(sv)                      SvUVx(sv)  #  define sv_uv(sv)                      SvUVx(sv)
3505  #endif  #endif
3506    
3507    #if !defined(SvUOK) && defined(SvIOK_UV)
3508    #  define SvUOK(sv) SvIOK_UV(sv)
3509    #endif
3510  #ifndef XST_mUV  #ifndef XST_mUV
3511  #  define XST_mUV(i,v)                   (ST(i) = sv_2mortal(newSVuv(v))  )  #  define XST_mUV(i,v)                   (ST(i) = sv_2mortal(newSVuv(v))  )
3512  #endif  #endif
# Line 3054  __DATA__ Line 3522  __DATA__
3522  #  define XPUSHu(u)                      STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END  #  define XPUSHu(u)                      STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END
3523  #endif  #endif
3524    
3525  #if (PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5))  #ifdef HAS_MEMCMP
3526  /* Replace: 1 */  #ifndef memNE
3527  #  define PL_DBsingle               DBsingle  #  define memNE(s1,s2,l)                 (memcmp(s1,s2,l))
3528  #  define PL_DBsub                  DBsub  #endif
3529  #  define PL_Sv                     Sv  
3530  #  define PL_compiling              compiling  #ifndef memEQ
3531  #  define PL_copline                copline  #  define memEQ(s1,s2,l)                 (!memcmp(s1,s2,l))
3532  #  define PL_curcop                 curcop  #endif
3533  #  define PL_curstash               curstash  
3534  #  define PL_debstash               debstash  #else
3535  #  define PL_defgv                  defgv  #ifndef memNE
3536  #  define PL_diehook                diehook  #  define memNE(s1,s2,l)                 (bcmp(s1,s2,l))
3537  #  define PL_dirty                  dirty  #endif
3538  #  define PL_dowarn                 dowarn  
3539  #  define PL_errgv                  errgv  #ifndef memEQ
3540  #  define PL_hexdigit               hexdigit  #  define memEQ(s1,s2,l)                 (!bcmp(s1,s2,l))
3541  #  define PL_hints                  hints  #endif
3542  #  define PL_na                     na  
3543  #  define PL_no_modify              no_modify  #endif
3544  #  define PL_perl_destruct_level    perl_destruct_level  #ifndef MoveD
3545  #  define PL_perldb                 perldb  #  define MoveD(s,d,n,t)                 memmove((char*)(d),(char*)(s), (n) * sizeof(t))
3546  #  define PL_ppaddr                 ppaddr  #endif
3547  #  define PL_rsfp_filters           rsfp_filters  
3548  #  define PL_rsfp                   rsfp  #ifndef CopyD
3549  #  define PL_stack_base             stack_base  #  define CopyD(s,d,n,t)                 memcpy((char*)(d),(char*)(s), (n) * sizeof(t))
3550  #  define PL_stack_sp               stack_sp  #endif
3551  #  define PL_stdingv                stdingv  
3552  #  define PL_sv_arenaroot           sv_arenaroot  #ifdef HAS_MEMSET
3553  #  define PL_sv_no                  sv_no  #ifndef ZeroD
3554  #  define PL_sv_undef               sv_undef  #  define ZeroD(d,n,t)                   memzero((char*)(d), (n) * sizeof(t))
3555  #  define PL_sv_yes                 sv_yes  #endif
3556  #  define PL_tainted                tainted  
3557  #  define PL_tainting               tainting  #else
3558  /* Replace: 0 */  #ifndef ZeroD
3559    #  define ZeroD(d,n,t)                   ((void)memzero((char*)(d), (n) * sizeof(t)), d)
3560    #endif
3561    
3562    #endif
3563    #ifndef PoisonWith
3564    #  define PoisonWith(d,n,t,b)            (void)memset((char*)(d), (U8)(b), (n) * sizeof(t))
3565    #endif
3566    
3567    #ifndef PoisonNew
3568    #  define PoisonNew(d,n,t)               PoisonWith(d,n,t,0xAB)
3569    #endif
3570    
3571    #ifndef PoisonFree
3572    #  define PoisonFree(d,n,t)              PoisonWith(d,n,t,0xEF)
3573    #endif
3574    
3575    #ifndef Poison
3576    #  define Poison(d,n,t)                  PoisonFree(d,n,t)
3577    #endif
3578    #ifndef Newx
3579    #  define Newx(v,n,t)                    New(0,v,n,t)
3580    #endif
3581    
3582    #ifndef Newxc
3583    #  define Newxc(v,n,t,c)                 Newc(0,v,n,t,c)
3584    #endif
3585    
3586    #ifndef Newxz
3587    #  define Newxz(v,n,t)                   Newz(0,v,n,t)
3588  #endif  #endif
3589    
3590  #ifndef PERL_UNUSED_DECL  #ifndef PERL_UNUSED_DECL
# Line 3101  __DATA__ Line 3598  __DATA__
3598  #    define PERL_UNUSED_DECL  #    define PERL_UNUSED_DECL
3599  #  endif  #  endif
3600  #endif  #endif
3601    
3602    #ifndef PERL_UNUSED_ARG
3603    #  if defined(lint) && defined(S_SPLINT_S) /* www.splint.org */
3604    #    include <note.h>
3605    #    define PERL_UNUSED_ARG(x) NOTE(ARGUNUSED(x))
3606    #  else
3607    #    define PERL_UNUSED_ARG(x) ((void)x)
3608    #  endif
3609    #endif
3610    
3611    #ifndef PERL_UNUSED_VAR
3612    #  define PERL_UNUSED_VAR(x) ((void)x)
3613    #endif
3614    
3615    #ifndef PERL_UNUSED_CONTEXT
3616    #  ifdef USE_ITHREADS
3617    #    define PERL_UNUSED_CONTEXT PERL_UNUSED_ARG(my_perl)
3618    #  else
3619    #    define PERL_UNUSED_CONTEXT
3620    #  endif
3621    #endif
3622  #ifndef NOOP  #ifndef NOOP
3623  #  define NOOP                           (void)0  #  define NOOP                           /*EMPTY*/(void)0
3624  #endif  #endif
3625    
3626  #ifndef dNOOP  #ifndef dNOOP
3627  #  define dNOOP                          extern int Perl___notused PERL_UNUSED_DECL  #  define dNOOP                          extern int /*@unused@*/ Perl___notused PERL_UNUSED_DECL
3628  #endif  #endif
3629    
3630  #ifndef NVTYPE  #ifndef NVTYPE
# Line 3158  typedef NVTYPE NV; Line 3676  typedef NVTYPE NV;
3676  #  define EXTERN_C extern  #  define EXTERN_C extern
3677  #endif  #endif
3678    
3679  #ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN  #if defined(PERL_GCC_PEDANTIC)
3680  #  if defined(__STRICT_ANSI__) && defined(PERL_GCC_PEDANTIC)  #  ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN
3681  #    define PERL_GCC_BRACE_GROUPS_FORBIDDEN  #    define PERL_GCC_BRACE_GROUPS_FORBIDDEN
3682  #  endif  #  endif
3683  #endif  #endif
3684    
3685    #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) && !defined(__cplusplus)
3686    #  ifndef PERL_USE_GCC_BRACE_GROUPS
3687    #    define PERL_USE_GCC_BRACE_GROUPS
3688    #  endif
3689    #endif
3690    
3691  #undef STMT_START  #undef STMT_START
3692  #undef STMT_END  #undef STMT_END
3693  #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) && !defined(__cplusplus)  #ifdef PERL_USE_GCC_BRACE_GROUPS
3694  #  define STMT_START    (void)( /* gcc supports ``({ STATEMENTS; })'' */  #  define STMT_START    (void)( /* gcc supports ``({ STATEMENTS; })'' */
3695  #  define STMT_END      )  #  define STMT_END      )
3696  #else  #else
# Line 3198  typedef NVTYPE NV; Line 3722  typedef NVTYPE NV;
3722  #ifndef ERRSV  #ifndef ERRSV
3723  #  define ERRSV                          get_sv("@",FALSE)  #  define ERRSV                          get_sv("@",FALSE)
3724  #endif  #endif
 #ifndef newSVpvn  
 #  define newSVpvn(data,len)             ((data)                                              \  
                                     ? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \  
                                     : newSV(0))  
 #endif  
3725    
3726  /* Hint: gv_stashpvn  /* Hint: gv_stashpvn
3727   * This function's backport doesn't support the length parameter, but   * This function's backport doesn't support the length parameter, but
# Line 3232  typedef NVTYPE NV; Line 3751  typedef NVTYPE NV;
3751  #endif  #endif
3752    
3753  /* Replace: 0 */  /* Replace: 0 */
   
 #ifdef HAS_MEMCMP  
 #ifndef memNE  
 #  define memNE(s1,s2,l)                 (memcmp(s1,s2,l))  
 #endif  
   
 #ifndef memEQ  
 #  define memEQ(s1,s2,l)                 (!memcmp(s1,s2,l))  
 #endif  
   
 #else  
 #ifndef memNE  
 #  define memNE(s1,s2,l)                 (bcmp(s1,s2,l))  
 #endif  
   
 #ifndef memEQ  
 #  define memEQ(s1,s2,l)                 (!bcmp(s1,s2,l))  
 #endif  
   
 #endif  
 #ifndef MoveD  
 #  define MoveD(s,d,n,t)                 memmove((char*)(d),(char*)(s), (n) * sizeof(t))  
 #endif  
   
 #ifndef CopyD  
 #  define CopyD(s,d,n,t)                 memcpy((char*)(d),(char*)(s), (n) * sizeof(t))  
 #endif  
   
 #ifdef HAS_MEMSET  
 #ifndef ZeroD  
 #  define ZeroD(d,n,t)                   memzero((char*)(d), (n) * sizeof(t))  
 #endif  
   
 #else  
 #ifndef ZeroD  
 #  define ZeroD(d,n,t)                   ((void)memzero((char*)(d), (n) * sizeof(t)),d)  
 #endif  
   
 #endif  
 #ifndef Poison  
 #  define Poison(d,n,t)                  (void)memset((char*)(d), 0xAB, (n) * sizeof(t))  
 #endif  
3754  #ifndef dUNDERBAR  #ifndef dUNDERBAR
3755  #  define dUNDERBAR                      dNOOP  #  define dUNDERBAR                      dNOOP
3756  #endif  #endif
# Line 3291  typedef NVTYPE NV; Line 3768  typedef NVTYPE NV;
3768  #ifndef dXSTARG  #ifndef dXSTARG
3769  #  define dXSTARG                        SV * targ = sv_newmortal()  #  define dXSTARG                        SV * targ = sv_newmortal()
3770  #endif  #endif
3771  #ifndef dTHR  #ifndef dAXMARK
3772  #  define dTHR                           dNOOP  #  define dAXMARK                        I32 ax = POPMARK; \
3773                                   register SV ** const mark = PL_stack_base + ax++
3774  #endif  #endif
3775  #ifndef dTHX  #ifndef XSprePUSH
3776  #  define dTHX                           dNOOP  #  define XSprePUSH                      (sp = PL_stack_base + ax - 1)
3777  #endif  #endif
3778    
3779  #ifndef dTHXa  #if (PERL_BCDVERSION < 0x5005000)
3780  #  define dTHXa(x)                       dNOOP  #  undef XSRETURN
3781    #  define XSRETURN(off)                                   \
3782          STMT_START {                                        \
3783              PL_stack_sp = PL_stack_base + ax + ((off) - 1); \
3784              return;                                         \
3785          } STMT_END
3786  #endif  #endif
3787  #ifndef pTHX  #ifndef PERL_ABS
3788  #  define pTHX                           void  #  define PERL_ABS(x)                    ((x) < 0 ? -(x) : (x))
3789    #endif
3790    #ifndef dVAR
3791    #  define dVAR                           dNOOP
3792    #endif
3793    #ifndef SVf
3794    #  define SVf                            "_"
3795    #endif
3796    #ifndef UTF8_MAXBYTES
3797    #  define UTF8_MAXBYTES                  UTF8_MAXLEN
3798    #endif
3799    #ifndef PERL_HASH
3800    #  define PERL_HASH(hash,str,len)        \
3801         STMT_START { \
3802            const char *s_PeRlHaSh = str; \
3803            I32 i_PeRlHaSh = len; \
3804            U32 hash_PeRlHaSh = 0; \
3805            while (i_PeRlHaSh--) \
3806                hash_PeRlHaSh = hash_PeRlHaSh * 33 + *s_PeRlHaSh++; \
3807            (hash) = hash_PeRlHaSh; \
3808        } STMT_END
3809  #endif  #endif
3810    
3811  #ifndef pTHX_  #ifndef PERL_SIGNALS_UNSAFE_FLAG
3812  #  define pTHX_  
3813    #define PERL_SIGNALS_UNSAFE_FLAG 0x0001
3814    
3815    #if (PERL_BCDVERSION < 0x5008000)
3816    #  define D_PPP_PERL_SIGNALS_INIT   PERL_SIGNALS_UNSAFE_FLAG
3817    #else
3818    #  define D_PPP_PERL_SIGNALS_INIT   0
3819  #endif  #endif
3820    
3821  #ifndef aTHX  #if defined(NEED_PL_signals)
3822  #  define aTHX  static U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
3823    #elif defined(NEED_PL_signals_GLOBAL)
3824    U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
3825    #else
3826    extern U32 DPPP_(my_PL_signals);
3827  #endif  #endif
3828    #define PL_signals DPPP_(my_PL_signals)
3829    
 #ifndef aTHX_  
 #  define aTHX_  
3830  #endif  #endif
3831  #ifndef dTHXoa  
3832    /* Hint: PL_ppaddr
3833     * Calling an op via PL_ppaddr requires passing a context argument
3834     * for threaded builds. Since the context argument is different for
3835     * 5.005 perls, you can use aTHXR (supplied by ppport.h), which will
3836     * automatically be defined as the correct argument.
3837     */
3838    
3839    #if (PERL_BCDVERSION <= 0x5005005)
3840    /* Replace: 1 */
3841    #  define PL_ppaddr                 ppaddr
3842    #  define PL_no_modify              no_modify
3843    /* Replace: 0 */
3844    #endif
3845    
3846    #if (PERL_BCDVERSION <= 0x5004005)
3847    /* Replace: 1 */
3848    #  define PL_DBsignal               DBsignal
3849    #  define PL_DBsingle               DBsingle
3850    #  define PL_DBsub                  DBsub
3851    #  define PL_DBtrace                DBtrace
3852    #  define PL_Sv                     Sv
3853    #  define PL_compiling              compiling
3854    #  define PL_copline                copline
3855    #  define PL_curcop                 curcop
3856    #  define PL_curstash               curstash
3857    #  define PL_debstash               debstash
3858    #  define PL_defgv                  defgv
3859    #  define PL_diehook                diehook
3860    #  define PL_dirty                  dirty
3861    #  define PL_dowarn                 dowarn
3862    #  define PL_errgv                  errgv
3863    #  define PL_expect                 expect
3864    #  define PL_hexdigit               hexdigit
3865    #  define PL_hints                  hints
3866    #  define PL_laststatval            laststatval
3867    #  define PL_na                     na
3868    #  define PL_perl_destruct_level    perl_destruct_level
3869    #  define PL_perldb                 perldb
3870    #  define PL_rsfp_filters           rsfp_filters
3871    #  define PL_rsfp                   rsfp
3872    #  define PL_stack_base             stack_base
3873    #  define PL_stack_sp               stack_sp
3874    #  define PL_statcache              statcache
3875    #  define PL_stdingv                stdingv
3876    #  define PL_sv_arenaroot           sv_arenaroot
3877    #  define PL_sv_no                  sv_no
3878    #  define PL_sv_undef               sv_undef
3879    #  define PL_sv_yes                 sv_yes
3880    #  define PL_tainted                tainted
3881    #  define PL_tainting               tainting
3882    /* Replace: 0 */
3883    #endif
3884    
3885    /* Warning: PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters
3886     * Do not use this variable. It is internal to the perl parser
3887     * and may change or even be removed in the future. Note that
3888     * as of perl 5.9.5 you cannot assign to this variable anymore.
3889     */
3890    
3891    /* TODO: cannot assign to these vars; is it worth fixing? */
3892    #if (PERL_BCDVERSION >= 0x5009005)
3893    #  define PL_expect         (PL_parser ? PL_parser->expect : 0)
3894    #  define PL_copline        (PL_parser ? PL_parser->copline : 0)
3895    #  define PL_rsfp           (PL_parser ? PL_parser->rsfp : (PerlIO *) 0)
3896    #  define PL_rsfp_filters   (PL_parser ? PL_parser->rsfp_filters : (AV *) 0)
3897    #endif
3898    #ifndef dTHR
3899    #  define dTHR                           dNOOP
3900    #endif
3901    #ifndef dTHX
3902    #  define dTHX                           dNOOP
3903    #endif
3904    
3905    #ifndef dTHXa
3906    #  define dTHXa(x)                       dNOOP
3907    #endif
3908    #ifndef pTHX
3909    #  define pTHX                           void
3910    #endif
3911    
3912    #ifndef pTHX_
3913    #  define pTHX_
3914    #endif
3915    
3916    #ifndef aTHX
3917    #  define aTHX
3918    #endif
3919    
3920    #ifndef aTHX_
3921    #  define aTHX_
3922    #endif
3923    
3924    #if (PERL_BCDVERSION < 0x5006000)
3925    #  ifdef USE_THREADS
3926    #    define aTHXR  thr
3927    #    define aTHXR_ thr,
3928    #  else
3929    #    define aTHXR
3930    #    define aTHXR_
3931    #  endif
3932    #  define dTHXR  dTHR
3933    #else
3934    #  define aTHXR  aTHX
3935    #  define aTHXR_ aTHX_
3936    #  define dTHXR  dTHX
3937    #endif
3938    #ifndef dTHXoa
3939  #  define dTHXoa(x)                      dTHXa(x)  #  define dTHXoa(x)                      dTHXa(x)
3940  #endif  #endif
3941    #ifndef mPUSHs
3942    #  define mPUSHs(s)                      PUSHs(sv_2mortal(s))
3943    #endif
3944    
3945  #ifndef PUSHmortal  #ifndef PUSHmortal
3946  #  define PUSHmortal                     PUSHs(sv_newmortal())  #  define PUSHmortal                     PUSHs(sv_newmortal())
3947  #endif  #endif
3948    
3949  #ifndef mPUSHp  #ifndef mPUSHp
3950  #  define mPUSHp(p,l)                    sv_setpvn_mg(PUSHmortal, (p), (l))  #  define mPUSHp(p,l)                    sv_setpvn(PUSHmortal, (p), (l))
3951  #endif  #endif
3952    
3953  #ifndef mPUSHn  #ifndef mPUSHn
3954  #  define mPUSHn(n)                      sv_setnv_mg(PUSHmortal, (NV)(n))  #  define mPUSHn(n)                      sv_setnv(PUSHmortal, (NV)(n))
3955  #endif  #endif
3956    
3957  #ifndef mPUSHi  #ifndef mPUSHi
3958  #  define mPUSHi(i)                      sv_setiv_mg(PUSHmortal, (IV)(i))  #  define mPUSHi(i)                      sv_setiv(PUSHmortal, (IV)(i))
3959  #endif  #endif
3960    
3961  #ifndef mPUSHu  #ifndef mPUSHu
3962  #  define mPUSHu(u)                      sv_setuv_mg(PUSHmortal, (UV)(u))  #  define mPUSHu(u)                      sv_setuv(PUSHmortal, (UV)(u))
3963  #endif  #endif
3964    #ifndef mXPUSHs
3965    #  define mXPUSHs(s)                     XPUSHs(sv_2mortal(s))
3966    #endif
3967    
3968  #ifndef XPUSHmortal  #ifndef XPUSHmortal
3969  #  define XPUSHmortal                    XPUSHs(sv_newmortal())  #  define XPUSHmortal                    XPUSHs(sv_newmortal())
3970  #endif  #endif
3971    
3972  #ifndef mXPUSHp  #ifndef mXPUSHp
3973  #  define mXPUSHp(p,l)                   STMT_START { EXTEND(sp,1); sv_setpvn_mg(PUSHmortal, (p), (l)); } STMT_END  #  define mXPUSHp(p,l)                   STMT_START { EXTEND(sp,1); sv_setpvn(PUSHmortal, (p), (l)); } STMT_END
3974  #endif  #endif
3975    
3976  #ifndef mXPUSHn  #ifndef mXPUSHn
3977  #  define mXPUSHn(n)                     STMT_START { EXTEND(sp,1); sv_setnv_mg(PUSHmortal, (NV)(n)); } STMT_END  #  define mXPUSHn(n)                     STMT_START { EXTEND(sp,1); sv_setnv(PUSHmortal, (NV)(n)); } STMT_END
3978  #endif  #endif
3979    
3980  #ifndef mXPUSHi  #ifndef mXPUSHi
3981  #  define mXPUSHi(i)                     STMT_START { EXTEND(sp,1); sv_setiv_mg(PUSHmortal, (IV)(i)); } STMT_END  #  define mXPUSHi(i)                     STMT_START { EXTEND(sp,1); sv_setiv(PUSHmortal, (IV)(i)); } STMT_END
3982  #endif  #endif
3983    
3984  #ifndef mXPUSHu  #ifndef mXPUSHu
3985  #  define mXPUSHu(u)                     STMT_START { EXTEND(sp,1); sv_setuv_mg(PUSHmortal, (UV)(u)); } STMT_END  #  define mXPUSHu(u)                     STMT_START { EXTEND(sp,1); sv_setuv(PUSHmortal, (UV)(u)); } STMT_END
3986  #endif  #endif
3987    
3988  /* Replace: 1 */  /* Replace: 1 */
# Line 3377  typedef NVTYPE NV; Line 4004  typedef NVTYPE NV;
4004  #ifndef eval_sv  #ifndef eval_sv
4005  #  define eval_sv                        perl_eval_sv  #  define eval_sv                        perl_eval_sv
4006  #endif  #endif
4007    #ifndef PERL_LOADMOD_DENY
4008    #  define PERL_LOADMOD_DENY              0x1
4009    #endif
4010    
4011    #ifndef PERL_LOADMOD_NOIMPORT
4012    #  define PERL_LOADMOD_NOIMPORT          0x2
4013    #endif
4014    
4015    #ifndef PERL_LOADMOD_IMPORT_OPS
4016    #  define PERL_LOADMOD_IMPORT_OPS        0x4
4017    #endif
4018    
4019  /* Replace: 0 */  /* Replace: 0 */
4020    
4021  /* Replace perl_eval_pv with eval_pv */  /* Replace perl_eval_pv with eval_pv */
 /* eval_pv depends on eval_sv */  
4022    
4023  #ifndef eval_pv  #ifndef eval_pv
4024  #if defined(NEED_eval_pv)  #if defined(NEED_eval_pv)
# Line 3421  DPPP_(my_eval_pv)(char *p, I32 croak_on_ Line 4058  DPPP_(my_eval_pv)(char *p, I32 croak_on_
4058    
4059  #endif  #endif
4060  #endif  #endif
4061    
4062    #ifndef vload_module
4063    #if defined(NEED_vload_module)
4064    static void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args);
4065    static
4066    #else
4067    extern void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args);
4068    #endif
4069    
4070    #ifdef vload_module
4071    #  undef vload_module
4072    #endif
4073    #define vload_module(a,b,c,d) DPPP_(my_vload_module)(aTHX_ a,b,c,d)
4074    #define Perl_vload_module DPPP_(my_vload_module)
4075    
4076    #if defined(NEED_vload_module) || defined(NEED_vload_module_GLOBAL)
4077    
4078    void
4079    DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args)
4080    {
4081        dTHR;
4082        dVAR;
4083        OP *veop, *imop;
4084    
4085        OP * const modname = newSVOP(OP_CONST, 0, name);
4086        /* 5.005 has a somewhat hacky force_normal that doesn't croak on
4087           SvREADONLY() if PL_compling is true. Current perls take care in
4088           ck_require() to correctly turn off SvREADONLY before calling
4089           force_normal_flags(). This seems a better fix than fudging PL_compling
4090         */
4091        SvREADONLY_off(((SVOP*)modname)->op_sv);
4092        modname->op_private |= OPpCONST_BARE;
4093        if (ver) {
4094            veop = newSVOP(OP_CONST, 0, ver);
4095        }
4096        else
4097            veop = NULL;
4098        if (flags & PERL_LOADMOD_NOIMPORT) {
4099            imop = sawparens(newNULLLIST());
4100        }
4101        else if (flags & PERL_LOADMOD_IMPORT_OPS) {
4102            imop = va_arg(*args, OP*);
4103        }
4104        else {
4105            SV *sv;
4106            imop = NULL;
4107            sv = va_arg(*args, SV*);
4108            while (sv) {
4109                imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));
4110                sv = va_arg(*args, SV*);
4111            }
4112        }
4113        {
4114            const line_t ocopline = PL_copline;
4115            COP * const ocurcop = PL_curcop;
4116            const int oexpect = PL_expect;
4117    
4118    #if (PERL_BCDVERSION >= 0x5004000)
4119            utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0),
4120                    veop, modname, imop);
4121    #else
4122            utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(),
4123                    modname, imop);
4124    #endif
4125            PL_expect = oexpect;
4126            PL_copline = ocopline;
4127            PL_curcop = ocurcop;
4128        }
4129    }
4130    
4131    #endif
4132    #endif
4133    
4134    #ifndef load_module
4135    #if defined(NEED_load_module)
4136    static void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...);
4137    static
4138    #else
4139    extern void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...);
4140    #endif
4141    
4142    #ifdef load_module
4143    #  undef load_module
4144    #endif
4145    #define load_module DPPP_(my_load_module)
4146    #define Perl_load_module DPPP_(my_load_module)
4147    
4148    #if defined(NEED_load_module) || defined(NEED_load_module_GLOBAL)
4149    
4150    void
4151    DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...)
4152    {
4153        va_list args;
4154        va_start(args, ver);
4155        vload_module(flags, name, ver, &args);
4156        va_end(args);
4157    }
4158    
4159    #endif
4160    #endif
4161  #ifndef newRV_inc  #ifndef newRV_inc
4162  #  define newRV_inc(sv)                  newRV(sv)   /* Replace */  #  define newRV_inc(sv)                  newRV(sv)   /* Replace */
4163  #endif  #endif
# Line 3456  DPPP_(my_newRV_noinc)(SV *sv) Line 4193  DPPP_(my_newRV_noinc)(SV *sv)
4193   */   */
4194    
4195  /* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */  /* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */
4196  #if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION < 63))) && ((PERL_VERSION != 4) || (PERL_SUBVERSION != 5))  #if (PERL_BCDVERSION < 0x5004063) && (PERL_BCDVERSION != 0x5004005)
4197  #if defined(NEED_newCONSTSUB)  #if defined(NEED_newCONSTSUB)
4198  static void DPPP_(my_newCONSTSUB)(HV *stash, char *name, SV *sv);  static void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv);
4199  static  static
4200  #else  #else
4201  extern void DPPP_(my_newCONSTSUB)(HV *stash, char *name, SV *sv);  extern void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv);
4202  #endif  #endif
4203    
4204  #ifdef newCONSTSUB  #ifdef newCONSTSUB
# Line 3473  extern void DPPP_(my_newCONSTSUB)(HV *st Line 4210  extern void DPPP_(my_newCONSTSUB)(HV *st
4210  #if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL)  #if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL)
4211    
4212  void  void
4213  DPPP_(my_newCONSTSUB)(HV *stash, char *name, SV *sv)  DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv)
4214  {  {
4215          U32 oldhints = PL_hints;          U32 oldhints = PL_hints;
4216          HV *old_cop_stash = PL_curcop->cop_stash;          HV *old_cop_stash = PL_curcop->cop_stash;
# Line 3487  DPPP_(my_newCONSTSUB)(HV *stash, char *n Line 4224  DPPP_(my_newCONSTSUB)(HV *stash, char *n
4224    
4225          newSUB(          newSUB(
4226    
4227  #if   ((PERL_VERSION < 3) || ((PERL_VERSION == 3) && (PERL_SUBVERSION < 22)))  #if   (PERL_BCDVERSION < 0x5003022)
4228                  start_subparse(),                  start_subparse(),
4229  #elif ((PERL_VERSION == 3) && (PERL_SUBVERSION == 22))  #elif (PERL_BCDVERSION == 0x5003022)
4230                  start_subparse(0),                  start_subparse(0),
4231  #else  /* 5.003_23  onwards */  #else  /* 5.003_23  onwards */
4232                  start_subparse(FALSE, 0),                  start_subparse(FALSE, 0),
4233  #endif  #endif
4234    
4235                  newSVOP(OP_CONST, 0, newSVpv(name,0)),                  newSVOP(OP_CONST, 0, newSVpv((char *) name, 0)),
4236                  newSVOP(OP_CONST, 0, &PL_sv_no),   /* SvPV(&PL_sv_no) == "" -- GMB */                  newSVOP(OP_CONST, 0, &PL_sv_no),   /* SvPV(&PL_sv_no) == "" -- GMB */
4237                  newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))                  newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))
4238          );          );
# Line 3537  DPPP_(my_newCONSTSUB)(HV *stash, char *n Line 4274  DPPP_(my_newCONSTSUB)(HV *stash, char *n
4274   * case below uses it to declare the data as static. */   * case below uses it to declare the data as static. */
4275  #define START_MY_CXT  #define START_MY_CXT
4276    
4277  #if (PERL_VERSION < 4 || (PERL_VERSION == 4 && PERL_SUBVERSION < 68 ))  #if (PERL_BCDVERSION < 0x5004068)
4278  /* Fetches the SV that keeps the per-interpreter data. */  /* Fetches the SV that keeps the per-interpreter data. */
4279  #define dMY_CXT_SV \  #define dMY_CXT_SV \
4280          SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE)          SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE)
# Line 3632  DPPP_(my_newCONSTSUB)(HV *stash, char *n Line 4369  DPPP_(my_newCONSTSUB)(HV *stash, char *n
4369    
4370  #ifndef NVef  #ifndef NVef
4371  #  if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \  #  if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \
4372        defined(PERL_PRIfldbl) /* Not very likely, but let's try anyway. */        defined(PERL_PRIfldbl) && (PERL_BCDVERSION != 0x5006000)
4373                /* Not very likely, but let's try anyway. */
4374  #    define NVef          PERL_PRIeldbl  #    define NVef          PERL_PRIeldbl
4375  #    define NVff          PERL_PRIfldbl  #    define NVff          PERL_PRIfldbl
4376  #    define NVgf          PERL_PRIgldbl  #    define NVgf          PERL_PRIgldbl
# Line 3643  DPPP_(my_newCONSTSUB)(HV *stash, char *n Line 4381  DPPP_(my_newCONSTSUB)(HV *stash, char *n
4381  #  endif  #  endif
4382  #endif  #endif
4383    
4384  #ifndef SvPV_nolen  #ifndef SvREFCNT_inc
4385    #  ifdef PERL_USE_GCC_BRACE_GROUPS
4386    #    define SvREFCNT_inc(sv)            \
4387          ({                                \
4388              SV * const _sv = (SV*)(sv);   \
4389              if (_sv)                      \
4390                   (SvREFCNT(_sv))++;       \
4391              _sv;                          \
4392          })
4393    #  else
4394    #    define SvREFCNT_inc(sv)    \
4395              ((PL_Sv=(SV*)(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL)
4396    #  endif
4397    #endif
4398    
4399    #ifndef SvREFCNT_inc_simple
4400    #  ifdef PERL_USE_GCC_BRACE_GROUPS
4401    #    define SvREFCNT_inc_simple(sv)     \
4402          ({                                        \
4403              if (sv)                               \
4404                   (SvREFCNT(sv))++;                \
4405              (SV *)(sv);                           \
4406          })
4407    #  else
4408    #    define SvREFCNT_inc_simple(sv) \
4409              ((sv) ? (SvREFCNT(sv)++,(SV*)(sv)) : NULL)
4410    #  endif
4411    #endif
4412    
4413    #ifndef SvREFCNT_inc_NN
4414    #  ifdef PERL_USE_GCC_BRACE_GROUPS
4415    #    define SvREFCNT_inc_NN(sv)         \
4416          ({                                        \
4417              SV * const _sv = (SV*)(sv);   \
4418              SvREFCNT(_sv)++;              \
4419              _sv;                          \
4420          })
4421    #  else
4422    #    define SvREFCNT_inc_NN(sv) \
4423              (PL_Sv=(SV*)(sv),++(SvREFCNT(PL_Sv)),PL_Sv)
4424    #  endif
4425    #endif
4426    
4427    #ifndef SvREFCNT_inc_void
4428    #  ifdef PERL_USE_GCC_BRACE_GROUPS
4429    #    define SvREFCNT_inc_void(sv)               \
4430          ({                                        \
4431              SV * const _sv = (SV*)(sv);   \
4432              if (_sv)                      \
4433                  (void)(SvREFCNT(_sv)++);  \
4434          })
4435    #  else
4436    #    define SvREFCNT_inc_void(sv) \
4437              (void)((PL_Sv=(SV*)(sv)) ? ++(SvREFCNT(PL_Sv)) : 0)
4438    #  endif
4439    #endif
4440    #ifndef SvREFCNT_inc_simple_void
4441    #  define SvREFCNT_inc_simple_void(sv)   STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END
4442    #endif
4443    
4444    #ifndef SvREFCNT_inc_simple_NN
4445    #  define SvREFCNT_inc_simple_NN(sv)     (++SvREFCNT(sv), (SV*)(sv))
4446    #endif
4447    
4448    #ifndef SvREFCNT_inc_void_NN
4449    #  define SvREFCNT_inc_void_NN(sv)       (void)(++SvREFCNT((SV*)(sv)))
4450    #endif
4451    
4452    #ifndef SvREFCNT_inc_simple_void_NN
4453    #  define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv)))
4454    #endif
4455    #ifndef newSVpvn
4456    #  define newSVpvn(data,len)             ((data)                                              \
4457                                        ? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \
4458                                        : newSV(0))
4459    #endif
4460    #ifndef newSVpvn_utf8
4461    #  define newSVpvn_utf8(s, len, u)       newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0)
4462    #endif
4463    #ifndef SVf_UTF8
4464    #  define SVf_UTF8                       0
4465    #endif
4466    
4467    #ifndef newSVpvn_flags
4468    
4469  #if defined(NEED_sv_2pv_nolen)  #if defined(NEED_newSVpvn_flags)
4470  static char * DPPP_(my_sv_2pv_nolen)(pTHX_ register SV *sv);  static SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char * s, STRLEN len, U32 flags);
4471  static  static
4472  #else  #else
4473  extern char * DPPP_(my_sv_2pv_nolen)(pTHX_ register SV *sv);  extern SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char * s, STRLEN len, U32 flags);
4474  #endif  #endif
4475    
4476  #ifdef sv_2pv_nolen  #ifdef newSVpvn_flags
4477  #  undef sv_2pv_nolen  #  undef newSVpvn_flags
4478  #endif  #endif
4479  #define sv_2pv_nolen(a) DPPP_(my_sv_2pv_nolen)(aTHX_ a)  #define newSVpvn_flags(a,b,c) DPPP_(my_newSVpvn_flags)(aTHX_ a,b,c)
4480  #define Perl_sv_2pv_nolen DPPP_(my_sv_2pv_nolen)  #define Perl_newSVpvn_flags DPPP_(my_newSVpvn_flags)
4481    
4482  #if defined(NEED_sv_2pv_nolen) || defined(NEED_sv_2pv_nolen_GLOBAL)  #if defined(NEED_newSVpvn_flags) || defined(NEED_newSVpvn_flags_GLOBAL)
4483    
4484  char *  SV *
4485  DPPP_(my_sv_2pv_nolen)(pTHX_ register SV *sv)  DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags)
4486  {  {
4487    STRLEN n_a;    SV *sv = newSVpvn(s, len);
4488    return sv_2pv(sv, &n_a);    SvFLAGS(sv) |= (flags & SVf_UTF8);
4489      return (flags & SVs_TEMP) ? sv_2mortal(sv) : sv;
4490  }  }
4491    
4492  #endif  #endif
4493    
4494  /* Hint: sv_2pv_nolen  #endif
  * Use the SvPV_nolen() macro instead of sv_2pv_nolen().  
  */  
4495    
4496  /* SvPV_nolen depends on sv_2pv_nolen */  /* Backwards compatibility stuff... :-( */
4497  #define SvPV_nolen(sv) \  #if !defined(NEED_sv_2pv_flags) && defined(NEED_sv_2pv_nolen)
4498            ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \  #  define NEED_sv_2pv_flags
4499             ? SvPVX(sv) : sv_2pv_nolen(sv))  #endif
4500    #if !defined(NEED_sv_2pv_flags_GLOBAL) && defined(NEED_sv_2pv_nolen_GLOBAL)
4501    #  define NEED_sv_2pv_flags_GLOBAL
4502    #endif
4503    
4504    /* Hint: sv_2pv_nolen
4505     * Use the SvPV_nolen() or SvPV_nolen_const() macros instead of sv_2pv_nolen().
4506     */
4507    #ifndef sv_2pv_nolen
4508    #  define sv_2pv_nolen(sv)               SvPV_nolen(sv)
4509  #endif  #endif
4510    
4511  #ifdef SvPVbyte  #ifdef SvPVbyte
# Line 3687  DPPP_(my_sv_2pv_nolen)(pTHX_ register SV Line 4515  DPPP_(my_sv_2pv_nolen)(pTHX_ register SV
4515   * borrowed from perl-5.7.3.   * borrowed from perl-5.7.3.
4516   */   */
4517    
4518  #if ((PERL_VERSION < 7) || ((PERL_VERSION == 7) && (PERL_SUBVERSION < 0)))  #if (PERL_BCDVERSION < 0x5007000)
4519    
4520  #if defined(NEED_sv_2pvbyte)  #if defined(NEED_sv_2pvbyte)
4521  static char * DPPP_(my_sv_2pvbyte)(pTHX_ register SV *sv, STRLEN *lp);  static char * DPPP_(my_sv_2pvbyte)(pTHX_ SV * sv, STRLEN * lp);
4522  static  static
4523  #else  #else
4524  extern char * DPPP_(my_sv_2pvbyte)(pTHX_ register SV *sv, STRLEN *lp);  extern char * DPPP_(my_sv_2pvbyte)(pTHX_ SV * sv, STRLEN * lp);
4525  #endif  #endif
4526    
4527  #ifdef sv_2pvbyte  #ifdef sv_2pvbyte
# Line 3705  extern char * DPPP_(my_sv_2pvbyte)(pTHX_ Line 4533  extern char * DPPP_(my_sv_2pvbyte)(pTHX_
4533  #if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_GLOBAL)  #if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_GLOBAL)
4534    
4535  char *  char *
4536  DPPP_(my_sv_2pvbyte)(pTHX_ register SV *sv, STRLEN *lp)  DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp)
4537  {  {
4538    sv_utf8_downgrade(sv,0);    sv_utf8_downgrade(sv,0);
4539    return SvPV(sv,*lp);    return SvPV(sv,*lp);
# Line 3719  DPPP_(my_sv_2pvbyte)(pTHX_ register SV * Line 4547  DPPP_(my_sv_2pvbyte)(pTHX_ register SV *
4547    
4548  #undef SvPVbyte  #undef SvPVbyte
4549    
 /* SvPVbyte depends on sv_2pvbyte */  
4550  #define SvPVbyte(sv, lp)                                                \  #define SvPVbyte(sv, lp)                                                \
4551          ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK)                \          ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK)                \
4552           ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp))           ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp))
# Line 3732  DPPP_(my_sv_2pvbyte)(pTHX_ register SV * Line 4559  DPPP_(my_sv_2pvbyte)(pTHX_ register SV *
4559  #  define sv_2pvbyte        sv_2pv  #  define sv_2pvbyte        sv_2pv
4560    
4561  #endif  #endif
   
 /* sv_2pvbyte_nolen depends on sv_2pv_nolen */  
4562  #ifndef sv_2pvbyte_nolen  #ifndef sv_2pvbyte_nolen
4563  #  define sv_2pvbyte_nolen               sv_2pv_nolen  #  define sv_2pvbyte_nolen(sv)           sv_2pv_nolen(sv)
4564  #endif  #endif
4565    
4566  /* Hint: sv_pvn  /* Hint: sv_pvn
4567   * Always use the SvPV() macro instead of sv_pvn().   * Always use the SvPV() macro instead of sv_pvn().
4568   */   */
 #ifndef sv_pvn  
 #  define sv_pvn(sv, len)                SvPV(sv, len)  
 #endif  
4569    
4570  /* Hint: sv_pvn_force  /* Hint: sv_pvn_force
4571   * Always use the SvPV_force() macro instead of sv_pvn_force().   * Always use the SvPV_force() macro instead of sv_pvn_force().
4572   */   */
4573  #ifndef sv_pvn_force  
4574  #  define sv_pvn_force(sv, len)          SvPV_force(sv, len)  /* If these are undefined, they're not handled by the core anyway */
4575    #ifndef SV_IMMEDIATE_UNREF
4576    #  define SV_IMMEDIATE_UNREF             0
4577    #endif
4578    
4579    #ifndef SV_GMAGIC
4580    #  define SV_GMAGIC                      0
4581    #endif
4582    
4583    #ifndef SV_COW_DROP_PV
4584    #  define SV_COW_DROP_PV                 0
4585    #endif
4586    
4587    #ifndef SV_UTF8_NO_ENCODING
4588    #  define SV_UTF8_NO_ENCODING            0
4589    #endif
4590    
4591    #ifndef SV_NOSTEAL
4592    #  define SV_NOSTEAL                     0
4593    #endif
4594    
4595    #ifndef SV_CONST_RETURN
4596    #  define SV_CONST_RETURN                0
4597    #endif
4598    
4599    #ifndef SV_MUTABLE_RETURN
4600    #  define SV_MUTABLE_RETURN              0
4601    #endif
4602    
4603    #ifndef SV_SMAGIC
4604    #  define SV_SMAGIC                      0
4605    #endif
4606    
4607    #ifndef SV_HAS_TRAILING_NUL
4608    #  define SV_HAS_TRAILING_NUL            0
4609    #endif
4610    
4611    #ifndef SV_COW_SHARED_HASH_KEYS
4612    #  define SV_COW_SHARED_HASH_KEYS        0
4613    #endif
4614    
4615    #if (PERL_BCDVERSION < 0x5007002)
4616    
4617    #if defined(NEED_sv_2pv_flags)
4618    static char * DPPP_(my_sv_2pv_flags)(pTHX_ SV * sv, STRLEN * lp, I32 flags);
4619    static
4620    #else
4621    extern char * DPPP_(my_sv_2pv_flags)(pTHX_ SV * sv, STRLEN * lp, I32 flags);
4622    #endif
4623    
4624    #ifdef sv_2pv_flags
4625    #  undef sv_2pv_flags
4626    #endif
4627    #define sv_2pv_flags(a,b,c) DPPP_(my_sv_2pv_flags)(aTHX_ a,b,c)
4628    #define Perl_sv_2pv_flags DPPP_(my_sv_2pv_flags)
4629    
4630    #if defined(NEED_sv_2pv_flags) || defined(NEED_sv_2pv_flags_GLOBAL)
4631    
4632    char *
4633    DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags)
4634    {
4635      STRLEN n_a = (STRLEN) flags;
4636      return sv_2pv(sv, lp ? lp : &n_a);
4637    }
4638    
4639    #endif
4640    
4641    #if defined(NEED_sv_pvn_force_flags)
4642    static char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV * sv, STRLEN * lp, I32 flags);
4643    static
4644    #else
4645    extern char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV * sv, STRLEN * lp, I32 flags);
4646    #endif
4647    
4648    #ifdef sv_pvn_force_flags
4649    #  undef sv_pvn_force_flags
4650    #endif
4651    #define sv_pvn_force_flags(a,b,c) DPPP_(my_sv_pvn_force_flags)(aTHX_ a,b,c)
4652    #define Perl_sv_pvn_force_flags DPPP_(my_sv_pvn_force_flags)
4653    
4654    #if defined(NEED_sv_pvn_force_flags) || defined(NEED_sv_pvn_force_flags_GLOBAL)
4655    
4656    char *
4657    DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags)
4658    {
4659      STRLEN n_a = (STRLEN) flags;
4660      return sv_pvn_force(sv, lp ? lp : &n_a);
4661    }
4662    
4663    #endif
4664    
4665    #endif
4666    
4667    #if (PERL_BCDVERSION < 0x5008008) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009003) )
4668    # define DPPP_SVPV_NOLEN_LP_ARG &PL_na
4669    #else
4670    # define DPPP_SVPV_NOLEN_LP_ARG 0
4671    #endif
4672    #ifndef SvPV_const
4673    #  define SvPV_const(sv, lp)             SvPV_flags_const(sv, lp, SV_GMAGIC)
4674    #endif
4675    
4676    #ifndef SvPV_mutable
4677    #  define SvPV_mutable(sv, lp)           SvPV_flags_mutable(sv, lp, SV_GMAGIC)
4678    #endif
4679    #ifndef SvPV_flags
4680    #  define SvPV_flags(sv, lp, flags)      \
4681                     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
4682                      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags))
4683    #endif
4684    #ifndef SvPV_flags_const
4685    #  define SvPV_flags_const(sv, lp, flags) \
4686                     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
4687                      ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \
4688                      (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN))
4689    #endif
4690    #ifndef SvPV_flags_const_nolen
4691    #  define SvPV_flags_const_nolen(sv, flags) \
4692                     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
4693                      ? SvPVX_const(sv) : \
4694                      (const char*) sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags|SV_CONST_RETURN))
4695    #endif
4696    #ifndef SvPV_flags_mutable
4697    #  define SvPV_flags_mutable(sv, lp, flags) \
4698                     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
4699                      ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \
4700                      sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
4701    #endif
4702    #ifndef SvPV_force
4703    #  define SvPV_force(sv, lp)             SvPV_force_flags(sv, lp, SV_GMAGIC)
4704    #endif
4705    
4706    #ifndef SvPV_force_nolen
4707    #  define SvPV_force_nolen(sv)           SvPV_force_flags_nolen(sv, SV_GMAGIC)
4708    #endif
4709    
4710    #ifndef SvPV_force_mutable
4711    #  define SvPV_force_mutable(sv, lp)     SvPV_force_flags_mutable(sv, lp, SV_GMAGIC)
4712    #endif
4713    
4714    #ifndef SvPV_force_nomg
4715    #  define SvPV_force_nomg(sv, lp)        SvPV_force_flags(sv, lp, 0)
4716    #endif
4717    
4718    #ifndef SvPV_force_nomg_nolen
4719    #  define SvPV_force_nomg_nolen(sv)      SvPV_force_flags_nolen(sv, 0)
4720    #endif
4721    #ifndef SvPV_force_flags
4722    #  define SvPV_force_flags(sv, lp, flags) \
4723                     ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
4724                     ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags))
4725    #endif
4726    #ifndef SvPV_force_flags_nolen
4727    #  define SvPV_force_flags_nolen(sv, flags) \
4728                     ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
4729                     ? SvPVX(sv) : sv_pvn_force_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags))
4730    #endif
4731    #ifndef SvPV_force_flags_mutable
4732    #  define SvPV_force_flags_mutable(sv, lp, flags) \
4733                     ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
4734                     ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \
4735                      : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
4736    #endif
4737    #ifndef SvPV_nolen
4738    #  define SvPV_nolen(sv)                 \
4739                     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
4740                      ? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC))
4741    #endif
4742    #ifndef SvPV_nolen_const
4743    #  define SvPV_nolen_const(sv)           \
4744                     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
4745                      ? SvPVX_const(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC|SV_CONST_RETURN))
4746    #endif
4747    #ifndef SvPV_nomg
4748    #  define SvPV_nomg(sv, lp)              SvPV_flags(sv, lp, 0)
4749    #endif
4750    
4751    #ifndef SvPV_nomg_const
4752    #  define SvPV_nomg_const(sv, lp)        SvPV_flags_const(sv, lp, 0)
4753    #endif
4754    
4755    #ifndef SvPV_nomg_const_nolen
4756    #  define SvPV_nomg_const_nolen(sv)      SvPV_flags_const_nolen(sv, 0)
4757    #endif
4758    #ifndef SvMAGIC_set
4759    #  define SvMAGIC_set(sv, val)           \
4760                    STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
4761                    (((XPVMG*) SvANY(sv))->xmg_magic = (val)); } STMT_END
4762    #endif
4763    
4764    #if (PERL_BCDVERSION < 0x5009003)
4765    #ifndef SvPVX_const
4766    #  define SvPVX_const(sv)                ((const char*) (0 + SvPVX(sv)))
4767    #endif
4768    
4769    #ifndef SvPVX_mutable
4770    #  define SvPVX_mutable(sv)              (0 + SvPVX(sv))
4771    #endif
4772    #ifndef SvRV_set
4773    #  define SvRV_set(sv, val)              \
4774                    STMT_START { assert(SvTYPE(sv) >=  SVt_RV); \
4775                    (((XRV*) SvANY(sv))->xrv_rv = (val)); } STMT_END
4776    #endif
4777    
4778    #else
4779    #ifndef SvPVX_const
4780    #  define SvPVX_const(sv)                ((const char*)((sv)->sv_u.svu_pv))
4781    #endif
4782    
4783    #ifndef SvPVX_mutable
4784    #  define SvPVX_mutable(sv)              ((sv)->sv_u.svu_pv)
4785    #endif
4786    #ifndef SvRV_set
4787    #  define SvRV_set(sv, val)              \
4788                    STMT_START { assert(SvTYPE(sv) >=  SVt_RV); \
4789                    ((sv)->sv_u.svu_rv = (val)); } STMT_END
4790  #endif  #endif
4791    
4792  #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(vnewSVpvf)  #endif
4793    #ifndef SvSTASH_set
4794    #  define SvSTASH_set(sv, val)           \
4795                    STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
4796                    (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END
4797    #endif
4798    
4799    #if (PERL_BCDVERSION < 0x5004000)
4800    #ifndef SvUV_set
4801    #  define SvUV_set(sv, val)              \
4802                    STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
4803                    (((XPVIV*) SvANY(sv))->xiv_iv = (IV) (val)); } STMT_END
4804    #endif
4805    
4806    #else
4807    #ifndef SvUV_set
4808    #  define SvUV_set(sv, val)              \
4809                    STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
4810                    (((XPVUV*) SvANY(sv))->xuv_uv = (val)); } STMT_END
4811    #endif
4812    
4813    #endif
4814    
4815    #if (PERL_BCDVERSION >= 0x5004000) && !defined(vnewSVpvf)
4816  #if defined(NEED_vnewSVpvf)  #if defined(NEED_vnewSVpvf)
4817  static SV * DPPP_(my_vnewSVpvf)(pTHX_ const char * pat, va_list * args);  static SV * DPPP_(my_vnewSVpvf)(pTHX_ const char * pat, va_list * args);
4818  static  static
# Line 3779  DPPP_(my_vnewSVpvf)(pTHX_ const char *pa Line 4839  DPPP_(my_vnewSVpvf)(pTHX_ const char *pa
4839  #endif  #endif
4840  #endif  #endif
4841    
4842  /* sv_vcatpvf depends on sv_vcatpvfn */  #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf)
 #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_vcatpvf)  
4843  #  define sv_vcatpvf(sv, pat, args)  sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))  #  define sv_vcatpvf(sv, pat, args)  sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
4844  #endif  #endif
4845    
4846  /* sv_vsetpvf depends on sv_vsetpvfn */  #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf)
 #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_vsetpvf)  
4847  #  define sv_vsetpvf(sv, pat, args)  sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))  #  define sv_vsetpvf(sv, pat, args)  sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
4848  #endif  #endif
4849    
4850  /* sv_catpvf_mg depends on sv_vcatpvfn, sv_catpvf_mg_nocontext */  #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg)
 #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_catpvf_mg)  
4851  #if defined(NEED_sv_catpvf_mg)  #if defined(NEED_sv_catpvf_mg)
4852  static void DPPP_(my_sv_catpvf_mg)(pTHX_ SV * sv, const char * pat, ...);  static void DPPP_(my_sv_catpvf_mg)(pTHX_ SV * sv, const char * pat, ...);
4853  static  static
# Line 3815  DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, con Line 4872  DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, con
4872  #endif  #endif
4873  #endif  #endif
4874    
 /* sv_catpvf_mg_nocontext depends on sv_vcatpvfn */  
4875  #ifdef PERL_IMPLICIT_CONTEXT  #ifdef PERL_IMPLICIT_CONTEXT
4876  #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_catpvf_mg_nocontext)  #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg_nocontext)
4877  #if defined(NEED_sv_catpvf_mg_nocontext)  #if defined(NEED_sv_catpvf_mg_nocontext)
4878  static void DPPP_(my_sv_catpvf_mg_nocontext)(SV * sv, const char * pat, ...);  static void DPPP_(my_sv_catpvf_mg_nocontext)(SV * sv, const char * pat, ...);
4879  static  static
# Line 3845  DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, Line 4901  DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv,
4901  #endif  #endif
4902  #endif  #endif
4903    
4904    /* sv_catpvf_mg depends on sv_catpvf_mg_nocontext */
4905  #ifndef sv_catpvf_mg  #ifndef sv_catpvf_mg
4906  #  ifdef PERL_IMPLICIT_CONTEXT  #  ifdef PERL_IMPLICIT_CONTEXT
4907  #    define sv_catpvf_mg   Perl_sv_catpvf_mg_nocontext  #    define sv_catpvf_mg   Perl_sv_catpvf_mg_nocontext
# Line 3853  DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, Line 4910  DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv,
4910  #  endif  #  endif
4911  #endif  #endif
4912    
4913  /* sv_vcatpvf_mg depends on sv_vcatpvfn */  #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf_mg)
 #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_vcatpvf_mg)  
4914  #  define sv_vcatpvf_mg(sv, pat, args)                                     \  #  define sv_vcatpvf_mg(sv, pat, args)                                     \
4915     STMT_START {                                                            \     STMT_START {                                                            \
4916       sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));  \       sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));  \
# Line 3862  DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, Line 4918  DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv,
4918     } STMT_END     } STMT_END
4919  #endif  #endif
4920    
4921  /* sv_setpvf_mg depends on sv_vsetpvfn, sv_setpvf_mg_nocontext */  #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg)
 #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_setpvf_mg)  
4922  #if defined(NEED_sv_setpvf_mg)  #if defined(NEED_sv_setpvf_mg)
4923  static void DPPP_(my_sv_setpvf_mg)(pTHX_ SV * sv, const char * pat, ...);  static void DPPP_(my_sv_setpvf_mg)(pTHX_ SV * sv, const char * pat, ...);
4924  static  static
# Line 3888  DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, con Line 4943  DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, con
4943  #endif  #endif
4944  #endif  #endif
4945    
 /* sv_setpvf_mg_nocontext depends on sv_vsetpvfn */  
4946  #ifdef PERL_IMPLICIT_CONTEXT  #ifdef PERL_IMPLICIT_CONTEXT
4947  #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_setpvf_mg_nocontext)  #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg_nocontext)
4948  #if defined(NEED_sv_setpvf_mg_nocontext)  #if defined(NEED_sv_setpvf_mg_nocontext)
4949  static void DPPP_(my_sv_setpvf_mg_nocontext)(SV * sv, const char * pat, ...);  static void DPPP_(my_sv_setpvf_mg_nocontext)(SV * sv, const char * pat, ...);
4950  static  static
# Line 3918  DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, Line 4972  DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv,
4972  #endif  #endif
4973  #endif  #endif
4974    
4975    /* sv_setpvf_mg depends on sv_setpvf_mg_nocontext */
4976  #ifndef sv_setpvf_mg  #ifndef sv_setpvf_mg
4977  #  ifdef PERL_IMPLICIT_CONTEXT  #  ifdef PERL_IMPLICIT_CONTEXT
4978  #    define sv_setpvf_mg   Perl_sv_setpvf_mg_nocontext  #    define sv_setpvf_mg   Perl_sv_setpvf_mg_nocontext
# Line 3926  DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, Line 4981  DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv,
4981  #  endif  #  endif
4982  #endif  #endif
4983    
4984  /* sv_vsetpvf_mg depends on sv_vsetpvfn */  #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf_mg)
 #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_vsetpvf_mg)  
4985  #  define sv_vsetpvf_mg(sv, pat, args)                                     \  #  define sv_vsetpvf_mg(sv, pat, args)                                     \
4986     STMT_START {                                                            \     STMT_START {                                                            \
4987       sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));  \       sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));  \
4988       SvSETMAGIC(sv);                                                       \       SvSETMAGIC(sv);                                                       \
4989     } STMT_END     } STMT_END
4990  #endif  #endif
4991    
4992    #ifndef newSVpvn_share
4993    
4994    #if defined(NEED_newSVpvn_share)
4995    static SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash);
4996    static
4997    #else
4998    extern SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash);
4999    #endif
5000    
5001    #ifdef newSVpvn_share
5002    #  undef newSVpvn_share
5003    #endif
5004    #define newSVpvn_share(a,b,c) DPPP_(my_newSVpvn_share)(aTHX_ a,b,c)
5005    #define Perl_newSVpvn_share DPPP_(my_newSVpvn_share)
5006    
5007    #if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL)
5008    
5009    SV *
5010    DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash)
5011    {
5012      SV *sv;
5013      if (len < 0)
5014        len = -len;
5015      if (!hash)
5016        PERL_HASH(hash, (char*) src, len);
5017      sv = newSVpvn((char *) src, len);
5018      sv_upgrade(sv, SVt_PVIV);
5019      SvIVX(sv) = hash;
5020      SvREADONLY_on(sv);
5021      SvPOK_on(sv);
5022      return sv;
5023    }
5024    
5025    #endif
5026    
5027    #endif
5028    #ifndef SvSHARED_HASH
5029    #  define SvSHARED_HASH(sv)              (0 + SvUVX(sv))
5030    #endif
5031    #ifndef WARN_ALL
5032    #  define WARN_ALL                       0
5033    #endif
5034    
5035    #ifndef WARN_CLOSURE
5036    #  define WARN_CLOSURE                   1
5037    #endif
5038    
5039    #ifndef WARN_DEPRECATED
5040    #  define WARN_DEPRECATED                2
5041    #endif
5042    
5043    #ifndef WARN_EXITING
5044    #  define WARN_EXITING                   3
5045    #endif
5046    
5047    #ifndef WARN_GLOB
5048    #  define WARN_GLOB                      4
5049    #endif
5050    
5051    #ifndef WARN_IO
5052    #  define WARN_IO                        5
5053    #endif
5054    
5055    #ifndef WARN_CLOSED
5056    #  define WARN_CLOSED                    6
5057    #endif
5058    
5059    #ifndef WARN_EXEC
5060    #  define WARN_EXEC                      7
5061    #endif
5062    
5063    #ifndef WARN_LAYER
5064    #  define WARN_LAYER                     8
5065    #endif
5066    
5067    #ifndef WARN_NEWLINE
5068    #  define WARN_NEWLINE                   9
5069    #endif
5070    
5071    #ifndef WARN_PIPE
5072    #  define WARN_PIPE                      10
5073    #endif
5074    
5075    #ifndef WARN_UNOPENED
5076    #  define WARN_UNOPENED                  11
5077    #endif
5078    
5079    #ifndef WARN_MISC
5080    #  define WARN_MISC                      12
5081    #endif
5082    
5083    #ifndef WARN_NUMERIC
5084    #  define WARN_NUMERIC                   13
5085    #endif
5086    
5087    #ifndef WARN_ONCE
5088    #  define WARN_ONCE                      14
5089    #endif
5090    
5091    #ifndef WARN_OVERFLOW
5092    #  define WARN_OVERFLOW                  15
5093    #endif
5094    
5095    #ifndef WARN_PACK
5096    #  define WARN_PACK                      16
5097    #endif
5098    
5099    #ifndef WARN_PORTABLE
5100    #  define WARN_PORTABLE                  17
5101    #endif
5102    
5103    #ifndef WARN_RECURSION
5104    #  define WARN_RECURSION                 18
5105    #endif
5106    
5107    #ifndef WARN_REDEFINE
5108    #  define WARN_REDEFINE                  19
5109    #endif
5110    
5111    #ifndef WARN_REGEXP
5112    #  define WARN_REGEXP                    20
5113    #endif
5114    
5115    #ifndef WARN_SEVERE
5116    #  define WARN_SEVERE                    21
5117    #endif
5118    
5119    #ifndef WARN_DEBUGGING
5120    #  define WARN_DEBUGGING                 22
5121    #endif
5122    
5123    #ifndef WARN_INPLACE
5124    #  define WARN_INPLACE                   23
5125    #endif
5126    
5127    #ifndef WARN_INTERNAL
5128    #  define WARN_INTERNAL                  24
5129    #endif
5130    
5131    #ifndef WARN_MALLOC
5132    #  define WARN_MALLOC                    25
5133    #endif
5134    
5135    #ifndef WARN_SIGNAL
5136    #  define WARN_SIGNAL                    26
5137    #endif
5138    
5139    #ifndef WARN_SUBSTR
5140    #  define WARN_SUBSTR                    27
5141    #endif
5142    
5143    #ifndef WARN_SYNTAX
5144    #  define WARN_SYNTAX                    28
5145    #endif
5146    
5147    #ifndef WARN_AMBIGUOUS
5148    #  define WARN_AMBIGUOUS                 29
5149    #endif
5150    
5151    #ifndef WARN_BAREWORD
5152    #  define WARN_BAREWORD                  30
5153    #endif
5154    
5155    #ifndef WARN_DIGIT
5156    #  define WARN_DIGIT                     31
5157    #endif
5158    
5159    #ifndef WARN_PARENTHESIS
5160    #  define WARN_PARENTHESIS               32
5161    #endif
5162    
5163    #ifndef WARN_PRECEDENCE
5164    #  define WARN_PRECEDENCE                33
5165    #endif
5166    
5167    #ifndef WARN_PRINTF
5168    #  define WARN_PRINTF                    34
5169    #endif
5170    
5171    #ifndef WARN_PROTOTYPE
5172    #  define WARN_PROTOTYPE                 35
5173    #endif
5174    
5175    #ifndef WARN_QW
5176    #  define WARN_QW                        36
5177    #endif
5178    
5179    #ifndef WARN_RESERVED
5180    #  define WARN_RESERVED                  37
5181    #endif
5182    
5183    #ifndef WARN_SEMICOLON
5184    #  define WARN_SEMICOLON                 38
5185    #endif
5186    
5187    #ifndef WARN_TAINT
5188    #  define WARN_TAINT                     39
5189    #endif
5190    
5191    #ifndef WARN_THREADS
5192    #  define WARN_THREADS                   40
5193    #endif
5194    
5195    #ifndef WARN_UNINITIALIZED
5196    #  define WARN_UNINITIALIZED             41
5197    #endif
5198    
5199    #ifndef WARN_UNPACK
5200    #  define WARN_UNPACK                    42
5201    #endif
5202    
5203    #ifndef WARN_UNTIE
5204    #  define WARN_UNTIE                     43
5205    #endif
5206    
5207    #ifndef WARN_UTF8
5208    #  define WARN_UTF8                      44
5209    #endif
5210    
5211    #ifndef WARN_VOID
5212    #  define WARN_VOID                      45
5213    #endif
5214    
5215    #ifndef WARN_ASSERTIONS
5216    #  define WARN_ASSERTIONS                46
5217    #endif
5218    #ifndef packWARN
5219    #  define packWARN(a)                    (a)
5220    #endif
5221    
5222    #ifndef ckWARN
5223    #  ifdef G_WARN_ON
5224    #    define  ckWARN(a)                  (PL_dowarn & G_WARN_ON)
5225    #  else
5226    #    define  ckWARN(a)                  PL_dowarn
5227    #  endif
5228    #endif
5229    
5230    #if (PERL_BCDVERSION >= 0x5004000) && !defined(warner)
5231    #if defined(NEED_warner)
5232    static void DPPP_(my_warner)(U32 err, const char *pat, ...);
5233    static
5234    #else
5235    extern void DPPP_(my_warner)(U32 err, const char *pat, ...);
5236    #endif
5237    
5238    #define Perl_warner DPPP_(my_warner)
5239    
5240    #if defined(NEED_warner) || defined(NEED_warner_GLOBAL)
5241    
5242    void
5243    DPPP_(my_warner)(U32 err, const char *pat, ...)
5244    {
5245      SV *sv;
5246      va_list args;
5247    
5248      PERL_UNUSED_ARG(err);
5249    
5250      va_start(args, pat);
5251      sv = vnewSVpvf(pat, &args);
5252      va_end(args);
5253      sv_2mortal(sv);
5254      warn("%s", SvPV_nolen(sv));
5255    }
5256    
5257    #define warner  Perl_warner
5258    
5259    #define Perl_warner_nocontext  Perl_warner
5260    
5261    #endif
5262    #endif
5263    
5264    /* concatenating with "" ensures that only literal strings are accepted as argument
5265     * note that STR_WITH_LEN() can't be used as argument to macros or functions that
5266     * under some configurations might be macros
5267     */
5268    #ifndef STR_WITH_LEN
5269    #  define STR_WITH_LEN(s)                (s ""), (sizeof(s)-1)
5270    #endif
5271    #ifndef newSVpvs
5272    #  define newSVpvs(str)                  newSVpvn(str "", sizeof(str) - 1)
5273    #endif
5274    
5275    #ifndef newSVpvs_flags
5276    #  define newSVpvs_flags(str, flags)     newSVpvn_flags(str "", sizeof(str) - 1, flags)
5277    #endif
5278    
5279    #ifndef sv_catpvs
5280    #  define sv_catpvs(sv, str)             sv_catpvn(sv, str "", sizeof(str) - 1)
5281    #endif
5282    
5283    #ifndef sv_setpvs
5284    #  define sv_setpvs(sv, str)             sv_setpvn(sv, str "", sizeof(str) - 1)
5285    #endif
5286    
5287    #ifndef hv_fetchs
5288    #  define hv_fetchs(hv, key, lval)       hv_fetch(hv, key "", sizeof(key) - 1, lval)
5289    #endif
5290    
5291    #ifndef hv_stores
5292    #  define hv_stores(hv, key, val)        hv_store(hv, key "", sizeof(key) - 1, val, 0)
5293    #endif
5294  #ifndef SvGETMAGIC  #ifndef SvGETMAGIC
5295  #  define SvGETMAGIC(x)                  STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END  #  define SvGETMAGIC(x)                  STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
5296  #endif  #endif
# Line 4094  DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, Line 5451  DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv,
5451  #endif  #endif
5452    
5453  /* That's the best we can do... */  /* That's the best we can do... */
 #ifndef SvPV_force_nomg  
 #  define SvPV_force_nomg                SvPV_force  
 #endif  
   
 #ifndef SvPV_nomg  
 #  define SvPV_nomg                      SvPV  
 #endif  
   
5454  #ifndef sv_catpvn_nomg  #ifndef sv_catpvn_nomg
5455  #  define sv_catpvn_nomg                 sv_catpvn  #  define sv_catpvn_nomg                 sv_catpvn
5456  #endif  #endif
# Line 4215  DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, Line 5564  DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv,
5564       SvSETMAGIC(TeMpSv);                \       SvSETMAGIC(TeMpSv);                \
5565     } STMT_END     } STMT_END
5566  #endif  #endif
5567    #ifndef SvVSTRING_mg
5568    #  define SvVSTRING_mg(sv)               (SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_vstring) : NULL)
5569    #endif
5570    
5571    /* Hint: sv_magic_portable
5572     * This is a compatibility function that is only available with
5573     * Devel::PPPort. It is NOT in the perl core.
5574     * Its purpose is to mimic the 5.8.0 behaviour of sv_magic() when
5575     * it is being passed a name pointer with namlen == 0. In that
5576     * case, perl 5.8.0 and later store the pointer, not a copy of it.
5577     * The compatibility can be provided back to perl 5.004. With
5578     * earlier versions, the code will not compile.
5579     */
5580    
5581    #if (PERL_BCDVERSION < 0x5004000)
5582    
5583      /* code that uses sv_magic_portable will not compile */
5584    
5585    #elif (PERL_BCDVERSION < 0x5008000)
5586    
5587    #  define sv_magic_portable(sv, obj, how, name, namlen)     \
5588       STMT_START {                                             \
5589         SV *SvMp_sv = (sv);                                    \
5590         char *SvMp_name = (char *) (name);                     \
5591         I32 SvMp_namlen = (namlen);                            \
5592         if (SvMp_name && SvMp_namlen == 0)                     \
5593         {                                                      \
5594           MAGIC *mg;                                           \
5595           sv_magic(SvMp_sv, obj, how, 0, 0);                   \
5596           mg = SvMAGIC(SvMp_sv);                               \
5597           mg->mg_len = -42; /* XXX: this is the tricky part */ \
5598           mg->mg_ptr = SvMp_name;                              \
5599         }                                                      \
5600         else                                                   \
5601         {                                                      \
5602           sv_magic(SvMp_sv, obj, how, SvMp_name, SvMp_namlen); \
5603         }                                                      \
5604       } STMT_END
5605    
5606    #else
5607    
5608    #  define sv_magic_portable(a, b, c, d, e)  sv_magic(a, b, c, d, e)
5609    
5610    #endif
5611    
5612  #ifdef USE_ITHREADS  #ifdef USE_ITHREADS
5613  #ifndef CopFILE  #ifndef CopFILE
# Line 4343  DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, Line 5736  DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv,
5736  #ifndef IS_NUMBER_NAN  #ifndef IS_NUMBER_NAN
5737  #  define IS_NUMBER_NAN                  0x20  #  define IS_NUMBER_NAN                  0x20
5738  #endif  #endif
   
 /* GROK_NUMERIC_RADIX depends on grok_numeric_radix */  
5739  #ifndef GROK_NUMERIC_RADIX  #ifndef GROK_NUMERIC_RADIX
5740  #  define GROK_NUMERIC_RADIX(sp, send)   grok_numeric_radix(sp, send)  #  define GROK_NUMERIC_RADIX(sp, send)   grok_numeric_radix(sp, send)
5741  #endif  #endif
# Line 4407  DPPP_(my_grok_numeric_radix)(pTHX_ const Line 5798  DPPP_(my_grok_numeric_radix)(pTHX_ const
5798              return TRUE;              return TRUE;
5799          }          }
5800      }      }
5801  #endif /* PERL_VERSION */  #endif
5802  #endif /* USE_LOCALE_NUMERIC */  #endif /* USE_LOCALE_NUMERIC */
5803      /* always try "." if numeric radix didn't match because      /* always try "." if numeric radix didn't match because
5804       * we may have data from different locales mixed */       * we may have data from different locales mixed */
# Line 4420  DPPP_(my_grok_numeric_radix)(pTHX_ const Line 5811  DPPP_(my_grok_numeric_radix)(pTHX_ const
5811  #endif  #endif
5812  #endif  #endif
5813    
 /* grok_number depends on grok_numeric_radix */  
   
5814  #ifndef grok_number  #ifndef grok_number
5815  #if defined(NEED_grok_number)  #if defined(NEED_grok_number)
5816  static int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep);  static int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep);
# Line 4638  DPPP_(my_grok_number)(pTHX_ const char * Line 6027  DPPP_(my_grok_number)(pTHX_ const char *
6027    
6028  #ifndef grok_bin  #ifndef grok_bin
6029  #if defined(NEED_grok_bin)  #if defined(NEED_grok_bin)
6030  static UV DPPP_(my_grok_bin)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);  static UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6031  static  static
6032  #else  #else
6033  extern UV DPPP_(my_grok_bin)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);  extern UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6034  #endif  #endif
6035    
6036  #ifdef grok_bin  #ifdef grok_bin
# Line 4652  extern UV DPPP_(my_grok_bin)(pTHX_ char Line 6041  extern UV DPPP_(my_grok_bin)(pTHX_ char
6041    
6042  #if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL)  #if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL)
6043  UV  UV
6044  DPPP_(my_grok_bin)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result)  DPPP_(my_grok_bin)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
6045  {  {
6046      const char *s = start;      const char *s = start;
6047      STRLEN len = *len_p;      STRLEN len = *len_p;
# Line 4740  DPPP_(my_grok_bin)(pTHX_ char *start, ST Line 6129  DPPP_(my_grok_bin)(pTHX_ char *start, ST
6129    
6130  #ifndef grok_hex  #ifndef grok_hex
6131  #if defined(NEED_grok_hex)  #if defined(NEED_grok_hex)
6132  static UV DPPP_(my_grok_hex)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);  static UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6133  static  static
6134  #else  #else
6135  extern UV DPPP_(my_grok_hex)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);  extern UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6136  #endif  #endif
6137    
6138  #ifdef grok_hex  #ifdef grok_hex
# Line 4754  extern UV DPPP_(my_grok_hex)(pTHX_ char Line 6143  extern UV DPPP_(my_grok_hex)(pTHX_ char
6143    
6144  #if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL)  #if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL)
6145  UV  UV
6146  DPPP_(my_grok_hex)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result)  DPPP_(my_grok_hex)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
6147  {  {
6148      const char *s = start;      const char *s = start;
6149      STRLEN len = *len_p;      STRLEN len = *len_p;
# Line 4842  DPPP_(my_grok_hex)(pTHX_ char *start, ST Line 6231  DPPP_(my_grok_hex)(pTHX_ char *start, ST
6231    
6232  #ifndef grok_oct  #ifndef grok_oct
6233  #if defined(NEED_grok_oct)  #if defined(NEED_grok_oct)
6234  static UV DPPP_(my_grok_oct)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);  static UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6235  static  static
6236  #else  #else
6237  extern UV DPPP_(my_grok_oct)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);  extern UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6238  #endif  #endif
6239    
6240  #ifdef grok_oct  #ifdef grok_oct
# Line 4856  extern UV DPPP_(my_grok_oct)(pTHX_ char Line 6245  extern UV DPPP_(my_grok_oct)(pTHX_ char
6245    
6246  #if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL)  #if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL)
6247  UV  UV
6248  DPPP_(my_grok_oct)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result)  DPPP_(my_grok_oct)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
6249  {  {
6250      const char *s = start;      const char *s = start;
6251      STRLEN len = *len_p;      STRLEN len = *len_p;
# Line 4933  DPPP_(my_grok_oct)(pTHX_ char *start, ST Line 6322  DPPP_(my_grok_oct)(pTHX_ char *start, ST
6322  #endif  #endif
6323  #endif  #endif
6324    
6325    #if !defined(my_snprintf)
6326    #if defined(NEED_my_snprintf)
6327    static int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...);
6328    static
6329    #else
6330    extern int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...);
6331    #endif
6332    
6333    #define my_snprintf DPPP_(my_my_snprintf)
6334    #define Perl_my_snprintf DPPP_(my_my_snprintf)
6335    
6336    #if defined(NEED_my_snprintf) || defined(NEED_my_snprintf_GLOBAL)
6337    
6338    int
6339    DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...)
6340    {
6341        dTHX;
6342        int retval;
6343        va_list ap;
6344        va_start(ap, format);
6345    #ifdef HAS_VSNPRINTF
6346        retval = vsnprintf(buffer, len, format, ap);
6347    #else
6348        retval = vsprintf(buffer, format, ap);
6349    #endif
6350        va_end(ap);
6351        if (retval >= (int)len)