This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
more PERL_OBJECT cleanups (changes still untested on Unix!)
authorGurusamy Sarathy <gsar@cpan.org>
Thu, 8 Jul 1999 18:47:35 +0000 (18:47 +0000)
committerGurusamy Sarathy <gsar@cpan.org>
Thu, 8 Jul 1999 18:47:35 +0000 (18:47 +0000)
p4raw-id: //depot/perl@3660

38 files changed:
MANIFEST
XSUB.h
emacs/ptags
embed.h
embed.pl
embedvar.h
ext/Opcode/Opcode.xs
global.sym
globals.c
intrpvar.h
iperlsys.h
mg.c
miniperlmain.c
objXSUB.h
perl.c
perl.h
perlapi.c [new file with mode: 0755]
perlapi.h [new file with mode: 0755]
perly.c
pp.c
pp_ctl.c
pp_hot.c
proto.h
regcomp.c
regcomp.h
regexec.c
scope.c
scope.h
sv.c
thrdvar.h
toke.c
util.c
win32/GenCAPI.pl
win32/Makefile
win32/makedef.pl
win32/perllib.c
win32/win32.c
win32/win32.h

index 6ad0a6c..1888c0d 100644 (file)
--- a/MANIFEST
+++ b/MANIFEST
@@ -930,6 +930,8 @@ os2/perl2cmd.pl             Corrects installed binaries under OS/2
 patchlevel.h           The current patch level of perl
 perl.c                 main()
 perl.h                 Global declarations
+perlapi.c              Perl API functions
+perlapi.h              Perl API function declarations
 perl_exp.SH            Creates list of exported symbols for AIX
 perlio.c               C code for PerlIO abstraction
 perlio.h               compatibility stub
diff --git a/XSUB.h b/XSUB.h
index 70e7d84..c43b7f9 100644 (file)
--- a/XSUB.h
+++ b/XSUB.h
@@ -23,7 +23,7 @@
 #define dXSFUNCTION(ret)               XSINTERFACE_CVT(ret,XSFUNCTION)
 #define XSINTERFACE_FUNC(ret,cv,f)     ((XSINTERFACE_CVT(ret,cv))(f))
 #define XSINTERFACE_FUNC_SET(cv,f)     \
-               CvXSUBANY(cv).any_dptr = (void (*) (pTHX_ void*))(f)
+               CvXSUBANY(cv).any_dptr = (void (*) (pTHXo_ void*))(f)
 
 #define XSRETURN(off)                                  \
     STMT_START {                                       \
 #  define XS_VERSION_BOOTCHECK
 #endif
 
-#ifdef PERL_CAPI
-#  define VTBL_sv              get_vtbl(want_vtbl_sv)
-#  define VTBL_env             get_vtbl(want_vtbl_env)
-#  define VTBL_envelem         get_vtbl(want_vtbl_envelem)
-#  define VTBL_sig             get_vtbl(want_vtbl_sig)
-#  define VTBL_sigelem         get_vtbl(want_vtbl_sigelem)
-#  define VTBL_pack            get_vtbl(want_vtbl_pack)
-#  define VTBL_packelem                get_vtbl(want_vtbl_packelem)
-#  define VTBL_dbline          get_vtbl(want_vtbl_dbline)
-#  define VTBL_isa             get_vtbl(want_vtbl_isa)
-#  define VTBL_isaelem         get_vtbl(want_vtbl_isaelem)
-#  define VTBL_arylen          get_vtbl(want_vtbl_arylen)
-#  define VTBL_glob            get_vtbl(want_vtbl_glob)
-#  define VTBL_mglob           get_vtbl(want_vtbl_mglob)
-#  define VTBL_nkeys           get_vtbl(want_vtbl_nkeys)
-#  define VTBL_taint           get_vtbl(want_vtbl_taint)
-#  define VTBL_substr          get_vtbl(want_vtbl_substr)
-#  define VTBL_vec             get_vtbl(want_vtbl_vec)
-#  define VTBL_pos             get_vtbl(want_vtbl_pos)
-#  define VTBL_bm              get_vtbl(want_vtbl_bm)
-#  define VTBL_fm              get_vtbl(want_vtbl_fm)
-#  define VTBL_uvar            get_vtbl(want_vtbl_uvar)
-#  define VTBL_defelem         get_vtbl(want_vtbl_defelem)
-#  define VTBL_regexp          get_vtbl(want_vtbl_regexp)
-#  define VTBL_regdata         get_vtbl(want_vtbl_regdata)
-#  define VTBL_regdatum                get_vtbl(want_vtbl_regdatum)
-#  ifdef USE_LOCALE_COLLATE
-#    define VTBL_collxfrm      get_vtbl(want_vtbl_collxfrm)
-#  endif
-#  define VTBL_amagic          get_vtbl(want_vtbl_amagic)
-#  define VTBL_amagicelem      get_vtbl(want_vtbl_amagicelem)
-#else
+#if 1          /* for compatibility */
 #  define VTBL_sv              &PL_vtbl_sv
 #  define VTBL_env             &PL_vtbl_env
 #  define VTBL_envelem         &PL_vtbl_envelem
 #endif
 
 #ifdef PERL_OBJECT
+
+#  include "perlapi.h"
 #  include "objXSUB.h"
 
 #  undef  aTHXo
 #  undef  _aTHXo
 #  define _aTHXo               ,aTHXo
 
-#  undef  SAVEDESTRUCTOR
-#  define SAVEDESTRUCTOR(f,p) \
-       pPerl->Perl_save_destructor((FUNC_NAME_TO_PTR(f)),(p))
-
 #  ifdef WIN32
-#    ifndef WIN32IO_IS_STDIO
-#      undef   errno
-#      define  errno                   ErrorNo()
-#    endif
-#    undef  NtCrypt
-#    define NtCrypt                    pPerl->NtCrypt
-#    undef  NtGetLib
-#    define NtGetLib                   pPerl->NtGetLib
-#    undef  NtGetArchLib
-#    define NtGetArchLib               pPerl->NtGetArchLib
-#    undef  NtGetSiteLib
-#    define NtGetSiteLib               pPerl->NtGetSiteLib
-#    undef  NtGetBin
-#    define NtGetBin                   pPerl->NtGetBin
-#    undef  NtGetDebugScriptStr
-#    define NtGetDebugScriptStr                pPerl->NtGetDebugScriptStr
 #    undef fprintf
 #    define fprintf                    pPerl->fprintf
 #  endif /* WIN32 */
 #    define shutdown           PerlSock_shutdown
 #    define socket             PerlSock_socket
 #    define socketpair         PerlSock_socketpair
-
 #    ifdef WIN32
 #      include "XSlock.h"
-#    endif  /* WIN32 */
+#    endif
 #  endif  /* NO_XSLOCKS */
-#else
-#  ifdef PERL_CAPI
-#    include "perlCAPI.h"
-#  endif
+
 #endif /* PERL_OBJECT */
index a048192..7570220 100755 (executable)
@@ -61,7 +61,7 @@ etags -o TAGS.tmp -a \
 etags -o TAGS.tmp -a "$@" $topfiles
 
 # Now add these PL_:
-perl -w014pe 'if (s/^( .* PERLVAR I?   # 1:   TAG group
+perl -w014pe 'if (s/^( .* PERLVAR A?I? # 1:   TAG group
                       \s* \( \s* [GIT] #
                       .*               #
                     \x7F               #      End of description
diff --git a/embed.h b/embed.h
index 1dade3e..22ef66d 100644 (file)
--- a/embed.h
+++ b/embed.h
 #if defined(PERL_GLOBAL_STRUCT)
 #define GetVars                        Perl_GetVars
 #endif
-#define yydestruct             Perl_yydestruct
 #define runops_standard                Perl_runops_standard
 #define runops_debug           Perl_runops_debug
-#if defined(WIN32)
-#if defined(PERL_OBJECT)
-#define ErrorNo                        Perl_ErrorNo
-#else
-#define ErrorNo                        Perl_ErrorNo
-#endif
-#endif
 #define sv_catpvf_mg           Perl_sv_catpvf_mg
 #define sv_catpv_mg            Perl_sv_catpv_mg
 #define sv_catpvn_mg           Perl_sv_catpvn_mg
 #define save_magic             S_save_magic
 #define magic_methpack         S_magic_methpack
 #define magic_methcall         S_magic_methcall
-#define unwind_handler_stack   S_unwind_handler_stack
-#define restore_magic          S_restore_magic
 #endif
 #if defined(PERL_IN_OP_C) || defined(PERL_DECL_PROT)
 #define list_assignment                S_list_assignment
 #define doeval                 S_doeval
 #define doopen_pmc             S_doopen_pmc
 #define qsortsv                        S_qsortsv
-#define sortcv                 S_sortcv
-#define sv_ncmp                        S_sv_ncmp
-#define sv_i_ncmp              S_sv_i_ncmp
-#define amagic_ncmp            S_amagic_ncmp
-#define amagic_i_ncmp          S_amagic_i_ncmp
-#define amagic_cmp             S_amagic_cmp
-#define amagic_cmp_locale      S_amagic_cmp_locale
 #endif
 #if defined(PERL_IN_PP_HOT_C) || defined(PERL_DECL_PROT)
 #define get_db_sub             S_get_db_sub
-#  if defined(USE_THREADS)
-#define unset_cvowner          S_unset_cvowner
-#  endif
 #endif
 #if defined(PERL_IN_PP_SYS_C) || defined(PERL_DECL_PROT)
 #define doform                 S_doform
 #define re_croak2              S_re_croak2
 #define regpposixcc            S_regpposixcc
 #define checkposixcc           S_checkposixcc
-#define clear_re               S_clear_re
 #endif
 #if defined(PERL_IN_REGEXEC_C) || defined(PERL_DECL_PROT)
 #define regmatch               S_regmatch
 #define regcppop               S_regcppop
 #define regcp_set_to           S_regcp_set_to
 #define cache_re               S_cache_re
-#define restore_pos            S_restore_pos
 #define reghop                 S_reghop
 #define reghopmaybe            S_reghopmaybe
 #endif
 #define del_xpv                        S_del_xpv
 #define del_xrv                        S_del_xrv
 #define sv_unglob              S_sv_unglob
-#define do_report_used         S_do_report_used
-#define do_clean_objs          S_do_clean_objs
-#define do_clean_named_objs    S_do_clean_named_objs
-#define do_clean_all           S_do_clean_all
 #define not_a_number           S_not_a_number
 #define visit                  S_visit
 #  if defined(PURIFY)
 #define incl_perldb            S_incl_perldb
 #define utf16_textfilter       S_utf16_textfilter
 #define utf16rev_textfilter    S_utf16rev_textfilter
-#define restore_rsfp           S_restore_rsfp
-#define restore_expect         S_restore_expect
-#define restore_lex_expect     S_restore_lex_expect
 #  if defined(CRIPPLED_CC)
 #define uni                    S_uni
 #  endif
 #if defined(PERL_GLOBAL_STRUCT)
 #define GetVars()              Perl_GetVars(aTHX)
 #endif
-#define yydestruct(a)          Perl_yydestruct(aTHX_ a)
 #define runops_standard()      Perl_runops_standard(aTHX)
 #define runops_debug()         Perl_runops_debug(aTHX)
-#if defined(WIN32)
-#if defined(PERL_OBJECT)
-#define ErrorNo()              Perl_ErrorNo(aTHX)
-#else
-#define ErrorNo()              Perl_ErrorNo(aTHX)
-#endif
-#endif
 #define sv_catpv_mg(a,b)       Perl_sv_catpv_mg(aTHX_ a,b)
 #define sv_catpvn_mg(a,b,c)    Perl_sv_catpvn_mg(aTHX_ a,b,c)
 #define sv_catsv_mg(a,b)       Perl_sv_catsv_mg(aTHX_ a,b)
 #define save_magic(a,b)                S_save_magic(aTHX_ a,b)
 #define magic_methpack(a,b,c)  S_magic_methpack(aTHX_ a,b,c)
 #define magic_methcall(a,b,c,d,e,f)    S_magic_methcall(aTHX_ a,b,c,d,e,f)
-#define unwind_handler_stack(a)        S_unwind_handler_stack(aTHX_ a)
-#define restore_magic(a)       S_restore_magic(aTHX_ a)
 #endif
 #if defined(PERL_IN_OP_C) || defined(PERL_DECL_PROT)
 #define list_assignment(a)     S_list_assignment(aTHX_ a)
 #define doeval(a,b)            S_doeval(aTHX_ a,b)
 #define doopen_pmc(a,b)                S_doopen_pmc(aTHX_ a,b)
 #define qsortsv(a,b,c)         S_qsortsv(aTHX_ a,b,c)
-#define sortcv(a,b)            S_sortcv(aTHX_ a,b)
-#define sv_ncmp(a,b)           S_sv_ncmp(aTHX_ a,b)
-#define sv_i_ncmp(a,b)         S_sv_i_ncmp(aTHX_ a,b)
-#define amagic_ncmp(a,b)       S_amagic_ncmp(aTHX_ a,b)
-#define amagic_i_ncmp(a,b)     S_amagic_i_ncmp(aTHX_ a,b)
-#define amagic_cmp(a,b)                S_amagic_cmp(aTHX_ a,b)
-#define amagic_cmp_locale(a,b) S_amagic_cmp_locale(aTHX_ a,b)
 #endif
 #if defined(PERL_IN_PP_HOT_C) || defined(PERL_DECL_PROT)
 #define get_db_sub(a,b)                S_get_db_sub(aTHX_ a,b)
-#  if defined(USE_THREADS)
-#define unset_cvowner(a)       S_unset_cvowner(aTHX_ a)
-#  endif
 #endif
 #if defined(PERL_IN_PP_SYS_C) || defined(PERL_DECL_PROT)
 #define doform(a,b,c)          S_doform(aTHX_ a,b,c)
 #define add_data(a,b)          S_add_data(aTHX_ a,b)
 #define regpposixcc(a)         S_regpposixcc(aTHX_ a)
 #define checkposixcc()         S_checkposixcc(aTHX)
-#define clear_re(a)            S_clear_re(aTHX_ a)
 #endif
 #if defined(PERL_IN_REGEXEC_C) || defined(PERL_DECL_PROT)
 #define regmatch(a)            S_regmatch(aTHX_ a)
 #define regcppop()             S_regcppop(aTHX)
 #define regcp_set_to(a)                S_regcp_set_to(aTHX_ a)
 #define cache_re(a)            S_cache_re(aTHX_ a)
-#define restore_pos(a)         S_restore_pos(aTHX_ a)
 #define reghop(a,b)            S_reghop(aTHX_ a,b)
 #define reghopmaybe(a,b)       S_reghopmaybe(aTHX_ a,b)
 #endif
 #define del_xpv(a)             S_del_xpv(aTHX_ a)
 #define del_xrv(a)             S_del_xrv(aTHX_ a)
 #define sv_unglob(a)           S_sv_unglob(aTHX_ a)
-#define do_report_used(a)      S_do_report_used(aTHX_ a)
-#define do_clean_objs(a)       S_do_clean_objs(aTHX_ a)
-#define do_clean_named_objs(a) S_do_clean_named_objs(aTHX_ a)
-#define do_clean_all(a)                S_do_clean_all(aTHX_ a)
 #define not_a_number(a)                S_not_a_number(aTHX_ a)
 #define visit(a)               S_visit(aTHX_ a)
 #  if defined(PURIFY)
 #define incl_perldb()          S_incl_perldb(aTHX)
 #define utf16_textfilter(a,b,c)        S_utf16_textfilter(aTHX_ a,b,c)
 #define utf16rev_textfilter(a,b,c)     S_utf16rev_textfilter(aTHX_ a,b,c)
-#define restore_rsfp(a)                S_restore_rsfp(aTHX_ a)
-#define restore_expect(a)      S_restore_expect(aTHX_ a)
-#define restore_lex_expect(a)  S_restore_lex_expect(aTHX_ a)
 #  if defined(CRIPPLED_CC)
 #define uni(a,b)               S_uni(aTHX_ a,b)
 #  endif
 #define Perl_GetVars           CPerlObj::Perl_GetVars
 #define GetVars                        Perl_GetVars
 #endif
-#define Perl_yydestruct                CPerlObj::Perl_yydestruct
-#define yydestruct             Perl_yydestruct
 #define Perl_runops_standard   CPerlObj::Perl_runops_standard
 #define runops_standard                Perl_runops_standard
 #define Perl_runops_debug      CPerlObj::Perl_runops_debug
 #define runops_debug           Perl_runops_debug
-#if defined(WIN32)
-#if defined(PERL_OBJECT)
-#define Perl_ErrorNo           CPerlObj::Perl_ErrorNo
-#define ErrorNo                        Perl_ErrorNo
-#else
-#define Perl_ErrorNo           CPerlObj::Perl_ErrorNo
-#define ErrorNo                        Perl_ErrorNo
-#endif
-#endif
 #define Perl_sv_catpvf_mg      CPerlObj::Perl_sv_catpvf_mg
 #define sv_catpvf_mg           Perl_sv_catpvf_mg
 #define Perl_sv_catpv_mg       CPerlObj::Perl_sv_catpv_mg
 #define magic_methpack         S_magic_methpack
 #define S_magic_methcall       CPerlObj::S_magic_methcall
 #define magic_methcall         S_magic_methcall
-#define S_unwind_handler_stack CPerlObj::S_unwind_handler_stack
-#define unwind_handler_stack   S_unwind_handler_stack
-#define S_restore_magic                CPerlObj::S_restore_magic
-#define restore_magic          S_restore_magic
 #endif
 #if defined(PERL_IN_OP_C) || defined(PERL_DECL_PROT)
 #define S_list_assignment      CPerlObj::S_list_assignment
 #define doopen_pmc             S_doopen_pmc
 #define S_qsortsv              CPerlObj::S_qsortsv
 #define qsortsv                        S_qsortsv
-#define S_sortcv               CPerlObj::S_sortcv
-#define sortcv                 S_sortcv
-#define S_sv_ncmp              CPerlObj::S_sv_ncmp
-#define sv_ncmp                        S_sv_ncmp
-#define S_sv_i_ncmp            CPerlObj::S_sv_i_ncmp
-#define sv_i_ncmp              S_sv_i_ncmp
-#define S_amagic_ncmp          CPerlObj::S_amagic_ncmp
-#define amagic_ncmp            S_amagic_ncmp
-#define S_amagic_i_ncmp                CPerlObj::S_amagic_i_ncmp
-#define amagic_i_ncmp          S_amagic_i_ncmp
-#define S_amagic_cmp           CPerlObj::S_amagic_cmp
-#define amagic_cmp             S_amagic_cmp
-#define S_amagic_cmp_locale    CPerlObj::S_amagic_cmp_locale
-#define amagic_cmp_locale      S_amagic_cmp_locale
 #endif
 #if defined(PERL_IN_PP_HOT_C) || defined(PERL_DECL_PROT)
 #define S_get_db_sub           CPerlObj::S_get_db_sub
 #define get_db_sub             S_get_db_sub
-#  if defined(USE_THREADS)
-#define S_unset_cvowner                CPerlObj::S_unset_cvowner
-#define unset_cvowner          S_unset_cvowner
-#  endif
 #endif
 #if defined(PERL_IN_PP_SYS_C) || defined(PERL_DECL_PROT)
 #define S_doform               CPerlObj::S_doform
 #define regpposixcc            S_regpposixcc
 #define S_checkposixcc         CPerlObj::S_checkposixcc
 #define checkposixcc           S_checkposixcc
-#define S_clear_re             CPerlObj::S_clear_re
-#define clear_re               S_clear_re
 #endif
 #if defined(PERL_IN_REGEXEC_C) || defined(PERL_DECL_PROT)
 #define S_regmatch             CPerlObj::S_regmatch
 #define regcp_set_to           S_regcp_set_to
 #define S_cache_re             CPerlObj::S_cache_re
 #define cache_re               S_cache_re
-#define S_restore_pos          CPerlObj::S_restore_pos
-#define restore_pos            S_restore_pos
 #define S_reghop               CPerlObj::S_reghop
 #define reghop                 S_reghop
 #define S_reghopmaybe          CPerlObj::S_reghopmaybe
 #define del_xrv                        S_del_xrv
 #define S_sv_unglob            CPerlObj::S_sv_unglob
 #define sv_unglob              S_sv_unglob
-#define S_do_report_used       CPerlObj::S_do_report_used
-#define do_report_used         S_do_report_used
-#define S_do_clean_objs                CPerlObj::S_do_clean_objs
-#define do_clean_objs          S_do_clean_objs
-#define S_do_clean_named_objs  CPerlObj::S_do_clean_named_objs
-#define do_clean_named_objs    S_do_clean_named_objs
-#define S_do_clean_all         CPerlObj::S_do_clean_all
-#define do_clean_all           S_do_clean_all
 #define S_not_a_number         CPerlObj::S_not_a_number
 #define not_a_number           S_not_a_number
 #define S_visit                        CPerlObj::S_visit
 #define utf16_textfilter       S_utf16_textfilter
 #define S_utf16rev_textfilter  CPerlObj::S_utf16rev_textfilter
 #define utf16rev_textfilter    S_utf16rev_textfilter
-#define S_restore_rsfp         CPerlObj::S_restore_rsfp
-#define restore_rsfp           S_restore_rsfp
-#define S_restore_expect       CPerlObj::S_restore_expect
-#define restore_expect         S_restore_expect
-#define S_restore_lex_expect   CPerlObj::S_restore_lex_expect
-#define restore_lex_expect     S_restore_lex_expect
 #  if defined(CRIPPLED_CC)
 #define S_uni                  CPerlObj::S_uni
 #define uni                    S_uni
index 25ff092..bdca208 100755 (executable)
--- a/embed.pl
+++ b/embed.pl
@@ -218,12 +218,12 @@ sub readvars(\%$$@) {
        or die "embed.pl: Can't open $file: $!\n";
     while (<FILE>) {
        s/[ \t]*#.*//;          # Delete comments.
-       if (/PERLVARI?C?\($pre(\w+)/) {
+       if (/PERLVARA?I?C?\($pre(\w+)/) {
            my $sym = $1;
            $sym = $pre . $sym if $keep_pre;
            warn "duplicate symbol $sym while processing $file\n"
                if exists $$syms{$sym};
-           $$syms{$sym} = 1;
+           $$syms{$sym} = $pre || 1;
        }
     }
     close(FILE);
@@ -235,12 +235,10 @@ my %thread;
 readvars %intrp,  'intrpvar.h','I';
 readvars %thread, 'thrdvar.h','T';
 readvars %globvar, 'perlvars.h','G';
-readvars %objvar, 'intrpvar.h','pi', 1;
 
-foreach my $sym (sort keys %thread)
- {
+foreach my $sym (sort keys %thread) {
   warn "$sym in intrpvar.h as well as thrdvar.h\n" if exists $intrp{$sym};
- }
+}
 
 sub undefine ($) {
     my ($sym) = @_;
@@ -253,9 +251,9 @@ sub hide ($$) {
     "#define $from" . "\t" x ($t < 3 ? 3 - $t : 1) . "$to\n";
 }
 
-sub objxsub_var ($) {
-    my ($sym) = @_;
-    undefine("PL_$sym") . hide("PL_$sym", "pPerl->PL_$sym");
+sub objxsub_var ($$) {
+    my ($pfx, $sym) = @_;
+    undefine("PL_$sym") . hide("PL_$sym", "(*Perl_${pfx}${sym}_ptr(pPerl))");
 }
 
 sub embedvar ($) {
@@ -672,12 +670,16 @@ print OBX <<'EOT';
 
 EOT
 
-foreach my $sym (sort(keys(%intrp),
-                     keys(%thread),
-                     keys(%globvar),
-                     keys(%objvar)))
-{
-    print OBX objxsub_var($sym);
+foreach my $sym (sort keys %intrp) {
+    print OBX objxsub_var('I',$sym);
+}
+
+foreach my $sym (sort keys %thread) {
+    print OBX objxsub_var('T',$sym);
+}
+
+foreach my $sym (sort keys %globvar) {
+    print OBX objxsub_var('G',$sym);
 }
 
 print OBX <<'EOT';
@@ -720,6 +722,160 @@ EOT
 
 close(OBX);
 
+unlink 'perlapi.h';
+unlink 'perlapi.c';
+open(CAPI, '> perlapi.c') or die "Can't create perlapi.c: $!\n";
+open(CAPIH, '> perlapi.h') or die "Can't create perlapi.h: $!\n";
+
+print CAPIH <<'EOT';
+/* !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+   This file is built by embed.pl from data in embed.pl, pp.sym, intrpvar.h,
+   perlvars.h and thrdvar.h.  Any changes made here will be lost!
+*/
+
+#if defined(PERL_OBJECT)
+
+/* declare accessor functions for Perl variables */
+
+START_EXTERN_C
+
+#undef PERLVAR
+#undef PERLVARA
+#undef PERLVARI
+#undef PERLVARIC
+#define PERLVAR(v,t)   EXTERN_C t* Perl_##v##_ptr(void *p);
+#define PERLVARA(v,n,t)        typedef t PL_##v##_t[n];                        \
+                       EXTERN_C PL_##v##_t* Perl_##v##_ptr(void *p);
+#define PERLVARI(v,t,i)        PERLVAR(v,t)
+#define PERLVARIC(v,t,i) PERLVAR(v,t)
+
+#include "thrdvar.h"
+#include "intrpvar.h"
+#include "perlvars.h"
+
+#undef PERLVAR
+#undef PERLVARA
+#undef PERLVARI
+#undef PERLVARIC
+
+END_EXTERN_C
+
+#endif /* PERL_OBJECT */
+
+EOT
+
+
+print CAPI <<'EOT';
+/* !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+   This file is built by embed.pl from data in embed.pl, pp.sym, intrpvar.h,
+   perlvars.h and thrdvar.h.  Any changes made here will be lost!
+*/
+
+#include "EXTERN.h"
+#include "perl.h"
+#include "perlapi.h"
+
+#if defined(PERL_OBJECT)
+
+/* accessor functions for Perl variables (provides binary compatibility) */
+START_EXTERN_C
+
+#undef PERLVAR
+#undef PERLVARA
+#undef PERLVARI
+#undef PERLVARIC
+#define PERLVAR(v,t)   t* Perl_##v##_ptr(void *p)                      \
+                       { return &(((CPerlObj*)p)->PL_##v); }
+#define PERLVARA(v,n,t)        PL_##v##_t* Perl_##v##_ptr(void *p)             \
+                       { return &(((CPerlObj*)p)->PL_##v); }
+#define PERLVARI(v,t,i)        PERLVAR(v,t)
+#define PERLVARIC(v,t,i) PERLVAR(v,t)
+
+#include "thrdvar.h"
+#include "intrpvar.h"
+#include "perlvars.h"
+
+#undef PERLVAR
+#undef PERLVARA
+#undef PERLVARI
+#undef PERLVARIC
+
+EOT
+
+sub emit_func {
+    my ($retval,$func,@args) = @_;
+    my @aargs = @args;
+    for my $a (@aargs) { $a =~ s/^.*\b(\w+)$/$1/ }
+    unshift @args, 'void *pPerl';
+    local $" = ', ';
+    my $return = ($retval =~ /^\s*(void|Free_t|Signal_t)\s*$/ ? '' : 'return ');
+    return <<EOT
+$retval
+$func(@args)
+{
+    $return((CPerlObj*)pPerl)->$func(@aargs);
+}
+EOT
+
+}
+
+# XXXX temporary hack
+for my $sym (qw(
+               perl_construct
+               perl_destruct
+               perl_free
+               perl_run
+               perl_parse
+               ))
+{
+    $skipapi_funcs{$sym}++;
+}
+
+walk_table {
+    my $ret = "";
+    if (@_ == 1) {
+       my $arg = shift;
+       $ret .= "$arg\n" if $arg =~ /^#\s*(if|ifdef|else|endif)\b/;
+    }
+    else {
+       my ($flags,$retval,$func,@args) = @_;
+       return $ret if exists $skipapi_funcs{$func};
+       unless (@args and $args[$#args] =~ /\.\.\./) {
+           unless ($flags =~ /s/) {
+               $ret .= "\n";
+               if ($flags =~ /p/) {
+                   $ret .= undefine("Perl_$func");
+                   $ret .= emit_func($retval,"Perl_$func",@args);
+               }
+               else {
+                   $ret .= undefine($func);
+                   $ret .= emit_func($retval,$func,@args);
+               }
+           }
+       }
+    }
+    $ret;
+} \*CAPI;
+
+for $sym (sort keys %ppsym) {
+    $sym =~ s/^Perl_//;
+    print CAPI "\n";
+    print CAPI undefine("Perl_$sym");
+    if ($sym =~ /^ck_/) {
+       print CAPI emit_func('OP *',"Perl_$sym",'OP *o');
+    }
+    else {                                     # pp_foo
+       print CAPI emit_func('OP *',"Perl_$sym");
+    }
+}
+
+print CAPI <<'EOT';
+
+END_EXTERN_C
+
+#endif /* PERL_OBJECT */
+EOT
+
 __END__
 
 # Lines are of the form:
@@ -1448,17 +1604,8 @@ pn       |void   |safexfree      |Malloc_t where
 #if defined(PERL_GLOBAL_STRUCT)
 p      |struct perl_vars *|GetVars
 #endif
-p      |void   |yydestruct     |void *ptr
 p      |int    |runops_standard
 p      |int    |runops_debug
-
-#if defined(WIN32)
-#if defined(PERL_OBJECT)
-p      |int&   |ErrorNo
-#else
-p      |int*   |ErrorNo
-#endif
-#endif
 p      |void   |sv_catpvf_mg   |SV *sv|const char* pat|...
 p      |void   |sv_catpv_mg    |SV *sv|const char *ptr
 p      |void   |sv_catpvn_mg   |SV *sv|const char *ptr|STRLEN len
@@ -1534,8 +1681,6 @@ s |void   |save_magic     |I32 mgs_ix|SV *sv
 s      |int    |magic_methpack |SV *sv|MAGIC *mg|char *meth
 s      |int    |magic_methcall |SV *sv|MAGIC *mg|char *meth|I32 f \
                                |int n|SV *val
-s      |void   |unwind_handler_stack   |void *p
-s      |void   |restore_magic  |void *p
 #endif
 
 #if defined(PERL_IN_OP_C) || defined(PERL_DECL_PROT)
@@ -1617,20 +1762,10 @@ s       |void   |save_lines     |AV *array|SV *sv
 s      |OP*    |doeval         |int gimme|OP** startop
 s      |PerlIO *|doopen_pmc    |const char *name|const char *mode
 s      |void   |qsortsv        |SV ** array|size_t num_elts|SVCOMPARE_t f
-s      |I32    |sortcv         |SV *a|SV *b
-s      |I32    |sv_ncmp        |SV *a|SV *b
-s      |I32    |sv_i_ncmp      |SV *a|SV *b
-s      |I32    |amagic_ncmp    |SV *a|SV *b
-s      |I32    |amagic_i_ncmp  |SV *a|SV *b
-s      |I32    |amagic_cmp     |SV *str1|SV *str2
-s      |I32    |amagic_cmp_locale|SV *str1|SV *str2
 #endif
 
 #if defined(PERL_IN_PP_HOT_C) || defined(PERL_DECL_PROT)
 s      |CV*    |get_db_sub     |SV **svp|CV *cv
-#  if defined(USE_THREADS)
-s      |void   |unset_cvowner  |void *cvarg
-#  endif
 #endif
 
 #if defined(PERL_IN_PP_SYS_C) || defined(PERL_DECL_PROT)
@@ -1667,7 +1802,6 @@ s |I32    |add_data       |I32 n|char *s
 rs     |void|re_croak2 |const char* pat1|const char* pat2|...
 s      |I32    |regpposixcc    |I32 value
 s      |void   |checkposixcc
-s      |void   |clear_re       |void *r
 #endif
 
 #if defined(PERL_IN_REGEXEC_C) || defined(PERL_DECL_PROT)
@@ -1681,7 +1815,6 @@ s |CHECKPOINT|regcppush   |I32 parenfloor
 s      |char*|regcppop
 s      |char*|regcp_set_to     |I32 ss
 s      |void   |cache_re       |regexp *prog
-s      |void   |restore_pos    |void *arg
 s      |U8*    |reghop         |U8 *pos|I32 off
 s      |U8*    |reghopmaybe    |U8 *pos|I32 off
 #endif
@@ -1711,10 +1844,6 @@ s        |void   |del_xnv        |XPVNV* p
 s      |void   |del_xpv        |XPV* p
 s      |void   |del_xrv        |XRV* p
 s      |void   |sv_unglob      |SV* sv
-s      |void   |do_report_used |SV *sv
-s      |void   |do_clean_objs  |SV *sv
-s      |void   |do_clean_named_objs|SV *sv
-s      |void   |do_clean_all   |SV *sv
 s      |void   |not_a_number   |SV *sv
 s      |void   |visit          |SVFUNC_t f
 #  if defined(PURIFY)
@@ -1770,9 +1899,6 @@ s |void   |depcom
 s      |char*  |incl_perldb
 s      |I32    |utf16_textfilter|int idx|SV *sv|int maxlen
 s      |I32    |utf16rev_textfilter|int idx|SV *sv|int maxlen
-s      |void   |restore_rsfp   |void *f
-s      |void   |restore_expect |void *e
-s      |void   |restore_lex_expect     |void *e
 #  if defined(CRIPPLED_CC)
 s      |int    |uni            |I32 f|char *s
 #  endif
index 74e7ca5..6933cec 100644 (file)
 #define PL_DBsingle            (PL_curinterp->IDBsingle)
 #define PL_DBsub               (PL_curinterp->IDBsub)
 #define PL_DBtrace             (PL_curinterp->IDBtrace)
+#define PL_Dir                 (PL_curinterp->IDir)
+#define PL_Env                 (PL_curinterp->IEnv)
+#define PL_LIO                 (PL_curinterp->ILIO)
+#define PL_Mem                 (PL_curinterp->IMem)
+#define PL_Proc                        (PL_curinterp->IProc)
+#define PL_Sock                        (PL_curinterp->ISock)
+#define PL_StdIO               (PL_curinterp->IStdIO)
 #define PL_amagic_generation   (PL_curinterp->Iamagic_generation)
 #define PL_ampergv             (PL_curinterp->Iampergv)
 #define PL_an                  (PL_curinterp->Ian)
 #define PL_IDBsingle           PL_DBsingle
 #define PL_IDBsub              PL_DBsub
 #define PL_IDBtrace            PL_DBtrace
+#define PL_IDir                        PL_Dir
+#define PL_IEnv                        PL_Env
+#define PL_ILIO                        PL_LIO
+#define PL_IMem                        PL_Mem
+#define PL_IProc               PL_Proc
+#define PL_ISock               PL_Sock
+#define PL_IStdIO              PL_StdIO
 #define PL_Iamagic_generation  PL_amagic_generation
 #define PL_Iampergv            PL_ampergv
 #define PL_Ian                 PL_an
index 100e6f8..c7d5f3e 100644 (file)
@@ -209,7 +209,7 @@ opmask_addlocal(pTHX_ SV *opset, char *op_mask_buf) /* Localise PL_op_mask then
      * is disallowed by Borland
      */
     if (opcode_debug >= 2)
-       SAVEDESTRUCTOR((void(CPERLscope(*))(void*))warn,"PL_op_mask restored");
+       SAVEDESTRUCTOR((void(*)(void*))Perl_warn,"PL_op_mask restored");
 #endif
     PL_op_mask = &op_mask_buf[0];
     if (orig_op_mask)
index c5597d1..36e2e75 100644 (file)
@@ -613,11 +613,8 @@ Perl_safexcalloc
 Perl_safexrealloc
 Perl_safexfree
 Perl_GetVars
-Perl_yydestruct
 Perl_runops_standard
 Perl_runops_debug
-Perl_ErrorNo
-Perl_ErrorNo
 Perl_sv_catpvf_mg
 Perl_sv_catpv_mg
 Perl_sv_catpvn_mg
index 8ba15b3..216139d 100644 (file)
--- a/globals.c
+++ b/globals.c
@@ -6,6 +6,8 @@
 
 #undef PERLVAR
 #define PERLVAR(x, y)
+#undef PERLVARA
+#define PERLVARA(x, n, y)
 #undef PERLVARI
 #define PERLVARI(x, y, z) PL_##x = z;
 #undef PERLVARIC
@@ -21,13 +23,13 @@ CPerlObj::CPerlObj(IPerlMem* ipM, IPerlEnv* ipE, IPerlStdIO* ipStd,
 #include "intrpvar.h"
 #include "perlvars.h"
 
-    PL_piMem = ipM;
-    PL_piENV = ipE;
-    PL_piStdIO = ipStd;
-    PL_piLIO = ipLIO;
-    PL_piDir = ipD;
-    PL_piSock = ipS;
-    PL_piProc = ipP;
+    PL_Mem = ipM;
+    PL_Env = ipE;
+    PL_StdIO = ipStd;
+    PL_LIO = ipLIO;
+    PL_Dir = ipD;
+    PL_Sock = ipS;
+    PL_Proc = ipP;
 }
 
 void*
@@ -39,12 +41,6 @@ CPerlObj::operator new(size_t nSize, IPerlMem *pvtbl)
     return NULL;
 }
 
-int&
-Perl_ErrorNo(void)
-{
-    return errno;
-}
-
 void
 CPerlObj::Init(void)
 {
index e2d1d5f..6bff0dd 100644 (file)
@@ -26,7 +26,7 @@ PERLVAR(Iwarnhook,    SV *)
 PERLVAR(Iparsehook,    SV *)
 PERLVAR(Icddir,                char *)         /* switches */
 PERLVAR(Iminus_c,      bool)
-PERLVAR(Ipatchlevel[10],char)
+PERLVARA(Ipatchlevel,10,char)
 PERLVAR(Ilocalpatches, char **)
 PERLVARI(Isplitstr,    char *, " ")
 PERLVAR(Ipreprocess,   bool)
@@ -228,7 +228,7 @@ PERLVAR(Inice_chunk_size,   U32)    /* how nice the chunk of memory is */
 
 PERLVARI(Irunops,      runops_proc_t,  FUNC_NAME_TO_PTR(RUNOPS_DEFAULT))
 
-PERLVAR(Itokenbuf[256],        char)
+PERLVARA(Itokenbuf,256,        char)
 
 PERLVAR(Isv_undef,     SV)
 PERLVAR(Isv_no,                SV)
@@ -257,8 +257,8 @@ PERLVAR(Ilex_brackstack,char *)             /* what kind of brackets to pop */
 PERLVAR(Ilex_casestack,        char *)         /* what kind of case mods in effect */
 
 /* What we know when we're in LEX_KNOWNEXT state. */
-PERLVAR(Inextval[5],   YYSTYPE)        /* value of next token, if any */
-PERLVAR(Inexttype[5],  I32)            /* type of next token */
+PERLVARA(Inextval,5,   YYSTYPE)        /* value of next token, if any */
+PERLVARA(Inexttype,5,  I32)            /* type of next token */
 PERLVAR(Inexttoke,     I32)
 
 PERLVAR(Ilinestr,      SV *)
@@ -340,7 +340,7 @@ PERLVAR(Iutf8_totitle,      SV *)
 PERLVAR(Iutf8_tolower, SV *)
 PERLVAR(Ilast_swash_hv,        HV *)
 PERLVAR(Ilast_swash_klen,      U32)
-PERLVAR(Ilast_swash_key[10],   U8)
+PERLVARA(Ilast_swash_key,10,   U8)
 PERLVAR(Ilast_swash_tmps,      U8 *)
 PERLVAR(Ilast_swash_slen,      STRLEN)
 
@@ -356,7 +356,7 @@ PERLVAR(Iglob_index,        int)
 PERLVAR(Iefloatbuf,    char*)
 PERLVAR(Iefloatsize,   STRLEN)
 PERLVAR(Isrand_called, bool)
-PERLVAR(Iuudmap[256],  char)
+PERLVARA(Iuudmap,256,  char)
 PERLVAR(Ibitcount,     char *)
 PERLVAR(Ifilter_debug, int)
 
@@ -383,11 +383,11 @@ PERLVAR(Icred_mutex,      perl_mutex)     /* altered credentials in effect */
 #endif /* USE_THREADS */
 
 #ifdef PERL_OBJECT
-PERLVARI(piMem,                IPerlMem*,  NULL)
-PERLVARI(piENV,                IPerlEnv*,  NULL)
-PERLVARI(piStdIO,      IPerlStdIO*, NULL)
-PERLVARI(piLIO,                IPerlLIO*,  NULL)
-PERLVARI(piDir,                IPerlDir*,  NULL)
-PERLVARI(piSock,       IPerlSock*, NULL)
-PERLVARI(piProc,       IPerlProc*, NULL)
+PERLVARI(IMem,         IPerlMem*,  NULL)
+PERLVARI(IEnv,         IPerlEnv*,  NULL)
+PERLVARI(IStdIO,       IPerlStdIO*, NULL)
+PERLVARI(ILIO,         IPerlLIO*,  NULL)
+PERLVARI(IDir,         IPerlDir*,  NULL)
+PERLVARI(ISock,                IPerlSock*, NULL)
+PERLVARI(IProc,                IPerlProc*, NULL)
 #endif
index 2adb321..8d05812 100644 (file)
@@ -203,82 +203,82 @@ struct IPerlStdIOInfo
 #endif
 
 #define PerlIO_stdin()                                                 \
-       (*PL_piStdIO->pStdin)(PL_piStdIO)
+       (*PL_StdIO->pStdin)(PL_StdIO)
 #define PerlIO_stdout()                                                        \
-       (*PL_piStdIO->pStdout)(PL_piStdIO)
+       (*PL_StdIO->pStdout)(PL_StdIO)
 #define PerlIO_stderr()                                                        \
-       (*PL_piStdIO->pStderr)(PL_piStdIO)
+       (*PL_StdIO->pStderr)(PL_StdIO)
 #define PerlIO_open(x,y)                                               \
-       (*PL_piStdIO->pOpen)(PL_piStdIO, (x),(y))
+       (*PL_StdIO->pOpen)(PL_StdIO, (x),(y))
 #define PerlIO_close(f)                                                        \
-       (*PL_piStdIO->pClose)(PL_piStdIO, (f))
+       (*PL_StdIO->pClose)(PL_StdIO, (f))
 #define PerlIO_eof(f)                                                  \
-       (*PL_piStdIO->pEof)(PL_piStdIO, (f))
+       (*PL_StdIO->pEof)(PL_StdIO, (f))
 #define PerlIO_error(f)                                                        \
-       (*PL_piStdIO->pError)(PL_piStdIO, (f))
+       (*PL_StdIO->pError)(PL_StdIO, (f))
 #define PerlIO_clearerr(f)                                             \
-       (*PL_piStdIO->pClearerr)(PL_piStdIO, (f))
+       (*PL_StdIO->pClearerr)(PL_StdIO, (f))
 #define PerlIO_getc(f)                                                 \
-       (*PL_piStdIO->pGetc)(PL_piStdIO, (f))
+       (*PL_StdIO->pGetc)(PL_StdIO, (f))
 #define PerlIO_get_base(f)                                             \
-       (*PL_piStdIO->pGetBase)(PL_piStdIO, (f))
+       (*PL_StdIO->pGetBase)(PL_StdIO, (f))
 #define PerlIO_get_bufsiz(f)                                           \
-       (*PL_piStdIO->pGetBufsiz)(PL_piStdIO, (f))
+       (*PL_StdIO->pGetBufsiz)(PL_StdIO, (f))
 #define PerlIO_get_cnt(f)                                              \
-       (*PL_piStdIO->pGetCnt)(PL_piStdIO, (f))
+       (*PL_StdIO->pGetCnt)(PL_StdIO, (f))
 #define PerlIO_get_ptr(f)                                              \
-       (*PL_piStdIO->pGetPtr)(PL_piStdIO, (f))
+       (*PL_StdIO->pGetPtr)(PL_StdIO, (f))
 #define PerlIO_putc(f,c)                                               \
-       (*PL_piStdIO->pPutc)(PL_piStdIO, (f),(c))
+       (*PL_StdIO->pPutc)(PL_StdIO, (f),(c))
 #define PerlIO_puts(f,s)                                               \
-       (*PL_piStdIO->pPuts)(PL_piStdIO, (f),(s))
+       (*PL_StdIO->pPuts)(PL_StdIO, (f),(s))
 #define PerlIO_flush(f)                                                        \
-       (*PL_piStdIO->pFlush)(PL_piStdIO, (f))
+       (*PL_StdIO->pFlush)(PL_StdIO, (f))
 #define PerlIO_gets(s, n, fp)                                          \
-       (*PL_piStdIO->pGets)(PL_piStdIO, (fp), s, n)
+       (*PL_StdIO->pGets)(PL_StdIO, (fp), s, n)
 #define PerlIO_ungetc(f,c)                                             \
-       (*PL_piStdIO->pUngetc)(PL_piStdIO, (f),(c))
+       (*PL_StdIO->pUngetc)(PL_StdIO, (f),(c))
 #define PerlIO_fileno(f)                                               \
-       (*PL_piStdIO->pFileno)(PL_piStdIO, (f))
+       (*PL_StdIO->pFileno)(PL_StdIO, (f))
 #define PerlIO_fdopen(f, s)                                            \
-       (*PL_piStdIO->pFdopen)(PL_piStdIO, (f),(s))
+       (*PL_StdIO->pFdopen)(PL_StdIO, (f),(s))
 #define PerlIO_reopen(p, m, f)                                         \
-       (*PL_piStdIO->pReopen)(PL_piStdIO, (p), (m), (f))
+       (*PL_StdIO->pReopen)(PL_StdIO, (p), (m), (f))
 #define PerlIO_read(f,buf,count)                                       \
-       (SSize_t)(*PL_piStdIO->pRead)(PL_piStdIO, (f), (buf), (count))
+       (SSize_t)(*PL_StdIO->pRead)(PL_StdIO, (f), (buf), (count))
 #define PerlIO_write(f,buf,count)                                      \
-       (*PL_piStdIO->pWrite)(PL_piStdIO, (f), (buf), (count))
+       (*PL_StdIO->pWrite)(PL_StdIO, (f), (buf), (count))
 #define PerlIO_setbuf(f,b)                                             \
-       (*PL_piStdIO->pSetBuf)(PL_piStdIO, (f), (b))
+       (*PL_StdIO->pSetBuf)(PL_StdIO, (f), (b))
 #define PerlIO_setvbuf(f,b,t,s)                                                \
-       (*PL_piStdIO->pSetVBuf)(PL_piStdIO, (f),(b),(t),(s))
+       (*PL_StdIO->pSetVBuf)(PL_StdIO, (f),(b),(t),(s))
 #define PerlIO_set_cnt(f,c)                                            \
-       (*PL_piStdIO->pSetCnt)(PL_piStdIO, (f), (c))
+       (*PL_StdIO->pSetCnt)(PL_StdIO, (f), (c))
 #define PerlIO_set_ptrcnt(f,p,c)                                       \
-       (*PL_piStdIO->pSetPtrCnt)(PL_piStdIO, (f), (p), (c))
+       (*PL_StdIO->pSetPtrCnt)(PL_StdIO, (f), (p), (c))
 #define PerlIO_setlinebuf(f)                                           \
-       (*PL_piStdIO->pSetlinebuf)(PL_piStdIO, (f))
+       (*PL_StdIO->pSetlinebuf)(PL_StdIO, (f))
 #define PerlIO_printf          fprintf
-#define PerlIO_stdoutf         *PL_piStdIO->pPrintf
+#define PerlIO_stdoutf         *PL_StdIO->pPrintf
 #define PerlIO_vprintf(f,fmt,a)                                                \
-       (*PL_piStdIO->pVprintf)(PL_piStdIO, (f),(fmt),a)          
+       (*PL_StdIO->pVprintf)(PL_StdIO, (f),(fmt),a)          
 #define PerlIO_tell(f)                                                 \
-       (*PL_piStdIO->pTell)(PL_piStdIO, (f))
+       (*PL_StdIO->pTell)(PL_StdIO, (f))
 #define PerlIO_seek(f,o,w)                                             \
-       (*PL_piStdIO->pSeek)(PL_piStdIO, (f),(o),(w))
+       (*PL_StdIO->pSeek)(PL_StdIO, (f),(o),(w))
 #define PerlIO_getpos(f,p)                                             \
-       (*PL_piStdIO->pGetpos)(PL_piStdIO, (f),(p))
+       (*PL_StdIO->pGetpos)(PL_StdIO, (f),(p))
 #define PerlIO_setpos(f,p)                                             \
-       (*PL_piStdIO->pSetpos)(PL_piStdIO, (f),(p))
+       (*PL_StdIO->pSetpos)(PL_StdIO, (f),(p))
 #define PerlIO_rewind(f)                                               \
-       (*PL_piStdIO->pRewind)(PL_piStdIO, (f))
+       (*PL_StdIO->pRewind)(PL_StdIO, (f))
 #define PerlIO_tmpfile()                                               \
-       (*PL_piStdIO->pTmpfile)(PL_piStdIO)
+       (*PL_StdIO->pTmpfile)(PL_StdIO)
 #define PerlIO_init()                                                  \
-       (*PL_piStdIO->pInit)(PL_piStdIO)
+       (*PL_StdIO->pInit)(PL_StdIO)
 #undef         init_os_extras
 #define init_os_extras(x)                                              \
-       (*PL_piStdIO->pInitOSExtras)(PL_piStdIO)
+       (*PL_StdIO->pInitOSExtras)(PL_StdIO)
 
 #else  /* PERL_OBJECT */
 
@@ -500,23 +500,23 @@ struct IPerlDirInfo
 };
 
 #define PerlDir_mkdir(name, mode)                              \
-       (*PL_piDir->pMakedir)(PL_piDir, (name), (mode))
+       (*PL_Dir->pMakedir)(PL_Dir, (name), (mode))
 #define PerlDir_chdir(name)                                    \
-       (*PL_piDir->pChdir)(PL_piDir, (name))
+       (*PL_Dir->pChdir)(PL_Dir, (name))
 #define PerlDir_rmdir(name)                                    \
-       (*PL_piDir->pRmdir)(PL_piDir, (name))
+       (*PL_Dir->pRmdir)(PL_Dir, (name))
 #define PerlDir_close(dir)                                     \
-       (*PL_piDir->pClose)(PL_piDir, (dir))
+       (*PL_Dir->pClose)(PL_Dir, (dir))
 #define PerlDir_open(name)                                     \
-       (*PL_piDir->pOpen)(PL_piDir, (name))
+       (*PL_Dir->pOpen)(PL_Dir, (name))
 #define PerlDir_read(dir)                                      \
-       (*PL_piDir->pRead)(PL_piDir, (dir))
+       (*PL_Dir->pRead)(PL_Dir, (dir))
 #define PerlDir_rewind(dir)                                    \
-       (*PL_piDir->pRewind)(PL_piDir, (dir))
+       (*PL_Dir->pRewind)(PL_Dir, (dir))
 #define PerlDir_seek(dir, loc)                                 \
-       (*PL_piDir->pSeek)(PL_piDir, (dir), (loc))
+       (*PL_Dir->pSeek)(PL_Dir, (dir), (loc))
 #define PerlDir_tell(dir)                                      \
-       (*PL_piDir->pTell)(PL_piDir, (dir))
+       (*PL_Dir->pTell)(PL_Dir, (dir))
 
 #else  /* PERL_OBJECT */
 
@@ -586,20 +586,20 @@ struct IPerlEnvInfo
 };
 
 #define PerlEnv_putenv(str)                                    \
-       (*PL_piENV->pPutenv)(PL_piENV,(str))
+       (*PL_Env->pPutenv)(PL_Env,(str))
 #define PerlEnv_getenv(str)                                    \
-       (*PL_piENV->pGetenv)(PL_piENV,(str))
+       (*PL_Env->pGetenv)(PL_Env,(str))
 #define PerlEnv_getenv_len(str,l)                              \
-       (*PL_piENV->pGetenv_len)(PL_piENV,(str), (l))
+       (*PL_Env->pGetenv_len)(PL_Env,(str), (l))
 #define PerlEnv_Clear()                                                \
-       (*PL_piENV->pClearenv)(PL_piENV)
+       (*PL_Env->pClearenv)(PL_Env)
 #define PerlEnv_Clear()                                                \
-       (*PL_piENV->pClearenv)(PL_piENV)
+       (*PL_Env->pClearenv)(PL_Env)
 #ifdef HAS_ENVGETENV
 #  define PerlEnv_ENVgetenv(str)                               \
-       (*PL_piENV->pENVGetenv)(PL_piENV,(str))
+       (*PL_Env->pENVGetenv)(PL_Env,(str))
 #  define PerlEnv_ENVgetenv_len(str,l)                         \
-       (*PL_piENV->pENVGetenv_len)(PL_piENV,(str), (l))
+       (*PL_Env->pENVGetenv_len)(PL_Env,(str), (l))
 #else
 #  define PerlEnv_ENVgetenv(str)                               \
        PerlEnv_getenv((str))
@@ -607,14 +607,14 @@ struct IPerlEnvInfo
        PerlEnv_getenv_len((str),(l))
 #endif
 #define PerlEnv_uname(name)                                    \
-       (*PL_piENV->pEnvUname)(PL_piENV,(name))
+       (*PL_Env->pEnvUname)(PL_Env,(name))
 #ifdef WIN32
 #define PerlEnv_os_id()                                                \
-       (*PL_piENV->pEnvOsID)(PL_piENV)
+       (*PL_Env->pEnvOsID)(PL_Env)
 #define PerlEnv_lib_path(str)                                  \
-       (*PL_piENV->pLibPath)(PL_piENV,(str))
+       (*PL_Env->pLibPath)(PL_Env,(str))
 #define PerlEnv_sitelib_path(str)                              \
-       (*PL_piENV->pSiteLibPath)(PL_piENV,(str))
+       (*PL_Env->pSiteLibPath)(PL_Env,(str))
 #endif
 
 #else  /* PERL_OBJECT */
@@ -713,55 +713,55 @@ struct IPerlLIOInfo
 };
 
 #define PerlLIO_access(file, mode)                                     \
-       (*PL_piLIO->pAccess)(PL_piLIO, (file), (mode))
+       (*PL_LIO->pAccess)(PL_LIO, (file), (mode))
 #define PerlLIO_chmod(file, mode)                                      \
-       (*PL_piLIO->pChmod)(PL_piLIO, (file), (mode))
+       (*PL_LIO->pChmod)(PL_LIO, (file), (mode))
 #define PerlLIO_chown(file, owner, group)                              \
-       (*PL_piLIO->pChown)(PL_piLIO, (file), (owner), (group))
+       (*PL_LIO->pChown)(PL_LIO, (file), (owner), (group))
 #define PerlLIO_chsize(fd, size)                                       \
-       (*PL_piLIO->pChsize)(PL_piLIO, (fd), (size))
+       (*PL_LIO->pChsize)(PL_LIO, (fd), (size))
 #define PerlLIO_close(fd)                                              \
-       (*PL_piLIO->pClose)(PL_piLIO, (fd))
+       (*PL_LIO->pClose)(PL_LIO, (fd))
 #define PerlLIO_dup(fd)                                                        \
-       (*PL_piLIO->pDup)(PL_piLIO, (fd))
+       (*PL_LIO->pDup)(PL_LIO, (fd))
 #define PerlLIO_dup2(fd1, fd2)                                         \
-       (*PL_piLIO->pDup2)(PL_piLIO, (fd1), (fd2))
+       (*PL_LIO->pDup2)(PL_LIO, (fd1), (fd2))
 #define PerlLIO_flock(fd, op)                                          \
-       (*PL_piLIO->pFlock)(PL_piLIO, (fd), (op))
+       (*PL_LIO->pFlock)(PL_LIO, (fd), (op))
 #define PerlLIO_fstat(fd, buf)                                         \
-       (*PL_piLIO->pFileStat)(PL_piLIO, (fd), (buf))
+       (*PL_LIO->pFileStat)(PL_LIO, (fd), (buf))
 #define PerlLIO_ioctl(fd, u, buf)                                      \
-       (*PL_piLIO->pIOCtl)(PL_piLIO, (fd), (u), (buf))
+       (*PL_LIO->pIOCtl)(PL_LIO, (fd), (u), (buf))
 #define PerlLIO_isatty(fd)                                             \
-       (*PL_piLIO->pIsatty)(PL_piLIO, (fd))
+       (*PL_LIO->pIsatty)(PL_LIO, (fd))
 #define PerlLIO_lseek(fd, offset, mode)                                        \
-       (*PL_piLIO->pLseek)(PL_piLIO, (fd), (offset), (mode))
+       (*PL_LIO->pLseek)(PL_LIO, (fd), (offset), (mode))
 #define PerlLIO_lstat(name, buf)                                       \
-       (*PL_piLIO->pLstat)(PL_piLIO, (name), (buf))
+       (*PL_LIO->pLstat)(PL_LIO, (name), (buf))
 #define PerlLIO_mktemp(file)                                           \
-       (*PL_piLIO->pMktemp)(PL_piLIO, (file))
+       (*PL_LIO->pMktemp)(PL_LIO, (file))
 #define PerlLIO_open(file, flag)                                       \
-       (*PL_piLIO->pOpen)(PL_piLIO, (file), (flag))
+       (*PL_LIO->pOpen)(PL_LIO, (file), (flag))
 #define PerlLIO_open3(file, flag, perm)                                        \
-       (*PL_piLIO->pOpen3)(PL_piLIO, (file), (flag), (perm))
+       (*PL_LIO->pOpen3)(PL_LIO, (file), (flag), (perm))
 #define PerlLIO_read(fd, buf, count)                                   \
-       (*PL_piLIO->pRead)(PL_piLIO, (fd), (buf), (count))
+       (*PL_LIO->pRead)(PL_LIO, (fd), (buf), (count))
 #define PerlLIO_rename(oname, newname)                                 \
-       (*PL_piLIO->pRename)(PL_piLIO, (oname), (newname))
+       (*PL_LIO->pRename)(PL_LIO, (oname), (newname))
 #define PerlLIO_setmode(fd, mode)                                      \
-       (*PL_piLIO->pSetmode)(PL_piLIO, (fd), (mode))
+       (*PL_LIO->pSetmode)(PL_LIO, (fd), (mode))
 #define PerlLIO_stat(name, buf)                                                \
-       (*PL_piLIO->pNameStat)(PL_piLIO, (name), (buf))
+       (*PL_LIO->pNameStat)(PL_LIO, (name), (buf))
 #define PerlLIO_tmpnam(str)                                            \
-       (*PL_piLIO->pTmpnam)(PL_piLIO, (str))
+       (*PL_LIO->pTmpnam)(PL_LIO, (str))
 #define PerlLIO_umask(mode)                                            \
-       (*PL_piLIO->pUmask)(PL_piLIO, (mode))
+       (*PL_LIO->pUmask)(PL_LIO, (mode))
 #define PerlLIO_unlink(file)                                           \
-       (*PL_piLIO->pUnlink)(PL_piLIO, (file))
+       (*PL_LIO->pUnlink)(PL_LIO, (file))
 #define PerlLIO_utime(file, time)                                      \
-       (*PL_piLIO->pUtime)(PL_piLIO, (file), (time))
+       (*PL_LIO->pUtime)(PL_LIO, (file), (time))
 #define PerlLIO_write(fd, buf, count)                                  \
-       (*PL_piLIO->pWrite)(PL_piLIO, (fd), (buf), (count))
+       (*PL_LIO->pWrite)(PL_LIO, (fd), (buf), (count))
 
 #else  /* PERL_OBJECT */
 
@@ -824,11 +824,11 @@ struct IPerlMemInfo
 };
 
 #define PerlMem_malloc(size)                               \
-       (*PL_piMem->pMalloc)(PL_piMem, (size))
+       (*PL_Mem->pMalloc)(PL_Mem, (size))
 #define PerlMem_realloc(buf, size)                         \
-       (*PL_piMem->pRealloc)(PL_piMem, (buf), (size))
+       (*PL_Mem->pRealloc)(PL_Mem, (buf), (size))
 #define PerlMem_free(buf)                                  \
-       (*PL_piMem->pFree)(PL_piMem, (buf))
+       (*PL_Mem->pFree)(PL_Mem, (buf))
 
 #else  /* PERL_OBJECT */
 
@@ -941,71 +941,71 @@ struct IPerlProcInfo
 };
 
 #define PerlProc_abort()                                               \
-       (*PL_piProc->pAbort)(PL_piProc)
+       (*PL_Proc->pAbort)(PL_Proc)
 #define PerlProc_crypt(c,s)                                            \
-       (*PL_piProc->pCrypt)(PL_piProc, (c), (s))
+       (*PL_Proc->pCrypt)(PL_Proc, (c), (s))
 #define PerlProc_exit(s)                                               \
-       (*PL_piProc->pExit)(PL_piProc, (s))
+       (*PL_Proc->pExit)(PL_Proc, (s))
 #define PerlProc__exit(s)                                              \
-       (*PL_piProc->p_Exit)(PL_piProc, (s))
+       (*PL_Proc->p_Exit)(PL_Proc, (s))
 #define PerlProc_execl(c, w, x, y, z)                                  \
-       (*PL_piProc->pExecl)(PL_piProc, (c), (w), (x), (y), (z))
+       (*PL_Proc->pExecl)(PL_Proc, (c), (w), (x), (y), (z))
 #define PerlProc_execv(c, a)                                           \
-       (*PL_piProc->pExecv)(PL_piProc, (c), (a))
+       (*PL_Proc->pExecv)(PL_Proc, (c), (a))
 #define PerlProc_execvp(c, a)                                          \
-       (*PL_piProc->pExecvp)(PL_piProc, (c), (a))
+       (*PL_Proc->pExecvp)(PL_Proc, (c), (a))
 #define PerlProc_getuid()                                              \
-       (*PL_piProc->pGetuid)(PL_piProc)
+       (*PL_Proc->pGetuid)(PL_Proc)
 #define PerlProc_geteuid()                                             \
-       (*PL_piProc->pGeteuid)(PL_piProc)
+       (*PL_Proc->pGeteuid)(PL_Proc)
 #define PerlProc_getgid()                                              \
-       (*PL_piProc->pGetgid)(PL_piProc)
+       (*PL_Proc->pGetgid)(PL_Proc)
 #define PerlProc_getegid()                                             \
-       (*PL_piProc->pGetegid)(PL_piProc)
+       (*PL_Proc->pGetegid)(PL_Proc)
 #define PerlProc_getlogin()                                            \
-       (*PL_piProc->pGetlogin)(PL_piProc)
+       (*PL_Proc->pGetlogin)(PL_Proc)
 #define PerlProc_kill(i, a)                                            \
-       (*PL_piProc->pKill)(PL_piProc, (i), (a))
+       (*PL_Proc->pKill)(PL_Proc, (i), (a))
 #define PerlProc_killpg(i, a)                                          \
-       (*PL_piProc->pKillpg)(PL_piProc, (i), (a))
+       (*PL_Proc->pKillpg)(PL_Proc, (i), (a))
 #define PerlProc_pause()                                               \
-       (*PL_piProc->pPauseProc)(PL_piProc)
+       (*PL_Proc->pPauseProc)(PL_Proc)
 #define PerlProc_popen(c, m)                                           \
-       (*PL_piProc->pPopen)(PL_piProc, (c), (m))
+       (*PL_Proc->pPopen)(PL_Proc, (c), (m))
 #define PerlProc_pclose(f)                                             \
-       (*PL_piProc->pPclose)(PL_piProc, (f))
+       (*PL_Proc->pPclose)(PL_Proc, (f))
 #define PerlProc_pipe(fd)                                              \
-       (*PL_piProc->pPipe)(PL_piProc, (fd))
+       (*PL_Proc->pPipe)(PL_Proc, (fd))
 #define PerlProc_setuid(u)                                             \
-       (*PL_piProc->pSetuid)(PL_piProc, (u))
+       (*PL_Proc->pSetuid)(PL_Proc, (u))
 #define PerlProc_setgid(g)                                             \
-       (*PL_piProc->pSetgid)(PL_piProc, (g))
+       (*PL_Proc->pSetgid)(PL_Proc, (g))
 #define PerlProc_sleep(t)                                              \
-       (*PL_piProc->pSleep)(PL_piProc, (t))
+       (*PL_Proc->pSleep)(PL_Proc, (t))
 #define PerlProc_times(t)                                              \
-       (*PL_piProc->pTimes)(PL_piProc, (t))
+       (*PL_Proc->pTimes)(PL_Proc, (t))
 #define PerlProc_wait(t)                                               \
-       (*PL_piProc->pWait)(PL_piProc, (t))
+       (*PL_Proc->pWait)(PL_Proc, (t))
 #define PerlProc_waitpid(p,s,f)                                                \
-       (*PL_piProc->pWaitpid)(PL_piProc, (p), (s), (f))
+       (*PL_Proc->pWaitpid)(PL_Proc, (p), (s), (f))
 #define PerlProc_signal(n, h)                                          \
-       (*PL_piProc->pSignal)(PL_piProc, (n), (h))
+       (*PL_Proc->pSignal)(PL_Proc, (n), (h))
 #define PerlProc_setjmp(b, n) Sigsetjmp((b), (n))
 #define PerlProc_longjmp(b, n) Siglongjmp((b), (n))
 
 #ifdef WIN32
 #define PerlProc_DynaLoad(f)                                           \
-       (*PL_piProc->pDynaLoader)(PL_piProc, (f))
+       (*PL_Proc->pDynaLoader)(PL_Proc, (f))
 #define PerlProc_GetOSError(s,e)                                       \
-       (*PL_piProc->pGetOSError)(PL_piProc, (s), (e))
+       (*PL_Proc->pGetOSError)(PL_Proc, (s), (e))
 #define PerlProc_Cmd(s)                                                        \
-       (*PL_piProc->pDoCmd)(PL_piProc, (s))
+       (*PL_Proc->pDoCmd)(PL_Proc, (s))
 #define do_spawn(s)                                                    \
-       (*PL_piProc->pSpawn)(PL_piProc, (s))
+       (*PL_Proc->pSpawn)(PL_Proc, (s))
 #define do_spawnvp(m, c, a)                                            \
-       (*PL_piProc->pSpawnvp)(PL_piProc, (m), (c), (a))
+       (*PL_Proc->pSpawnvp)(PL_Proc, (m), (c), (a))
 #define PerlProc_aspawn(m,c,a)                                         \
-       (*PL_piProc->pASpawn)(PL_piProc, (m), (c), (a))
+       (*PL_Proc->pASpawn)(PL_Proc, (m), (c), (a))
 #endif
 
 #else  /* PERL_OBJECT */
@@ -1041,7 +1041,7 @@ struct IPerlProcInfo
 
 #ifdef WIN32
 #define PerlProc_DynaLoad(f)                                           \
-       win32_dynaload(aTHX_ const char*filename)
+       win32_dynaload(aTHX_ (f))
 #define PerlProc_GetOSError(s,e)                                       \
        win32_str_os_error(aTHX_ (s), (e))
 #endif
@@ -1174,95 +1174,95 @@ struct IPerlSockInfo
 };
 
 #define PerlSock_htonl(x)                                              \
-       (*PL_piSock->pHtonl)(PL_piSock, x)
+       (*PL_Sock->pHtonl)(PL_Sock, x)
 #define PerlSock_htons(x)                                              \
-       (*PL_piSock->pHtons)(PL_piSock, x)
+       (*PL_Sock->pHtons)(PL_Sock, x)
 #define PerlSock_ntohl(x)                                              \
-       (*PL_piSock->pNtohl)(PL_piSock, x)
+       (*PL_Sock->pNtohl)(PL_Sock, x)
 #define PerlSock_ntohs(x)                                              \
-       (*PL_piSock->pNtohs)(PL_piSock, x)
+       (*PL_Sock->pNtohs)(PL_Sock, x)
 #define PerlSock_accept(s, a, l)                                       \
-       (*PL_piSock->pAccept)(PL_piSock, s, a, l)
+       (*PL_Sock->pAccept)(PL_Sock, s, a, l)
 #define PerlSock_bind(s, n, l)                                         \
-       (*PL_piSock->pBind)(PL_piSock, s, n, l)
+       (*PL_Sock->pBind)(PL_Sock, s, n, l)
 #define PerlSock_connect(s, n, l)                                      \
-       (*PL_piSock->pConnect)(PL_piSock, s, n, l)
+       (*PL_Sock->pConnect)(PL_Sock, s, n, l)
 #define PerlSock_endhostent()                                          \
-       (*PL_piSock->pEndhostent)(PL_piSock)
+       (*PL_Sock->pEndhostent)(PL_Sock)
 #define PerlSock_endnetent()                                           \
-       (*PL_piSock->pEndnetent)(PL_piSock)
+       (*PL_Sock->pEndnetent)(PL_Sock)
 #define PerlSock_endprotoent()                                         \
-       (*PL_piSock->pEndprotoent)(PL_piSock)
+       (*PL_Sock->pEndprotoent)(PL_Sock)
 #define PerlSock_endservent()                                          \
-       (*PL_piSock->pEndservent)(PL_piSock)
+       (*PL_Sock->pEndservent)(PL_Sock)
 #define PerlSock_gethostbyaddr(a, l, t)                                        \
-       (*PL_piSock->pGethostbyaddr)(PL_piSock, a, l, t)
+       (*PL_Sock->pGethostbyaddr)(PL_Sock, a, l, t)
 #define PerlSock_gethostbyname(n)                                      \
-       (*PL_piSock->pGethostbyname)(PL_piSock, n)
+       (*PL_Sock->pGethostbyname)(PL_Sock, n)
 #define PerlSock_gethostent()                                          \
-       (*PL_piSock->pGethostent)(PL_piSock)
+       (*PL_Sock->pGethostent)(PL_Sock)
 #define PerlSock_gethostname(n, l)                                     \
-       (*PL_piSock->pGethostname)(PL_piSock, n, l)
+       (*PL_Sock->pGethostname)(PL_Sock, n, l)
 #define PerlSock_getnetbyaddr(n, t)                                    \
-       (*PL_piSock->pGetnetbyaddr)(PL_piSock, n, t)
+       (*PL_Sock->pGetnetbyaddr)(PL_Sock, n, t)
 #define PerlSock_getnetbyname(c)                                       \
-       (*PL_piSock->pGetnetbyname)(PL_piSock, c)
+       (*PL_Sock->pGetnetbyname)(PL_Sock, c)
 #define PerlSock_getnetent()                                           \
-       (*PL_piSock->pGetnetent)(PL_piSock)
+       (*PL_Sock->pGetnetent)(PL_Sock)
 #define PerlSock_getpeername(s, n, l)                                  \
-       (*PL_piSock->pGetpeername)(PL_piSock, s, n, l)
+       (*PL_Sock->pGetpeername)(PL_Sock, s, n, l)
 #define PerlSock_getprotobyname(n)                                     \
-       (*PL_piSock->pGetprotobyname)(PL_piSock, n)
+       (*PL_Sock->pGetprotobyname)(PL_Sock, n)
 #define PerlSock_getprotobynumber(n)                                   \
-       (*PL_piSock->pGetprotobynumber)(PL_piSock, n)
+       (*PL_Sock->pGetprotobynumber)(PL_Sock, n)
 #define PerlSock_getprotoent()                                         \
-       (*PL_piSock->pGetprotoent)(PL_piSock)
+       (*PL_Sock->pGetprotoent)(PL_Sock)
 #define PerlSock_getservbyname(n, p)                                   \
-       (*PL_piSock->pGetservbyname)(PL_piSock, n, p)
+       (*PL_Sock->pGetservbyname)(PL_Sock, n, p)
 #define PerlSock_getservbyport(port, p)                                        \
-       (*PL_piSock->pGetservbyport)(PL_piSock, port, p)
+       (*PL_Sock->pGetservbyport)(PL_Sock, port, p)
 #define PerlSock_getservent()                                          \
-       (*PL_piSock->pGetservent)(PL_piSock)
+       (*PL_Sock->pGetservent)(PL_Sock)
 #define PerlSock_getsockname(s, n, l)                                  \
-       (*PL_piSock->pGetsockname)(PL_piSock, s, n, l)
+       (*PL_Sock->pGetsockname)(PL_Sock, s, n, l)
 #define PerlSock_getsockopt(s,l,n,v,i)                                 \
-       (*PL_piSock->pGetsockopt)(PL_piSock, s, l, n, v, i)
+       (*PL_Sock->pGetsockopt)(PL_Sock, s, l, n, v, i)
 #define PerlSock_inet_addr(c)                                          \
-       (*PL_piSock->pInetAddr)(PL_piSock, c)
+       (*PL_Sock->pInetAddr)(PL_Sock, c)
 #define PerlSock_inet_ntoa(i)                                          \
-       (*PL_piSock->pInetNtoa)(PL_piSock, i)
+       (*PL_Sock->pInetNtoa)(PL_Sock, i)
 #define PerlSock_listen(s, b)                                          \
-       (*PL_piSock->pListen)(PL_piSock, s, b)
+       (*PL_Sock->pListen)(PL_Sock, s, b)
 #define PerlSock_recv(s, b, l, f)                                      \
-       (*PL_piSock->pRecv)(PL_piSock, s, b, l, f)
+       (*PL_Sock->pRecv)(PL_Sock, s, b, l, f)
 #define PerlSock_recvfrom(s,b,l,f,from,fromlen)                                \
-       (*PL_piSock->pRecvfrom)(PL_piSock, s, b, l, f, from, fromlen)
+       (*PL_Sock->pRecvfrom)(PL_Sock, s, b, l, f, from, fromlen)
 #define PerlSock_select(n, r, w, e, t)                                 \
-       (*PL_piSock->pSelect)(PL_piSock, n, (char*)r, (char*)w, (char*)e, t)
+       (*PL_Sock->pSelect)(PL_Sock, n, (char*)r, (char*)w, (char*)e, t)
 #define PerlSock_send(s, b, l, f)                                      \
-       (*PL_piSock->pSend)(PL_piSock, s, b, l, f)
+       (*PL_Sock->pSend)(PL_Sock, s, b, l, f)
 #define PerlSock_sendto(s, b, l, f, t, tlen)                           \
-       (*PL_piSock->pSendto)(PL_piSock, s, b, l, f, t, tlen)
+       (*PL_Sock->pSendto)(PL_Sock, s, b, l, f, t, tlen)
 #define PerlSock_sethostent(f)                                         \
-       (*PL_piSock->pSethostent)(PL_piSock, f)
+       (*PL_Sock->pSethostent)(PL_Sock, f)
 #define PerlSock_setnetent(f)                                          \
-       (*PL_piSock->pSetnetent)(PL_piSock, f)
+       (*PL_Sock->pSetnetent)(PL_Sock, f)
 #define PerlSock_setprotoent(f)                                                \
-       (*PL_piSock->pSetprotoent)(PL_piSock, f)
+       (*PL_Sock->pSetprotoent)(PL_Sock, f)
 #define PerlSock_setservent(f)                                         \
-       (*PL_piSock->pSetservent)(PL_piSock, f)
+       (*PL_Sock->pSetservent)(PL_Sock, f)
 #define PerlSock_setsockopt(s, l, n, v, len)                           \
-       (*PL_piSock->pSetsockopt)(PL_piSock, s, l, n, v, len)
+       (*PL_Sock->pSetsockopt)(PL_Sock, s, l, n, v, len)
 #define PerlSock_shutdown(s, h)                                                \
-       (*PL_piSock->pShutdown)(PL_piSock, s, h)
+       (*PL_Sock->pShutdown)(PL_Sock, s, h)
 #define PerlSock_socket(a, t, p)                                       \
-       (*PL_piSock->pSocket)(PL_piSock, a, t, p)
+       (*PL_Sock->pSocket)(PL_Sock, a, t, p)
 #define PerlSock_socketpair(a, t, p, f)                                        \
-       (*PL_piSock->pSocketpair)(PL_piSock, a, t, p, f)
+       (*PL_Sock->pSocketpair)(PL_Sock, a, t, p, f)
 
 #ifdef WIN32
 #define        PerlSock_closesocket(s)                                         \
-       (*PL_piSock->pClosesocket)(PL_piSock, s)
+       (*PL_Sock->pClosesocket)(PL_Sock, s)
 #endif
 
 #else  /* PERL_OBJECT */
diff --git a/mg.c b/mg.c
index cc40a29..2b6459f 100644 (file)
--- a/mg.c
+++ b/mg.c
@@ -33,6 +33,9 @@
 #  define VTBL                 *vtbl
 #endif
 
+static void restore_magic(pTHXo_ void *p);
+static void unwind_handler_stack(pTHXo_ void *p);
+
 /*
  * Use the "DESTRUCTOR" scope cleanup to reinstate magic.
  */
@@ -51,7 +54,7 @@ S_save_magic(pTHX_ I32 mgs_ix, SV *sv)
     MGS* mgs;
     assert(SvMAGICAL(sv));
 
-    SAVEDESTRUCTOR(S_restore_magic, (void*)mgs_ix);
+    SAVEDESTRUCTOR(restore_magic, (void*)mgs_ix);
 
     mgs = SSPTR(mgs_ix, MGS*);
     mgs->mgs_sv = sv;
@@ -63,48 +66,6 @@ S_save_magic(pTHX_ I32 mgs_ix, SV *sv)
     SvFLAGS(sv) |= (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT;
 }
 
-STATIC void
-S_restore_magic(pTHX_ void *p)
-{
-    dTHR;
-    MGS* mgs = SSPTR((I32)p, MGS*);
-    SV* sv = mgs->mgs_sv;
-
-    if (!sv)
-        return;
-
-    if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv))
-    {
-       if (mgs->mgs_flags)
-           SvFLAGS(sv) |= mgs->mgs_flags;
-       else
-           mg_magical(sv);
-       if (SvGMAGICAL(sv))
-           SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK|SVf_POK);
-    }
-
-    mgs->mgs_sv = NULL;  /* mark the MGS structure as restored */
-
-    /* If we're still on top of the stack, pop us off.  (That condition
-     * will be satisfied if restore_magic was called explicitly, but *not*
-     * if it's being called via leave_scope.)
-     * The reason for doing this is that otherwise, things like sv_2cv()
-     * may leave alloc gunk on the savestack, and some code
-     * (e.g. sighandler) doesn't expect that...
-     */
-    if (PL_savestack_ix == mgs->mgs_ss_ix)
-    {
-       I32 popval = SSPOPINT;
-        assert(popval == SAVEt_DESTRUCTOR);
-        PL_savestack_ix -= 2;
-       popval = SSPOPINT;
-        assert(popval == SAVEt_ALLOC);
-       popval = SSPOPINT;
-        PL_savestack_ix -= popval;
-    }
-
-}
-
 void
 Perl_mg_magical(pTHX_ SV *sv)
 {
@@ -153,7 +114,7 @@ Perl_mg_get(pTHX_ SV *sv)
            mgp = &SvMAGIC(sv); /* Re-establish pointer after sv_upgrade */
     }
 
-    restore_magic((void*)mgs_ix);
+    restore_magic(aTHXo_ (void*)mgs_ix);
     return 0;
 }
 
@@ -179,7 +140,7 @@ Perl_mg_set(pTHX_ SV *sv)
            (VTBL->svt_set)(aTHX_ sv, mg);
     }
 
-    restore_magic((void*)mgs_ix);
+    restore_magic(aTHXo_ (void*)mgs_ix);
     return 0;
 }
 
@@ -199,7 +160,7 @@ Perl_mg_length(pTHX_ SV *sv)
            save_magic(mgs_ix, sv);
            /* omit MGf_GSKIP -- not changed here */
            len = (VTBL->svt_len)(aTHX_ sv, mg);
-           restore_magic((void*)mgs_ix);
+           restore_magic(aTHXo_ (void*)mgs_ix);
            return len;
        }
     }
@@ -223,7 +184,7 @@ Perl_mg_size(pTHX_ SV *sv)
            save_magic(mgs_ix, sv);
            /* omit MGf_GSKIP -- not changed here */
            len = (VTBL->svt_len)(aTHX_ sv, mg);
-           restore_magic((void*)mgs_ix);
+           restore_magic(aTHXo_ (void*)mgs_ix);
            return len;
        }
     }
@@ -258,7 +219,7 @@ Perl_mg_clear(pTHX_ SV *sv)
            (VTBL->svt_clear)(aTHX_ sv, mg);
     }
 
-    restore_magic((void*)mgs_ix);
+    restore_magic(aTHXo_ (void*)mgs_ix);
     return 0;
 }
 
@@ -2061,19 +2022,6 @@ Perl_whichsig(pTHX_ char *sig)
 
 static SV* sig_sv;
 
-STATIC void
-S_unwind_handler_stack(pTHX_ void *p)
-{
-    dTHR;
-    U32 flags = *(U32*)p;
-
-    if (flags & 1)
-       PL_savestack_ix -= 5; /* Unprotect save in progress. */
-    /* cxstack_ix-- Not needed, die already unwound it. */
-    if (flags & 64)
-       SvREFCNT_dec(sig_sv);
-}
-
 Signal_t
 Perl_sighandler(int sig)
 {
@@ -2106,7 +2054,7 @@ Perl_sighandler(int sig)
     if (flags & 1) {
        PL_savestack_ix += 5;           /* Protect save in progress. */
        o_save_i = PL_savestack_ix;
-       SAVEDESTRUCTOR(S_unwind_handler_stack, (void*)&flags);
+       SAVEDESTRUCTOR(unwind_handler_stack, (void*)&flags);
     }
     if (flags & 4) 
        PL_markstack_ptr++;             /* Protect mark. */
@@ -2167,3 +2115,62 @@ cleanup:
 }
 
 
+#ifdef PERL_OBJECT
+#define NO_XSLOCKS
+#include "XSUB.h"
+#endif
+
+static void
+restore_magic(pTHXo_ void *p)
+{
+    dTHR;
+    MGS* mgs = SSPTR((I32)p, MGS*);
+    SV* sv = mgs->mgs_sv;
+
+    if (!sv)
+        return;
+
+    if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv))
+    {
+       if (mgs->mgs_flags)
+           SvFLAGS(sv) |= mgs->mgs_flags;
+       else
+           mg_magical(sv);
+       if (SvGMAGICAL(sv))
+           SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK|SVf_POK);
+    }
+
+    mgs->mgs_sv = NULL;  /* mark the MGS structure as restored */
+
+    /* If we're still on top of the stack, pop us off.  (That condition
+     * will be satisfied if restore_magic was called explicitly, but *not*
+     * if it's being called via leave_scope.)
+     * The reason for doing this is that otherwise, things like sv_2cv()
+     * may leave alloc gunk on the savestack, and some code
+     * (e.g. sighandler) doesn't expect that...
+     */
+    if (PL_savestack_ix == mgs->mgs_ss_ix)
+    {
+       I32 popval = SSPOPINT;
+        assert(popval == SAVEt_DESTRUCTOR);
+        PL_savestack_ix -= 2;
+       popval = SSPOPINT;
+        assert(popval == SAVEt_ALLOC);
+       popval = SSPOPINT;
+        PL_savestack_ix -= popval;
+    }
+
+}
+
+static void
+unwind_handler_stack(pTHXo_ void *p)
+{
+    dTHR;
+    U32 flags = *(U32*)p;
+
+    if (flags & 1)
+       PL_savestack_ix -= 5; /* Unprotect save in progress. */
+    /* cxstack_ix-- Not needed, die already unwound it. */
+    if (flags & 64)
+       SvREFCNT_dec(sig_sv);
+}
index 11635dd..f7b24f4 100644 (file)
@@ -28,10 +28,12 @@ main(int argc, char **argv, char **env)
 
 #ifdef PERL_GLOBAL_STRUCT
 #define PERLVAR(var,type) /**/
+#define PERLVARA(var,type) /**/
 #define PERLVARI(var,type,init) PL_Vars.var = init;
 #define PERLVARIC(var,type,init) PL_Vars.var = init;
 #include "perlvars.h"
 #undef PERLVAR
+#undef PERLVARA
 #undef PERLVARI
 #undef PERLVARIC
 #endif
index 6f201dc..e741aa4 100644 (file)
--- a/objXSUB.h
+++ b/objXSUB.h
 /* Variables */
 
 #undef  PL_Argv
-#define PL_Argv                        pPerl->PL_Argv
+#define PL_Argv                        (*Perl_IArgv_ptr(pPerl))
 #undef  PL_Cmd
-#define PL_Cmd                 pPerl->PL_Cmd
+#define PL_Cmd                 (*Perl_ICmd_ptr(pPerl))
 #undef  PL_DBcv
-#define PL_DBcv                        pPerl->PL_DBcv
+#define PL_DBcv                        (*Perl_IDBcv_ptr(pPerl))
 #undef  PL_DBgv
-#define PL_DBgv                        pPerl->PL_DBgv
+#define PL_DBgv                        (*Perl_IDBgv_ptr(pPerl))
 #undef  PL_DBline
-#define PL_DBline              pPerl->PL_DBline
+#define PL_DBline              (*Perl_IDBline_ptr(pPerl))
 #undef  PL_DBsignal
-#define PL_DBsignal            pPerl->PL_DBsignal
+#define PL_DBsignal            (*Perl_IDBsignal_ptr(pPerl))
 #undef  PL_DBsingle
-#define PL_DBsingle            pPerl->PL_DBsingle
+#define PL_DBsingle            (*Perl_IDBsingle_ptr(pPerl))
 #undef  PL_DBsub
-#define PL_DBsub               pPerl->PL_DBsub
+#define PL_DBsub               (*Perl_IDBsub_ptr(pPerl))
 #undef  PL_DBtrace
-#define PL_DBtrace             pPerl->PL_DBtrace
-#undef  PL_No
-#define PL_No                  pPerl->PL_No
-#undef  PL_Sv
-#define PL_Sv                  pPerl->PL_Sv
-#undef  PL_Xpv
-#define PL_Xpv                 pPerl->PL_Xpv
-#undef  PL_Yes
-#define PL_Yes                 pPerl->PL_Yes
+#define PL_DBtrace             (*Perl_IDBtrace_ptr(pPerl))
+#undef  PL_Dir
+#define PL_Dir                 (*Perl_IDir_ptr(pPerl))
+#undef  PL_Env
+#define PL_Env                 (*Perl_IEnv_ptr(pPerl))
+#undef  PL_LIO
+#define PL_LIO                 (*Perl_ILIO_ptr(pPerl))
+#undef  PL_Mem
+#define PL_Mem                 (*Perl_IMem_ptr(pPerl))
+#undef  PL_Proc
+#define PL_Proc                        (*Perl_IProc_ptr(pPerl))
+#undef  PL_Sock
+#define PL_Sock                        (*Perl_ISock_ptr(pPerl))
+#undef  PL_StdIO
+#define PL_StdIO               (*Perl_IStdIO_ptr(pPerl))
 #undef  PL_amagic_generation
-#define PL_amagic_generation   pPerl->PL_amagic_generation
+#define PL_amagic_generation   (*Perl_Iamagic_generation_ptr(pPerl))
 #undef  PL_ampergv
-#define PL_ampergv             pPerl->PL_ampergv
+#define PL_ampergv             (*Perl_Iampergv_ptr(pPerl))
 #undef  PL_an
-#define PL_an                  pPerl->PL_an
+#define PL_an                  (*Perl_Ian_ptr(pPerl))
 #undef  PL_archpat_auto
-#define PL_archpat_auto                pPerl->PL_archpat_auto
+#define PL_archpat_auto                (*Perl_Iarchpat_auto_ptr(pPerl))
 #undef  PL_argvgv
-#define PL_argvgv              pPerl->PL_argvgv
+#define PL_argvgv              (*Perl_Iargvgv_ptr(pPerl))
 #undef  PL_argvoutgv
-#define PL_argvoutgv           pPerl->PL_argvoutgv
-#undef  PL_av_fetch_sv
-#define PL_av_fetch_sv         pPerl->PL_av_fetch_sv
+#define PL_argvoutgv           (*Perl_Iargvoutgv_ptr(pPerl))
 #undef  PL_basetime
-#define PL_basetime            pPerl->PL_basetime
+#define PL_basetime            (*Perl_Ibasetime_ptr(pPerl))
 #undef  PL_beginav
-#define PL_beginav             pPerl->PL_beginav
+#define PL_beginav             (*Perl_Ibeginav_ptr(pPerl))
 #undef  PL_bitcount
-#define PL_bitcount            pPerl->PL_bitcount
-#undef  PL_bodytarget
-#define PL_bodytarget          pPerl->PL_bodytarget
-#undef  PL_bostr
-#define PL_bostr               pPerl->PL_bostr
+#define PL_bitcount            (*Perl_Ibitcount_ptr(pPerl))
 #undef  PL_bufend
-#define PL_bufend              pPerl->PL_bufend
+#define PL_bufend              (*Perl_Ibufend_ptr(pPerl))
 #undef  PL_bufptr
-#define PL_bufptr              pPerl->PL_bufptr
+#define PL_bufptr              (*Perl_Ibufptr_ptr(pPerl))
 #undef  PL_cddir
-#define PL_cddir               pPerl->PL_cddir
-#undef  PL_chopset
-#define PL_chopset             pPerl->PL_chopset
+#define PL_cddir               (*Perl_Icddir_ptr(pPerl))
 #undef  PL_collation_ix
-#define PL_collation_ix                pPerl->PL_collation_ix
+#define PL_collation_ix                (*Perl_Icollation_ix_ptr(pPerl))
 #undef  PL_collation_name
-#define PL_collation_name      pPerl->PL_collation_name
+#define PL_collation_name      (*Perl_Icollation_name_ptr(pPerl))
 #undef  PL_collation_standard
-#define PL_collation_standard  pPerl->PL_collation_standard
+#define PL_collation_standard  (*Perl_Icollation_standard_ptr(pPerl))
 #undef  PL_collxfrm_base
-#define PL_collxfrm_base       pPerl->PL_collxfrm_base
+#define PL_collxfrm_base       (*Perl_Icollxfrm_base_ptr(pPerl))
 #undef  PL_collxfrm_mult
-#define PL_collxfrm_mult       pPerl->PL_collxfrm_mult
-#undef  PL_colors
-#define PL_colors              pPerl->PL_colors
-#undef  PL_colorset
-#define PL_colorset            pPerl->PL_colorset
+#define PL_collxfrm_mult       (*Perl_Icollxfrm_mult_ptr(pPerl))
 #undef  PL_compcv
-#define PL_compcv              pPerl->PL_compcv
+#define PL_compcv              (*Perl_Icompcv_ptr(pPerl))
 #undef  PL_compiling
-#define PL_compiling           pPerl->PL_compiling
+#define PL_compiling           (*Perl_Icompiling_ptr(pPerl))
 #undef  PL_comppad
-#define PL_comppad             pPerl->PL_comppad
+#define PL_comppad             (*Perl_Icomppad_ptr(pPerl))
 #undef  PL_comppad_name
-#define PL_comppad_name                pPerl->PL_comppad_name
+#define PL_comppad_name                (*Perl_Icomppad_name_ptr(pPerl))
 #undef  PL_comppad_name_fill
-#define PL_comppad_name_fill   pPerl->PL_comppad_name_fill
+#define PL_comppad_name_fill   (*Perl_Icomppad_name_fill_ptr(pPerl))
 #undef  PL_comppad_name_floor
-#define PL_comppad_name_floor  pPerl->PL_comppad_name_floor
+#define PL_comppad_name_floor  (*Perl_Icomppad_name_floor_ptr(pPerl))
 #undef  PL_cop_seqmax
-#define PL_cop_seqmax          pPerl->PL_cop_seqmax
+#define PL_cop_seqmax          (*Perl_Icop_seqmax_ptr(pPerl))
 #undef  PL_copline
-#define PL_copline             pPerl->PL_copline
+#define PL_copline             (*Perl_Icopline_ptr(pPerl))
 #undef  PL_cred_mutex
-#define PL_cred_mutex          pPerl->PL_cred_mutex
+#define PL_cred_mutex          (*Perl_Icred_mutex_ptr(pPerl))
 #undef  PL_cryptseen
-#define PL_cryptseen           pPerl->PL_cryptseen
+#define PL_cryptseen           (*Perl_Icryptseen_ptr(pPerl))
 #undef  PL_cshlen
-#define PL_cshlen              pPerl->PL_cshlen
+#define PL_cshlen              (*Perl_Icshlen_ptr(pPerl))
 #undef  PL_cshname
-#define PL_cshname             pPerl->PL_cshname
-#undef  PL_curcop
-#define PL_curcop              pPerl->PL_curcop
+#define PL_cshname             (*Perl_Icshname_ptr(pPerl))
 #undef  PL_curcopdb
-#define PL_curcopdb            pPerl->PL_curcopdb
-#undef  PL_curinterp
-#define PL_curinterp           pPerl->PL_curinterp
-#undef  PL_curpad
-#define PL_curpad              pPerl->PL_curpad
-#undef  PL_curpm
-#define PL_curpm               pPerl->PL_curpm
-#undef  PL_curstack
-#define PL_curstack            pPerl->PL_curstack
-#undef  PL_curstackinfo
-#define PL_curstackinfo                pPerl->PL_curstackinfo
-#undef  PL_curstash
-#define PL_curstash            pPerl->PL_curstash
+#define PL_curcopdb            (*Perl_Icurcopdb_ptr(pPerl))
 #undef  PL_curstname
-#define PL_curstname           pPerl->PL_curstname
+#define PL_curstname           (*Perl_Icurstname_ptr(pPerl))
 #undef  PL_curthr
-#define PL_curthr              pPerl->PL_curthr
+#define PL_curthr              (*Perl_Icurthr_ptr(pPerl))
 #undef  PL_dbargs
-#define PL_dbargs              pPerl->PL_dbargs
+#define PL_dbargs              (*Perl_Idbargs_ptr(pPerl))
 #undef  PL_debdelim
-#define PL_debdelim            pPerl->PL_debdelim
+#define PL_debdelim            (*Perl_Idebdelim_ptr(pPerl))
 #undef  PL_debname
-#define PL_debname             pPerl->PL_debname
+#define PL_debname             (*Perl_Idebname_ptr(pPerl))
 #undef  PL_debstash
-#define PL_debstash            pPerl->PL_debstash
+#define PL_debstash            (*Perl_Idebstash_ptr(pPerl))
 #undef  PL_debug
-#define PL_debug               pPerl->PL_debug
+#define PL_debug               (*Perl_Idebug_ptr(pPerl))
 #undef  PL_defgv
-#define PL_defgv               pPerl->PL_defgv
-#undef  PL_defoutgv
-#define PL_defoutgv            pPerl->PL_defoutgv
-#undef  PL_defstash
-#define PL_defstash            pPerl->PL_defstash
-#undef  PL_delaymagic
-#define PL_delaymagic          pPerl->PL_delaymagic
+#define PL_defgv               (*Perl_Idefgv_ptr(pPerl))
 #undef  PL_diehook
-#define PL_diehook             pPerl->PL_diehook
-#undef  PL_dirty
-#define PL_dirty               pPerl->PL_dirty
+#define PL_diehook             (*Perl_Idiehook_ptr(pPerl))
 #undef  PL_dlevel
-#define PL_dlevel              pPerl->PL_dlevel
+#define PL_dlevel              (*Perl_Idlevel_ptr(pPerl))
 #undef  PL_dlmax
-#define PL_dlmax               pPerl->PL_dlmax
-#undef  PL_do_undump
-#define PL_do_undump           pPerl->PL_do_undump
+#define PL_dlmax               (*Perl_Idlmax_ptr(pPerl))
 #undef  PL_doextract
-#define PL_doextract           pPerl->PL_doextract
+#define PL_doextract           (*Perl_Idoextract_ptr(pPerl))
 #undef  PL_doswitches
-#define PL_doswitches          pPerl->PL_doswitches
+#define PL_doswitches          (*Perl_Idoswitches_ptr(pPerl))
 #undef  PL_dowarn
-#define PL_dowarn              pPerl->PL_dowarn
-#undef  PL_dumpindent
-#define PL_dumpindent          pPerl->PL_dumpindent
+#define PL_dowarn              (*Perl_Idowarn_ptr(pPerl))
 #undef  PL_e_script
-#define PL_e_script            pPerl->PL_e_script
+#define PL_e_script            (*Perl_Ie_script_ptr(pPerl))
 #undef  PL_efloatbuf
-#define PL_efloatbuf           pPerl->PL_efloatbuf
+#define PL_efloatbuf           (*Perl_Iefloatbuf_ptr(pPerl))
 #undef  PL_efloatsize
-#define PL_efloatsize          pPerl->PL_efloatsize
+#define PL_efloatsize          (*Perl_Iefloatsize_ptr(pPerl))
 #undef  PL_egid
-#define PL_egid                        pPerl->PL_egid
+#define PL_egid                        (*Perl_Iegid_ptr(pPerl))
 #undef  PL_endav
-#define PL_endav               pPerl->PL_endav
+#define PL_endav               (*Perl_Iendav_ptr(pPerl))
 #undef  PL_envgv
-#define PL_envgv               pPerl->PL_envgv
+#define PL_envgv               (*Perl_Ienvgv_ptr(pPerl))
 #undef  PL_errgv
-#define PL_errgv               pPerl->PL_errgv
+#define PL_errgv               (*Perl_Ierrgv_ptr(pPerl))
 #undef  PL_error_count
-#define PL_error_count         pPerl->PL_error_count
+#define PL_error_count         (*Perl_Ierror_count_ptr(pPerl))
 #undef  PL_euid
-#define PL_euid                        pPerl->PL_euid
+#define PL_euid                        (*Perl_Ieuid_ptr(pPerl))
 #undef  PL_eval_cond
-#define PL_eval_cond           pPerl->PL_eval_cond
+#define PL_eval_cond           (*Perl_Ieval_cond_ptr(pPerl))
 #undef  PL_eval_mutex
-#define PL_eval_mutex          pPerl->PL_eval_mutex
+#define PL_eval_mutex          (*Perl_Ieval_mutex_ptr(pPerl))
 #undef  PL_eval_owner
-#define PL_eval_owner          pPerl->PL_eval_owner
+#define PL_eval_owner          (*Perl_Ieval_owner_ptr(pPerl))
 #undef  PL_eval_root
-#define PL_eval_root           pPerl->PL_eval_root
+#define PL_eval_root           (*Perl_Ieval_root_ptr(pPerl))
 #undef  PL_eval_start
-#define PL_eval_start          pPerl->PL_eval_start
+#define PL_eval_start          (*Perl_Ieval_start_ptr(pPerl))
 #undef  PL_evalseq
-#define PL_evalseq             pPerl->PL_evalseq
+#define PL_evalseq             (*Perl_Ievalseq_ptr(pPerl))
 #undef  PL_exitlist
-#define PL_exitlist            pPerl->PL_exitlist
+#define PL_exitlist            (*Perl_Iexitlist_ptr(pPerl))
 #undef  PL_exitlistlen
-#define PL_exitlistlen         pPerl->PL_exitlistlen
+#define PL_exitlistlen         (*Perl_Iexitlistlen_ptr(pPerl))
 #undef  PL_expect
-#define PL_expect              pPerl->PL_expect
-#undef  PL_extralen
-#define PL_extralen            pPerl->PL_extralen
+#define PL_expect              (*Perl_Iexpect_ptr(pPerl))
 #undef  PL_fdpid
-#define PL_fdpid               pPerl->PL_fdpid
+#define PL_fdpid               (*Perl_Ifdpid_ptr(pPerl))
 #undef  PL_filemode
-#define PL_filemode            pPerl->PL_filemode
+#define PL_filemode            (*Perl_Ifilemode_ptr(pPerl))
 #undef  PL_filter_debug
-#define PL_filter_debug                pPerl->PL_filter_debug
-#undef  PL_firstgv
-#define PL_firstgv             pPerl->PL_firstgv
+#define PL_filter_debug                (*Perl_Ifilter_debug_ptr(pPerl))
 #undef  PL_forkprocess
-#define PL_forkprocess         pPerl->PL_forkprocess
+#define PL_forkprocess         (*Perl_Iforkprocess_ptr(pPerl))
 #undef  PL_formfeed
-#define PL_formfeed            pPerl->PL_formfeed
-#undef  PL_formtarget
-#define PL_formtarget          pPerl->PL_formtarget
+#define PL_formfeed            (*Perl_Iformfeed_ptr(pPerl))
 #undef  PL_generation
-#define PL_generation          pPerl->PL_generation
+#define PL_generation          (*Perl_Igeneration_ptr(pPerl))
 #undef  PL_gensym
-#define PL_gensym              pPerl->PL_gensym
+#define PL_gensym              (*Perl_Igensym_ptr(pPerl))
 #undef  PL_gid
-#define PL_gid                 pPerl->PL_gid
+#define PL_gid                 (*Perl_Igid_ptr(pPerl))
 #undef  PL_glob_index
-#define PL_glob_index          pPerl->PL_glob_index
+#define PL_glob_index          (*Perl_Iglob_index_ptr(pPerl))
 #undef  PL_globalstash
-#define PL_globalstash         pPerl->PL_globalstash
+#define PL_globalstash         (*Perl_Iglobalstash_ptr(pPerl))
 #undef  PL_he_root
-#define PL_he_root             pPerl->PL_he_root
-#undef  PL_hexdigit
-#define PL_hexdigit            pPerl->PL_hexdigit
+#define PL_he_root             (*Perl_Ihe_root_ptr(pPerl))
 #undef  PL_hintgv
-#define PL_hintgv              pPerl->PL_hintgv
+#define PL_hintgv              (*Perl_Ihintgv_ptr(pPerl))
 #undef  PL_hints
-#define PL_hints               pPerl->PL_hints
-#undef  PL_hv_fetch_ent_mh
-#define PL_hv_fetch_ent_mh     pPerl->PL_hv_fetch_ent_mh
-#undef  PL_hv_fetch_sv
-#define PL_hv_fetch_sv         pPerl->PL_hv_fetch_sv
+#define PL_hints               (*Perl_Ihints_ptr(pPerl))
 #undef  PL_in_clean_all
-#define PL_in_clean_all                pPerl->PL_in_clean_all
+#define PL_in_clean_all                (*Perl_Iin_clean_all_ptr(pPerl))
 #undef  PL_in_clean_objs
-#define PL_in_clean_objs       pPerl->PL_in_clean_objs
-#undef  PL_in_eval
-#define PL_in_eval             pPerl->PL_in_eval
+#define PL_in_clean_objs       (*Perl_Iin_clean_objs_ptr(pPerl))
 #undef  PL_in_my
-#define PL_in_my               pPerl->PL_in_my
+#define PL_in_my               (*Perl_Iin_my_ptr(pPerl))
 #undef  PL_in_my_stash
-#define PL_in_my_stash         pPerl->PL_in_my_stash
+#define PL_in_my_stash         (*Perl_Iin_my_stash_ptr(pPerl))
 #undef  PL_incgv
-#define PL_incgv               pPerl->PL_incgv
+#define PL_incgv               (*Perl_Iincgv_ptr(pPerl))
 #undef  PL_initav
-#define PL_initav              pPerl->PL_initav
+#define PL_initav              (*Perl_Iinitav_ptr(pPerl))
 #undef  PL_inplace
-#define PL_inplace             pPerl->PL_inplace
-#undef  PL_last_in_gv
-#define PL_last_in_gv          pPerl->PL_last_in_gv
+#define PL_inplace             (*Perl_Iinplace_ptr(pPerl))
 #undef  PL_last_lop
-#define PL_last_lop            pPerl->PL_last_lop
+#define PL_last_lop            (*Perl_Ilast_lop_ptr(pPerl))
 #undef  PL_last_lop_op
-#define PL_last_lop_op         pPerl->PL_last_lop_op
+#define PL_last_lop_op         (*Perl_Ilast_lop_op_ptr(pPerl))
 #undef  PL_last_swash_hv
-#define PL_last_swash_hv       pPerl->PL_last_swash_hv
+#define PL_last_swash_hv       (*Perl_Ilast_swash_hv_ptr(pPerl))
 #undef  PL_last_swash_key
-#define PL_last_swash_key      pPerl->PL_last_swash_key
+#define PL_last_swash_key      (*Perl_Ilast_swash_key_ptr(pPerl))
 #undef  PL_last_swash_klen
-#define PL_last_swash_klen     pPerl->PL_last_swash_klen
+#define PL_last_swash_klen     (*Perl_Ilast_swash_klen_ptr(pPerl))
 #undef  PL_last_swash_slen
-#define PL_last_swash_slen     pPerl->PL_last_swash_slen
+#define PL_last_swash_slen     (*Perl_Ilast_swash_slen_ptr(pPerl))
 #undef  PL_last_swash_tmps
-#define PL_last_swash_tmps     pPerl->PL_last_swash_tmps
+#define PL_last_swash_tmps     (*Perl_Ilast_swash_tmps_ptr(pPerl))
 #undef  PL_last_uni
-#define PL_last_uni            pPerl->PL_last_uni
+#define PL_last_uni            (*Perl_Ilast_uni_ptr(pPerl))
 #undef  PL_lastfd
-#define PL_lastfd              pPerl->PL_lastfd
-#undef  PL_lastgotoprobe
-#define PL_lastgotoprobe       pPerl->PL_lastgotoprobe
-#undef  PL_lastscream
-#define PL_lastscream          pPerl->PL_lastscream
+#define PL_lastfd              (*Perl_Ilastfd_ptr(pPerl))
 #undef  PL_lastsize
-#define PL_lastsize            pPerl->PL_lastsize
+#define PL_lastsize            (*Perl_Ilastsize_ptr(pPerl))
 #undef  PL_lastspbase
-#define PL_lastspbase          pPerl->PL_lastspbase
+#define PL_lastspbase          (*Perl_Ilastspbase_ptr(pPerl))
 #undef  PL_laststatval
-#define PL_laststatval         pPerl->PL_laststatval
+#define PL_laststatval         (*Perl_Ilaststatval_ptr(pPerl))
 #undef  PL_laststype
-#define PL_laststype           pPerl->PL_laststype
+#define PL_laststype           (*Perl_Ilaststype_ptr(pPerl))
 #undef  PL_leftgv
-#define PL_leftgv              pPerl->PL_leftgv
+#define PL_leftgv              (*Perl_Ileftgv_ptr(pPerl))
 #undef  PL_lex_brackets
-#define PL_lex_brackets                pPerl->PL_lex_brackets
+#define PL_lex_brackets                (*Perl_Ilex_brackets_ptr(pPerl))
 #undef  PL_lex_brackstack
-#define PL_lex_brackstack      pPerl->PL_lex_brackstack
+#define PL_lex_brackstack      (*Perl_Ilex_brackstack_ptr(pPerl))
 #undef  PL_lex_casemods
-#define PL_lex_casemods                pPerl->PL_lex_casemods
+#define PL_lex_casemods                (*Perl_Ilex_casemods_ptr(pPerl))
 #undef  PL_lex_casestack
-#define PL_lex_casestack       pPerl->PL_lex_casestack
+#define PL_lex_casestack       (*Perl_Ilex_casestack_ptr(pPerl))
 #undef  PL_lex_defer
-#define PL_lex_defer           pPerl->PL_lex_defer
+#define PL_lex_defer           (*Perl_Ilex_defer_ptr(pPerl))
 #undef  PL_lex_dojoin
-#define PL_lex_dojoin          pPerl->PL_lex_dojoin
+#define PL_lex_dojoin          (*Perl_Ilex_dojoin_ptr(pPerl))
 #undef  PL_lex_expect
-#define PL_lex_expect          pPerl->PL_lex_expect
+#define PL_lex_expect          (*Perl_Ilex_expect_ptr(pPerl))
 #undef  PL_lex_fakebrack
-#define PL_lex_fakebrack       pPerl->PL_lex_fakebrack
+#define PL_lex_fakebrack       (*Perl_Ilex_fakebrack_ptr(pPerl))
 #undef  PL_lex_formbrack
-#define PL_lex_formbrack       pPerl->PL_lex_formbrack
+#define PL_lex_formbrack       (*Perl_Ilex_formbrack_ptr(pPerl))
 #undef  PL_lex_inpat
-#define PL_lex_inpat           pPerl->PL_lex_inpat
+#define PL_lex_inpat           (*Perl_Ilex_inpat_ptr(pPerl))
 #undef  PL_lex_inwhat
-#define PL_lex_inwhat          pPerl->PL_lex_inwhat
+#define PL_lex_inwhat          (*Perl_Ilex_inwhat_ptr(pPerl))
 #undef  PL_lex_op
-#define PL_lex_op              pPerl->PL_lex_op
+#define PL_lex_op              (*Perl_Ilex_op_ptr(pPerl))
 #undef  PL_lex_repl
-#define PL_lex_repl            pPerl->PL_lex_repl
+#define PL_lex_repl            (*Perl_Ilex_repl_ptr(pPerl))
 #undef  PL_lex_starts
-#define PL_lex_starts          pPerl->PL_lex_starts
+#define PL_lex_starts          (*Perl_Ilex_starts_ptr(pPerl))
 #undef  PL_lex_state
-#define PL_lex_state           pPerl->PL_lex_state
+#define PL_lex_state           (*Perl_Ilex_state_ptr(pPerl))
 #undef  PL_lex_stuff
-#define PL_lex_stuff           pPerl->PL_lex_stuff
+#define PL_lex_stuff           (*Perl_Ilex_stuff_ptr(pPerl))
 #undef  PL_lineary
-#define PL_lineary             pPerl->PL_lineary
+#define PL_lineary             (*Perl_Ilineary_ptr(pPerl))
 #undef  PL_linestart
-#define PL_linestart           pPerl->PL_linestart
+#define PL_linestart           (*Perl_Ilinestart_ptr(pPerl))
 #undef  PL_linestr
-#define PL_linestr             pPerl->PL_linestr
-#undef  PL_localizing
-#define PL_localizing          pPerl->PL_localizing
+#define PL_linestr             (*Perl_Ilinestr_ptr(pPerl))
 #undef  PL_localpatches
-#define PL_localpatches                pPerl->PL_localpatches
+#define PL_localpatches                (*Perl_Ilocalpatches_ptr(pPerl))
 #undef  PL_main_cv
-#define PL_main_cv             pPerl->PL_main_cv
+#define PL_main_cv             (*Perl_Imain_cv_ptr(pPerl))
 #undef  PL_main_root
-#define PL_main_root           pPerl->PL_main_root
+#define PL_main_root           (*Perl_Imain_root_ptr(pPerl))
 #undef  PL_main_start
-#define PL_main_start          pPerl->PL_main_start
-#undef  PL_mainstack
-#define PL_mainstack           pPerl->PL_mainstack
+#define PL_main_start          (*Perl_Imain_start_ptr(pPerl))
 #undef  PL_malloc_mutex
-#define PL_malloc_mutex                pPerl->PL_malloc_mutex
-#undef  PL_markstack
-#define PL_markstack           pPerl->PL_markstack
-#undef  PL_markstack_max
-#define PL_markstack_max       pPerl->PL_markstack_max
-#undef  PL_markstack_ptr
-#define PL_markstack_ptr       pPerl->PL_markstack_ptr
+#define PL_malloc_mutex                (*Perl_Imalloc_mutex_ptr(pPerl))
 #undef  PL_max_intro_pending
-#define PL_max_intro_pending   pPerl->PL_max_intro_pending
+#define PL_max_intro_pending   (*Perl_Imax_intro_pending_ptr(pPerl))
 #undef  PL_maxo
-#define PL_maxo                        pPerl->PL_maxo
-#undef  PL_maxscream
-#define PL_maxscream           pPerl->PL_maxscream
+#define PL_maxo                        (*Perl_Imaxo_ptr(pPerl))
 #undef  PL_maxsysfd
-#define PL_maxsysfd            pPerl->PL_maxsysfd
+#define PL_maxsysfd            (*Perl_Imaxsysfd_ptr(pPerl))
 #undef  PL_mess_sv
-#define PL_mess_sv             pPerl->PL_mess_sv
+#define PL_mess_sv             (*Perl_Imess_sv_ptr(pPerl))
 #undef  PL_min_intro_pending
-#define PL_min_intro_pending   pPerl->PL_min_intro_pending
+#define PL_min_intro_pending   (*Perl_Imin_intro_pending_ptr(pPerl))
 #undef  PL_minus_F
-#define PL_minus_F             pPerl->PL_minus_F
+#define PL_minus_F             (*Perl_Iminus_F_ptr(pPerl))
 #undef  PL_minus_a
-#define PL_minus_a             pPerl->PL_minus_a
+#define PL_minus_a             (*Perl_Iminus_a_ptr(pPerl))
 #undef  PL_minus_c
-#define PL_minus_c             pPerl->PL_minus_c
+#define PL_minus_c             (*Perl_Iminus_c_ptr(pPerl))
 #undef  PL_minus_l
-#define PL_minus_l             pPerl->PL_minus_l
+#define PL_minus_l             (*Perl_Iminus_l_ptr(pPerl))
 #undef  PL_minus_n
-#define PL_minus_n             pPerl->PL_minus_n
+#define PL_minus_n             (*Perl_Iminus_n_ptr(pPerl))
 #undef  PL_minus_p
-#define PL_minus_p             pPerl->PL_minus_p
-#undef  PL_modcount
-#define PL_modcount            pPerl->PL_modcount
+#define PL_minus_p             (*Perl_Iminus_p_ptr(pPerl))
 #undef  PL_modglobal
-#define PL_modglobal           pPerl->PL_modglobal
+#define PL_modglobal           (*Perl_Imodglobal_ptr(pPerl))
 #undef  PL_multi_close
-#define PL_multi_close         pPerl->PL_multi_close
+#define PL_multi_close         (*Perl_Imulti_close_ptr(pPerl))
 #undef  PL_multi_end
-#define PL_multi_end           pPerl->PL_multi_end
+#define PL_multi_end           (*Perl_Imulti_end_ptr(pPerl))
 #undef  PL_multi_open
-#define PL_multi_open          pPerl->PL_multi_open
+#define PL_multi_open          (*Perl_Imulti_open_ptr(pPerl))
 #undef  PL_multi_start
-#define PL_multi_start         pPerl->PL_multi_start
+#define PL_multi_start         (*Perl_Imulti_start_ptr(pPerl))
 #undef  PL_multiline
-#define PL_multiline           pPerl->PL_multiline
+#define PL_multiline           (*Perl_Imultiline_ptr(pPerl))
 #undef  PL_mystrk
-#define PL_mystrk              pPerl->PL_mystrk
-#undef  PL_na
-#define PL_na                  pPerl->PL_na
+#define PL_mystrk              (*Perl_Imystrk_ptr(pPerl))
 #undef  PL_nexttoke
-#define PL_nexttoke            pPerl->PL_nexttoke
+#define PL_nexttoke            (*Perl_Inexttoke_ptr(pPerl))
 #undef  PL_nexttype
-#define PL_nexttype            pPerl->PL_nexttype
+#define PL_nexttype            (*Perl_Inexttype_ptr(pPerl))
 #undef  PL_nextval
-#define PL_nextval             pPerl->PL_nextval
+#define PL_nextval             (*Perl_Inextval_ptr(pPerl))
 #undef  PL_nice_chunk
-#define PL_nice_chunk          pPerl->PL_nice_chunk
+#define PL_nice_chunk          (*Perl_Inice_chunk_ptr(pPerl))
 #undef  PL_nice_chunk_size
-#define PL_nice_chunk_size     pPerl->PL_nice_chunk_size
+#define PL_nice_chunk_size     (*Perl_Inice_chunk_size_ptr(pPerl))
 #undef  PL_nomemok
-#define PL_nomemok             pPerl->PL_nomemok
-#undef  PL_nrs
-#define PL_nrs                 pPerl->PL_nrs
+#define PL_nomemok             (*Perl_Inomemok_ptr(pPerl))
 #undef  PL_nthreads
-#define PL_nthreads            pPerl->PL_nthreads
+#define PL_nthreads            (*Perl_Inthreads_ptr(pPerl))
 #undef  PL_nthreads_cond
-#define PL_nthreads_cond       pPerl->PL_nthreads_cond
+#define PL_nthreads_cond       (*Perl_Inthreads_cond_ptr(pPerl))
 #undef  PL_numeric_local
-#define PL_numeric_local       pPerl->PL_numeric_local
+#define PL_numeric_local       (*Perl_Inumeric_local_ptr(pPerl))
 #undef  PL_numeric_name
-#define PL_numeric_name                pPerl->PL_numeric_name
+#define PL_numeric_name                (*Perl_Inumeric_name_ptr(pPerl))
 #undef  PL_numeric_radix
-#define PL_numeric_radix       pPerl->PL_numeric_radix
+#define PL_numeric_radix       (*Perl_Inumeric_radix_ptr(pPerl))
 #undef  PL_numeric_standard
-#define PL_numeric_standard    pPerl->PL_numeric_standard
+#define PL_numeric_standard    (*Perl_Inumeric_standard_ptr(pPerl))
 #undef  PL_ofmt
-#define PL_ofmt                        pPerl->PL_ofmt
-#undef  PL_ofs
-#define PL_ofs                 pPerl->PL_ofs
-#undef  PL_ofslen
-#define PL_ofslen              pPerl->PL_ofslen
+#define PL_ofmt                        (*Perl_Iofmt_ptr(pPerl))
 #undef  PL_oldbufptr
-#define PL_oldbufptr           pPerl->PL_oldbufptr
+#define PL_oldbufptr           (*Perl_Ioldbufptr_ptr(pPerl))
 #undef  PL_oldlastpm
-#define PL_oldlastpm           pPerl->PL_oldlastpm
+#define PL_oldlastpm           (*Perl_Ioldlastpm_ptr(pPerl))
 #undef  PL_oldname
-#define PL_oldname             pPerl->PL_oldname
+#define PL_oldname             (*Perl_Ioldname_ptr(pPerl))
 #undef  PL_oldoldbufptr
-#define PL_oldoldbufptr                pPerl->PL_oldoldbufptr
-#undef  PL_op
-#define PL_op                  pPerl->PL_op
+#define PL_oldoldbufptr                (*Perl_Ioldoldbufptr_ptr(pPerl))
 #undef  PL_op_mask
-#define PL_op_mask             pPerl->PL_op_mask
+#define PL_op_mask             (*Perl_Iop_mask_ptr(pPerl))
 #undef  PL_op_seqmax
-#define PL_op_seqmax           pPerl->PL_op_seqmax
-#undef  PL_opsave
-#define PL_opsave              pPerl->PL_opsave
+#define PL_op_seqmax           (*Perl_Iop_seqmax_ptr(pPerl))
 #undef  PL_origalen
-#define PL_origalen            pPerl->PL_origalen
+#define PL_origalen            (*Perl_Iorigalen_ptr(pPerl))
 #undef  PL_origargc
-#define PL_origargc            pPerl->PL_origargc
+#define PL_origargc            (*Perl_Iorigargc_ptr(pPerl))
 #undef  PL_origargv
-#define PL_origargv            pPerl->PL_origargv
+#define PL_origargv            (*Perl_Iorigargv_ptr(pPerl))
 #undef  PL_origenviron
-#define PL_origenviron         pPerl->PL_origenviron
+#define PL_origenviron         (*Perl_Iorigenviron_ptr(pPerl))
 #undef  PL_origfilename
-#define PL_origfilename                pPerl->PL_origfilename
+#define PL_origfilename                (*Perl_Iorigfilename_ptr(pPerl))
 #undef  PL_ors
-#define PL_ors                 pPerl->PL_ors
+#define PL_ors                 (*Perl_Iors_ptr(pPerl))
 #undef  PL_orslen
-#define PL_orslen              pPerl->PL_orslen
+#define PL_orslen              (*Perl_Iorslen_ptr(pPerl))
 #undef  PL_osname
-#define PL_osname              pPerl->PL_osname
+#define PL_osname              (*Perl_Iosname_ptr(pPerl))
 #undef  PL_pad_reset_pending
-#define PL_pad_reset_pending   pPerl->PL_pad_reset_pending
+#define PL_pad_reset_pending   (*Perl_Ipad_reset_pending_ptr(pPerl))
 #undef  PL_padix
-#define PL_padix               pPerl->PL_padix
+#define PL_padix               (*Perl_Ipadix_ptr(pPerl))
 #undef  PL_padix_floor
-#define PL_padix_floor         pPerl->PL_padix_floor
+#define PL_padix_floor         (*Perl_Ipadix_floor_ptr(pPerl))
 #undef  PL_parsehook
-#define PL_parsehook           pPerl->PL_parsehook
+#define PL_parsehook           (*Perl_Iparsehook_ptr(pPerl))
 #undef  PL_patchlevel
-#define PL_patchlevel          pPerl->PL_patchlevel
-#undef  PL_patleave
-#define PL_patleave            pPerl->PL_patleave
+#define PL_patchlevel          (*Perl_Ipatchlevel_ptr(pPerl))
 #undef  PL_pending_ident
-#define PL_pending_ident       pPerl->PL_pending_ident
+#define PL_pending_ident       (*Perl_Ipending_ident_ptr(pPerl))
 #undef  PL_perl_destruct_level
-#define PL_perl_destruct_level pPerl->PL_perl_destruct_level
+#define PL_perl_destruct_level (*Perl_Iperl_destruct_level_ptr(pPerl))
 #undef  PL_perldb
-#define PL_perldb              pPerl->PL_perldb
-#undef  PL_piDir
-#define PL_piDir               pPerl->PL_piDir
-#undef  PL_piENV
-#define PL_piENV               pPerl->PL_piENV
-#undef  PL_piLIO
-#define PL_piLIO               pPerl->PL_piLIO
-#undef  PL_piMem
-#define PL_piMem               pPerl->PL_piMem
-#undef  PL_piProc
-#define PL_piProc              pPerl->PL_piProc
-#undef  PL_piSock
-#define PL_piSock              pPerl->PL_piSock
-#undef  PL_piStdIO
-#define PL_piStdIO             pPerl->PL_piStdIO
+#define PL_perldb              (*Perl_Iperldb_ptr(pPerl))
 #undef  PL_pidstatus
-#define PL_pidstatus           pPerl->PL_pidstatus
+#define PL_pidstatus           (*Perl_Ipidstatus_ptr(pPerl))
 #undef  PL_preambleav
-#define PL_preambleav          pPerl->PL_preambleav
+#define PL_preambleav          (*Perl_Ipreambleav_ptr(pPerl))
 #undef  PL_preambled
-#define PL_preambled           pPerl->PL_preambled
+#define PL_preambled           (*Perl_Ipreambled_ptr(pPerl))
 #undef  PL_preprocess
-#define PL_preprocess          pPerl->PL_preprocess
+#define PL_preprocess          (*Perl_Ipreprocess_ptr(pPerl))
 #undef  PL_profiledata
-#define PL_profiledata         pPerl->PL_profiledata
+#define PL_profiledata         (*Perl_Iprofiledata_ptr(pPerl))
+#undef  PL_replgv
+#define PL_replgv              (*Perl_Ireplgv_ptr(pPerl))
+#undef  PL_rightgv
+#define PL_rightgv             (*Perl_Irightgv_ptr(pPerl))
+#undef  PL_rsfp
+#define PL_rsfp                        (*Perl_Irsfp_ptr(pPerl))
+#undef  PL_rsfp_filters
+#define PL_rsfp_filters                (*Perl_Irsfp_filters_ptr(pPerl))
+#undef  PL_runops
+#define PL_runops              (*Perl_Irunops_ptr(pPerl))
+#undef  PL_sawampersand
+#define PL_sawampersand                (*Perl_Isawampersand_ptr(pPerl))
+#undef  PL_sawstudy
+#define PL_sawstudy            (*Perl_Isawstudy_ptr(pPerl))
+#undef  PL_sawvec
+#define PL_sawvec              (*Perl_Isawvec_ptr(pPerl))
+#undef  PL_sh_path
+#define PL_sh_path             (*Perl_Ish_path_ptr(pPerl))
+#undef  PL_siggv
+#define PL_siggv               (*Perl_Isiggv_ptr(pPerl))
+#undef  PL_sighandlerp
+#define PL_sighandlerp         (*Perl_Isighandlerp_ptr(pPerl))
+#undef  PL_splitstr
+#define PL_splitstr            (*Perl_Isplitstr_ptr(pPerl))
+#undef  PL_srand_called
+#define PL_srand_called                (*Perl_Isrand_called_ptr(pPerl))
+#undef  PL_statusvalue
+#define PL_statusvalue         (*Perl_Istatusvalue_ptr(pPerl))
+#undef  PL_statusvalue_vms
+#define PL_statusvalue_vms     (*Perl_Istatusvalue_vms_ptr(pPerl))
+#undef  PL_stdingv
+#define PL_stdingv             (*Perl_Istdingv_ptr(pPerl))
+#undef  PL_strchop
+#define PL_strchop             (*Perl_Istrchop_ptr(pPerl))
+#undef  PL_strtab
+#define PL_strtab              (*Perl_Istrtab_ptr(pPerl))
+#undef  PL_strtab_mutex
+#define PL_strtab_mutex                (*Perl_Istrtab_mutex_ptr(pPerl))
+#undef  PL_sub_generation
+#define PL_sub_generation      (*Perl_Isub_generation_ptr(pPerl))
+#undef  PL_sublex_info
+#define PL_sublex_info         (*Perl_Isublex_info_ptr(pPerl))
+#undef  PL_subline
+#define PL_subline             (*Perl_Isubline_ptr(pPerl))
+#undef  PL_subname
+#define PL_subname             (*Perl_Isubname_ptr(pPerl))
+#undef  PL_sv_arenaroot
+#define PL_sv_arenaroot                (*Perl_Isv_arenaroot_ptr(pPerl))
+#undef  PL_sv_count
+#define PL_sv_count            (*Perl_Isv_count_ptr(pPerl))
+#undef  PL_sv_mutex
+#define PL_sv_mutex            (*Perl_Isv_mutex_ptr(pPerl))
+#undef  PL_sv_no
+#define PL_sv_no               (*Perl_Isv_no_ptr(pPerl))
+#undef  PL_sv_objcount
+#define PL_sv_objcount         (*Perl_Isv_objcount_ptr(pPerl))
+#undef  PL_sv_root
+#define PL_sv_root             (*Perl_Isv_root_ptr(pPerl))
+#undef  PL_sv_undef
+#define PL_sv_undef            (*Perl_Isv_undef_ptr(pPerl))
+#undef  PL_sv_yes
+#define PL_sv_yes              (*Perl_Isv_yes_ptr(pPerl))
+#undef  PL_svref_mutex
+#define PL_svref_mutex         (*Perl_Isvref_mutex_ptr(pPerl))
+#undef  PL_sys_intern
+#define PL_sys_intern          (*Perl_Isys_intern_ptr(pPerl))
+#undef  PL_tainting
+#define PL_tainting            (*Perl_Itainting_ptr(pPerl))
+#undef  PL_thisexpr
+#define PL_thisexpr            (*Perl_Ithisexpr_ptr(pPerl))
+#undef  PL_thr_key
+#define PL_thr_key             (*Perl_Ithr_key_ptr(pPerl))
+#undef  PL_threadnum
+#define PL_threadnum           (*Perl_Ithreadnum_ptr(pPerl))
+#undef  PL_threads_mutex
+#define PL_threads_mutex       (*Perl_Ithreads_mutex_ptr(pPerl))
+#undef  PL_threadsv_names
+#define PL_threadsv_names      (*Perl_Ithreadsv_names_ptr(pPerl))
+#undef  PL_thrsv
+#define PL_thrsv               (*Perl_Ithrsv_ptr(pPerl))
+#undef  PL_tokenbuf
+#define PL_tokenbuf            (*Perl_Itokenbuf_ptr(pPerl))
+#undef  PL_uid
+#define PL_uid                 (*Perl_Iuid_ptr(pPerl))
+#undef  PL_unsafe
+#define PL_unsafe              (*Perl_Iunsafe_ptr(pPerl))
+#undef  PL_utf8_alnum
+#define PL_utf8_alnum          (*Perl_Iutf8_alnum_ptr(pPerl))
+#undef  PL_utf8_alnumc
+#define PL_utf8_alnumc         (*Perl_Iutf8_alnumc_ptr(pPerl))
+#undef  PL_utf8_alpha
+#define PL_utf8_alpha          (*Perl_Iutf8_alpha_ptr(pPerl))
+#undef  PL_utf8_ascii
+#define PL_utf8_ascii          (*Perl_Iutf8_ascii_ptr(pPerl))
+#undef  PL_utf8_cntrl
+#define PL_utf8_cntrl          (*Perl_Iutf8_cntrl_ptr(pPerl))
+#undef  PL_utf8_digit
+#define PL_utf8_digit          (*Perl_Iutf8_digit_ptr(pPerl))
+#undef  PL_utf8_graph
+#define PL_utf8_graph          (*Perl_Iutf8_graph_ptr(pPerl))
+#undef  PL_utf8_lower
+#define PL_utf8_lower          (*Perl_Iutf8_lower_ptr(pPerl))
+#undef  PL_utf8_mark
+#define PL_utf8_mark           (*Perl_Iutf8_mark_ptr(pPerl))
+#undef  PL_utf8_print
+#define PL_utf8_print          (*Perl_Iutf8_print_ptr(pPerl))
+#undef  PL_utf8_punct
+#define PL_utf8_punct          (*Perl_Iutf8_punct_ptr(pPerl))
+#undef  PL_utf8_space
+#define PL_utf8_space          (*Perl_Iutf8_space_ptr(pPerl))
+#undef  PL_utf8_tolower
+#define PL_utf8_tolower                (*Perl_Iutf8_tolower_ptr(pPerl))
+#undef  PL_utf8_totitle
+#define PL_utf8_totitle                (*Perl_Iutf8_totitle_ptr(pPerl))
+#undef  PL_utf8_toupper
+#define PL_utf8_toupper                (*Perl_Iutf8_toupper_ptr(pPerl))
+#undef  PL_utf8_upper
+#define PL_utf8_upper          (*Perl_Iutf8_upper_ptr(pPerl))
+#undef  PL_utf8_xdigit
+#define PL_utf8_xdigit         (*Perl_Iutf8_xdigit_ptr(pPerl))
+#undef  PL_uudmap
+#define PL_uudmap              (*Perl_Iuudmap_ptr(pPerl))
+#undef  PL_warnhook
+#define PL_warnhook            (*Perl_Iwarnhook_ptr(pPerl))
+#undef  PL_xiv_arenaroot
+#define PL_xiv_arenaroot       (*Perl_Ixiv_arenaroot_ptr(pPerl))
+#undef  PL_xiv_root
+#define PL_xiv_root            (*Perl_Ixiv_root_ptr(pPerl))
+#undef  PL_xnv_root
+#define PL_xnv_root            (*Perl_Ixnv_root_ptr(pPerl))
+#undef  PL_xpv_root
+#define PL_xpv_root            (*Perl_Ixpv_root_ptr(pPerl))
+#undef  PL_xrv_root
+#define PL_xrv_root            (*Perl_Ixrv_root_ptr(pPerl))
+#undef  PL_yychar
+#define PL_yychar              (*Perl_Iyychar_ptr(pPerl))
+#undef  PL_yydebug
+#define PL_yydebug             (*Perl_Iyydebug_ptr(pPerl))
+#undef  PL_yyerrflag
+#define PL_yyerrflag           (*Perl_Iyyerrflag_ptr(pPerl))
+#undef  PL_yylval
+#define PL_yylval              (*Perl_Iyylval_ptr(pPerl))
+#undef  PL_yynerrs
+#define PL_yynerrs             (*Perl_Iyynerrs_ptr(pPerl))
+#undef  PL_yyval
+#define PL_yyval               (*Perl_Iyyval_ptr(pPerl))
+#undef  PL_Sv
+#define PL_Sv                  (*Perl_TSv_ptr(pPerl))
+#undef  PL_Xpv
+#define PL_Xpv                 (*Perl_TXpv_ptr(pPerl))
+#undef  PL_av_fetch_sv
+#define PL_av_fetch_sv         (*Perl_Tav_fetch_sv_ptr(pPerl))
+#undef  PL_bodytarget
+#define PL_bodytarget          (*Perl_Tbodytarget_ptr(pPerl))
+#undef  PL_bostr
+#define PL_bostr               (*Perl_Tbostr_ptr(pPerl))
+#undef  PL_chopset
+#define PL_chopset             (*Perl_Tchopset_ptr(pPerl))
+#undef  PL_colors
+#define PL_colors              (*Perl_Tcolors_ptr(pPerl))
+#undef  PL_colorset
+#define PL_colorset            (*Perl_Tcolorset_ptr(pPerl))
+#undef  PL_curcop
+#define PL_curcop              (*Perl_Tcurcop_ptr(pPerl))
+#undef  PL_curpad
+#define PL_curpad              (*Perl_Tcurpad_ptr(pPerl))
+#undef  PL_curpm
+#define PL_curpm               (*Perl_Tcurpm_ptr(pPerl))
+#undef  PL_curstack
+#define PL_curstack            (*Perl_Tcurstack_ptr(pPerl))
+#undef  PL_curstackinfo
+#define PL_curstackinfo                (*Perl_Tcurstackinfo_ptr(pPerl))
+#undef  PL_curstash
+#define PL_curstash            (*Perl_Tcurstash_ptr(pPerl))
+#undef  PL_defoutgv
+#define PL_defoutgv            (*Perl_Tdefoutgv_ptr(pPerl))
+#undef  PL_defstash
+#define PL_defstash            (*Perl_Tdefstash_ptr(pPerl))
+#undef  PL_delaymagic
+#define PL_delaymagic          (*Perl_Tdelaymagic_ptr(pPerl))
+#undef  PL_dirty
+#define PL_dirty               (*Perl_Tdirty_ptr(pPerl))
+#undef  PL_dumpindent
+#define PL_dumpindent          (*Perl_Tdumpindent_ptr(pPerl))
+#undef  PL_extralen
+#define PL_extralen            (*Perl_Textralen_ptr(pPerl))
+#undef  PL_firstgv
+#define PL_firstgv             (*Perl_Tfirstgv_ptr(pPerl))
+#undef  PL_formtarget
+#define PL_formtarget          (*Perl_Tformtarget_ptr(pPerl))
+#undef  PL_hv_fetch_ent_mh
+#define PL_hv_fetch_ent_mh     (*Perl_Thv_fetch_ent_mh_ptr(pPerl))
+#undef  PL_hv_fetch_sv
+#define PL_hv_fetch_sv         (*Perl_Thv_fetch_sv_ptr(pPerl))
+#undef  PL_in_eval
+#define PL_in_eval             (*Perl_Tin_eval_ptr(pPerl))
+#undef  PL_last_in_gv
+#define PL_last_in_gv          (*Perl_Tlast_in_gv_ptr(pPerl))
+#undef  PL_lastgotoprobe
+#define PL_lastgotoprobe       (*Perl_Tlastgotoprobe_ptr(pPerl))
+#undef  PL_lastscream
+#define PL_lastscream          (*Perl_Tlastscream_ptr(pPerl))
+#undef  PL_localizing
+#define PL_localizing          (*Perl_Tlocalizing_ptr(pPerl))
+#undef  PL_mainstack
+#define PL_mainstack           (*Perl_Tmainstack_ptr(pPerl))
+#undef  PL_markstack
+#define PL_markstack           (*Perl_Tmarkstack_ptr(pPerl))
+#undef  PL_markstack_max
+#define PL_markstack_max       (*Perl_Tmarkstack_max_ptr(pPerl))
+#undef  PL_markstack_ptr
+#define PL_markstack_ptr       (*Perl_Tmarkstack_ptr_ptr(pPerl))
+#undef  PL_maxscream
+#define PL_maxscream           (*Perl_Tmaxscream_ptr(pPerl))
+#undef  PL_modcount
+#define PL_modcount            (*Perl_Tmodcount_ptr(pPerl))
+#undef  PL_na
+#define PL_na                  (*Perl_Tna_ptr(pPerl))
+#undef  PL_nrs
+#define PL_nrs                 (*Perl_Tnrs_ptr(pPerl))
+#undef  PL_ofs
+#define PL_ofs                 (*Perl_Tofs_ptr(pPerl))
+#undef  PL_ofslen
+#define PL_ofslen              (*Perl_Tofslen_ptr(pPerl))
+#undef  PL_op
+#define PL_op                  (*Perl_Top_ptr(pPerl))
+#undef  PL_opsave
+#define PL_opsave              (*Perl_Topsave_ptr(pPerl))
 #undef  PL_protect
-#define PL_protect             pPerl->PL_protect
+#define PL_protect             (*Perl_Tprotect_ptr(pPerl))
 #undef  PL_reg_call_cc
-#define PL_reg_call_cc         pPerl->PL_reg_call_cc
+#define PL_reg_call_cc         (*Perl_Treg_call_cc_ptr(pPerl))
 #undef  PL_reg_curpm
-#define PL_reg_curpm           pPerl->PL_reg_curpm
+#define PL_reg_curpm           (*Perl_Treg_curpm_ptr(pPerl))
 #undef  PL_reg_eval_set
-#define PL_reg_eval_set                pPerl->PL_reg_eval_set
+#define PL_reg_eval_set                (*Perl_Treg_eval_set_ptr(pPerl))
 #undef  PL_reg_flags
-#define PL_reg_flags           pPerl->PL_reg_flags
+#define PL_reg_flags           (*Perl_Treg_flags_ptr(pPerl))
 #undef  PL_reg_ganch
-#define PL_reg_ganch           pPerl->PL_reg_ganch
+#define PL_reg_ganch           (*Perl_Treg_ganch_ptr(pPerl))
 #undef  PL_reg_magic
-#define PL_reg_magic           pPerl->PL_reg_magic
+#define PL_reg_magic           (*Perl_Treg_magic_ptr(pPerl))
 #undef  PL_reg_oldcurpm
-#define PL_reg_oldcurpm                pPerl->PL_reg_oldcurpm
+#define PL_reg_oldcurpm                (*Perl_Treg_oldcurpm_ptr(pPerl))
 #undef  PL_reg_oldpos
-#define PL_reg_oldpos          pPerl->PL_reg_oldpos
+#define PL_reg_oldpos          (*Perl_Treg_oldpos_ptr(pPerl))
 #undef  PL_reg_oldsaved
-#define PL_reg_oldsaved                pPerl->PL_reg_oldsaved
+#define PL_reg_oldsaved                (*Perl_Treg_oldsaved_ptr(pPerl))
 #undef  PL_reg_oldsavedlen
-#define PL_reg_oldsavedlen     pPerl->PL_reg_oldsavedlen
+#define PL_reg_oldsavedlen     (*Perl_Treg_oldsavedlen_ptr(pPerl))
 #undef  PL_reg_re
-#define PL_reg_re              pPerl->PL_reg_re
+#define PL_reg_re              (*Perl_Treg_re_ptr(pPerl))
 #undef  PL_reg_start_tmp
-#define PL_reg_start_tmp       pPerl->PL_reg_start_tmp
+#define PL_reg_start_tmp       (*Perl_Treg_start_tmp_ptr(pPerl))
 #undef  PL_reg_start_tmpl
-#define PL_reg_start_tmpl      pPerl->PL_reg_start_tmpl
+#define PL_reg_start_tmpl      (*Perl_Treg_start_tmpl_ptr(pPerl))
 #undef  PL_reg_starttry
-#define PL_reg_starttry                pPerl->PL_reg_starttry
+#define PL_reg_starttry                (*Perl_Treg_starttry_ptr(pPerl))
 #undef  PL_reg_sv
-#define PL_reg_sv              pPerl->PL_reg_sv
+#define PL_reg_sv              (*Perl_Treg_sv_ptr(pPerl))
 #undef  PL_regbol
-#define PL_regbol              pPerl->PL_regbol
+#define PL_regbol              (*Perl_Tregbol_ptr(pPerl))
 #undef  PL_regcc
-#define PL_regcc               pPerl->PL_regcc
+#define PL_regcc               (*Perl_Tregcc_ptr(pPerl))
 #undef  PL_regcode
-#define PL_regcode             pPerl->PL_regcode
+#define PL_regcode             (*Perl_Tregcode_ptr(pPerl))
 #undef  PL_regcomp_parse
-#define PL_regcomp_parse       pPerl->PL_regcomp_parse
+#define PL_regcomp_parse       (*Perl_Tregcomp_parse_ptr(pPerl))
 #undef  PL_regcomp_rx
-#define PL_regcomp_rx          pPerl->PL_regcomp_rx
+#define PL_regcomp_rx          (*Perl_Tregcomp_rx_ptr(pPerl))
 #undef  PL_regcompp
-#define PL_regcompp            pPerl->PL_regcompp
+#define PL_regcompp            (*Perl_Tregcompp_ptr(pPerl))
 #undef  PL_regdata
-#define PL_regdata             pPerl->PL_regdata
+#define PL_regdata             (*Perl_Tregdata_ptr(pPerl))
 #undef  PL_regdummy
-#define PL_regdummy            pPerl->PL_regdummy
+#define PL_regdummy            (*Perl_Tregdummy_ptr(pPerl))
 #undef  PL_regendp
-#define PL_regendp             pPerl->PL_regendp
+#define PL_regendp             (*Perl_Tregendp_ptr(pPerl))
 #undef  PL_regeol
-#define PL_regeol              pPerl->PL_regeol
+#define PL_regeol              (*Perl_Tregeol_ptr(pPerl))
 #undef  PL_regexecp
-#define PL_regexecp            pPerl->PL_regexecp
+#define PL_regexecp            (*Perl_Tregexecp_ptr(pPerl))
 #undef  PL_regflags
-#define PL_regflags            pPerl->PL_regflags
+#define PL_regflags            (*Perl_Tregflags_ptr(pPerl))
 #undef  PL_regfree
-#define PL_regfree             pPerl->PL_regfree
+#define PL_regfree             (*Perl_Tregfree_ptr(pPerl))
 #undef  PL_regindent
-#define PL_regindent           pPerl->PL_regindent
+#define PL_regindent           (*Perl_Tregindent_ptr(pPerl))
 #undef  PL_reginput
-#define PL_reginput            pPerl->PL_reginput
+#define PL_reginput            (*Perl_Treginput_ptr(pPerl))
 #undef  PL_regint_start
-#define PL_regint_start                pPerl->PL_regint_start
+#define PL_regint_start                (*Perl_Tregint_start_ptr(pPerl))
 #undef  PL_regint_string
-#define PL_regint_string       pPerl->PL_regint_string
+#define PL_regint_string       (*Perl_Tregint_string_ptr(pPerl))
 #undef  PL_reginterp_cnt
-#define PL_reginterp_cnt       pPerl->PL_reginterp_cnt
+#define PL_reginterp_cnt       (*Perl_Treginterp_cnt_ptr(pPerl))
 #undef  PL_reglastparen
-#define PL_reglastparen                pPerl->PL_reglastparen
+#define PL_reglastparen                (*Perl_Treglastparen_ptr(pPerl))
 #undef  PL_regnarrate
-#define PL_regnarrate          pPerl->PL_regnarrate
+#define PL_regnarrate          (*Perl_Tregnarrate_ptr(pPerl))
 #undef  PL_regnaughty
-#define PL_regnaughty          pPerl->PL_regnaughty
+#define PL_regnaughty          (*Perl_Tregnaughty_ptr(pPerl))
 #undef  PL_regnpar
-#define PL_regnpar             pPerl->PL_regnpar
+#define PL_regnpar             (*Perl_Tregnpar_ptr(pPerl))
 #undef  PL_regprecomp
-#define PL_regprecomp          pPerl->PL_regprecomp
+#define PL_regprecomp          (*Perl_Tregprecomp_ptr(pPerl))
 #undef  PL_regprev
-#define PL_regprev             pPerl->PL_regprev
+#define PL_regprev             (*Perl_Tregprev_ptr(pPerl))
 #undef  PL_regprogram
-#define PL_regprogram          pPerl->PL_regprogram
+#define PL_regprogram          (*Perl_Tregprogram_ptr(pPerl))
 #undef  PL_regsawback
-#define PL_regsawback          pPerl->PL_regsawback
+#define PL_regsawback          (*Perl_Tregsawback_ptr(pPerl))
 #undef  PL_regseen
-#define PL_regseen             pPerl->PL_regseen
+#define PL_regseen             (*Perl_Tregseen_ptr(pPerl))
 #undef  PL_regsize
-#define PL_regsize             pPerl->PL_regsize
+#define PL_regsize             (*Perl_Tregsize_ptr(pPerl))
 #undef  PL_regstartp
-#define PL_regstartp           pPerl->PL_regstartp
+#define PL_regstartp           (*Perl_Tregstartp_ptr(pPerl))
 #undef  PL_regtill
-#define PL_regtill             pPerl->PL_regtill
+#define PL_regtill             (*Perl_Tregtill_ptr(pPerl))
 #undef  PL_regxend
-#define PL_regxend             pPerl->PL_regxend
-#undef  PL_replgv
-#define PL_replgv              pPerl->PL_replgv
+#define PL_regxend             (*Perl_Tregxend_ptr(pPerl))
 #undef  PL_restartop
-#define PL_restartop           pPerl->PL_restartop
+#define PL_restartop           (*Perl_Trestartop_ptr(pPerl))
 #undef  PL_retstack
-#define PL_retstack            pPerl->PL_retstack
+#define PL_retstack            (*Perl_Tretstack_ptr(pPerl))
 #undef  PL_retstack_ix
-#define PL_retstack_ix         pPerl->PL_retstack_ix
+#define PL_retstack_ix         (*Perl_Tretstack_ix_ptr(pPerl))
 #undef  PL_retstack_max
-#define PL_retstack_max                pPerl->PL_retstack_max
-#undef  PL_rightgv
-#define PL_rightgv             pPerl->PL_rightgv
+#define PL_retstack_max                (*Perl_Tretstack_max_ptr(pPerl))
 #undef  PL_rs
-#define PL_rs                  pPerl->PL_rs
-#undef  PL_rsfp
-#define PL_rsfp                        pPerl->PL_rsfp
-#undef  PL_rsfp_filters
-#define PL_rsfp_filters                pPerl->PL_rsfp_filters
-#undef  PL_runops
-#define PL_runops              pPerl->PL_runops
+#define PL_rs                  (*Perl_Trs_ptr(pPerl))
 #undef  PL_savestack
-#define PL_savestack           pPerl->PL_savestack
+#define PL_savestack           (*Perl_Tsavestack_ptr(pPerl))
 #undef  PL_savestack_ix
-#define PL_savestack_ix                pPerl->PL_savestack_ix
+#define PL_savestack_ix                (*Perl_Tsavestack_ix_ptr(pPerl))
 #undef  PL_savestack_max
-#define PL_savestack_max       pPerl->PL_savestack_max
-#undef  PL_sawampersand
-#define PL_sawampersand                pPerl->PL_sawampersand
-#undef  PL_sawstudy
-#define PL_sawstudy            pPerl->PL_sawstudy
-#undef  PL_sawvec
-#define PL_sawvec              pPerl->PL_sawvec
+#define PL_savestack_max       (*Perl_Tsavestack_max_ptr(pPerl))
 #undef  PL_scopestack
-#define PL_scopestack          pPerl->PL_scopestack
+#define PL_scopestack          (*Perl_Tscopestack_ptr(pPerl))
 #undef  PL_scopestack_ix
-#define PL_scopestack_ix       pPerl->PL_scopestack_ix
+#define PL_scopestack_ix       (*Perl_Tscopestack_ix_ptr(pPerl))
 #undef  PL_scopestack_max
-#define PL_scopestack_max      pPerl->PL_scopestack_max
+#define PL_scopestack_max      (*Perl_Tscopestack_max_ptr(pPerl))
 #undef  PL_screamfirst
-#define PL_screamfirst         pPerl->PL_screamfirst
+#define PL_screamfirst         (*Perl_Tscreamfirst_ptr(pPerl))
 #undef  PL_screamnext
-#define PL_screamnext          pPerl->PL_screamnext
+#define PL_screamnext          (*Perl_Tscreamnext_ptr(pPerl))
 #undef  PL_secondgv
-#define PL_secondgv            pPerl->PL_secondgv
+#define PL_secondgv            (*Perl_Tsecondgv_ptr(pPerl))
 #undef  PL_seen_evals
-#define PL_seen_evals          pPerl->PL_seen_evals
+#define PL_seen_evals          (*Perl_Tseen_evals_ptr(pPerl))
 #undef  PL_seen_zerolen
-#define PL_seen_zerolen                pPerl->PL_seen_zerolen
-#undef  PL_sh_path
-#define PL_sh_path             pPerl->PL_sh_path
-#undef  PL_siggv
-#define PL_siggv               pPerl->PL_siggv
-#undef  PL_sighandlerp
-#define PL_sighandlerp         pPerl->PL_sighandlerp
+#define PL_seen_zerolen                (*Perl_Tseen_zerolen_ptr(pPerl))
 #undef  PL_sortcop
-#define PL_sortcop             pPerl->PL_sortcop
+#define PL_sortcop             (*Perl_Tsortcop_ptr(pPerl))
 #undef  PL_sortcxix
-#define PL_sortcxix            pPerl->PL_sortcxix
+#define PL_sortcxix            (*Perl_Tsortcxix_ptr(pPerl))
 #undef  PL_sortstash
-#define PL_sortstash           pPerl->PL_sortstash
-#undef  PL_splitstr
-#define PL_splitstr            pPerl->PL_splitstr
-#undef  PL_srand_called
-#define PL_srand_called                pPerl->PL_srand_called
+#define PL_sortstash           (*Perl_Tsortstash_ptr(pPerl))
 #undef  PL_stack_base
-#define PL_stack_base          pPerl->PL_stack_base
+#define PL_stack_base          (*Perl_Tstack_base_ptr(pPerl))
 #undef  PL_stack_max
-#define PL_stack_max           pPerl->PL_stack_max
+#define PL_stack_max           (*Perl_Tstack_max_ptr(pPerl))
 #undef  PL_stack_sp
-#define PL_stack_sp            pPerl->PL_stack_sp
+#define PL_stack_sp            (*Perl_Tstack_sp_ptr(pPerl))
 #undef  PL_start_env
-#define PL_start_env           pPerl->PL_start_env
+#define PL_start_env           (*Perl_Tstart_env_ptr(pPerl))
 #undef  PL_statbuf
-#define PL_statbuf             pPerl->PL_statbuf
+#define PL_statbuf             (*Perl_Tstatbuf_ptr(pPerl))
 #undef  PL_statcache
-#define PL_statcache           pPerl->PL_statcache
+#define PL_statcache           (*Perl_Tstatcache_ptr(pPerl))
 #undef  PL_statgv
-#define PL_statgv              pPerl->PL_statgv
+#define PL_statgv              (*Perl_Tstatgv_ptr(pPerl))
 #undef  PL_statname
-#define PL_statname            pPerl->PL_statname
-#undef  PL_statusvalue
-#define PL_statusvalue         pPerl->PL_statusvalue
-#undef  PL_statusvalue_vms
-#define PL_statusvalue_vms     pPerl->PL_statusvalue_vms
-#undef  PL_stdingv
-#define PL_stdingv             pPerl->PL_stdingv
-#undef  PL_strchop
-#define PL_strchop             pPerl->PL_strchop
-#undef  PL_strtab
-#define PL_strtab              pPerl->PL_strtab
-#undef  PL_strtab_mutex
-#define PL_strtab_mutex                pPerl->PL_strtab_mutex
-#undef  PL_sub_generation
-#define PL_sub_generation      pPerl->PL_sub_generation
-#undef  PL_sublex_info
-#define PL_sublex_info         pPerl->PL_sublex_info
-#undef  PL_subline
-#define PL_subline             pPerl->PL_subline
-#undef  PL_subname
-#define PL_subname             pPerl->PL_subname
-#undef  PL_sv_arenaroot
-#define PL_sv_arenaroot                pPerl->PL_sv_arenaroot
-#undef  PL_sv_count
-#define PL_sv_count            pPerl->PL_sv_count
-#undef  PL_sv_mutex
-#define PL_sv_mutex            pPerl->PL_sv_mutex
-#undef  PL_sv_no
-#define PL_sv_no               pPerl->PL_sv_no
-#undef  PL_sv_objcount
-#define PL_sv_objcount         pPerl->PL_sv_objcount
-#undef  PL_sv_root
-#define PL_sv_root             pPerl->PL_sv_root
-#undef  PL_sv_undef
-#define PL_sv_undef            pPerl->PL_sv_undef
-#undef  PL_sv_yes
-#define PL_sv_yes              pPerl->PL_sv_yes
-#undef  PL_svref_mutex
-#define PL_svref_mutex         pPerl->PL_svref_mutex
-#undef  PL_sys_intern
-#define PL_sys_intern          pPerl->PL_sys_intern
+#define PL_statname            (*Perl_Tstatname_ptr(pPerl))
 #undef  PL_tainted
-#define PL_tainted             pPerl->PL_tainted
-#undef  PL_tainting
-#define PL_tainting            pPerl->PL_tainting
-#undef  PL_thisexpr
-#define PL_thisexpr            pPerl->PL_thisexpr
-#undef  PL_thr_key
-#define PL_thr_key             pPerl->PL_thr_key
-#undef  PL_threadnum
-#define PL_threadnum           pPerl->PL_threadnum
-#undef  PL_threads_mutex
-#define PL_threads_mutex       pPerl->PL_threads_mutex
-#undef  PL_threadsv_names
-#define PL_threadsv_names      pPerl->PL_threadsv_names
-#undef  PL_thrsv
-#define PL_thrsv               pPerl->PL_thrsv
+#define PL_tainted             (*Perl_Ttainted_ptr(pPerl))
 #undef  PL_timesbuf
-#define PL_timesbuf            pPerl->PL_timesbuf
+#define PL_timesbuf            (*Perl_Ttimesbuf_ptr(pPerl))
 #undef  PL_tmps_floor
-#define PL_tmps_floor          pPerl->PL_tmps_floor
+#define PL_tmps_floor          (*Perl_Ttmps_floor_ptr(pPerl))
 #undef  PL_tmps_ix
-#define PL_tmps_ix             pPerl->PL_tmps_ix
+#define PL_tmps_ix             (*Perl_Ttmps_ix_ptr(pPerl))
 #undef  PL_tmps_max
-#define PL_tmps_max            pPerl->PL_tmps_max
+#define PL_tmps_max            (*Perl_Ttmps_max_ptr(pPerl))
 #undef  PL_tmps_stack
-#define PL_tmps_stack          pPerl->PL_tmps_stack
-#undef  PL_tokenbuf
-#define PL_tokenbuf            pPerl->PL_tokenbuf
+#define PL_tmps_stack          (*Perl_Ttmps_stack_ptr(pPerl))
 #undef  PL_top_env
-#define PL_top_env             pPerl->PL_top_env
+#define PL_top_env             (*Perl_Ttop_env_ptr(pPerl))
 #undef  PL_toptarget
-#define PL_toptarget           pPerl->PL_toptarget
-#undef  PL_uid
-#define PL_uid                 pPerl->PL_uid
-#undef  PL_unsafe
-#define PL_unsafe              pPerl->PL_unsafe
-#undef  PL_utf8_alnum
-#define PL_utf8_alnum          pPerl->PL_utf8_alnum
-#undef  PL_utf8_alnumc
-#define PL_utf8_alnumc         pPerl->PL_utf8_alnumc
-#undef  PL_utf8_alpha
-#define PL_utf8_alpha          pPerl->PL_utf8_alpha
-#undef  PL_utf8_ascii
-#define PL_utf8_ascii          pPerl->PL_utf8_ascii
-#undef  PL_utf8_cntrl
-#define PL_utf8_cntrl          pPerl->PL_utf8_cntrl
-#undef  PL_utf8_digit
-#define PL_utf8_digit          pPerl->PL_utf8_digit
-#undef  PL_utf8_graph
-#define PL_utf8_graph          pPerl->PL_utf8_graph
-#undef  PL_utf8_lower
-#define PL_utf8_lower          pPerl->PL_utf8_lower
-#undef  PL_utf8_mark
-#define PL_utf8_mark           pPerl->PL_utf8_mark
-#undef  PL_utf8_print
-#define PL_utf8_print          pPerl->PL_utf8_print
-#undef  PL_utf8_punct
-#define PL_utf8_punct          pPerl->PL_utf8_punct
-#undef  PL_utf8_space
-#define PL_utf8_space          pPerl->PL_utf8_space
-#undef  PL_utf8_tolower
-#define PL_utf8_tolower                pPerl->PL_utf8_tolower
-#undef  PL_utf8_totitle
-#define PL_utf8_totitle                pPerl->PL_utf8_totitle
-#undef  PL_utf8_toupper
-#define PL_utf8_toupper                pPerl->PL_utf8_toupper
-#undef  PL_utf8_upper
-#define PL_utf8_upper          pPerl->PL_utf8_upper
-#undef  PL_utf8_xdigit
-#define PL_utf8_xdigit         pPerl->PL_utf8_xdigit
-#undef  PL_uudmap
-#define PL_uudmap              pPerl->PL_uudmap
-#undef  PL_warnhook
-#define PL_warnhook            pPerl->PL_warnhook
+#define PL_toptarget           (*Perl_Ttoptarget_ptr(pPerl))
 #undef  PL_watchaddr
-#define PL_watchaddr           pPerl->PL_watchaddr
+#define PL_watchaddr           (*Perl_Twatchaddr_ptr(pPerl))
 #undef  PL_watchok
-#define PL_watchok             pPerl->PL_watchok
-#undef  PL_xiv_arenaroot
-#define PL_xiv_arenaroot       pPerl->PL_xiv_arenaroot
-#undef  PL_xiv_root
-#define PL_xiv_root            pPerl->PL_xiv_root
-#undef  PL_xnv_root
-#define PL_xnv_root            pPerl->PL_xnv_root
-#undef  PL_xpv_root
-#define PL_xpv_root            pPerl->PL_xpv_root
-#undef  PL_xrv_root
-#define PL_xrv_root            pPerl->PL_xrv_root
-#undef  PL_yychar
-#define PL_yychar              pPerl->PL_yychar
-#undef  PL_yydebug
-#define PL_yydebug             pPerl->PL_yydebug
-#undef  PL_yyerrflag
-#define PL_yyerrflag           pPerl->PL_yyerrflag
-#undef  PL_yylval
-#define PL_yylval              pPerl->PL_yylval
-#undef  PL_yynerrs
-#define PL_yynerrs             pPerl->PL_yynerrs
-#undef  PL_yyval
-#define PL_yyval               pPerl->PL_yyval
+#define PL_watchok             (*Perl_Twatchok_ptr(pPerl))
+#undef  PL_No
+#define PL_No                  (*Perl_GNo_ptr(pPerl))
+#undef  PL_Yes
+#define PL_Yes                 (*Perl_GYes_ptr(pPerl))
+#undef  PL_curinterp
+#define PL_curinterp           (*Perl_Gcurinterp_ptr(pPerl))
+#undef  PL_do_undump
+#define PL_do_undump           (*Perl_Gdo_undump_ptr(pPerl))
+#undef  PL_hexdigit
+#define PL_hexdigit            (*Perl_Ghexdigit_ptr(pPerl))
+#undef  PL_patleave
+#define PL_patleave            (*Perl_Gpatleave_ptr(pPerl))
 
 /* Functions */
 
 #undef  GetVars
 #define GetVars                        Perl_GetVars
 #endif
-#undef  Perl_yydestruct
-#define Perl_yydestruct                pPerl->Perl_yydestruct
-#undef  yydestruct
-#define yydestruct             Perl_yydestruct
 #undef  Perl_runops_standard
 #define Perl_runops_standard   pPerl->Perl_runops_standard
 #undef  runops_standard
 #define Perl_runops_debug      pPerl->Perl_runops_debug
 #undef  runops_debug
 #define runops_debug           Perl_runops_debug
-#if defined(WIN32)
-#if defined(PERL_OBJECT)
-#undef  Perl_ErrorNo
-#define Perl_ErrorNo           pPerl->Perl_ErrorNo
-#undef  ErrorNo
-#define ErrorNo                        Perl_ErrorNo
-#else
-#undef  Perl_ErrorNo
-#define Perl_ErrorNo           pPerl->Perl_ErrorNo
-#undef  ErrorNo
-#define ErrorNo                        Perl_ErrorNo
-#endif
-#endif
 #undef  Perl_sv_catpvf_mg
 #define Perl_sv_catpvf_mg      pPerl->Perl_sv_catpvf_mg
 #undef  sv_catpvf_mg
 #if defined(PERL_IN_PP_CTL_C) || defined(PERL_DECL_PROT)
 #endif
 #if defined(PERL_IN_PP_HOT_C) || defined(PERL_DECL_PROT)
-#  if defined(USE_THREADS)
-#  endif
 #endif
 #if defined(PERL_IN_PP_SYS_C) || defined(PERL_DECL_PROT)
 #  if !defined(HAS_MKDIR) || !defined(HAS_RMDIR)
diff --git a/perl.c b/perl.c
index ee6d20b..b654404 100644 (file)
--- a/perl.c
+++ b/perl.c
@@ -1902,6 +1902,7 @@ S_init_interp(pTHX)
 #else
 #  ifdef MULTIPLICITY
 #    define PERLVAR(var,type)
+#    define PERLVARA(var,n,type)
 #    if defined(PERL_IMPLICIT_CONTEXT)
 #      define PERLVARI(var,type,init)  my_perl->var = init;
 #      define PERLVARIC(var,type,init) my_perl->var = init;
@@ -1914,10 +1915,12 @@ S_init_interp(pTHX)
 #      include "thrdvar.h"
 #    endif
 #    undef PERLVAR
+#    undef PERLVARA
 #    undef PERLVARI
 #    undef PERLVARIC
 #  else
 #    define PERLVAR(var,type)
+#    define PERLVARA(var,n,type)
 #    define PERLVARI(var,type,init)    PL_##var = init;
 #    define PERLVARIC(var,type,init)   PL_##var = init;
 #    include "intrpvar.h"
@@ -1925,6 +1928,7 @@ S_init_interp(pTHX)
 #      include "thrdvar.h"
 #    endif
 #    undef PERLVAR
+#    undef PERLVARA
 #    undef PERLVARI
 #    undef PERLVARIC
 #  endif
@@ -3119,9 +3123,8 @@ S_my_exit_jump(pTHX)
 
 #ifdef PERL_OBJECT
 #define NO_XSLOCKS
-#endif  /* PERL_OBJECT */
-
 #include "XSUB.h"
+#endif
 
 static I32
 read_e_script(pTHXo_ int idx, SV *buf_sv, int maxlen)
diff --git a/perl.h b/perl.h
index 22aa413..68c4940 100644 (file)
--- a/perl.h
+++ b/perl.h
@@ -448,6 +448,19 @@ register struct op *Perl_op asm(stringify(OP_IN_REGISTER));
 
 #define MEM_SIZE Size_t
 
+#if defined(STANDARD_C) && defined(I_STDDEF)
+#   include <stddef.h>
+#   define STRUCT_OFFSET(s,m)  offsetof(s,m)
+#else
+#   define STRUCT_OFFSET(s,m)  (Size_t)(&(((s *)0)->m))
+#endif
+
+#if defined(I_STRING) || defined(__cplusplus)
+#   include <string.h>
+#else
+#   include <strings.h>
+#endif
+
 /* This comes after <stdlib.h> so we don't try to change the standard
  * library prototypes; we'll use our own in proto.h instead. */
 
@@ -478,19 +491,6 @@ Free_t   Perl_mfree (Malloc_t where);
 #  define safefree    safesysfree
 #endif /* MYMALLOC */
 
-#if defined(STANDARD_C) && defined(I_STDDEF)
-#   include <stddef.h>
-#   define STRUCT_OFFSET(s,m)  offsetof(s,m)
-#else
-#   define STRUCT_OFFSET(s,m)  (Size_t)(&(((s *)0)->m))
-#endif
-
-#if defined(I_STRING) || defined(__cplusplus)
-#   include <string.h>
-#else
-#   include <strings.h>
-#endif
-
 #if !defined(HAS_STRCHR) && defined(HAS_INDEX) && !defined(strchr)
 #define strchr index
 #define strrchr rindex
@@ -1609,7 +1609,7 @@ union any {
     I32                any_i32;
     IV         any_iv;
     long       any_long;
-    void       (CPERLscope(*any_dptr)) (pTHX_ void*);
+    void       (*any_dptr) (pTHXo_ void*);
 };
 #endif
 
@@ -2394,9 +2394,20 @@ typedef char* (CPERLscope(*re_intuit_start_t)) (pTHX_ regexp *prog, SV *sv,
 typedef SV*    (CPERLscope(*re_intuit_string_t)) (pTHX_ regexp *prog);
 typedef void   (CPERLscope(*regfree_t)) (pTHX_ struct regexp* r);
 
+#ifdef USE_PURE_BISON
+int Perl_yylex(pTHX_ YYSTYPE *lvalp, int *lcharp);
+#endif
+
+typedef void (*DESTRUCTORFUNC_t) (pTHXo_ void*);
+typedef void (*SVFUNC_t) (pTHXo_ SV*);
+typedef I32  (*SVCOMPARE_t) (pTHXo_ SV*, SV*);
+typedef void (*XSINIT_t) (pTHXo);
+typedef void (*ATEXIT_t) (pTHXo_ void*);
+typedef void (*XSUBADDR_t) (pTHXo_ CV *);
 
 /* Set up PERLVAR macros for populating structs */
 #define PERLVAR(var,type) type var;
+#define PERLVARA(var,n,type) type var[n];
 #define PERLVARI(var,type,init) type var;
 #define PERLVARIC(var,type,init) type var;
 
@@ -2478,6 +2489,7 @@ typedef void *Thread;
 
 /* Done with PERLVAR macros for now ... */
 #undef PERLVAR
+#undef PERLVARA
 #undef PERLVARI
 #undef PERLVARIC
 
@@ -2504,17 +2516,6 @@ typedef void *Thread;
 #  endif
 #endif
 
-#ifdef USE_PURE_BISON
-int Perl_yylex(pTHX_ YYSTYPE *lvalp, int *lcharp);
-#endif
-
-typedef void (CPERLscope(*DESTRUCTORFUNC_t)) (pTHX_ void*);
-typedef void (CPERLscope(*SVFUNC_t)) (pTHX_ SV*);
-typedef I32 (CPERLscope(*SVCOMPARE_t)) (pTHX_ SV*, SV*);
-typedef void (*XSINIT_t) (pTHXo);
-typedef void (*ATEXIT_t) (pTHXo_ void*);
-typedef void (*XSUBADDR_t) (pTHXo_ CV *);
-
 #ifdef PERL_OBJECT
 #define PERL_DECL_PROT
 #define perl_alloc Perl_alloc
@@ -2557,6 +2558,7 @@ VIRTUAL int CPerlObj::do_aspawn (void *vreally, void **vmark, void **vsp);
  */
                          
 #define PERLVAR(var,type) EXT type PL_##var;
+#define PERLVARA(var,n,type) EXT type PL_##var[n];
 #define PERLVARI(var,type,init) EXT type  PL_##var INIT(init);
 #define PERLVARIC(var,type,init) EXTCONST type PL_##var INIT(init);
 
@@ -2587,7 +2589,7 @@ END_EXTERN_C
  * be defined to maintain binary compatibility with PERL_OBJECT
  * for 5.005
  */
-PERLVAR(object_compatibility[30],      char)
+PERLVARA(object_compatibility,30,      char)
 };
 
 #  include "embed.h"
@@ -2607,6 +2609,7 @@ PERLVAR(object_compatibility[30], char)
 #endif  /* PERL_OBJECT */
 
 #undef PERLVAR
+#undef PERLVARA
 #undef PERLVARI
 #undef PERLVARIC
 
diff --git a/perlapi.c b/perlapi.c
new file mode 100755 (executable)
index 0000000..855ed22
--- /dev/null
+++ b/perlapi.c
@@ -0,0 +1,7082 @@
+/* !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+   This file is built by embed.pl from data in embed.pl, pp.sym, intrpvar.h,
+   perlvars.h and thrdvar.h.  Any changes made here will be lost!
+*/
+
+#include "EXTERN.h"
+#include "perl.h"
+#include "perlapi.h"
+
+#if defined(PERL_OBJECT)
+
+/* accessor functions for Perl variables (provides binary compatibility) */
+START_EXTERN_C
+
+#undef PERLVAR
+#undef PERLVARA
+#undef PERLVARI
+#undef PERLVARIC
+#define PERLVAR(v,t)   t* Perl_##v##_ptr(void *p)                      \
+                       { return &(((CPerlObj*)p)->PL_##v); }
+#define PERLVARA(v,n,t)        PL_##v##_t* Perl_##v##_ptr(void *p)             \
+                       { return &(((CPerlObj*)p)->PL_##v); }
+#define PERLVARI(v,t,i)        PERLVAR(v,t)
+#define PERLVARIC(v,t,i) PERLVAR(v,t)
+
+#include "thrdvar.h"
+#include "intrpvar.h"
+#include "perlvars.h"
+
+#undef PERLVAR
+#undef PERLVARA
+#undef PERLVARI
+#undef PERLVARIC
+
+#if defined(PERL_OBJECT)
+#endif
+
+#undef  Perl_amagic_call
+SV*
+Perl_amagic_call(void *pPerl, SV* left, SV* right, int method, int dir)
+{
+    return ((CPerlObj*)pPerl)->Perl_amagic_call(left, right, method, dir);
+}
+
+#undef  Perl_Gv_AMupdate
+bool
+Perl_Gv_AMupdate(void *pPerl, HV* stash)
+{
+    return ((CPerlObj*)pPerl)->Perl_Gv_AMupdate(stash);
+}
+
+#undef  Perl_append_elem
+OP*
+Perl_append_elem(void *pPerl, I32 optype, OP* head, OP* tail)
+{
+    return ((CPerlObj*)pPerl)->Perl_append_elem(optype, head, tail);
+}
+
+#undef  Perl_append_list
+OP*
+Perl_append_list(void *pPerl, I32 optype, LISTOP* first, LISTOP* last)
+{
+    return ((CPerlObj*)pPerl)->Perl_append_list(optype, first, last);
+}
+
+#undef  Perl_apply
+I32
+Perl_apply(void *pPerl, I32 type, SV** mark, SV** sp)
+{
+    return ((CPerlObj*)pPerl)->Perl_apply(type, mark, sp);
+}
+
+#undef  Perl_assertref
+void
+Perl_assertref(void *pPerl, OP* o)
+{
+    ((CPerlObj*)pPerl)->Perl_assertref(o);
+}
+
+#undef  Perl_avhv_exists_ent
+bool
+Perl_avhv_exists_ent(void *pPerl, AV *ar, SV* keysv, U32 hash)
+{
+    return ((CPerlObj*)pPerl)->Perl_avhv_exists_ent(ar, keysv, hash);
+}
+
+#undef  Perl_avhv_fetch_ent
+SV**
+Perl_avhv_fetch_ent(void *pPerl, AV *ar, SV* keysv, I32 lval, U32 hash)
+{
+    return ((CPerlObj*)pPerl)->Perl_avhv_fetch_ent(ar, keysv, lval, hash);
+}
+
+#undef  Perl_avhv_iternext
+HE*
+Perl_avhv_iternext(void *pPerl, AV *ar)
+{
+    return ((CPerlObj*)pPerl)->Perl_avhv_iternext(ar);
+}
+
+#undef  Perl_avhv_iterval
+SV*
+Perl_avhv_iterval(void *pPerl, AV *ar, HE* entry)
+{
+    return ((CPerlObj*)pPerl)->Perl_avhv_iterval(ar, entry);
+}
+
+#undef  Perl_avhv_keys
+HV*
+Perl_avhv_keys(void *pPerl, AV *ar)
+{
+    return ((CPerlObj*)pPerl)->Perl_avhv_keys(ar);
+}
+
+#undef  Perl_av_clear
+void
+Perl_av_clear(void *pPerl, AV* ar)
+{
+    ((CPerlObj*)pPerl)->Perl_av_clear(ar);
+}
+
+#undef  Perl_av_extend
+void
+Perl_av_extend(void *pPerl, AV* ar, I32 key)
+{
+    ((CPerlObj*)pPerl)->Perl_av_extend(ar, key);
+}
+
+#undef  Perl_av_fake
+AV*
+Perl_av_fake(void *pPerl, I32 size, SV** svp)
+{
+    return ((CPerlObj*)pPerl)->Perl_av_fake(size, svp);
+}
+
+#undef  Perl_av_fetch
+SV**
+Perl_av_fetch(void *pPerl, AV* ar, I32 key, I32 lval)
+{
+    return ((CPerlObj*)pPerl)->Perl_av_fetch(ar, key, lval);
+}
+
+#undef  Perl_av_fill
+void
+Perl_av_fill(void *pPerl, AV* ar, I32 fill)
+{
+    ((CPerlObj*)pPerl)->Perl_av_fill(ar, fill);
+}
+
+#undef  Perl_av_len
+I32
+Perl_av_len(void *pPerl, AV* ar)
+{
+    return ((CPerlObj*)pPerl)->Perl_av_len(ar);
+}
+
+#undef  Perl_av_make
+AV*
+Perl_av_make(void *pPerl, I32 size, SV** svp)
+{
+    return ((CPerlObj*)pPerl)->Perl_av_make(size, svp);
+}
+
+#undef  Perl_av_pop
+SV*
+Perl_av_pop(void *pPerl, AV* ar)
+{
+    return ((CPerlObj*)pPerl)->Perl_av_pop(ar);
+}
+
+#undef  Perl_av_push
+void
+Perl_av_push(void *pPerl, AV* ar, SV* val)
+{
+    ((CPerlObj*)pPerl)->Perl_av_push(ar, val);
+}
+
+#undef  Perl_av_reify
+void
+Perl_av_reify(void *pPerl, AV* ar)
+{
+    ((CPerlObj*)pPerl)->Perl_av_reify(ar);
+}
+
+#undef  Perl_av_shift
+SV*
+Perl_av_shift(void *pPerl, AV* ar)
+{
+    return ((CPerlObj*)pPerl)->Perl_av_shift(ar);
+}
+
+#undef  Perl_av_store
+SV**
+Perl_av_store(void *pPerl, AV* ar, I32 key, SV* val)
+{
+    return ((CPerlObj*)pPerl)->Perl_av_store(ar, key, val);
+}
+
+#undef  Perl_av_undef
+void
+Perl_av_undef(void *pPerl, AV* ar)
+{
+    ((CPerlObj*)pPerl)->Perl_av_undef(ar);
+}
+
+#undef  Perl_av_unshift
+void
+Perl_av_unshift(void *pPerl, AV* ar, I32 num)
+{
+    ((CPerlObj*)pPerl)->Perl_av_unshift(ar, num);
+}
+
+#undef  Perl_bind_match
+OP*
+Perl_bind_match(void *pPerl, I32 type, OP* left, OP* pat)
+{
+    return ((CPerlObj*)pPerl)->Perl_bind_match(type, left, pat);
+}
+
+#undef  Perl_block_end
+OP*
+Perl_block_end(void *pPerl, I32 floor, OP* seq)
+{
+    return ((CPerlObj*)pPerl)->Perl_block_end(floor, seq);
+}
+
+#undef  Perl_block_gimme
+I32
+Perl_block_gimme(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_block_gimme();
+}
+
+#undef  Perl_block_start
+int
+Perl_block_start(void *pPerl, int full)
+{
+    return ((CPerlObj*)pPerl)->Perl_block_start(full);
+}
+
+#undef  Perl_boot_core_UNIVERSAL
+void
+Perl_boot_core_UNIVERSAL(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_boot_core_UNIVERSAL();
+}
+
+#undef  Perl_call_list
+void
+Perl_call_list(void *pPerl, I32 oldscope, AV* av_list)
+{
+    ((CPerlObj*)pPerl)->Perl_call_list(oldscope, av_list);
+}
+
+#undef  Perl_cando
+I32
+Perl_cando(void *pPerl, I32 bit, I32 effective, Stat_t* statbufp)
+{
+    return ((CPerlObj*)pPerl)->Perl_cando(bit, effective, statbufp);
+}
+
+#undef  Perl_cast_ulong
+U32
+Perl_cast_ulong(void *pPerl, NV f)
+{
+    return ((CPerlObj*)pPerl)->Perl_cast_ulong(f);
+}
+
+#undef  Perl_cast_i32
+I32
+Perl_cast_i32(void *pPerl, NV f)
+{
+    return ((CPerlObj*)pPerl)->Perl_cast_i32(f);
+}
+
+#undef  Perl_cast_iv
+IV
+Perl_cast_iv(void *pPerl, NV f)
+{
+    return ((CPerlObj*)pPerl)->Perl_cast_iv(f);
+}
+
+#undef  Perl_cast_uv
+UV
+Perl_cast_uv(void *pPerl, NV f)
+{
+    return ((CPerlObj*)pPerl)->Perl_cast_uv(f);
+}
+#if !defined(HAS_TRUNCATE) && !defined(HAS_CHSIZE) && defined(F_FREESP)
+
+#undef  Perl_my_chsize
+I32
+Perl_my_chsize(void *pPerl, int fd, Off_t length)
+{
+    return ((CPerlObj*)pPerl)->Perl_my_chsize(fd, length);
+}
+#endif
+#if defined(USE_THREADS)
+
+#undef  Perl_condpair_magic
+MAGIC*
+Perl_condpair_magic(void *pPerl, SV *sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_condpair_magic(sv);
+}
+#endif
+
+#undef  Perl_convert
+OP*
+Perl_convert(void *pPerl, I32 optype, I32 flags, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_convert(optype, flags, o);
+}
+#if defined(PERL_IMPLICIT_CONTEXT)
+#endif
+
+#undef  Perl_cv_ckproto
+void
+Perl_cv_ckproto(void *pPerl, CV* cv, GV* gv, char* p)
+{
+    ((CPerlObj*)pPerl)->Perl_cv_ckproto(cv, gv, p);
+}
+
+#undef  Perl_cv_clone
+CV*
+Perl_cv_clone(void *pPerl, CV* proto)
+{
+    return ((CPerlObj*)pPerl)->Perl_cv_clone(proto);
+}
+
+#undef  Perl_cv_const_sv
+SV*
+Perl_cv_const_sv(void *pPerl, CV* cv)
+{
+    return ((CPerlObj*)pPerl)->Perl_cv_const_sv(cv);
+}
+
+#undef  Perl_op_const_sv
+SV*
+Perl_op_const_sv(void *pPerl, OP* o, CV* cv)
+{
+    return ((CPerlObj*)pPerl)->Perl_op_const_sv(o, cv);
+}
+
+#undef  Perl_cv_undef
+void
+Perl_cv_undef(void *pPerl, CV* cv)
+{
+    ((CPerlObj*)pPerl)->Perl_cv_undef(cv);
+}
+
+#undef  Perl_cx_dump
+void
+Perl_cx_dump(void *pPerl, PERL_CONTEXT* cs)
+{
+    ((CPerlObj*)pPerl)->Perl_cx_dump(cs);
+}
+
+#undef  Perl_filter_add
+SV*
+Perl_filter_add(void *pPerl, filter_t funcp, SV* datasv)
+{
+    return ((CPerlObj*)pPerl)->Perl_filter_add(funcp, datasv);
+}
+
+#undef  Perl_filter_del
+void
+Perl_filter_del(void *pPerl, filter_t funcp)
+{
+    ((CPerlObj*)pPerl)->Perl_filter_del(funcp);
+}
+
+#undef  Perl_filter_read
+I32
+Perl_filter_read(void *pPerl, int idx, SV* buffer, int maxlen)
+{
+    return ((CPerlObj*)pPerl)->Perl_filter_read(idx, buffer, maxlen);
+}
+
+#undef  Perl_get_op_descs
+char**
+Perl_get_op_descs(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_get_op_descs();
+}
+
+#undef  Perl_get_op_names
+char**
+Perl_get_op_names(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_get_op_names();
+}
+
+#undef  Perl_get_no_modify
+char*
+Perl_get_no_modify(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_get_no_modify();
+}
+
+#undef  Perl_get_opargs
+U32*
+Perl_get_opargs(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_get_opargs();
+}
+
+#undef  Perl_get_ppaddr
+PPADDR_t*
+Perl_get_ppaddr(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_get_ppaddr();
+}
+
+#undef  Perl_cxinc
+I32
+Perl_cxinc(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_cxinc();
+}
+
+#undef  Perl_deb_growlevel
+void
+Perl_deb_growlevel(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_deb_growlevel();
+}
+
+#undef  Perl_debprofdump
+void
+Perl_debprofdump(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_debprofdump();
+}
+
+#undef  Perl_debop
+I32
+Perl_debop(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_debop(o);
+}
+
+#undef  Perl_debstack
+I32
+Perl_debstack(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_debstack();
+}
+
+#undef  Perl_debstackptrs
+I32
+Perl_debstackptrs(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_debstackptrs();
+}
+
+#undef  Perl_delimcpy
+char*
+Perl_delimcpy(void *pPerl, char* to, char* toend, char* from, char* fromend, int delim, I32* retlen)
+{
+    return ((CPerlObj*)pPerl)->Perl_delimcpy(to, toend, from, fromend, delim, retlen);
+}
+
+#undef  Perl_deprecate
+void
+Perl_deprecate(void *pPerl, char* s)
+{
+    ((CPerlObj*)pPerl)->Perl_deprecate(s);
+}
+
+#undef  Perl_die_where
+OP*
+Perl_die_where(void *pPerl, char* message, STRLEN msglen)
+{
+    return ((CPerlObj*)pPerl)->Perl_die_where(message, msglen);
+}
+
+#undef  Perl_dounwind
+void
+Perl_dounwind(void *pPerl, I32 cxix)
+{
+    ((CPerlObj*)pPerl)->Perl_dounwind(cxix);
+}
+
+#undef  Perl_do_aexec
+bool
+Perl_do_aexec(void *pPerl, SV* really, SV** mark, SV** sp)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_aexec(really, mark, sp);
+}
+
+#undef  Perl_do_binmode
+int
+Perl_do_binmode(void *pPerl, PerlIO *fp, int iotype, int flag)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_binmode(fp, iotype, flag);
+}
+
+#undef  Perl_do_chop
+void
+Perl_do_chop(void *pPerl, SV* asv, SV* sv)
+{
+    ((CPerlObj*)pPerl)->Perl_do_chop(asv, sv);
+}
+
+#undef  Perl_do_close
+bool
+Perl_do_close(void *pPerl, GV* gv, bool not_implicit)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_close(gv, not_implicit);
+}
+
+#undef  Perl_do_eof
+bool
+Perl_do_eof(void *pPerl, GV* gv)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_eof(gv);
+}
+
+#undef  Perl_do_exec
+bool
+Perl_do_exec(void *pPerl, char* cmd)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_exec(cmd);
+}
+#if !defined(WIN32)
+
+#undef  Perl_do_exec3
+bool
+Perl_do_exec3(void *pPerl, char* cmd, int fd, int flag)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_exec3(cmd, fd, flag);
+}
+#endif
+
+#undef  Perl_do_execfree
+void
+Perl_do_execfree(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_do_execfree();
+}
+#if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
+
+#undef  Perl_do_ipcctl
+I32
+Perl_do_ipcctl(void *pPerl, I32 optype, SV** mark, SV** sp)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_ipcctl(optype, mark, sp);
+}
+
+#undef  Perl_do_ipcget
+I32
+Perl_do_ipcget(void *pPerl, I32 optype, SV** mark, SV** sp)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_ipcget(optype, mark, sp);
+}
+
+#undef  Perl_do_msgrcv
+I32
+Perl_do_msgrcv(void *pPerl, SV** mark, SV** sp)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_msgrcv(mark, sp);
+}
+
+#undef  Perl_do_msgsnd
+I32
+Perl_do_msgsnd(void *pPerl, SV** mark, SV** sp)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_msgsnd(mark, sp);
+}
+
+#undef  Perl_do_semop
+I32
+Perl_do_semop(void *pPerl, SV** mark, SV** sp)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_semop(mark, sp);
+}
+
+#undef  Perl_do_shmio
+I32
+Perl_do_shmio(void *pPerl, I32 optype, SV** mark, SV** sp)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_shmio(optype, mark, sp);
+}
+#endif
+
+#undef  Perl_do_join
+void
+Perl_do_join(void *pPerl, SV* sv, SV* del, SV** mark, SV** sp)
+{
+    ((CPerlObj*)pPerl)->Perl_do_join(sv, del, mark, sp);
+}
+
+#undef  Perl_do_kv
+OP*
+Perl_do_kv(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_kv();
+}
+
+#undef  Perl_do_open
+bool
+Perl_do_open(void *pPerl, GV* gv, char* name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO* supplied_fp)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_open(gv, name, len, as_raw, rawmode, rawperm, supplied_fp);
+}
+
+#undef  Perl_do_pipe
+void
+Perl_do_pipe(void *pPerl, SV* sv, GV* rgv, GV* wgv)
+{
+    ((CPerlObj*)pPerl)->Perl_do_pipe(sv, rgv, wgv);
+}
+
+#undef  Perl_do_print
+bool
+Perl_do_print(void *pPerl, SV* sv, PerlIO* fp)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_print(sv, fp);
+}
+
+#undef  Perl_do_readline
+OP*
+Perl_do_readline(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_readline();
+}
+
+#undef  Perl_do_chomp
+I32
+Perl_do_chomp(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_chomp(sv);
+}
+
+#undef  Perl_do_seek
+bool
+Perl_do_seek(void *pPerl, GV* gv, Off_t pos, int whence)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_seek(gv, pos, whence);
+}
+
+#undef  Perl_do_sprintf
+void
+Perl_do_sprintf(void *pPerl, SV* sv, I32 len, SV** sarg)
+{
+    ((CPerlObj*)pPerl)->Perl_do_sprintf(sv, len, sarg);
+}
+
+#undef  Perl_do_sysseek
+Off_t
+Perl_do_sysseek(void *pPerl, GV* gv, Off_t pos, int whence)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_sysseek(gv, pos, whence);
+}
+
+#undef  Perl_do_tell
+Off_t
+Perl_do_tell(void *pPerl, GV* gv)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_tell(gv);
+}
+
+#undef  Perl_do_trans
+I32
+Perl_do_trans(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_do_trans(sv);
+}
+
+#undef  Perl_do_vecset
+void
+Perl_do_vecset(void *pPerl, SV* sv)
+{
+    ((CPerlObj*)pPerl)->Perl_do_vecset(sv);
+}
+
+#undef  Perl_do_vop
+void
+Perl_do_vop(void *pPerl, I32 optype, SV* sv, SV* left, SV* right)
+{
+    ((CPerlObj*)pPerl)->Perl_do_vop(optype, sv, left, right);
+}
+
+#undef  Perl_dofile
+OP*
+Perl_dofile(void *pPerl, OP* term)
+{
+    return ((CPerlObj*)pPerl)->Perl_dofile(term);
+}
+
+#undef  Perl_dowantarray
+I32
+Perl_dowantarray(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_dowantarray();
+}
+
+#undef  Perl_dump_all
+void
+Perl_dump_all(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_dump_all();
+}
+
+#undef  Perl_dump_eval
+void
+Perl_dump_eval(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_dump_eval();
+}
+#if defined(DUMP_FDS)
+
+#undef  Perl_dump_fds
+void
+Perl_dump_fds(void *pPerl, char* s)
+{
+    ((CPerlObj*)pPerl)->Perl_dump_fds(s);
+}
+#endif
+
+#undef  Perl_dump_form
+void
+Perl_dump_form(void *pPerl, GV* gv)
+{
+    ((CPerlObj*)pPerl)->Perl_dump_form(gv);
+}
+
+#undef  Perl_gv_dump
+void
+Perl_gv_dump(void *pPerl, GV* gv)
+{
+    ((CPerlObj*)pPerl)->Perl_gv_dump(gv);
+}
+
+#undef  Perl_op_dump
+void
+Perl_op_dump(void *pPerl, OP* arg)
+{
+    ((CPerlObj*)pPerl)->Perl_op_dump(arg);
+}
+
+#undef  Perl_pmop_dump
+void
+Perl_pmop_dump(void *pPerl, PMOP* pm)
+{
+    ((CPerlObj*)pPerl)->Perl_pmop_dump(pm);
+}
+
+#undef  Perl_dump_packsubs
+void
+Perl_dump_packsubs(void *pPerl, HV* stash)
+{
+    ((CPerlObj*)pPerl)->Perl_dump_packsubs(stash);
+}
+
+#undef  Perl_dump_sub
+void
+Perl_dump_sub(void *pPerl, GV* gv)
+{
+    ((CPerlObj*)pPerl)->Perl_dump_sub(gv);
+}
+
+#undef  Perl_fbm_compile
+void
+Perl_fbm_compile(void *pPerl, SV* sv, U32 flags)
+{
+    ((CPerlObj*)pPerl)->Perl_fbm_compile(sv, flags);
+}
+
+#undef  Perl_fbm_instr
+char*
+Perl_fbm_instr(void *pPerl, unsigned char* big, unsigned char* bigend, SV* littlesv, U32 flags)
+{
+    return ((CPerlObj*)pPerl)->Perl_fbm_instr(big, bigend, littlesv, flags);
+}
+
+#undef  Perl_find_script
+char*
+Perl_find_script(void *pPerl, char *scriptname, bool dosearch, char **search_ext, I32 flags)
+{
+    return ((CPerlObj*)pPerl)->Perl_find_script(scriptname, dosearch, search_ext, flags);
+}
+#if defined(USE_THREADS)
+
+#undef  Perl_find_threadsv
+PADOFFSET
+Perl_find_threadsv(void *pPerl, const char *name)
+{
+    return ((CPerlObj*)pPerl)->Perl_find_threadsv(name);
+}
+#endif
+
+#undef  Perl_force_list
+OP*
+Perl_force_list(void *pPerl, OP* arg)
+{
+    return ((CPerlObj*)pPerl)->Perl_force_list(arg);
+}
+
+#undef  Perl_fold_constants
+OP*
+Perl_fold_constants(void *pPerl, OP* arg)
+{
+    return ((CPerlObj*)pPerl)->Perl_fold_constants(arg);
+}
+
+#undef  Perl_free_tmps
+void
+Perl_free_tmps(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_free_tmps();
+}
+
+#undef  Perl_gen_constant_list
+OP*
+Perl_gen_constant_list(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_gen_constant_list(o);
+}
+#if !defined(HAS_GETENV_LEN)
+
+#undef  Perl_getenv_len
+char*
+Perl_getenv_len(void *pPerl, char* key, unsigned long *len)
+{
+    return ((CPerlObj*)pPerl)->Perl_getenv_len(key, len);
+}
+#endif
+
+#undef  Perl_gp_free
+void
+Perl_gp_free(void *pPerl, GV* gv)
+{
+    ((CPerlObj*)pPerl)->Perl_gp_free(gv);
+}
+
+#undef  Perl_gp_ref
+GP*
+Perl_gp_ref(void *pPerl, GP* gp)
+{
+    return ((CPerlObj*)pPerl)->Perl_gp_ref(gp);
+}
+
+#undef  Perl_gv_AVadd
+GV*
+Perl_gv_AVadd(void *pPerl, GV* gv)
+{
+    return ((CPerlObj*)pPerl)->Perl_gv_AVadd(gv);
+}
+
+#undef  Perl_gv_HVadd
+GV*
+Perl_gv_HVadd(void *pPerl, GV* gv)
+{
+    return ((CPerlObj*)pPerl)->Perl_gv_HVadd(gv);
+}
+
+#undef  Perl_gv_IOadd
+GV*
+Perl_gv_IOadd(void *pPerl, GV* gv)
+{
+    return ((CPerlObj*)pPerl)->Perl_gv_IOadd(gv);
+}
+
+#undef  Perl_gv_autoload4
+GV*
+Perl_gv_autoload4(void *pPerl, HV* stash, const char* name, STRLEN len, I32 method)
+{
+    return ((CPerlObj*)pPerl)->Perl_gv_autoload4(stash, name, len, method);
+}
+
+#undef  Perl_gv_check
+void
+Perl_gv_check(void *pPerl, HV* stash)
+{
+    ((CPerlObj*)pPerl)->Perl_gv_check(stash);
+}
+
+#undef  Perl_gv_efullname
+void
+Perl_gv_efullname(void *pPerl, SV* sv, GV* gv)
+{
+    ((CPerlObj*)pPerl)->Perl_gv_efullname(sv, gv);
+}
+
+#undef  Perl_gv_efullname3
+void
+Perl_gv_efullname3(void *pPerl, SV* sv, GV* gv, const char* prefix)
+{
+    ((CPerlObj*)pPerl)->Perl_gv_efullname3(sv, gv, prefix);
+}
+
+#undef  Perl_gv_fetchfile
+GV*
+Perl_gv_fetchfile(void *pPerl, const char* name)
+{
+    return ((CPerlObj*)pPerl)->Perl_gv_fetchfile(name);
+}
+
+#undef  Perl_gv_fetchmeth
+GV*
+Perl_gv_fetchmeth(void *pPerl, HV* stash, const char* name, STRLEN len, I32 level)
+{
+    return ((CPerlObj*)pPerl)->Perl_gv_fetchmeth(stash, name, len, level);
+}
+
+#undef  Perl_gv_fetchmethod
+GV*
+Perl_gv_fetchmethod(void *pPerl, HV* stash, const char* name)
+{
+    return ((CPerlObj*)pPerl)->Perl_gv_fetchmethod(stash, name);
+}
+
+#undef  Perl_gv_fetchmethod_autoload
+GV*
+Perl_gv_fetchmethod_autoload(void *pPerl, HV* stash, const char* name, I32 autoload)
+{
+    return ((CPerlObj*)pPerl)->Perl_gv_fetchmethod_autoload(stash, name, autoload);
+}
+
+#undef  Perl_gv_fetchpv
+GV*
+Perl_gv_fetchpv(void *pPerl, const char* name, I32 add, I32 sv_type)
+{
+    return ((CPerlObj*)pPerl)->Perl_gv_fetchpv(name, add, sv_type);
+}
+
+#undef  Perl_gv_fullname
+void
+Perl_gv_fullname(void *pPerl, SV* sv, GV* gv)
+{
+    ((CPerlObj*)pPerl)->Perl_gv_fullname(sv, gv);
+}
+
+#undef  Perl_gv_fullname3
+void
+Perl_gv_fullname3(void *pPerl, SV* sv, GV* gv, const char* prefix)
+{
+    ((CPerlObj*)pPerl)->Perl_gv_fullname3(sv, gv, prefix);
+}
+
+#undef  Perl_gv_init
+void
+Perl_gv_init(void *pPerl, GV* gv, HV* stash, const char* name, STRLEN len, int multi)
+{
+    ((CPerlObj*)pPerl)->Perl_gv_init(gv, stash, name, len, multi);
+}
+
+#undef  Perl_gv_stashpv
+HV*
+Perl_gv_stashpv(void *pPerl, const char* name, I32 create)
+{
+    return ((CPerlObj*)pPerl)->Perl_gv_stashpv(name, create);
+}
+
+#undef  Perl_gv_stashpvn
+HV*
+Perl_gv_stashpvn(void *pPerl, const char* name, U32 namelen, I32 create)
+{
+    return ((CPerlObj*)pPerl)->Perl_gv_stashpvn(name, namelen, create);
+}
+
+#undef  Perl_gv_stashsv
+HV*
+Perl_gv_stashsv(void *pPerl, SV* sv, I32 create)
+{
+    return ((CPerlObj*)pPerl)->Perl_gv_stashsv(sv, create);
+}
+
+#undef  Perl_hv_clear
+void
+Perl_hv_clear(void *pPerl, HV* tb)
+{
+    ((CPerlObj*)pPerl)->Perl_hv_clear(tb);
+}
+
+#undef  Perl_hv_delayfree_ent
+void
+Perl_hv_delayfree_ent(void *pPerl, HV* hv, HE* entry)
+{
+    ((CPerlObj*)pPerl)->Perl_hv_delayfree_ent(hv, entry);
+}
+
+#undef  Perl_hv_delete
+SV*
+Perl_hv_delete(void *pPerl, HV* tb, const char* key, U32 klen, I32 flags)
+{
+    return ((CPerlObj*)pPerl)->Perl_hv_delete(tb, key, klen, flags);
+}
+
+#undef  Perl_hv_delete_ent
+SV*
+Perl_hv_delete_ent(void *pPerl, HV* tb, SV* key, I32 flags, U32 hash)
+{
+    return ((CPerlObj*)pPerl)->Perl_hv_delete_ent(tb, key, flags, hash);
+}
+
+#undef  Perl_hv_exists
+bool
+Perl_hv_exists(void *pPerl, HV* tb, const char* key, U32 klen)
+{
+    return ((CPerlObj*)pPerl)->Perl_hv_exists(tb, key, klen);
+}
+
+#undef  Perl_hv_exists_ent
+bool
+Perl_hv_exists_ent(void *pPerl, HV* tb, SV* key, U32 hash)
+{
+    return ((CPerlObj*)pPerl)->Perl_hv_exists_ent(tb, key, hash);
+}
+
+#undef  Perl_hv_fetch
+SV**
+Perl_hv_fetch(void *pPerl, HV* tb, const char* key, U32 klen, I32 lval)
+{
+    return ((CPerlObj*)pPerl)->Perl_hv_fetch(tb, key, klen, lval);
+}
+
+#undef  Perl_hv_fetch_ent
+HE*
+Perl_hv_fetch_ent(void *pPerl, HV* tb, SV* key, I32 lval, U32 hash)
+{
+    return ((CPerlObj*)pPerl)->Perl_hv_fetch_ent(tb, key, lval, hash);
+}
+
+#undef  Perl_hv_free_ent
+void
+Perl_hv_free_ent(void *pPerl, HV* hv, HE* entry)
+{
+    ((CPerlObj*)pPerl)->Perl_hv_free_ent(hv, entry);
+}
+
+#undef  Perl_hv_iterinit
+I32
+Perl_hv_iterinit(void *pPerl, HV* tb)
+{
+    return ((CPerlObj*)pPerl)->Perl_hv_iterinit(tb);
+}
+
+#undef  Perl_hv_iterkey
+char*
+Perl_hv_iterkey(void *pPerl, HE* entry, I32* retlen)
+{
+    return ((CPerlObj*)pPerl)->Perl_hv_iterkey(entry, retlen);
+}
+
+#undef  Perl_hv_iterkeysv
+SV*
+Perl_hv_iterkeysv(void *pPerl, HE* entry)
+{
+    return ((CPerlObj*)pPerl)->Perl_hv_iterkeysv(entry);
+}
+
+#undef  Perl_hv_iternext
+HE*
+Perl_hv_iternext(void *pPerl, HV* tb)
+{
+    return ((CPerlObj*)pPerl)->Perl_hv_iternext(tb);
+}
+
+#undef  Perl_hv_iternextsv
+SV*
+Perl_hv_iternextsv(void *pPerl, HV* hv, char** key, I32* retlen)
+{
+    return ((CPerlObj*)pPerl)->Perl_hv_iternextsv(hv, key, retlen);
+}
+
+#undef  Perl_hv_iterval
+SV*
+Perl_hv_iterval(void *pPerl, HV* tb, HE* entry)
+{
+    return ((CPerlObj*)pPerl)->Perl_hv_iterval(tb, entry);
+}
+
+#undef  Perl_hv_ksplit
+void
+Perl_hv_ksplit(void *pPerl, HV* hv, IV newmax)
+{
+    ((CPerlObj*)pPerl)->Perl_hv_ksplit(hv, newmax);
+}
+
+#undef  Perl_hv_magic
+void
+Perl_hv_magic(void *pPerl, HV* hv, GV* gv, int how)
+{
+    ((CPerlObj*)pPerl)->Perl_hv_magic(hv, gv, how);
+}
+
+#undef  Perl_hv_store
+SV**
+Perl_hv_store(void *pPerl, HV* tb, const char* key, U32 klen, SV* val, U32 hash)
+{
+    return ((CPerlObj*)pPerl)->Perl_hv_store(tb, key, klen, val, hash);
+}
+
+#undef  Perl_hv_store_ent
+HE*
+Perl_hv_store_ent(void *pPerl, HV* tb, SV* key, SV* val, U32 hash)
+{
+    return ((CPerlObj*)pPerl)->Perl_hv_store_ent(tb, key, val, hash);
+}
+
+#undef  Perl_hv_undef
+void
+Perl_hv_undef(void *pPerl, HV* tb)
+{
+    ((CPerlObj*)pPerl)->Perl_hv_undef(tb);
+}
+
+#undef  Perl_ibcmp
+I32
+Perl_ibcmp(void *pPerl, const char* a, const char* b, I32 len)
+{
+    return ((CPerlObj*)pPerl)->Perl_ibcmp(a, b, len);
+}
+
+#undef  Perl_ibcmp_locale
+I32
+Perl_ibcmp_locale(void *pPerl, const char* a, const char* b, I32 len)
+{
+    return ((CPerlObj*)pPerl)->Perl_ibcmp_locale(a, b, len);
+}
+
+#undef  Perl_ingroup
+I32
+Perl_ingroup(void *pPerl, I32 testgid, I32 effective)
+{
+    return ((CPerlObj*)pPerl)->Perl_ingroup(testgid, effective);
+}
+
+#undef  Perl_init_stacks
+void
+Perl_init_stacks(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_init_stacks();
+}
+
+#undef  Perl_intro_my
+U32
+Perl_intro_my(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_intro_my();
+}
+
+#undef  Perl_instr
+char*
+Perl_instr(void *pPerl, const char* big, const char* little)
+{
+    return ((CPerlObj*)pPerl)->Perl_instr(big, little);
+}
+
+#undef  Perl_io_close
+bool
+Perl_io_close(void *pPerl, IO* io)
+{
+    return ((CPerlObj*)pPerl)->Perl_io_close(io);
+}
+
+#undef  Perl_invert
+OP*
+Perl_invert(void *pPerl, OP* cmd)
+{
+    return ((CPerlObj*)pPerl)->Perl_invert(cmd);
+}
+
+#undef  Perl_is_uni_alnum
+bool
+Perl_is_uni_alnum(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_alnum(c);
+}
+
+#undef  Perl_is_uni_alnumc
+bool
+Perl_is_uni_alnumc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_alnumc(c);
+}
+
+#undef  Perl_is_uni_idfirst
+bool
+Perl_is_uni_idfirst(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_idfirst(c);
+}
+
+#undef  Perl_is_uni_alpha
+bool
+Perl_is_uni_alpha(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_alpha(c);
+}
+
+#undef  Perl_is_uni_ascii
+bool
+Perl_is_uni_ascii(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_ascii(c);
+}
+
+#undef  Perl_is_uni_space
+bool
+Perl_is_uni_space(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_space(c);
+}
+
+#undef  Perl_is_uni_cntrl
+bool
+Perl_is_uni_cntrl(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_cntrl(c);
+}
+
+#undef  Perl_is_uni_graph
+bool
+Perl_is_uni_graph(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_graph(c);
+}
+
+#undef  Perl_is_uni_digit
+bool
+Perl_is_uni_digit(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_digit(c);
+}
+
+#undef  Perl_is_uni_upper
+bool
+Perl_is_uni_upper(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_upper(c);
+}
+
+#undef  Perl_is_uni_lower
+bool
+Perl_is_uni_lower(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_lower(c);
+}
+
+#undef  Perl_is_uni_print
+bool
+Perl_is_uni_print(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_print(c);
+}
+
+#undef  Perl_is_uni_punct
+bool
+Perl_is_uni_punct(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_punct(c);
+}
+
+#undef  Perl_is_uni_xdigit
+bool
+Perl_is_uni_xdigit(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_xdigit(c);
+}
+
+#undef  Perl_to_uni_upper
+U32
+Perl_to_uni_upper(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_to_uni_upper(c);
+}
+
+#undef  Perl_to_uni_title
+U32
+Perl_to_uni_title(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_to_uni_title(c);
+}
+
+#undef  Perl_to_uni_lower
+U32
+Perl_to_uni_lower(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_to_uni_lower(c);
+}
+
+#undef  Perl_is_uni_alnum_lc
+bool
+Perl_is_uni_alnum_lc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_alnum_lc(c);
+}
+
+#undef  Perl_is_uni_alnumc_lc
+bool
+Perl_is_uni_alnumc_lc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_alnumc_lc(c);
+}
+
+#undef  Perl_is_uni_idfirst_lc
+bool
+Perl_is_uni_idfirst_lc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_idfirst_lc(c);
+}
+
+#undef  Perl_is_uni_alpha_lc
+bool
+Perl_is_uni_alpha_lc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_alpha_lc(c);
+}
+
+#undef  Perl_is_uni_ascii_lc
+bool
+Perl_is_uni_ascii_lc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_ascii_lc(c);
+}
+
+#undef  Perl_is_uni_space_lc
+bool
+Perl_is_uni_space_lc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_space_lc(c);
+}
+
+#undef  Perl_is_uni_cntrl_lc
+bool
+Perl_is_uni_cntrl_lc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_cntrl_lc(c);
+}
+
+#undef  Perl_is_uni_graph_lc
+bool
+Perl_is_uni_graph_lc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_graph_lc(c);
+}
+
+#undef  Perl_is_uni_digit_lc
+bool
+Perl_is_uni_digit_lc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_digit_lc(c);
+}
+
+#undef  Perl_is_uni_upper_lc
+bool
+Perl_is_uni_upper_lc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_upper_lc(c);
+}
+
+#undef  Perl_is_uni_lower_lc
+bool
+Perl_is_uni_lower_lc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_lower_lc(c);
+}
+
+#undef  Perl_is_uni_print_lc
+bool
+Perl_is_uni_print_lc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_print_lc(c);
+}
+
+#undef  Perl_is_uni_punct_lc
+bool
+Perl_is_uni_punct_lc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_punct_lc(c);
+}
+
+#undef  Perl_is_uni_xdigit_lc
+bool
+Perl_is_uni_xdigit_lc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_uni_xdigit_lc(c);
+}
+
+#undef  Perl_to_uni_upper_lc
+U32
+Perl_to_uni_upper_lc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_to_uni_upper_lc(c);
+}
+
+#undef  Perl_to_uni_title_lc
+U32
+Perl_to_uni_title_lc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_to_uni_title_lc(c);
+}
+
+#undef  Perl_to_uni_lower_lc
+U32
+Perl_to_uni_lower_lc(void *pPerl, U32 c)
+{
+    return ((CPerlObj*)pPerl)->Perl_to_uni_lower_lc(c);
+}
+
+#undef  Perl_is_utf8_alnum
+bool
+Perl_is_utf8_alnum(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_utf8_alnum(p);
+}
+
+#undef  Perl_is_utf8_alnumc
+bool
+Perl_is_utf8_alnumc(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_utf8_alnumc(p);
+}
+
+#undef  Perl_is_utf8_idfirst
+bool
+Perl_is_utf8_idfirst(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_utf8_idfirst(p);
+}
+
+#undef  Perl_is_utf8_alpha
+bool
+Perl_is_utf8_alpha(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_utf8_alpha(p);
+}
+
+#undef  Perl_is_utf8_ascii
+bool
+Perl_is_utf8_ascii(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_utf8_ascii(p);
+}
+
+#undef  Perl_is_utf8_space
+bool
+Perl_is_utf8_space(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_utf8_space(p);
+}
+
+#undef  Perl_is_utf8_cntrl
+bool
+Perl_is_utf8_cntrl(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_utf8_cntrl(p);
+}
+
+#undef  Perl_is_utf8_digit
+bool
+Perl_is_utf8_digit(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_utf8_digit(p);
+}
+
+#undef  Perl_is_utf8_graph
+bool
+Perl_is_utf8_graph(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_utf8_graph(p);
+}
+
+#undef  Perl_is_utf8_upper
+bool
+Perl_is_utf8_upper(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_utf8_upper(p);
+}
+
+#undef  Perl_is_utf8_lower
+bool
+Perl_is_utf8_lower(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_utf8_lower(p);
+}
+
+#undef  Perl_is_utf8_print
+bool
+Perl_is_utf8_print(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_utf8_print(p);
+}
+
+#undef  Perl_is_utf8_punct
+bool
+Perl_is_utf8_punct(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_utf8_punct(p);
+}
+
+#undef  Perl_is_utf8_xdigit
+bool
+Perl_is_utf8_xdigit(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_utf8_xdigit(p);
+}
+
+#undef  Perl_is_utf8_mark
+bool
+Perl_is_utf8_mark(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_is_utf8_mark(p);
+}
+
+#undef  Perl_jmaybe
+OP*
+Perl_jmaybe(void *pPerl, OP* arg)
+{
+    return ((CPerlObj*)pPerl)->Perl_jmaybe(arg);
+}
+
+#undef  Perl_keyword
+I32
+Perl_keyword(void *pPerl, char* d, I32 len)
+{
+    return ((CPerlObj*)pPerl)->Perl_keyword(d, len);
+}
+
+#undef  Perl_leave_scope
+void
+Perl_leave_scope(void *pPerl, I32 base)
+{
+    ((CPerlObj*)pPerl)->Perl_leave_scope(base);
+}
+
+#undef  Perl_lex_end
+void
+Perl_lex_end(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_lex_end();
+}
+
+#undef  Perl_lex_start
+void
+Perl_lex_start(void *pPerl, SV* line)
+{
+    ((CPerlObj*)pPerl)->Perl_lex_start(line);
+}
+
+#undef  Perl_linklist
+OP*
+Perl_linklist(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_linklist(o);
+}
+
+#undef  Perl_list
+OP*
+Perl_list(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_list(o);
+}
+
+#undef  Perl_listkids
+OP*
+Perl_listkids(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_listkids(o);
+}
+
+#undef  Perl_localize
+OP*
+Perl_localize(void *pPerl, OP* arg, I32 lexical)
+{
+    return ((CPerlObj*)pPerl)->Perl_localize(arg, lexical);
+}
+
+#undef  Perl_looks_like_number
+I32
+Perl_looks_like_number(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_looks_like_number(sv);
+}
+
+#undef  Perl_magic_clearenv
+int
+Perl_magic_clearenv(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_clearenv(sv, mg);
+}
+
+#undef  Perl_magic_clear_all_env
+int
+Perl_magic_clear_all_env(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_clear_all_env(sv, mg);
+}
+
+#undef  Perl_magic_clearpack
+int
+Perl_magic_clearpack(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_clearpack(sv, mg);
+}
+
+#undef  Perl_magic_clearsig
+int
+Perl_magic_clearsig(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_clearsig(sv, mg);
+}
+
+#undef  Perl_magic_existspack
+int
+Perl_magic_existspack(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_existspack(sv, mg);
+}
+
+#undef  Perl_magic_freeregexp
+int
+Perl_magic_freeregexp(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_freeregexp(sv, mg);
+}
+
+#undef  Perl_magic_get
+int
+Perl_magic_get(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_get(sv, mg);
+}
+
+#undef  Perl_magic_getarylen
+int
+Perl_magic_getarylen(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_getarylen(sv, mg);
+}
+
+#undef  Perl_magic_getdefelem
+int
+Perl_magic_getdefelem(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_getdefelem(sv, mg);
+}
+
+#undef  Perl_magic_getglob
+int
+Perl_magic_getglob(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_getglob(sv, mg);
+}
+
+#undef  Perl_magic_getnkeys
+int
+Perl_magic_getnkeys(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_getnkeys(sv, mg);
+}
+
+#undef  Perl_magic_getpack
+int
+Perl_magic_getpack(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_getpack(sv, mg);
+}
+
+#undef  Perl_magic_getpos
+int
+Perl_magic_getpos(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_getpos(sv, mg);
+}
+
+#undef  Perl_magic_getsig
+int
+Perl_magic_getsig(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_getsig(sv, mg);
+}
+
+#undef  Perl_magic_getsubstr
+int
+Perl_magic_getsubstr(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_getsubstr(sv, mg);
+}
+
+#undef  Perl_magic_gettaint
+int
+Perl_magic_gettaint(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_gettaint(sv, mg);
+}
+
+#undef  Perl_magic_getuvar
+int
+Perl_magic_getuvar(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_getuvar(sv, mg);
+}
+
+#undef  Perl_magic_getvec
+int
+Perl_magic_getvec(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_getvec(sv, mg);
+}
+
+#undef  Perl_magic_len
+U32
+Perl_magic_len(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_len(sv, mg);
+}
+#if defined(USE_THREADS)
+
+#undef  Perl_magic_mutexfree
+int
+Perl_magic_mutexfree(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_mutexfree(sv, mg);
+}
+#endif
+
+#undef  Perl_magic_nextpack
+int
+Perl_magic_nextpack(void *pPerl, SV* sv, MAGIC* mg, SV* key)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_nextpack(sv, mg, key);
+}
+
+#undef  Perl_magic_regdata_cnt
+U32
+Perl_magic_regdata_cnt(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_regdata_cnt(sv, mg);
+}
+
+#undef  Perl_magic_regdatum_get
+int
+Perl_magic_regdatum_get(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_regdatum_get(sv, mg);
+}
+
+#undef  Perl_magic_set
+int
+Perl_magic_set(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_set(sv, mg);
+}
+
+#undef  Perl_magic_setamagic
+int
+Perl_magic_setamagic(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setamagic(sv, mg);
+}
+
+#undef  Perl_magic_setarylen
+int
+Perl_magic_setarylen(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setarylen(sv, mg);
+}
+
+#undef  Perl_magic_setbm
+int
+Perl_magic_setbm(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setbm(sv, mg);
+}
+
+#undef  Perl_magic_setdbline
+int
+Perl_magic_setdbline(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setdbline(sv, mg);
+}
+#if defined(USE_LOCALE_COLLATE)
+
+#undef  Perl_magic_setcollxfrm
+int
+Perl_magic_setcollxfrm(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setcollxfrm(sv, mg);
+}
+#endif
+
+#undef  Perl_magic_setdefelem
+int
+Perl_magic_setdefelem(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setdefelem(sv, mg);
+}
+
+#undef  Perl_magic_setenv
+int
+Perl_magic_setenv(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setenv(sv, mg);
+}
+
+#undef  Perl_magic_setfm
+int
+Perl_magic_setfm(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setfm(sv, mg);
+}
+
+#undef  Perl_magic_setisa
+int
+Perl_magic_setisa(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setisa(sv, mg);
+}
+
+#undef  Perl_magic_setglob
+int
+Perl_magic_setglob(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setglob(sv, mg);
+}
+
+#undef  Perl_magic_setmglob
+int
+Perl_magic_setmglob(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setmglob(sv, mg);
+}
+
+#undef  Perl_magic_setnkeys
+int
+Perl_magic_setnkeys(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setnkeys(sv, mg);
+}
+
+#undef  Perl_magic_setpack
+int
+Perl_magic_setpack(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setpack(sv, mg);
+}
+
+#undef  Perl_magic_setpos
+int
+Perl_magic_setpos(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setpos(sv, mg);
+}
+
+#undef  Perl_magic_setsig
+int
+Perl_magic_setsig(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setsig(sv, mg);
+}
+
+#undef  Perl_magic_setsubstr
+int
+Perl_magic_setsubstr(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setsubstr(sv, mg);
+}
+
+#undef  Perl_magic_settaint
+int
+Perl_magic_settaint(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_settaint(sv, mg);
+}
+
+#undef  Perl_magic_setuvar
+int
+Perl_magic_setuvar(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setuvar(sv, mg);
+}
+
+#undef  Perl_magic_setvec
+int
+Perl_magic_setvec(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_setvec(sv, mg);
+}
+
+#undef  Perl_magic_set_all_env
+int
+Perl_magic_set_all_env(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_set_all_env(sv, mg);
+}
+
+#undef  Perl_magic_sizepack
+U32
+Perl_magic_sizepack(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_sizepack(sv, mg);
+}
+
+#undef  Perl_magic_wipepack
+int
+Perl_magic_wipepack(void *pPerl, SV* sv, MAGIC* mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_wipepack(sv, mg);
+}
+
+#undef  Perl_magicname
+void
+Perl_magicname(void *pPerl, char* sym, char* name, I32 namlen)
+{
+    ((CPerlObj*)pPerl)->Perl_magicname(sym, name, namlen);
+}
+#if defined(MYMALLOC)
+
+#undef  Perl_malloced_size
+MEM_SIZE
+Perl_malloced_size(void *pPerl, void *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_malloced_size(p);
+}
+#endif
+
+#undef  Perl_markstack_grow
+void
+Perl_markstack_grow(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_markstack_grow();
+}
+#if defined(USE_LOCALE_COLLATE)
+
+#undef  Perl_mem_collxfrm
+char*
+Perl_mem_collxfrm(void *pPerl, const char* s, STRLEN len, STRLEN* xlen)
+{
+    return ((CPerlObj*)pPerl)->Perl_mem_collxfrm(s, len, xlen);
+}
+#endif
+
+#undef  Perl_mess
+SV*
+Perl_mess(void *pPerl, const char* pat, va_list* args)
+{
+    return ((CPerlObj*)pPerl)->Perl_mess(pat, args);
+}
+
+#undef  Perl_mg_clear
+int
+Perl_mg_clear(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_mg_clear(sv);
+}
+
+#undef  Perl_mg_copy
+int
+Perl_mg_copy(void *pPerl, SV* sv, SV* nsv, const char* key, I32 klen)
+{
+    return ((CPerlObj*)pPerl)->Perl_mg_copy(sv, nsv, key, klen);
+}
+
+#undef  Perl_mg_find
+MAGIC*
+Perl_mg_find(void *pPerl, SV* sv, int type)
+{
+    return ((CPerlObj*)pPerl)->Perl_mg_find(sv, type);
+}
+
+#undef  Perl_mg_free
+int
+Perl_mg_free(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_mg_free(sv);
+}
+
+#undef  Perl_mg_get
+int
+Perl_mg_get(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_mg_get(sv);
+}
+
+#undef  Perl_mg_length
+U32
+Perl_mg_length(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_mg_length(sv);
+}
+
+#undef  Perl_mg_magical
+void
+Perl_mg_magical(void *pPerl, SV* sv)
+{
+    ((CPerlObj*)pPerl)->Perl_mg_magical(sv);
+}
+
+#undef  Perl_mg_set
+int
+Perl_mg_set(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_mg_set(sv);
+}
+
+#undef  Perl_mg_size
+I32
+Perl_mg_size(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_mg_size(sv);
+}
+
+#undef  Perl_mod
+OP*
+Perl_mod(void *pPerl, OP* o, I32 type)
+{
+    return ((CPerlObj*)pPerl)->Perl_mod(o, type);
+}
+
+#undef  Perl_moreswitches
+char*
+Perl_moreswitches(void *pPerl, char* s)
+{
+    return ((CPerlObj*)pPerl)->Perl_moreswitches(s);
+}
+
+#undef  Perl_my
+OP*
+Perl_my(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_my(o);
+}
+
+#undef  Perl_my_atof
+NV
+Perl_my_atof(void *pPerl, const char *s)
+{
+    return ((CPerlObj*)pPerl)->Perl_my_atof(s);
+}
+#if !defined(HAS_BCOPY) || !defined(HAS_SAFE_BCOPY)
+
+#undef  Perl_my_bcopy
+char*
+Perl_my_bcopy(void *pPerl, const char* from, char* to, I32 len)
+{
+    return ((CPerlObj*)pPerl)->Perl_my_bcopy(from, to, len);
+}
+#endif
+#if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
+
+#undef  Perl_my_bzero
+char*
+Perl_my_bzero(void *pPerl, char* loc, I32 len)
+{
+    return ((CPerlObj*)pPerl)->Perl_my_bzero(loc, len);
+}
+#endif
+
+#undef  Perl_my_exit
+void
+Perl_my_exit(void *pPerl, U32 status)
+{
+    ((CPerlObj*)pPerl)->Perl_my_exit(status);
+}
+
+#undef  Perl_my_failure_exit
+void
+Perl_my_failure_exit(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_my_failure_exit();
+}
+
+#undef  Perl_my_fflush_all
+I32
+Perl_my_fflush_all(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_my_fflush_all();
+}
+
+#undef  Perl_my_lstat
+I32
+Perl_my_lstat(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_my_lstat();
+}
+#if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP)
+
+#undef  Perl_my_memcmp
+I32
+Perl_my_memcmp(void *pPerl, const char* s1, const char* s2, I32 len)
+{
+    return ((CPerlObj*)pPerl)->Perl_my_memcmp(s1, s2, len);
+}
+#endif
+#if !defined(HAS_MEMSET)
+
+#undef  Perl_my_memset
+void*
+Perl_my_memset(void *pPerl, char* loc, I32 ch, I32 len)
+{
+    return ((CPerlObj*)pPerl)->Perl_my_memset(loc, ch, len);
+}
+#endif
+#if !defined(PERL_OBJECT)
+
+#undef  Perl_my_pclose
+I32
+Perl_my_pclose(void *pPerl, PerlIO* ptr)
+{
+    return ((CPerlObj*)pPerl)->Perl_my_pclose(ptr);
+}
+
+#undef  Perl_my_popen
+PerlIO*
+Perl_my_popen(void *pPerl, char* cmd, char* mode)
+{
+    return ((CPerlObj*)pPerl)->Perl_my_popen(cmd, mode);
+}
+#endif
+
+#undef  Perl_my_setenv
+void
+Perl_my_setenv(void *pPerl, char* nam, char* val)
+{
+    ((CPerlObj*)pPerl)->Perl_my_setenv(nam, val);
+}
+
+#undef  Perl_my_stat
+I32
+Perl_my_stat(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_my_stat();
+}
+#if defined(MYSWAP)
+
+#undef  Perl_my_swap
+short
+Perl_my_swap(void *pPerl, short s)
+{
+    return ((CPerlObj*)pPerl)->Perl_my_swap(s);
+}
+
+#undef  Perl_my_htonl
+long
+Perl_my_htonl(void *pPerl, long l)
+{
+    return ((CPerlObj*)pPerl)->Perl_my_htonl(l);
+}
+
+#undef  Perl_my_ntohl
+long
+Perl_my_ntohl(void *pPerl, long l)
+{
+    return ((CPerlObj*)pPerl)->Perl_my_ntohl(l);
+}
+#endif
+
+#undef  Perl_my_unexec
+void
+Perl_my_unexec(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_my_unexec();
+}
+
+#undef  Perl_newANONLIST
+OP*
+Perl_newANONLIST(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_newANONLIST(o);
+}
+
+#undef  Perl_newANONHASH
+OP*
+Perl_newANONHASH(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_newANONHASH(o);
+}
+
+#undef  Perl_newANONSUB
+OP*
+Perl_newANONSUB(void *pPerl, I32 floor, OP* proto, OP* block)
+{
+    return ((CPerlObj*)pPerl)->Perl_newANONSUB(floor, proto, block);
+}
+
+#undef  Perl_newASSIGNOP
+OP*
+Perl_newASSIGNOP(void *pPerl, I32 flags, OP* left, I32 optype, OP* right)
+{
+    return ((CPerlObj*)pPerl)->Perl_newASSIGNOP(flags, left, optype, right);
+}
+
+#undef  Perl_newCONDOP
+OP*
+Perl_newCONDOP(void *pPerl, I32 flags, OP* expr, OP* trueop, OP* falseop)
+{
+    return ((CPerlObj*)pPerl)->Perl_newCONDOP(flags, expr, trueop, falseop);
+}
+
+#undef  Perl_newCONSTSUB
+void
+Perl_newCONSTSUB(void *pPerl, HV* stash, char* name, SV* sv)
+{
+    ((CPerlObj*)pPerl)->Perl_newCONSTSUB(stash, name, sv);
+}
+
+#undef  Perl_newFORM
+void
+Perl_newFORM(void *pPerl, I32 floor, OP* o, OP* block)
+{
+    ((CPerlObj*)pPerl)->Perl_newFORM(floor, o, block);
+}
+
+#undef  Perl_newFOROP
+OP*
+Perl_newFOROP(void *pPerl, I32 flags, char* label, line_t forline, OP* sclr, OP* expr, OP*block, OP*cont)
+{
+    return ((CPerlObj*)pPerl)->Perl_newFOROP(flags, label, forline, sclr, expr, block, cont);
+}
+
+#undef  Perl_newLOGOP
+OP*
+Perl_newLOGOP(void *pPerl, I32 optype, I32 flags, OP* left, OP* right)
+{
+    return ((CPerlObj*)pPerl)->Perl_newLOGOP(optype, flags, left, right);
+}
+
+#undef  Perl_newLOOPEX
+OP*
+Perl_newLOOPEX(void *pPerl, I32 type, OP* label)
+{
+    return ((CPerlObj*)pPerl)->Perl_newLOOPEX(type, label);
+}
+
+#undef  Perl_newLOOPOP
+OP*
+Perl_newLOOPOP(void *pPerl, I32 flags, I32 debuggable, OP* expr, OP* block)
+{
+    return ((CPerlObj*)pPerl)->Perl_newLOOPOP(flags, debuggable, expr, block);
+}
+
+#undef  Perl_newNULLLIST
+OP*
+Perl_newNULLLIST(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_newNULLLIST();
+}
+
+#undef  Perl_newOP
+OP*
+Perl_newOP(void *pPerl, I32 optype, I32 flags)
+{
+    return ((CPerlObj*)pPerl)->Perl_newOP(optype, flags);
+}
+
+#undef  Perl_newPROG
+void
+Perl_newPROG(void *pPerl, OP* o)
+{
+    ((CPerlObj*)pPerl)->Perl_newPROG(o);
+}
+
+#undef  Perl_newRANGE
+OP*
+Perl_newRANGE(void *pPerl, I32 flags, OP* left, OP* right)
+{
+    return ((CPerlObj*)pPerl)->Perl_newRANGE(flags, left, right);
+}
+
+#undef  Perl_newSLICEOP
+OP*
+Perl_newSLICEOP(void *pPerl, I32 flags, OP* subscript, OP* listop)
+{
+    return ((CPerlObj*)pPerl)->Perl_newSLICEOP(flags, subscript, listop);
+}
+
+#undef  Perl_newSTATEOP
+OP*
+Perl_newSTATEOP(void *pPerl, I32 flags, char* label, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_newSTATEOP(flags, label, o);
+}
+
+#undef  Perl_newSUB
+CV*
+Perl_newSUB(void *pPerl, I32 floor, OP* o, OP* proto, OP* block)
+{
+    return ((CPerlObj*)pPerl)->Perl_newSUB(floor, o, proto, block);
+}
+
+#undef  Perl_newXS
+CV*
+Perl_newXS(void *pPerl, char* name, XSUBADDR_t f, char* filename)
+{
+    return ((CPerlObj*)pPerl)->Perl_newXS(name, f, filename);
+}
+
+#undef  Perl_newAV
+AV*
+Perl_newAV(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_newAV();
+}
+
+#undef  Perl_newAVREF
+OP*
+Perl_newAVREF(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_newAVREF(o);
+}
+
+#undef  Perl_newBINOP
+OP*
+Perl_newBINOP(void *pPerl, I32 type, I32 flags, OP* first, OP* last)
+{
+    return ((CPerlObj*)pPerl)->Perl_newBINOP(type, flags, first, last);
+}
+
+#undef  Perl_newCVREF
+OP*
+Perl_newCVREF(void *pPerl, I32 flags, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_newCVREF(flags, o);
+}
+
+#undef  Perl_newGVOP
+OP*
+Perl_newGVOP(void *pPerl, I32 type, I32 flags, GV* gv)
+{
+    return ((CPerlObj*)pPerl)->Perl_newGVOP(type, flags, gv);
+}
+
+#undef  Perl_newGVgen
+GV*
+Perl_newGVgen(void *pPerl, char* pack)
+{
+    return ((CPerlObj*)pPerl)->Perl_newGVgen(pack);
+}
+
+#undef  Perl_newGVREF
+OP*
+Perl_newGVREF(void *pPerl, I32 type, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_newGVREF(type, o);
+}
+
+#undef  Perl_newHVREF
+OP*
+Perl_newHVREF(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_newHVREF(o);
+}
+
+#undef  Perl_newHV
+HV*
+Perl_newHV(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_newHV();
+}
+
+#undef  Perl_newHVhv
+HV*
+Perl_newHVhv(void *pPerl, HV* hv)
+{
+    return ((CPerlObj*)pPerl)->Perl_newHVhv(hv);
+}
+
+#undef  Perl_newIO
+IO*
+Perl_newIO(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_newIO();
+}
+
+#undef  Perl_newLISTOP
+OP*
+Perl_newLISTOP(void *pPerl, I32 type, I32 flags, OP* first, OP* last)
+{
+    return ((CPerlObj*)pPerl)->Perl_newLISTOP(type, flags, first, last);
+}
+
+#undef  Perl_newPMOP
+OP*
+Perl_newPMOP(void *pPerl, I32 type, I32 flags)
+{
+    return ((CPerlObj*)pPerl)->Perl_newPMOP(type, flags);
+}
+
+#undef  Perl_newPVOP
+OP*
+Perl_newPVOP(void *pPerl, I32 type, I32 flags, char* pv)
+{
+    return ((CPerlObj*)pPerl)->Perl_newPVOP(type, flags, pv);
+}
+
+#undef  Perl_newRV
+SV*
+Perl_newRV(void *pPerl, SV* pref)
+{
+    return ((CPerlObj*)pPerl)->Perl_newRV(pref);
+}
+
+#undef  Perl_newRV_noinc
+SV*
+Perl_newRV_noinc(void *pPerl, SV *sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_newRV_noinc(sv);
+}
+
+#undef  Perl_newSV
+SV*
+Perl_newSV(void *pPerl, STRLEN len)
+{
+    return ((CPerlObj*)pPerl)->Perl_newSV(len);
+}
+
+#undef  Perl_newSVREF
+OP*
+Perl_newSVREF(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_newSVREF(o);
+}
+
+#undef  Perl_newSVOP
+OP*
+Perl_newSVOP(void *pPerl, I32 type, I32 flags, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_newSVOP(type, flags, sv);
+}
+
+#undef  Perl_newSViv
+SV*
+Perl_newSViv(void *pPerl, IV i)
+{
+    return ((CPerlObj*)pPerl)->Perl_newSViv(i);
+}
+
+#undef  Perl_newSVnv
+SV*
+Perl_newSVnv(void *pPerl, NV n)
+{
+    return ((CPerlObj*)pPerl)->Perl_newSVnv(n);
+}
+
+#undef  Perl_newSVpv
+SV*
+Perl_newSVpv(void *pPerl, const char* s, STRLEN len)
+{
+    return ((CPerlObj*)pPerl)->Perl_newSVpv(s, len);
+}
+
+#undef  Perl_newSVpvn
+SV*
+Perl_newSVpvn(void *pPerl, const char* s, STRLEN len)
+{
+    return ((CPerlObj*)pPerl)->Perl_newSVpvn(s, len);
+}
+
+#undef  Perl_newSVrv
+SV*
+Perl_newSVrv(void *pPerl, SV* rv, const char* classname)
+{
+    return ((CPerlObj*)pPerl)->Perl_newSVrv(rv, classname);
+}
+
+#undef  Perl_newSVsv
+SV*
+Perl_newSVsv(void *pPerl, SV* old)
+{
+    return ((CPerlObj*)pPerl)->Perl_newSVsv(old);
+}
+
+#undef  Perl_newUNOP
+OP*
+Perl_newUNOP(void *pPerl, I32 type, I32 flags, OP* first)
+{
+    return ((CPerlObj*)pPerl)->Perl_newUNOP(type, flags, first);
+}
+
+#undef  Perl_newWHILEOP
+OP*
+Perl_newWHILEOP(void *pPerl, I32 flags, I32 debuggable, LOOP* loop, I32 whileline, OP* expr, OP* block, OP* cont)
+{
+    return ((CPerlObj*)pPerl)->Perl_newWHILEOP(flags, debuggable, loop, whileline, expr, block, cont);
+}
+#if defined(USE_THREADS)
+
+#undef  Perl_new_struct_thread
+struct perl_thread*
+Perl_new_struct_thread(void *pPerl, struct perl_thread *t)
+{
+    return ((CPerlObj*)pPerl)->Perl_new_struct_thread(t);
+}
+#endif
+
+#undef  Perl_new_stackinfo
+PERL_SI*
+Perl_new_stackinfo(void *pPerl, I32 stitems, I32 cxitems)
+{
+    return ((CPerlObj*)pPerl)->Perl_new_stackinfo(stitems, cxitems);
+}
+
+#undef  Perl_nextargv
+PerlIO*
+Perl_nextargv(void *pPerl, GV* gv)
+{
+    return ((CPerlObj*)pPerl)->Perl_nextargv(gv);
+}
+
+#undef  Perl_ninstr
+char*
+Perl_ninstr(void *pPerl, const char* big, const char* bigend, const char* little, const char* lend)
+{
+    return ((CPerlObj*)pPerl)->Perl_ninstr(big, bigend, little, lend);
+}
+
+#undef  Perl_oopsCV
+OP*
+Perl_oopsCV(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_oopsCV(o);
+}
+
+#undef  Perl_op_free
+void
+Perl_op_free(void *pPerl, OP* arg)
+{
+    ((CPerlObj*)pPerl)->Perl_op_free(arg);
+}
+
+#undef  Perl_package
+void
+Perl_package(void *pPerl, OP* o)
+{
+    ((CPerlObj*)pPerl)->Perl_package(o);
+}
+
+#undef  Perl_pad_alloc
+PADOFFSET
+Perl_pad_alloc(void *pPerl, I32 optype, U32 tmptype)
+{
+    return ((CPerlObj*)pPerl)->Perl_pad_alloc(optype, tmptype);
+}
+
+#undef  Perl_pad_allocmy
+PADOFFSET
+Perl_pad_allocmy(void *pPerl, char* name)
+{
+    return ((CPerlObj*)pPerl)->Perl_pad_allocmy(name);
+}
+
+#undef  Perl_pad_findmy
+PADOFFSET
+Perl_pad_findmy(void *pPerl, char* name)
+{
+    return ((CPerlObj*)pPerl)->Perl_pad_findmy(name);
+}
+
+#undef  Perl_oopsAV
+OP*
+Perl_oopsAV(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_oopsAV(o);
+}
+
+#undef  Perl_oopsHV
+OP*
+Perl_oopsHV(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_oopsHV(o);
+}
+
+#undef  Perl_pad_leavemy
+void
+Perl_pad_leavemy(void *pPerl, I32 fill)
+{
+    ((CPerlObj*)pPerl)->Perl_pad_leavemy(fill);
+}
+
+#undef  Perl_pad_sv
+SV*
+Perl_pad_sv(void *pPerl, PADOFFSET po)
+{
+    return ((CPerlObj*)pPerl)->Perl_pad_sv(po);
+}
+
+#undef  Perl_pad_free
+void
+Perl_pad_free(void *pPerl, PADOFFSET po)
+{
+    ((CPerlObj*)pPerl)->Perl_pad_free(po);
+}
+
+#undef  Perl_pad_reset
+void
+Perl_pad_reset(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_pad_reset();
+}
+
+#undef  Perl_pad_swipe
+void
+Perl_pad_swipe(void *pPerl, PADOFFSET po)
+{
+    ((CPerlObj*)pPerl)->Perl_pad_swipe(po);
+}
+
+#undef  Perl_peep
+void
+Perl_peep(void *pPerl, OP* o)
+{
+    ((CPerlObj*)pPerl)->Perl_peep(o);
+}
+#if defined(PERL_OBJECT)
+#else
+
+#undef  perl_alloc
+PerlInterpreter*
+perl_alloc(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->perl_alloc();
+}
+#endif
+
+#undef  Perl_call_atexit
+void
+Perl_call_atexit(void *pPerl, ATEXIT_t fn, void *ptr)
+{
+    ((CPerlObj*)pPerl)->Perl_call_atexit(fn, ptr);
+}
+
+#undef  Perl_call_argv
+I32
+Perl_call_argv(void *pPerl, const char* sub_name, I32 flags, char** argv)
+{
+    return ((CPerlObj*)pPerl)->Perl_call_argv(sub_name, flags, argv);
+}
+
+#undef  Perl_call_method
+I32
+Perl_call_method(void *pPerl, const char* methname, I32 flags)
+{
+    return ((CPerlObj*)pPerl)->Perl_call_method(methname, flags);
+}
+
+#undef  Perl_call_pv
+I32
+Perl_call_pv(void *pPerl, const char* sub_name, I32 flags)
+{
+    return ((CPerlObj*)pPerl)->Perl_call_pv(sub_name, flags);
+}
+
+#undef  Perl_call_sv
+I32
+Perl_call_sv(void *pPerl, SV* sv, I32 flags)
+{
+    return ((CPerlObj*)pPerl)->Perl_call_sv(sv, flags);
+}
+
+#undef  Perl_eval_pv
+SV*
+Perl_eval_pv(void *pPerl, const char* p, I32 croak_on_error)
+{
+    return ((CPerlObj*)pPerl)->Perl_eval_pv(p, croak_on_error);
+}
+
+#undef  Perl_eval_sv
+I32
+Perl_eval_sv(void *pPerl, SV* sv, I32 flags)
+{
+    return ((CPerlObj*)pPerl)->Perl_eval_sv(sv, flags);
+}
+
+#undef  Perl_get_sv
+SV*
+Perl_get_sv(void *pPerl, const char* name, I32 create)
+{
+    return ((CPerlObj*)pPerl)->Perl_get_sv(name, create);
+}
+
+#undef  Perl_get_av
+AV*
+Perl_get_av(void *pPerl, const char* name, I32 create)
+{
+    return ((CPerlObj*)pPerl)->Perl_get_av(name, create);
+}
+
+#undef  Perl_get_hv
+HV*
+Perl_get_hv(void *pPerl, const char* name, I32 create)
+{
+    return ((CPerlObj*)pPerl)->Perl_get_hv(name, create);
+}
+
+#undef  Perl_get_cv
+CV*
+Perl_get_cv(void *pPerl, const char* name, I32 create)
+{
+    return ((CPerlObj*)pPerl)->Perl_get_cv(name, create);
+}
+
+#undef  Perl_init_i18nl10n
+int
+Perl_init_i18nl10n(void *pPerl, int printwarn)
+{
+    return ((CPerlObj*)pPerl)->Perl_init_i18nl10n(printwarn);
+}
+
+#undef  Perl_init_i18nl14n
+int
+Perl_init_i18nl14n(void *pPerl, int printwarn)
+{
+    return ((CPerlObj*)pPerl)->Perl_init_i18nl14n(printwarn);
+}
+
+#undef  Perl_new_collate
+void
+Perl_new_collate(void *pPerl, const char* newcoll)
+{
+    ((CPerlObj*)pPerl)->Perl_new_collate(newcoll);
+}
+
+#undef  Perl_new_ctype
+void
+Perl_new_ctype(void *pPerl, const char* newctype)
+{
+    ((CPerlObj*)pPerl)->Perl_new_ctype(newctype);
+}
+
+#undef  Perl_new_numeric
+void
+Perl_new_numeric(void *pPerl, const char* newcoll)
+{
+    ((CPerlObj*)pPerl)->Perl_new_numeric(newcoll);
+}
+
+#undef  Perl_set_numeric_local
+void
+Perl_set_numeric_local(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_set_numeric_local();
+}
+
+#undef  Perl_set_numeric_radix
+void
+Perl_set_numeric_radix(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_set_numeric_radix();
+}
+
+#undef  Perl_set_numeric_standard
+void
+Perl_set_numeric_standard(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_set_numeric_standard();
+}
+
+#undef  Perl_require_pv
+void
+Perl_require_pv(void *pPerl, const char* pv)
+{
+    ((CPerlObj*)pPerl)->Perl_require_pv(pv);
+}
+
+#undef  Perl_pidgone
+void
+Perl_pidgone(void *pPerl, int pid, int status)
+{
+    ((CPerlObj*)pPerl)->Perl_pidgone(pid, status);
+}
+
+#undef  Perl_pmflag
+void
+Perl_pmflag(void *pPerl, U16* pmfl, int ch)
+{
+    ((CPerlObj*)pPerl)->Perl_pmflag(pmfl, ch);
+}
+
+#undef  Perl_pmruntime
+OP*
+Perl_pmruntime(void *pPerl, OP* pm, OP* expr, OP* repl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pmruntime(pm, expr, repl);
+}
+
+#undef  Perl_pmtrans
+OP*
+Perl_pmtrans(void *pPerl, OP* o, OP* expr, OP* repl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pmtrans(o, expr, repl);
+}
+
+#undef  Perl_pop_return
+OP*
+Perl_pop_return(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pop_return();
+}
+
+#undef  Perl_pop_scope
+void
+Perl_pop_scope(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_pop_scope();
+}
+
+#undef  Perl_prepend_elem
+OP*
+Perl_prepend_elem(void *pPerl, I32 optype, OP* head, OP* tail)
+{
+    return ((CPerlObj*)pPerl)->Perl_prepend_elem(optype, head, tail);
+}
+
+#undef  Perl_push_return
+void
+Perl_push_return(void *pPerl, OP* o)
+{
+    ((CPerlObj*)pPerl)->Perl_push_return(o);
+}
+
+#undef  Perl_push_scope
+void
+Perl_push_scope(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_push_scope();
+}
+
+#undef  Perl_ref
+OP*
+Perl_ref(void *pPerl, OP* o, I32 type)
+{
+    return ((CPerlObj*)pPerl)->Perl_ref(o, type);
+}
+
+#undef  Perl_refkids
+OP*
+Perl_refkids(void *pPerl, OP* o, I32 type)
+{
+    return ((CPerlObj*)pPerl)->Perl_refkids(o, type);
+}
+
+#undef  Perl_regdump
+void
+Perl_regdump(void *pPerl, regexp* r)
+{
+    ((CPerlObj*)pPerl)->Perl_regdump(r);
+}
+
+#undef  Perl_pregexec
+I32
+Perl_pregexec(void *pPerl, regexp* prog, char* stringarg, char* strend, char* strbeg, I32 minend, SV* screamer, U32 nosave)
+{
+    return ((CPerlObj*)pPerl)->Perl_pregexec(prog, stringarg, strend, strbeg, minend, screamer, nosave);
+}
+
+#undef  Perl_pregfree
+void
+Perl_pregfree(void *pPerl, struct regexp* r)
+{
+    ((CPerlObj*)pPerl)->Perl_pregfree(r);
+}
+
+#undef  Perl_pregcomp
+regexp*
+Perl_pregcomp(void *pPerl, char* exp, char* xend, PMOP* pm)
+{
+    return ((CPerlObj*)pPerl)->Perl_pregcomp(exp, xend, pm);
+}
+
+#undef  Perl_re_intuit_start
+char*
+Perl_re_intuit_start(void *pPerl, regexp* prog, SV* sv, char* strpos, char* strend, U32 flags, struct re_scream_pos_data_s *data)
+{
+    return ((CPerlObj*)pPerl)->Perl_re_intuit_start(prog, sv, strpos, strend, flags, data);
+}
+
+#undef  Perl_re_intuit_string
+SV*
+Perl_re_intuit_string(void *pPerl, regexp* prog)
+{
+    return ((CPerlObj*)pPerl)->Perl_re_intuit_string(prog);
+}
+
+#undef  Perl_regexec_flags
+I32
+Perl_regexec_flags(void *pPerl, regexp* prog, char* stringarg, char* strend, char* strbeg, I32 minend, SV* screamer, void* data, U32 flags)
+{
+    return ((CPerlObj*)pPerl)->Perl_regexec_flags(prog, stringarg, strend, strbeg, minend, screamer, data, flags);
+}
+
+#undef  Perl_regnext
+regnode*
+Perl_regnext(void *pPerl, regnode* p)
+{
+    return ((CPerlObj*)pPerl)->Perl_regnext(p);
+}
+
+#undef  Perl_regprop
+void
+Perl_regprop(void *pPerl, SV* sv, regnode* o)
+{
+    ((CPerlObj*)pPerl)->Perl_regprop(sv, o);
+}
+
+#undef  Perl_repeatcpy
+void
+Perl_repeatcpy(void *pPerl, char* to, const char* from, I32 len, I32 count)
+{
+    ((CPerlObj*)pPerl)->Perl_repeatcpy(to, from, len, count);
+}
+
+#undef  Perl_rninstr
+char*
+Perl_rninstr(void *pPerl, const char* big, const char* bigend, const char* little, const char* lend)
+{
+    return ((CPerlObj*)pPerl)->Perl_rninstr(big, bigend, little, lend);
+}
+
+#undef  Perl_rsignal
+Sighandler_t
+Perl_rsignal(void *pPerl, int i, Sighandler_t t)
+{
+    return ((CPerlObj*)pPerl)->Perl_rsignal(i, t);
+}
+
+#undef  Perl_rsignal_restore
+int
+Perl_rsignal_restore(void *pPerl, int i, Sigsave_t* t)
+{
+    return ((CPerlObj*)pPerl)->Perl_rsignal_restore(i, t);
+}
+
+#undef  Perl_rsignal_save
+int
+Perl_rsignal_save(void *pPerl, int i, Sighandler_t t1, Sigsave_t* t2)
+{
+    return ((CPerlObj*)pPerl)->Perl_rsignal_save(i, t1, t2);
+}
+
+#undef  Perl_rsignal_state
+Sighandler_t
+Perl_rsignal_state(void *pPerl, int i)
+{
+    return ((CPerlObj*)pPerl)->Perl_rsignal_state(i);
+}
+
+#undef  Perl_rxres_free
+void
+Perl_rxres_free(void *pPerl, void** rsp)
+{
+    ((CPerlObj*)pPerl)->Perl_rxres_free(rsp);
+}
+
+#undef  Perl_rxres_restore
+void
+Perl_rxres_restore(void *pPerl, void** rsp, REGEXP* prx)
+{
+    ((CPerlObj*)pPerl)->Perl_rxres_restore(rsp, prx);
+}
+
+#undef  Perl_rxres_save
+void
+Perl_rxres_save(void *pPerl, void** rsp, REGEXP* prx)
+{
+    ((CPerlObj*)pPerl)->Perl_rxres_save(rsp, prx);
+}
+#if !defined(HAS_RENAME)
+
+#undef  Perl_same_dirent
+I32
+Perl_same_dirent(void *pPerl, char* a, char* b)
+{
+    return ((CPerlObj*)pPerl)->Perl_same_dirent(a, b);
+}
+#endif
+
+#undef  Perl_savepv
+char*
+Perl_savepv(void *pPerl, const char* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_savepv(sv);
+}
+
+#undef  Perl_savepvn
+char*
+Perl_savepvn(void *pPerl, const char* sv, I32 len)
+{
+    return ((CPerlObj*)pPerl)->Perl_savepvn(sv, len);
+}
+
+#undef  Perl_savestack_grow
+void
+Perl_savestack_grow(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_savestack_grow();
+}
+
+#undef  Perl_save_aelem
+void
+Perl_save_aelem(void *pPerl, AV* av, I32 idx, SV **sptr)
+{
+    ((CPerlObj*)pPerl)->Perl_save_aelem(av, idx, sptr);
+}
+
+#undef  Perl_save_alloc
+I32
+Perl_save_alloc(void *pPerl, I32 size, I32 pad)
+{
+    return ((CPerlObj*)pPerl)->Perl_save_alloc(size, pad);
+}
+
+#undef  Perl_save_aptr
+void
+Perl_save_aptr(void *pPerl, AV** aptr)
+{
+    ((CPerlObj*)pPerl)->Perl_save_aptr(aptr);
+}
+
+#undef  Perl_save_ary
+AV*
+Perl_save_ary(void *pPerl, GV* gv)
+{
+    return ((CPerlObj*)pPerl)->Perl_save_ary(gv);
+}
+
+#undef  Perl_save_clearsv
+void
+Perl_save_clearsv(void *pPerl, SV** svp)
+{
+    ((CPerlObj*)pPerl)->Perl_save_clearsv(svp);
+}
+
+#undef  Perl_save_delete
+void
+Perl_save_delete(void *pPerl, HV* hv, char* key, I32 klen)
+{
+    ((CPerlObj*)pPerl)->Perl_save_delete(hv, key, klen);
+}
+
+#undef  Perl_save_destructor
+void
+Perl_save_destructor(void *pPerl, DESTRUCTORFUNC_t f, void* p)
+{
+    ((CPerlObj*)pPerl)->Perl_save_destructor(f, p);
+}
+
+#undef  Perl_save_freesv
+void
+Perl_save_freesv(void *pPerl, SV* sv)
+{
+    ((CPerlObj*)pPerl)->Perl_save_freesv(sv);
+}
+
+#undef  Perl_save_freeop
+void
+Perl_save_freeop(void *pPerl, OP* o)
+{
+    ((CPerlObj*)pPerl)->Perl_save_freeop(o);
+}
+
+#undef  Perl_save_freepv
+void
+Perl_save_freepv(void *pPerl, char* pv)
+{
+    ((CPerlObj*)pPerl)->Perl_save_freepv(pv);
+}
+
+#undef  Perl_save_generic_svref
+void
+Perl_save_generic_svref(void *pPerl, SV** sptr)
+{
+    ((CPerlObj*)pPerl)->Perl_save_generic_svref(sptr);
+}
+
+#undef  Perl_save_gp
+void
+Perl_save_gp(void *pPerl, GV* gv, I32 empty)
+{
+    ((CPerlObj*)pPerl)->Perl_save_gp(gv, empty);
+}
+
+#undef  Perl_save_hash
+HV*
+Perl_save_hash(void *pPerl, GV* gv)
+{
+    return ((CPerlObj*)pPerl)->Perl_save_hash(gv);
+}
+
+#undef  Perl_save_helem
+void
+Perl_save_helem(void *pPerl, HV* hv, SV *key, SV **sptr)
+{
+    ((CPerlObj*)pPerl)->Perl_save_helem(hv, key, sptr);
+}
+
+#undef  Perl_save_hints
+void
+Perl_save_hints(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_save_hints();
+}
+
+#undef  Perl_save_hptr
+void
+Perl_save_hptr(void *pPerl, HV** hptr)
+{
+    ((CPerlObj*)pPerl)->Perl_save_hptr(hptr);
+}
+
+#undef  Perl_save_I16
+void
+Perl_save_I16(void *pPerl, I16* intp)
+{
+    ((CPerlObj*)pPerl)->Perl_save_I16(intp);
+}
+
+#undef  Perl_save_I32
+void
+Perl_save_I32(void *pPerl, I32* intp)
+{
+    ((CPerlObj*)pPerl)->Perl_save_I32(intp);
+}
+
+#undef  Perl_save_int
+void
+Perl_save_int(void *pPerl, int* intp)
+{
+    ((CPerlObj*)pPerl)->Perl_save_int(intp);
+}
+
+#undef  Perl_save_item
+void
+Perl_save_item(void *pPerl, SV* item)
+{
+    ((CPerlObj*)pPerl)->Perl_save_item(item);
+}
+
+#undef  Perl_save_iv
+void
+Perl_save_iv(void *pPerl, IV* iv)
+{
+    ((CPerlObj*)pPerl)->Perl_save_iv(iv);
+}
+
+#undef  Perl_save_list
+void
+Perl_save_list(void *pPerl, SV** sarg, I32 maxsarg)
+{
+    ((CPerlObj*)pPerl)->Perl_save_list(sarg, maxsarg);
+}
+
+#undef  Perl_save_long
+void
+Perl_save_long(void *pPerl, long* longp)
+{
+    ((CPerlObj*)pPerl)->Perl_save_long(longp);
+}
+
+#undef  Perl_save_nogv
+void
+Perl_save_nogv(void *pPerl, GV* gv)
+{
+    ((CPerlObj*)pPerl)->Perl_save_nogv(gv);
+}
+
+#undef  Perl_save_op
+void
+Perl_save_op(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_save_op();
+}
+
+#undef  Perl_save_scalar
+SV*
+Perl_save_scalar(void *pPerl, GV* gv)
+{
+    return ((CPerlObj*)pPerl)->Perl_save_scalar(gv);
+}
+
+#undef  Perl_save_pptr
+void
+Perl_save_pptr(void *pPerl, char** pptr)
+{
+    ((CPerlObj*)pPerl)->Perl_save_pptr(pptr);
+}
+
+#undef  Perl_save_re_context
+void
+Perl_save_re_context(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_save_re_context();
+}
+
+#undef  Perl_save_sptr
+void
+Perl_save_sptr(void *pPerl, SV** sptr)
+{
+    ((CPerlObj*)pPerl)->Perl_save_sptr(sptr);
+}
+
+#undef  Perl_save_svref
+SV*
+Perl_save_svref(void *pPerl, SV** sptr)
+{
+    return ((CPerlObj*)pPerl)->Perl_save_svref(sptr);
+}
+
+#undef  Perl_save_threadsv
+SV**
+Perl_save_threadsv(void *pPerl, PADOFFSET i)
+{
+    return ((CPerlObj*)pPerl)->Perl_save_threadsv(i);
+}
+
+#undef  Perl_sawparens
+OP*
+Perl_sawparens(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_sawparens(o);
+}
+
+#undef  Perl_scalar
+OP*
+Perl_scalar(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_scalar(o);
+}
+
+#undef  Perl_scalarkids
+OP*
+Perl_scalarkids(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_scalarkids(o);
+}
+
+#undef  Perl_scalarseq
+OP*
+Perl_scalarseq(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_scalarseq(o);
+}
+
+#undef  Perl_scalarvoid
+OP*
+Perl_scalarvoid(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_scalarvoid(o);
+}
+
+#undef  Perl_scan_bin
+UV
+Perl_scan_bin(void *pPerl, char* start, I32 len, I32* retlen)
+{
+    return ((CPerlObj*)pPerl)->Perl_scan_bin(start, len, retlen);
+}
+
+#undef  Perl_scan_hex
+UV
+Perl_scan_hex(void *pPerl, char* start, I32 len, I32* retlen)
+{
+    return ((CPerlObj*)pPerl)->Perl_scan_hex(start, len, retlen);
+}
+
+#undef  Perl_scan_num
+char*
+Perl_scan_num(void *pPerl, char* s)
+{
+    return ((CPerlObj*)pPerl)->Perl_scan_num(s);
+}
+
+#undef  Perl_scan_oct
+UV
+Perl_scan_oct(void *pPerl, char* start, I32 len, I32* retlen)
+{
+    return ((CPerlObj*)pPerl)->Perl_scan_oct(start, len, retlen);
+}
+
+#undef  Perl_scope
+OP*
+Perl_scope(void *pPerl, OP* o)
+{
+    return ((CPerlObj*)pPerl)->Perl_scope(o);
+}
+
+#undef  Perl_screaminstr
+char*
+Perl_screaminstr(void *pPerl, SV* bigsv, SV* littlesv, I32 start_shift, I32 end_shift, I32 *state, I32 last)
+{
+    return ((CPerlObj*)pPerl)->Perl_screaminstr(bigsv, littlesv, start_shift, end_shift, state, last);
+}
+#if !defined(VMS)
+
+#undef  Perl_setenv_getix
+I32
+Perl_setenv_getix(void *pPerl, char* nam)
+{
+    return ((CPerlObj*)pPerl)->Perl_setenv_getix(nam);
+}
+#endif
+
+#undef  Perl_setdefout
+void
+Perl_setdefout(void *pPerl, GV* gv)
+{
+    ((CPerlObj*)pPerl)->Perl_setdefout(gv);
+}
+
+#undef  Perl_sharepvn
+char*
+Perl_sharepvn(void *pPerl, const char* sv, I32 len, U32 hash)
+{
+    return ((CPerlObj*)pPerl)->Perl_sharepvn(sv, len, hash);
+}
+
+#undef  Perl_share_hek
+HEK*
+Perl_share_hek(void *pPerl, const char* sv, I32 len, U32 hash)
+{
+    return ((CPerlObj*)pPerl)->Perl_share_hek(sv, len, hash);
+}
+
+#undef  Perl_sighandler
+Signal_t
+Perl_sighandler(void *pPerl, int sig)
+{
+    ((CPerlObj*)pPerl)->Perl_sighandler(sig);
+}
+
+#undef  Perl_stack_grow
+SV**
+Perl_stack_grow(void *pPerl, SV** sp, SV**p, int n)
+{
+    return ((CPerlObj*)pPerl)->Perl_stack_grow(sp, p, n);
+}
+
+#undef  Perl_start_subparse
+I32
+Perl_start_subparse(void *pPerl, I32 is_format, U32 flags)
+{
+    return ((CPerlObj*)pPerl)->Perl_start_subparse(is_format, flags);
+}
+
+#undef  Perl_sub_crush_depth
+void
+Perl_sub_crush_depth(void *pPerl, CV* cv)
+{
+    ((CPerlObj*)pPerl)->Perl_sub_crush_depth(cv);
+}
+
+#undef  Perl_sv_2bool
+bool
+Perl_sv_2bool(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_2bool(sv);
+}
+
+#undef  Perl_sv_2cv
+CV*
+Perl_sv_2cv(void *pPerl, SV* sv, HV** st, GV** gvp, I32 lref)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_2cv(sv, st, gvp, lref);
+}
+
+#undef  Perl_sv_2io
+IO*
+Perl_sv_2io(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_2io(sv);
+}
+
+#undef  Perl_sv_2iv
+IV
+Perl_sv_2iv(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_2iv(sv);
+}
+
+#undef  Perl_sv_2mortal
+SV*
+Perl_sv_2mortal(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_2mortal(sv);
+}
+
+#undef  Perl_sv_2nv
+NV
+Perl_sv_2nv(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_2nv(sv);
+}
+
+#undef  Perl_sv_2pv
+char*
+Perl_sv_2pv(void *pPerl, SV* sv, STRLEN* lp)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_2pv(sv, lp);
+}
+
+#undef  Perl_sv_2uv
+UV
+Perl_sv_2uv(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_2uv(sv);
+}
+
+#undef  Perl_sv_iv
+IV
+Perl_sv_iv(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_iv(sv);
+}
+
+#undef  Perl_sv_uv
+UV
+Perl_sv_uv(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_uv(sv);
+}
+
+#undef  Perl_sv_nv
+NV
+Perl_sv_nv(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_nv(sv);
+}
+
+#undef  Perl_sv_pvn
+char*
+Perl_sv_pvn(void *pPerl, SV *sv, STRLEN *len)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_pvn(sv, len);
+}
+
+#undef  Perl_sv_true
+I32
+Perl_sv_true(void *pPerl, SV *sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_true(sv);
+}
+
+#undef  Perl_sv_add_arena
+void
+Perl_sv_add_arena(void *pPerl, char* ptr, U32 size, U32 flags)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_add_arena(ptr, size, flags);
+}
+
+#undef  Perl_sv_backoff
+int
+Perl_sv_backoff(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_backoff(sv);
+}
+
+#undef  Perl_sv_bless
+SV*
+Perl_sv_bless(void *pPerl, SV* sv, HV* stash)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_bless(sv, stash);
+}
+
+#undef  Perl_sv_catpv
+void
+Perl_sv_catpv(void *pPerl, SV* sv, const char* ptr)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_catpv(sv, ptr);
+}
+
+#undef  Perl_sv_catpvn
+void
+Perl_sv_catpvn(void *pPerl, SV* sv, const char* ptr, STRLEN len)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_catpvn(sv, ptr, len);
+}
+
+#undef  Perl_sv_catsv
+void
+Perl_sv_catsv(void *pPerl, SV* dsv, SV* ssv)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_catsv(dsv, ssv);
+}
+
+#undef  Perl_sv_chop
+void
+Perl_sv_chop(void *pPerl, SV* sv, char* ptr)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_chop(sv, ptr);
+}
+
+#undef  Perl_sv_clean_all
+void
+Perl_sv_clean_all(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_clean_all();
+}
+
+#undef  Perl_sv_clean_objs
+void
+Perl_sv_clean_objs(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_clean_objs();
+}
+
+#undef  Perl_sv_clear
+void
+Perl_sv_clear(void *pPerl, SV* sv)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_clear(sv);
+}
+
+#undef  Perl_sv_cmp
+I32
+Perl_sv_cmp(void *pPerl, SV* sv1, SV* sv2)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_cmp(sv1, sv2);
+}
+
+#undef  Perl_sv_cmp_locale
+I32
+Perl_sv_cmp_locale(void *pPerl, SV* sv1, SV* sv2)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_cmp_locale(sv1, sv2);
+}
+#if defined(USE_LOCALE_COLLATE)
+
+#undef  Perl_sv_collxfrm
+char*
+Perl_sv_collxfrm(void *pPerl, SV* sv, STRLEN* nxp)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_collxfrm(sv, nxp);
+}
+#endif
+
+#undef  Perl_sv_compile_2op
+OP*
+Perl_sv_compile_2op(void *pPerl, SV* sv, OP** startp, char* code, AV** avp)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_compile_2op(sv, startp, code, avp);
+}
+
+#undef  Perl_sv_dec
+void
+Perl_sv_dec(void *pPerl, SV* sv)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_dec(sv);
+}
+
+#undef  Perl_sv_dump
+void
+Perl_sv_dump(void *pPerl, SV* sv)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_dump(sv);
+}
+
+#undef  Perl_sv_derived_from
+bool
+Perl_sv_derived_from(void *pPerl, SV* sv, const char* name)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_derived_from(sv, name);
+}
+
+#undef  Perl_sv_eq
+I32
+Perl_sv_eq(void *pPerl, SV* sv1, SV* sv2)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_eq(sv1, sv2);
+}
+
+#undef  Perl_sv_free
+void
+Perl_sv_free(void *pPerl, SV* sv)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_free(sv);
+}
+
+#undef  Perl_sv_free_arenas
+void
+Perl_sv_free_arenas(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_free_arenas();
+}
+
+#undef  Perl_sv_gets
+char*
+Perl_sv_gets(void *pPerl, SV* sv, PerlIO* fp, I32 append)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_gets(sv, fp, append);
+}
+
+#undef  Perl_sv_grow
+char*
+Perl_sv_grow(void *pPerl, SV* sv, STRLEN newlen)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_grow(sv, newlen);
+}
+
+#undef  Perl_sv_inc
+void
+Perl_sv_inc(void *pPerl, SV* sv)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_inc(sv);
+}
+
+#undef  Perl_sv_insert
+void
+Perl_sv_insert(void *pPerl, SV* bigsv, STRLEN offset, STRLEN len, char* little, STRLEN littlelen)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_insert(bigsv, offset, len, little, littlelen);
+}
+
+#undef  Perl_sv_isa
+int
+Perl_sv_isa(void *pPerl, SV* sv, const char* name)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_isa(sv, name);
+}
+
+#undef  Perl_sv_isobject
+int
+Perl_sv_isobject(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_isobject(sv);
+}
+
+#undef  Perl_sv_len
+STRLEN
+Perl_sv_len(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_len(sv);
+}
+
+#undef  Perl_sv_len_utf8
+STRLEN
+Perl_sv_len_utf8(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_len_utf8(sv);
+}
+
+#undef  Perl_sv_magic
+void
+Perl_sv_magic(void *pPerl, SV* sv, SV* obj, int how, const char* name, I32 namlen)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_magic(sv, obj, how, name, namlen);
+}
+
+#undef  Perl_sv_mortalcopy
+SV*
+Perl_sv_mortalcopy(void *pPerl, SV* oldsv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_mortalcopy(oldsv);
+}
+
+#undef  Perl_sv_newmortal
+SV*
+Perl_sv_newmortal(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_newmortal();
+}
+
+#undef  Perl_sv_newref
+SV*
+Perl_sv_newref(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_newref(sv);
+}
+
+#undef  Perl_sv_peek
+char*
+Perl_sv_peek(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_peek(sv);
+}
+
+#undef  Perl_sv_pos_u2b
+void
+Perl_sv_pos_u2b(void *pPerl, SV* sv, I32* offsetp, I32* lenp)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_pos_u2b(sv, offsetp, lenp);
+}
+
+#undef  Perl_sv_pos_b2u
+void
+Perl_sv_pos_b2u(void *pPerl, SV* sv, I32* offsetp)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_pos_b2u(sv, offsetp);
+}
+
+#undef  Perl_sv_pvn_force
+char*
+Perl_sv_pvn_force(void *pPerl, SV* sv, STRLEN* lp)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_pvn_force(sv, lp);
+}
+
+#undef  Perl_sv_reftype
+char*
+Perl_sv_reftype(void *pPerl, SV* sv, int ob)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_reftype(sv, ob);
+}
+
+#undef  Perl_sv_replace
+void
+Perl_sv_replace(void *pPerl, SV* sv, SV* nsv)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_replace(sv, nsv);
+}
+
+#undef  Perl_sv_report_used
+void
+Perl_sv_report_used(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_report_used();
+}
+
+#undef  Perl_sv_reset
+void
+Perl_sv_reset(void *pPerl, char* s, HV* stash)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_reset(s, stash);
+}
+
+#undef  Perl_sv_setiv
+void
+Perl_sv_setiv(void *pPerl, SV* sv, IV num)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_setiv(sv, num);
+}
+
+#undef  Perl_sv_setpviv
+void
+Perl_sv_setpviv(void *pPerl, SV* sv, IV num)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_setpviv(sv, num);
+}
+
+#undef  Perl_sv_setuv
+void
+Perl_sv_setuv(void *pPerl, SV* sv, UV num)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_setuv(sv, num);
+}
+
+#undef  Perl_sv_setnv
+void
+Perl_sv_setnv(void *pPerl, SV* sv, NV num)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_setnv(sv, num);
+}
+
+#undef  Perl_sv_setref_iv
+SV*
+Perl_sv_setref_iv(void *pPerl, SV* rv, const char* classname, IV iv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_setref_iv(rv, classname, iv);
+}
+
+#undef  Perl_sv_setref_nv
+SV*
+Perl_sv_setref_nv(void *pPerl, SV* rv, const char* classname, NV nv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_setref_nv(rv, classname, nv);
+}
+
+#undef  Perl_sv_setref_pv
+SV*
+Perl_sv_setref_pv(void *pPerl, SV* rv, const char* classname, void* pv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_setref_pv(rv, classname, pv);
+}
+
+#undef  Perl_sv_setref_pvn
+SV*
+Perl_sv_setref_pvn(void *pPerl, SV* rv, const char* classname, char* pv, STRLEN n)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_setref_pvn(rv, classname, pv, n);
+}
+
+#undef  Perl_sv_setpv
+void
+Perl_sv_setpv(void *pPerl, SV* sv, const char* ptr)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_setpv(sv, ptr);
+}
+
+#undef  Perl_sv_setpvn
+void
+Perl_sv_setpvn(void *pPerl, SV* sv, const char* ptr, STRLEN len)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_setpvn(sv, ptr, len);
+}
+
+#undef  Perl_sv_setsv
+void
+Perl_sv_setsv(void *pPerl, SV* dsv, SV* ssv)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_setsv(dsv, ssv);
+}
+
+#undef  Perl_sv_taint
+void
+Perl_sv_taint(void *pPerl, SV* sv)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_taint(sv);
+}
+
+#undef  Perl_sv_tainted
+bool
+Perl_sv_tainted(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_tainted(sv);
+}
+
+#undef  Perl_sv_unmagic
+int
+Perl_sv_unmagic(void *pPerl, SV* sv, int type)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_unmagic(sv, type);
+}
+
+#undef  Perl_sv_unref
+void
+Perl_sv_unref(void *pPerl, SV* sv)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_unref(sv);
+}
+
+#undef  Perl_sv_untaint
+void
+Perl_sv_untaint(void *pPerl, SV* sv)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_untaint(sv);
+}
+
+#undef  Perl_sv_upgrade
+bool
+Perl_sv_upgrade(void *pPerl, SV* sv, U32 mt)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_upgrade(sv, mt);
+}
+
+#undef  Perl_sv_usepvn
+void
+Perl_sv_usepvn(void *pPerl, SV* sv, char* ptr, STRLEN len)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_usepvn(sv, ptr, len);
+}
+
+#undef  Perl_sv_vcatpvfn
+void
+Perl_sv_vcatpvfn(void *pPerl, SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *used_locale)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_vcatpvfn(sv, pat, patlen, args, svargs, svmax, used_locale);
+}
+
+#undef  Perl_sv_vsetpvfn
+void
+Perl_sv_vsetpvfn(void *pPerl, SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *used_locale)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_vsetpvfn(sv, pat, patlen, args, svargs, svmax, used_locale);
+}
+
+#undef  Perl_swash_init
+SV*
+Perl_swash_init(void *pPerl, char* pkg, char* name, SV* listsv, I32 minbits, I32 none)
+{
+    return ((CPerlObj*)pPerl)->Perl_swash_init(pkg, name, listsv, minbits, none);
+}
+
+#undef  Perl_swash_fetch
+UV
+Perl_swash_fetch(void *pPerl, SV *sv, U8 *ptr)
+{
+    return ((CPerlObj*)pPerl)->Perl_swash_fetch(sv, ptr);
+}
+
+#undef  Perl_taint_env
+void
+Perl_taint_env(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_taint_env();
+}
+
+#undef  Perl_taint_proper
+void
+Perl_taint_proper(void *pPerl, const char* f, char* s)
+{
+    ((CPerlObj*)pPerl)->Perl_taint_proper(f, s);
+}
+
+#undef  Perl_to_utf8_lower
+UV
+Perl_to_utf8_lower(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_to_utf8_lower(p);
+}
+
+#undef  Perl_to_utf8_upper
+UV
+Perl_to_utf8_upper(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_to_utf8_upper(p);
+}
+
+#undef  Perl_to_utf8_title
+UV
+Perl_to_utf8_title(void *pPerl, U8 *p)
+{
+    return ((CPerlObj*)pPerl)->Perl_to_utf8_title(p);
+}
+#if defined(UNLINK_ALL_VERSIONS)
+
+#undef  Perl_unlnk
+I32
+Perl_unlnk(void *pPerl, char* f)
+{
+    return ((CPerlObj*)pPerl)->Perl_unlnk(f);
+}
+#endif
+#if defined(USE_THREADS)
+
+#undef  Perl_unlock_condpair
+void
+Perl_unlock_condpair(void *pPerl, void* svv)
+{
+    ((CPerlObj*)pPerl)->Perl_unlock_condpair(svv);
+}
+#endif
+
+#undef  Perl_unsharepvn
+void
+Perl_unsharepvn(void *pPerl, const char* sv, I32 len, U32 hash)
+{
+    ((CPerlObj*)pPerl)->Perl_unsharepvn(sv, len, hash);
+}
+
+#undef  Perl_unshare_hek
+void
+Perl_unshare_hek(void *pPerl, HEK* hek)
+{
+    ((CPerlObj*)pPerl)->Perl_unshare_hek(hek);
+}
+
+#undef  Perl_utilize
+void
+Perl_utilize(void *pPerl, int aver, I32 floor, OP* version, OP* id, OP* arg)
+{
+    ((CPerlObj*)pPerl)->Perl_utilize(aver, floor, version, id, arg);
+}
+
+#undef  Perl_utf16_to_utf8
+U8*
+Perl_utf16_to_utf8(void *pPerl, U16* p, U8 *d, I32 bytelen)
+{
+    return ((CPerlObj*)pPerl)->Perl_utf16_to_utf8(p, d, bytelen);
+}
+
+#undef  Perl_utf16_to_utf8_reversed
+U8*
+Perl_utf16_to_utf8_reversed(void *pPerl, U16* p, U8 *d, I32 bytelen)
+{
+    return ((CPerlObj*)pPerl)->Perl_utf16_to_utf8_reversed(p, d, bytelen);
+}
+
+#undef  Perl_utf8_distance
+I32
+Perl_utf8_distance(void *pPerl, U8 *a, U8 *b)
+{
+    return ((CPerlObj*)pPerl)->Perl_utf8_distance(a, b);
+}
+
+#undef  Perl_utf8_hop
+U8*
+Perl_utf8_hop(void *pPerl, U8 *s, I32 off)
+{
+    return ((CPerlObj*)pPerl)->Perl_utf8_hop(s, off);
+}
+
+#undef  Perl_utf8_to_uv
+UV
+Perl_utf8_to_uv(void *pPerl, U8 *s, I32* retlen)
+{
+    return ((CPerlObj*)pPerl)->Perl_utf8_to_uv(s, retlen);
+}
+
+#undef  Perl_uv_to_utf8
+U8*
+Perl_uv_to_utf8(void *pPerl, U8 *d, UV uv)
+{
+    return ((CPerlObj*)pPerl)->Perl_uv_to_utf8(d, uv);
+}
+
+#undef  Perl_vivify_defelem
+void
+Perl_vivify_defelem(void *pPerl, SV* sv)
+{
+    ((CPerlObj*)pPerl)->Perl_vivify_defelem(sv);
+}
+
+#undef  Perl_vivify_ref
+void
+Perl_vivify_ref(void *pPerl, SV* sv, U32 to_what)
+{
+    ((CPerlObj*)pPerl)->Perl_vivify_ref(sv, to_what);
+}
+
+#undef  Perl_wait4pid
+I32
+Perl_wait4pid(void *pPerl, int pid, int* statusp, int flags)
+{
+    return ((CPerlObj*)pPerl)->Perl_wait4pid(pid, statusp, flags);
+}
+
+#undef  Perl_watch
+void
+Perl_watch(void *pPerl, char** addr)
+{
+    ((CPerlObj*)pPerl)->Perl_watch(addr);
+}
+
+#undef  Perl_whichsig
+I32
+Perl_whichsig(void *pPerl, char* sig)
+{
+    return ((CPerlObj*)pPerl)->Perl_whichsig(sig);
+}
+
+#undef  Perl_yyerror
+int
+Perl_yyerror(void *pPerl, char* s)
+{
+    return ((CPerlObj*)pPerl)->Perl_yyerror(s);
+}
+#if defined(USE_PURE_BISON)
+
+#undef  Perl_yylex
+int
+Perl_yylex(void *pPerl, YYSTYPE *lvalp, int *lcharp)
+{
+    return ((CPerlObj*)pPerl)->Perl_yylex(lvalp, lcharp);
+}
+#else
+
+#undef  Perl_yylex
+int
+Perl_yylex(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_yylex();
+}
+#endif
+
+#undef  Perl_yyparse
+int
+Perl_yyparse(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_yyparse();
+}
+
+#undef  Perl_yywarn
+int
+Perl_yywarn(void *pPerl, char* s)
+{
+    return ((CPerlObj*)pPerl)->Perl_yywarn(s);
+}
+#if defined(MYMALLOC)
+
+#undef  Perl_dump_mstats
+void
+Perl_dump_mstats(void *pPerl, char* s)
+{
+    ((CPerlObj*)pPerl)->Perl_dump_mstats(s);
+}
+
+#undef  Perl_malloc
+Malloc_t
+Perl_malloc(void *pPerl, MEM_SIZE nbytes)
+{
+    return ((CPerlObj*)pPerl)->Perl_malloc(nbytes);
+}
+
+#undef  Perl_calloc
+Malloc_t
+Perl_calloc(void *pPerl, MEM_SIZE elements, MEM_SIZE size)
+{
+    return ((CPerlObj*)pPerl)->Perl_calloc(elements, size);
+}
+
+#undef  Perl_realloc
+Malloc_t
+Perl_realloc(void *pPerl, Malloc_t where, MEM_SIZE nbytes)
+{
+    return ((CPerlObj*)pPerl)->Perl_realloc(where, nbytes);
+}
+
+#undef  Perl_mfree
+Free_t
+Perl_mfree(void *pPerl, Malloc_t where)
+{
+    ((CPerlObj*)pPerl)->Perl_mfree(where);
+}
+#endif
+
+#undef  Perl_safesysmalloc
+Malloc_t
+Perl_safesysmalloc(void *pPerl, MEM_SIZE nbytes)
+{
+    return ((CPerlObj*)pPerl)->Perl_safesysmalloc(nbytes);
+}
+
+#undef  Perl_safesyscalloc
+Malloc_t
+Perl_safesyscalloc(void *pPerl, MEM_SIZE elements, MEM_SIZE size)
+{
+    return ((CPerlObj*)pPerl)->Perl_safesyscalloc(elements, size);
+}
+
+#undef  Perl_safesysrealloc
+Malloc_t
+Perl_safesysrealloc(void *pPerl, Malloc_t where, MEM_SIZE nbytes)
+{
+    return ((CPerlObj*)pPerl)->Perl_safesysrealloc(where, nbytes);
+}
+
+#undef  Perl_safesysfree
+Free_t
+Perl_safesysfree(void *pPerl, Malloc_t where)
+{
+    ((CPerlObj*)pPerl)->Perl_safesysfree(where);
+}
+#if defined(LEAKTEST)
+
+#undef  Perl_safexmalloc
+Malloc_t
+Perl_safexmalloc(void *pPerl, I32 x, MEM_SIZE size)
+{
+    return ((CPerlObj*)pPerl)->Perl_safexmalloc(x, size);
+}
+
+#undef  Perl_safexcalloc
+Malloc_t
+Perl_safexcalloc(void *pPerl, I32 x, MEM_SIZE elements, MEM_SIZE size)
+{
+    return ((CPerlObj*)pPerl)->Perl_safexcalloc(x, elements, size);
+}
+
+#undef  Perl_safexrealloc
+Malloc_t
+Perl_safexrealloc(void *pPerl, Malloc_t where, MEM_SIZE size)
+{
+    return ((CPerlObj*)pPerl)->Perl_safexrealloc(where, size);
+}
+
+#undef  Perl_safexfree
+void
+Perl_safexfree(void *pPerl, Malloc_t where)
+{
+    ((CPerlObj*)pPerl)->Perl_safexfree(where);
+}
+#endif
+#if defined(PERL_GLOBAL_STRUCT)
+
+#undef  Perl_GetVars
+struct perl_vars *
+Perl_GetVars(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_GetVars();
+}
+#endif
+
+#undef  Perl_runops_standard
+int
+Perl_runops_standard(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_runops_standard();
+}
+
+#undef  Perl_runops_debug
+int
+Perl_runops_debug(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_runops_debug();
+}
+
+#undef  Perl_sv_catpv_mg
+void
+Perl_sv_catpv_mg(void *pPerl, SV *sv, const char *ptr)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_catpv_mg(sv, ptr);
+}
+
+#undef  Perl_sv_catpvn_mg
+void
+Perl_sv_catpvn_mg(void *pPerl, SV *sv, const char *ptr, STRLEN len)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_catpvn_mg(sv, ptr, len);
+}
+
+#undef  Perl_sv_catsv_mg
+void
+Perl_sv_catsv_mg(void *pPerl, SV *dstr, SV *sstr)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_catsv_mg(dstr, sstr);
+}
+
+#undef  Perl_sv_setiv_mg
+void
+Perl_sv_setiv_mg(void *pPerl, SV *sv, IV i)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_setiv_mg(sv, i);
+}
+
+#undef  Perl_sv_setpviv_mg
+void
+Perl_sv_setpviv_mg(void *pPerl, SV *sv, IV iv)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_setpviv_mg(sv, iv);
+}
+
+#undef  Perl_sv_setuv_mg
+void
+Perl_sv_setuv_mg(void *pPerl, SV *sv, UV u)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_setuv_mg(sv, u);
+}
+
+#undef  Perl_sv_setnv_mg
+void
+Perl_sv_setnv_mg(void *pPerl, SV *sv, NV num)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_setnv_mg(sv, num);
+}
+
+#undef  Perl_sv_setpv_mg
+void
+Perl_sv_setpv_mg(void *pPerl, SV *sv, const char *ptr)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_setpv_mg(sv, ptr);
+}
+
+#undef  Perl_sv_setpvn_mg
+void
+Perl_sv_setpvn_mg(void *pPerl, SV *sv, const char *ptr, STRLEN len)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_setpvn_mg(sv, ptr, len);
+}
+
+#undef  Perl_sv_setsv_mg
+void
+Perl_sv_setsv_mg(void *pPerl, SV *dstr, SV *sstr)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_setsv_mg(dstr, sstr);
+}
+
+#undef  Perl_sv_usepvn_mg
+void
+Perl_sv_usepvn_mg(void *pPerl, SV *sv, char *ptr, STRLEN len)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_usepvn_mg(sv, ptr, len);
+}
+
+#undef  Perl_get_vtbl
+MGVTBL*
+Perl_get_vtbl(void *pPerl, int vtbl_id)
+{
+    return ((CPerlObj*)pPerl)->Perl_get_vtbl(vtbl_id);
+}
+
+#undef  Perl_pv_display
+char*
+Perl_pv_display(void *pPerl, SV *sv, char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)
+{
+    return ((CPerlObj*)pPerl)->Perl_pv_display(sv, pv, cur, len, pvlim);
+}
+
+#undef  Perl_do_gv_dump
+void
+Perl_do_gv_dump(void *pPerl, I32 level, PerlIO *file, char *name, GV *sv)
+{
+    ((CPerlObj*)pPerl)->Perl_do_gv_dump(level, file, name, sv);
+}
+
+#undef  Perl_do_gvgv_dump
+void
+Perl_do_gvgv_dump(void *pPerl, I32 level, PerlIO *file, char *name, GV *sv)
+{
+    ((CPerlObj*)pPerl)->Perl_do_gvgv_dump(level, file, name, sv);
+}
+
+#undef  Perl_do_hv_dump
+void
+Perl_do_hv_dump(void *pPerl, I32 level, PerlIO *file, char *name, HV *sv)
+{
+    ((CPerlObj*)pPerl)->Perl_do_hv_dump(level, file, name, sv);
+}
+
+#undef  Perl_do_magic_dump
+void
+Perl_do_magic_dump(void *pPerl, I32 level, PerlIO *file, MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim)
+{
+    ((CPerlObj*)pPerl)->Perl_do_magic_dump(level, file, mg, nest, maxnest, dumpops, pvlim);
+}
+
+#undef  Perl_do_op_dump
+void
+Perl_do_op_dump(void *pPerl, I32 level, PerlIO *file, OP *o)
+{
+    ((CPerlObj*)pPerl)->Perl_do_op_dump(level, file, o);
+}
+
+#undef  Perl_do_pmop_dump
+void
+Perl_do_pmop_dump(void *pPerl, I32 level, PerlIO *file, PMOP *pm)
+{
+    ((CPerlObj*)pPerl)->Perl_do_pmop_dump(level, file, pm);
+}
+
+#undef  Perl_do_sv_dump
+void
+Perl_do_sv_dump(void *pPerl, I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim)
+{
+    ((CPerlObj*)pPerl)->Perl_do_sv_dump(level, file, sv, nest, maxnest, dumpops, pvlim);
+}
+
+#undef  Perl_magic_dump
+void
+Perl_magic_dump(void *pPerl, MAGIC *mg)
+{
+    ((CPerlObj*)pPerl)->Perl_magic_dump(mg);
+}
+
+#undef  Perl_reginitcolors
+void
+Perl_reginitcolors(void *pPerl)
+{
+    ((CPerlObj*)pPerl)->Perl_reginitcolors();
+}
+
+#undef  Perl_sv_2pv_nolen
+char*
+Perl_sv_2pv_nolen(void *pPerl, SV* sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_2pv_nolen(sv);
+}
+
+#undef  Perl_sv_pv
+char*
+Perl_sv_pv(void *pPerl, SV *sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_pv(sv);
+}
+
+#undef  Perl_sv_force_normal
+void
+Perl_sv_force_normal(void *pPerl, SV *sv)
+{
+    ((CPerlObj*)pPerl)->Perl_sv_force_normal(sv);
+}
+
+#undef  Perl_tmps_grow
+void
+Perl_tmps_grow(void *pPerl, I32 n)
+{
+    ((CPerlObj*)pPerl)->Perl_tmps_grow(n);
+}
+
+#undef  Perl_sv_rvweaken
+SV*
+Perl_sv_rvweaken(void *pPerl, SV *sv)
+{
+    return ((CPerlObj*)pPerl)->Perl_sv_rvweaken(sv);
+}
+
+#undef  Perl_magic_killbackrefs
+int
+Perl_magic_killbackrefs(void *pPerl, SV *sv, MAGIC *mg)
+{
+    return ((CPerlObj*)pPerl)->Perl_magic_killbackrefs(sv, mg);
+}
+#if defined(PERL_OBJECT)
+#endif
+#if defined(PERL_IN_AV_C) || defined(PERL_DECL_PROT)
+#endif
+#if defined(PERL_IN_DOOP_C) || defined(PERL_DECL_PROT)
+#endif
+#if defined(PERL_IN_GV_C) || defined(PERL_DECL_PROT)
+#endif
+#if defined(PERL_IN_HV_C) || defined(PERL_DECL_PROT)
+#endif
+#if defined(PERL_IN_MG_C) || defined(PERL_DECL_PROT)
+#endif
+#if defined(PERL_IN_OP_C) || defined(PERL_DECL_PROT)
+#  if defined(PL_OP_SLAB_ALLOC)
+#  endif
+#endif
+#if defined(PERL_IN_PERL_C) || defined(PERL_DECL_PROT)
+#  if defined(IAMSUID)
+#  endif
+#  if defined(USE_THREADS)
+#  endif
+#endif
+#if defined(PERL_IN_PP_C) || defined(PERL_DECL_PROT)
+#endif
+#if defined(PERL_IN_PP_CTL_C) || defined(PERL_DECL_PROT)
+#endif
+#if defined(PERL_IN_PP_HOT_C) || defined(PERL_DECL_PROT)
+#endif
+#if defined(PERL_IN_PP_SYS_C) || defined(PERL_DECL_PROT)
+#  if !defined(HAS_MKDIR) || !defined(HAS_RMDIR)
+#  endif
+#endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_DECL_PROT)
+#endif
+#if defined(PERL_IN_REGEXEC_C) || defined(PERL_DECL_PROT)
+#endif
+#if defined(PERL_IN_RUN_C) || defined(PERL_DECL_PROT)
+#endif
+#if defined(PERL_IN_SCOPE_C) || defined(PERL_DECL_PROT)
+#endif
+#if defined(PERL_IN_SV_C) || defined(PERL_DECL_PROT)
+#  if defined(PURIFY)
+#  else
+#  endif
+#  if defined(DEBUGGING)
+#  endif
+#endif
+#if defined(PERL_IN_TOKE_C) || defined(PERL_DECL_PROT)
+#  if defined(CRIPPLED_CC)
+#  endif
+#  if defined(WIN32)
+#  endif
+#endif
+#if defined(PERL_IN_UNIVERSAL_C) || defined(PERL_DECL_PROT)
+#endif
+#if defined(PERL_IN_UTIL_C) || defined(PERL_DECL_PROT)
+#  if defined(LEAKTEST)
+#  endif
+#endif
+
+#undef  Perl_ck_anoncode
+OP *
+Perl_ck_anoncode(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_anoncode(o);
+}
+
+#undef  Perl_ck_bitop
+OP *
+Perl_ck_bitop(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_bitop(o);
+}
+
+#undef  Perl_ck_concat
+OP *
+Perl_ck_concat(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_concat(o);
+}
+
+#undef  Perl_ck_defined
+OP *
+Perl_ck_defined(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_defined(o);
+}
+
+#undef  Perl_ck_delete
+OP *
+Perl_ck_delete(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_delete(o);
+}
+
+#undef  Perl_ck_eof
+OP *
+Perl_ck_eof(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_eof(o);
+}
+
+#undef  Perl_ck_eval
+OP *
+Perl_ck_eval(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_eval(o);
+}
+
+#undef  Perl_ck_exec
+OP *
+Perl_ck_exec(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_exec(o);
+}
+
+#undef  Perl_ck_exists
+OP *
+Perl_ck_exists(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_exists(o);
+}
+
+#undef  Perl_ck_ftst
+OP *
+Perl_ck_ftst(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_ftst(o);
+}
+
+#undef  Perl_ck_fun
+OP *
+Perl_ck_fun(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_fun(o);
+}
+
+#undef  Perl_ck_fun_locale
+OP *
+Perl_ck_fun_locale(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_fun_locale(o);
+}
+
+#undef  Perl_ck_glob
+OP *
+Perl_ck_glob(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_glob(o);
+}
+
+#undef  Perl_ck_grep
+OP *
+Perl_ck_grep(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_grep(o);
+}
+
+#undef  Perl_ck_index
+OP *
+Perl_ck_index(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_index(o);
+}
+
+#undef  Perl_ck_lengthconst
+OP *
+Perl_ck_lengthconst(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_lengthconst(o);
+}
+
+#undef  Perl_ck_lfun
+OP *
+Perl_ck_lfun(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_lfun(o);
+}
+
+#undef  Perl_ck_listiob
+OP *
+Perl_ck_listiob(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_listiob(o);
+}
+
+#undef  Perl_ck_match
+OP *
+Perl_ck_match(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_match(o);
+}
+
+#undef  Perl_ck_null
+OP *
+Perl_ck_null(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_null(o);
+}
+
+#undef  Perl_ck_repeat
+OP *
+Perl_ck_repeat(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_repeat(o);
+}
+
+#undef  Perl_ck_require
+OP *
+Perl_ck_require(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_require(o);
+}
+
+#undef  Perl_ck_rfun
+OP *
+Perl_ck_rfun(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_rfun(o);
+}
+
+#undef  Perl_ck_rvconst
+OP *
+Perl_ck_rvconst(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_rvconst(o);
+}
+
+#undef  Perl_ck_sassign
+OP *
+Perl_ck_sassign(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_sassign(o);
+}
+
+#undef  Perl_ck_scmp
+OP *
+Perl_ck_scmp(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_scmp(o);
+}
+
+#undef  Perl_ck_select
+OP *
+Perl_ck_select(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_select(o);
+}
+
+#undef  Perl_ck_shift
+OP *
+Perl_ck_shift(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_shift(o);
+}
+
+#undef  Perl_ck_sort
+OP *
+Perl_ck_sort(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_sort(o);
+}
+
+#undef  Perl_ck_spair
+OP *
+Perl_ck_spair(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_spair(o);
+}
+
+#undef  Perl_ck_split
+OP *
+Perl_ck_split(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_split(o);
+}
+
+#undef  Perl_ck_subr
+OP *
+Perl_ck_subr(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_subr(o);
+}
+
+#undef  Perl_ck_svconst
+OP *
+Perl_ck_svconst(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_svconst(o);
+}
+
+#undef  Perl_ck_trunc
+OP *
+Perl_ck_trunc(void *pPerl, OP *o)
+{
+    return ((CPerlObj*)pPerl)->Perl_ck_trunc(o);
+}
+
+#undef  Perl_pp_aassign
+OP *
+Perl_pp_aassign(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_aassign();
+}
+
+#undef  Perl_pp_abs
+OP *
+Perl_pp_abs(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_abs();
+}
+
+#undef  Perl_pp_accept
+OP *
+Perl_pp_accept(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_accept();
+}
+
+#undef  Perl_pp_add
+OP *
+Perl_pp_add(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_add();
+}
+
+#undef  Perl_pp_aelem
+OP *
+Perl_pp_aelem(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_aelem();
+}
+
+#undef  Perl_pp_aelemfast
+OP *
+Perl_pp_aelemfast(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_aelemfast();
+}
+
+#undef  Perl_pp_alarm
+OP *
+Perl_pp_alarm(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_alarm();
+}
+
+#undef  Perl_pp_and
+OP *
+Perl_pp_and(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_and();
+}
+
+#undef  Perl_pp_andassign
+OP *
+Perl_pp_andassign(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_andassign();
+}
+
+#undef  Perl_pp_anoncode
+OP *
+Perl_pp_anoncode(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_anoncode();
+}
+
+#undef  Perl_pp_anonhash
+OP *
+Perl_pp_anonhash(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_anonhash();
+}
+
+#undef  Perl_pp_anonlist
+OP *
+Perl_pp_anonlist(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_anonlist();
+}
+
+#undef  Perl_pp_aslice
+OP *
+Perl_pp_aslice(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_aslice();
+}
+
+#undef  Perl_pp_atan2
+OP *
+Perl_pp_atan2(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_atan2();
+}
+
+#undef  Perl_pp_av2arylen
+OP *
+Perl_pp_av2arylen(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_av2arylen();
+}
+
+#undef  Perl_pp_backtick
+OP *
+Perl_pp_backtick(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_backtick();
+}
+
+#undef  Perl_pp_bind
+OP *
+Perl_pp_bind(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_bind();
+}
+
+#undef  Perl_pp_binmode
+OP *
+Perl_pp_binmode(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_binmode();
+}
+
+#undef  Perl_pp_bit_and
+OP *
+Perl_pp_bit_and(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_bit_and();
+}
+
+#undef  Perl_pp_bit_or
+OP *
+Perl_pp_bit_or(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_bit_or();
+}
+
+#undef  Perl_pp_bit_xor
+OP *
+Perl_pp_bit_xor(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_bit_xor();
+}
+
+#undef  Perl_pp_bless
+OP *
+Perl_pp_bless(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_bless();
+}
+
+#undef  Perl_pp_caller
+OP *
+Perl_pp_caller(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_caller();
+}
+
+#undef  Perl_pp_chdir
+OP *
+Perl_pp_chdir(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_chdir();
+}
+
+#undef  Perl_pp_chmod
+OP *
+Perl_pp_chmod(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_chmod();
+}
+
+#undef  Perl_pp_chomp
+OP *
+Perl_pp_chomp(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_chomp();
+}
+
+#undef  Perl_pp_chop
+OP *
+Perl_pp_chop(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_chop();
+}
+
+#undef  Perl_pp_chown
+OP *
+Perl_pp_chown(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_chown();
+}
+
+#undef  Perl_pp_chr
+OP *
+Perl_pp_chr(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_chr();
+}
+
+#undef  Perl_pp_chroot
+OP *
+Perl_pp_chroot(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_chroot();
+}
+
+#undef  Perl_pp_close
+OP *
+Perl_pp_close(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_close();
+}
+
+#undef  Perl_pp_closedir
+OP *
+Perl_pp_closedir(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_closedir();
+}
+
+#undef  Perl_pp_complement
+OP *
+Perl_pp_complement(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_complement();
+}
+
+#undef  Perl_pp_concat
+OP *
+Perl_pp_concat(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_concat();
+}
+
+#undef  Perl_pp_cond_expr
+OP *
+Perl_pp_cond_expr(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_cond_expr();
+}
+
+#undef  Perl_pp_connect
+OP *
+Perl_pp_connect(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_connect();
+}
+
+#undef  Perl_pp_const
+OP *
+Perl_pp_const(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_const();
+}
+
+#undef  Perl_pp_cos
+OP *
+Perl_pp_cos(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_cos();
+}
+
+#undef  Perl_pp_crypt
+OP *
+Perl_pp_crypt(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_crypt();
+}
+
+#undef  Perl_pp_dbmclose
+OP *
+Perl_pp_dbmclose(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_dbmclose();
+}
+
+#undef  Perl_pp_dbmopen
+OP *
+Perl_pp_dbmopen(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_dbmopen();
+}
+
+#undef  Perl_pp_dbstate
+OP *
+Perl_pp_dbstate(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_dbstate();
+}
+
+#undef  Perl_pp_defined
+OP *
+Perl_pp_defined(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_defined();
+}
+
+#undef  Perl_pp_delete
+OP *
+Perl_pp_delete(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_delete();
+}
+
+#undef  Perl_pp_die
+OP *
+Perl_pp_die(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_die();
+}
+
+#undef  Perl_pp_divide
+OP *
+Perl_pp_divide(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_divide();
+}
+
+#undef  Perl_pp_dofile
+OP *
+Perl_pp_dofile(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_dofile();
+}
+
+#undef  Perl_pp_dump
+OP *
+Perl_pp_dump(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_dump();
+}
+
+#undef  Perl_pp_each
+OP *
+Perl_pp_each(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_each();
+}
+
+#undef  Perl_pp_egrent
+OP *
+Perl_pp_egrent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_egrent();
+}
+
+#undef  Perl_pp_ehostent
+OP *
+Perl_pp_ehostent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ehostent();
+}
+
+#undef  Perl_pp_enetent
+OP *
+Perl_pp_enetent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_enetent();
+}
+
+#undef  Perl_pp_enter
+OP *
+Perl_pp_enter(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_enter();
+}
+
+#undef  Perl_pp_entereval
+OP *
+Perl_pp_entereval(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_entereval();
+}
+
+#undef  Perl_pp_enteriter
+OP *
+Perl_pp_enteriter(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_enteriter();
+}
+
+#undef  Perl_pp_enterloop
+OP *
+Perl_pp_enterloop(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_enterloop();
+}
+
+#undef  Perl_pp_entersub
+OP *
+Perl_pp_entersub(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_entersub();
+}
+
+#undef  Perl_pp_entertry
+OP *
+Perl_pp_entertry(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_entertry();
+}
+
+#undef  Perl_pp_enterwrite
+OP *
+Perl_pp_enterwrite(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_enterwrite();
+}
+
+#undef  Perl_pp_eof
+OP *
+Perl_pp_eof(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_eof();
+}
+
+#undef  Perl_pp_eprotoent
+OP *
+Perl_pp_eprotoent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_eprotoent();
+}
+
+#undef  Perl_pp_epwent
+OP *
+Perl_pp_epwent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_epwent();
+}
+
+#undef  Perl_pp_eq
+OP *
+Perl_pp_eq(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_eq();
+}
+
+#undef  Perl_pp_eservent
+OP *
+Perl_pp_eservent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_eservent();
+}
+
+#undef  Perl_pp_exec
+OP *
+Perl_pp_exec(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_exec();
+}
+
+#undef  Perl_pp_exists
+OP *
+Perl_pp_exists(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_exists();
+}
+
+#undef  Perl_pp_exit
+OP *
+Perl_pp_exit(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_exit();
+}
+
+#undef  Perl_pp_exp
+OP *
+Perl_pp_exp(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_exp();
+}
+
+#undef  Perl_pp_fcntl
+OP *
+Perl_pp_fcntl(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_fcntl();
+}
+
+#undef  Perl_pp_fileno
+OP *
+Perl_pp_fileno(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_fileno();
+}
+
+#undef  Perl_pp_flip
+OP *
+Perl_pp_flip(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_flip();
+}
+
+#undef  Perl_pp_flock
+OP *
+Perl_pp_flock(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_flock();
+}
+
+#undef  Perl_pp_flop
+OP *
+Perl_pp_flop(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_flop();
+}
+
+#undef  Perl_pp_fork
+OP *
+Perl_pp_fork(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_fork();
+}
+
+#undef  Perl_pp_formline
+OP *
+Perl_pp_formline(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_formline();
+}
+
+#undef  Perl_pp_ftatime
+OP *
+Perl_pp_ftatime(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftatime();
+}
+
+#undef  Perl_pp_ftbinary
+OP *
+Perl_pp_ftbinary(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftbinary();
+}
+
+#undef  Perl_pp_ftblk
+OP *
+Perl_pp_ftblk(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftblk();
+}
+
+#undef  Perl_pp_ftchr
+OP *
+Perl_pp_ftchr(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftchr();
+}
+
+#undef  Perl_pp_ftctime
+OP *
+Perl_pp_ftctime(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftctime();
+}
+
+#undef  Perl_pp_ftdir
+OP *
+Perl_pp_ftdir(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftdir();
+}
+
+#undef  Perl_pp_fteexec
+OP *
+Perl_pp_fteexec(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_fteexec();
+}
+
+#undef  Perl_pp_fteowned
+OP *
+Perl_pp_fteowned(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_fteowned();
+}
+
+#undef  Perl_pp_fteread
+OP *
+Perl_pp_fteread(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_fteread();
+}
+
+#undef  Perl_pp_ftewrite
+OP *
+Perl_pp_ftewrite(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftewrite();
+}
+
+#undef  Perl_pp_ftfile
+OP *
+Perl_pp_ftfile(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftfile();
+}
+
+#undef  Perl_pp_ftis
+OP *
+Perl_pp_ftis(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftis();
+}
+
+#undef  Perl_pp_ftlink
+OP *
+Perl_pp_ftlink(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftlink();
+}
+
+#undef  Perl_pp_ftmtime
+OP *
+Perl_pp_ftmtime(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftmtime();
+}
+
+#undef  Perl_pp_ftpipe
+OP *
+Perl_pp_ftpipe(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftpipe();
+}
+
+#undef  Perl_pp_ftrexec
+OP *
+Perl_pp_ftrexec(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftrexec();
+}
+
+#undef  Perl_pp_ftrowned
+OP *
+Perl_pp_ftrowned(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftrowned();
+}
+
+#undef  Perl_pp_ftrread
+OP *
+Perl_pp_ftrread(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftrread();
+}
+
+#undef  Perl_pp_ftrwrite
+OP *
+Perl_pp_ftrwrite(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftrwrite();
+}
+
+#undef  Perl_pp_ftsgid
+OP *
+Perl_pp_ftsgid(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftsgid();
+}
+
+#undef  Perl_pp_ftsize
+OP *
+Perl_pp_ftsize(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftsize();
+}
+
+#undef  Perl_pp_ftsock
+OP *
+Perl_pp_ftsock(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftsock();
+}
+
+#undef  Perl_pp_ftsuid
+OP *
+Perl_pp_ftsuid(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftsuid();
+}
+
+#undef  Perl_pp_ftsvtx
+OP *
+Perl_pp_ftsvtx(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftsvtx();
+}
+
+#undef  Perl_pp_fttext
+OP *
+Perl_pp_fttext(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_fttext();
+}
+
+#undef  Perl_pp_fttty
+OP *
+Perl_pp_fttty(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_fttty();
+}
+
+#undef  Perl_pp_ftzero
+OP *
+Perl_pp_ftzero(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ftzero();
+}
+
+#undef  Perl_pp_ge
+OP *
+Perl_pp_ge(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ge();
+}
+
+#undef  Perl_pp_gelem
+OP *
+Perl_pp_gelem(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gelem();
+}
+
+#undef  Perl_pp_getc
+OP *
+Perl_pp_getc(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_getc();
+}
+
+#undef  Perl_pp_getlogin
+OP *
+Perl_pp_getlogin(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_getlogin();
+}
+
+#undef  Perl_pp_getpeername
+OP *
+Perl_pp_getpeername(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_getpeername();
+}
+
+#undef  Perl_pp_getpgrp
+OP *
+Perl_pp_getpgrp(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_getpgrp();
+}
+
+#undef  Perl_pp_getppid
+OP *
+Perl_pp_getppid(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_getppid();
+}
+
+#undef  Perl_pp_getpriority
+OP *
+Perl_pp_getpriority(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_getpriority();
+}
+
+#undef  Perl_pp_getsockname
+OP *
+Perl_pp_getsockname(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_getsockname();
+}
+
+#undef  Perl_pp_ggrent
+OP *
+Perl_pp_ggrent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ggrent();
+}
+
+#undef  Perl_pp_ggrgid
+OP *
+Perl_pp_ggrgid(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ggrgid();
+}
+
+#undef  Perl_pp_ggrnam
+OP *
+Perl_pp_ggrnam(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ggrnam();
+}
+
+#undef  Perl_pp_ghbyaddr
+OP *
+Perl_pp_ghbyaddr(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ghbyaddr();
+}
+
+#undef  Perl_pp_ghbyname
+OP *
+Perl_pp_ghbyname(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ghbyname();
+}
+
+#undef  Perl_pp_ghostent
+OP *
+Perl_pp_ghostent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ghostent();
+}
+
+#undef  Perl_pp_glob
+OP *
+Perl_pp_glob(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_glob();
+}
+
+#undef  Perl_pp_gmtime
+OP *
+Perl_pp_gmtime(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gmtime();
+}
+
+#undef  Perl_pp_gnbyaddr
+OP *
+Perl_pp_gnbyaddr(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gnbyaddr();
+}
+
+#undef  Perl_pp_gnbyname
+OP *
+Perl_pp_gnbyname(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gnbyname();
+}
+
+#undef  Perl_pp_gnetent
+OP *
+Perl_pp_gnetent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gnetent();
+}
+
+#undef  Perl_pp_goto
+OP *
+Perl_pp_goto(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_goto();
+}
+
+#undef  Perl_pp_gpbyname
+OP *
+Perl_pp_gpbyname(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gpbyname();
+}
+
+#undef  Perl_pp_gpbynumber
+OP *
+Perl_pp_gpbynumber(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gpbynumber();
+}
+
+#undef  Perl_pp_gprotoent
+OP *
+Perl_pp_gprotoent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gprotoent();
+}
+
+#undef  Perl_pp_gpwent
+OP *
+Perl_pp_gpwent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gpwent();
+}
+
+#undef  Perl_pp_gpwnam
+OP *
+Perl_pp_gpwnam(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gpwnam();
+}
+
+#undef  Perl_pp_gpwuid
+OP *
+Perl_pp_gpwuid(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gpwuid();
+}
+
+#undef  Perl_pp_grepstart
+OP *
+Perl_pp_grepstart(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_grepstart();
+}
+
+#undef  Perl_pp_grepwhile
+OP *
+Perl_pp_grepwhile(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_grepwhile();
+}
+
+#undef  Perl_pp_gsbyname
+OP *
+Perl_pp_gsbyname(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gsbyname();
+}
+
+#undef  Perl_pp_gsbyport
+OP *
+Perl_pp_gsbyport(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gsbyport();
+}
+
+#undef  Perl_pp_gservent
+OP *
+Perl_pp_gservent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gservent();
+}
+
+#undef  Perl_pp_gsockopt
+OP *
+Perl_pp_gsockopt(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gsockopt();
+}
+
+#undef  Perl_pp_gt
+OP *
+Perl_pp_gt(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gt();
+}
+
+#undef  Perl_pp_gv
+OP *
+Perl_pp_gv(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gv();
+}
+
+#undef  Perl_pp_gvsv
+OP *
+Perl_pp_gvsv(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_gvsv();
+}
+
+#undef  Perl_pp_helem
+OP *
+Perl_pp_helem(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_helem();
+}
+
+#undef  Perl_pp_hex
+OP *
+Perl_pp_hex(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_hex();
+}
+
+#undef  Perl_pp_hslice
+OP *
+Perl_pp_hslice(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_hslice();
+}
+
+#undef  Perl_pp_i_add
+OP *
+Perl_pp_i_add(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_i_add();
+}
+
+#undef  Perl_pp_i_divide
+OP *
+Perl_pp_i_divide(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_i_divide();
+}
+
+#undef  Perl_pp_i_eq
+OP *
+Perl_pp_i_eq(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_i_eq();
+}
+
+#undef  Perl_pp_i_ge
+OP *
+Perl_pp_i_ge(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_i_ge();
+}
+
+#undef  Perl_pp_i_gt
+OP *
+Perl_pp_i_gt(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_i_gt();
+}
+
+#undef  Perl_pp_i_le
+OP *
+Perl_pp_i_le(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_i_le();
+}
+
+#undef  Perl_pp_i_lt
+OP *
+Perl_pp_i_lt(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_i_lt();
+}
+
+#undef  Perl_pp_i_modulo
+OP *
+Perl_pp_i_modulo(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_i_modulo();
+}
+
+#undef  Perl_pp_i_multiply
+OP *
+Perl_pp_i_multiply(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_i_multiply();
+}
+
+#undef  Perl_pp_i_ncmp
+OP *
+Perl_pp_i_ncmp(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_i_ncmp();
+}
+
+#undef  Perl_pp_i_ne
+OP *
+Perl_pp_i_ne(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_i_ne();
+}
+
+#undef  Perl_pp_i_negate
+OP *
+Perl_pp_i_negate(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_i_negate();
+}
+
+#undef  Perl_pp_i_subtract
+OP *
+Perl_pp_i_subtract(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_i_subtract();
+}
+
+#undef  Perl_pp_index
+OP *
+Perl_pp_index(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_index();
+}
+
+#undef  Perl_pp_int
+OP *
+Perl_pp_int(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_int();
+}
+
+#undef  Perl_pp_ioctl
+OP *
+Perl_pp_ioctl(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ioctl();
+}
+
+#undef  Perl_pp_iter
+OP *
+Perl_pp_iter(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_iter();
+}
+
+#undef  Perl_pp_join
+OP *
+Perl_pp_join(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_join();
+}
+
+#undef  Perl_pp_keys
+OP *
+Perl_pp_keys(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_keys();
+}
+
+#undef  Perl_pp_kill
+OP *
+Perl_pp_kill(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_kill();
+}
+
+#undef  Perl_pp_last
+OP *
+Perl_pp_last(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_last();
+}
+
+#undef  Perl_pp_lc
+OP *
+Perl_pp_lc(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_lc();
+}
+
+#undef  Perl_pp_lcfirst
+OP *
+Perl_pp_lcfirst(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_lcfirst();
+}
+
+#undef  Perl_pp_le
+OP *
+Perl_pp_le(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_le();
+}
+
+#undef  Perl_pp_leave
+OP *
+Perl_pp_leave(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_leave();
+}
+
+#undef  Perl_pp_leaveeval
+OP *
+Perl_pp_leaveeval(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_leaveeval();
+}
+
+#undef  Perl_pp_leaveloop
+OP *
+Perl_pp_leaveloop(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_leaveloop();
+}
+
+#undef  Perl_pp_leavesub
+OP *
+Perl_pp_leavesub(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_leavesub();
+}
+
+#undef  Perl_pp_leavetry
+OP *
+Perl_pp_leavetry(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_leavetry();
+}
+
+#undef  Perl_pp_leavewrite
+OP *
+Perl_pp_leavewrite(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_leavewrite();
+}
+
+#undef  Perl_pp_left_shift
+OP *
+Perl_pp_left_shift(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_left_shift();
+}
+
+#undef  Perl_pp_length
+OP *
+Perl_pp_length(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_length();
+}
+
+#undef  Perl_pp_lineseq
+OP *
+Perl_pp_lineseq(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_lineseq();
+}
+
+#undef  Perl_pp_link
+OP *
+Perl_pp_link(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_link();
+}
+
+#undef  Perl_pp_list
+OP *
+Perl_pp_list(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_list();
+}
+
+#undef  Perl_pp_listen
+OP *
+Perl_pp_listen(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_listen();
+}
+
+#undef  Perl_pp_localtime
+OP *
+Perl_pp_localtime(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_localtime();
+}
+
+#undef  Perl_pp_lock
+OP *
+Perl_pp_lock(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_lock();
+}
+
+#undef  Perl_pp_log
+OP *
+Perl_pp_log(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_log();
+}
+
+#undef  Perl_pp_lslice
+OP *
+Perl_pp_lslice(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_lslice();
+}
+
+#undef  Perl_pp_lstat
+OP *
+Perl_pp_lstat(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_lstat();
+}
+
+#undef  Perl_pp_lt
+OP *
+Perl_pp_lt(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_lt();
+}
+
+#undef  Perl_pp_mapstart
+OP *
+Perl_pp_mapstart(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_mapstart();
+}
+
+#undef  Perl_pp_mapwhile
+OP *
+Perl_pp_mapwhile(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_mapwhile();
+}
+
+#undef  Perl_pp_match
+OP *
+Perl_pp_match(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_match();
+}
+
+#undef  Perl_pp_method
+OP *
+Perl_pp_method(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_method();
+}
+
+#undef  Perl_pp_mkdir
+OP *
+Perl_pp_mkdir(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_mkdir();
+}
+
+#undef  Perl_pp_modulo
+OP *
+Perl_pp_modulo(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_modulo();
+}
+
+#undef  Perl_pp_msgctl
+OP *
+Perl_pp_msgctl(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_msgctl();
+}
+
+#undef  Perl_pp_msgget
+OP *
+Perl_pp_msgget(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_msgget();
+}
+
+#undef  Perl_pp_msgrcv
+OP *
+Perl_pp_msgrcv(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_msgrcv();
+}
+
+#undef  Perl_pp_msgsnd
+OP *
+Perl_pp_msgsnd(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_msgsnd();
+}
+
+#undef  Perl_pp_multiply
+OP *
+Perl_pp_multiply(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_multiply();
+}
+
+#undef  Perl_pp_ncmp
+OP *
+Perl_pp_ncmp(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ncmp();
+}
+
+#undef  Perl_pp_ne
+OP *
+Perl_pp_ne(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ne();
+}
+
+#undef  Perl_pp_negate
+OP *
+Perl_pp_negate(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_negate();
+}
+
+#undef  Perl_pp_next
+OP *
+Perl_pp_next(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_next();
+}
+
+#undef  Perl_pp_nextstate
+OP *
+Perl_pp_nextstate(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_nextstate();
+}
+
+#undef  Perl_pp_not
+OP *
+Perl_pp_not(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_not();
+}
+
+#undef  Perl_pp_null
+OP *
+Perl_pp_null(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_null();
+}
+
+#undef  Perl_pp_oct
+OP *
+Perl_pp_oct(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_oct();
+}
+
+#undef  Perl_pp_open
+OP *
+Perl_pp_open(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_open();
+}
+
+#undef  Perl_pp_open_dir
+OP *
+Perl_pp_open_dir(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_open_dir();
+}
+
+#undef  Perl_pp_or
+OP *
+Perl_pp_or(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_or();
+}
+
+#undef  Perl_pp_orassign
+OP *
+Perl_pp_orassign(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_orassign();
+}
+
+#undef  Perl_pp_ord
+OP *
+Perl_pp_ord(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ord();
+}
+
+#undef  Perl_pp_pack
+OP *
+Perl_pp_pack(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_pack();
+}
+
+#undef  Perl_pp_padany
+OP *
+Perl_pp_padany(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_padany();
+}
+
+#undef  Perl_pp_padav
+OP *
+Perl_pp_padav(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_padav();
+}
+
+#undef  Perl_pp_padhv
+OP *
+Perl_pp_padhv(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_padhv();
+}
+
+#undef  Perl_pp_padsv
+OP *
+Perl_pp_padsv(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_padsv();
+}
+
+#undef  Perl_pp_pipe_op
+OP *
+Perl_pp_pipe_op(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_pipe_op();
+}
+
+#undef  Perl_pp_pop
+OP *
+Perl_pp_pop(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_pop();
+}
+
+#undef  Perl_pp_pos
+OP *
+Perl_pp_pos(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_pos();
+}
+
+#undef  Perl_pp_postdec
+OP *
+Perl_pp_postdec(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_postdec();
+}
+
+#undef  Perl_pp_postinc
+OP *
+Perl_pp_postinc(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_postinc();
+}
+
+#undef  Perl_pp_pow
+OP *
+Perl_pp_pow(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_pow();
+}
+
+#undef  Perl_pp_predec
+OP *
+Perl_pp_predec(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_predec();
+}
+
+#undef  Perl_pp_preinc
+OP *
+Perl_pp_preinc(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_preinc();
+}
+
+#undef  Perl_pp_print
+OP *
+Perl_pp_print(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_print();
+}
+
+#undef  Perl_pp_prototype
+OP *
+Perl_pp_prototype(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_prototype();
+}
+
+#undef  Perl_pp_prtf
+OP *
+Perl_pp_prtf(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_prtf();
+}
+
+#undef  Perl_pp_push
+OP *
+Perl_pp_push(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_push();
+}
+
+#undef  Perl_pp_pushmark
+OP *
+Perl_pp_pushmark(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_pushmark();
+}
+
+#undef  Perl_pp_pushre
+OP *
+Perl_pp_pushre(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_pushre();
+}
+
+#undef  Perl_pp_qr
+OP *
+Perl_pp_qr(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_qr();
+}
+
+#undef  Perl_pp_quotemeta
+OP *
+Perl_pp_quotemeta(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_quotemeta();
+}
+
+#undef  Perl_pp_rand
+OP *
+Perl_pp_rand(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_rand();
+}
+
+#undef  Perl_pp_range
+OP *
+Perl_pp_range(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_range();
+}
+
+#undef  Perl_pp_rcatline
+OP *
+Perl_pp_rcatline(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_rcatline();
+}
+
+#undef  Perl_pp_read
+OP *
+Perl_pp_read(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_read();
+}
+
+#undef  Perl_pp_readdir
+OP *
+Perl_pp_readdir(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_readdir();
+}
+
+#undef  Perl_pp_readline
+OP *
+Perl_pp_readline(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_readline();
+}
+
+#undef  Perl_pp_readlink
+OP *
+Perl_pp_readlink(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_readlink();
+}
+
+#undef  Perl_pp_recv
+OP *
+Perl_pp_recv(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_recv();
+}
+
+#undef  Perl_pp_redo
+OP *
+Perl_pp_redo(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_redo();
+}
+
+#undef  Perl_pp_ref
+OP *
+Perl_pp_ref(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ref();
+}
+
+#undef  Perl_pp_refgen
+OP *
+Perl_pp_refgen(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_refgen();
+}
+
+#undef  Perl_pp_regcmaybe
+OP *
+Perl_pp_regcmaybe(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_regcmaybe();
+}
+
+#undef  Perl_pp_regcomp
+OP *
+Perl_pp_regcomp(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_regcomp();
+}
+
+#undef  Perl_pp_regcreset
+OP *
+Perl_pp_regcreset(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_regcreset();
+}
+
+#undef  Perl_pp_rename
+OP *
+Perl_pp_rename(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_rename();
+}
+
+#undef  Perl_pp_repeat
+OP *
+Perl_pp_repeat(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_repeat();
+}
+
+#undef  Perl_pp_require
+OP *
+Perl_pp_require(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_require();
+}
+
+#undef  Perl_pp_reset
+OP *
+Perl_pp_reset(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_reset();
+}
+
+#undef  Perl_pp_return
+OP *
+Perl_pp_return(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_return();
+}
+
+#undef  Perl_pp_reverse
+OP *
+Perl_pp_reverse(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_reverse();
+}
+
+#undef  Perl_pp_rewinddir
+OP *
+Perl_pp_rewinddir(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_rewinddir();
+}
+
+#undef  Perl_pp_right_shift
+OP *
+Perl_pp_right_shift(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_right_shift();
+}
+
+#undef  Perl_pp_rindex
+OP *
+Perl_pp_rindex(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_rindex();
+}
+
+#undef  Perl_pp_rmdir
+OP *
+Perl_pp_rmdir(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_rmdir();
+}
+
+#undef  Perl_pp_rv2av
+OP *
+Perl_pp_rv2av(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_rv2av();
+}
+
+#undef  Perl_pp_rv2cv
+OP *
+Perl_pp_rv2cv(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_rv2cv();
+}
+
+#undef  Perl_pp_rv2gv
+OP *
+Perl_pp_rv2gv(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_rv2gv();
+}
+
+#undef  Perl_pp_rv2hv
+OP *
+Perl_pp_rv2hv(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_rv2hv();
+}
+
+#undef  Perl_pp_rv2sv
+OP *
+Perl_pp_rv2sv(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_rv2sv();
+}
+
+#undef  Perl_pp_sassign
+OP *
+Perl_pp_sassign(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sassign();
+}
+
+#undef  Perl_pp_scalar
+OP *
+Perl_pp_scalar(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_scalar();
+}
+
+#undef  Perl_pp_schomp
+OP *
+Perl_pp_schomp(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_schomp();
+}
+
+#undef  Perl_pp_schop
+OP *
+Perl_pp_schop(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_schop();
+}
+
+#undef  Perl_pp_scmp
+OP *
+Perl_pp_scmp(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_scmp();
+}
+
+#undef  Perl_pp_scope
+OP *
+Perl_pp_scope(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_scope();
+}
+
+#undef  Perl_pp_seek
+OP *
+Perl_pp_seek(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_seek();
+}
+
+#undef  Perl_pp_seekdir
+OP *
+Perl_pp_seekdir(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_seekdir();
+}
+
+#undef  Perl_pp_select
+OP *
+Perl_pp_select(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_select();
+}
+
+#undef  Perl_pp_semctl
+OP *
+Perl_pp_semctl(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_semctl();
+}
+
+#undef  Perl_pp_semget
+OP *
+Perl_pp_semget(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_semget();
+}
+
+#undef  Perl_pp_semop
+OP *
+Perl_pp_semop(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_semop();
+}
+
+#undef  Perl_pp_send
+OP *
+Perl_pp_send(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_send();
+}
+
+#undef  Perl_pp_seq
+OP *
+Perl_pp_seq(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_seq();
+}
+
+#undef  Perl_pp_setpgrp
+OP *
+Perl_pp_setpgrp(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_setpgrp();
+}
+
+#undef  Perl_pp_setpriority
+OP *
+Perl_pp_setpriority(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_setpriority();
+}
+
+#undef  Perl_pp_sge
+OP *
+Perl_pp_sge(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sge();
+}
+
+#undef  Perl_pp_sgrent
+OP *
+Perl_pp_sgrent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sgrent();
+}
+
+#undef  Perl_pp_sgt
+OP *
+Perl_pp_sgt(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sgt();
+}
+
+#undef  Perl_pp_shift
+OP *
+Perl_pp_shift(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_shift();
+}
+
+#undef  Perl_pp_shmctl
+OP *
+Perl_pp_shmctl(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_shmctl();
+}
+
+#undef  Perl_pp_shmget
+OP *
+Perl_pp_shmget(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_shmget();
+}
+
+#undef  Perl_pp_shmread
+OP *
+Perl_pp_shmread(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_shmread();
+}
+
+#undef  Perl_pp_shmwrite
+OP *
+Perl_pp_shmwrite(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_shmwrite();
+}
+
+#undef  Perl_pp_shostent
+OP *
+Perl_pp_shostent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_shostent();
+}
+
+#undef  Perl_pp_shutdown
+OP *
+Perl_pp_shutdown(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_shutdown();
+}
+
+#undef  Perl_pp_sin
+OP *
+Perl_pp_sin(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sin();
+}
+
+#undef  Perl_pp_sle
+OP *
+Perl_pp_sle(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sle();
+}
+
+#undef  Perl_pp_sleep
+OP *
+Perl_pp_sleep(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sleep();
+}
+
+#undef  Perl_pp_slt
+OP *
+Perl_pp_slt(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_slt();
+}
+
+#undef  Perl_pp_sne
+OP *
+Perl_pp_sne(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sne();
+}
+
+#undef  Perl_pp_snetent
+OP *
+Perl_pp_snetent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_snetent();
+}
+
+#undef  Perl_pp_socket
+OP *
+Perl_pp_socket(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_socket();
+}
+
+#undef  Perl_pp_sockpair
+OP *
+Perl_pp_sockpair(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sockpair();
+}
+
+#undef  Perl_pp_sort
+OP *
+Perl_pp_sort(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sort();
+}
+
+#undef  Perl_pp_splice
+OP *
+Perl_pp_splice(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_splice();
+}
+
+#undef  Perl_pp_split
+OP *
+Perl_pp_split(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_split();
+}
+
+#undef  Perl_pp_sprintf
+OP *
+Perl_pp_sprintf(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sprintf();
+}
+
+#undef  Perl_pp_sprotoent
+OP *
+Perl_pp_sprotoent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sprotoent();
+}
+
+#undef  Perl_pp_spwent
+OP *
+Perl_pp_spwent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_spwent();
+}
+
+#undef  Perl_pp_sqrt
+OP *
+Perl_pp_sqrt(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sqrt();
+}
+
+#undef  Perl_pp_srand
+OP *
+Perl_pp_srand(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_srand();
+}
+
+#undef  Perl_pp_srefgen
+OP *
+Perl_pp_srefgen(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_srefgen();
+}
+
+#undef  Perl_pp_sselect
+OP *
+Perl_pp_sselect(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sselect();
+}
+
+#undef  Perl_pp_sservent
+OP *
+Perl_pp_sservent(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sservent();
+}
+
+#undef  Perl_pp_ssockopt
+OP *
+Perl_pp_ssockopt(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ssockopt();
+}
+
+#undef  Perl_pp_stat
+OP *
+Perl_pp_stat(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_stat();
+}
+
+#undef  Perl_pp_stringify
+OP *
+Perl_pp_stringify(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_stringify();
+}
+
+#undef  Perl_pp_stub
+OP *
+Perl_pp_stub(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_stub();
+}
+
+#undef  Perl_pp_study
+OP *
+Perl_pp_study(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_study();
+}
+
+#undef  Perl_pp_subst
+OP *
+Perl_pp_subst(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_subst();
+}
+
+#undef  Perl_pp_substcont
+OP *
+Perl_pp_substcont(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_substcont();
+}
+
+#undef  Perl_pp_substr
+OP *
+Perl_pp_substr(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_substr();
+}
+
+#undef  Perl_pp_subtract
+OP *
+Perl_pp_subtract(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_subtract();
+}
+
+#undef  Perl_pp_symlink
+OP *
+Perl_pp_symlink(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_symlink();
+}
+
+#undef  Perl_pp_syscall
+OP *
+Perl_pp_syscall(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_syscall();
+}
+
+#undef  Perl_pp_sysopen
+OP *
+Perl_pp_sysopen(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sysopen();
+}
+
+#undef  Perl_pp_sysread
+OP *
+Perl_pp_sysread(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sysread();
+}
+
+#undef  Perl_pp_sysseek
+OP *
+Perl_pp_sysseek(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_sysseek();
+}
+
+#undef  Perl_pp_system
+OP *
+Perl_pp_system(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_system();
+}
+
+#undef  Perl_pp_syswrite
+OP *
+Perl_pp_syswrite(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_syswrite();
+}
+
+#undef  Perl_pp_tell
+OP *
+Perl_pp_tell(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_tell();
+}
+
+#undef  Perl_pp_telldir
+OP *
+Perl_pp_telldir(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_telldir();
+}
+
+#undef  Perl_pp_threadsv
+OP *
+Perl_pp_threadsv(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_threadsv();
+}
+
+#undef  Perl_pp_tie
+OP *
+Perl_pp_tie(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_tie();
+}
+
+#undef  Perl_pp_tied
+OP *
+Perl_pp_tied(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_tied();
+}
+
+#undef  Perl_pp_time
+OP *
+Perl_pp_time(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_time();
+}
+
+#undef  Perl_pp_tms
+OP *
+Perl_pp_tms(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_tms();
+}
+
+#undef  Perl_pp_trans
+OP *
+Perl_pp_trans(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_trans();
+}
+
+#undef  Perl_pp_truncate
+OP *
+Perl_pp_truncate(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_truncate();
+}
+
+#undef  Perl_pp_uc
+OP *
+Perl_pp_uc(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_uc();
+}
+
+#undef  Perl_pp_ucfirst
+OP *
+Perl_pp_ucfirst(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_ucfirst();
+}
+
+#undef  Perl_pp_umask
+OP *
+Perl_pp_umask(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_umask();
+}
+
+#undef  Perl_pp_undef
+OP *
+Perl_pp_undef(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_undef();
+}
+
+#undef  Perl_pp_unlink
+OP *
+Perl_pp_unlink(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_unlink();
+}
+
+#undef  Perl_pp_unpack
+OP *
+Perl_pp_unpack(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_unpack();
+}
+
+#undef  Perl_pp_unshift
+OP *
+Perl_pp_unshift(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_unshift();
+}
+
+#undef  Perl_pp_unstack
+OP *
+Perl_pp_unstack(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_unstack();
+}
+
+#undef  Perl_pp_untie
+OP *
+Perl_pp_untie(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_untie();
+}
+
+#undef  Perl_pp_utime
+OP *
+Perl_pp_utime(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_utime();
+}
+
+#undef  Perl_pp_values
+OP *
+Perl_pp_values(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_values();
+}
+
+#undef  Perl_pp_vec
+OP *
+Perl_pp_vec(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_vec();
+}
+
+#undef  Perl_pp_wait
+OP *
+Perl_pp_wait(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_wait();
+}
+
+#undef  Perl_pp_waitpid
+OP *
+Perl_pp_waitpid(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_waitpid();
+}
+
+#undef  Perl_pp_wantarray
+OP *
+Perl_pp_wantarray(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_wantarray();
+}
+
+#undef  Perl_pp_warn
+OP *
+Perl_pp_warn(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_warn();
+}
+
+#undef  Perl_pp_xor
+OP *
+Perl_pp_xor(void *pPerl)
+{
+    return ((CPerlObj*)pPerl)->Perl_pp_xor();
+}
+
+END_EXTERN_C
+
+#endif /* PERL_OBJECT */
diff --git a/perlapi.h b/perlapi.h
new file mode 100755 (executable)
index 0000000..d1d8dd5
--- /dev/null
+++ b/perlapi.h
@@ -0,0 +1,34 @@
+/* !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+   This file is built by embed.pl from data in embed.pl, pp.sym, intrpvar.h,
+   perlvars.h and thrdvar.h.  Any changes made here will be lost!
+*/
+
+#if defined(PERL_OBJECT)
+
+/* declare accessor functions for Perl variables */
+
+START_EXTERN_C
+
+#undef PERLVAR
+#undef PERLVARA
+#undef PERLVARI
+#undef PERLVARIC
+#define PERLVAR(v,t)   EXTERN_C t* Perl_##v##_ptr(void *p);
+#define PERLVARA(v,n,t)        typedef t PL_##v##_t[n];                        \
+                       EXTERN_C PL_##v##_t* Perl_##v##_ptr(void *p);
+#define PERLVARI(v,t,i)        PERLVAR(v,t)
+#define PERLVARIC(v,t,i) PERLVAR(v,t)
+
+#include "thrdvar.h"
+#include "intrpvar.h"
+#include "perlvars.h"
+
+#undef PERLVAR
+#undef PERLVARA
+#undef PERLVARI
+#undef PERLVARIC
+
+END_EXTERN_C
+
+#endif /* PERL_OBJECT */
+
diff --git a/perly.c b/perly.c
index 1a31506..b92de4e 100644 (file)
--- a/perly.c
+++ b/perly.c
@@ -16,6 +16,8 @@ static char yysccsid[] = "@(#)yaccpar 1.8 (Berkeley) 01/20/91";
 
 #define dep() deprecate("\"do\" to call subroutines")
 
+static void yydestruct(pTHXo_ void *ptr);
+
 #line 30 "perly.y"
 #define YYERRCODE 256
 static short yylhs[] = {                                 -1,
@@ -1316,21 +1318,6 @@ struct ysv {
     YYSTYPE oldyylval;
 };
 
-void
-Perl_yydestruct(pTHX_ void *ptr)
-{
-    struct ysv* ysave = (struct ysv*)ptr;
-    if (ysave->yyss) Safefree(ysave->yyss);
-    if (ysave->yyvs) Safefree(ysave->yyvs);
-    yydebug    = ysave->oldyydebug;
-    yynerrs    = ysave->oldyynerrs;
-    yyerrflag  = ysave->oldyyerrflag;
-    yychar     = ysave->oldyychar;
-    yyval      = ysave->oldyyval;
-    yylval     = ysave->oldyylval;
-    Safefree(ysave);
-}
-
 int
 Perl_yyparse(pTHX)
 {
@@ -1350,7 +1337,7 @@ Perl_yyparse(pTHX)
 
     struct ysv *ysave;
     New(73, ysave, 1, struct ysv);
-    SAVEDESTRUCTOR(Perl_yydestruct, ysave);
+    SAVEDESTRUCTOR(yydestruct, ysave);
     ysave->oldyydebug  = yydebug;
     ysave->oldyynerrs  = yynerrs;
     ysave->oldyyerrflag        = yyerrflag;
@@ -2384,3 +2371,24 @@ yyabort:
 yyaccept:
     return retval;
 }
+
+
+#ifdef PERL_OBJECT
+#define NO_XSLOCKS
+#include "XSUB.h"
+#endif
+
+static void
+yydestruct(pTHXo_ void *ptr)
+{
+    struct ysv* ysave = (struct ysv*)ptr;
+    if (ysave->yyss) Safefree(ysave->yyss);
+    if (ysave->yyvs) Safefree(ysave->yyvs);
+    yydebug    = ysave->oldyydebug;
+    yynerrs    = ysave->oldyynerrs;
+    yyerrflag  = ysave->oldyyerrflag;
+    yychar     = ysave->oldyychar;
+    yyval      = ysave->oldyyval;
+    yylval     = ysave->oldyylval;
+    Safefree(ysave);
+}
diff --git a/pp.c b/pp.c
index faa6656..3bd26f4 100644 (file)
--- a/pp.c
+++ b/pp.c
@@ -5186,7 +5186,7 @@ PP(pp_lock)
        DEBUG_S(PerlIO_printf(PerlIO_stderr(), "0x%lx: pp_lock lock 0x%lx\n",
                              (unsigned long)thr, (unsigned long)sv);)
        MUTEX_UNLOCK(MgMUTEXP(mg));
-       save_destructor(Perl_unlock_condpair, sv);
+       SAVEDESTRUCTOR(Perl_unlock_condpair, sv);
     }
 #endif /* USE_THREADS */
     if (SvTYPE(retsv) == SVt_PVAV || SvTYPE(retsv) == SVt_PVHV
index af6394d..d7fec16 100644 (file)
--- a/pp_ctl.c
+++ b/pp_ctl.c
 #define CALLOP *PL_op
 #endif
 
+static I32 sortcv(pTHXo_ SV *a, SV *b);
+static I32 sv_ncmp(pTHXo_ SV *a, SV *b);
+static I32 sv_i_ncmp(pTHXo_ SV *a, SV *b);
+static I32 amagic_ncmp(pTHXo_ SV *a, SV *b);
+static I32 amagic_i_ncmp(pTHXo_ SV *a, SV *b);
+static I32 amagic_cmp(pTHXo_ SV *a, SV *b);
+static I32 amagic_cmp_locale(pTHXo_ SV *a, SV *b);
+static I32 sv_cmp_static(pTHXo_ SV *a, SV *b);
+static I32 sv_cmp_locale_static(pTHXo_ SV *a, SV *b);
+
 PP(pp_wantarray)
 {
     djSP;
@@ -755,120 +765,6 @@ PP(pp_mapwhile)
     }
 }
 
-STATIC I32
-S_sv_ncmp(pTHX_ SV *a, SV *b)
-{
-    NV nv1 = SvNV(a);
-    NV nv2 = SvNV(b);
-    return nv1 < nv2 ? -1 : nv1 > nv2 ? 1 : 0;
-}
-
-STATIC I32
-S_sv_i_ncmp(pTHX_ SV *a, SV *b)
-{
-    IV iv1 = SvIV(a);
-    IV iv2 = SvIV(b);
-    return iv1 < iv2 ? -1 : iv1 > iv2 ? 1 : 0;
-}
-#define tryCALL_AMAGICbin(left,right,meth,svp) STMT_START { \
-         *svp = Nullsv;                                \
-          if (PL_amagic_generation) { \
-           if (SvAMAGIC(left)||SvAMAGIC(right))\
-               *svp = amagic_call(left, \
-                                  right, \
-                                  CAT2(meth,_amg), \
-                                  0); \
-         } \
-       } STMT_END
-
-STATIC I32
-S_amagic_ncmp(pTHX_ register SV *a, register SV *b)
-{
-    SV *tmpsv;
-    tryCALL_AMAGICbin(a,b,ncmp,&tmpsv);
-    if (tmpsv) {
-       NV d;
-       
-        if (SvIOK(tmpsv)) {
-            I32 i = SvIVX(tmpsv);
-            if (i > 0)
-               return 1;
-            return i? -1 : 0;
-        }
-        d = SvNV(tmpsv);
-        if (d > 0)
-           return 1;
-        return d? -1 : 0;
-     }
-     return sv_ncmp(a, b);
-}
-
-STATIC I32
-S_amagic_i_ncmp(pTHX_ register SV *a, register SV *b)
-{
-    SV *tmpsv;
-    tryCALL_AMAGICbin(a,b,ncmp,&tmpsv);
-    if (tmpsv) {
-       NV d;
-       
-        if (SvIOK(tmpsv)) {
-            I32 i = SvIVX(tmpsv);
-            if (i > 0)
-               return 1;
-            return i? -1 : 0;
-        }
-        d = SvNV(tmpsv);
-        if (d > 0)
-           return 1;
-        return d? -1 : 0;
-    }
-    return sv_i_ncmp(a, b);
-}
-
-STATIC I32
-S_amagic_cmp(pTHX_ register SV *str1, register SV *str2)
-{
-    SV *tmpsv;
-    tryCALL_AMAGICbin(str1,str2,scmp,&tmpsv);
-    if (tmpsv) {
-       NV d;
-       
-        if (SvIOK(tmpsv)) {
-            I32 i = SvIVX(tmpsv);
-            if (i > 0)
-               return 1;
-            return i? -1 : 0;
-        }
-        d = SvNV(tmpsv);
-        if (d > 0)
-           return 1;
-        return d? -1 : 0;
-    }
-    return sv_cmp(str1, str2);
-}
-
-STATIC I32
-S_amagic_cmp_locale(pTHX_ register SV *str1, register SV *str2)
-{
-    SV *tmpsv;
-    tryCALL_AMAGICbin(str1,str2,scmp,&tmpsv);
-    if (tmpsv) {
-       NV d;
-       
-        if (SvIOK(tmpsv)) {
-            I32 i = SvIVX(tmpsv);
-            if (i > 0)
-               return 1;
-            return i? -1 : 0;
-        }
-        d = SvNV(tmpsv);
-        if (d > 0)
-           return 1;
-        return d? -1 : 0;
-    }
-    return sv_cmp_locale(str1, str2);
-}
-
 PP(pp_sort)
 {
     djSP; dMARK; dORIGMARK;
@@ -974,7 +870,7 @@ PP(pp_sort)
                    (void)SvREFCNT_inc(cv); /* in preparation for POPSUB */
            }
            PL_sortcxix = cxstack_ix;
-           qsortsv((myorigmark+1), max, FUNC_NAME_TO_PTR(S_sortcv));
+           qsortsv((myorigmark+1), max, FUNC_NAME_TO_PTR(sortcv));
 
            POPBLOCK(cx,PL_curpm);
            PL_stack_sp = newsp;
@@ -989,18 +885,18 @@ PP(pp_sort)
                    (PL_op->op_private & OPpSORT_NUMERIC)
                        ? ( (PL_op->op_private & OPpSORT_INTEGER)
                            ? ( overloading
-                               ? FUNC_NAME_TO_PTR(S_amagic_i_ncmp)
-                               : FUNC_NAME_TO_PTR(S_sv_i_ncmp))
+                               ? FUNC_NAME_TO_PTR(amagic_i_ncmp)
+                               : FUNC_NAME_TO_PTR(sv_i_ncmp))
                            : ( overloading
-                               ? FUNC_NAME_TO_PTR(S_amagic_ncmp)
-                               : FUNC_NAME_TO_PTR(S_sv_ncmp)))
+                               ? FUNC_NAME_TO_PTR(amagic_ncmp)
+                               : FUNC_NAME_TO_PTR(sv_ncmp)))
                        : ( (PL_op->op_private & OPpLOCALE)
                            ? ( overloading
-                               ? FUNC_NAME_TO_PTR(S_amagic_cmp_locale)
-                               : FUNC_NAME_TO_PTR(Perl_sv_cmp_locale))
+                               ? FUNC_NAME_TO_PTR(amagic_cmp_locale)
+                               : FUNC_NAME_TO_PTR(sv_cmp_locale_static))
                            : ( overloading
-                               ? FUNC_NAME_TO_PTR(S_amagic_cmp)
-                   : FUNC_NAME_TO_PTR(Perl_sv_cmp) )));
+                               ? FUNC_NAME_TO_PTR(amagic_cmp)
+                   : FUNC_NAME_TO_PTR(sv_cmp_static) )));
            if (PL_op->op_private & OPpSORT_REVERSE) {
                SV **p = ORIGMARK+1;
                SV **q = ORIGMARK+max;
@@ -1595,30 +1491,6 @@ PP(pp_caller)
     RETURN;
 }
 
-STATIC I32
-S_sortcv(pTHX_ SV *a, SV *b)
-{
-    dTHR;
-    I32 oldsaveix = PL_savestack_ix;
-    I32 oldscopeix = PL_scopestack_ix;
-    I32 result;
-    GvSV(PL_firstgv) = a;
-    GvSV(PL_secondgv) = b;
-    PL_stack_sp = PL_stack_base;
-    PL_op = PL_sortcop;
-    CALLRUNOPS(aTHX);
-    if (PL_stack_sp != PL_stack_base + 1)
-       Perl_croak(aTHX_ "Sort subroutine didn't return single value");
-    if (!SvNIOKp(*PL_stack_sp))
-       Perl_croak(aTHX_ "Sort subroutine didn't return a numeric value");
-    result = SvIV(*PL_stack_sp);
-    while (PL_scopestack_ix > oldscopeix) {
-       LEAVE;
-    }
-    leave_scope(oldsaveix);
-    return result;
-}
-
 PP(pp_reset)
 {
     djSP;
@@ -3503,13 +3375,8 @@ struct partition_stack_entry {
 
 /* Return < 0 == 0 or > 0 as the value of elt1 is < elt2, == elt2, > elt2
 */
-#ifdef PERL_OBJECT
 #define qsort_cmp(elt1, elt2) \
-   ((this->*compare)(array[elt1], array[elt2]))
-#else
-#define qsort_cmp(elt1, elt2) \
-   ((*compare)(aTHX_ array[elt1], array[elt2]))
-#endif
+   ((*compare)(aTHXo_ array[elt1], array[elt2]))
 
 #ifdef QSORT_ORDER_GUESS
 #define QSORT_NOTICE_SWAP swapped++;
@@ -4080,3 +3947,163 @@ S_qsortsv(pTHX_ SV ** array, size_t num_elts, SVCOMPARE_t compare)
 
    /* Believe it or not, the array is sorted at this point! */
 }
+
+
+#ifdef PERL_OBJECT
+#define NO_XSLOCKS
+#undef this
+#define this pPerl
+#include "XSUB.h"
+#endif
+
+
+static I32
+sortcv(pTHXo_ SV *a, SV *b)
+{
+    dTHR;
+    I32 oldsaveix = PL_savestack_ix;
+    I32 oldscopeix = PL_scopestack_ix;
+    I32 result;
+    GvSV(PL_firstgv) = a;
+    GvSV(PL_secondgv) = b;
+    PL_stack_sp = PL_stack_base;
+    PL_op = PL_sortcop;
+    CALLRUNOPS(aTHX);
+    if (PL_stack_sp != PL_stack_base + 1)
+       Perl_croak(aTHX_ "Sort subroutine didn't return single value");
+    if (!SvNIOKp(*PL_stack_sp))
+       Perl_croak(aTHX_ "Sort subroutine didn't return a numeric value");
+    result = SvIV(*PL_stack_sp);
+    while (PL_scopestack_ix > oldscopeix) {
+       LEAVE;
+    }
+    leave_scope(oldsaveix);
+    return result;
+}
+
+
+static I32
+sv_ncmp(pTHXo_ SV *a, SV *b)
+{
+    NV nv1 = SvNV(a);
+    NV nv2 = SvNV(b);
+    return nv1 < nv2 ? -1 : nv1 > nv2 ? 1 : 0;
+}
+
+static I32
+sv_i_ncmp(pTHXo_ SV *a, SV *b)
+{
+    IV iv1 = SvIV(a);
+    IV iv2 = SvIV(b);
+    return iv1 < iv2 ? -1 : iv1 > iv2 ? 1 : 0;
+}
+#define tryCALL_AMAGICbin(left,right,meth,svp) STMT_START { \
+         *svp = Nullsv;                                \
+          if (PL_amagic_generation) { \
+           if (SvAMAGIC(left)||SvAMAGIC(right))\
+               *svp = amagic_call(left, \
+                                  right, \
+                                  CAT2(meth,_amg), \
+                                  0); \
+         } \
+       } STMT_END
+
+static I32
+amagic_ncmp(pTHXo_ register SV *a, register SV *b)
+{
+    SV *tmpsv;
+    tryCALL_AMAGICbin(a,b,ncmp,&tmpsv);
+    if (tmpsv) {
+       NV d;
+       
+        if (SvIOK(tmpsv)) {
+            I32 i = SvIVX(tmpsv);
+            if (i > 0)
+               return 1;
+            return i? -1 : 0;
+        }
+        d = SvNV(tmpsv);
+        if (d > 0)
+           return 1;
+        return d? -1 : 0;
+     }
+     return sv_ncmp(aTHXo_ a, b);
+}
+
+static I32
+amagic_i_ncmp(pTHXo_ register SV *a, register SV *b)
+{
+    SV *tmpsv;
+    tryCALL_AMAGICbin(a,b,ncmp,&tmpsv);
+    if (tmpsv) {
+       NV d;
+       
+        if (SvIOK(tmpsv)) {
+            I32 i = SvIVX(tmpsv);
+            if (i > 0)
+               return 1;
+            return i? -1 : 0;
+        }
+        d = SvNV(tmpsv);
+        if (d > 0)
+           return 1;
+        return d? -1 : 0;
+    }
+    return sv_i_ncmp(aTHXo_ a, b);
+}
+
+static I32
+amagic_cmp(pTHXo_ register SV *str1, register SV *str2)
+{
+    SV *tmpsv;
+    tryCALL_AMAGICbin(str1,str2,scmp,&tmpsv);
+    if (tmpsv) {
+       NV d;
+       
+        if (SvIOK(tmpsv)) {
+            I32 i = SvIVX(tmpsv);
+            if (i > 0)
+               return 1;
+            return i? -1 : 0;
+        }
+        d = SvNV(tmpsv);
+        if (d > 0)
+           return 1;
+        return d? -1 : 0;
+    }
+    return sv_cmp(str1, str2);
+}
+
+static I32
+amagic_cmp_locale(pTHXo_ register SV *str1, register SV *str2)
+{
+    SV *tmpsv;
+    tryCALL_AMAGICbin(str1,str2,scmp,&tmpsv);
+    if (tmpsv) {
+       NV d;
+       
+        if (SvIOK(tmpsv)) {
+            I32 i = SvIVX(tmpsv);
+            if (i > 0)
+               return 1;
+            return i? -1 : 0;
+        }
+        d = SvNV(tmpsv);
+        if (d > 0)
+           return 1;
+        return d? -1 : 0;
+    }
+    return sv_cmp_locale(str1, str2);
+}
+
+static I32
+sv_cmp_locale_static(pTHXo_ register SV *str1, register SV *str2)
+{
+    return sv_cmp_locale(str1, str2);
+}
+
+static I32
+sv_cmp_static(pTHXo_ register SV *str1, register SV *str2)
+{
+    return sv_cmp(str1, str2);
+}
index f4ed171..81a4f56 100644 (file)
--- a/pp_hot.c
+++ b/pp_hot.c
 /* Hot code. */
 
 #ifdef USE_THREADS
-STATIC void
-S_unset_cvowner(pTHX_ void *cvarg)
-{
-    register CV* cv = (CV *) cvarg;
-#ifdef DEBUGGING
-    dTHR;
-#endif /* DEBUGGING */
-
-    DEBUG_S((PerlIO_printf(PerlIO_stderr(), "%p unsetting CvOWNER of %p:%s\n",
-                          thr, cv, SvPEEK((SV*)cv))));
-    MUTEX_LOCK(CvMUTEXP(cv));
-    DEBUG_S(if (CvDEPTH(cv) != 0)
-               PerlIO_printf(PerlIO_stderr(), "depth %ld != 0\n",
-                             CvDEPTH(cv)););
-    assert(thr == CvOWNER(cv));
-    CvOWNER(cv) = 0;
-    MUTEX_UNLOCK(CvMUTEXP(cv));
-    SvREFCNT_dec(cv);
-}
+static void unset_cvowner(pTHXo_ void *cvarg);
 #endif /* USE_THREADS */
 
 PP(pp_const)
@@ -2142,7 +2124,7 @@ try_autoload:
            DEBUG_S(PerlIO_printf(PerlIO_stderr(), "%p: pp_entersub lock %p\n",
                                  thr, sv);)
            MUTEX_UNLOCK(MgMUTEXP(mg));
-           save_destructor(Perl_unlock_condpair, sv);
+           SAVEDESTRUCTOR(Perl_unlock_condpair, sv);
        }
        MUTEX_LOCK(CvMUTEXP(cv));
     }
@@ -2187,7 +2169,7 @@ try_autoload:
            CvOWNER(cv) = thr;
            SvREFCNT_inc(cv);
            if (CvDEPTH(cv) == 0)
-               SAVEDESTRUCTOR(S_unset_cvowner, (void*) cv);
+               SAVEDESTRUCTOR(unset_cvowner, (void*) cv);
        }
        else {
            /* (2) => grab ownership of cv. (3) => make clone */
@@ -2224,7 +2206,7 @@ try_autoload:
            DEBUG_S(if (CvDEPTH(cv) != 0)
                        PerlIO_printf(PerlIO_stderr(), "depth %ld != 0\n",
                                      CvDEPTH(cv)););
-           SAVEDESTRUCTOR(S_unset_cvowner, (void*) cv);
+           SAVEDESTRUCTOR(unset_cvowner, (void*) cv);
        }
     }
 #endif /* USE_THREADS */
@@ -2597,3 +2579,24 @@ PP(pp_method)
     RETURN;
 }
 
+#ifdef USE_THREADS
+static void
+unset_cvowner(pTHXo_ void *cvarg)
+{
+    register CV* cv = (CV *) cvarg;
+#ifdef DEBUGGING
+    dTHR;
+#endif /* DEBUGGING */
+
+    DEBUG_S((PerlIO_printf(PerlIO_stderr(), "%p unsetting CvOWNER of %p:%s\n",
+                          thr, cv, SvPEEK((SV*)cv))));
+    MUTEX_LOCK(CvMUTEXP(cv));
+    DEBUG_S(if (CvDEPTH(cv) != 0)
+               PerlIO_printf(PerlIO_stderr(), "depth %ld != 0\n",
+                             CvDEPTH(cv)););
+    assert(thr == CvOWNER(cv));
+    CvOWNER(cv) = 0;
+    MUTEX_UNLOCK(CvMUTEXP(cv));
+    SvREFCNT_dec(cv);
+}
+#endif /* USE_THREADS */
diff --git a/proto.h b/proto.h
index 2fac5d0..b02eb43 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -676,16 +676,8 @@ VIRTUAL void       Perl_safexfree(Malloc_t where);
 #if defined(PERL_GLOBAL_STRUCT)
 VIRTUAL struct perl_vars *     Perl_GetVars(pTHX);
 #endif
-VIRTUAL void   Perl_yydestruct(pTHX_ void *ptr);
 VIRTUAL int    Perl_runops_standard(pTHX);
 VIRTUAL int    Perl_runops_debug(pTHX);
-#if defined(WIN32)
-#if defined(PERL_OBJECT)
-VIRTUAL int&   Perl_ErrorNo(pTHX);
-#else
-VIRTUAL int*   Perl_ErrorNo(pTHX);
-#endif
-#endif
 VIRTUAL void   Perl_sv_catpvf_mg(pTHX_ SV *sv, const char* pat, ...);
 VIRTUAL void   Perl_sv_catpv_mg(pTHX_ SV *sv, const char *ptr);
 VIRTUAL void   Perl_sv_catpvn_mg(pTHX_ SV *sv, const char *ptr, STRLEN len);
@@ -752,8 +744,6 @@ STATIC void S_hv_magic_check(pTHX_ HV *hv, bool *needs_copy, bool *needs_store);
 STATIC void    S_save_magic(pTHX_ I32 mgs_ix, SV *sv);
 STATIC int     S_magic_methpack(pTHX_ SV *sv, MAGIC *mg, char *meth);
 STATIC int     S_magic_methcall(pTHX_ SV *sv, MAGIC *mg, char *meth, I32 f, int n, SV *val);
-STATIC void    S_unwind_handler_stack(pTHX_ void *p);
-STATIC void    S_restore_magic(pTHX_ void *p);
 #endif
 #if defined(PERL_IN_OP_C) || defined(PERL_DECL_PROT)
 STATIC I32     S_list_assignment(pTHX_ OP *o);
@@ -830,19 +820,9 @@ STATIC void        S_save_lines(pTHX_ AV *array, SV *sv);
 STATIC OP*     S_doeval(pTHX_ int gimme, OP** startop);
 STATIC PerlIO *        S_doopen_pmc(pTHX_ const char *name, const char *mode);
 STATIC void    S_qsortsv(pTHX_ SV ** array, size_t num_elts, SVCOMPARE_t f);
-STATIC I32     S_sortcv(pTHX_ SV *a, SV *b);
-STATIC I32     S_sv_ncmp(pTHX_ SV *a, SV *b);
-STATIC I32     S_sv_i_ncmp(pTHX_ SV *a, SV *b);
-STATIC I32     S_amagic_ncmp(pTHX_ SV *a, SV *b);
-STATIC I32     S_amagic_i_ncmp(pTHX_ SV *a, SV *b);
-STATIC I32     S_amagic_cmp(pTHX_ SV *str1, SV *str2);
-STATIC I32     S_amagic_cmp_locale(pTHX_ SV *str1, SV *str2);
 #endif
 #if defined(PERL_IN_PP_HOT_C) || defined(PERL_DECL_PROT)
 STATIC CV*     S_get_db_sub(pTHX_ SV **svp, CV *cv);
-#  if defined(USE_THREADS)
-STATIC void    S_unset_cvowner(pTHX_ void *cvarg);
-#  endif
 #endif
 #if defined(PERL_IN_PP_SYS_C) || defined(PERL_DECL_PROT)
 STATIC OP*     S_doform(pTHX_ CV *cv, GV *gv, OP *retop);
@@ -875,7 +855,6 @@ STATIC I32  S_add_data(pTHX_ I32 n, char *s);
 STATIC void    S_re_croak2(pTHX_ const char* pat1, const char* pat2, ...) __attribute__((noreturn));
 STATIC I32     S_regpposixcc(pTHX_ I32 value);
 STATIC void    S_checkposixcc(pTHX);
-STATIC void    S_clear_re(pTHX_ void *r);
 #endif
 #if defined(PERL_IN_REGEXEC_C) || defined(PERL_DECL_PROT)
 STATIC I32     S_regmatch(pTHX_ regnode *prog);
@@ -888,7 +867,6 @@ STATIC CHECKPOINT   S_regcppush(pTHX_ I32 parenfloor);
 STATIC char*   S_regcppop(pTHX);
 STATIC char*   S_regcp_set_to(pTHX_ I32 ss);
 STATIC void    S_cache_re(pTHX_ regexp *prog);
-STATIC void    S_restore_pos(pTHX_ void *arg);
 STATIC U8*     S_reghop(pTHX_ U8 *pos, I32 off);
 STATIC U8*     S_reghopmaybe(pTHX_ U8 *pos, I32 off);
 #endif
@@ -915,10 +893,6 @@ STATIC void        S_del_xnv(pTHX_ XPVNV* p);
 STATIC void    S_del_xpv(pTHX_ XPV* p);
 STATIC void    S_del_xrv(pTHX_ XRV* p);
 STATIC void    S_sv_unglob(pTHX_ SV* sv);
-STATIC void    S_do_report_used(pTHX_ SV *sv);
-STATIC void    S_do_clean_objs(pTHX_ SV *sv);
-STATIC void    S_do_clean_named_objs(pTHX_ SV *sv);
-STATIC void    S_do_clean_all(pTHX_ SV *sv);
 STATIC void    S_not_a_number(pTHX_ SV *sv);
 STATIC void    S_visit(pTHX_ SVFUNC_t f);
 #  if defined(PURIFY)
@@ -969,9 +943,6 @@ STATIC void S_depcom(pTHX);
 STATIC char*   S_incl_perldb(pTHX);
 STATIC I32     S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen);
 STATIC I32     S_utf16rev_textfilter(pTHX_ int idx, SV *sv, int maxlen);
-STATIC void    S_restore_rsfp(pTHX_ void *f);
-STATIC void    S_restore_expect(pTHX_ void *e);
-STATIC void    S_restore_lex_expect(pTHX_ void *e);
 #  if defined(CRIPPLED_CC)
 STATIC int     S_uni(pTHX_ I32 f, char *s);
 #  endif
index 9c9fc14..d2717e1 100644 (file)
--- a/regcomp.c
+++ b/regcomp.c
@@ -169,11 +169,7 @@ static scan_data_t zero_scan_data = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 #define CHR_SVLEN(sv) (UTF ? sv_len_utf8(sv) : SvCUR(sv))
 #define CHR_DIST(a,b) (UTF ? utf8_distance(a,b) : a - b)
 
-STATIC void
-S_clear_re(pTHX_ void *r)
-{
-    ReREFCNT_dec((regexp *)r);
-}
+static void clear_re(pTHXo_ void *r);
 
 STATIC void
 S_scan_commit(pTHX_ scan_data_t *data)
@@ -3390,3 +3386,17 @@ Perl_save_re_context(pTHX)
     SAVEPPTR(PL_reg_starttry);         /* from regexec.c */    
 #endif
 }
+
+#ifdef PERL_OBJECT
+#define NO_XSLOCKS
+#include "XSUB.h"
+#undef this
+#define this pPerl
+#endif
+
+static void
+clear_re(pTHXo_ void *r)
+{
+    ReREFCNT_dec((regexp *)r);
+}
+
index 61726bb..7bddc1b 100644 (file)
--- a/regcomp.h
+++ b/regcomp.h
@@ -241,14 +241,14 @@ struct regnode_2 {
 #define        FAIL(m) \
     STMT_START {                                                       \
        if (!SIZE_ONLY)                                                 \
-           SAVEDESTRUCTOR(S_clear_re,(void*)PL_regcomp_rx);            \
+           SAVEDESTRUCTOR(clear_re,(void*)PL_regcomp_rx);              \
        Perl_croak(aTHX_ "/%.127s/: %s",  PL_regprecomp,m);             \
     } STMT_END
 
 #define        FAIL2(pat,m) \
     STMT_START {                                                       \
        if (!SIZE_ONLY)                                                 \
-           SAVEDESTRUCTOR(S_clear_re,(void*)PL_regcomp_rx);            \
+           SAVEDESTRUCTOR(clear_re,(void*)PL_regcomp_rx);              \
        S_re_croak2(aTHX_ "/%.127s/: ",pat,PL_regprecomp,m);            \
     } STMT_END
 
index 58d6af9..286131a 100644 (file)
--- a/regexec.c
+++ b/regexec.c
 #define HOPc(pos,off) ((char*)HOP(pos,off))
 #define HOPMAYBEc(pos,off) ((char*)HOPMAYBE(pos,off))
 
+static void restore_pos(pTHXo_ void *arg);
+
+
 STATIC CHECKPOINT
 S_regcppush(pTHX_ I32 parenfloor)
 {
@@ -243,22 +246,6 @@ S_cache_re(pTHX_ regexp *prog)
     PL_reg_re = prog;    
 }
 
-STATIC void
-S_restore_pos(pTHX_ void *arg)
-{
-    dTHR;
-    if (PL_reg_eval_set) {
-       if (PL_reg_oldsaved) {
-           PL_reg_re->subbeg = PL_reg_oldsaved;
-           PL_reg_re->sublen = PL_reg_oldsavedlen;
-           RX_MATCH_COPIED_on(PL_reg_re);
-       }
-       PL_reg_magic->mg_len = PL_reg_oldpos;
-       PL_reg_eval_set = 0;
-       PL_curpm = PL_reg_oldcurpm;
-    }  
-}
-
 /* 
  * Need to implement the following flags for reg_anch:
  *
@@ -2022,7 +2009,7 @@ got_it:
            sv_setsv(oreplsv, GvSV(PL_replgv));/* So that when GvSV(replgv) is
                                                  restored, the value remains
                                                  the same. */
-       restore_pos(0);
+       restore_pos(aTHXo_ 0);
     }
 
     /* make sure $`, $&, $', and $digit will work later */
@@ -2049,7 +2036,7 @@ got_it:
 
 phooey:
     if (PL_reg_eval_set)
-       restore_pos(0);
+       restore_pos(aTHXo_ 0);
     return 0;
 }
 
@@ -2098,7 +2085,7 @@ S_regtry(pTHX_ regexp *prog, char *startpos)
            }
            PL_reg_magic    = mg;
            PL_reg_oldpos   = mg->mg_len;
-           SAVEDESTRUCTOR(S_restore_pos, 0);
+           SAVEDESTRUCTOR(restore_pos, 0);
         }
        if (!PL_reg_curpm)
            New(22,PL_reg_curpm, 1, PMOP);
@@ -4455,3 +4442,25 @@ S_reghopmaybe(pTHX_ U8* s, I32 off)
     }
     return s;
 }
+
+#ifdef PERL_OBJECT
+#define NO_XSLOCKS
+#include "XSUB.h"
+#endif
+
+static void
+restore_pos(pTHXo_ void *arg)
+{
+    dTHR;
+    if (PL_reg_eval_set) {
+       if (PL_reg_oldsaved) {
+           PL_reg_re->subbeg = PL_reg_oldsaved;
+           PL_reg_re->sublen = PL_reg_oldsavedlen;
+           RX_MATCH_COPIED_on(PL_reg_re);
+       }
+       PL_reg_magic->mg_len = PL_reg_oldpos;
+       PL_reg_eval_set = 0;
+       PL_curpm = PL_reg_oldcurpm;
+    }  
+}
+
diff --git a/scope.c b/scope.c
index f87689e..3da5e63 100644 (file)
--- a/scope.c
+++ b/scope.c
@@ -824,7 +824,7 @@ Perl_leave_scope(pTHX_ I32 base)
            break;
        case SAVEt_DESTRUCTOR:
            ptr = SSPOPPTR;
-           CALLDESTRUCTOR(aTHX_ ptr);
+           CALLDESTRUCTOR(aTHXo_ ptr);
            break;
        case SAVEt_REGCONTEXT:
        case SAVEt_ALLOC:
diff --git a/scope.h b/scope.h
index c0070bd..4a3a2ed 100644 (file)
--- a/scope.h
+++ b/scope.h
 #define SAVEGENERICSV(s)       save_generic_svref((SV**)&(s))
 #define SAVEDELETE(h,k,l) \
          save_delete(SOFT_CAST(HV*)(h), SOFT_CAST(char*)(k), (I32)(l))
-#ifdef PERL_OBJECT
-#define CALLDESTRUCTOR (this->*SSPOPDPTR)
-#else
 #define CALLDESTRUCTOR (*SSPOPDPTR)
-#endif
 #define SAVEDESTRUCTOR(f,p) \
          save_destructor((DESTRUCTORFUNC_t)(FUNC_NAME_TO_PTR(f)),      \
                          SOFT_CAST(void*)(p))
diff --git a/sv.c b/sv.c
index 9973156..5bb9a87 100644 (file)
--- a/sv.c
+++ b/sv.c
 #endif
 
 #ifdef PERL_OBJECT
-#define FCALL this->*f
 #define VTBL this->*vtbl
 #else /* !PERL_OBJECT */
 #define VTBL *vtbl
-#define FCALL *f
 #endif /* PERL_OBJECT */
 
+#define FCALL *f
 #define SV_CHECK_THINKFIRST(sv) if (SvTHINKFIRST(sv)) sv_force_normal(sv)
 
+static void do_report_used(pTHXo_ SV *sv);
+static void do_clean_objs(pTHXo_ SV *sv);
+#ifndef DISABLE_DESTRUCTOR_KLUDGE
+static void do_clean_named_objs(pTHXo_ SV *sv);
+#endif
+static void do_clean_all(pTHXo_ SV *sv);
+
+
 #ifdef PURIFY
 
 #define new_SV(p) \
@@ -277,87 +284,36 @@ S_visit(pTHX_ SVFUNC_t f)
        svend = &sva[SvREFCNT(sva)];
        for (sv = sva + 1; sv < svend; ++sv) {
            if (SvTYPE(sv) != SVTYPEMASK)
-               (FCALL)(aTHX_ sv);
+               (FCALL)(aTHXo_ sv);
        }
     }
 }
 
 #endif /* PURIFY */
 
-STATIC void
-S_do_report_used(pTHX_ SV *sv)
-{
-    if (SvTYPE(sv) != SVTYPEMASK) {
-       /* XXX Perhaps this ought to go to Perl_debug_log, if DEBUGGING. */
-       PerlIO_printf(PerlIO_stderr(), "****\n");
-       sv_dump(sv);
-    }
-}
-
 void
 Perl_sv_report_used(pTHX)
 {
-    visit(FUNC_NAME_TO_PTR(S_do_report_used));
+    visit(FUNC_NAME_TO_PTR(do_report_used));
 }
 
-STATIC void
-S_do_clean_objs(pTHX_ SV *sv)
-{
-    SV* rv;
-
-    if (SvROK(sv) && SvOBJECT(rv = SvRV(sv))) {
-       DEBUG_D((PerlIO_printf(Perl_debug_log, "Cleaning object ref:\n "), sv_dump(sv));)
-       SvROK_off(sv);
-       SvRV(sv) = 0;
-       SvREFCNT_dec(rv);
-    }
-
-    /* XXX Might want to check arrays, etc. */
-}
-
-#ifndef DISABLE_DESTRUCTOR_KLUDGE
-STATIC void
-S_do_clean_named_objs(pTHX_ SV *sv)
-{
-    if (SvTYPE(sv) == SVt_PVGV) {
-       if ( SvOBJECT(GvSV(sv)) ||
-            GvAV(sv) && SvOBJECT(GvAV(sv)) ||
-            GvHV(sv) && SvOBJECT(GvHV(sv)) ||
-            GvIO(sv) && SvOBJECT(GvIO(sv)) ||
-            GvCV(sv) && SvOBJECT(GvCV(sv)) )
-       {
-           DEBUG_D((PerlIO_printf(Perl_debug_log, "Cleaning named glob object:\n "), sv_dump(sv));)
-           SvREFCNT_dec(sv);
-       }
-    }
-}
-#endif
-
 void
 Perl_sv_clean_objs(pTHX)
 {
     PL_in_clean_objs = TRUE;
-    visit(FUNC_NAME_TO_PTR(S_do_clean_objs));
+    visit(FUNC_NAME_TO_PTR(do_clean_objs));
 #ifndef DISABLE_DESTRUCTOR_KLUDGE
     /* some barnacles may yet remain, clinging to typeglobs */
-    visit(FUNC_NAME_TO_PTR(S_do_clean_named_objs));
+    visit(FUNC_NAME_TO_PTR(do_clean_named_objs));
 #endif
     PL_in_clean_objs = FALSE;
 }
 
-STATIC void
-S_do_clean_all(pTHX_ SV *sv)
-{
-    DEBUG_D((PerlIO_printf(Perl_debug_log, "Cleaning loops: SV at 0x%lx\n", sv) );)
-    SvFLAGS(sv) |= SVf_BREAK;
-    SvREFCNT_dec(sv);
-}
-
 void
 Perl_sv_clean_all(pTHX)
 {
     PL_in_clean_all = TRUE;
-    visit(FUNC_NAME_TO_PTR(S_do_clean_all));
+    visit(FUNC_NAME_TO_PTR(do_clean_all));
     PL_in_clean_all = FALSE;
 }
 
@@ -5241,3 +5197,61 @@ Perl_sv_vcatpvfn(pTHX_ SV *sv, const char *pat, STRLEN patlen, va_list *args, SV
        SvCUR(sv) = p - SvPVX(sv);
     }
 }
+
+
+#ifdef PERL_OBJECT
+#define NO_XSLOCKS
+#include "XSUB.h"
+#endif
+
+static void
+do_report_used(pTHXo_ SV *sv)
+{
+    if (SvTYPE(sv) != SVTYPEMASK) {
+       /* XXX Perhaps this ought to go to Perl_debug_log, if DEBUGGING. */
+       PerlIO_printf(PerlIO_stderr(), "****\n");
+       sv_dump(sv);
+    }
+}
+
+static void
+do_clean_objs(pTHXo_ SV *sv)
+{
+    SV* rv;
+
+    if (SvROK(sv) && SvOBJECT(rv = SvRV(sv))) {
+       DEBUG_D((PerlIO_printf(Perl_debug_log, "Cleaning object ref:\n "), sv_dump(sv));)
+       SvROK_off(sv);
+       SvRV(sv) = 0;
+       SvREFCNT_dec(rv);
+    }
+
+    /* XXX Might want to check arrays, etc. */
+}
+
+#ifndef DISABLE_DESTRUCTOR_KLUDGE
+static void
+do_clean_named_objs(pTHXo_ SV *sv)
+{
+    if (SvTYPE(sv) == SVt_PVGV) {
+       if ( SvOBJECT(GvSV(sv)) ||
+            GvAV(sv) && SvOBJECT(GvAV(sv)) ||
+            GvHV(sv) && SvOBJECT(GvHV(sv)) ||
+            GvIO(sv) && SvOBJECT(GvIO(sv)) ||
+            GvCV(sv) && SvOBJECT(GvCV(sv)) )
+       {
+           DEBUG_D((PerlIO_printf(Perl_debug_log, "Cleaning named glob object:\n "), sv_dump(sv));)
+           SvREFCNT_dec(sv);
+       }
+    }
+}
+#endif
+
+static void
+do_clean_all(pTHXo_ SV *sv)
+{
+    DEBUG_D((PerlIO_printf(Perl_debug_log, "Cleaning loops: SV at 0x%lx\n", sv) );)
+    SvFLAGS(sv) |= SVf_BREAK;
+    SvREFCNT_dec(sv);
+}
+
index c823393..5406085 100644 (file)
--- a/thrdvar.h
+++ b/thrdvar.h
@@ -138,7 +138,7 @@ PERLVAR(Tseen_evals,        I32)            /* from regcomp.c */
 PERLVAR(Tregcomp_rx,   regexp *)       /* from regcomp.c */
 PERLVAR(Textralen,     I32)            /* from regcomp.c */
 PERLVAR(Tcolorset,     int)            /* from regcomp.c */
-PERLVAR(Tcolors[6],    char *)         /* from regcomp.c */
+PERLVARA(Tcolors,6,    char *)         /* from regcomp.c */
 PERLVAR(Treginput,     char *)         /* String-input pointer. */
 PERLVAR(Tregbol,       char *)         /* Beginning of input, for ^ check. */
 PERLVAR(Tregeol,       char *)         /* End of input, for $ check. */
diff --git a/toke.c b/toke.c
index d9e3bf7..85b37a4 100644 (file)
--- a/toke.c
+++ b/toke.c
 
 static char ident_too_long[] = "Identifier too long";
 
+static void restore_rsfp(pTHXo_ void *f);
+static void restore_expect(pTHXo_ void *e);
+static void restore_lex_expect(pTHXo_ void *e);
+
 #define UTF (PL_hints & HINT_UTF8)
 /*
  * Note: we try to be careful never to call the isXXX_utf8() functions
@@ -282,12 +286,12 @@ Perl_lex_start(pTHX_ SV *line)
     SAVESPTR(PL_linestr);
     SAVEPPTR(PL_lex_brackstack);
     SAVEPPTR(PL_lex_casestack);
-    SAVEDESTRUCTOR(S_restore_rsfp, PL_rsfp);
+    SAVEDESTRUCTOR(restore_rsfp, PL_rsfp);
     SAVESPTR(PL_lex_stuff);
     SAVEI32(PL_lex_defer);
     SAVESPTR(PL_lex_repl);
-    SAVEDESTRUCTOR(S_restore_expect, PL_tokenbuf + PL_expect); /* encode as pointer */
-    SAVEDESTRUCTOR(S_restore_lex_expect, PL_tokenbuf + PL_expect);
+    SAVEDESTRUCTOR(restore_expect, PL_tokenbuf + PL_expect); /* encode as pointer */
+    SAVEDESTRUCTOR(restore_lex_expect, PL_tokenbuf + PL_expect);
 
     PL_lex_state = LEX_NORMAL;
     PL_lex_defer = 0;
@@ -330,32 +334,6 @@ Perl_lex_end(pTHX)
 }
 
 STATIC void
-S_restore_rsfp(pTHX_ void *f)
-{
-    PerlIO *fp = (PerlIO*)f;
-
-    if (PL_rsfp == PerlIO_stdin())
-       PerlIO_clearerr(PL_rsfp);
-    else if (PL_rsfp && (PL_rsfp != fp))
-       PerlIO_close(PL_rsfp);
-    PL_rsfp = fp;
-}
-
-STATIC void
-S_restore_expect(pTHX_ void *e)
-{
-    /* a safe way to store a small integer in a pointer */
-    PL_expect = (expectation)((char *)e - PL_tokenbuf);
-}
-
-STATIC void
-S_restore_lex_expect(pTHX_ void *e)
-{
-    /* a safe way to store a small integer in a pointer */
-    PL_lex_expect = (expectation)((char *)e - PL_tokenbuf);
-}
-
-STATIC void
 S_incline(pTHX_ char *s)
 {
     dTHR;
@@ -6432,3 +6410,34 @@ Perl_yyerror(pTHX_ char *s)
 }
 
 
+#ifdef PERL_OBJECT
+#define NO_XSLOCKS
+#include "XSUB.h"
+#endif
+
+static void
+restore_rsfp(pTHXo_ void *f)
+{
+    PerlIO *fp = (PerlIO*)f;
+
+    if (PL_rsfp == PerlIO_stdin())
+       PerlIO_clearerr(PL_rsfp);
+    else if (PL_rsfp && (PL_rsfp != fp))
+       PerlIO_close(PL_rsfp);
+    PL_rsfp = fp;
+}
+
+static void
+restore_expect(pTHXo_ void *e)
+{
+    /* a safe way to store a small integer in a pointer */
+    PL_expect = (expectation)((char *)e - PL_tokenbuf);
+}
+
+static void
+restore_lex_expect(pTHXo_ void *e)
+{
+    /* a safe way to store a small integer in a pointer */
+    PL_lex_expect = (expectation)((char *)e - PL_tokenbuf);
+}
+
diff --git a/util.c b/util.c
index 9374299..64580f6 100644 (file)
--- a/util.c
+++ b/util.c
@@ -546,7 +546,7 @@ Perl_new_collate(pTHX_ const char *newcoll)
 }
 
 void
-perl_set_numeric_radix(void)
+Perl_set_numeric_radix(pTHX)
 {
 #ifdef USE_LOCALE_NUMERIC
 # ifdef HAS_LOCALECONV
@@ -589,7 +589,7 @@ Perl_new_numeric(pTHX_ const char *newnum)
        PL_numeric_name = savepv(newnum);
        PL_numeric_standard = (strEQ(newnum, "C") || strEQ(newnum, "POSIX"));
        PL_numeric_local = TRUE;
-       perl_set_numeric_radix();
+       set_numeric_radix();
     }
 
 #endif /* USE_LOCALE_NUMERIC */
@@ -618,7 +618,7 @@ Perl_set_numeric_local(pTHX)
        setlocale(LC_NUMERIC, PL_numeric_name);
        PL_numeric_standard = FALSE;
        PL_numeric_local = TRUE;
-       perl_set_numeric_radix();
+       set_numeric_radix();
     }
 
 #endif /* USE_LOCALE_NUMERIC */
index 3cd581d..703a156 100644 (file)
@@ -511,13 +511,13 @@ statusvalue_vms
 sublex_info
 thrsv
 threadnum
-PL_piMem
-PL_piENV
-PL_piStdIO
-PL_piLIO
-PL_piDir
-PL_piSock
-PL_piProc
+PL_Mem
+PL_Env
+PL_StdIO
+PL_LIO
+PL_Dir
+PL_Sock
+PL_Proc
 cshname
 threadsv_names
 thread
@@ -544,7 +544,7 @@ sub readvars(\%$$) {
        or die "$0: Can't open $file: $!\n";
     while (<FILE>) {
        s/[ \t]*#.*//;          # Delete comments.
-       if (/PERLVARI?C?\($pre(\w+),\s*([^,)]+)/) {
+       if (/PERLVARA?I?C?\($pre(\w+),\s*([^,)]+)/) {
            $$syms{$1} = $2;
        }
     }
@@ -675,13 +675,13 @@ void Perl_deb(const char pat, ...)
 {
 }
 
-#undef PL_piMem
-#undef PL_piENV
-#undef PL_piStdIO
-#undef PL_piLIO
-#undef PL_piDir
-#undef PL_piSock
-#undef PL_piProc
+#undef PL_Mem
+#undef PL_Env
+#undef PL_StdIO
+#undef PL_LIO
+#undef PL_Dir
+#undef PL_Sock
+#undef PL_Proc
 
 int *        _win32_errno(void)
 {
@@ -690,27 +690,27 @@ int *        _win32_errno(void)
 
 FILE*        _win32_stdin(void)
 {
-    return (FILE*)pPerl->PL_piStdIO->Stdin();
+    return (FILE*)pPerl->PL_StdIO->Stdin();
 }
 
 FILE*        _win32_stdout(void)
 {
-    return (FILE*)pPerl->PL_piStdIO->Stdout();
+    return (FILE*)pPerl->PL_StdIO->Stdout();
 }
 
 FILE*        _win32_stderr(void)
 {
-    return (FILE*)pPerl->PL_piStdIO->Stderr();
+    return (FILE*)pPerl->PL_StdIO->Stderr();
 }
 
 int          _win32_ferror(FILE *fp)
 {
-    return pPerl->PL_piStdIO->Error((PerlIO*)fp, ErrorNo());
+    return pPerl->PL_StdIO->Error((PerlIO*)fp, ErrorNo());
 }
 
 int          _win32_feof(FILE *fp)
 {
-    return pPerl->PL_piStdIO->Eof((PerlIO*)fp, ErrorNo());
+    return pPerl->PL_StdIO->Eof((PerlIO*)fp, ErrorNo());
 }
 
 char*       _win32_strerror(int e)
@@ -725,12 +725,12 @@ void           _win32_perror(const char *str)
 
 int          _win32_vfprintf(FILE *pf, const char *format, va_list arg)
 {
-    return pPerl->PL_piStdIO->Vprintf((PerlIO*)pf, ErrorNo(), format, arg);
+    return pPerl->PL_StdIO->Vprintf((PerlIO*)pf, ErrorNo(), format, arg);
 }
 
 int          _win32_vprintf(const char *format, va_list arg)
 {
-    return pPerl->PL_piStdIO->Vprintf(pPerl->PL_piStdIO->Stdout(), ErrorNo(), format, arg);
+    return pPerl->PL_StdIO->Vprintf(pPerl->PL_StdIO->Stdout(), ErrorNo(), format, arg);
 }
 
 int          _win32_fprintf(FILE *pf, const char *format, ...)
@@ -755,532 +755,532 @@ int          _win32_printf(const char *format, ...)
 
 size_t       _win32_fread(void *buf, size_t size, size_t count, FILE *pf)
 {
-    return pPerl->PL_piStdIO->Read((PerlIO*)pf, buf, (size*count), ErrorNo());
+    return pPerl->PL_StdIO->Read((PerlIO*)pf, buf, (size*count), ErrorNo());
 }
 
 size_t       _win32_fwrite(const void *buf, size_t size, size_t count, FILE *pf)
 {
-    return pPerl->PL_piStdIO->Write((PerlIO*)pf, buf, (size*count), ErrorNo());
+    return pPerl->PL_StdIO->Write((PerlIO*)pf, buf, (size*count), ErrorNo());
 }
 
 FILE*        _win32_fopen(const char *path, const char *mode)
 {
-    return (FILE*)pPerl->PL_piStdIO->Open(path, mode, ErrorNo());
+    return (FILE*)pPerl->PL_StdIO->Open(path, mode, ErrorNo());
 }
 
 FILE*        _win32_fdopen(int fh, const char *mode)
 {
-    return (FILE*)pPerl->PL_piStdIO->Fdopen(fh, mode, ErrorNo());
+    return (FILE*)pPerl->PL_StdIO->Fdopen(fh, mode, ErrorNo());
 }
 
 FILE*        _win32_freopen(const char *path, const char *mode, FILE *pf)
 {
-    return (FILE*)pPerl->PL_piStdIO->Reopen(path, mode, (PerlIO*)pf, ErrorNo());
+    return (FILE*)pPerl->PL_StdIO->Reopen(path, mode, (PerlIO*)pf, ErrorNo());
 }
 
 int          _win32_fclose(FILE *pf)
 {
-    return pPerl->PL_piStdIO->Close((PerlIO*)pf, ErrorNo());
+    return pPerl->PL_StdIO->Close((PerlIO*)pf, ErrorNo());
 }
 
 int          _win32_fputs(const char *s,FILE *pf)
 {
-    return pPerl->PL_piStdIO->Puts((PerlIO*)pf, s, ErrorNo());
+    return pPerl->PL_StdIO->Puts((PerlIO*)pf, s, ErrorNo());
 }
 
 int          _win32_fputc(int c,FILE *pf)
 {
-    return pPerl->PL_piStdIO->Putc((PerlIO*)pf, c, ErrorNo());
+    return pPerl->PL_StdIO->Putc((PerlIO*)pf, c, ErrorNo());
 }
 
 int          _win32_ungetc(int c,FILE *pf)
 {
-    return pPerl->PL_piStdIO->Ungetc((PerlIO*)pf, c, ErrorNo());
+    return pPerl->PL_StdIO->Ungetc((PerlIO*)pf, c, ErrorNo());
 }
 
 int          _win32_getc(FILE *pf)
 {
-    return pPerl->PL_piStdIO->Getc((PerlIO*)pf, ErrorNo());
+    return pPerl->PL_StdIO->Getc((PerlIO*)pf, ErrorNo());
 }
 
 int          _win32_fileno(FILE *pf)
 {
-    return pPerl->PL_piStdIO->Fileno((PerlIO*)pf, ErrorNo());
+    return pPerl->PL_StdIO->Fileno((PerlIO*)pf, ErrorNo());
 }
 
 void         _win32_clearerr(FILE *pf)
 {
-    pPerl->PL_piStdIO->Clearerr((PerlIO*)pf, ErrorNo());
+    pPerl->PL_StdIO->Clearerr((PerlIO*)pf, ErrorNo());
 }
 
 int          _win32_fflush(FILE *pf)
 {
-    return pPerl->PL_piStdIO->Flush((PerlIO*)pf, ErrorNo());
+    return pPerl->PL_StdIO->Flush((PerlIO*)pf, ErrorNo());
 }
 
 long         _win32_ftell(FILE *pf)
 {
-    return pPerl->PL_piStdIO->Tell((PerlIO*)pf, ErrorNo());
+    return pPerl->PL_StdIO->Tell((PerlIO*)pf, ErrorNo());
 }
 
 int          _win32_fseek(FILE *pf,long offset,int origin)
 {
-    return pPerl->PL_piStdIO->Seek((PerlIO*)pf, offset, origin, ErrorNo());
+    return pPerl->PL_StdIO->Seek((PerlIO*)pf, offset, origin, ErrorNo());
 }
 
 int          _win32_fgetpos(FILE *pf,fpos_t *p)
 {
-    return pPerl->PL_piStdIO->Getpos((PerlIO*)pf, p, ErrorNo());
+    return pPerl->PL_StdIO->Getpos((PerlIO*)pf, p, ErrorNo());
 }
 
 int          _win32_fsetpos(FILE *pf,const fpos_t *p)
 {
-    return pPerl->PL_piStdIO->Setpos((PerlIO*)pf, p, ErrorNo());
+    return pPerl->PL_StdIO->Setpos((PerlIO*)pf, p, ErrorNo());
 }
 
 void         _win32_rewind(FILE *pf)
 {
-    pPerl->PL_piStdIO->Rewind((PerlIO*)pf, ErrorNo());
+    pPerl->PL_StdIO->Rewind((PerlIO*)pf, ErrorNo());
 }
 
 FILE*        _win32_tmpfile(void)
 {
-    return (FILE*)pPerl->PL_piStdIO->Tmpfile(ErrorNo());
+    return (FILE*)pPerl->PL_StdIO->Tmpfile(ErrorNo());
 }
 
 void         _win32_setbuf(FILE *pf, char *buf)
 {
-    pPerl->PL_piStdIO->SetBuf((PerlIO*)pf, buf, ErrorNo());
+    pPerl->PL_StdIO->SetBuf((PerlIO*)pf, buf, ErrorNo());
 }
 
 int          _win32_setvbuf(FILE *pf, char *buf, int type, size_t size)
 {
-    return pPerl->PL_piStdIO->SetVBuf((PerlIO*)pf, buf, type, size, ErrorNo());
+    return pPerl->PL_StdIO->SetVBuf((PerlIO*)pf, buf, type, size, ErrorNo());
 }
 
 char*          _win32_fgets(char *s, int n, FILE *pf)
 {
-    return pPerl->PL_piStdIO->Gets((PerlIO*)pf, s, n, ErrorNo());
+    return pPerl->PL_StdIO->Gets((PerlIO*)pf, s, n, ErrorNo());
 }
 
 char*          _win32_gets(char *s)
 {
-    return _win32_fgets(s, 80, (FILE*)pPerl->PL_piStdIO->Stdin());
+    return _win32_fgets(s, 80, (FILE*)pPerl->PL_StdIO->Stdin());
 }
 
 int          _win32_fgetc(FILE *pf)
 {
-    return pPerl->PL_piStdIO->Getc((PerlIO*)pf, ErrorNo());
+    return pPerl->PL_StdIO->Getc((PerlIO*)pf, ErrorNo());
 }
 
 int          _win32_putc(int c, FILE *pf)
 {
-    return pPerl->PL_piStdIO->Putc((PerlIO*)pf, c, ErrorNo());
+    return pPerl->PL_StdIO->Putc((PerlIO*)pf, c, ErrorNo());
 }
 
 int          _win32_puts(const char *s)
 {
-    return pPerl->PL_piStdIO->Puts(pPerl->PL_piStdIO->Stdout(), s, ErrorNo());
+    return pPerl->PL_StdIO->Puts(pPerl->PL_StdIO->Stdout(), s, ErrorNo());
 }
 
 int          _win32_getchar(void)
 {
-    return pPerl->PL_piStdIO->Getc(pPerl->PL_piStdIO->Stdin(), ErrorNo());
+    return pPerl->PL_StdIO->Getc(pPerl->PL_StdIO->Stdin(), ErrorNo());
 }
 
 int          _win32_putchar(int c)
 {
-    return pPerl->PL_piStdIO->Putc(pPerl->PL_piStdIO->Stdout(), c, ErrorNo());
+    return pPerl->PL_StdIO->Putc(pPerl->PL_StdIO->Stdout(), c, ErrorNo());
 }
 
 void*        _win32_malloc(size_t size)
 {
-    return pPerl->PL_piMem->Malloc(size);
+    return pPerl->PL_Mem->Malloc(size);
 }
 
 void*        _win32_calloc(size_t numitems, size_t size)
 {
-    return pPerl->PL_piMem->Malloc(numitems*size);
+    return pPerl->PL_Mem->Malloc(numitems*size);
 }
 
 void*        _win32_realloc(void *block, size_t size)
 {
-    return pPerl->PL_piMem->Realloc(block, size);
+    return pPerl->PL_Mem->Realloc(block, size);
 }
 
 void         _win32_free(void *block)
 {
-    pPerl->PL_piMem->Free(block);
+    pPerl->PL_Mem->Free(block);
 }
 
 void         _win32_abort(void)
 {
-    pPerl->PL_piProc->Abort();
+    pPerl->PL_Proc->Abort();
 }
 
 int          _win32_pipe(int *phandles, unsigned int psize, int textmode)
 {
-    return pPerl->PL_piProc->Pipe(phandles);
+    return pPerl->PL_Proc->Pipe(phandles);
 }
 
 FILE*        _win32_popen(const char *command, const char *mode)
 {
-    return (FILE*)pPerl->PL_piProc->Popen(command, mode);
+    return (FILE*)pPerl->PL_Proc->Popen(command, mode);
 }
 
 int          _win32_pclose(FILE *pf)
 {
-    return pPerl->PL_piProc->Pclose((PerlIO*)pf);
+    return pPerl->PL_Proc->Pclose((PerlIO*)pf);
 }
 
 unsigned     _win32_sleep(unsigned int t)
 {
-    return pPerl->PL_piProc->Sleep(t);
+    return pPerl->PL_Proc->Sleep(t);
 }
 
 int    _win32_spawnvp(int mode, const char *cmdname, const char *const *argv)
 {
-    return pPerl->PL_piProc->Spawnvp(mode, cmdname, argv);
+    return pPerl->PL_Proc->Spawnvp(mode, cmdname, argv);
 }
 
 int          _win32_mkdir(const char *dir, int mode)
 {
-    return pPerl->PL_piDir->Makedir(dir, mode, ErrorNo());
+    return pPerl->PL_Dir->Makedir(dir, mode, ErrorNo());
 }
 
 int          _win32_rmdir(const char *dir)
 {
-    return pPerl->PL_piDir->Rmdir(dir, ErrorNo());
+    return pPerl->PL_Dir->Rmdir(dir, ErrorNo());
 }
 
 int          _win32_chdir(const char *dir)
 {
-    return pPerl->PL_piDir->Chdir(dir, ErrorNo());
+    return pPerl->PL_Dir->Chdir(dir, ErrorNo());
 }
 
 #undef stat
 int          _win32_fstat(int fd,struct stat *sbufptr)
 {
-    return pPerl->PL_piLIO->FileStat(fd, sbufptr, ErrorNo());
+    return pPerl->PL_LIO->FileStat(fd, sbufptr, ErrorNo());
 }
 
 int          _win32_stat(const char *name,struct stat *sbufptr)
 {
-    return pPerl->PL_piLIO->NameStat(name, sbufptr, ErrorNo());
+    return pPerl->PL_LIO->NameStat(name, sbufptr, ErrorNo());
 }
 
 int          _win32_rename(const char *oname, const char *newname)
 {
-    return pPerl->PL_piLIO->Rename(oname, newname, ErrorNo());
+    return pPerl->PL_LIO->Rename(oname, newname, ErrorNo());
 }
 
 int          _win32_setmode(int fd, int mode)
 {
-    return pPerl->PL_piLIO->Setmode(fd, mode, ErrorNo());
+    return pPerl->PL_LIO->Setmode(fd, mode, ErrorNo());
 }
 
 long         _win32_lseek(int fd, long offset, int origin)
 {
-    return pPerl->PL_piLIO->Lseek(fd, offset, origin, ErrorNo());
+    return pPerl->PL_LIO->Lseek(fd, offset, origin, ErrorNo());
 }
 
 long         _win32_tell(int fd)
 {
-    return pPerl->PL_piStdIO->Tell((PerlIO*)fd, ErrorNo());
+    return pPerl->PL_StdIO->Tell((PerlIO*)fd, ErrorNo());
 }
 
 int          _win32_dup(int fd)
 {
-    return pPerl->PL_piLIO->Dup(fd, ErrorNo());
+    return pPerl->PL_LIO->Dup(fd, ErrorNo());
 }
 
 int          _win32_dup2(int h1, int h2)
 {
-    return pPerl->PL_piLIO->Dup2(h1, h2, ErrorNo());
+    return pPerl->PL_LIO->Dup2(h1, h2, ErrorNo());
 }
 
 int          _win32_open(const char *path, int oflag,...)
 {
-    return pPerl->PL_piLIO->Open(path, oflag, ErrorNo());
+    return pPerl->PL_LIO->Open(path, oflag, ErrorNo());
 }
 
 int          _win32_close(int fd)
 {
-    return pPerl->PL_piLIO->Close(fd, ErrorNo());
+    return pPerl->PL_LIO->Close(fd, ErrorNo());
 }
 
 int          _win32_read(int fd, void *buf, unsigned int cnt)
 {
-    return pPerl->PL_piLIO->Read(fd, buf, cnt, ErrorNo());
+    return pPerl->PL_LIO->Read(fd, buf, cnt, ErrorNo());
 }
 
 int          _win32_write(int fd, const void *buf, unsigned int cnt)
 {
-    return pPerl->PL_piLIO->Write(fd, buf, cnt, ErrorNo());
+    return pPerl->PL_LIO->Write(fd, buf, cnt, ErrorNo());
 }
 
 int          _win32_times(struct tms *timebuf)
 {
-    return pPerl->PL_piProc->Times(timebuf);
+    return pPerl->PL_Proc->Times(timebuf);
 }
 
 int          _win32_ioctl(int i, unsigned int u, char *data)
 {
-    return pPerl->PL_piLIO->IOCtl(i, u, data, ErrorNo());
+    return pPerl->PL_LIO->IOCtl(i, u, data, ErrorNo());
 }
 
 int          _win32_utime(const char *f, struct utimbuf *t)
 {
-    return pPerl->PL_piLIO->Utime((char*)f, t, ErrorNo());
+    return pPerl->PL_LIO->Utime((char*)f, t, ErrorNo());
 }
 
 int          _win32_uname(struct utsname *name)
 {
-    return pPerl->PL_piENV->Uname(name, ErrorNo());
+    return pPerl->PL_Env->Uname(name, ErrorNo());
 }
 
 unsigned long _win32_os_id(void)
 {
-    return pPerl->PL_piENV->OsID();
+    return pPerl->PL_Env->OsID();
 }
 
 char*   _win32_getenv(const char *name)
 {
-    return pPerl->PL_piENV->Getenv(name, ErrorNo());
+    return pPerl->PL_Env->Getenv(name, ErrorNo());
 }
 
 int   _win32_putenv(const char *name)
 {
-    return pPerl->PL_piENV->Putenv(name, ErrorNo());
+    return pPerl->PL_Env->Putenv(name, ErrorNo());
 }
 
 int          _win32_open_osfhandle(long handle, int flags)
 {
-    return pPerl->PL_piStdIO->OpenOSfhandle(handle, flags);
+    return pPerl->PL_StdIO->OpenOSfhandle(handle, flags);
 }
 
 long         _win32_get_osfhandle(int fd)
 {
-    return pPerl->PL_piStdIO->GetOSfhandle(fd);
+    return pPerl->PL_StdIO->GetOSfhandle(fd);
 }
 
 u_long _win32_htonl (u_long hostlong)
 {
-    return pPerl->PL_piSock->Htonl(hostlong);
+    return pPerl->PL_Sock->Htonl(hostlong);
 }
 
 u_short _win32_htons (u_short hostshort)
 {
-    return pPerl->PL_piSock->Htons(hostshort);
+    return pPerl->PL_Sock->Htons(hostshort);
 }
 
 u_long _win32_ntohl (u_long netlong)
 {
-    return pPerl->PL_piSock->Ntohl(netlong);
+    return pPerl->PL_Sock->Ntohl(netlong);
 }
 
 u_short _win32_ntohs (u_short netshort)
 {
-    return pPerl->PL_piSock->Ntohs(netshort);
+    return pPerl->PL_Sock->Ntohs(netshort);
 }
 
 unsigned long _win32_inet_addr (const char * cp)
 {
-    return pPerl->PL_piSock->InetAddr(cp, ErrorNo());
+    return pPerl->PL_Sock->InetAddr(cp, ErrorNo());
 }
 
 char * _win32_inet_ntoa (struct in_addr in)
 {
-    return pPerl->PL_piSock->InetNtoa(in, ErrorNo());
+    return pPerl->PL_Sock->InetNtoa(in, ErrorNo());
 }
 
 SOCKET _win32_socket (int af, int type, int protocol)
 {
-    return pPerl->PL_piSock->Socket(af, type, protocol, ErrorNo());
+    return pPerl->PL_Sock->Socket(af, type, protocol, ErrorNo());
 }
 
 int _win32_bind (SOCKET s, const struct sockaddr *addr, int namelen)
 {
-    return pPerl->PL_piSock->Bind(s, addr, namelen, ErrorNo());
+    return pPerl->PL_Sock->Bind(s, addr, namelen, ErrorNo());
 }
 
 int _win32_listen (SOCKET s, int backlog)
 {
-    return pPerl->PL_piSock->Listen(s, backlog, ErrorNo());
+    return pPerl->PL_Sock->Listen(s, backlog, ErrorNo());
 }
 
 SOCKET _win32_accept (SOCKET s, struct sockaddr *addr, int *addrlen)
 {
-    return pPerl->PL_piSock->Accept(s, addr, addrlen, ErrorNo());
+    return pPerl->PL_Sock->Accept(s, addr, addrlen, ErrorNo());
 }
 
 int _win32_connect (SOCKET s, const struct sockaddr *name, int namelen)
 {
-    return pPerl->PL_piSock->Connect(s, name, namelen, ErrorNo());
+    return pPerl->PL_Sock->Connect(s, name, namelen, ErrorNo());
 }
 
 int _win32_send (SOCKET s, const char * buf, int len, int flags)
 {
-    return pPerl->PL_piSock->Send(s, buf, len, flags, ErrorNo());
+    return pPerl->PL_Sock->Send(s, buf, len, flags, ErrorNo());
 }
 
 int _win32_sendto (SOCKET s, const char * buf, int len, int flags,
                        const struct sockaddr *to, int tolen)
 {
-    return pPerl->PL_piSock->Sendto(s, buf, len, flags, to, tolen, ErrorNo());
+    return pPerl->PL_Sock->Sendto(s, buf, len, flags, to, tolen, ErrorNo());
 }
 
 int _win32_recv (SOCKET s, char * buf, int len, int flags)
 {
-    return pPerl->PL_piSock->Recv(s, buf, len, flags, ErrorNo());
+    return pPerl->PL_Sock->Recv(s, buf, len, flags, ErrorNo());
 }
 
 int _win32_recvfrom (SOCKET s, char * buf, int len, int flags,
                          struct sockaddr *from, int * fromlen)
 {
-    return pPerl->PL_piSock->Recvfrom(s, buf, len, flags, from, fromlen, ErrorNo());
+    return pPerl->PL_Sock->Recvfrom(s, buf, len, flags, from, fromlen, ErrorNo());
 }
 
 int _win32_shutdown (SOCKET s, int how)
 {
-    return pPerl->PL_piSock->Shutdown(s, how, ErrorNo());
+    return pPerl->PL_Sock->Shutdown(s, how, ErrorNo());
 }
 
 int _win32_closesocket (SOCKET s)
 {
-    return pPerl->PL_piSock->Closesocket(s, ErrorNo());
+    return pPerl->PL_Sock->Closesocket(s, ErrorNo());
 }
 
 int _win32_ioctlsocket (SOCKET s, long cmd, u_long *argp)
 {
-    return pPerl->PL_piSock->Ioctlsocket(s, cmd, argp, ErrorNo());
+    return pPerl->PL_Sock->Ioctlsocket(s, cmd, argp, ErrorNo());
 }
 
 int _win32_setsockopt (SOCKET s, int level, int optname,
                            const char * optval, int optlen)
 {
-    return pPerl->PL_piSock->Setsockopt(s, level, optname, optval, optlen, ErrorNo());
+    return pPerl->PL_Sock->Setsockopt(s, level, optname, optval, optlen, ErrorNo());
 }
 
 int _win32_getsockopt (SOCKET s, int level, int optname, char * optval, int *optlen)
 {
-    return pPerl->PL_piSock->Getsockopt(s, level, optname, optval, optlen, ErrorNo());
+    return pPerl->PL_Sock->Getsockopt(s, level, optname, optval, optlen, ErrorNo());
 }
 
 int _win32_getpeername (SOCKET s, struct sockaddr *name, int * namelen)
 {
-    return pPerl->PL_piSock->Getpeername(s, name, namelen, ErrorNo());
+    return pPerl->PL_Sock->Getpeername(s, name, namelen, ErrorNo());
 }
 
 int _win32_getsockname (SOCKET s, struct sockaddr *name, int * namelen)
 {
-    return pPerl->PL_piSock->Getsockname(s, name, namelen, ErrorNo());
+    return pPerl->PL_Sock->Getsockname(s, name, namelen, ErrorNo());
 }
 
 int _win32_gethostname (char * name, int namelen)
 {
-    return pPerl->PL_piSock->Gethostname(name, namelen, ErrorNo());
+    return pPerl->PL_Sock->Gethostname(name, namelen, ErrorNo());
 }
 
 struct hostent * _win32_gethostbyname(const char * name)
 {
-    return pPerl->PL_piSock->Gethostbyname(name, ErrorNo());
+    return pPerl->PL_Sock->Gethostbyname(name, ErrorNo());
 }
 
 struct hostent * _win32_gethostbyaddr(const char * addr, int len, int type)
 {
-    return pPerl->PL_piSock->Gethostbyaddr(addr, len, type, ErrorNo());
+    return pPerl->PL_Sock->Gethostbyaddr(addr, len, type, ErrorNo());
 }
 
 struct protoent * _win32_getprotobyname(const char * name)
 {
-    return pPerl->PL_piSock->Getprotobyname(name, ErrorNo());
+    return pPerl->PL_Sock->Getprotobyname(name, ErrorNo());
 }
 
 struct protoent * _win32_getprotobynumber(int proto)
 {
-    return pPerl->PL_pi