From 954c1994944eafa74aaac1bab94e820b6e447da9 Mon Sep 17 00:00:00 2001 From: Gurusamy Sarathy Date: Fri, 28 Jan 2000 03:43:52 +0000 Subject: [PATCH] autogenerate API listing from comments in the source (from Benjamin Stuhl ); fix the markup format to be more flexible for better readability; add missing docs in sv.c; regenerate perltoc p4raw-id: //depot/perl@4915 --- MANIFEST | 2 + XSUB.h | 127 +- av.c | 119 + av.h | 10 + cop.h | 30 + cv.h | 10 + embed.pl | 1231 +++++---- global.sym | 219 -- gv.c | 77 + gv.h | 8 + handy.h | 131 + hv.c | 200 ++ hv.h | 56 + intrpvar.h | 60 + makedef.pl | 2 +- mg.c | 64 + objXSUB.h | 2404 ------------------ op.c | 17 + op.h | 15 + perl.c | 148 ++ perlapi.c | 6988 +++++++++++----------------------------------------- pod/Makefile | 8 + pod/buildtoc | 2 +- pod/perl.pod | 2 + pod/perlapi.pod | 2225 +++++++++++++++++ pod/perldelta.pod | 9 + pod/perlguts.pod | 2174 +--------------- pod/perlintern.pod | 26 + pod/perltoc.pod | 175 +- pod/roffitall | 2 + pp.h | 107 + scope.h | 18 + sv.c | 550 +++++ sv.h | 252 ++ thrdvar.h | 12 + universal.c | 10 + util.c | 57 + 37 files changed, 6619 insertions(+), 10928 deletions(-) create mode 100644 pod/perlapi.pod create mode 100644 pod/perlintern.pod diff --git a/MANIFEST b/MANIFEST index 64b666e..1b3615f 100644 --- a/MANIFEST +++ b/MANIFEST @@ -1047,6 +1047,7 @@ pod/checkpods.PL Tool to check for common errors in pods pod/perl.pod Top level perl man page pod/perl5004delta.pod Changes from 5.003 to 5.004 pod/perl5005delta.pod Changes from 5.004 to 5.005 +pod/perlapi.pod Perl API documentation (autogenerated) pod/perlapio.pod IO API info pod/perlbook.pod Book info pod/perlbot.pod Object-oriented Bag o' Tricks @@ -1076,6 +1077,7 @@ pod/perlfunc.pod Function info pod/perlguts.pod Internals info pod/perlhack.pod Perl hackers guide pod/perlhist.pod Perl history info +pod/perlintern.pod Perl internal function docs (autogenrated) pod/perlipc.pod IPC info pod/perllexwarn.pod Lexical Warnings info pod/perllocale.pod Locale support info diff --git a/XSUB.h b/XSUB.h index 18f5b81..7e1c28c 100644 --- a/XSUB.h +++ b/XSUB.h @@ -1,6 +1,50 @@ #ifndef _INC_PERL_XSUB_H #define _INC_PERL_XSUB_H 1 +/* first, some documentation for xsubpp-generated items */ + +/* +=for apidoc Amn|char*|CLASS +Variable which is setup by C to indicate the +class name for a C++ XS constructor. This is always a C. See C. + +=for apidoc Amn|(whatever)|RETVAL +Variable which is setup by C to hold the return value for an +XSUB. This is always the proper type for the XSUB. See +L. + +=for apidoc Amn|(whatever)|THIS +Variable which is setup by C to designate the object in a C++ +XSUB. This is always the proper type for the C++ object. See C and +L. + +=for apidoc Amn|I32|items +Variable which is setup by C to indicate the number of +items on the stack. See L. + +=for apidoc Amn|I32|ix +Variable which is setup by C to indicate which of an +XSUB's aliases was used to invoke it. See L. + +=for apidoc Am|SV*|ST|int ix +Used to access elements on the XSUB's stack. + +=for apidoc AmU||XS +Macro to declare an XSUB and its C parameter list. This is handled by +C. + +=for apidoc Ams||dXSARGS +Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. This +is usually handled automatically by C. Declares the C +variable to indicate the number of items on the stack. + +=for apidoc Ams||dXSI32 +Sets up the C variable for an XSUB which has aliases. This is usually +handled automatically by C. + +=cut +*/ + #define ST(off) PL_stack_base[ax + (off)] #if defined(CYGWIN) && defined(USE_DYNAMIC_LOADING) @@ -34,14 +78,75 @@ #define XSINTERFACE_FUNC_SET(cv,f) \ CvXSUBANY(cv).any_dptr = (void (*) (pTHXo_ void*))(f) -#define XSRETURN(off) \ - STMT_START { \ - PL_stack_sp = PL_stack_base + ax + ((off) - 1); \ - return; \ - } STMT_END - /* Simple macros to put new mortal values onto the stack. */ /* Typically used to return values from XS functions. */ + +/* +=for apidoc Am|void|XST_mIV|int pos|IV iv +Place an integer into the specified position C on the stack. The +value is stored in a new mortal SV. + +=for apidoc Am|void|XST_mNV|int pos|NV nv +Place a double into the specified position C on the stack. The value +is stored in a new mortal SV. + +=for apidoc Am|void|XST_mPV|int pos|char* str +Place a copy of a string into the specified position C on the stack. +The value is stored in a new mortal SV. + +=for apidoc Am|void|XST_mNO|int pos +Place C<&PL_sv_no> into the specified position C on the +stack. + +=for apidoc Am|void|XST_mYES|int pos +Place C<&PL_sv_yes> into the specified position C on the +stack. + +=for apidoc Am|void|XST_mUNDEF|int pos +Place C<&PL_sv_undef> into the specified position C on the +stack. + +=for apidoc Am|void|XSRETURN|int nitems +Return from XSUB, indicating number of items on the stack. This is usually +handled by C. + +=for apidoc Am|void|XSRETURN_IV|IV iv +Return an integer from an XSUB immediately. Uses C. + +=for apidoc Am|void|XSRETURN_NV|NV nv +Return an double from an XSUB immediately. Uses C. + +=for apidoc Am|void|XSRETURN_PV|char* str +Return a copy of a string from an XSUB immediately. Uses C. + +=for apidoc Ams||XSRETURN_NO +Return C<&PL_sv_no> from an XSUB immediately. Uses C. + +=for apidoc Ams||XSRETURN_YES +Return C<&PL_sv_yes> from an XSUB immediately. Uses C. + +=for apidoc Ams||XSRETURN_UNDEF +Return C<&PL_sv_undef> from an XSUB immediately. Uses C. + +=for apidoc Ams||XSRETURN_EMPTY +Return an empty list from an XSUB immediately. + +=for apidoc AmU||newXSproto +Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to +the subs. + +=for apidoc AmU||XS_VERSION +The version identifier for an XS module. This is usually +handled automatically by C. See C. + +=for apidoc Ams||XS_VERSION_BOOTCHECK +Macro to verify that a PM module's $VERSION variable matches the XS +module's C variable. This is usually handled automatically by +C. See L. + +=cut +*/ + #define XST_mIV(i,v) (ST(i) = sv_2mortal(newSViv(v)) ) #define XST_mNV(i,v) (ST(i) = sv_2mortal(newSVnv(v)) ) #define XST_mPV(i,v) (ST(i) = sv_2mortal(newSVpv(v,0))) @@ -49,11 +154,17 @@ #define XST_mNO(i) (ST(i) = &PL_sv_no ) #define XST_mYES(i) (ST(i) = &PL_sv_yes ) #define XST_mUNDEF(i) (ST(i) = &PL_sv_undef) - + +#define XSRETURN(off) \ + STMT_START { \ + PL_stack_sp = PL_stack_base + ax + ((off) - 1); \ + return; \ + } STMT_END + #define XSRETURN_IV(v) STMT_START { XST_mIV(0,v); XSRETURN(1); } STMT_END #define XSRETURN_NV(v) STMT_START { XST_mNV(0,v); XSRETURN(1); } STMT_END #define XSRETURN_PV(v) STMT_START { XST_mPV(0,v); XSRETURN(1); } STMT_END -#define XSRETURN_PVN(v) STMT_START { XST_mPVN(0,v,n); XSRETURN(1); } STMT_END +#define XSRETURN_PVN(v,n) STMT_START { XST_mPVN(0,v,n); XSRETURN(1); } STMT_END #define XSRETURN_NO STMT_START { XST_mNO(0); XSRETURN(1); } STMT_END #define XSRETURN_YES STMT_START { XST_mYES(0); XSRETURN(1); } STMT_END #define XSRETURN_UNDEF STMT_START { XST_mUNDEF(0); XSRETURN(1); } STMT_END diff --git a/av.c b/av.c index af8296a..264fe23 100644 --- a/av.c +++ b/av.c @@ -46,6 +46,15 @@ Perl_av_reify(pTHX_ AV *av) AvREAL_on(av); } +/* +=for apidoc av_extend + +Pre-extend an array. The C is the index to which the array should be +extended. + +=cut +*/ + void Perl_av_extend(pTHX_ AV *av, I32 key) { @@ -151,6 +160,19 @@ Perl_av_extend(pTHX_ AV *av, I32 key) } } +/* +=for apidoc av_fetch + +Returns the SV at the specified index in the array. The C is the +index. If C is set then the fetch will be part of a store. Check +that the return value is non-null before dereferencing it to a C. + +See L for more information +on how to use this function on tied arrays. + +=cut +*/ + SV** Perl_av_fetch(pTHX_ register AV *av, I32 key, I32 lval) { @@ -198,6 +220,23 @@ Perl_av_fetch(pTHX_ register AV *av, I32 key, I32 lval) return &AvARRAY(av)[key]; } +/* +=for apidoc av_store + +Stores an SV in an array. The array index is specified as C. The +return value will be NULL if the operation failed or if the value did not +need to be actually stored within the array (as in the case of tied +arrays). Otherwise it can be dereferenced to get the original C. Note +that the caller is responsible for suitably incrementing the reference +count of C before the call, and decrementing it if the function +returned NULL. + +See L for +more information on how to use this function on tied arrays. + +=cut +*/ + SV** Perl_av_store(pTHX_ register AV *av, I32 key, SV *val) { @@ -257,6 +296,14 @@ Perl_av_store(pTHX_ register AV *av, I32 key, SV *val) return &ary[key]; } +/* +=for apidoc newAV + +Creates a new AV. The reference count is set to 1. + +=cut +*/ + AV * Perl_newAV(pTHX) { @@ -271,6 +318,16 @@ Perl_newAV(pTHX) return av; } +/* +=for apidoc av_make + +Creates a new AV and populates it with a list of SVs. The SVs are copied +into the array, so they may be freed after the call to av_make. The new AV +will have a reference count of 1. + +=cut +*/ + AV * Perl_av_make(pTHX_ register I32 size, register SV **strp) { @@ -320,6 +377,15 @@ Perl_av_fake(pTHX_ register I32 size, register SV **strp) return av; } +/* +=for apidoc av_clear + +Clears an array, making it empty. Does not free the memory used by the +array itself. + +=cut +*/ + void Perl_av_clear(pTHX_ register AV *av) { @@ -361,6 +427,14 @@ Perl_av_clear(pTHX_ register AV *av) } +/* +=for apidoc av_undef + +Undefines the array. Frees the memory used by the array itself. + +=cut +*/ + void Perl_av_undef(pTHX_ register AV *av) { @@ -389,6 +463,15 @@ Perl_av_undef(pTHX_ register AV *av) } } +/* +=for apidoc av_push + +Pushes an SV onto the end of the array. The array will grow automatically +to accommodate the addition. + +=cut +*/ + void Perl_av_push(pTHX_ register AV *av, SV *val) { @@ -415,6 +498,15 @@ Perl_av_push(pTHX_ register AV *av, SV *val) av_store(av,AvFILLp(av)+1,val); } +/* +=for apidoc av_pop + +Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array +is empty. + +=cut +*/ + SV * Perl_av_pop(pTHX_ register AV *av) { @@ -448,6 +540,16 @@ Perl_av_pop(pTHX_ register AV *av) return retval; } +/* +=for apidoc av_unshift + +Unshift the given number of C values onto the beginning of the +array. The array will grow automatically to accommodate the addition. You +must then use C to assign values to these new elements. + +=cut +*/ + void Perl_av_unshift(pTHX_ register AV *av, register I32 num) { @@ -501,6 +603,14 @@ Perl_av_unshift(pTHX_ register AV *av, register I32 num) } } +/* +=for apidoc av_shift + +Shifts an SV off the beginning of the array. + +=cut +*/ + SV * Perl_av_shift(pTHX_ register AV *av) { @@ -538,6 +648,15 @@ Perl_av_shift(pTHX_ register AV *av) return retval; } +/* +=for apidoc av_len + +Returns the highest index in the array. Returns -1 if the array is +empty. + +=cut +*/ + I32 Perl_av_len(pTHX_ register AV *av) { diff --git a/av.h b/av.h index 14e8765..b56917f 100644 --- a/av.h +++ b/av.h @@ -45,6 +45,16 @@ struct xpvav { /* XXX this is not used anywhere */ #define AVf_REUSED 4 /* got undeffed--don't turn old memory into SVs now */ +/* +=for apidoc AmU||Nullav +Null AV pointer. + +=for apidoc Am|int|AvFILL|AV* av +Same as C. Deprecated, use C instead. + +=cut +*/ + #define Nullav Null(AV*) #define AvARRAY(av) ((SV**)((XPVAV*) SvANY(av))->xav_array) diff --git a/cop.h b/cop.h index ede2fce..5760a8d 100644 --- a/cop.h +++ b/cop.h @@ -373,6 +373,36 @@ struct context { #define CXINC (cxstack_ix < cxstack_max ? ++cxstack_ix : (cxstack_ix = cxinc())) /* "gimme" values */ + +/* +=for apidoc AmU||G_SCALAR +Used to indicate scalar context. See C, C, and +L. + +=for apidoc AmU||G_ARRAY +Used to indicate array context. See C, C and +L. + +=for apidoc AmU||G_VOID +Used to indicate void context. See C and L. + +=for apidoc AmU||G_DISCARD +Indicates that arguments returned from a callback should be discarded. See +L. + +=for apidoc AmU||G_EVAL + +Used to force a Perl C wrapper around a callback. See +L. + +=for apidoc AmU||G_NOARGS + +Indicates that no arguments are being sent to a callback. See +L. + +=cut +*/ + #define G_SCALAR 0 #define G_ARRAY 1 #define G_VOID 128 /* skip this bit when adding flags below */ diff --git a/cv.h b/cv.h index 06cbb89..8210298 100644 --- a/cv.h +++ b/cv.h @@ -36,6 +36,16 @@ struct xpvcv { cv_flags_t xcv_flags; }; +/* +=for apidoc AmU||Nullcv +Null CV pointer. + +=for apidoc Am|HV*|CvSTASH|CV* cv +Returns the stash of the CV. + +=cut +*/ + #define Nullcv Null(CV*) #define CvSTASH(sv) ((XPVCV*)SvANY(sv))->xcv_stash diff --git a/embed.pl b/embed.pl index 5305dad..932124a 100755 --- a/embed.pl +++ b/embed.pl @@ -1,6 +1,7 @@ #!/usr/bin/perl -w -require 5.003; +require 5.003; # keep this compatible, an old perl is all we may have before + # we build the new one # # See database of global and static function prototypes at the __END__. @@ -147,12 +148,12 @@ sub write_protos { $ret; } -# generates global.sym, and populates %global with global symbols +# generates global.sym (API export list), and populates %global with global symbols sub write_global_sym { my $ret = ""; if (@_ > 1) { my ($flags,$retval,$func,@args) = @_; - unless ($flags =~ /[sx]/) { + if ($flags =~ /A/ && $flags !~ /x/) { # public API, so export $func = "Perl_$func" if $flags =~ /p/; $ret = "$func\n"; } @@ -726,7 +727,7 @@ walk_table { } else { my ($flags,$retval,$func,@args) = @_; - unless ($flags =~ /[js]/) { + if ($flags =~ /A/ && $flags !~ /j/) { # API function needing macros if ($flags =~ /p/) { $ret .= undefine("Perl_$func") . hide("Perl_$func","pPerl->Perl_$func"); $ret .= undefine($func) . hide($func,"Perl_$func"); @@ -739,11 +740,12 @@ walk_table { $ret; } \*OBX; -for $sym (sort keys %ppsym) { - $sym =~ s/^Perl_//; - print OBX undefine("Perl_$sym") . hide("Perl_$sym", "pPerl->Perl_$sym"); - print OBX undefine($sym) . hide($sym, "Perl_$sym"); -} +# NOTE: not part of API +#for $sym (sort keys %ppsym) { +# $sym =~ s/^Perl_//; +# print OBX undefine("Perl_$sym") . hide("Perl_$sym", "pPerl->Perl_$sym"); +# print OBX undefine($sym) . hide($sym, "Perl_$sym"); +#} print OBX <<'EOT'; @@ -943,7 +945,8 @@ my %vfuncs = qw( sub emit_func { my ($addcontext, $rettype,$func,@args) = @_; my @aargs = @args; - for my $a (@aargs) { $a =~ s/^.*\b(\w+)$/$1/ } + my $a; + for $a (@aargs) { $a =~ s/^.*\b(\w+)$/$1/ } my $ctxarg = ''; if (not $addcontext) { $ctxarg = 'pTHXo'; @@ -992,7 +995,8 @@ EOT } # XXXX temporary hack -for my $sym (qw( +my $sym; +for $sym (qw( perl_construct perl_destruct perl_free @@ -1012,7 +1016,7 @@ walk_table { else { my ($flags,$retval,$func,@args) = @_; return $ret if exists $skipapi_funcs{$func}; - unless ($flags =~ /[js]/) { + if ($flags =~ /A/ && $flags !~ /j/) { # in public API, needed for XSUBS $ret .= "\n"; my $addctx = 1 if $flags =~ /n/; if ($flags =~ /p/) { @@ -1028,17 +1032,18 @@ walk_table { $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(0, 'OP *',"Perl_$sym",'OP *o'); - } - else { # pp_foo - print CAPI emit_func(0, 'OP *',"Perl_$sym"); - } -} +# NOTE: not part of the API +#for $sym (sort keys %ppsym) { +# $sym =~ s/^Perl_//; +# print CAPI "\n"; +# print CAPI undefine("Perl_$sym"); +# if ($sym =~ /^ck_/) { +# print CAPI emit_func(0, 'OP *',"Perl_$sym",'OP *o'); +# } +# else { # pp_foo +# print CAPI emit_func(0, 'OP *',"Perl_$sym"); +# } +#} print CAPI <<'EOT'; @@ -1058,6 +1063,201 @@ END_EXTERN_C #endif /* PERL_OBJECT || MULTIPLICITY */ EOT +close(CAPI); + +# autogenerate documentation from comments in source files + +my %apidocs; +my %gutsdocs; +my %docfuncs; + +sub autodoc ($) { # parse a file and extract documentation info + my($fh) = @_; + my($in, $doc); + +FUNC: + while (defined($in = <$fh>)) { + if ($in =~ /^=for\s+apidoc\s+(.*)\n/) { + my $proto = $1; + $proto = "||$proto" unless $proto =~ /\|/; + my($flags, $ret, $name, @args) = split /\|/, $proto; + my $docs = ""; +DOC: + while (defined($doc = <$fh>)) { + last DOC if $doc =~ /^=\w+/; + $docs .= $doc; + } + $docs = "\n$docs" if $docs and $docs !~ /^\n/; + if ($flags =~ /m/) { + if ($flags =~ /A/) { + $apidocs{$name} = [$flags, $docs, $ret, @args]; + } + else { + $gutsdocs{$name} = [$flags, $docs, $ret, @args]; + } + } + else { + $docfuncs{$name} = [$flags, $docs, $ret, @args]; + } + if ($doc =~ /^=for/) { + $in = $doc; + redo FUNC; + } + } + } +} + +sub docout ($$$) { # output the docs for one function + my($fh, $name, $docref) = @_; + my($flags, $docs, $ret, @args) = @$docref; + + $docs .= "NOTE: the perl_ form of this function is deprecated.\n\n" + if $flags =~ /p/; + + print $fh "=item $name\n$docs"; + + if ($flags =~ /U/) { # no usage + # nothing + } elsif ($flags =~ /s/) { # semicolon ("dTHR;") + print $fh "\t\t$name;\n\n"; + } elsif ($flags =~ /n/) { # no args + print $fh "\t$ret\t$name\n\n"; + } else { # full usage + print $fh "\t$ret\t$name"; + print $fh "(" . join(", ", @args) . ")"; + print $fh "\n\n"; + } +} + +my $file; +for $file (glob('*.c'), glob('*.h')) { + open F, "< $file" or die "Cannot open $file for docs: $!\n"; + autodoc(\*F); + close F or die "Error closing $file: $!\n"; +} + +unlink "pod/perlapi.pod"; +open (DOC, ">pod/perlapi.pod") or + die "Can't create pod/perlapi.pod: $!\n"; + +walk_table { # load documented functions into approriate hash + if (@_ > 1) { + my($flags, $retval, $func, @args) = @_; + return "" unless $flags =~ /d/; + $func =~ s/\t//g; $flags =~ s/p//; # clean up fields from embed.pl + $retval =~ s/\t//; + if ($flags =~ /A/) { + my $docref = delete $docfuncs{$func}; + warn "no docs for $func\n" unless $docref and @$docref; + $apidocs{$func} = [$docref->[0] . 'A', $docref->[1], $retval, @args]; + } else { + my $docref = delete $docfuncs{$func}; + $gutsdocs{$func} = [$docref->[0], $docref->[1], $retval, @args]; + } + } + return ""; +} \*DOC; + +for (sort keys %docfuncs) { + warn "Unable to place $_!\n"; +} + +print DOC <<'_EOB_'; +=head1 NAME + +perlapi - autogenerated documentation for the perl public API + +=head1 DESCRIPTION + +This file contains the documentation of the perl public API generated by +embed.pl, specifically a listing of functions, macros, flags, and variables +that may be used by extension writers. The interfaces of any functions that +are not listed here are subject to change without notice. For this reason, +blindly using functions listed in proto.h is to be avoided when writing +extensions. + +Note that all Perl API global variables must be referenced with the C +prefix. Some macros are provided for compatibility with the older, +unadorned names, but this support may be disabled in a future release. + +The listing is alphabetical, case insensitive. + +=over 8 + +_EOB_ + +my $key; +for $key (sort { uc($a) cmp uc($b); } keys %apidocs) { # case insensitive sort + docout(\*DOC, $key, $apidocs{$key}); +} + +print DOC <<'_EOE_'; +=back + +=head1 AUTHORS + +Until May 1997, this document was maintained by Jeff Okamoto +. It is now maintained as part of Perl itself. + +With lots of help and suggestions from Dean Roehrich, Malcolm Beattie, +Andreas Koenig, Paul Hudson, Ilya Zakharevich, Paul Marquess, Neil +Bowers, Matthew Green, Tim Bunce, Spider Boardman, Ulrich Pfeifer, +Stephen McCamant, and Gurusamy Sarathy. + +API Listing originally by Dean Roehrich . + +Updated to be autogenerated from comments in the source by Benjamin Stuhl. + +=head1 SEE ALSO + +perlguts(1), perlxs(1), perlxstut(1), perlintern(1) + +_EOE_ + + +close(DOC); + +open(GUTS, ">pod/perlintern.pod") or + die "Unable to create pod/perlintern.pod: $!\n"; +print GUTS <<'END'; +=head1 NAME + +perlintern - autogenerated documentation of purely B + Perl functions + +=head1 DESCRIPTION + +This file is the autogenerated documentation of functions in the +Perl intrepreter that are documented using Perl's internal documentation +format but are not marked as part of the Perl API. In other words, +B! + +=over 8 + +END + +for $key (sort { uc($a) cmp uc($b); } keys %gutsdocs) { + docout(\*GUTS, $key, $gutsdocs{$key}); +} + +print GUTS <<'END'; +=back + +=head1 AUTHORS + +The autodocumentation system was orignally added to the Perl core by +Benjamin Stuhl. Documentation is by whoever was kind enough to +document their functions. + +=head1 SEE ALSO + +perlguts(1), perlapi(1) + +END + +close GUTS; + + __END__ : Lines are of the form: @@ -1067,8 +1267,10 @@ __END__ : Leading and trailing whitespace will be ignored in each component. : : flags are single letters with following meanings: +: A member of public API +: d function has documentation with its source : s static function, should have an S_ prefix in source -: file +: file : n has no implicit interpreter/thread context argument : p function has a Perl_ prefix : f function takes printf style format string, varargs @@ -1081,33 +1283,30 @@ __END__ : : New global functions should be added at the end for binary compatibility : in some configurations. -: -: TODO: 1) Add a flag to mark the functions that are part of the public API. -: 2) Add a field for documentation, so that L -: may be autogenerated. START_EXTERN_C #if defined(PERL_IMPLICIT_SYS) -jno |PerlInterpreter* |perl_alloc_using \ +Ajno |PerlInterpreter* |perl_alloc_using \ |struct IPerlMem* m|struct IPerlMem* ms \ |struct IPerlMem* mp|struct IPerlEnv* e \ |struct IPerlStdIO* io|struct IPerlLIO* lio \ |struct IPerlDir* d|struct IPerlSock* s \ |struct IPerlProc* p #else -jno |PerlInterpreter* |perl_alloc +Ajnod |PerlInterpreter* |perl_alloc #endif -jno |void |perl_construct |PerlInterpreter* interp -jno |void |perl_destruct |PerlInterpreter* interp -jno |void |perl_free |PerlInterpreter* interp -jno |int |perl_run |PerlInterpreter* interp -jno |int |perl_parse |PerlInterpreter* interp|XSINIT_t xsinit \ +Ajnod |void |perl_construct |PerlInterpreter* interp +Ajnod |void |perl_destruct |PerlInterpreter* interp +Ajnod |void |perl_free |PerlInterpreter* interp +Ajnod |int |perl_run |PerlInterpreter* interp +Ajnod |int |perl_parse |PerlInterpreter* interp|XSINIT_t xsinit \ |int argc|char** argv|char** env #if defined(USE_ITHREADS) -jno |PerlInterpreter*|perl_clone|PerlInterpreter* interp, UV flags +: XXX: perl_clone needs docs +Ajno |PerlInterpreter*|perl_clone|PerlInterpreter* interp, UV flags # if defined(PERL_IMPLICIT_SYS) -jno |PerlInterpreter*|perl_clone_using|PerlInterpreter *interp|UV flags \ +Ajno |PerlInterpreter*|perl_clone_using|PerlInterpreter *interp|UV flags \ |struct IPerlMem* m|struct IPerlMem* ms \ |struct IPerlMem* mp|struct IPerlEnv* e \ |struct IPerlStdIO* io|struct IPerlLIO* lio \ @@ -1117,10 +1316,10 @@ jno |PerlInterpreter*|perl_clone_using|PerlInterpreter *interp|UV flags \ #endif #if defined(MYMALLOC) -jnop |Malloc_t|malloc |MEM_SIZE nbytes -jnop |Malloc_t|calloc |MEM_SIZE elements|MEM_SIZE size -jnop |Malloc_t|realloc |Malloc_t where|MEM_SIZE nbytes -jnop |Free_t |mfree |Malloc_t where +Ajnop |Malloc_t|malloc |MEM_SIZE nbytes +Ajnop |Malloc_t|calloc |MEM_SIZE elements|MEM_SIZE size +Ajnop |Malloc_t|realloc |Malloc_t where|MEM_SIZE nbytes +Ajnop |Free_t |mfree |Malloc_t where jnp |MEM_SIZE|malloced_size |void *p #endif @@ -1145,90 +1344,90 @@ public: START_EXTERN_C #endif # include "pp_proto.h" -p |SV* |amagic_call |SV* left|SV* right|int method|int dir -p |bool |Gv_AMupdate |HV* stash +Ap |SV* |amagic_call |SV* left|SV* right|int method|int dir +Ap |bool |Gv_AMupdate |HV* stash p |OP* |append_elem |I32 optype|OP* head|OP* tail p |OP* |append_list |I32 optype|LISTOP* first|LISTOP* last p |I32 |apply |I32 type|SV** mark|SV** sp -p |SV* |avhv_delete_ent|AV *ar|SV* keysv|I32 flags|U32 hash -p |bool |avhv_exists_ent|AV *ar|SV* keysv|U32 hash -p |SV** |avhv_fetch_ent |AV *ar|SV* keysv|I32 lval|U32 hash -p |HE* |avhv_iternext |AV *ar -p |SV* |avhv_iterval |AV *ar|HE* entry -p |HV* |avhv_keys |AV *ar -p |void |av_clear |AV* ar -p |SV* |av_delete |AV* ar|I32 key|I32 flags -p |bool |av_exists |AV* ar|I32 key -p |void |av_extend |AV* ar|I32 key -p |AV* |av_fake |I32 size|SV** svp -p |SV** |av_fetch |AV* ar|I32 key|I32 lval -p |void |av_fill |AV* ar|I32 fill -p |I32 |av_len |AV* ar -p |AV* |av_make |I32 size|SV** svp -p |SV* |av_pop |AV* ar -p |void |av_push |AV* ar|SV* val -p |void |av_reify |AV* ar -p |SV* |av_shift |AV* ar -p |SV** |av_store |AV* ar|I32 key|SV* val -p |void |av_undef |AV* ar -p |void |av_unshift |AV* ar|I32 num +Ap |SV* |avhv_delete_ent|AV *ar|SV* keysv|I32 flags|U32 hash +Ap |bool |avhv_exists_ent|AV *ar|SV* keysv|U32 hash +Ap |SV** |avhv_fetch_ent |AV *ar|SV* keysv|I32 lval|U32 hash +Ap |HE* |avhv_iternext |AV *ar +Ap |SV* |avhv_iterval |AV *ar|HE* entry +Ap |HV* |avhv_keys |AV *ar +Apd |void |av_clear |AV* ar +Ap |SV* |av_delete |AV* ar|I32 key|I32 flags +Ap |bool |av_exists |AV* ar|I32 key +Apd |void |av_extend |AV* ar|I32 key +Ap |AV* |av_fake |I32 size|SV** svp +Apd |SV** |av_fetch |AV* ar|I32 key|I32 lval +Ap |void |av_fill |AV* ar|I32 fill +Apd |I32 |av_len |AV* ar +Apd |AV* |av_make |I32 size|SV** svp +Apd |SV* |av_pop |AV* ar +Apd |void |av_push |AV* ar|SV* val +Ap |void |av_reify |AV* ar +Apd |SV* |av_shift |AV* ar +Apd |SV** |av_store |AV* ar|I32 key|SV* val +Apd |void |av_undef |AV* ar +Apd |void |av_unshift |AV* ar|I32 num p |OP* |bind_match |I32 type|OP* left|OP* pat p |OP* |block_end |I32 floor|OP* seq -p |I32 |block_gimme +Ap |I32 |block_gimme p |int |block_start |int full p |void |boot_core_UNIVERSAL p |void |call_list |I32 oldscope|AV* av_list p |bool |cando |Mode_t mode|Uid_t effective|Stat_t* statbufp -p |U32 |cast_ulong |NV f -p |I32 |cast_i32 |NV f -p |IV |cast_iv |NV f -p |UV |cast_uv |NV f +Ap |U32 |cast_ulong |NV f +Ap |I32 |cast_i32 |NV f +Ap |IV |cast_iv |NV f +Ap |UV |cast_uv |NV f #if !defined(HAS_TRUNCATE) && !defined(HAS_CHSIZE) && defined(F_FREESP) -p |I32 |my_chsize |int fd|Off_t length +Ap |I32 |my_chsize |int fd|Off_t length #endif #if defined(USE_THREADS) p |MAGIC* |condpair_magic |SV *sv #endif p |OP* |convert |I32 optype|I32 flags|OP* o -fpr |void |croak |const char* pat|... -pr |void |vcroak |const char* pat|va_list* args +Afprd |void |croak |const char* pat|... +Apr |void |vcroak |const char* pat|va_list* args #if defined(PERL_IMPLICIT_CONTEXT) -fnrp |void |croak_nocontext|const char* pat|... -fnp |OP* |die_nocontext |const char* pat|... -fnp |void |deb_nocontext |const char* pat|... -fnp |char* |form_nocontext |const char* pat|... -fnp |SV* |mess_nocontext |const char* pat|... -fnp |void |warn_nocontext |const char* pat|... -fnp |void |warner_nocontext|U32 err|const char* pat|... -fnp |SV* |newSVpvf_nocontext|const char* pat|... -fnp |void |sv_catpvf_nocontext|SV* sv|const char* pat|... -fnp |void |sv_setpvf_nocontext|SV* sv|const char* pat|... -fnp |void |sv_catpvf_mg_nocontext|SV* sv|const char* pat|... -fnp |void |sv_setpvf_mg_nocontext|SV* sv|const char* pat|... -fnp |int |fprintf_nocontext|PerlIO* stream|const char* fmt|... +Afnrp |void |croak_nocontext|const char* pat|... +Afnp |OP* |die_nocontext |const char* pat|... +Afnp |void |deb_nocontext |const char* pat|... +Afnp |char* |form_nocontext |const char* pat|... +Afnp |SV* |mess_nocontext |const char* pat|... +Afnp |void |warn_nocontext |const char* pat|... +Afnp |void |warner_nocontext|U32 err|const char* pat|... +Afnp |SV* |newSVpvf_nocontext|const char* pat|... +Afnp |void |sv_catpvf_nocontext|SV* sv|const char* pat|... +Afnp |void |sv_setpvf_nocontext|SV* sv|const char* pat|... +Afnp |void |sv_catpvf_mg_nocontext|SV* sv|const char* pat|... +Afnp |void |sv_setpvf_mg_nocontext|SV* sv|const char* pat|... +Afnp |int |fprintf_nocontext|PerlIO* stream|const char* fmt|... #endif p |void |cv_ckproto |CV* cv|GV* gv|char* p p |CV* |cv_clone |CV* proto p |SV* |cv_const_sv |CV* cv p |SV* |op_const_sv |OP* o|CV* cv p |void |cv_undef |CV* cv -p |void |cx_dump |PERL_CONTEXT* cs -p |SV* |filter_add |filter_t funcp|SV* datasv -p |void |filter_del |filter_t funcp -p |I32 |filter_read |int idx|SV* buffer|int maxlen -p |char** |get_op_descs -p |char** |get_op_names +Ap |void |cx_dump |PERL_CONTEXT* cs +Ap |SV* |filter_add |filter_t funcp|SV* datasv +Ap |void |filter_del |filter_t funcp +Ap |I32 |filter_read |int idx|SV* buffer|int maxlen +Ap |char** |get_op_descs +Ap |char** |get_op_names p |char* |get_no_modify p |U32* |get_opargs -p |PPADDR_t*|get_ppaddr +Ap |PPADDR_t*|get_ppaddr p |I32 |cxinc -fp |void |deb |const char* pat|... -p |void |vdeb |const char* pat|va_list* args -p |void |debprofdump -p |I32 |debop |OP* o -p |I32 |debstack -p |I32 |debstackptrs -p |char* |delimcpy |char* to|char* toend|char* from \ +Afp |void |deb |const char* pat|... +Ap |void |vdeb |const char* pat|va_list* args +Ap |void |debprofdump +Ap |I32 |debop |OP* o +Ap |I32 |debstack +Ap |I32 |debstackptrs +Ap |char* |delimcpy |char* to|char* toend|char* from \ |char* fromend|int delim|I32* retlen p |void |deprecate |char* s fp |OP* |die |const char* pat|... @@ -1237,7 +1436,7 @@ p |OP* |die_where |char* message|STRLEN msglen p |void |dounwind |I32 cxix p |bool |do_aexec |SV* really|SV** mark|SV** sp p |bool |do_aexec5 |SV* really|SV** mark|SV** sp|int fd|int flag -p |int |do_binmode |PerlIO *fp|int iotype|int flag +Ap |int |do_binmode |PerlIO *fp|int iotype|int flag p |void |do_chop |SV* asv|SV* sv p |bool |do_close |GV* gv|bool not_implicit p |bool |do_eof |GV* gv @@ -1256,9 +1455,9 @@ p |I32 |do_shmio |I32 optype|SV** mark|SV** sp #endif p |void |do_join |SV* sv|SV* del|SV** mark|SV** sp p |OP* |do_kv -p |bool |do_open |GV* gv|char* name|I32 len|int as_raw \ +Ap |bool |do_open |GV* gv|char* name|I32 len|int as_raw \ |int rawmode|int rawperm|PerlIO* supplied_fp -p |bool |do_open9 |GV *gv|char *name|I32 len|int as_raw \ +Ap |bool |do_open9 |GV *gv|char *name|I32 len|int as_raw \ |int rawmode|int rawperm|PerlIO *supplied_fp \ |SV *svs|I32 num p |void |do_pipe |SV* sv|GV* rgv|GV* wgv @@ -1274,20 +1473,20 @@ p |UV |do_vecget |SV* sv|I32 offset|I32 size p |void |do_vecset |SV* sv p |void |do_vop |I32 optype|SV* sv|SV* left|SV* right p |OP* |dofile |OP* term -p |I32 |dowantarray -p |void |dump_all -p |void |dump_eval +Ap |I32 |dowantarray +Ap |void |dump_all +Ap |void |dump_eval #if defined(DUMP_FDS) -p |void |dump_fds |char* s +Ap |void |dump_fds |char* s #endif -p |void |dump_form |GV* gv -p |void |gv_dump |GV* gv -p |void |op_dump |OP* arg -p |void |pmop_dump |PMOP* pm -p |void |dump_packsubs |HV* stash -p |void |dump_sub |GV* gv -p |void |fbm_compile |SV* sv|U32 flags -p |char* |fbm_instr |unsigned char* big|unsigned char* bigend \ +Ap |void |dump_form |GV* gv +Ap |void |gv_dump |GV* gv +Ap |void |op_dump |OP* arg +Ap |void |pmop_dump |PMOP* pm +Ap |void |dump_packsubs |HV* stash +Ap |void |dump_sub |GV* gv +Apd |void |fbm_compile |SV* sv|U32 flags +Apd |char* |fbm_instr |unsigned char* big|unsigned char* bigend \ |SV* littlesv|U32 flags p |char* |find_script |char *scriptname|bool dosearch \ |char **search_ext|I32 flags @@ -1296,116 +1495,116 @@ p |PADOFFSET|find_threadsv|const char *name #endif p |OP* |force_list |OP* arg p |OP* |fold_constants |OP* arg -fp |char* |form |const char* pat|... -p |char* |vform |const char* pat|va_list* args -p |void |free_tmps +Afp |char* |form |const char* pat|... +Ap |char* |vform |const char* pat|va_list* args +Ap |void |free_tmps p |OP* |gen_constant_list|OP* o #if !defined(HAS_GETENV_LEN) p |char* |getenv_len |char* key|unsigned long *len #endif -p |void |gp_free |GV* gv -p |GP* |gp_ref |GP* gp -p |GV* |gv_AVadd |GV* gv -p |GV* |gv_HVadd |GV* gv -p |GV* |gv_IOadd |GV* gv -p |GV* |gv_autoload4 |HV* stash|const char* name|STRLEN len \ +Ap |void |gp_free |GV* gv +Ap |GP* |gp_ref |GP* gp +Ap |GV* |gv_AVadd |GV* gv +Ap |GV* |gv_HVadd |GV* gv +Ap |GV* |gv_IOadd |GV* gv +Ap |GV* |gv_autoload4 |HV* stash|const char* name|STRLEN len \ |I32 method -p |void |gv_check |HV* stash -p |void |gv_efullname |SV* sv|GV* gv -p |void |gv_efullname3 |SV* sv|GV* gv|const char* prefix -p |GV* |gv_fetchfile |const char* name -p |GV* |gv_fetchmeth |HV* stash|const char* name|STRLEN len \ +Ap |void |gv_check |HV* stash +Ap |void |gv_efullname |SV* sv|GV* gv +Ap |void |gv_efullname3 |SV* sv|GV* gv|const char* prefix +Ap |GV* |gv_fetchfile |const char* name +Apd |GV* |gv_fetchmeth |HV* stash|const char* name|STRLEN len \ |I32 level -p |GV* |gv_fetchmethod |HV* stash|const char* name -p |GV* |gv_fetchmethod_autoload|HV* stash|const char* name \ +Apd |GV* |gv_fetchmethod |HV* stash|const char* name +Apd |GV* |gv_fetchmethod_autoload|HV* stash|const char* name \ |I32 autoload -p |GV* |gv_fetchpv |const char* name|I32 add|I32 sv_type -p |void |gv_fullname |SV* sv|GV* gv -p |void |gv_fullname3 |SV* sv|GV* gv|const char* prefix -p |void |gv_init |GV* gv|HV* stash|const char* name \ +Ap |GV* |gv_fetchpv |const char* name|I32 add|I32 sv_type +Ap |void |gv_fullname |SV* sv|GV* gv +Ap |void |gv_fullname3 |SV* sv|GV* gv|const char* prefix +Ap |void |gv_init |GV* gv|HV* stash|const char* name \ |STRLEN len|int multi -p |HV* |gv_stashpv |const char* name|I32 create -p |HV* |gv_stashpvn |const char* name|U32 namelen|I32 create -p |HV* |gv_stashsv |SV* sv|I32 create -p |void |hv_clear |HV* tb -p |void |hv_delayfree_ent|HV* hv|HE* entry -p |SV* |hv_delete |HV* tb|const char* key|U32 klen|I32 flags -p |SV* |hv_delete_ent |HV* tb|SV* key|I32 flags|U32 hash -p |bool |hv_exists |HV* tb|const char* key|U32 klen -p |bool |hv_exists_ent |HV* tb|SV* key|U32 hash -p |SV** |hv_fetch |HV* tb|const char* key|U32 klen|I32 lval -p |HE* |hv_fetch_ent |HV* tb|SV* key|I32 lval|U32 hash -p |void |hv_free_ent |HV* hv|HE* entry -p |I32 |hv_iterinit |HV* tb -p |char* |hv_iterkey |HE* entry|I32* retlen -p |SV* |hv_iterkeysv |HE* entry -p |HE* |hv_iternext |HV* tb -p |SV* |hv_iternextsv |HV* hv|char** key|I32* retlen -p |SV* |hv_iterval |HV* tb|HE* entry -p |void |hv_ksplit |HV* hv|IV newmax -p |void |hv_magic |HV* hv|GV* gv|int how -p |SV** |hv_store |HV* tb|const char* key|U32 klen|SV* val \ +Apd |HV* |gv_stashpv |const char* name|I32 create +Ap |HV* |gv_stashpvn |const char* name|U32 namelen|I32 create +Apd |HV* |gv_stashsv |SV* sv|I32 create +Apd |void |hv_clear |HV* tb +Ap |void |hv_delayfree_ent|HV* hv|HE* entry +Apd |SV* |hv_delete |HV* tb|const char* key|U32 klen|I32 flags +Apd |SV* |hv_delete_ent |HV* tb|SV* key|I32 flags|U32 hash +Apd |bool |hv_exists |HV* tb|const char* key|U32 klen +Apd |bool |hv_exists_ent |HV* tb|SV* key|U32 hash +Apd |SV** |hv_fetch |HV* tb|const char* key|U32 klen|I32 lval +Apd |HE* |hv_fetch_ent |HV* tb|SV* key|I32 lval|U32 hash +Ap |void |hv_free_ent |HV* hv|HE* entry +Apd |I32 |hv_iterinit |HV* tb +Apd |char* |hv_iterkey |HE* entry|I32* retlen +Apd |SV* |hv_iterkeysv |HE* entry +Apd |HE* |hv_iternext |HV* tb +Apd |SV* |hv_iternextsv |HV* hv|char** key|I32* retlen +Apd |SV* |hv_iterval |HV* tb|HE* entry +Ap |void |hv_ksplit |HV* hv|IV newmax +Apd |void |hv_magic |HV* hv|GV* gv|int how +Apd |SV** |hv_store |HV* tb|const char* key|U32 klen|SV* val \ |U32 hash -p |HE* |hv_store_ent |HV* tb|SV* key|SV* val|U32 hash -p |void |hv_undef |HV* tb -p |I32 |ibcmp |const char* a|const char* b|I32 len -p |I32 |ibcmp_locale |const char* a|const char* b|I32 len +Apd |HE* |hv_store_ent |HV* tb|SV* key|SV* val|U32 hash +Apd |void |hv_undef |HV* tb +Ap |I32 |ibcmp |const char* a|const char* b|I32 len +Ap |I32 |ibcmp_locale |const char* a|const char* b|I32 len p |bool |ingroup |Gid_t testgid|Uid_t effective p |void |init_debugger p |void |init_stacks p |U32 |intro_my -p |char* |instr |const char* big|const char* little +Ap |char* |instr |const char* big|const char* little p |bool |io_close |IO* io|bool not_implicit p |OP* |invert |OP* cmd -p |bool |is_uni_alnum |U32 c -p |bool |is_uni_alnumc |U32 c -p |bool |is_uni_idfirst |U32 c -p |bool |is_uni_alpha |U32 c -p |bool |is_uni_ascii |U32 c -p |bool |is_uni_space |U32 c -p |bool |is_uni_cntrl |U32 c -p |bool |is_uni_graph |U32 c -p |bool |is_uni_digit |U32 c -p |bool |is_uni_upper |U32 c -p |bool |is_uni_lower |U32 c -p |bool |is_uni_print |U32 c -p |bool |is_uni_punct |U32 c -p |bool |is_uni_xdigit |U32 c -p |U32 |to_uni_upper |U32 c -p |U32 |to_uni_title |U32 c -p |U32 |to_uni_lower |U32 c -p |bool |is_uni_alnum_lc|U32 c -p |bool |is_uni_alnumc_lc|U32 c -p |bool |is_uni_idfirst_lc|U32 c -p |bool |is_uni_alpha_lc|U32 c -p |bool |is_uni_ascii_lc|U32 c -p |bool |is_uni_space_lc|U32 c -p |bool |is_uni_cntrl_lc|U32 c -p |bool |is_uni_graph_lc|U32 c -p |bool |is_uni_digit_lc|U32 c -p |bool |is_uni_upper_lc|U32 c -p |bool |is_uni_lower_lc|U32 c -p |bool |is_uni_print_lc|U32 c -p |bool |is_uni_punct_lc|U32 c -p |bool |is_uni_xdigit_lc|U32 c -p |U32 |to_uni_upper_lc|U32 c -p |U32 |to_uni_title_lc|U32 c -p |U32 |to_uni_lower_lc|U32 c -p |bool |is_utf8_alnum |U8 *p -p |bool |is_utf8_alnumc |U8 *p -p |bool |is_utf8_idfirst|U8 *p -p |bool |is_utf8_alpha |U8 *p -p |bool |is_utf8_ascii |U8 *p -p |bool |is_utf8_space |U8 *p -p |bool |is_utf8_cntrl |U8 *p -p |bool |is_utf8_digit |U8 *p -p |bool |is_utf8_graph |U8 *p -p |bool |is_utf8_upper |U8 *p -p |bool |is_utf8_lower |U8 *p -p |bool |is_utf8_print |U8 *p -p |bool |is_utf8_punct |U8 *p -p |bool |is_utf8_xdigit |U8 *p -p |bool |is_utf8_mark |U8 *p +Ap |bool |is_uni_alnum |U32 c +Ap |bool |is_uni_alnumc |U32 c +Ap |bool |is_uni_idfirst |U32 c +Ap |bool |is_uni_alpha |U32 c +Ap |bool |is_uni_ascii |U32 c +Ap |bool |is_uni_space |U32 c +Ap |bool |is_uni_cntrl |U32 c +Ap |bool |is_uni_graph |U32 c +Ap |bool |is_uni_digit |U32 c +Ap |bool |is_uni_upper |U32 c +Ap |bool |is_uni_lower |U32 c +Ap |bool |is_uni_print |U32 c +Ap |bool |is_uni_punct |U32 c +Ap |bool |is_uni_xdigit |U32 c +Ap |U32 |to_uni_upper |U32 c +Ap |U32 |to_uni_title |U32 c +Ap |U32 |to_uni_lower |U32 c +Ap |bool |is_uni_alnum_lc|U32 c +Ap |bool |is_uni_alnumc_lc|U32 c +Ap |bool |is_uni_idfirst_lc|U32 c +Ap |bool |is_uni_alpha_lc|U32 c +Ap |bool |is_uni_ascii_lc|U32 c +Ap |bool |is_uni_space_lc|U32 c +Ap |bool |is_uni_cntrl_lc|U32 c +Ap |bool |is_uni_graph_lc|U32 c +Ap |bool |is_uni_digit_lc|U32 c +Ap |bool |is_uni_upper_lc|U32 c +Ap |bool |is_uni_lower_lc|U32 c +Ap |bool |is_uni_print_lc|U32 c +Ap |bool |is_uni_punct_lc|U32 c +Ap |bool |is_uni_xdigit_lc|U32 c +Ap |U32 |to_uni_upper_lc|U32 c +Ap |U32 |to_uni_title_lc|U32 c +Ap |U32 |to_uni_lower_lc|U32 c +Ap |bool |is_utf8_alnum |U8 *p +Ap |bool |is_utf8_alnumc |U8 *p +Ap |bool |is_utf8_idfirst|U8 *p +Ap |bool |is_utf8_alpha |U8 *p +Ap |bool |is_utf8_ascii |U8 *p +Ap |bool |is_utf8_space |U8 *p +Ap |bool |is_utf8_cntrl |U8 *p +Ap |bool |is_utf8_digit |U8 *p +Ap |bool |is_utf8_graph |U8 *p +Ap |bool |is_utf8_upper |U8 *p +Ap |bool |is_utf8_lower |U8 *p +Ap |bool |is_utf8_print |U8 *p +Ap |bool |is_utf8_punct |U8 *p +Ap |bool |is_utf8_xdigit |U8 *p +Ap |bool |is_utf8_mark |U8 *p p |OP* |jmaybe |OP* arg p |I32 |keyword |char* d|I32 len p |void |leave_scope |I32 base @@ -1415,7 +1614,7 @@ p |OP* |linklist |OP* o p |OP* |list |OP* o p |OP* |listkids |OP* o p |OP* |localize |OP* arg|I32 lexical -p |I32 |looks_like_number|SV* sv +Apd |I32 |looks_like_number|SV* sv p |int |magic_clearenv |SV* sv|MAGIC* mg p |int |magic_clear_all_env|SV* sv|MAGIC* mg p |int |magic_clearpack|SV* sv|MAGIC* mg @@ -1467,109 +1666,109 @@ p |int |magic_set_all_env|SV* sv|MAGIC* mg p |U32 |magic_sizepack |SV* sv|MAGIC* mg p |int |magic_wipepack |SV* sv|MAGIC* mg p |void |magicname |char* sym|char* name|I32 namlen -p |void |markstack_grow +Ap |void |markstack_grow #if defined(USE_LOCALE_COLLATE) p |char* |mem_collxfrm |const char* s|STRLEN len|STRLEN* xlen #endif -fp |SV* |mess |const char* pat|... -p |SV* |vmess |const char* pat|va_list* args +Afp |SV* |mess |const char* pat|... +Ap |SV* |vmess |const char* pat|va_list* args p |void |qerror |SV* err -p |int |mg_clear |SV* sv -p |int |mg_copy |SV* sv|SV* nsv|const char* key|I32 klen -p |MAGIC* |mg_find |SV* sv|int type -p |int |mg_free |SV* sv -p |int |mg_get |SV* sv -p |U32 |mg_length |SV* sv -p |void |mg_magical |SV* sv -p |int |mg_set |SV* sv -p |I32 |mg_size |SV* sv +Apd |int |mg_clear |SV* sv +Apd |int |mg_copy |SV* sv|SV* nsv|const char* key|I32 klen +Apd |MAGIC* |mg_find |SV* sv|int type +Apd |int |mg_free |SV* sv +Apd |int |mg_get |SV* sv +Apd |U32 |mg_length |SV* sv +Apd |void |mg_magical |SV* sv +Apd |int |mg_set |SV* sv +Ap |I32 |mg_size |SV* sv p |OP* |mod |OP* o|I32 type p |char* |moreswitches |char* s p |OP* |my |OP* o -p |NV |my_atof |const char *s +Ap |NV |my_atof |const char *s #if !defined(HAS_BCOPY) || !defined(HAS_SAFE_BCOPY) -np |char* |my_bcopy |const char* from|char* to|I32 len +Anp |char* |my_bcopy |const char* from|char* to|I32 len #endif #if !defined(HAS_BZERO) && !defined(HAS_MEMSET) -np |char* |my_bzero |char* loc|I32 len +Anp |char* |my_bzero |char* loc|I32 len #endif -pr |void |my_exit |U32 status -pr |void |my_failure_exit -p |I32 |my_fflush_all -p |I32 |my_lstat +Apr |void |my_exit |U32 status +Apr |void |my_failure_exit +Ap |I32 |my_fflush_all +Ap |I32 |my_lstat #if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP) -np |I32 |my_memcmp |const char* s1|const char* s2|I32 len +Anp |I32 |my_memcmp |const char* s1|const char* s2|I32 len #endif #if !defined(HAS_MEMSET) -np |void* |my_memset |char* loc|I32 ch|I32 len +Anp |void* |my_memset |char* loc|I32 ch|I32 len #endif #if !defined(PERL_OBJECT) -p |I32 |my_pclose |PerlIO* ptr -p |PerlIO*|my_popen |char* cmd|char* mode +Ap |I32 |my_pclose |PerlIO* ptr +Ap |PerlIO*|my_popen |char* cmd|char* mode #endif -p |void |my_setenv |char* nam|char* val -p |I32 |my_stat +Ap |void |my_setenv |char* nam|char* val +Ap |I32 |my_stat #if defined(MYSWAP) -p |short |my_swap |short s -p |long |my_htonl |long l -p |long |my_ntohl |long l +Ap |short |my_swap |short s +Ap |long |my_htonl |long l +Ap |long |my_ntohl |long l #endif p |void |my_unexec -p |OP* |newANONLIST |OP* o -p |OP* |newANONHASH |OP* o -p |OP* |newANONSUB |I32 floor|OP* proto|OP* block -p |OP* |newASSIGNOP |I32 flags|OP* left|I32 optype|OP* right -p |OP* |newCONDOP |I32 flags|OP* expr|OP* trueop|OP* falseop -p |void |newCONSTSUB |HV* stash|char* name|SV* sv -p |void |newFORM |I32 floor|OP* o|OP* block -p |OP* |newFOROP |I32 flags|char* label|line_t forline \ +Ap |OP* |newANONLIST |OP* o +Ap |OP* |newANONHASH |OP* o +Ap |OP* |newANONSUB |I32 floor|OP* proto|OP* block +Ap |OP* |newASSIGNOP |I32 flags|OP* left|I32 optype|OP* right +Ap |OP* |newCONDOP |I32 flags|OP* expr|OP* trueop|OP* falseop +Apd |void |newCONSTSUB |HV* stash|char* name|SV* sv +Ap |void |newFORM |I32 floor|OP* o|OP* block +Ap |OP* |newFOROP |I32 flags|char* label|line_t forline \ |OP* sclr|OP* expr|OP*block|OP*cont -p |OP* |newLOGOP |I32 optype|I32 flags|OP* left|OP* right -p |OP* |newLOOPEX |I32 type|OP* label -p |OP* |newLOOPOP |I32 flags|I32 debuggable|OP* expr|OP* block -p |OP* |newNULLLIST -p |OP* |newOP |I32 optype|I32 flags -p |void |newPROG |OP* o -p |OP* |newRANGE |I32 flags|OP* left|OP* right -p |OP* |newSLICEOP |I32 flags|OP* subscript|OP* listop -p |OP* |newSTATEOP |I32 flags|char* label|OP* o -p |CV* |newSUB |I32 floor|OP* o|OP* proto|OP* block -p |CV* |newXS |char* name|XSUBADDR_t f|char* filename -p |AV* |newAV -p |OP* |newAVREF |OP* o -p |OP* |newBINOP |I32 type|I32 flags|OP* first|OP* last -p |OP* |newCVREF |I32 flags|OP* o -p |OP* |newGVOP |I32 type|I32 flags|GV* gv -p |GV* |newGVgen |char* pack -p |OP* |newGVREF |I32 type|OP* o -p |OP* |newHVREF |OP* o -p |HV* |newHV -p |HV* |newHVhv |HV* hv -p |IO* |newIO -p |OP* |newLISTOP |I32 type|I32 flags|OP* first|OP* last -p |OP* |newPADOP |I32 type|I32 flags|SV* sv -p |OP* |newPMOP |I32 type|I32 flags -p |OP* |newPVOP |I32 type|I32 flags|char* pv -p |SV* |newRV |SV* pref -p |SV* |newRV_noinc |SV *sv -p |SV* |newSV |STRLEN len -p |OP* |newSVREF |OP* o -p |OP* |newSVOP |I32 type|I32 flags|SV* sv -p |SV* |newSViv |IV i -p |SV* |newSVnv |NV n -p |SV* |newSVpv |const char* s|STRLEN len -p |SV* |newSVpvn |const char* s|STRLEN len -fp |SV* |newSVpvf |const char* pat|... -p |SV* |vnewSVpvf |const char* pat|va_list* args -p |SV* |newSVrv |SV* rv|const char* classname -p |SV* |newSVsv |SV* old -p |OP* |newUNOP |I32 type|I32 flags|OP* first -p |OP* |newWHILEOP |I32 flags|I32 debuggable|LOOP* loop \ +Ap |OP* |newLOGOP |I32 optype|I32 flags|OP* left|OP* right +Ap |OP* |newLOOPEX |I32 type|OP* label +Ap |OP* |newLOOPOP |I32 flags|I32 debuggable|OP* expr|OP* block +Ap |OP* |newNULLLIST +Ap |OP* |newOP |I32 optype|I32 flags +Ap |void |newPROG |OP* o +Ap |OP* |newRANGE |I32 flags|OP* left|OP* right +Ap |OP* |newSLICEOP |I32 flags|OP* subscript|OP* listop +Ap |OP* |newSTATEOP |I32 flags|char* label|OP* o +Ap |CV* |newSUB |I32 floor|OP* o|OP* proto|OP* block +Apd |CV* |newXS |char* name|XSUBADDR_t f|char* filename +Apd |AV* |newAV +Ap |OP* |newAVREF |OP* o +Ap |OP* |newBINOP |I32 type|I32 flags|OP* first|OP* last +Ap |OP* |newCVREF |I32 flags|OP* o +Ap |OP* |newGVOP |I32 type|I32 flags|GV* gv +Ap |GV* |newGVgen |char* pack +Ap |OP* |newGVREF |I32 type|OP* o +Ap |OP* |newHVREF |OP* o +Apd |HV* |newHV +Ap |HV* |newHVhv |HV* hv +Ap |IO* |newIO +Ap |OP* |newLISTOP |I32 type|I32 flags|OP* first|OP* last +Ap |OP* |newPADOP |I32 type|I32 flags|SV* sv +Ap |OP* |newPMOP |I32 type|I32 flags +Ap |OP* |newPVOP |I32 type|I32 flags|char* pv +Ap |SV* |newRV |SV* pref +Apd |SV* |newRV_noinc |SV *sv +Ap |SV* |newSV |STRLEN len +Ap |OP* |newSVREF |OP* o +Ap |OP* |newSVOP |I32 type|I32 flags|SV* sv +Apd |SV* |newSViv |IV i +Apd |SV* |newSVnv |NV n +Apd |SV* |newSVpv |const char* s|STRLEN len +Apd |SV* |newSVpvn |const char* s|STRLEN len +Afpd |SV* |newSVpvf |const char* pat|... +Ap |SV* |vnewSVpvf |const char* pat|va_list* args +Apd |SV* |newSVrv |SV* rv|const char* classname +Apd |SV* |newSVsv |SV* old +Ap |OP* |newUNOP |I32 type|I32 flags|OP* first +Ap |OP* |newWHILEOP |I32 flags|I32 debuggable|LOOP* loop \ |I32 whileline|OP* expr|OP* block|OP* cont p |PERL_SI*|new_stackinfo|I32 stitems|I32 cxitems p |PerlIO*|nextargv |GV* gv -p |char* |ninstr |const char* big|const char* bigend \ +Ap |char* |ninstr |const char* big|const char* bigend \ |const char* little|const char* lend p |OP* |oopsCV |OP* o p |void |op_free |OP* arg @@ -1586,48 +1785,48 @@ p |void |pad_reset p |void |pad_swipe |PADOFFSET po p |void |peep |OP* o #if defined(PERL_OBJECT) -ox |void |Perl_construct -ox |void |Perl_destruct -ox |void |Perl_free -ox |int |Perl_run -ox |int |Perl_parse |XSINIT_t xsinit \ +Aox |void |Perl_construct +Aox |void |Perl_destruct +Aox |void |Perl_free +Aox |int |Perl_run +Aox |int |Perl_parse |XSINIT_t xsinit \ |int argc|char** argv|char** env #endif #if defined(USE_THREADS) -p |struct perl_thread* |new_struct_thread|struct perl_thread *t +Ap |struct perl_thread* |new_struct_thread|struct perl_thread *t #endif -p |void |call_atexit |ATEXIT_t fn|void *ptr -p |I32 |call_argv |const char* sub_name|I32 flags|char** argv -p |I32 |call_method |const char* methname|I32 flags -p |I32 |call_pv |const char* sub_name|I32 flags -p |I32 |call_sv |SV* sv|I32 flags -p |SV* |eval_pv |const char* p|I32 croak_on_error -p |I32 |eval_sv |SV* sv|I32 flags -p |SV* |get_sv |const char* name|I32 create -p |AV* |get_av |const char* name|I32 create -p |HV* |get_hv |const char* name|I32 create -p |CV* |get_cv |const char* name|I32 create +Ap |void |call_atexit |ATEXIT_t fn|void *ptr +Apd |I32 |call_argv |const char* sub_name|I32 flags|char** argv +Apd |I32 |call_method |const char* methname|I32 flags +Apd |I32 |call_pv |const char* sub_name|I32 flags +Apd |I32 |call_sv |SV* sv|I32 flags +Apd |SV* |eval_pv |const char* p|I32 croak_on_error +Apd |I32 |eval_sv |SV* sv|I32 flags +Apd |SV* |get_sv |const char* name|I32 create +Apd |AV* |get_av |const char* name|I32 create +Apd |HV* |get_hv |const char* name|I32 create +Apd |CV* |get_cv |const char* name|I32 create p |int |init_i18nl10n |int printwarn p |int |init_i18nl14n |int printwarn -p |void |new_collate |const char* newcoll -p |void |new_ctype |const char* newctype -p |void |new_numeric |const char* newcoll -p |void |set_numeric_local -p |void |set_numeric_radix -p |void |set_numeric_standard -p |void |require_pv |const char* pv +Ap |void |new_collate |const char* newcoll +Ap |void |new_ctype |const char* newctype +Ap |void |new_numeric |const char* newcoll +Ap |void |set_numeric_local +Ap |void |set_numeric_radix +Ap |void |set_numeric_standard +Apd |void |require_pv |const char* pv p |void |pidgone |Pid_t pid|int status p |void |pmflag |U16* pmfl|int ch p |OP* |pmruntime |OP* pm|OP* expr|OP* repl p |OP* |pmtrans |OP* o|OP* expr|OP* repl p |OP* |pop_return -p |void |pop_scope +Ap |void |pop_scope p |OP* |prepend_elem |I32 optype|OP* head|OP* tail p |void |push_return |OP* o -p |void |push_scope +Ap |void |push_scope p |OP* |ref |OP* o|I32 type p |OP* |refkids |OP* o|I32 type -p |void |regdump |regexp* r +Ap |void |regdump |regexp* r p |I32 |pregexec |regexp* prog|char* stringarg \ |char* strend|char* strbeg|I32 minend \ |SV* screamer|U32 nosave @@ -1643,7 +1842,7 @@ p |I32 |regexec_flags |regexp* prog|char* stringarg \ p |regnode*|regnext |regnode* p p |void |regprop |SV* sv|regnode* o p |void |repeatcpy |char* to|const char* from|I32 len|I32 count -p |char* |rninstr |const char* big|const char* bigend \ +Ap |char* |rninstr |const char* big|const char* bigend \ |const char* little|const char* lend p |Sighandler_t|rsignal |int i|Sighandler_t t p |int |rsignal_restore|int i|Sigsave_t* t @@ -1655,43 +1854,43 @@ p |void |rxres_save |void** rsp|REGEXP* prx #if !defined(HAS_RENAME) p |I32 |same_dirent |char* a|char* b #endif -p |char* |savepv |const char* sv -p |char* |savepvn |const char* sv|I32 len -p |void |savestack_grow -p |void |save_aelem |AV* av|I32 idx|SV **sptr -p |I32 |save_alloc |I32 size|I32 pad -p |void |save_aptr |AV** aptr -p |AV* |save_ary |GV* gv -p |void |save_clearsv |SV** svp -p |void |save_delete |HV* hv|char* key|I32 klen -p |void |save_destructor|DESTRUCTORFUNC_NOCONTEXT_t f|void* p -p |void |save_destructor_x|DESTRUCTORFUNC_t f|void* p -p |void |save_freesv |SV* sv +Apd |char* |savepv |const char* sv +Apd |char* |savepvn |const char* sv|I32 len +Ap |void |savestack_grow +Ap |void |save_aelem |AV* av|I32 idx|SV **sptr +Ap |I32 |save_alloc |I32 size|I32 pad +Ap |void |save_aptr |AV** aptr +Ap |AV* |save_ary |GV* gv +Ap |void |save_clearsv |SV** svp +Ap |void |save_delete |HV* hv|char* key|I32 klen +Ap |void |save_destructor|DESTRUCTORFUNC_NOCONTEXT_t f|void* p +Ap |void |save_destructor_x|DESTRUCTORFUNC_t f|void* p +Ap |void |save_freesv |SV* sv p |void |save_freeop |OP* o -p |void |save_freepv |char* pv -p |void |save_generic_svref|SV** sptr -p |void |save_gp |GV* gv|I32 empty -p |HV* |save_hash |GV* gv -p |void |save_helem |HV* hv|SV *key|SV **sptr -p |void |save_hints -p |void |save_hptr |HV** hptr -p |void |save_I16 |I16* intp -p |void |save_I32 |I32* intp -p |void |save_I8 |I8* bytep -p |void |save_int |int* intp -p |void |save_item |SV* item -p |void |save_iv |IV* iv -p |void |save_list |SV** sarg|I32 maxsarg -p |void |save_long |long* longp -p |void |save_nogv |GV* gv +Ap |void |save_freepv |char* pv +Ap |void |save_generic_svref|SV** sptr +Ap |void |save_gp |GV* gv|I32 empty +Ap |HV* |save_hash |GV* gv +Ap |void |save_helem |HV* hv|SV *key|SV **sptr +Ap |void |save_hints +Ap |void |save_hptr |HV** hptr +Ap |void |save_I16 |I16* intp +Ap |void |save_I32 |I32* intp +Ap |void |save_I8 |I8* bytep +Ap |void |save_int |int* intp +Ap |void |save_item |SV* item +Ap |void |save_iv |IV* iv +Ap |void |save_list |SV** sarg|I32 maxsarg +Ap |void |save_long |long* longp +Ap |void |save_nogv |GV* gv p |void |save_op -p |SV* |save_scalar |GV* gv -p |void |save_pptr |char** pptr -p |void |save_vptr |void* pptr -p |void |save_re_context -p |void |save_sptr |SV** sptr -p |SV* |save_svref |SV** sptr -p |SV** |save_threadsv |PADOFFSET i +Ap |SV* |save_scalar |GV* gv +Ap |void |save_pptr |char** pptr +Ap |void |save_vptr |void* pptr +Ap |void |save_re_context +Ap |void |save_sptr |SV** sptr +Ap |SV* |save_svref |SV** sptr +Ap |SV** |save_threadsv |PADOFFSET i p |OP* |sawparens |OP* o p |OP* |scalar |OP* o p |OP* |scalarkids |OP* o @@ -1711,111 +1910,111 @@ p |void |setdefout |GV* gv p |char* |sharepvn |const char* sv|I32 len|U32 hash p |HEK* |share_hek |const char* sv|I32 len|U32 hash np |Signal_t |sighandler |int sig -p |SV** |stack_grow |SV** sp|SV**p|int n -p |I32 |start_subparse |I32 is_format|U32 flags +Ap |SV** |stack_grow |SV** sp|SV**p|int n +Ap |I32 |start_subparse |I32 is_format|U32 flags p |void |sub_crush_depth|CV* cv -p |bool |sv_2bool |SV* sv -p |CV* |sv_2cv |SV* sv|HV** st|GV** gvp|I32 lref -p |IO* |sv_2io |SV* sv -p |IV |sv_2iv |SV* sv -p |SV* |sv_2mortal |SV* sv -p |NV |sv_2nv |SV* sv -p |char* |sv_2pv |SV* sv|STRLEN* lp -p |char* |sv_2pvutf8 |SV* sv|STRLEN* lp -p |char* |sv_2pvbyte |SV* sv|STRLEN* lp -p |UV |sv_2uv |SV* sv -p |IV |sv_iv |SV* sv -p |UV |sv_uv |SV* sv -p |NV |sv_nv |SV* sv -p |char* |sv_pvn |SV *sv|STRLEN *len -p |char* |sv_pvutf8n |SV *sv|STRLEN *len -p |char* |sv_pvbyten |SV *sv|STRLEN *len -p |I32 |sv_true |SV *sv +Ap |bool |sv_2bool |SV* sv +Ap |CV* |sv_2cv |SV* sv|HV** st|GV** gvp|I32 lref +Ap |IO* |sv_2io |SV* sv +Ap |IV |sv_2iv |SV* sv +Apd |SV* |sv_2mortal |SV* sv +Ap |NV |sv_2nv |SV* sv +Ap |char* |sv_2pv |SV* sv|STRLEN* lp +Ap |char* |sv_2pvutf8 |SV* sv|STRLEN* lp +Ap |char* |sv_2pvbyte |SV* sv|STRLEN* lp +Ap |UV |sv_2uv |SV* sv +Ap |IV |sv_iv |SV* sv +Ap |UV |sv_uv |SV* sv +Ap |NV |sv_nv |SV* sv +Ap |char* |sv_pvn |SV *sv|STRLEN *len +Ap |char* |sv_pvutf8n |SV *sv|STRLEN *len +Ap |char* |sv_pvbyten |SV *sv|STRLEN *len +Ap |I32 |sv_true |SV *sv p |void |sv_add_arena |char* ptr|U32 size|U32 flags -p |int |sv_backoff |SV* sv -p |SV* |sv_bless |SV* sv|HV* stash -fp |void |sv_catpvf |SV* sv|const char* pat|... -p |void |sv_vcatpvf |SV* sv|const char* pat|va_list* args -p |void |sv_catpv |SV* sv|const char* ptr -p |void |sv_catpvn |SV* sv|const char* ptr|STRLEN len -p |void |sv_catsv |SV* dsv|SV* ssv -p |void |sv_chop |SV* sv|char* ptr +Ap |int |sv_backoff |SV* sv +Apd |SV* |sv_bless |SV* sv|HV* stash +Afpd |void |sv_catpvf |SV* sv|const char* pat|... +Ap |void |sv_vcatpvf |SV* sv|const char* pat|va_list* args +Apd |void |sv_catpv |SV* sv|const char* ptr +Apd |void |sv_catpvn |SV* sv|const char* ptr|STRLEN len +Apd |void |sv_catsv |SV* dsv|SV* ssv +Apd |void |sv_chop |SV* sv|char* ptr p |void |sv_clean_all p |void |sv_clean_objs -p |void |sv_clear |SV* sv -p |I32 |sv_cmp |SV* sv1|SV* sv2 -p |I32 |sv_cmp_locale |SV* sv1|SV* sv2 +Ap |void |sv_clear |SV* sv +Apd |I32 |sv_cmp |SV* sv1|SV* sv2 +Ap |I32 |sv_cmp_locale |SV* sv1|SV* sv2 #if defined(USE_LOCALE_COLLATE) -p |char* |sv_collxfrm |SV* sv|STRLEN* nxp +Ap |char* |sv_collxfrm |SV* sv|STRLEN* nxp #endif p |OP* |sv_compile_2op |SV* sv|OP** startp|char* code|AV** avp -p |void |sv_dec |SV* sv -p |void |sv_dump |SV* sv -p |bool |sv_derived_from|SV* sv|const char* name -p |I32 |sv_eq |SV* sv1|SV* sv2 -p |void |sv_free |SV* sv +Apd |void |sv_dec |SV* sv +Ap |void |sv_dump |SV* sv +Apd |bool |sv_derived_from|SV* sv|const char* name +Apd |I32 |sv_eq |SV* sv1|SV* sv2 +Ap |void |sv_free |SV* sv p |void |sv_free_arenas p |char* |sv_gets |SV* sv|PerlIO* fp|I32 append -p |char* |sv_grow |SV* sv|STRLEN newlen -p |void |sv_inc |SV* sv -p |void |sv_insert |SV* bigsv|STRLEN offset|STRLEN len \ +Apd |char* |sv_grow |SV* sv|STRLEN newlen +Apd |void |sv_inc |SV* sv +Apd |void |sv_insert |SV* bigsv|STRLEN offset|STRLEN len \ |char* little|STRLEN littlelen -p |int |sv_isa |SV* sv|const char* name -p |int |sv_isobject |SV* sv -p |STRLEN |sv_len |SV* sv -p |STRLEN |sv_len_utf8 |SV* sv -p |void |sv_magic |SV* sv|SV* obj|int how|const char* name \ +Apd |int |sv_isa |SV* sv|const char* name +Apd |int |sv_isobject |SV* sv +Apd |STRLEN |sv_len |SV* sv +Ap |STRLEN |sv_len_utf8 |SV* sv +Apd |void |sv_magic |SV* sv|SV* obj|int how|const char* name \ |I32 namlen -p |SV* |sv_mortalcopy |SV* oldsv -p |SV* |sv_newmortal -p |SV* |sv_newref |SV* sv -p |char* |sv_peek |SV* sv -p |void |sv_pos_u2b |SV* sv|I32* offsetp|I32* lenp -p |void |sv_pos_b2u |SV* sv|I32* offsetp -p |char* |sv_pvn_force |SV* sv|STRLEN* lp -p |char* |sv_pvutf8n_force|SV* sv|STRLEN* lp -p |char* |sv_pvbyten_force|SV* sv|STRLEN* lp -p |char* |sv_reftype |SV* sv|int ob -p |void |sv_replace |SV* sv|SV* nsv -p |void |sv_report_used -p |void |sv_reset |char* s|HV* stash -fp |void |sv_setpvf |SV* sv|const char* pat|... -p |void |sv_vsetpvf |SV* sv|const char* pat|va_list* args -p |void |sv_setiv |SV* sv|IV num -p |void |sv_setpviv |SV* sv|IV num -p |void |sv_setuv |SV* sv|UV num -p |void |sv_setnv |SV* sv|NV num -p |SV* |sv_setref_iv |SV* rv|const char* classname|IV iv -p |SV* |sv_setref_nv |SV* rv|const char* classname|NV nv -p |SV* |sv_setref_pv |SV* rv|const char* classname|void* pv -p |SV* |sv_setref_pvn |SV* rv|const char* classname|char* pv \ +Apd |SV* |sv_mortalcopy |SV* oldsv +Apd |SV* |sv_newmortal +Ap |SV* |sv_newref |SV* sv +Ap |char* |sv_peek |SV* sv +Ap |void |sv_pos_u2b |SV* sv|I32* offsetp|I32* lenp +Ap |void |sv_pos_b2u |SV* sv|I32* offsetp +Ap |char* |sv_pvn_force |SV* sv|STRLEN* lp +Ap |char* |sv_pvutf8n_force|SV* sv|STRLEN* lp +Ap |char* |sv_pvbyten_force|SV* sv|STRLEN* lp +Ap |char* |sv_reftype |SV* sv|int ob +Ap |void |sv_replace |SV* sv|SV* nsv +Ap |void |sv_report_used +Ap |void |sv_reset |char* s|HV* stash +Afpd |void |sv_setpvf |SV* sv|const char* pat|... +Ap |void |sv_vsetpvf |SV* sv|const char* pat|va_list* args +Apd |void |sv_setiv |SV* sv|IV num +Apd |void |sv_setpviv |SV* sv|IV num +Apd |void |sv_setuv |SV* sv|UV num +Apd |void |sv_setnv |SV* sv|NV num +Apd |SV* |sv_setref_iv |SV* rv|const char* classname|IV iv +Apd |SV* |sv_setref_nv |SV* rv|const char* classname|NV nv +Apd |SV* |sv_setref_pv |SV* rv|const char* classname|void* pv +Apd |SV* |sv_setref_pvn |SV* rv|const char* classname|char* pv \ |STRLEN n -p |void |sv_setpv |SV* sv|const char* ptr -p |void |sv_setpvn |SV* sv|const char* ptr|STRLEN len -p |void |sv_setsv |SV* dsv|SV* ssv -p |void |sv_taint |SV* sv -p |bool |sv_tainted |SV* sv -p |int |sv_unmagic |SV* sv|int type -p |void |sv_unref |SV* sv -p |void |sv_untaint |SV* sv -p |bool |sv_upgrade |SV* sv|U32 mt -p |void |sv_usepvn |SV* sv|char* ptr|STRLEN len -p |void |sv_vcatpvfn |SV* sv|const char* pat|STRLEN patlen \ +Apd |void |sv_setpv |SV* sv|const char* ptr +Apd |void |sv_setpvn |SV* sv|const char* ptr|STRLEN len +Apd |void |sv_setsv |SV* dsv|SV* ssv +Ap |void |sv_taint |SV* sv +Ap |bool |sv_tainted |SV* sv +Ap |int |sv_unmagic |SV* sv|int type +Apd |void |sv_unref |SV* sv +Ap |void |sv_untaint |SV* sv +Apd |bool |sv_upgrade |SV* sv|U32 mt +Apd |void |sv_usepvn |SV* sv|char* ptr|STRLEN len +Apd |void |sv_vcatpvfn |SV* sv|const char* pat|STRLEN patlen \ |va_list* args|SV** svargs|I32 svmax \ |bool *maybe_tainted -p |void |sv_vsetpvfn |SV* sv|const char* pat|STRLEN patlen \ +Apd |void |sv_vsetpvfn |SV* sv|const char* pat|STRLEN patlen \ |va_list* args|SV** svargs|I32 svmax \ |bool *maybe_tainted p |SV* |swash_init |char* pkg|char* name|SV* listsv \ |I32 minbits|I32 none p |UV |swash_fetch |SV *sv|U8 *ptr -p |void |taint_env -p |void |taint_proper |const char* f|const char* s -p |UV |to_utf8_lower |U8 *p -p |UV |to_utf8_upper |U8 *p -p |UV |to_utf8_title |U8 *p +Ap |void |taint_env +Ap |void |taint_proper |const char* f|const char* s +Ap |UV |to_utf8_lower |U8 *p +Ap |UV |to_utf8_upper |U8 *p +Ap |UV |to_utf8_title |U8 *p #if defined(UNLINK_ALL_VERSIONS) -p |I32 |unlnk |char* f +Ap |I32 |unlnk |char* f #endif #if defined(USE_THREADS) p |void |unlock_condpair|void* svv @@ -1823,21 +2022,21 @@ p |void |unlock_condpair|void* svv p |void |unsharepvn |const char* sv|I32 len|U32 hash p |void |unshare_hek |HEK* hek p |void |utilize |int aver|I32 floor|OP* version|OP* id|OP* arg -p |U8* |utf16_to_utf8 |U16* p|U8 *d|I32 bytelen -p |U8* |utf16_to_utf8_reversed|U16* p|U8 *d|I32 bytelen -p |I32 |utf8_distance |U8 *a|U8 *b -p |U8* |utf8_hop |U8 *s|I32 off -p |UV |utf8_to_uv |U8 *s|I32* retlen -p |U8* |uv_to_utf8 |U8 *d|UV uv +Ap |U8* |utf16_to_utf8 |U16* p|U8 *d|I32 bytelen +Ap |U8* |utf16_to_utf8_reversed|U16* p|U8 *d|I32 bytelen +Ap |I32 |utf8_distance |U8 *a|U8 *b +Ap |U8* |utf8_hop |U8 *s|I32 off +Ap |UV |utf8_to_uv |U8 *s|I32* retlen +Ap |U8* |uv_to_utf8 |U8 *d|UV uv p |void |vivify_defelem |SV* sv p |void |vivify_ref |SV* sv|U32 to_what p |I32 |wait4pid |Pid_t pid|int* statusp|int flags p |void |report_closed_fh|GV *gv|IO *io|const char *func|const char *obj p |void |report_uninit -fp |void |warn |const char* pat|... -p |void |vwarn |const char* pat|va_list* args -fp |void |warner |U32 err|const char* pat|... -p |void |vwarner |U32 err|const char* pat|va_list* args +Afpd |void |warn |const char* pat|... +Ap |void |vwarn |const char* pat|va_list* args +Afp |void |warner |U32 err|const char* pat|... +Ap |void |vwarner |U32 err|const char* pat|va_list* args p |void |watch |char** addr p |I32 |whichsig |char* sig p |int |yyerror |char* s @@ -1849,94 +2048,94 @@ p |int |yylex p |int |yyparse p |int |yywarn |char* s #if defined(MYMALLOC) -p |void |dump_mstats |char* s +Ap |void |dump_mstats |char* s #endif -np |Malloc_t|safesysmalloc |MEM_SIZE nbytes -np |Malloc_t|safesyscalloc |MEM_SIZE elements|MEM_SIZE size -np |Malloc_t|safesysrealloc|Malloc_t where|MEM_SIZE nbytes -np |Free_t |safesysfree |Malloc_t where +Anp |Malloc_t|safesysmalloc |MEM_SIZE nbytes +Anp |Malloc_t|safesyscalloc |MEM_SIZE elements|MEM_SIZE size +Anp |Malloc_t|safesysrealloc|Malloc_t where|MEM_SIZE nbytes +Anp |Free_t |safesysfree |Malloc_t where #if defined(LEAKTEST) -np |Malloc_t|safexmalloc |I32 x|MEM_SIZE size -np |Malloc_t|safexcalloc |I32 x|MEM_SIZE elements|MEM_SIZE size -np |Malloc_t|safexrealloc |Malloc_t where|MEM_SIZE size -np |void |safexfree |Malloc_t where +Anp |Malloc_t|safexmalloc |I32 x|MEM_SIZE size +Anp |Malloc_t|safexcalloc |I32 x|MEM_SIZE elements|MEM_SIZE size +Anp |Malloc_t|safexrealloc |Malloc_t where|MEM_SIZE size +Anp |void |safexfree |Malloc_t where #endif #if defined(PERL_GLOBAL_STRUCT) -p |struct perl_vars *|GetVars +Ap |struct perl_vars *|GetVars #endif -p |int |runops_standard -p |int |runops_debug -fp |void |sv_catpvf_mg |SV *sv|const char* pat|... -p |void |sv_vcatpvf_mg |SV* sv|const char* pat|va_list* args -p |void |sv_catpv_mg |SV *sv|const char *ptr -p |void |sv_catpvn_mg |SV *sv|const char *ptr|STRLEN len -p |void |sv_catsv_mg |SV *dstr|SV *sstr -fp |void |sv_setpvf_mg |SV *sv|const char* pat|... -p |void |sv_vsetpvf_mg |SV* sv|const char* pat|va_list* args -p |void |sv_setiv_mg |SV *sv|IV i -p |void |sv_setpviv_mg |SV *sv|IV iv -p |void |sv_setuv_mg |SV *sv|UV u -p |void |sv_setnv_mg |SV *sv|NV num -p |void |sv_setpv_mg |SV *sv|const char *ptr -p |void |sv_setpvn_mg |SV *sv|const char *ptr|STRLEN len -p |void |sv_setsv_mg |SV *dstr|SV *sstr -p |void |sv_usepvn_mg |SV *sv|char *ptr|STRLEN len -p |MGVTBL*|get_vtbl |int vtbl_id +Ap |int |runops_standard +Ap |int |runops_debug +Afpd |void |sv_catpvf_mg |SV *sv|const char* pat|... +Ap |void |sv_vcatpvf_mg |SV* sv|const char* pat|va_list* args +Apd |void |sv_catpv_mg |SV *sv|const char *ptr +Apd |void |sv_catpvn_mg |SV *sv|const char *ptr|STRLEN len +Apd |void |sv_catsv_mg |SV *dstr|SV *sstr +Afpd |void |sv_setpvf_mg |SV *sv|const char* pat|... +Ap |void |sv_vsetpvf_mg |SV* sv|const char* pat|va_list* args +Apd |void |sv_setiv_mg |SV *sv|IV i +Apd |void |sv_setpviv_mg |SV *sv|IV iv +Apd |void |sv_setuv_mg |SV *sv|UV u +Apd |void |sv_setnv_mg |SV *sv|NV num +Apd |void |sv_setpv_mg |SV *sv|const char *ptr +Apd |void |sv_setpvn_mg |SV *sv|const char *ptr|STRLEN len +Apd |void |sv_setsv_mg |SV *dstr|SV *sstr +Apd |void |sv_usepvn_mg |SV *sv|char *ptr|STRLEN len +Ap |MGVTBL*|get_vtbl |int vtbl_id p |char* |pv_display |SV *sv|char *pv|STRLEN cur|STRLEN len \ |STRLEN pvlim -fp |void |dump_indent |I32 level|PerlIO *file|const char* pat|... -p |void |dump_vindent |I32 level|PerlIO *file|const char* pat \ +Afp |void |dump_indent |I32 level|PerlIO *file|const char* pat|... +Ap |void |dump_vindent |I32 level|PerlIO *file|const char* pat \ |va_list *args -p |void |do_gv_dump |I32 level|PerlIO *file|char *name|GV *sv -p |void |do_gvgv_dump |I32 level|PerlIO *file|char *name|GV *sv -p |void |do_hv_dump |I32 level|PerlIO *file|char *name|HV *sv -p |void |do_magic_dump |I32 level|PerlIO *file|MAGIC *mg|I32 nest \ +Ap |void |do_gv_dump |I32 level|PerlIO *file|char *name|GV *sv +Ap |void |do_gvgv_dump |I32 level|PerlIO *file|char *name|GV *sv +Ap |void |do_hv_dump |I32 level|PerlIO *file|char *name|HV *sv +Ap |void |do_magic_dump |I32 level|PerlIO *file|MAGIC *mg|I32 nest \ |I32 maxnest|bool dumpops|STRLEN pvlim -p |void |do_op_dump |I32 level|PerlIO *file|OP *o -p |void |do_pmop_dump |I32 level|PerlIO *file|PMOP *pm -p |void |do_sv_dump |I32 level|PerlIO *file|SV *sv|I32 nest \ +Ap |void |do_op_dump |I32 level|PerlIO *file|OP *o +Ap |void |do_pmop_dump |I32 level|PerlIO *file|PMOP *pm +Ap |void |do_sv_dump |I32 level|PerlIO *file|SV *sv|I32 nest \ |I32 maxnest|bool dumpops|STRLEN pvlim -p |void |magic_dump |MAGIC *mg -p |void* |default_protect|volatile JMPENV *je|int *excpt \ +Ap |void |magic_dump |MAGIC *mg +Ap |void* |default_protect|volatile JMPENV *je|int *excpt \ |protect_body_t body|... -p |void* |vdefault_protect|volatile JMPENV *je|int *excpt \ +Ap |void* |vdefault_protect|volatile JMPENV *je|int *excpt \ |protect_body_t body|va_list *args -p |void |reginitcolors -p |char* |sv_2pv_nolen |SV* sv -p |char* |sv_2pvutf8_nolen|SV* sv -p |char* |sv_2pvbyte_nolen|SV* sv -p |char* |sv_pv |SV *sv -p |char* |sv_pvutf8 |SV *sv -p |char* |sv_pvbyte |SV *sv -p |void |sv_force_normal|SV *sv -p |void |tmps_grow |I32 n -p |SV* |sv_rvweaken |SV *sv +Ap |void |reginitcolors +Ap |char* |sv_2pv_nolen |SV* sv +Ap |char* |sv_2pvutf8_nolen|SV* sv +Ap |char* |sv_2pvbyte_nolen|SV* sv +Ap |char* |sv_pv |SV *sv +Ap |char* |sv_pvutf8 |SV *sv +Ap |char* |sv_pvbyte |SV *sv +Ap |void |sv_force_normal|SV *sv +Ap |void |tmps_grow |I32 n +Ap |SV* |sv_rvweaken |SV *sv p |int |magic_killbackrefs|SV *sv|MAGIC *mg -p |OP* |newANONATTRSUB |I32 floor|OP *proto|OP *attrs|OP *block -p |CV* |newATTRSUB |I32 floor|OP *o|OP *proto|OP *attrs|OP *block -p |void |newMYSUB |I32 floor|OP *o|OP *proto|OP *attrs|OP *block +Ap |OP* |newANONATTRSUB |I32 floor|OP *proto|OP *attrs|OP *block +Ap |CV* |newATTRSUB |I32 floor|OP *o|OP *proto|OP *attrs|OP *block +Ap |void |newMYSUB |I32 floor|OP *o|OP *proto|OP *attrs|OP *block p |OP * |my_attrs |OP *o|OP *attrs p |void |boot_core_xsutils #if defined(USE_ITHREADS) -p |PERL_CONTEXT*|cx_dup |PERL_CONTEXT* cx|I32 ix|I32 max -p |PERL_SI*|si_dup |PERL_SI* si -p |ANY* |ss_dup |PerlInterpreter* proto_perl -p |void* |any_dup |void* v|PerlInterpreter* proto_perl -p |HE* |he_dup |HE* e|bool shared -p |REGEXP*|re_dup |REGEXP* r -p |PerlIO*|fp_dup |PerlIO* fp|char type -p |DIR* |dirp_dup |DIR* dp -p |GP* |gp_dup |GP* gp -p |MAGIC* |mg_dup |MAGIC* mg -p |SV* |sv_dup |SV* sstr +Ap |PERL_CONTEXT*|cx_dup |PERL_CONTEXT* cx|I32 ix|I32 max +Ap |PERL_SI*|si_dup |PERL_SI* si +Ap |ANY* |ss_dup |PerlInterpreter* proto_perl +Ap |void* |any_dup |void* v|PerlInterpreter* proto_perl +Ap |HE* |he_dup |HE* e|bool shared +Ap |REGEXP*|re_dup |REGEXP* r +Ap |PerlIO*|fp_dup |PerlIO* fp|char type +Ap |DIR* |dirp_dup |DIR* dp +Ap |GP* |gp_dup |GP* gp +Ap |MAGIC* |mg_dup |MAGIC* mg +Ap |SV* |sv_dup |SV* sstr #if defined(HAVE_INTERP_INTERN) -p |void |sys_intern_dup |struct interp_intern* src \ +Ap |void |sys_intern_dup |struct interp_intern* src \ |struct interp_intern* dst #endif -p |PTR_TBL_t*|ptr_table_new -p |void* |ptr_table_fetch|PTR_TBL_t *tbl|void *sv -p |void |ptr_table_store|PTR_TBL_t *tbl|void *oldsv|void *newsv -p |void |ptr_table_split|PTR_TBL_t *tbl +Ap |PTR_TBL_t*|ptr_table_new +Ap |void* |ptr_table_fetch|PTR_TBL_t *tbl|void *sv +Ap |void |ptr_table_store|PTR_TBL_t *tbl|void *oldsv|void *newsv +Ap |void |ptr_table_split|PTR_TBL_t *tbl #endif #if defined(PERL_OBJECT) diff --git a/global.sym b/global.sym index 734b663..d3d4cd6 100644 --- a/global.sym +++ b/global.sym @@ -17,12 +17,8 @@ Perl_malloc Perl_calloc Perl_realloc Perl_mfree -Perl_malloced_size Perl_amagic_call Perl_Gv_AMupdate -Perl_append_elem -Perl_append_list -Perl_apply Perl_avhv_delete_ent Perl_avhv_exists_ent Perl_avhv_fetch_ent @@ -45,20 +41,12 @@ Perl_av_shift Perl_av_store Perl_av_undef Perl_av_unshift -Perl_bind_match -Perl_block_end Perl_block_gimme -Perl_block_start -Perl_boot_core_UNIVERSAL -Perl_call_list -Perl_cando Perl_cast_ulong Perl_cast_i32 Perl_cast_iv Perl_cast_uv Perl_my_chsize -Perl_condpair_magic -Perl_convert Perl_croak Perl_vcroak Perl_croak_nocontext @@ -74,21 +62,13 @@ Perl_sv_setpvf_nocontext Perl_sv_catpvf_mg_nocontext Perl_sv_setpvf_mg_nocontext Perl_fprintf_nocontext -Perl_cv_ckproto -Perl_cv_clone -Perl_cv_const_sv -Perl_op_const_sv -Perl_cv_undef Perl_cx_dump Perl_filter_add Perl_filter_del Perl_filter_read Perl_get_op_descs Perl_get_op_names -Perl_get_no_modify -Perl_get_opargs Perl_get_ppaddr -Perl_cxinc Perl_deb Perl_vdeb Perl_debprofdump @@ -96,43 +76,9 @@ Perl_debop Perl_debstack Perl_debstackptrs Perl_delimcpy -Perl_deprecate -Perl_die -Perl_vdie -Perl_die_where -Perl_dounwind -Perl_do_aexec -Perl_do_aexec5 Perl_do_binmode -Perl_do_chop -Perl_do_close -Perl_do_eof -Perl_do_exec -Perl_do_exec3 -Perl_do_execfree -Perl_do_ipcctl -Perl_do_ipcget -Perl_do_msgrcv -Perl_do_msgsnd -Perl_do_semop -Perl_do_shmio -Perl_do_join -Perl_do_kv Perl_do_open Perl_do_open9 -Perl_do_pipe -Perl_do_print -Perl_do_readline -Perl_do_chomp -Perl_do_seek -Perl_do_sprintf -Perl_do_sysseek -Perl_do_tell -Perl_do_trans -Perl_do_vecget -Perl_do_vecset -Perl_do_vop -Perl_dofile Perl_dowantarray Perl_dump_all Perl_dump_eval @@ -145,15 +91,9 @@ Perl_dump_packsubs Perl_dump_sub Perl_fbm_compile Perl_fbm_instr -Perl_find_script -Perl_find_threadsv -Perl_force_list -Perl_fold_constants Perl_form Perl_vform Perl_free_tmps -Perl_gen_constant_list -Perl_getenv_len Perl_gp_free Perl_gp_ref Perl_gv_AVadd @@ -196,13 +136,7 @@ Perl_hv_store_ent Perl_hv_undef Perl_ibcmp Perl_ibcmp_locale -Perl_ingroup -Perl_init_debugger -Perl_init_stacks -Perl_intro_my Perl_instr -Perl_io_close -Perl_invert Perl_is_uni_alnum Perl_is_uni_alnumc Perl_is_uni_idfirst @@ -252,68 +186,10 @@ Perl_is_utf8_print Perl_is_utf8_punct Perl_is_utf8_xdigit Perl_is_utf8_mark -Perl_jmaybe -Perl_keyword -Perl_leave_scope -Perl_lex_end -Perl_lex_start -Perl_linklist -Perl_list -Perl_listkids -Perl_localize Perl_looks_like_number -Perl_magic_clearenv -Perl_magic_clear_all_env -Perl_magic_clearpack -Perl_magic_clearsig -Perl_magic_existspack -Perl_magic_freeregexp -Perl_magic_get -Perl_magic_getarylen -Perl_magic_getdefelem -Perl_magic_getglob -Perl_magic_getnkeys -Perl_magic_getpack -Perl_magic_getpos -Perl_magic_getsig -Perl_magic_getsubstr -Perl_magic_gettaint -Perl_magic_getuvar -Perl_magic_getvec -Perl_magic_len -Perl_magic_mutexfree -Perl_magic_nextpack -Perl_magic_regdata_cnt -Perl_magic_regdatum_get -Perl_magic_set -Perl_magic_setamagic -Perl_magic_setarylen -Perl_magic_setbm -Perl_magic_setdbline -Perl_magic_setcollxfrm -Perl_magic_setdefelem -Perl_magic_setenv -Perl_magic_setfm -Perl_magic_setisa -Perl_magic_setglob -Perl_magic_setmglob -Perl_magic_setnkeys -Perl_magic_setpack -Perl_magic_setpos -Perl_magic_setsig -Perl_magic_setsubstr -Perl_magic_settaint -Perl_magic_setuvar -Perl_magic_setvec -Perl_magic_set_all_env -Perl_magic_sizepack -Perl_magic_wipepack -Perl_magicname Perl_markstack_grow -Perl_mem_collxfrm Perl_mess Perl_vmess -Perl_qerror Perl_mg_clear Perl_mg_copy Perl_mg_find @@ -323,9 +199,6 @@ Perl_mg_length Perl_mg_magical Perl_mg_set Perl_mg_size -Perl_mod -Perl_moreswitches -Perl_my Perl_my_atof Perl_my_bcopy Perl_my_bzero @@ -342,7 +215,6 @@ Perl_my_stat Perl_my_swap Perl_my_htonl Perl_my_ntohl -Perl_my_unexec Perl_newANONLIST Perl_newANONHASH Perl_newANONSUB @@ -392,23 +264,7 @@ Perl_newSVrv Perl_newSVsv Perl_newUNOP Perl_newWHILEOP -Perl_new_stackinfo -Perl_nextargv Perl_ninstr -Perl_oopsCV -Perl_op_free -Perl_package -Perl_pad_alloc -Perl_pad_allocmy -Perl_pad_findmy -Perl_oopsAV -Perl_oopsHV -Perl_pad_leavemy -Perl_pad_sv -Perl_pad_free -Perl_pad_reset -Perl_pad_swipe -Perl_peep Perl_new_struct_thread Perl_call_atexit Perl_call_argv @@ -421,8 +277,6 @@ Perl_get_sv Perl_get_av Perl_get_hv Perl_get_cv -Perl_init_i18nl10n -Perl_init_i18nl14n Perl_new_collate Perl_new_ctype Perl_new_numeric @@ -430,36 +284,10 @@ Perl_set_numeric_local Perl_set_numeric_radix Perl_set_numeric_standard Perl_require_pv -Perl_pidgone -Perl_pmflag -Perl_pmruntime -Perl_pmtrans -Perl_pop_return Perl_pop_scope -Perl_prepend_elem -Perl_push_return Perl_push_scope -Perl_ref -Perl_refkids Perl_regdump -Perl_pregexec -Perl_pregfree -Perl_pregcomp -Perl_re_intuit_start -Perl_re_intuit_string -Perl_regexec_flags -Perl_regnext -Perl_regprop -Perl_repeatcpy Perl_rninstr -Perl_rsignal -Perl_rsignal_restore -Perl_rsignal_save -Perl_rsignal_state -Perl_rxres_free -Perl_rxres_restore -Perl_rxres_save -Perl_same_dirent Perl_savepv Perl_savepvn Perl_savestack_grow @@ -472,7 +300,6 @@ Perl_save_delete Perl_save_destructor Perl_save_destructor_x Perl_save_freesv -Perl_save_freeop Perl_save_freepv Perl_save_generic_svref Perl_save_gp @@ -489,7 +316,6 @@ Perl_save_iv Perl_save_list Perl_save_long Perl_save_nogv -Perl_save_op Perl_save_scalar Perl_save_pptr Perl_save_vptr @@ -497,25 +323,8 @@ Perl_save_re_context Perl_save_sptr Perl_save_svref Perl_save_threadsv -Perl_sawparens -Perl_scalar -Perl_scalarkids -Perl_scalarseq -Perl_scalarvoid -Perl_scan_bin -Perl_scan_hex -Perl_scan_num -Perl_scan_oct -Perl_scope -Perl_screaminstr -Perl_setenv_getix -Perl_setdefout -Perl_sharepvn -Perl_share_hek -Perl_sighandler Perl_stack_grow Perl_start_subparse -Perl_sub_crush_depth Perl_sv_2bool Perl_sv_2cv Perl_sv_2io @@ -533,7 +342,6 @@ Perl_sv_pvn Perl_sv_pvutf8n Perl_sv_pvbyten Perl_sv_true -Perl_sv_add_arena Perl_sv_backoff Perl_sv_bless Perl_sv_catpvf @@ -542,20 +350,15 @@ Perl_sv_catpv Perl_sv_catpvn Perl_sv_catsv Perl_sv_chop -Perl_sv_clean_all -Perl_sv_clean_objs Perl_sv_clear Perl_sv_cmp Perl_sv_cmp_locale Perl_sv_collxfrm -Perl_sv_compile_2op Perl_sv_dec Perl_sv_dump Perl_sv_derived_from Perl_sv_eq Perl_sv_free -Perl_sv_free_arenas -Perl_sv_gets Perl_sv_grow Perl_sv_inc Perl_sv_insert @@ -599,40 +402,22 @@ Perl_sv_upgrade Perl_sv_usepvn Perl_sv_vcatpvfn Perl_sv_vsetpvfn -Perl_swash_init -Perl_swash_fetch Perl_taint_env Perl_taint_proper Perl_to_utf8_lower Perl_to_utf8_upper Perl_to_utf8_title Perl_unlnk -Perl_unlock_condpair -Perl_unsharepvn -Perl_unshare_hek -Perl_utilize Perl_utf16_to_utf8 Perl_utf16_to_utf8_reversed Perl_utf8_distance Perl_utf8_hop Perl_utf8_to_uv Perl_uv_to_utf8 -Perl_vivify_defelem -Perl_vivify_ref -Perl_wait4pid -Perl_report_closed_fh -Perl_report_uninit Perl_warn Perl_vwarn Perl_warner Perl_vwarner -Perl_watch -Perl_whichsig -Perl_yyerror -Perl_yylex -Perl_yylex -Perl_yyparse -Perl_yywarn Perl_dump_mstats Perl_safesysmalloc Perl_safesyscalloc @@ -661,7 +446,6 @@ Perl_sv_setpvn_mg Perl_sv_setsv_mg Perl_sv_usepvn_mg Perl_get_vtbl -Perl_pv_display Perl_dump_indent Perl_dump_vindent Perl_do_gv_dump @@ -684,12 +468,9 @@ Perl_sv_pvbyte Perl_sv_force_normal Perl_tmps_grow Perl_sv_rvweaken -Perl_magic_killbackrefs Perl_newANONATTRSUB Perl_newATTRSUB Perl_newMYSUB -Perl_my_attrs -Perl_boot_core_xsutils Perl_cx_dup Perl_si_dup Perl_ss_dup diff --git a/gv.c b/gv.c index 907620b..854a822 100644 --- a/gv.c +++ b/gv.c @@ -154,6 +154,27 @@ S_gv_init_sv(pTHX_ GV *gv, I32 sv_type) } } +/* +=for apidoc gv_fetchmeth + +Returns the glob with the given C and a defined subroutine or +C. The glob lives in the given C, or in the stashes +accessible via @ISA and @UNIVERSAL. + +The argument C should be either 0 or -1. If C, as a +side-effect creates a glob with the given C in the given C +which in the case of success contains an alias for the subroutine, and sets +up caching info for this glob. Similarly for all the searched stashes. + +This function grants C<"SUPER"> token as a postfix of the stash name. The +GV returned from C may be a method cache entry, which is not +visible to Perl code. So when calling C, you should not use +the GV directly; instead, you should use the method's CV, which can be +obtained from the GV with the C macro. + +=cut +*/ + GV * Perl_gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level) { @@ -275,12 +296,48 @@ Perl_gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level) return 0; } +/* +=for apidoc gv_fetchmethod + +See L. In fact in the presence of autoloading this may be the +glob for "AUTOLOAD". In this case the corresponding variable $AUTOLOAD is +already setup. + +The third parameter of C determines whether +AUTOLOAD lookup is performed if the given method is not present: non-zero +means yes, look for AUTOLOAD; zero means no, don't look for AUTOLOAD. +Calling C is equivalent to calling C +with a non-zero C parameter. + +These functions grant C<"SUPER"> token as a prefix of the method name. Note +that if you want to keep the returned glob for a long time, you need to +check for it being "AUTOLOAD", since at the later time the call may load a +different subroutine due to $AUTOLOAD changing its value. Use the glob +created via a side effect to do this. + +These functions have the same side-effects and as C with +C. C should be writable if contains C<':'> or C<' +''>. The warning against passing the GV returned by C to +C apply equally to these functions. + +=cut +*/ + GV * Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload) { @@ -387,6 +444,17 @@ Perl_gv_autoload4(pTHX_ HV *stash, const char *name, STRLEN len, I32 method) return gv; } +/* +=for apidoc gv_stashpv + +Returns a pointer to the stash for a specified package. If C is +set then the package will be created if it does not already exist. If +C is not set and the package does not exist then NULL is +returned. + +=cut +*/ + HV* Perl_gv_stashpv(pTHX_ const char *name, I32 create) { @@ -422,6 +490,15 @@ Perl_gv_stashpvn(pTHX_ const char *name, U32 namelen, I32 create) return stash; } +/* +=for apidoc gv_stashsv + +Returns a pointer to the stash for a specified package. See +C. + +=cut +*/ + HV* Perl_gv_stashsv(pTHX_ SV *sv, I32 create) { diff --git a/gv.h b/gv.h index f489d2d..680f2c0 100644 --- a/gv.h +++ b/gv.h @@ -34,6 +34,14 @@ struct gp { #define GvSTASH(gv) (GvXPVGV(gv)->xgv_stash) #define GvFLAGS(gv) (GvXPVGV(gv)->xgv_flags) +/* +=for apidoc Am|SV*|GvSV|GV* gv + +Return the SV from the GV. + +=cut +*/ + #define GvSV(gv) (GvGP(gv)->gp_sv) #define GvREFCNT(gv) (GvGP(gv)->gp_refcnt) #define GvIO(gv) ((gv) && SvTYPE((SV*)gv) == SVt_PVGV ? GvIOp(gv) : 0) diff --git a/handy.h b/handy.h index 92d163e..741c716 100644 --- a/handy.h +++ b/handy.h @@ -19,6 +19,17 @@ #endif #define Null(type) ((type)NULL) + +/* +=for apidoc AmU||Nullch +Null character pointer. + +=for apidoc AmU||Nullsv +Null SV pointer. + +=cut +*/ + #define Nullch Null(char*) #define Nullfp Null(PerlIO*) #define Nullsv Null(SV*) @@ -173,6 +184,43 @@ typedef U64TYPE U64; #define Ctl(ch) ((ch) & 037) +/* +=for apidoc Am|bool|strNE|char* s1|char* s2 +Test two strings to see if they are different. Returns true or +false. + +=for apidoc Am|bool|strEQ|char* s1|char* s2 +Test two strings to see if they are equal. Returns true or false. + +=for apidoc Am|bool|strLT|char* s1|char* s2 +Test two strings to see if the first, C, is less than the second, +C. Returns true or false. + +=for apidoc Am|bool|strLE|char* s1|char* s2 +Test two strings to see if the first, C, is less than or equal to the +second, C. Returns true or false. + +=for apidoc Am|bool|strGT|char* s1|char* s2 +Test two strings to see if the first, C, is greater than the second, +C. Returns true or false. + +=for apidoc Am|bool|strGE|char* s1|char* s2 +Test two strings to see if the first, C, is greater than or equal to +the second, C. Returns true or false. + +=for apidoc Am|bool|strnNE|char* s1|char* s2|STRLEN len +Test two strings to see if they are different. The C parameter +indicates the number of bytes to compare. Returns true or false. (A +wrapper for C). + +=for apidoc Am|bool|strnEQ|char* s1|char* s2|STRLEN len +Test two strings to see if they are equal. The C parameter indicates +the number of bytes to compare. Returns true or false. (A wrapper for +C). + +=cut +*/ + #define strNE(s1,s2) (strcmp(s1,s2)) #define strEQ(s1,s2) (!strcmp(s1,s2)) #define strLT(s1,s2) (strcmp(s1,s2) < 0) @@ -209,6 +257,39 @@ typedef U64TYPE U64; # endif #endif +/* +=for apidoc Am|bool|isALNUM|char ch +Returns a boolean indicating whether the C C is an ascii alphanumeric +character or digit. + +=for apidoc Am|bool|isALPHA|char ch +Returns a boolean indicating whether the C C is an ascii alphabetic +character. + +=for apidoc Am|bool|isSPACE|char ch +Returns a boolean indicating whether the C C is whitespace. + +=for apidoc Am|bool|isDIGIT|char ch +Returns a boolean indicating whether the C C is an ascii +digit. + +=for apidoc Am|bool|isUPPER|char ch +Returns a boolean indicating whether the C C is an uppercase +character. + +=for apidoc Am|bool|isLOWER|char ch +Returns a boolean indicating whether the C C is a lowercase +character. + +=for apidoc Am|char|toUPPER|char ch +Converts the specified character to uppercase. + +=for apidoc Am|char|toLOWER|char ch +Converts the specified character to lowercase. + +=cut +*/ + #define isALNUM(c) (isALPHA(c) || isDIGIT(c) || (c) == '_') #define isIDFIRST(c) (isALPHA(c) || (c) == '_') #define isALPHA(c) (isUPPER(c) || isLOWER(c)) @@ -397,6 +478,56 @@ typedef U16 line_t; --Andy Dougherty August 1996 */ +/* +=for apidoc Am|SV*|NEWSV|int id|STRLEN len +Creates a new SV. A non-zero C parameter indicates the number of +bytes of preallocated string space the SV should have. An extra byte for a +tailing NUL is also reserved. (SvPOK is not set for the SV even if string +space is allocated.) The reference count for the new SV is set to 1. +C is an integer id between 0 and 1299 (used to identify leaks). + +=for apidoc Am|void|New|int id|void* ptr|int nitems|type +The XSUB-writer's interface to the C C function. + +=for apidoc Am|void|Newc|int id|void* ptr|int nitems|type|cast +The XSUB-writer's interface to the C C function, with +cast. + +=for apidoc Am|void|Newz|int id|void* ptr|int nitems|type +The XSUB-writer's interface to the C C function. The allocated +memory is zeroed with C. + +=for apidoc Am|void|Renew|void* ptr|int nitems|type +The XSUB-writer's interface to the C C function. + +=for apidoc Am|void|Renewc|void* ptr|int nitems|type|cast +The XSUB-writer's interface to the C C function, with +cast. + +=for apidoc Am|void|Safefree|void* src|void* dest|int nitems|type +The XSUB-writer's interface to the C C function. + +=for apidoc Am|void|Move|void* src|void* dest|int nitems|type +The XSUB-writer's interface to the C C function. The C is the +source, C is the destination, C is the number of items, and C is +the type. Can do overlapping moves. See also C. + +=for apidoc Am|void|Copy|void* src|void* dest|int nitems|type +The XSUB-writer's interface to the C C function. The C is the +source, C is the destination, C is the number of items, and C is +the type. May fail on overlapping copies. See also C. + +=for apidoc Am|void|Zero|void* dest|int nitems|type + +The XSUB-writer's interface to the C C function. The C is the +destination, C is the number of items, and C is the type. + +=for apidoc Am|void|StructCopy|type src|type dest|type +This is an architecture-independant macro to copy one structure to another. + +=cut +*/ + #ifndef lint #define NEWSV(x,len) newSV(len) diff --git a/hv.c b/hv.c index 9b01db7..e48e8b0 100644 --- a/hv.c +++ b/hv.c @@ -105,6 +105,20 @@ Perl_he_dup(pTHX_ HE *e, bool shared) /* (klen == HEf_SVKEY) is special for MAGICAL hv entries, meaning key slot * contains an SV* */ +/* +=for apidoc hv_fetch + +Returns the SV which corresponds to the specified key in the hash. The +C is the length of the key. If C is set then the fetch will be +part of a store. Check that the return value is non-null before +dereferencing it to a C. + +See L for more +information on how to use this function on tied hashes. + +=cut +*/ + SV** Perl_hv_fetch(pTHX_ HV *hv, const char *key, U32 klen, I32 lval) { @@ -184,6 +198,23 @@ Perl_hv_fetch(pTHX_ HV *hv, const char *key, U32 klen, I32 lval) /* returns a HE * structure with the all fields set */ /* note that hent_val will be a mortal sv for MAGICAL hashes */ +/* +=for apidoc hv_fetch_ent + +Returns the hash entry which corresponds to the specified key in the hash. +C must be a valid precomputed hash number for the given C, or 0 +if you want the function to compute it. IF C is set then the fetch +will be part of a store. Make sure the return value is non-null before +accessing it. The return value when C is a tied hash is a pointer to a +static location, so be sure to make a copy of the structure if you need to +store it somewhere. + +See L for more +information on how to use this function on tied hashes. + +=cut +*/ + HE * Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, register U32 hash) { @@ -293,6 +324,24 @@ S_hv_magic_check(pTHX_ HV *hv, bool *needs_copy, bool *needs_store) } } +/* +=for apidoc hv_store + +Stores an SV in a hash. The hash key is specified as C and C is +the length of the key. The C parameter is the precomputed hash +value; if it is zero then Perl will compute it. The return value will be +NULL if the operation failed or if the value did not need to be actually +stored within the hash (as in the case of tied hashes). Otherwise it can +be dereferenced to get the original C. Note that the caller is +responsible for suitably incrementing the reference count of C before +the call, and decrementing it if the function returned NULL. + +See L for more +information on how to use this function on tied hashes. + +=cut +*/ + SV** Perl_hv_store(pTHX_ HV *hv, const char *key, U32 klen, SV *val, register U32 hash) { @@ -363,6 +412,25 @@ Perl_hv_store(pTHX_ HV *hv, const char *key, U32 klen, SV *val, register U32 has return &HeVAL(entry); } +/* +=for apidoc hv_store_ent + +Stores C in a hash. The hash key is specified as C. The C +parameter is the precomputed hash value; if it is zero then Perl will +compute it. The return value is the new hash entry so created. It will be +NULL if the operation failed or if the value did not need to be actually +stored within the hash (as in the case of tied hashes). Otherwise the +contents of the return value can be accessed using the C macros +described here. Note that the caller is responsible for suitably +incrementing the reference count of C before the call, and +decrementing it if the function returned NULL. + +See L for more +information on how to use this function on tied hashes. + +=cut +*/ + HE * Perl_hv_store_ent(pTHX_ HV *hv, SV *keysv, SV *val, register U32 hash) { @@ -445,6 +513,17 @@ Perl_hv_store_ent(pTHX_ HV *hv, SV *keysv, SV *val, register U32 hash) return entry; } +/* +=for apidoc hv_delete + +Deletes a key/value pair in the hash. The value SV is removed from the +hash and returned to the caller. The C is the length of the key. +The C value will normally be zero; if set to G_DISCARD then NULL +will be returned. + +=cut +*/ + SV * Perl_hv_delete(pTHX_ HV *hv, const char *key, U32 klen, I32 flags) { @@ -516,6 +595,17 @@ Perl_hv_delete(pTHX_ HV *hv, const char *key, U32 klen, I32 flags) return Nullsv; } +/* +=for apidoc hv_delete_ent + +Deletes a key/value pair in the hash. The value SV is removed from the +hash and returned to the caller. The C value will normally be zero; +if set to G_DISCARD then NULL will be returned. C can be a valid +precomputed hash value, or 0 to ask for it to be computed. + +=cut +*/ + SV * Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash) { @@ -592,6 +682,15 @@ Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash) return Nullsv; } +/* +=for apidoc hv_exists + +Returns a boolean indicating whether the specified hash key exists. The +C is the length of the key. + +=cut +*/ + bool Perl_hv_exists(pTHX_ HV *hv, const char *key, U32 klen) { @@ -657,6 +756,16 @@ Perl_hv_exists(pTHX_ HV *hv, const char *key, U32 klen) } +/* +=for apidoc hv_exists_ent + +Returns a boolean indicating whether the specified hash key exists. C +can be a valid precomputed hash value, or 0 to ask for it to be +computed. + +=cut +*/ + bool Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash) { @@ -867,6 +976,14 @@ Perl_hv_ksplit(pTHX_ HV *hv, IV newmax) } } +/* +=for apidoc newHV + +Creates a new HV. The reference count is set to 1. + +=cut +*/ + HV * Perl_newHV(pTHX) { @@ -967,6 +1084,14 @@ Perl_hv_delayfree_ent(pTHX_ HV *hv, register HE *entry) del_he(entry); } +/* +=for apidoc hv_clear + +Clears a hash, making it empty. + +=cut +*/ + void Perl_hv_clear(pTHX_ HV *hv) { @@ -1017,6 +1142,14 @@ S_hfreeentries(pTHX_ HV *hv) (void)hv_iterinit(hv); } +/* +=for apidoc hv_undef + +Undefines the hash. + +=cut +*/ + void Perl_hv_undef(pTHX_ HV *hv) { @@ -1039,6 +1172,20 @@ Perl_hv_undef(pTHX_ HV *hv) mg_clear((SV*)hv); } +/* +=for apidoc hv_iterinit + +Prepares a starting point to traverse a hash table. Returns the number of +keys in the hash (i.e. the same as C). The return value is +currently only meaningful for hashes without tie magic. + +NOTE: Before version 5.004_65, C used to return the number of +hash buckets that happen to be in use. If you still need that esoteric +value, you can get it through the macro C. + +=cut +*/ + I32 Perl_hv_iterinit(pTHX_ HV *hv) { @@ -1058,6 +1205,14 @@ Perl_hv_iterinit(pTHX_ HV *hv) return xhv->xhv_keys; /* used to be xhv->xhv_fill before 5.004_65 */ } +/* +=for apidoc hv_iternext + +Returns entries from a hash iterator. See C. + +=cut +*/ + HE * Perl_hv_iternext(pTHX_ HV *hv) { @@ -1129,6 +1284,15 @@ Perl_hv_iternext(pTHX_ HV *hv) return entry; } +/* +=for apidoc hv_iterkey + +Returns the key from the current position of the hash iterator. See +C. + +=cut +*/ + char * Perl_hv_iterkey(pTHX_ register HE *entry, I32 *retlen) { @@ -1145,6 +1309,16 @@ Perl_hv_iterkey(pTHX_ register HE *entry, I32 *retlen) } /* unlike hv_iterval(), this always returns a mortal copy of the key */ +/* +=for apidoc hv_iterkeysv + +Returns the key as an C from the current position of the hash +iterator. The return value will always be a mortal copy of the key. Also +see C. + +=cut +*/ + SV * Perl_hv_iterkeysv(pTHX_ register HE *entry) { @@ -1155,6 +1329,15 @@ Perl_hv_iterkeysv(pTHX_ register HE *entry) HeKLEN(entry))); } +/* +=for apidoc hv_iterval + +Returns the value from the current position of the hash iterator. See +C. + +=cut +*/ + SV * Perl_hv_iterval(pTHX_ HV *hv, register HE *entry) { @@ -1170,6 +1353,15 @@ Perl_hv_iterval(pTHX_ HV *hv, register HE *entry) return HeVAL(entry); } +/* +=for apidoc hv_iternextsv + +Performs an C, C, and C in one +operation. + +=cut +*/ + SV * Perl_hv_iternextsv(pTHX_ HV *hv, char **key, I32 *retlen) { @@ -1180,6 +1372,14 @@ Perl_hv_iternextsv(pTHX_ HV *hv, char **key, I32 *retlen) return hv_iterval(hv, he); } +/* +=for apidoc hv_magic + +Adds magic to a hash. See C. + +=cut +*/ + void Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how) { diff --git a/hv.h b/hv.h index 11a602c..f052258 100644 --- a/hv.h +++ b/hv.h @@ -48,6 +48,62 @@ struct xpvhv { (hash) = hash_PeRlHaSh + (hash_PeRlHaSh>>5); \ } STMT_END +/* +=for apidoc AmU||HEf_SVKEY +This flag, used in the length slot of hash entries and magic structures, +specifies the structure contains a C pointer where a C pointer +is to be expected. (For information only--not to be used). + +=for apidoc AmU||Nullhv +Null HV pointer. + +=for apidoc Am|char*|HvNAME|HV* stash +Returns the package name of a stash. See C, C. + +=for apidoc Am|void*|HeKEY|HE* he +Returns the actual pointer stored in the key slot of the hash entry. The +pointer may be either C or C, depending on the value of +C. Can be assigned to. The C or C macros are +usually preferable for finding the value of a key. + +=for apidoc Am|STRLEN|HeKLEN|HE* he +If this is negative, and amounts to C, it indicates the entry +holds an C key. Otherwise, holds the actual length of the key. Can +be assigned to. The C macro is usually preferable for finding key +lengths. + +=for apidoc Am|SV*|HeVAL|HE* he +Returns the value slot (type C) stored in the hash entry. + +=for apidoc Am|U32|HeHASH|HE* he +Returns the computed hash stored in the hash entry. + +=for apidoc Am|char*|HePV|HE* he|STRLEN len +Returns the key slot of the hash entry as a C value, doing any +necessary dereferencing of possibly C keys. The length of the string +is placed in C (this is a macro, so do I use C<&len>). If you do +not care about what the length of the key is, you may use the global +variable C, though this is rather less efficient than using a local +variable. Remember though, that hash keys in perl are free to contain +embedded nulls, so using C or similar is not a good way to find +the length of hash keys. This is very similar to the C macro +described elsewhere in this document. + +=for apidoc Am|SV*|HeSVKEY|HE* he +Returns the key as an C, or C if the hash entry does not +contain an C key. + +=for apidoc Am|SV*|HeSVKEY_force|HE* he +Returns the key as an C. Will create and return a temporary mortal +C if the hash entry contains only a C key. + +=for apidoc Am|SV*|HeSVKEY_set|HE* he|SV* sv +Sets the key to a given C, taking care to set the appropriate flags to +indicate the presence of an C key, and returns the same +C. + +=cut +*/ /* these hash entry flags ride on hent_klen (for use only in magic/tied HVs) */ #define HEf_SVKEY -2 /* hent_key is a SV* */ diff --git a/intrpvar.h b/intrpvar.h index f110b32..2dde0dc 100644 --- a/intrpvar.h +++ b/intrpvar.h @@ -35,6 +35,15 @@ PERLVAR(Iminus_l, bool) PERLVAR(Iminus_a, bool) PERLVAR(Iminus_F, bool) PERLVAR(Idoswitches, bool) + +/* +=for apidoc Amn|bool|PL_dowarn + +The C variable which corresponds to Perl's $^W warning variable. + +=cut +*/ + PERLVAR(Idowarn, bool) PERLVAR(Idoextract, bool) PERLVAR(Isawampersand, bool) /* must save all match strings */ @@ -80,6 +89,29 @@ PERLVAR(Ierrgv, GV *) /* shortcuts to debugging objects */ PERLVAR(IDBgv, GV *) PERLVAR(IDBline, GV *) + +/* +=for apidoc Amn|GV *|PL_DBsub +When Perl is run in debugging mode, with the B<-d> switch, this GV contains +the SV which holds the name of the sub being debugged. This is the C +variable which corresponds to Perl's $DB::sub variable. See +C. + +=for apidoc Amn|SV *|PL_DBsingle +When Perl is run in debugging mode, with the B<-d> switch, this SV is a +boolean which indicates whether subs are being single-stepped. +Single-stepping is automatically turned on after every step. This is the C +variable which corresponds to Perl's $DB::single variable. See +C. + +=for apidoc Amn|SV *|PL_DBtrace +Trace variable used when Perl is run in debugging mode, with the B<-d> +switch. This is the C variable which corresponds to Perl's $DB::trace +variable. See C. + +=cut +*/ + PERLVAR(IDBsub, GV *) PERLVAR(IDBsingle, SV *) PERLVAR(IDBtrace, SV *) @@ -147,6 +179,19 @@ PERLVAR(Iofmt, char *) /* output format for numbers $# */ PERLVARI(Iexitlist, PerlExitListEntry *, NULL) /* list of exit functions */ PERLVARI(Iexitlistlen, I32, 0) /* length of same */ + +/* +=for apidoc Amn|HV*|PL_modglobal + +C is a general purpose, interpreter global HV for use by +extensions that need to keep information on a per-interpreter basis. +In a pinch, it can also be used as a symbol table for extensions +to share data among each other. It is a good idea to use keys +prefixed by the package name of the extension that owns the data. + +=cut +*/ + PERLVAR(Imodglobal, HV *) /* per-interp module data */ /* these used to be in global before 5.004_68 */ @@ -222,6 +267,21 @@ PERLVARI(Irunops, runops_proc_t, MEMBER_TO_FPTR(RUNOPS_DEFAULT)) PERLVARA(Itokenbuf,256, char) +/* +=for apidoc Amn|SV|PL_sv_undef +This is the C SV. Always refer to this as C<&PL_sv_undef>. + +=for apidoc Amn|SV|PL_sv_no +This is the C SV. See C. Always refer to this as +C<&PL_sv_no>. + +=for apidoc Amn|SV|PL_sv_yes +This is the C SV. See C. Always refer to this as +C<&PL_sv_yes>. + +=cut +*/ + PERLVAR(Isv_undef, SV) PERLVAR(Isv_no, SV) PERLVAR(Isv_yes, SV) diff --git a/makedef.pl b/makedef.pl index 9c2e96a..5846875 100644 --- a/makedef.pl +++ b/makedef.pl @@ -448,7 +448,7 @@ if ($define{'PERL_GLOBAL_STRUCT'}) { # functions from *.sym files -my @syms = ($global_sym, $pp_sym, $globvar_sym); +my @syms = ($global_sym, $globvar_sym); # $pp_sym is not part of the API if ($define{'USE_PERLIO'}) { push @syms, $perlio_sym; diff --git a/mg.c b/mg.c index 4274a20..edabb11 100644 --- a/mg.c +++ b/mg.c @@ -60,6 +60,14 @@ S_save_magic(pTHX_ I32 mgs_ix, SV *sv) SvFLAGS(sv) |= (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT; } +/* +=for apidoc mg_magical + +Turns on the magical status of an SV. See C. + +=cut +*/ + void Perl_mg_magical(pTHX_ SV *sv) { @@ -77,6 +85,14 @@ Perl_mg_magical(pTHX_ SV *sv) } } +/* +=for apidoc mg_get + +Do magic after a value is retrieved from the SV. See C. + +=cut +*/ + int Perl_mg_get(pTHX_ SV *sv) { @@ -112,6 +128,14 @@ Perl_mg_get(pTHX_ SV *sv) return 0; } +/* +=for apidoc mg_set + +Do magic after a value is assigned to the SV. See C. + +=cut +*/ + int Perl_mg_set(pTHX_ SV *sv) { @@ -138,6 +162,14 @@ Perl_mg_set(pTHX_ SV *sv) return 0; } +/* +=for apidoc mg_length + +Report on the SV's length. See C. + +=cut +*/ + U32 Perl_mg_length(pTHX_ SV *sv) { @@ -196,6 +228,14 @@ Perl_mg_size(pTHX_ SV *sv) return 0; } +/* +=for apidoc mg_clear + +Clear something magical that the SV represents. See C. + +=cut +*/ + int Perl_mg_clear(pTHX_ SV *sv) { @@ -217,6 +257,14 @@ Perl_mg_clear(pTHX_ SV *sv) return 0; } +/* +=for apidoc mg_find + +Finds the magic pointer for type matching the SV. See C. + +=cut +*/ + MAGIC* Perl_mg_find(pTHX_ SV *sv, int type) { @@ -228,6 +276,14 @@ Perl_mg_find(pTHX_ SV *sv, int type) return 0; } +/* +=for apidoc mg_copy + +Copies the magic from one SV to another. See C. + +=cut +*/ + int Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen) { @@ -244,6 +300,14 @@ Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen) return count; } +/* +=for apidoc mg_free + +Free any magic storage used by the SV. See C. + +=cut +*/ + int Perl_mg_free(pTHX_ SV *sv) { diff --git a/objXSUB.h b/objXSUB.h index 262ead9..8d31e99 100644 --- a/objXSUB.h +++ b/objXSUB.h @@ -36,18 +36,6 @@ #define Perl_Gv_AMupdate pPerl->Perl_Gv_AMupdate #undef Gv_AMupdate #define Gv_AMupdate Perl_Gv_AMupdate -#undef Perl_append_elem -#define Perl_append_elem pPerl->Perl_append_elem -#undef append_elem -#define append_elem Perl_append_elem -#undef Perl_append_list -#define Perl_append_list pPerl->Perl_append_list -#undef append_list -#define append_list Perl_append_list -#undef Perl_apply -#define Perl_apply pPerl->Perl_apply -#undef apply -#define apply Perl_apply #undef Perl_avhv_delete_ent #define Perl_avhv_delete_ent pPerl->Perl_avhv_delete_ent #undef avhv_delete_ent @@ -136,34 +124,10 @@ #define Perl_av_unshift pPerl->Perl_av_unshift #undef av_unshift #define av_unshift Perl_av_unshift -#undef Perl_bind_match -#define Perl_bind_match pPerl->Perl_bind_match -#undef bind_match -#define bind_match Perl_bind_match -#undef Perl_block_end -#define Perl_block_end pPerl->Perl_block_end -#undef block_end -#define block_end Perl_block_end #undef Perl_block_gimme #define Perl_block_gimme pPerl->Perl_block_gimme #undef block_gimme #define block_gimme Perl_block_gimme -#undef Perl_block_start -#define Perl_block_start pPerl->Perl_block_start -#undef block_start -#define block_start Perl_block_start -#undef Perl_boot_core_UNIVERSAL -#define Perl_boot_core_UNIVERSAL pPerl->Perl_boot_core_UNIVERSAL -#undef boot_core_UNIVERSAL -#define boot_core_UNIVERSAL Perl_boot_core_UNIVERSAL -#undef Perl_call_list -#define Perl_call_list pPerl->Perl_call_list -#undef call_list -#define call_list Perl_call_list -#undef Perl_cando -#define Perl_cando pPerl->Perl_cando -#undef cando -#define cando Perl_cando #undef Perl_cast_ulong #define Perl_cast_ulong pPerl->Perl_cast_ulong #undef cast_ulong @@ -187,15 +151,7 @@ #define my_chsize Perl_my_chsize #endif #if defined(USE_THREADS) -#undef Perl_condpair_magic -#define Perl_condpair_magic pPerl->Perl_condpair_magic -#undef condpair_magic -#define condpair_magic Perl_condpair_magic #endif -#undef Perl_convert -#define Perl_convert pPerl->Perl_convert -#undef convert -#define convert Perl_convert #undef Perl_croak #define Perl_croak pPerl->Perl_croak #undef croak @@ -258,26 +214,6 @@ #undef fprintf_nocontext #define fprintf_nocontext Perl_fprintf_nocontext #endif -#undef Perl_cv_ckproto -#define Perl_cv_ckproto pPerl->Perl_cv_ckproto -#undef cv_ckproto -#define cv_ckproto Perl_cv_ckproto -#undef Perl_cv_clone -#define Perl_cv_clone pPerl->Perl_cv_clone -#undef cv_clone -#define cv_clone Perl_cv_clone -#undef Perl_cv_const_sv -#define Perl_cv_const_sv pPerl->Perl_cv_const_sv -#undef cv_const_sv -#define cv_const_sv Perl_cv_const_sv -#undef Perl_op_const_sv -#define Perl_op_const_sv pPerl->Perl_op_const_sv -#undef op_const_sv -#define op_const_sv Perl_op_const_sv -#undef Perl_cv_undef -#define Perl_cv_undef pPerl->Perl_cv_undef -#undef cv_undef -#define cv_undef Perl_cv_undef #undef Perl_cx_dump #define Perl_cx_dump pPerl->Perl_cx_dump #undef cx_dump @@ -302,22 +238,10 @@ #define Perl_get_op_names pPerl->Perl_get_op_names #undef get_op_names #define get_op_names Perl_get_op_names -#undef Perl_get_no_modify -#define Perl_get_no_modify pPerl->Perl_get_no_modify -#undef get_no_modify -#define get_no_modify Perl_get_no_modify -#undef Perl_get_opargs -#define Perl_get_opargs pPerl->Perl_get_opargs -#undef get_opargs -#define get_opargs Perl_get_opargs #undef Perl_get_ppaddr #define Perl_get_ppaddr pPerl->Perl_get_ppaddr #undef get_ppaddr #define get_ppaddr Perl_get_ppaddr -#undef Perl_cxinc -#define Perl_cxinc pPerl->Perl_cxinc -#undef cxinc -#define cxinc Perl_cxinc #undef Perl_deb #define Perl_deb pPerl->Perl_deb #undef deb @@ -346,98 +270,14 @@ #define Perl_delimcpy pPerl->Perl_delimcpy #undef delimcpy #define delimcpy Perl_delimcpy -#undef Perl_deprecate -#define Perl_deprecate pPerl->Perl_deprecate -#undef deprecate -#define deprecate Perl_deprecate -#undef Perl_die -#define Perl_die pPerl->Perl_die -#undef die -#define die Perl_die -#undef Perl_vdie -#define Perl_vdie pPerl->Perl_vdie -#undef vdie -#define vdie Perl_vdie -#undef Perl_die_where -#define Perl_die_where pPerl->Perl_die_where -#undef die_where -#define die_where Perl_die_where -#undef Perl_dounwind -#define Perl_dounwind pPerl->Perl_dounwind -#undef dounwind -#define dounwind Perl_dounwind -#undef Perl_do_aexec -#define Perl_do_aexec pPerl->Perl_do_aexec -#undef do_aexec -#define do_aexec Perl_do_aexec -#undef Perl_do_aexec5 -#define Perl_do_aexec5 pPerl->Perl_do_aexec5 -#undef do_aexec5 -#define do_aexec5 Perl_do_aexec5 #undef Perl_do_binmode #define Perl_do_binmode pPerl->Perl_do_binmode #undef do_binmode #define do_binmode Perl_do_binmode -#undef Perl_do_chop -#define Perl_do_chop pPerl->Perl_do_chop -#undef do_chop -#define do_chop Perl_do_chop -#undef Perl_do_close -#define Perl_do_close pPerl->Perl_do_close -#undef do_close -#define do_close Perl_do_close -#undef Perl_do_eof -#define Perl_do_eof pPerl->Perl_do_eof -#undef do_eof -#define do_eof Perl_do_eof -#undef Perl_do_exec -#define Perl_do_exec pPerl->Perl_do_exec -#undef do_exec -#define do_exec Perl_do_exec #if !defined(WIN32) -#undef Perl_do_exec3 -#define Perl_do_exec3 pPerl->Perl_do_exec3 -#undef do_exec3 -#define do_exec3 Perl_do_exec3 #endif -#undef Perl_do_execfree -#define Perl_do_execfree pPerl->Perl_do_execfree -#undef do_execfree -#define do_execfree Perl_do_execfree #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) -#undef Perl_do_ipcctl -#define Perl_do_ipcctl pPerl->Perl_do_ipcctl -#undef do_ipcctl -#define do_ipcctl Perl_do_ipcctl -#undef Perl_do_ipcget -#define Perl_do_ipcget pPerl->Perl_do_ipcget -#undef do_ipcget -#define do_ipcget Perl_do_ipcget -#undef Perl_do_msgrcv -#define Perl_do_msgrcv pPerl->Perl_do_msgrcv -#undef do_msgrcv -#define do_msgrcv Perl_do_msgrcv -#undef Perl_do_msgsnd -#define Perl_do_msgsnd pPerl->Perl_do_msgsnd -#undef do_msgsnd -#define do_msgsnd Perl_do_msgsnd -#undef Perl_do_semop -#define Perl_do_semop pPerl->Perl_do_semop -#undef do_semop -#define do_semop Perl_do_semop -#undef Perl_do_shmio -#define Perl_do_shmio pPerl->Perl_do_shmio -#undef do_shmio -#define do_shmio Perl_do_shmio #endif -#undef Perl_do_join -#define Perl_do_join pPerl->Perl_do_join -#undef do_join -#define do_join Perl_do_join -#undef Perl_do_kv -#define Perl_do_kv pPerl->Perl_do_kv -#undef do_kv -#define do_kv Perl_do_kv #undef Perl_do_open #define Perl_do_open pPerl->Perl_do_open #undef do_open @@ -446,58 +286,6 @@ #define Perl_do_open9 pPerl->Perl_do_open9 #undef do_open9 #define do_open9 Perl_do_open9 -#undef Perl_do_pipe -#define Perl_do_pipe pPerl->Perl_do_pipe -#undef do_pipe -#define do_pipe Perl_do_pipe -#undef Perl_do_print -#define Perl_do_print pPerl->Perl_do_print -#undef do_print -#define do_print Perl_do_print -#undef Perl_do_readline -#define Perl_do_readline pPerl->Perl_do_readline -#undef do_readline -#define do_readline Perl_do_readline -#undef Perl_do_chomp -#define Perl_do_chomp pPerl->Perl_do_chomp -#undef do_chomp -#define do_chomp Perl_do_chomp -#undef Perl_do_seek -#define Perl_do_seek pPerl->Perl_do_seek -#undef do_seek -#define do_seek Perl_do_seek -#undef Perl_do_sprintf -#define Perl_do_sprintf pPerl->Perl_do_sprintf -#undef do_sprintf -#define do_sprintf Perl_do_sprintf -#undef Perl_do_sysseek -#define Perl_do_sysseek pPerl->Perl_do_sysseek -#undef do_sysseek -#define do_sysseek Perl_do_sysseek -#undef Perl_do_tell -#define Perl_do_tell pPerl->Perl_do_tell -#undef do_tell -#define do_tell Perl_do_tell -#undef Perl_do_trans -#define Perl_do_trans pPerl->Perl_do_trans -#undef do_trans -#define do_trans Perl_do_trans -#undef Perl_do_vecget -#define Perl_do_vecget pPerl->Perl_do_vecget -#undef do_vecget -#define do_vecget Perl_do_vecget -#undef Perl_do_vecset -#define Perl_do_vecset pPerl->Perl_do_vecset -#undef do_vecset -#define do_vecset Perl_do_vecset -#undef Perl_do_vop -#define Perl_do_vop pPerl->Perl_do_vop -#undef do_vop -#define do_vop Perl_do_vop -#undef Perl_dofile -#define Perl_dofile pPerl->Perl_dofile -#undef dofile -#define dofile Perl_dofile #undef Perl_dowantarray #define Perl_dowantarray pPerl->Perl_dowantarray #undef dowantarray @@ -548,24 +336,8 @@ #define Perl_fbm_instr pPerl->Perl_fbm_instr #undef fbm_instr #define fbm_instr Perl_fbm_instr -#undef Perl_find_script -#define Perl_find_script pPerl->Perl_find_script -#undef find_script -#define find_script Perl_find_script #if defined(USE_THREADS) -#undef Perl_find_threadsv -#define Perl_find_threadsv pPerl->Perl_find_threadsv -#undef find_threadsv -#define find_threadsv Perl_find_threadsv #endif -#undef Perl_force_list -#define Perl_force_list pPerl->Perl_force_list -#undef force_list -#define force_list Perl_force_list -#undef Perl_fold_constants -#define Perl_fold_constants pPerl->Perl_fold_constants -#undef fold_constants -#define fold_constants Perl_fold_constants #undef Perl_form #define Perl_form pPerl->Perl_form #undef form @@ -578,15 +350,7 @@ #define Perl_free_tmps pPerl->Perl_free_tmps #undef free_tmps #define free_tmps Perl_free_tmps -#undef Perl_gen_constant_list -#define Perl_gen_constant_list pPerl->Perl_gen_constant_list -#undef gen_constant_list -#define gen_constant_list Perl_gen_constant_list #if !defined(HAS_GETENV_LEN) -#undef Perl_getenv_len -#define Perl_getenv_len pPerl->Perl_getenv_len -#undef getenv_len -#define getenv_len Perl_getenv_len #endif #undef Perl_gp_free #define Perl_gp_free pPerl->Perl_gp_free @@ -756,34 +520,10 @@ #define Perl_ibcmp_locale pPerl->Perl_ibcmp_locale #undef ibcmp_locale #define ibcmp_locale Perl_ibcmp_locale -#undef Perl_ingroup -#define Perl_ingroup pPerl->Perl_ingroup -#undef ingroup -#define ingroup Perl_ingroup -#undef Perl_init_debugger -#define Perl_init_debugger pPerl->Perl_init_debugger -#undef init_debugger -#define init_debugger Perl_init_debugger -#undef Perl_init_stacks -#define Perl_init_stacks pPerl->Perl_init_stacks -#undef init_stacks -#define init_stacks Perl_init_stacks -#undef Perl_intro_my -#define Perl_intro_my pPerl->Perl_intro_my -#undef intro_my -#define intro_my Perl_intro_my #undef Perl_instr #define Perl_instr pPerl->Perl_instr #undef instr #define instr Perl_instr -#undef Perl_io_close -#define Perl_io_close pPerl->Perl_io_close -#undef io_close -#define io_close Perl_io_close -#undef Perl_invert -#define Perl_invert pPerl->Perl_invert -#undef invert -#define invert Perl_invert #undef Perl_is_uni_alnum #define Perl_is_uni_alnum pPerl->Perl_is_uni_alnum #undef is_uni_alnum @@ -980,247 +720,19 @@ #define Perl_is_utf8_mark pPerl->Perl_is_utf8_mark #undef is_utf8_mark #define is_utf8_mark Perl_is_utf8_mark -#undef Perl_jmaybe -#define Perl_jmaybe pPerl->Perl_jmaybe -#undef jmaybe -#define jmaybe Perl_jmaybe -#undef Perl_keyword -#define Perl_keyword pPerl->Perl_keyword -#undef keyword -#define keyword Perl_keyword -#undef Perl_leave_scope -#define Perl_leave_scope pPerl->Perl_leave_scope -#undef leave_scope -#define leave_scope Perl_leave_scope -#undef Perl_lex_end -#define Perl_lex_end pPerl->Perl_lex_end -#undef lex_end -#define lex_end Perl_lex_end -#undef Perl_lex_start -#define Perl_lex_start pPerl->Perl_lex_start -#undef lex_start -#define lex_start Perl_lex_start -#undef Perl_linklist -#define Perl_linklist pPerl->Perl_linklist -#undef linklist -#define linklist Perl_linklist -#undef Perl_list -#define Perl_list pPerl->Perl_list -#undef list -#define list Perl_list -#undef Perl_listkids -#define Perl_listkids pPerl->Perl_listkids -#undef listkids -#define listkids Perl_listkids -#undef Perl_localize -#define Perl_localize pPerl->Perl_localize -#undef localize -#define localize Perl_localize #undef Perl_looks_like_number #define Perl_looks_like_number pPerl->Perl_looks_like_number #undef looks_like_number #define looks_like_number Perl_looks_like_number -#undef Perl_magic_clearenv -#define Perl_magic_clearenv pPerl->Perl_magic_clearenv -#undef magic_clearenv -#define magic_clearenv Perl_magic_clearenv -#undef Perl_magic_clear_all_env -#define Perl_magic_clear_all_env pPerl->Perl_magic_clear_all_env -#undef magic_clear_all_env -#define magic_clear_all_env Perl_magic_clear_all_env -#undef Perl_magic_clearpack -#define Perl_magic_clearpack pPerl->Perl_magic_clearpack -#undef magic_clearpack -#define magic_clearpack Perl_magic_clearpack -#undef Perl_magic_clearsig -#define Perl_magic_clearsig pPerl->Perl_magic_clearsig -#undef magic_clearsig -#define magic_clearsig Perl_magic_clearsig -#undef Perl_magic_existspack -#define Perl_magic_existspack pPerl->Perl_magic_existspack -#undef magic_existspack -#define magic_existspack Perl_magic_existspack -#undef Perl_magic_freeregexp -#define Perl_magic_freeregexp pPerl->Perl_magic_freeregexp -#undef magic_freeregexp -#define magic_freeregexp Perl_magic_freeregexp -#undef Perl_magic_get -#define Perl_magic_get pPerl->Perl_magic_get -#undef magic_get -#define magic_get Perl_magic_get -#undef Perl_magic_getarylen -#define Perl_magic_getarylen pPerl->Perl_magic_getarylen -#undef magic_getarylen -#define magic_getarylen Perl_magic_getarylen -#undef Perl_magic_getdefelem -#define Perl_magic_getdefelem pPerl->Perl_magic_getdefelem -#undef magic_getdefelem -#define magic_getdefelem Perl_magic_getdefelem -#undef Perl_magic_getglob -#define Perl_magic_getglob pPerl->Perl_magic_getglob -#undef magic_getglob -#define magic_getglob Perl_magic_getglob -#undef Perl_magic_getnkeys -#define Perl_magic_getnkeys pPerl->Perl_magic_getnkeys -#undef magic_getnkeys -#define magic_getnkeys Perl_magic_getnkeys -#undef Perl_magic_getpack -#define Perl_magic_getpack pPerl->Perl_magic_getpack -#undef magic_getpack -#define magic_getpack Perl_magic_getpack -#undef Perl_magic_getpos -#define Perl_magic_getpos pPerl->Perl_magic_getpos -#undef magic_getpos -#define magic_getpos Perl_magic_getpos -#undef Perl_magic_getsig -#define Perl_magic_getsig pPerl->Perl_magic_getsig -#undef magic_getsig -#define magic_getsig Perl_magic_getsig -#undef Perl_magic_getsubstr -#define Perl_magic_getsubstr pPerl->Perl_magic_getsubstr -#undef magic_getsubstr -#define magic_getsubstr Perl_magic_getsubstr -#undef Perl_magic_gettaint -#define Perl_magic_gettaint pPerl->Perl_magic_gettaint -#undef magic_gettaint -#define magic_gettaint Perl_magic_gettaint -#undef Perl_magic_getuvar -#define Perl_magic_getuvar pPerl->Perl_magic_getuvar -#undef magic_getuvar -#define magic_getuvar Perl_magic_getuvar -#undef Perl_magic_getvec -#define Perl_magic_getvec pPerl->Perl_magic_getvec -#undef magic_getvec -#define magic_getvec Perl_magic_getvec -#undef Perl_magic_len -#define Perl_magic_len pPerl->Perl_magic_len -#undef magic_len -#define magic_len Perl_magic_len #if defined(USE_THREADS) -#undef Perl_magic_mutexfree -#define Perl_magic_mutexfree pPerl->Perl_magic_mutexfree -#undef magic_mutexfree -#define magic_mutexfree Perl_magic_mutexfree #endif -#undef Perl_magic_nextpack -#define Perl_magic_nextpack pPerl->Perl_magic_nextpack -#undef magic_nextpack -#define magic_nextpack Perl_magic_nextpack -#undef Perl_magic_regdata_cnt -#define Perl_magic_regdata_cnt pPerl->Perl_magic_regdata_cnt -#undef magic_regdata_cnt -#define magic_regdata_cnt Perl_magic_regdata_cnt -#undef Perl_magic_regdatum_get -#define Perl_magic_regdatum_get pPerl->Perl_magic_regdatum_get -#undef magic_regdatum_get -#define magic_regdatum_get Perl_magic_regdatum_get -#undef Perl_magic_set -#define Perl_magic_set pPerl->Perl_magic_set -#undef magic_set -#define magic_set Perl_magic_set -#undef Perl_magic_setamagic -#define Perl_magic_setamagic pPerl->Perl_magic_setamagic -#undef magic_setamagic -#define magic_setamagic Perl_magic_setamagic -#undef Perl_magic_setarylen -#define Perl_magic_setarylen pPerl->Perl_magic_setarylen -#undef magic_setarylen -#define magic_setarylen Perl_magic_setarylen -#undef Perl_magic_setbm -#define Perl_magic_setbm pPerl->Perl_magic_setbm -#undef magic_setbm -#define magic_setbm Perl_magic_setbm -#undef Perl_magic_setdbline -#define Perl_magic_setdbline pPerl->Perl_magic_setdbline -#undef magic_setdbline -#define magic_setdbline Perl_magic_setdbline #if defined(USE_LOCALE_COLLATE) -#undef Perl_magic_setcollxfrm -#define Perl_magic_setcollxfrm pPerl->Perl_magic_setcollxfrm -#undef magic_setcollxfrm -#define magic_setcollxfrm Perl_magic_setcollxfrm #endif -#undef Perl_magic_setdefelem -#define Perl_magic_setdefelem pPerl->Perl_magic_setdefelem -#undef magic_setdefelem -#define magic_setdefelem Perl_magic_setdefelem -#undef Perl_magic_setenv -#define Perl_magic_setenv pPerl->Perl_magic_setenv -#undef magic_setenv -#define magic_setenv Perl_magic_setenv -#undef Perl_magic_setfm -#define Perl_magic_setfm pPerl->Perl_magic_setfm -#undef magic_setfm -#define magic_setfm Perl_magic_setfm -#undef Perl_magic_setisa -#define Perl_magic_setisa pPerl->Perl_magic_setisa -#undef magic_setisa -#define magic_setisa Perl_magic_setisa -#undef Perl_magic_setglob -#define Perl_magic_setglob pPerl->Perl_magic_setglob -#undef magic_setglob -#define magic_setglob Perl_magic_setglob -#undef Perl_magic_setmglob -#define Perl_magic_setmglob pPerl->Perl_magic_setmglob -#undef magic_setmglob -#define magic_setmglob Perl_magic_setmglob -#undef Perl_magic_setnkeys -#define Perl_magic_setnkeys pPerl->Perl_magic_setnkeys -#undef magic_setnkeys -#define magic_setnkeys Perl_magic_setnkeys -#undef Perl_magic_setpack -#define Perl_magic_setpack pPerl->Perl_magic_setpack -#undef magic_setpack -#define magic_setpack Perl_magic_setpack -#undef Perl_magic_setpos -#define Perl_magic_setpos pPerl->Perl_magic_setpos -#undef magic_setpos -#define magic_setpos Perl_magic_setpos -#undef Perl_magic_setsig -#define Perl_magic_setsig pPerl->Perl_magic_setsig -#undef magic_setsig -#define magic_setsig Perl_magic_setsig -#undef Perl_magic_setsubstr -#define Perl_magic_setsubstr pPerl->Perl_magic_setsubstr -#undef magic_setsubstr -#define magic_setsubstr Perl_magic_setsubstr -#undef Perl_magic_settaint -#define Perl_magic_settaint pPerl->Perl_magic_settaint -#undef magic_settaint -#define magic_settaint Perl_magic_settaint -#undef Perl_magic_setuvar -#define Perl_magic_setuvar pPerl->Perl_magic_setuvar -#undef magic_setuvar -#define magic_setuvar Perl_magic_setuvar -#undef Perl_magic_setvec -#define Perl_magic_setvec pPerl->Perl_magic_setvec -#undef magic_setvec -#define magic_setvec Perl_magic_setvec -#undef Perl_magic_set_all_env -#define Perl_magic_set_all_env pPerl->Perl_magic_set_all_env -#undef magic_set_all_env -#define magic_set_all_env Perl_magic_set_all_env -#undef Perl_magic_sizepack -#define Perl_magic_sizepack pPerl->Perl_magic_sizepack -#undef magic_sizepack -#define magic_sizepack Perl_magic_sizepack -#undef Perl_magic_wipepack -#define Perl_magic_wipepack pPerl->Perl_magic_wipepack -#undef magic_wipepack -#define magic_wipepack Perl_magic_wipepack -#undef Perl_magicname -#define Perl_magicname pPerl->Perl_magicname -#undef magicname -#define magicname Perl_magicname #undef Perl_markstack_grow #define Perl_markstack_grow pPerl->Perl_markstack_grow #undef markstack_grow #define markstack_grow Perl_markstack_grow #if defined(USE_LOCALE_COLLATE) -#undef Perl_mem_collxfrm -#define Perl_mem_collxfrm pPerl->Perl_mem_collxfrm -#undef mem_collxfrm -#define mem_collxfrm Perl_mem_collxfrm #endif #undef Perl_mess #define Perl_mess pPerl->Perl_mess @@ -1230,10 +742,6 @@ #define Perl_vmess pPerl->Perl_vmess #undef vmess #define vmess Perl_vmess -#undef Perl_qerror -#define Perl_qerror pPerl->Perl_qerror -#undef qerror -#define qerror Perl_qerror #undef Perl_mg_clear #define Perl_mg_clear pPerl->Perl_mg_clear #undef mg_clear @@ -1270,18 +778,6 @@ #define Perl_mg_size pPerl->Perl_mg_size #undef mg_size #define mg_size Perl_mg_size -#undef Perl_mod -#define Perl_mod pPerl->Perl_mod -#undef mod -#define mod Perl_mod -#undef Perl_moreswitches -#define Perl_moreswitches pPerl->Perl_moreswitches -#undef moreswitches -#define moreswitches Perl_moreswitches -#undef Perl_my -#define Perl_my pPerl->Perl_my -#undef my -#define my Perl_my #undef Perl_my_atof #define Perl_my_atof pPerl->Perl_my_atof #undef my_atof @@ -1358,10 +854,6 @@ #undef my_ntohl #define my_ntohl Perl_my_ntohl #endif -#undef Perl_my_unexec -#define Perl_my_unexec pPerl->Perl_my_unexec -#undef my_unexec -#define my_unexec Perl_my_unexec #undef Perl_newANONLIST #define Perl_newANONLIST pPerl->Perl_newANONLIST #undef newANONLIST @@ -1558,74 +1050,10 @@ #define Perl_newWHILEOP pPerl->Perl_newWHILEOP #undef newWHILEOP #define newWHILEOP Perl_newWHILEOP -#undef Perl_new_stackinfo -#define Perl_new_stackinfo pPerl->Perl_new_stackinfo -#undef new_stackinfo -#define new_stackinfo Perl_new_stackinfo -#undef Perl_nextargv -#define Perl_nextargv pPerl->Perl_nextargv -#undef nextargv -#define nextargv Perl_nextargv #undef Perl_ninstr #define Perl_ninstr pPerl->Perl_ninstr #undef ninstr #define ninstr Perl_ninstr -#undef Perl_oopsCV -#define Perl_oopsCV pPerl->Perl_oopsCV -#undef oopsCV -#define oopsCV Perl_oopsCV -#undef Perl_op_free -#define Perl_op_free pPerl->Perl_op_free -#undef op_free -#define op_free Perl_op_free -#undef Perl_package -#define Perl_package pPerl->Perl_package -#undef package -#define package Perl_package -#undef Perl_pad_alloc -#define Perl_pad_alloc pPerl->Perl_pad_alloc -#undef pad_alloc -#define pad_alloc Perl_pad_alloc -#undef Perl_pad_allocmy -#define Perl_pad_allocmy pPerl->Perl_pad_allocmy -#undef pad_allocmy -#define pad_allocmy Perl_pad_allocmy -#undef Perl_pad_findmy -#define Perl_pad_findmy pPerl->Perl_pad_findmy -#undef pad_findmy -#define pad_findmy Perl_pad_findmy -#undef Perl_oopsAV -#define Perl_oopsAV pPerl->Perl_oopsAV -#undef oopsAV -#define oopsAV Perl_oopsAV -#undef Perl_oopsHV -#define Perl_oopsHV pPerl->Perl_oopsHV -#undef oopsHV -#define oopsHV Perl_oopsHV -#undef Perl_pad_leavemy -#define Perl_pad_leavemy pPerl->Perl_pad_leavemy -#undef pad_leavemy -#define pad_leavemy Perl_pad_leavemy -#undef Perl_pad_sv -#define Perl_pad_sv pPerl->Perl_pad_sv -#undef pad_sv -#define pad_sv Perl_pad_sv -#undef Perl_pad_free -#define Perl_pad_free pPerl->Perl_pad_free -#undef pad_free -#define pad_free Perl_pad_free -#undef Perl_pad_reset -#define Perl_pad_reset pPerl->Perl_pad_reset -#undef pad_reset -#define pad_reset Perl_pad_reset -#undef Perl_pad_swipe -#define Perl_pad_swipe pPerl->Perl_pad_swipe -#undef pad_swipe -#define pad_swipe Perl_pad_swipe -#undef Perl_peep -#define Perl_peep pPerl->Perl_peep -#undef peep -#define peep Perl_peep #if defined(PERL_OBJECT) #undef Perl_construct #define Perl_construct pPerl->Perl_construct @@ -1688,14 +1116,6 @@ #define Perl_get_cv pPerl->Perl_get_cv #undef get_cv #define get_cv Perl_get_cv -#undef Perl_init_i18nl10n -#define Perl_init_i18nl10n pPerl->Perl_init_i18nl10n -#undef init_i18nl10n -#define init_i18nl10n Perl_init_i18nl10n -#undef Perl_init_i18nl14n -#define Perl_init_i18nl14n pPerl->Perl_init_i18nl14n -#undef init_i18nl14n -#define init_i18nl14n Perl_init_i18nl14n #undef Perl_new_collate #define Perl_new_collate pPerl->Perl_new_collate #undef new_collate @@ -1724,127 +1144,23 @@ #define Perl_require_pv pPerl->Perl_require_pv #undef require_pv #define require_pv Perl_require_pv -#undef Perl_pidgone -#define Perl_pidgone pPerl->Perl_pidgone -#undef pidgone -#define pidgone Perl_pidgone -#undef Perl_pmflag -#define Perl_pmflag pPerl->Perl_pmflag -#undef pmflag -#define pmflag Perl_pmflag -#undef Perl_pmruntime -#define Perl_pmruntime pPerl->Perl_pmruntime -#undef pmruntime -#define pmruntime Perl_pmruntime -#undef Perl_pmtrans -#define Perl_pmtrans pPerl->Perl_pmtrans -#undef pmtrans -#define pmtrans Perl_pmtrans -#undef Perl_pop_return -#define Perl_pop_return pPerl->Perl_pop_return -#undef pop_return -#define pop_return Perl_pop_return #undef Perl_pop_scope #define Perl_pop_scope pPerl->Perl_pop_scope #undef pop_scope #define pop_scope Perl_pop_scope -#undef Perl_prepend_elem -#define Perl_prepend_elem pPerl->Perl_prepend_elem -#undef prepend_elem -#define prepend_elem Perl_prepend_elem -#undef Perl_push_return -#define Perl_push_return pPerl->Perl_push_return -#undef push_return -#define push_return Perl_push_return #undef Perl_push_scope #define Perl_push_scope pPerl->Perl_push_scope #undef push_scope #define push_scope Perl_push_scope -#undef Perl_ref -#define Perl_ref pPerl->Perl_ref -#undef ref -#define ref Perl_ref -#undef Perl_refkids -#define Perl_refkids pPerl->Perl_refkids -#undef refkids -#define refkids Perl_refkids #undef Perl_regdump #define Perl_regdump pPerl->Perl_regdump #undef regdump #define regdump Perl_regdump -#undef Perl_pregexec -#define Perl_pregexec pPerl->Perl_pregexec -#undef pregexec -#define pregexec Perl_pregexec -#undef Perl_pregfree -#define Perl_pregfree pPerl->Perl_pregfree -#undef pregfree -#define pregfree Perl_pregfree -#undef Perl_pregcomp -#define Perl_pregcomp pPerl->Perl_pregcomp -#undef pregcomp -#define pregcomp Perl_pregcomp -#undef Perl_re_intuit_start -#define Perl_re_intuit_start pPerl->Perl_re_intuit_start -#undef re_intuit_start -#define re_intuit_start Perl_re_intuit_start -#undef Perl_re_intuit_string -#define Perl_re_intuit_string pPerl->Perl_re_intuit_string -#undef re_intuit_string -#define re_intuit_string Perl_re_intuit_string -#undef Perl_regexec_flags -#define Perl_regexec_flags pPerl->Perl_regexec_flags -#undef regexec_flags -#define regexec_flags Perl_regexec_flags -#undef Perl_regnext -#define Perl_regnext pPerl->Perl_regnext -#undef regnext -#define regnext Perl_regnext -#undef Perl_regprop -#define Perl_regprop pPerl->Perl_regprop -#undef regprop -#define regprop Perl_regprop -#undef Perl_repeatcpy -#define Perl_repeatcpy pPerl->Perl_repeatcpy -#undef repeatcpy -#define repeatcpy Perl_repeatcpy #undef Perl_rninstr #define Perl_rninstr pPerl->Perl_rninstr #undef rninstr #define rninstr Perl_rninstr -#undef Perl_rsignal -#define Perl_rsignal pPerl->Perl_rsignal -#undef rsignal -#define rsignal Perl_rsignal -#undef Perl_rsignal_restore -#define Perl_rsignal_restore pPerl->Perl_rsignal_restore -#undef rsignal_restore -#define rsignal_restore Perl_rsignal_restore -#undef Perl_rsignal_save -#define Perl_rsignal_save pPerl->Perl_rsignal_save -#undef rsignal_save -#define rsignal_save Perl_rsignal_save -#undef Perl_rsignal_state -#define Perl_rsignal_state pPerl->Perl_rsignal_state -#undef rsignal_state -#define rsignal_state Perl_rsignal_state -#undef Perl_rxres_free -#define Perl_rxres_free pPerl->Perl_rxres_free -#undef rxres_free -#define rxres_free Perl_rxres_free -#undef Perl_rxres_restore -#define Perl_rxres_restore pPerl->Perl_rxres_restore -#undef rxres_restore -#define rxres_restore Perl_rxres_restore -#undef Perl_rxres_save -#define Perl_rxres_save pPerl->Perl_rxres_save -#undef rxres_save -#define rxres_save Perl_rxres_save #if !defined(HAS_RENAME) -#undef Perl_same_dirent -#define Perl_same_dirent pPerl->Perl_same_dirent -#undef same_dirent -#define same_dirent Perl_same_dirent #endif #undef Perl_savepv #define Perl_savepv pPerl->Perl_savepv @@ -1894,10 +1210,6 @@ #define Perl_save_freesv pPerl->Perl_save_freesv #undef save_freesv #define save_freesv Perl_save_freesv -#undef Perl_save_freeop -#define Perl_save_freeop pPerl->Perl_save_freeop -#undef save_freeop -#define save_freeop Perl_save_freeop #undef Perl_save_freepv #define Perl_save_freepv pPerl->Perl_save_freepv #undef save_freepv @@ -1962,10 +1274,6 @@ #define Perl_save_nogv pPerl->Perl_save_nogv #undef save_nogv #define save_nogv Perl_save_nogv -#undef Perl_save_op -#define Perl_save_op pPerl->Perl_save_op -#undef save_op -#define save_op Perl_save_op #undef Perl_save_scalar #define Perl_save_scalar pPerl->Perl_save_scalar #undef save_scalar @@ -1994,72 +1302,8 @@ #define Perl_save_threadsv pPerl->Perl_save_threadsv #undef save_threadsv #define save_threadsv Perl_save_threadsv -#undef Perl_sawparens -#define Perl_sawparens pPerl->Perl_sawparens -#undef sawparens -#define sawparens Perl_sawparens -#undef Perl_scalar -#define Perl_scalar pPerl->Perl_scalar -#undef scalar -#define scalar Perl_scalar -#undef Perl_scalarkids -#define Perl_scalarkids pPerl->Perl_scalarkids -#undef scalarkids -#define scalarkids Perl_scalarkids -#undef Perl_scalarseq -#define Perl_scalarseq pPerl->Perl_scalarseq -#undef scalarseq -#define scalarseq Perl_scalarseq -#undef Perl_scalarvoid -#define Perl_scalarvoid pPerl->Perl_scalarvoid -#undef scalarvoid -#define scalarvoid Perl_scalarvoid -#undef Perl_scan_bin -#define Perl_scan_bin pPerl->Perl_scan_bin -#undef scan_bin -#define scan_bin Perl_scan_bin -#undef Perl_scan_hex -#define Perl_scan_hex pPerl->Perl_scan_hex -#undef scan_hex -#define scan_hex Perl_scan_hex -#undef Perl_scan_num -#define Perl_scan_num pPerl->Perl_scan_num -#undef scan_num -#define scan_num Perl_scan_num -#undef Perl_scan_oct -#define Perl_scan_oct pPerl->Perl_scan_oct -#undef scan_oct -#define scan_oct Perl_scan_oct -#undef Perl_scope -#define Perl_scope pPerl->Perl_scope -#undef scope -#define scope Perl_scope -#undef Perl_screaminstr -#define Perl_screaminstr pPerl->Perl_screaminstr -#undef screaminstr -#define screaminstr Perl_screaminstr #if !defined(VMS) -#undef Perl_setenv_getix -#define Perl_setenv_getix pPerl->Perl_setenv_getix -#undef setenv_getix -#define setenv_getix Perl_setenv_getix #endif -#undef Perl_setdefout -#define Perl_setdefout pPerl->Perl_setdefout -#undef setdefout -#define setdefout Perl_setdefout -#undef Perl_sharepvn -#define Perl_sharepvn pPerl->Perl_sharepvn -#undef sharepvn -#define sharepvn Perl_sharepvn -#undef Perl_share_hek -#define Perl_share_hek pPerl->Perl_share_hek -#undef share_hek -#define share_hek Perl_share_hek -#undef Perl_sighandler -#define Perl_sighandler pPerl->Perl_sighandler -#undef sighandler -#define sighandler Perl_sighandler #undef Perl_stack_grow #define Perl_stack_grow pPerl->Perl_stack_grow #undef stack_grow @@ -2068,10 +1312,6 @@ #define Perl_start_subparse pPerl->Perl_start_subparse #undef start_subparse #define start_subparse Perl_start_subparse -#undef Perl_sub_crush_depth -#define Perl_sub_crush_depth pPerl->Perl_sub_crush_depth -#undef sub_crush_depth -#define sub_crush_depth Perl_sub_crush_depth #undef Perl_sv_2bool #define Perl_sv_2bool pPerl->Perl_sv_2bool #undef sv_2bool @@ -2140,10 +1380,6 @@ #define Perl_sv_true pPerl->Perl_sv_true #undef sv_true #define sv_true Perl_sv_true -#undef Perl_sv_add_arena -#define Perl_sv_add_arena pPerl->Perl_sv_add_arena -#undef sv_add_arena -#define sv_add_arena Perl_sv_add_arena #undef Perl_sv_backoff #define Perl_sv_backoff pPerl->Perl_sv_backoff #undef sv_backoff @@ -2176,14 +1412,6 @@ #define Perl_sv_chop pPerl->Perl_sv_chop #undef sv_chop #define sv_chop Perl_sv_chop -#undef Perl_sv_clean_all -#define Perl_sv_clean_all pPerl->Perl_sv_clean_all -#undef sv_clean_all -#define sv_clean_all Perl_sv_clean_all -#undef Perl_sv_clean_objs -#define Perl_sv_clean_objs pPerl->Perl_sv_clean_objs -#undef sv_clean_objs -#define sv_clean_objs Perl_sv_clean_objs #undef Perl_sv_clear #define Perl_sv_clear pPerl->Perl_sv_clear #undef sv_clear @@ -2202,10 +1430,6 @@ #undef sv_collxfrm #define sv_collxfrm Perl_sv_collxfrm #endif -#undef Perl_sv_compile_2op -#define Perl_sv_compile_2op pPerl->Perl_sv_compile_2op -#undef sv_compile_2op -#define sv_compile_2op Perl_sv_compile_2op #undef Perl_sv_dec #define Perl_sv_dec pPerl->Perl_sv_dec #undef sv_dec @@ -2226,14 +1450,6 @@ #define Perl_sv_free pPerl->Perl_sv_free #undef sv_free #define sv_free Perl_sv_free -#undef Perl_sv_free_arenas -#define Perl_sv_free_arenas pPerl->Perl_sv_free_arenas -#undef sv_free_arenas -#define sv_free_arenas Perl_sv_free_arenas -#undef Perl_sv_gets -#define Perl_sv_gets pPerl->Perl_sv_gets -#undef sv_gets -#define sv_gets Perl_sv_gets #undef Perl_sv_grow #define Perl_sv_grow pPerl->Perl_sv_grow #undef sv_grow @@ -2406,14 +1622,6 @@ #define Perl_sv_vsetpvfn pPerl->Perl_sv_vsetpvfn #undef sv_vsetpvfn #define sv_vsetpvfn Perl_sv_vsetpvfn -#undef Perl_swash_init -#define Perl_swash_init pPerl->Perl_swash_init -#undef swash_init -#define swash_init Perl_swash_init -#undef Perl_swash_fetch -#define Perl_swash_fetch pPerl->Perl_swash_fetch -#undef swash_fetch -#define swash_fetch Perl_swash_fetch #undef Perl_taint_env #define Perl_taint_env pPerl->Perl_taint_env #undef taint_env @@ -2441,23 +1649,7 @@ #define unlnk Perl_unlnk #endif #if defined(USE_THREADS) -#undef Perl_unlock_condpair -#define Perl_unlock_condpair pPerl->Perl_unlock_condpair -#undef unlock_condpair -#define unlock_condpair Perl_unlock_condpair #endif -#undef Perl_unsharepvn -#define Perl_unsharepvn pPerl->Perl_unsharepvn -#undef unsharepvn -#define unsharepvn Perl_unsharepvn -#undef Perl_unshare_hek -#define Perl_unshare_hek pPerl->Perl_unshare_hek -#undef unshare_hek -#define unshare_hek Perl_unshare_hek -#undef Perl_utilize -#define Perl_utilize pPerl->Perl_utilize -#undef utilize -#define utilize Perl_utilize #undef Perl_utf16_to_utf8 #define Perl_utf16_to_utf8 pPerl->Perl_utf16_to_utf8 #undef utf16_to_utf8 @@ -2482,26 +1674,6 @@ #define Perl_uv_to_utf8 pPerl->Perl_uv_to_utf8 #undef uv_to_utf8 #define uv_to_utf8 Perl_uv_to_utf8 -#undef Perl_vivify_defelem -#define Perl_vivify_defelem pPerl->Perl_vivify_defelem -#undef vivify_defelem -#define vivify_defelem Perl_vivify_defelem -#undef Perl_vivify_ref -#define Perl_vivify_ref pPerl->Perl_vivify_ref -#undef vivify_ref -#define vivify_ref Perl_vivify_ref -#undef Perl_wait4pid -#define Perl_wait4pid pPerl->Perl_wait4pid -#undef wait4pid -#define wait4pid Perl_wait4pid -#undef Perl_report_closed_fh -#define Perl_report_closed_fh pPerl->Perl_report_closed_fh -#undef report_closed_fh -#define report_closed_fh Perl_report_closed_fh -#undef Perl_report_uninit -#define Perl_report_uninit pPerl->Perl_report_uninit -#undef report_uninit -#define report_uninit Perl_report_uninit #undef Perl_warn #define Perl_warn pPerl->Perl_warn #undef warn @@ -2518,37 +1690,9 @@ #define Perl_vwarner pPerl->Perl_vwarner #undef vwarner #define vwarner Perl_vwarner -#undef Perl_watch -#define Perl_watch pPerl->Perl_watch -#undef watch -#define watch Perl_watch -#undef Perl_whichsig -#define Perl_whichsig pPerl->Perl_whichsig -#undef whichsig -#define whichsig Perl_whichsig -#undef Perl_yyerror -#define Perl_yyerror pPerl->Perl_yyerror -#undef yyerror -#define yyerror Perl_yyerror #if defined(USE_PURE_BISON) -#undef Perl_yylex -#define Perl_yylex pPerl->Perl_yylex -#undef yylex -#define yylex Perl_yylex #else -#undef Perl_yylex -#define Perl_yylex pPerl->Perl_yylex -#undef yylex -#define yylex Perl_yylex #endif -#undef Perl_yyparse -#define Perl_yyparse pPerl->Perl_yyparse -#undef yyparse -#define yyparse Perl_yyparse -#undef Perl_yywarn -#define Perl_yywarn pPerl->Perl_yywarn -#undef yywarn -#define yywarn Perl_yywarn #if defined(MYMALLOC) #undef Perl_dump_mstats #define Perl_dump_mstats pPerl->Perl_dump_mstats @@ -2667,10 +1811,6 @@ #define Perl_get_vtbl pPerl->Perl_get_vtbl #undef get_vtbl #define get_vtbl Perl_get_vtbl -#undef Perl_pv_display -#define Perl_pv_display pPerl->Perl_pv_display -#undef pv_display -#define pv_display Perl_pv_display #undef Perl_dump_indent #define Perl_dump_indent pPerl->Perl_dump_indent #undef dump_indent @@ -2759,10 +1899,6 @@ #define Perl_sv_rvweaken pPerl->Perl_sv_rvweaken #undef sv_rvweaken #define sv_rvweaken Perl_sv_rvweaken -#undef Perl_magic_killbackrefs -#define Perl_magic_killbackrefs pPerl->Perl_magic_killbackrefs -#undef magic_killbackrefs -#define magic_killbackrefs Perl_magic_killbackrefs #undef Perl_newANONATTRSUB #define Perl_newANONATTRSUB pPerl->Perl_newANONATTRSUB #undef newANONATTRSUB @@ -2775,14 +1911,6 @@ #define Perl_newMYSUB pPerl->Perl_newMYSUB #undef newMYSUB #define newMYSUB Perl_newMYSUB -#undef Perl_my_attrs -#define Perl_my_attrs pPerl->Perl_my_attrs -#undef my_attrs -#define my_attrs Perl_my_attrs -#undef Perl_boot_core_xsutils -#define Perl_boot_core_xsutils pPerl->Perl_boot_core_xsutils -#undef boot_core_xsutils -#define boot_core_xsutils Perl_boot_core_xsutils #if defined(USE_ITHREADS) #undef Perl_cx_dup #define Perl_cx_dup pPerl->Perl_cx_dup @@ -2913,1538 +2041,6 @@ #endif #if defined(PERL_OBJECT) #endif -#undef Perl_ck_anoncode -#define Perl_ck_anoncode pPerl->Perl_ck_anoncode -#undef ck_anoncode -#define ck_anoncode Perl_ck_anoncode -#undef Perl_ck_bitop -#define Perl_ck_bitop pPerl->Perl_ck_bitop -#undef ck_bitop -#define ck_bitop Perl_ck_bitop -#undef Perl_ck_concat -#define Perl_ck_concat pPerl->Perl_ck_concat -#undef ck_concat -#define ck_concat Perl_ck_concat -#undef Perl_ck_defined -#define Perl_ck_defined pPerl->Perl_ck_defined -#undef ck_defined -#define ck_defined Perl_ck_defined -#undef Perl_ck_delete -#define Perl_ck_delete pPerl->Perl_ck_delete -#undef ck_delete -#define ck_delete Perl_ck_delete -#undef Perl_ck_eof -#define Perl_ck_eof pPerl->Perl_ck_eof -#undef ck_eof -#define ck_eof Perl_ck_eof -#undef Perl_ck_eval -#define Perl_ck_eval pPerl->Perl_ck_eval -#undef ck_eval -#define ck_eval Perl_ck_eval -#undef Perl_ck_exec -#define Perl_ck_exec pPerl->Perl_ck_exec -#undef ck_exec -#define ck_exec Perl_ck_exec -#undef Perl_ck_exists -#define Perl_ck_exists pPerl->Perl_ck_exists -#undef ck_exists -#define ck_exists Perl_ck_exists -#undef Perl_ck_ftst -#define Perl_ck_ftst pPerl->Perl_ck_ftst -#undef ck_ftst -#define ck_ftst Perl_ck_ftst -#undef Perl_ck_fun -#define Perl_ck_fun pPerl->Perl_ck_fun -#undef ck_fun -#define ck_fun Perl_ck_fun -#undef Perl_ck_fun_locale -#define Perl_ck_fun_locale pPerl->Perl_ck_fun_locale -#undef ck_fun_locale -#define ck_fun_locale Perl_ck_fun_locale -#undef Perl_ck_glob -#define Perl_ck_glob pPerl->Perl_ck_glob -#undef ck_glob -#define ck_glob Perl_ck_glob -#undef Perl_ck_grep -#define Perl_ck_grep pPerl->Perl_ck_grep -#undef ck_grep -#define ck_grep Perl_ck_grep -#undef Perl_ck_index -#define Perl_ck_index pPerl->Perl_ck_index -#undef ck_index -#define ck_index Perl_ck_index -#undef Perl_ck_join -#define Perl_ck_join pPerl->Perl_ck_join -#undef ck_join -#define ck_join Perl_ck_join -#undef Perl_ck_lengthconst -#define Perl_ck_lengthconst pPerl->Perl_ck_lengthconst -#undef ck_lengthconst -#define ck_lengthconst Perl_ck_lengthconst -#undef Perl_ck_lfun -#define Perl_ck_lfun pPerl->Perl_ck_lfun -#undef ck_lfun -#define ck_lfun Perl_ck_lfun -#undef Perl_ck_listiob -#define Perl_ck_listiob pPerl->Perl_ck_listiob -#undef ck_listiob -#define ck_listiob Perl_ck_listiob -#undef Perl_ck_match -#define Perl_ck_match pPerl->Perl_ck_match -#undef ck_match -#define ck_match Perl_ck_match -#undef Perl_ck_method -#define Perl_ck_method pPerl->Perl_ck_method -#undef ck_method -#define ck_method Perl_ck_method -#undef Perl_ck_null -#define Perl_ck_null pPerl->Perl_ck_null -#undef ck_null -#define ck_null Perl_ck_null -#undef Perl_ck_repeat -#define Perl_ck_repeat pPerl->Perl_ck_repeat -#undef ck_repeat -#define ck_repeat Perl_ck_repeat -#undef Perl_ck_require -#define Perl_ck_require pPerl->Perl_ck_require -#undef ck_require -#define ck_require Perl_ck_require -#undef Perl_ck_rfun -#define Perl_ck_rfun pPerl->Perl_ck_rfun -#undef ck_rfun -#define ck_rfun Perl_ck_rfun -#undef Perl_ck_rvconst -#define Perl_ck_rvconst pPerl->Perl_ck_rvconst -#undef ck_rvconst -#define ck_rvconst Perl_ck_rvconst -#undef Perl_ck_sassign -#define Perl_ck_sassign pPerl->Perl_ck_sassign -#undef ck_sassign -#define ck_sassign Perl_ck_sassign -#undef Perl_ck_scmp -#define Perl_ck_scmp pPerl->Perl_ck_scmp -#undef ck_scmp -#define ck_scmp Perl_ck_scmp -#undef Perl_ck_select -#define Perl_ck_select pPerl->Perl_ck_select -#undef ck_select -#define ck_select Perl_ck_select -#undef Perl_ck_shift -#define Perl_ck_shift pPerl->Perl_ck_shift -#undef ck_shift -#define ck_shift Perl_ck_shift -#undef Perl_ck_sort -#define Perl_ck_sort pPerl->Perl_ck_sort -#undef ck_sort -#define ck_sort Perl_ck_sort -#undef Perl_ck_spair -#define Perl_ck_spair pPerl->Perl_ck_spair -#undef ck_spair -#define ck_spair Perl_ck_spair -#undef Perl_ck_split -#define Perl_ck_split pPerl->Perl_ck_split -#undef ck_split -#define ck_split Perl_ck_split -#undef Perl_ck_subr -#define Perl_ck_subr pPerl->Perl_ck_subr -#undef ck_subr -#define ck_subr Perl_ck_subr -#undef Perl_ck_svconst -#define Perl_ck_svconst pPerl->Perl_ck_svconst -#undef ck_svconst -#define ck_svconst Perl_ck_svconst -#undef Perl_ck_trunc -#define Perl_ck_trunc pPerl->Perl_ck_trunc -#undef ck_trunc -#define ck_trunc Perl_ck_trunc -#undef Perl_pp_aassign -#define Perl_pp_aassign pPerl->Perl_pp_aassign -#undef pp_aassign -#define pp_aassign Perl_pp_aassign -#undef Perl_pp_abs -#define Perl_pp_abs pPerl->Perl_pp_abs -#undef pp_abs -#define pp_abs Perl_pp_abs -#undef Perl_pp_accept -#define Perl_pp_accept pPerl->Perl_pp_accept -#undef pp_accept -#define pp_accept Perl_pp_accept -#undef Perl_pp_add -#define Perl_pp_add pPerl->Perl_pp_add -#undef pp_add -#define pp_add Perl_pp_add -#undef Perl_pp_aelem -#define Perl_pp_aelem pPerl->Perl_pp_aelem -#undef pp_aelem -#define pp_aelem Perl_pp_aelem -#undef Perl_pp_aelemfast -#define Perl_pp_aelemfast pPerl->Perl_pp_aelemfast -#undef pp_aelemfast -#define pp_aelemfast Perl_pp_aelemfast -#undef Perl_pp_alarm -#define Perl_pp_alarm pPerl->Perl_pp_alarm -#undef pp_alarm -#define pp_alarm Perl_pp_alarm -#undef Perl_pp_and -#define Perl_pp_and pPerl->Perl_pp_and -#undef pp_and -#define pp_and Perl_pp_and -#undef Perl_pp_andassign -#define Perl_pp_andassign pPerl->Perl_pp_andassign -#undef pp_andassign -#define pp_andassign Perl_pp_andassign -#undef Perl_pp_anoncode -#define Perl_pp_anoncode pPerl->Perl_pp_anoncode -#undef pp_anoncode -#define pp_anoncode Perl_pp_anoncode -#undef Perl_pp_anonhash -#define Perl_pp_anonhash pPerl->Perl_pp_anonhash -#undef pp_anonhash -#define pp_anonhash Perl_pp_anonhash -#undef Perl_pp_anonlist -#define Perl_pp_anonlist pPerl->Perl_pp_anonlist -#undef pp_anonlist -#define pp_anonlist Perl_pp_anonlist -#undef Perl_pp_aslice -#define Perl_pp_aslice pPerl->Perl_pp_aslice -#undef pp_aslice -#define pp_aslice Perl_pp_aslice -#undef Perl_pp_atan2 -#define Perl_pp_atan2 pPerl->Perl_pp_atan2 -#undef pp_atan2 -#define pp_atan2 Perl_pp_atan2 -#undef Perl_pp_av2arylen -#define Perl_pp_av2arylen pPerl->Perl_pp_av2arylen -#undef pp_av2arylen -#define pp_av2arylen Perl_pp_av2arylen -#undef Perl_pp_backtick -#define Perl_pp_backtick pPerl->Perl_pp_backtick -#undef pp_backtick -#define pp_backtick Perl_pp_backtick -#undef Perl_pp_bind -#define Perl_pp_bind pPerl->Perl_pp_bind -#undef pp_bind -#define pp_bind Perl_pp_bind -#undef Perl_pp_binmode -#define Perl_pp_binmode pPerl->Perl_pp_binmode -#undef pp_binmode -#define pp_binmode Perl_pp_binmode -#undef Perl_pp_bit_and -#define Perl_pp_bit_and pPerl->Perl_pp_bit_and -#undef pp_bit_and -#define pp_bit_and Perl_pp_bit_and -#undef Perl_pp_bit_or -#define Perl_pp_bit_or pPerl->Perl_pp_bit_or -#undef pp_bit_or -#define pp_bit_or Perl_pp_bit_or -#undef Perl_pp_bit_xor -#define Perl_pp_bit_xor pPerl->Perl_pp_bit_xor -#undef pp_bit_xor -#define pp_bit_xor Perl_pp_bit_xor -#undef Perl_pp_bless -#define Perl_pp_bless pPerl->Perl_pp_bless -#undef pp_bless -#define pp_bless Perl_pp_bless -#undef Perl_pp_caller -#define Perl_pp_caller pPerl->Perl_pp_caller -#undef pp_caller -#define pp_caller Perl_pp_caller -#undef Perl_pp_chdir -#define Perl_pp_chdir pPerl->Perl_pp_chdir -#undef pp_chdir -#define pp_chdir Perl_pp_chdir -#undef Perl_pp_chmod -#define Perl_pp_chmod pPerl->Perl_pp_chmod -#undef pp_chmod -#define pp_chmod Perl_pp_chmod -#undef Perl_pp_chomp -#define Perl_pp_chomp pPerl->Perl_pp_chomp -#undef pp_chomp -#define pp_chomp Perl_pp_chomp -#undef Perl_pp_chop -#define Perl_pp_chop pPerl->Perl_pp_chop -#undef pp_chop -#define pp_chop Perl_pp_chop -#undef Perl_pp_chown -#define Perl_pp_chown pPerl->Perl_pp_chown -#undef pp_chown -#define pp_chown Perl_pp_chown -#undef Perl_pp_chr -#define Perl_pp_chr pPerl->Perl_pp_chr -#undef pp_chr -#define pp_chr Perl_pp_chr -#undef Perl_pp_chroot -#define Perl_pp_chroot pPerl->Perl_pp_chroot -#undef pp_chroot -#define pp_chroot Perl_pp_chroot -#undef Perl_pp_close -#define Perl_pp_close pPerl->Perl_pp_close -#undef pp_close -#define pp_close Perl_pp_close -#undef Perl_pp_closedir -#define Perl_pp_closedir pPerl->Perl_pp_closedir -#undef pp_closedir -#define pp_closedir Perl_pp_closedir -#undef Perl_pp_complement -#define Perl_pp_complement pPerl->Perl_pp_complement -#undef pp_complement -#define pp_complement Perl_pp_complement -#undef Perl_pp_concat -#define Perl_pp_concat pPerl->Perl_pp_concat -#undef pp_concat -#define pp_concat Perl_pp_concat -#undef Perl_pp_cond_expr -#define Perl_pp_cond_expr pPerl->Perl_pp_cond_expr -#undef pp_cond_expr -#define pp_cond_expr Perl_pp_cond_expr -#undef Perl_pp_connect -#define Perl_pp_connect pPerl->Perl_pp_connect -#undef pp_connect -#define pp_connect Perl_pp_connect -#undef Perl_pp_const -#define Perl_pp_const pPerl->Perl_pp_const -#undef pp_const -#define pp_const Perl_pp_const -#undef Perl_pp_cos -#define Perl_pp_cos pPerl->Perl_pp_cos -#undef pp_cos -#define pp_cos Perl_pp_cos -#undef Perl_pp_crypt -#define Perl_pp_crypt pPerl->Perl_pp_crypt -#undef pp_crypt -#define pp_crypt Perl_pp_crypt -#undef Perl_pp_dbmclose -#define Perl_pp_dbmclose pPerl->Perl_pp_dbmclose -#undef pp_dbmclose -#define pp_dbmclose Perl_pp_dbmclose -#undef Perl_pp_dbmopen -#define Perl_pp_dbmopen pPerl->Perl_pp_dbmopen -#undef pp_dbmopen -#define pp_dbmopen Perl_pp_dbmopen -#undef Perl_pp_dbstate -#define Perl_pp_dbstate pPerl->Perl_pp_dbstate -#undef pp_dbstate -#define pp_dbstate Perl_pp_dbstate -#undef Perl_pp_defined -#define Perl_pp_defined pPerl->Perl_pp_defined -#undef pp_defined -#define pp_defined Perl_pp_defined -#undef Perl_pp_delete -#define Perl_pp_delete pPerl->Perl_pp_delete -#undef pp_delete -#define pp_delete Perl_pp_delete -#undef Perl_pp_die -#define Perl_pp_die pPerl->Perl_pp_die -#undef pp_die -#define pp_die Perl_pp_die -#undef Perl_pp_divide -#define Perl_pp_divide pPerl->Perl_pp_divide -#undef pp_divide -#define pp_divide Perl_pp_divide -#undef Perl_pp_dofile -#define Perl_pp_dofile pPerl->Perl_pp_dofile -#undef pp_dofile -#define pp_dofile Perl_pp_dofile -#undef Perl_pp_dump -#define Perl_pp_dump pPerl->Perl_pp_dump -#undef pp_dump -#define pp_dump Perl_pp_dump -#undef Perl_pp_each -#define Perl_pp_each pPerl->Perl_pp_each -#undef pp_each -#define pp_each Perl_pp_each -#undef Perl_pp_egrent -#define Perl_pp_egrent pPerl->Perl_pp_egrent -#undef pp_egrent -#define pp_egrent Perl_pp_egrent -#undef Perl_pp_ehostent -#define Perl_pp_ehostent pPerl->Perl_pp_ehostent -#undef pp_ehostent -#define pp_ehostent Perl_pp_ehostent -#undef Perl_pp_enetent -#define Perl_pp_enetent pPerl->Perl_pp_enetent -#undef pp_enetent -#define pp_enetent Perl_pp_enetent -#undef Perl_pp_enter -#define Perl_pp_enter pPerl->Perl_pp_enter -#undef pp_enter -#define pp_enter Perl_pp_enter -#undef Perl_pp_entereval -#define Perl_pp_entereval pPerl->Perl_pp_entereval -#undef pp_entereval -#define pp_entereval Perl_pp_entereval -#undef Perl_pp_enteriter -#define Perl_pp_enteriter pPerl->Perl_pp_enteriter -#undef pp_enteriter -#define pp_enteriter Perl_pp_enteriter -#undef Perl_pp_enterloop -#define Perl_pp_enterloop pPerl->Perl_pp_enterloop -#undef pp_enterloop -#define pp_enterloop Perl_pp_enterloop -#undef Perl_pp_entersub -#define Perl_pp_entersub pPerl->Perl_pp_entersub -#undef pp_entersub -#define pp_entersub Perl_pp_entersub -#undef Perl_pp_entertry -#define Perl_pp_entertry pPerl->Perl_pp_entertry -#undef pp_entertry -#define pp_entertry Perl_pp_entertry -#undef Perl_pp_enterwrite -#define Perl_pp_enterwrite pPerl->Perl_pp_enterwrite -#undef pp_enterwrite -#define pp_enterwrite Perl_pp_enterwrite -#undef Perl_pp_eof -#define Perl_pp_eof pPerl->Perl_pp_eof -#undef pp_eof -#define pp_eof Perl_pp_eof -#undef Perl_pp_eprotoent -#define Perl_pp_eprotoent pPerl->Perl_pp_eprotoent -#undef pp_eprotoent -#define pp_eprotoent Perl_pp_eprotoent -#undef Perl_pp_epwent -#define Perl_pp_epwent pPerl->Perl_pp_epwent -#undef pp_epwent -#define pp_epwent Perl_pp_epwent -#undef Perl_pp_eq -#define Perl_pp_eq pPerl->Perl_pp_eq -#undef pp_eq -#define pp_eq Perl_pp_eq -#undef Perl_pp_eservent -#define Perl_pp_eservent pPerl->Perl_pp_eservent -#undef pp_eservent -#define pp_eservent Perl_pp_eservent -#undef Perl_pp_exec -#define Perl_pp_exec pPerl->Perl_pp_exec -#undef pp_exec -#define pp_exec Perl_pp_exec -#undef Perl_pp_exists -#define Perl_pp_exists pPerl->Perl_pp_exists -#undef pp_exists -#define pp_exists Perl_pp_exists -#undef Perl_pp_exit -#define Perl_pp_exit pPerl->Perl_pp_exit -#undef pp_exit -#define pp_exit Perl_pp_exit -#undef Perl_pp_exp -#define Perl_pp_exp pPerl->Perl_pp_exp -#undef pp_exp -#define pp_exp Perl_pp_exp -#undef Perl_pp_fcntl -#define Perl_pp_fcntl pPerl->Perl_pp_fcntl -#undef pp_fcntl -#define pp_fcntl Perl_pp_fcntl -#undef Perl_pp_fileno -#define Perl_pp_fileno pPerl->Perl_pp_fileno -#undef pp_fileno -#define pp_fileno Perl_pp_fileno -#undef Perl_pp_flip -#define Perl_pp_flip pPerl->Perl_pp_flip -#undef pp_flip -#define pp_flip Perl_pp_flip -#undef Perl_pp_flock -#define Perl_pp_flock pPerl->Perl_pp_flock -#undef pp_flock -#define pp_flock Perl_pp_flock -#undef Perl_pp_flop -#define Perl_pp_flop pPerl->Perl_pp_flop -#undef pp_flop -#define pp_flop Perl_pp_flop -#undef Perl_pp_fork -#define Perl_pp_fork pPerl->Perl_pp_fork -#undef pp_fork -#define pp_fork Perl_pp_fork -#undef Perl_pp_formline -#define Perl_pp_formline pPerl->Perl_pp_formline -#undef pp_formline -#define pp_formline Perl_pp_formline -#undef Perl_pp_ftatime -#define Perl_pp_ftatime pPerl->Perl_pp_ftatime -#undef pp_ftatime -#define pp_ftatime Perl_pp_ftatime -#undef Perl_pp_ftbinary -#define Perl_pp_ftbinary pPerl->Perl_pp_ftbinary -#undef pp_ftbinary -#define pp_ftbinary Perl_pp_ftbinary -#undef Perl_pp_ftblk -#define Perl_pp_ftblk pPerl->Perl_pp_ftblk -#undef pp_ftblk -#define pp_ftblk Perl_pp_ftblk -#undef Perl_pp_ftchr -#define Perl_pp_ftchr pPerl->Perl_pp_ftchr -#undef pp_ftchr -#define pp_ftchr Perl_pp_ftchr -#undef Perl_pp_ftctime -#define Perl_pp_ftctime pPerl->Perl_pp_ftctime -#undef pp_ftctime -#define pp_ftctime Perl_pp_ftctime -#undef Perl_pp_ftdir -#define Perl_pp_ftdir pPerl->Perl_pp_ftdir -#undef pp_ftdir -#define pp_ftdir Perl_pp_ftdir -#undef Perl_pp_fteexec -#define Perl_pp_fteexec pPerl->Perl_pp_fteexec -#undef pp_fteexec -#define pp_fteexec Perl_pp_fteexec -#undef Perl_pp_fteowned -#define Perl_pp_fteowned pPerl->Perl_pp_fteowned -#undef pp_fteowned -#define pp_fteowned Perl_pp_fteowned -#undef Perl_pp_fteread -#define Perl_pp_fteread pPerl->Perl_pp_fteread -#undef pp_fteread -#define pp_fteread Perl_pp_fteread -#undef Perl_pp_ftewrite -#define Perl_pp_ftewrite pPerl->Perl_pp_ftewrite -#undef pp_ftewrite -#define pp_ftewrite Perl_pp_ftewrite -#undef Perl_pp_ftfile -#define Perl_pp_ftfile pPerl->Perl_pp_ftfile -#undef pp_ftfile -#define pp_ftfile Perl_pp_ftfile -#undef Perl_pp_ftis -#define Perl_pp_ftis pPerl->Perl_pp_ftis -#undef pp_ftis -#define pp_ftis Perl_pp_ftis -#undef Perl_pp_ftlink -#define Perl_pp_ftlink pPerl->Perl_pp_ftlink -#undef pp_ftlink -#define pp_ftlink Perl_pp_ftlink -#undef Perl_pp_ftmtime -#define Perl_pp_ftmtime pPerl->Perl_pp_ftmtime -#undef pp_ftmtime -#define pp_ftmtime Perl_pp_ftmtime -#undef Perl_pp_ftpipe -#define Perl_pp_ftpipe pPerl->Perl_pp_ftpipe -#undef pp_ftpipe -#define pp_ftpipe Perl_pp_ftpipe -#undef Perl_pp_ftrexec -#define Perl_pp_ftrexec pPerl->Perl_pp_ftrexec -#undef pp_ftrexec -#define pp_ftrexec Perl_pp_ftrexec -#undef Perl_pp_ftrowned -#define Perl_pp_ftrowned pPerl->Perl_pp_ftrowned -#undef pp_ftrowned -#define pp_ftrowned Perl_pp_ftrowned -#undef Perl_pp_ftrread -#define Perl_pp_ftrread pPerl->Perl_pp_ftrread -#undef pp_ftrread -#define pp_ftrread Perl_pp_ftrread -#undef Perl_pp_ftrwrite -#define Perl_pp_ftrwrite pPerl->Perl_pp_ftrwrite -#undef pp_ftrwrite -#define pp_ftrwrite Perl_pp_ftrwrite -#undef Perl_pp_ftsgid -#define Perl_pp_ftsgid pPerl->Perl_pp_ftsgid -#undef pp_ftsgid -#define pp_ftsgid Perl_pp_ftsgid -#undef Perl_pp_ftsize -#define Perl_pp_ftsize pPerl->Perl_pp_ftsize -#undef pp_ftsize -#define pp_ftsize Perl_pp_ftsize -#undef Perl_pp_ftsock -#define Perl_pp_ftsock pPerl->Perl_pp_ftsock -#undef pp_ftsock -#define pp_ftsock Perl_pp_ftsock -#undef Perl_pp_ftsuid -#define Perl_pp_ftsuid pPerl->Perl_pp_ftsuid -#undef pp_ftsuid -#define pp_ftsuid Perl_pp_ftsuid -#undef Perl_pp_ftsvtx -#define Perl_pp_ftsvtx pPerl->Perl_pp_ftsvtx -#undef pp_ftsvtx -#define pp_ftsvtx Perl_pp_ftsvtx -#undef Perl_pp_fttext -#define Perl_pp_fttext pPerl->Perl_pp_fttext -#undef pp_fttext -#define pp_fttext Perl_pp_fttext -#undef Perl_pp_fttty -#define Perl_pp_fttty pPerl->Perl_pp_fttty -#undef pp_fttty -#define pp_fttty Perl_pp_fttty -#undef Perl_pp_ftzero -#define Perl_pp_ftzero pPerl->Perl_pp_ftzero -#undef pp_ftzero -#define pp_ftzero Perl_pp_ftzero -#undef Perl_pp_ge -#define Perl_pp_ge pPerl->Perl_pp_ge -#undef pp_ge -#define pp_ge Perl_pp_ge -#undef Perl_pp_gelem -#define Perl_pp_gelem pPerl->Perl_pp_gelem -#undef pp_gelem -#define pp_gelem Perl_pp_gelem -#undef Perl_pp_getc -#define Perl_pp_getc pPerl->Perl_pp_getc -#undef pp_getc -#define pp_getc Perl_pp_getc -#undef Perl_pp_getlogin -#define Perl_pp_getlogin pPerl->Perl_pp_getlogin -#undef pp_getlogin -#define pp_getlogin Perl_pp_getlogin -#undef Perl_pp_getpeername -#define Perl_pp_getpeername pPerl->Perl_pp_getpeername -#undef pp_getpeername -#define pp_getpeername Perl_pp_getpeername -#undef Perl_pp_getpgrp -#define Perl_pp_getpgrp pPerl->Perl_pp_getpgrp -#undef pp_getpgrp -#define pp_getpgrp Perl_pp_getpgrp -#undef Perl_pp_getppid -#define Perl_pp_getppid pPerl->Perl_pp_getppid -#undef pp_getppid -#define pp_getppid Perl_pp_getppid -#undef Perl_pp_getpriority -#define Perl_pp_getpriority pPerl->Perl_pp_getpriority -#undef pp_getpriority -#define pp_getpriority Perl_pp_getpriority -#undef Perl_pp_getsockname -#define Perl_pp_getsockname pPerl->Perl_pp_getsockname -#undef pp_getsockname -#define pp_getsockname Perl_pp_getsockname -#undef Perl_pp_ggrent -#define Perl_pp_ggrent pPerl->Perl_pp_ggrent -#undef pp_ggrent -#define pp_ggrent Perl_pp_ggrent -#undef Perl_pp_ggrgid -#define Perl_pp_ggrgid pPerl->Perl_pp_ggrgid -#undef pp_ggrgid -#define pp_ggrgid Perl_pp_ggrgid -#undef Perl_pp_ggrnam -#define Perl_pp_ggrnam pPerl->Perl_pp_ggrnam -#undef pp_ggrnam -#define pp_ggrnam Perl_pp_ggrnam -#undef Perl_pp_ghbyaddr -#define Perl_pp_ghbyaddr pPerl->Perl_pp_ghbyaddr -#undef pp_ghbyaddr -#define pp_ghbyaddr Perl_pp_ghbyaddr -#undef Perl_pp_ghbyname -#define Perl_pp_ghbyname pPerl->Perl_pp_ghbyname -#undef pp_ghbyname -#define pp_ghbyname Perl_pp_ghbyname -#undef Perl_pp_ghostent -#define Perl_pp_ghostent pPerl->Perl_pp_ghostent -#undef pp_ghostent -#define pp_ghostent Perl_pp_ghostent -#undef Perl_pp_glob -#define Perl_pp_glob pPerl->Perl_pp_glob -#undef pp_glob -#define pp_glob Perl_pp_glob -#undef Perl_pp_gmtime -#define Perl_pp_gmtime pPerl->Perl_pp_gmtime -#undef pp_gmtime -#define pp_gmtime Perl_pp_gmtime -#undef Perl_pp_gnbyaddr -#define Perl_pp_gnbyaddr pPerl->Perl_pp_gnbyaddr -#undef pp_gnbyaddr -#define pp_gnbyaddr Perl_pp_gnbyaddr -#undef Perl_pp_gnbyname -#define Perl_pp_gnbyname pPerl->Perl_pp_gnbyname -#undef pp_gnbyname -#define pp_gnbyname Perl_pp_gnbyname -#undef Perl_pp_gnetent -#define Perl_pp_gnetent pPerl->Perl_pp_gnetent -#undef pp_gnetent -#define pp_gnetent Perl_pp_gnetent -#undef Perl_pp_goto -#define Perl_pp_goto pPerl->Perl_pp_goto -#undef pp_goto -#define pp_goto Perl_pp_goto -#undef Perl_pp_gpbyname -#define Perl_pp_gpbyname pPerl->Perl_pp_gpbyname -#undef pp_gpbyname -#define pp_gpbyname Perl_pp_gpbyname -#undef Perl_pp_gpbynumber -#define Perl_pp_gpbynumber pPerl->Perl_pp_gpbynumber -#undef pp_gpbynumber -#define pp_gpbynumber Perl_pp_gpbynumber -#undef Perl_pp_gprotoent -#define Perl_pp_gprotoent pPerl->Perl_pp_gprotoent -#undef pp_gprotoent -#define pp_gprotoent Perl_pp_gprotoent -#undef Perl_pp_gpwent -#define Perl_pp_gpwent pPerl->Perl_pp_gpwent -#undef pp_gpwent -#define pp_gpwent Perl_pp_gpwent -#undef Perl_pp_gpwnam -#define Perl_pp_gpwnam pPerl->Perl_pp_gpwnam -#undef pp_gpwnam -#define pp_gpwnam Perl_pp_gpwnam -#undef Perl_pp_gpwuid -#define Perl_pp_gpwuid pPerl->Perl_pp_gpwuid -#undef pp_gpwuid -#define pp_gpwuid Perl_pp_gpwuid -#undef Perl_pp_grepstart -#define Perl_pp_grepstart pPerl->Perl_pp_grepstart -#undef pp_grepstart -#define pp_grepstart Perl_pp_grepstart -#undef Perl_pp_grepwhile -#define Perl_pp_grepwhile pPerl->Perl_pp_grepwhile -#undef pp_grepwhile -#define pp_grepwhile Perl_pp_grepwhile -#undef Perl_pp_gsbyname -#define Perl_pp_gsbyname pPerl->Perl_pp_gsbyname -#undef pp_gsbyname -#define pp_gsbyname Perl_pp_gsbyname -#undef Perl_pp_gsbyport -#define Perl_pp_gsbyport pPerl->Perl_pp_gsbyport -#undef pp_gsbyport -#define pp_gsbyport Perl_pp_gsbyport -#undef Perl_pp_gservent -#define Perl_pp_gservent pPerl->Perl_pp_gservent -#undef pp_gservent -#define pp_gservent Perl_pp_gservent -#undef Perl_pp_gsockopt -#define Perl_pp_gsockopt pPerl->Perl_pp_gsockopt -#undef pp_gsockopt -#define pp_gsockopt Perl_pp_gsockopt -#undef Perl_pp_gt -#define Perl_pp_gt pPerl->Perl_pp_gt -#undef pp_gt -#define pp_gt Perl_pp_gt -#undef Perl_pp_gv -#define Perl_pp_gv pPerl->Perl_pp_gv -#undef pp_gv -#define pp_gv Perl_pp_gv -#undef Perl_pp_gvsv -#define Perl_pp_gvsv pPerl->Perl_pp_gvsv -#undef pp_gvsv -#define pp_gvsv Perl_pp_gvsv -#undef Perl_pp_helem -#define Perl_pp_helem pPerl->Perl_pp_helem -#undef pp_helem -#define pp_helem Perl_pp_helem -#undef Perl_pp_hex -#define Perl_pp_hex pPerl->Perl_pp_hex -#undef pp_hex -#define pp_hex Perl_pp_hex -#undef Perl_pp_hslice -#define Perl_pp_hslice pPerl->Perl_pp_hslice -#undef pp_hslice -#define pp_hslice Perl_pp_hslice -#undef Perl_pp_i_add -#define Perl_pp_i_add pPerl->Perl_pp_i_add -#undef pp_i_add -#define pp_i_add Perl_pp_i_add -#undef Perl_pp_i_divide -#define Perl_pp_i_divide pPerl->Perl_pp_i_divide -#undef pp_i_divide -#define pp_i_divide Perl_pp_i_divide -#undef Perl_pp_i_eq -#define Perl_pp_i_eq pPerl->Perl_pp_i_eq -#undef pp_i_eq -#define pp_i_eq Perl_pp_i_eq -#undef Perl_pp_i_ge -#define Perl_pp_i_ge pPerl->Perl_pp_i_ge -#undef pp_i_ge -#define pp_i_ge Perl_pp_i_ge -#undef Perl_pp_i_gt -#define Perl_pp_i_gt pPerl->Perl_pp_i_gt -#undef pp_i_gt -#define pp_i_gt Perl_pp_i_gt -#undef Perl_pp_i_le -#define Perl_pp_i_le pPerl->Perl_pp_i_le -#undef pp_i_le -#define pp_i_le Perl_pp_i_le -#undef Perl_pp_i_lt -#define Perl_pp_i_lt pPerl->Perl_pp_i_lt -#undef pp_i_lt -#define pp_i_lt Perl_pp_i_lt -#undef Perl_pp_i_modulo -#define Perl_pp_i_modulo pPerl->Perl_pp_i_modulo -#undef pp_i_modulo -#define pp_i_modulo Perl_pp_i_modulo -#undef Perl_pp_i_multiply -#define Perl_pp_i_multiply pPerl->Perl_pp_i_multiply -#undef pp_i_multiply -#define pp_i_multiply Perl_pp_i_multiply -#undef Perl_pp_i_ncmp -#define Perl_pp_i_ncmp pPerl->Perl_pp_i_ncmp -#undef pp_i_ncmp -#define pp_i_ncmp Perl_pp_i_ncmp -#undef Perl_pp_i_ne -#define Perl_pp_i_ne pPerl->Perl_pp_i_ne -#undef pp_i_ne -#define pp_i_ne Perl_pp_i_ne -#undef Perl_pp_i_negate -#define Perl_pp_i_negate pPerl->Perl_pp_i_negate -#undef pp_i_negate -#define pp_i_negate Perl_pp_i_negate -#undef Perl_pp_i_subtract -#define Perl_pp_i_subtract pPerl->Perl_pp_i_subtract -#undef pp_i_subtract -#define pp_i_subtract Perl_pp_i_subtract -#undef Perl_pp_index -#define Perl_pp_index pPerl->Perl_pp_index -#undef pp_index -#define pp_index Perl_pp_index -#undef Perl_pp_int -#define Perl_pp_int pPerl->Perl_pp_int -#undef pp_int -#define pp_int Perl_pp_int -#undef Perl_pp_ioctl -#define Perl_pp_ioctl pPerl->Perl_pp_ioctl -#undef pp_ioctl -#define pp_ioctl Perl_pp_ioctl -#undef Perl_pp_iter -#define Perl_pp_iter pPerl->Perl_pp_iter -#undef pp_iter -#define pp_iter Perl_pp_iter -#undef Perl_pp_join -#define Perl_pp_join pPerl->Perl_pp_join -#undef pp_join -#define pp_join Perl_pp_join -#undef Perl_pp_keys -#define Perl_pp_keys pPerl->Perl_pp_keys -#undef pp_keys -#define pp_keys Perl_pp_keys -#undef Perl_pp_kill -#define Perl_pp_kill pPerl->Perl_pp_kill -#undef pp_kill -#define pp_kill Perl_pp_kill -#undef Perl_pp_last -#define Perl_pp_last pPerl->Perl_pp_last -#undef pp_last -#define pp_last Perl_pp_last -#undef Perl_pp_lc -#define Perl_pp_lc pPerl->Perl_pp_lc -#undef pp_lc -#define pp_lc Perl_pp_lc -#undef Perl_pp_lcfirst -#define Perl_pp_lcfirst pPerl->Perl_pp_lcfirst -#undef pp_lcfirst -#define pp_lcfirst Perl_pp_lcfirst -#undef Perl_pp_le -#define Perl_pp_le pPerl->Perl_pp_le -#undef pp_le -#define pp_le Perl_pp_le -#undef Perl_pp_leave -#define Perl_pp_leave pPerl->Perl_pp_leave -#undef pp_leave -#define pp_leave Perl_pp_leave -#undef Perl_pp_leaveeval -#define Perl_pp_leaveeval pPerl->Perl_pp_leaveeval -#undef pp_leaveeval -#define pp_leaveeval Perl_pp_leaveeval -#undef Perl_pp_leaveloop -#define Perl_pp_leaveloop pPerl->Perl_pp_leaveloop -#undef pp_leaveloop -#define pp_leaveloop Perl_pp_leaveloop -#undef Perl_pp_leavesub -#define Perl_pp_leavesub pPerl->Perl_pp_leavesub -#undef pp_leavesub -#define pp_leavesub Perl_pp_leavesub -#undef Perl_pp_leavesublv -#define Perl_pp_leavesublv pPerl->Perl_pp_leavesublv -#undef pp_leavesublv -#define pp_leavesublv Perl_pp_leavesublv -#undef Perl_pp_leavetry -#define Perl_pp_leavetry pPerl->Perl_pp_leavetry -#undef pp_leavetry -#define pp_leavetry Perl_pp_leavetry -#undef Perl_pp_leavewrite -#define Perl_pp_leavewrite pPerl->Perl_pp_leavewrite -#undef pp_leavewrite -#define pp_leavewrite Perl_pp_leavewrite -#undef Perl_pp_left_shift -#define Perl_pp_left_shift pPerl->Perl_pp_left_shift -#undef pp_left_shift -#define pp_left_shift Perl_pp_left_shift -#undef Perl_pp_length -#define Perl_pp_length pPerl->Perl_pp_length -#undef pp_length -#define pp_length Perl_pp_length -#undef Perl_pp_lineseq -#define Perl_pp_lineseq pPerl->Perl_pp_lineseq -#undef pp_lineseq -#define pp_lineseq Perl_pp_lineseq -#undef Perl_pp_link -#define Perl_pp_link pPerl->Perl_pp_link -#undef pp_link -#define pp_link Perl_pp_link -#undef Perl_pp_list -#define Perl_pp_list pPerl->Perl_pp_list -#undef pp_list -#define pp_list Perl_pp_list -#undef Perl_pp_listen -#define Perl_pp_listen pPerl->Perl_pp_listen -#undef pp_listen -#define pp_listen Perl_pp_listen -#undef Perl_pp_localtime -#define Perl_pp_localtime pPerl->Perl_pp_localtime -#undef pp_localtime -#define pp_localtime Perl_pp_localtime -#undef Perl_pp_lock -#define Perl_pp_lock pPerl->Perl_pp_lock -#undef pp_lock -#define pp_lock Perl_pp_lock -#undef Perl_pp_log -#define Perl_pp_log pPerl->Perl_pp_log -#undef pp_log -#define pp_log Perl_pp_log -#undef Perl_pp_lslice -#define Perl_pp_lslice pPerl->Perl_pp_lslice -#undef pp_lslice -#define pp_lslice Perl_pp_lslice -#undef Perl_pp_lstat -#define Perl_pp_lstat pPerl->Perl_pp_lstat -#undef pp_lstat -#define pp_lstat Perl_pp_lstat -#undef Perl_pp_lt -#define Perl_pp_lt pPerl->Perl_pp_lt -#undef pp_lt -#define pp_lt Perl_pp_lt -#undef Perl_pp_mapstart -#define Perl_pp_mapstart pPerl->Perl_pp_mapstart -#undef pp_mapstart -#define pp_mapstart Perl_pp_mapstart -#undef Perl_pp_mapwhile -#define Perl_pp_mapwhile pPerl->Perl_pp_mapwhile -#undef pp_mapwhile -#define pp_mapwhile Perl_pp_mapwhile -#undef Perl_pp_match -#define Perl_pp_match pPerl->Perl_pp_match -#undef pp_match -#define pp_match Perl_pp_match -#undef Perl_pp_method -#define Perl_pp_method pPerl->Perl_pp_method -#undef pp_method -#define pp_method Perl_pp_method -#undef Perl_pp_method_named -#define Perl_pp_method_named pPerl->Perl_pp_method_named -#undef pp_method_named -#define pp_method_named Perl_pp_method_named -#undef Perl_pp_mkdir -#define Perl_pp_mkdir pPerl->Perl_pp_mkdir -#undef pp_mkdir -#define pp_mkdir Perl_pp_mkdir -#undef Perl_pp_modulo -#define Perl_pp_modulo pPerl->Perl_pp_modulo -#undef pp_modulo -#define pp_modulo Perl_pp_modulo -#undef Perl_pp_msgctl -#define Perl_pp_msgctl pPerl->Perl_pp_msgctl -#undef pp_msgctl -#define pp_msgctl Perl_pp_msgctl -#undef Perl_pp_msgget -#define Perl_pp_msgget pPerl->Perl_pp_msgget -#undef pp_msgget -#define pp_msgget Perl_pp_msgget -#undef Perl_pp_msgrcv -#define Perl_pp_msgrcv pPerl->Perl_pp_msgrcv -#undef pp_msgrcv -#define pp_msgrcv Perl_pp_msgrcv -#undef Perl_pp_msgsnd -#define Perl_pp_msgsnd pPerl->Perl_pp_msgsnd -#undef pp_msgsnd -#define pp_msgsnd Perl_pp_msgsnd -#undef Perl_pp_multiply -#define Perl_pp_multiply pPerl->Perl_pp_multiply -#undef pp_multiply -#define pp_multiply Perl_pp_multiply -#undef Perl_pp_ncmp -#define Perl_pp_ncmp pPerl->Perl_pp_ncmp -#undef pp_ncmp -#define pp_ncmp Perl_pp_ncmp -#undef Perl_pp_ne -#define Perl_pp_ne pPerl->Perl_pp_ne -#undef pp_ne -#define pp_ne Perl_pp_ne -#undef Perl_pp_negate -#define Perl_pp_negate pPerl->Perl_pp_negate -#undef pp_negate -#define pp_negate Perl_pp_negate -#undef Perl_pp_next -#define Perl_pp_next pPerl->Perl_pp_next -#undef pp_next -#define pp_next Perl_pp_next -#undef Perl_pp_nextstate -#define Perl_pp_nextstate pPerl->Perl_pp_nextstate -#undef pp_nextstate -#define pp_nextstate Perl_pp_nextstate -#undef Perl_pp_not -#define Perl_pp_not pPerl->Perl_pp_not -#undef pp_not -#define pp_not Perl_pp_not -#undef Perl_pp_null -#define Perl_pp_null pPerl->Perl_pp_null -#undef pp_null -#define pp_null Perl_pp_null -#undef Perl_pp_oct -#define Perl_pp_oct pPerl->Perl_pp_oct -#undef pp_oct -#define pp_oct Perl_pp_oct -#undef Perl_pp_open -#define Perl_pp_open pPerl->Perl_pp_open -#undef pp_open -#define pp_open Perl_pp_open -#undef Perl_pp_open_dir -#define Perl_pp_open_dir pPerl->Perl_pp_open_dir -#undef pp_open_dir -#define pp_open_dir Perl_pp_open_dir -#undef Perl_pp_or -#define Perl_pp_or pPerl->Perl_pp_or -#undef pp_or -#define pp_or Perl_pp_or -#undef Perl_pp_orassign -#define Perl_pp_orassign pPerl->Perl_pp_orassign -#undef pp_orassign -#define pp_orassign Perl_pp_orassign -#undef Perl_pp_ord -#define Perl_pp_ord pPerl->Perl_pp_ord -#undef pp_ord -#define pp_ord Perl_pp_ord -#undef Perl_pp_pack -#define Perl_pp_pack pPerl->Perl_pp_pack -#undef pp_pack -#define pp_pack Perl_pp_pack -#undef Perl_pp_padany -#define Perl_pp_padany pPerl->Perl_pp_padany -#undef pp_padany -#define pp_padany Perl_pp_padany -#undef Perl_pp_padav -#define Perl_pp_padav pPerl->Perl_pp_padav -#undef pp_padav -#define pp_padav Perl_pp_padav -#undef Perl_pp_padhv -#define Perl_pp_padhv pPerl->Perl_pp_padhv -#undef pp_padhv -#define pp_padhv Perl_pp_padhv -#undef Perl_pp_padsv -#define Perl_pp_padsv pPerl->Perl_pp_padsv -#undef pp_padsv -#define pp_padsv Perl_pp_padsv -#undef Perl_pp_pipe_op -#define Perl_pp_pipe_op pPerl->Perl_pp_pipe_op -#undef pp_pipe_op -#define pp_pipe_op Perl_pp_pipe_op -#undef Perl_pp_pop -#define Perl_pp_pop pPerl->Perl_pp_pop -#undef pp_pop -#define pp_pop Perl_pp_pop -#undef Perl_pp_pos -#define Perl_pp_pos pPerl->Perl_pp_pos -#undef pp_pos -#define pp_pos Perl_pp_pos -#undef Perl_pp_postdec -#define Perl_pp_postdec pPerl->Perl_pp_postdec -#undef pp_postdec -#define pp_postdec Perl_pp_postdec -#undef Perl_pp_postinc -#define Perl_pp_postinc pPerl->Perl_pp_postinc -#undef pp_postinc -#define pp_postinc Perl_pp_postinc -#undef Perl_pp_pow -#define Perl_pp_pow pPerl->Perl_pp_pow -#undef pp_pow -#define pp_pow Perl_pp_pow -#undef Perl_pp_predec -#define Perl_pp_predec pPerl->Perl_pp_predec -#undef pp_predec -#define pp_predec Perl_pp_predec -#undef Perl_pp_preinc -#define Perl_pp_preinc pPerl->Perl_pp_preinc -#undef pp_preinc -#define pp_preinc Perl_pp_preinc -#undef Perl_pp_print -#define Perl_pp_print pPerl->Perl_pp_print -#undef pp_print -#define pp_print Perl_pp_print -#undef Perl_pp_prototype -#define Perl_pp_prototype pPerl->Perl_pp_prototype -#undef pp_prototype -#define pp_prototype Perl_pp_prototype -#undef Perl_pp_prtf -#define Perl_pp_prtf pPerl->Perl_pp_prtf -#undef pp_prtf -#define pp_prtf Perl_pp_prtf -#undef Perl_pp_push -#define Perl_pp_push pPerl->Perl_pp_push -#undef pp_push -#define pp_push Perl_pp_push -#undef Perl_pp_pushmark -#define Perl_pp_pushmark pPerl->Perl_pp_pushmark -#undef pp_pushmark -#define pp_pushmark Perl_pp_pushmark -#undef Perl_pp_pushre -#define Perl_pp_pushre pPerl->Perl_pp_pushre -#undef pp_pushre -#define pp_pushre Perl_pp_pushre -#undef Perl_pp_qr -#define Perl_pp_qr pPerl->Perl_pp_qr -#undef pp_qr -#define pp_qr Perl_pp_qr -#undef Perl_pp_quotemeta -#define Perl_pp_quotemeta pPerl->Perl_pp_quotemeta -#undef pp_quotemeta -#define pp_quotemeta Perl_pp_quotemeta -#undef Perl_pp_rand -#define Perl_pp_rand pPerl->Perl_pp_rand -#undef pp_rand -#define pp_rand Perl_pp_rand -#undef Perl_pp_range -#define Perl_pp_range pPerl->Perl_pp_range -#undef pp_range -#define pp_range Perl_pp_range -#undef Perl_pp_rcatline -#define Perl_pp_rcatline pPerl->Perl_pp_rcatline -#undef pp_rcatline -#define pp_rcatline Perl_pp_rcatline -#undef Perl_pp_read -#define Perl_pp_read pPerl->Perl_pp_read -#undef pp_read -#define pp_read Perl_pp_read -#undef Perl_pp_readdir -#define Perl_pp_readdir pPerl->Perl_pp_readdir -#undef pp_readdir -#define pp_readdir Perl_pp_readdir -#undef Perl_pp_readline -#define Perl_pp_readline pPerl->Perl_pp_readline -#undef pp_readline -#define pp_readline Perl_pp_readline -#undef Perl_pp_readlink -#define Perl_pp_readlink pPerl->Perl_pp_readlink -#undef pp_readlink -#define pp_readlink Perl_pp_readlink -#undef Perl_pp_recv -#define Perl_pp_recv pPerl->Perl_pp_recv -#undef pp_recv -#define pp_recv Perl_pp_recv -#undef Perl_pp_redo -#define Perl_pp_redo pPerl->Perl_pp_redo -#undef pp_redo -#define pp_redo Perl_pp_redo -#undef Perl_pp_ref -#define Perl_pp_ref pPerl->Perl_pp_ref -#undef pp_ref -#define pp_ref Perl_pp_ref -#undef Perl_pp_refgen -#define Perl_pp_refgen pPerl->Perl_pp_refgen -#undef pp_refgen -#define pp_refgen Perl_pp_refgen -#undef Perl_pp_regcmaybe -#define Perl_pp_regcmaybe pPerl->Perl_pp_regcmaybe -#undef pp_regcmaybe -#define pp_regcmaybe Perl_pp_regcmaybe -#undef Perl_pp_regcomp -#define Perl_pp_regcomp pPerl->Perl_pp_regcomp -#undef pp_regcomp -#define pp_regcomp Perl_pp_regcomp -#undef Perl_pp_regcreset -#define Perl_pp_regcreset pPerl->Perl_pp_regcreset -#undef pp_regcreset -#define pp_regcreset Perl_pp_regcreset -#undef Perl_pp_rename -#define Perl_pp_rename pPerl->Perl_pp_rename -#undef pp_rename -#define pp_rename Perl_pp_rename -#undef Perl_pp_repeat -#define Perl_pp_repeat pPerl->Perl_pp_repeat -#undef pp_repeat -#define pp_repeat Perl_pp_repeat -#undef Perl_pp_require -#define Perl_pp_require pPerl->Perl_pp_require -#undef pp_require -#define pp_require Perl_pp_require -#undef Perl_pp_reset -#define Perl_pp_reset pPerl->Perl_pp_reset -#undef pp_reset -#define pp_reset Perl_pp_reset -#undef Perl_pp_return -#define Perl_pp_return pPerl->Perl_pp_return -#undef pp_return -#define pp_return Perl_pp_return -#undef Perl_pp_reverse -#define Perl_pp_reverse pPerl->Perl_pp_reverse -#undef pp_reverse -#define pp_reverse Perl_pp_reverse -#undef Perl_pp_rewinddir -#define Perl_pp_rewinddir pPerl->Perl_pp_rewinddir -#undef pp_rewinddir -#define pp_rewinddir Perl_pp_rewinddir -#undef Perl_pp_right_shift -#define Perl_pp_right_shift pPerl->Perl_pp_right_shift -#undef pp_right_shift -#define pp_right_shift Perl_pp_right_shift -#undef Perl_pp_rindex -#define Perl_pp_rindex pPerl->Perl_pp_rindex -#undef pp_rindex -#define pp_rindex Perl_pp_rindex -#undef Perl_pp_rmdir -#define Perl_pp_rmdir pPerl->Perl_pp_rmdir -#undef pp_rmdir -#define pp_rmdir Perl_pp_rmdir -#undef Perl_pp_rv2av -#define Perl_pp_rv2av pPerl->Perl_pp_rv2av -#undef pp_rv2av -#define pp_rv2av Perl_pp_rv2av -#undef Perl_pp_rv2cv -#define Perl_pp_rv2cv pPerl->Perl_pp_rv2cv -#undef pp_rv2cv -#define pp_rv2cv Perl_pp_rv2cv -#undef Perl_pp_rv2gv -#define Perl_pp_rv2gv pPerl->Perl_pp_rv2gv -#undef pp_rv2gv -#define pp_rv2gv Perl_pp_rv2gv -#undef Perl_pp_rv2hv -#define Perl_pp_rv2hv pPerl->Perl_pp_rv2hv -#undef pp_rv2hv -#define pp_rv2hv Perl_pp_rv2hv -#undef Perl_pp_rv2sv -#define Perl_pp_rv2sv pPerl->Perl_pp_rv2sv -#undef pp_rv2sv -#define pp_rv2sv Perl_pp_rv2sv -#undef Perl_pp_sassign -#define Perl_pp_sassign pPerl->Perl_pp_sassign -#undef pp_sassign -#define pp_sassign Perl_pp_sassign -#undef Perl_pp_scalar -#define Perl_pp_scalar pPerl->Perl_pp_scalar -#undef pp_scalar -#define pp_scalar Perl_pp_scalar -#undef Perl_pp_schomp -#define Perl_pp_schomp pPerl->Perl_pp_schomp -#undef pp_schomp -#define pp_schomp Perl_pp_schomp -#undef Perl_pp_schop -#define Perl_pp_schop pPerl->Perl_pp_schop -#undef pp_schop -#define pp_schop Perl_pp_schop -#undef Perl_pp_scmp -#define Perl_pp_scmp pPerl->Perl_pp_scmp -#undef pp_scmp -#define pp_scmp Perl_pp_scmp -#undef Perl_pp_scope -#define Perl_pp_scope pPerl->Perl_pp_scope -#undef pp_scope -#define pp_scope Perl_pp_scope -#undef Perl_pp_seek -#define Perl_pp_seek pPerl->Perl_pp_seek -#undef pp_seek -#define pp_seek Perl_pp_seek -#undef Perl_pp_seekdir -#define Perl_pp_seekdir pPerl->Perl_pp_seekdir -#undef pp_seekdir -#define pp_seekdir Perl_pp_seekdir -#undef Perl_pp_select -#define Perl_pp_select pPerl->Perl_pp_select -#undef pp_select -#define pp_select Perl_pp_select -#undef Perl_pp_semctl -#define Perl_pp_semctl pPerl->Perl_pp_semctl -#undef pp_semctl -#define pp_semctl Perl_pp_semctl -#undef Perl_pp_semget -#define Perl_pp_semget pPerl->Perl_pp_semget -#undef pp_semget -#define pp_semget Perl_pp_semget -#undef Perl_pp_semop -#define Perl_pp_semop pPerl->Perl_pp_semop -#undef pp_semop -#define pp_semop Perl_pp_semop -#undef Perl_pp_send -#define Perl_pp_send pPerl->Perl_pp_send -#undef pp_send -#define pp_send Perl_pp_send -#undef Perl_pp_seq -#define Perl_pp_seq pPerl->Perl_pp_seq -#undef pp_seq -#define pp_seq Perl_pp_seq -#undef Perl_pp_setpgrp -#define Perl_pp_setpgrp pPerl->Perl_pp_setpgrp -#undef pp_setpgrp -#define pp_setpgrp Perl_pp_setpgrp -#undef Perl_pp_setpriority -#define Perl_pp_setpriority pPerl->Perl_pp_setpriority -#undef pp_setpriority -#define pp_setpriority Perl_pp_setpriority -#undef Perl_pp_setstate -#define Perl_pp_setstate pPerl->Perl_pp_setstate -#undef pp_setstate -#define pp_setstate Perl_pp_setstate -#undef Perl_pp_sge -#define Perl_pp_sge pPerl->Perl_pp_sge -#undef pp_sge -#define pp_sge Perl_pp_sge -#undef Perl_pp_sgrent -#define Perl_pp_sgrent pPerl->Perl_pp_sgrent -#undef pp_sgrent -#define pp_sgrent Perl_pp_sgrent -#undef Perl_pp_sgt -#define Perl_pp_sgt pPerl->Perl_pp_sgt -#undef pp_sgt -#define pp_sgt Perl_pp_sgt -#undef Perl_pp_shift -#define Perl_pp_shift pPerl->Perl_pp_shift -#undef pp_shift -#define pp_shift Perl_pp_shift -#undef Perl_pp_shmctl -#define Perl_pp_shmctl pPerl->Perl_pp_shmctl -#undef pp_shmctl -#define pp_shmctl Perl_pp_shmctl -#undef Perl_pp_shmget -#define Perl_pp_shmget pPerl->Perl_pp_shmget -#undef pp_shmget -#define pp_shmget Perl_pp_shmget -#undef Perl_pp_shmread -#define Perl_pp_shmread pPerl->Perl_pp_shmread -#undef pp_shmread -#define pp_shmread Perl_pp_shmread -#undef Perl_pp_shmwrite -#define Perl_pp_shmwrite pPerl->Perl_pp_shmwrite -#undef pp_shmwrite -#define pp_shmwrite Perl_pp_shmwrite -#undef Perl_pp_shostent -#define Perl_pp_shostent pPerl->Perl_pp_shostent -#undef pp_shostent -#define pp_shostent Perl_pp_shostent -#undef Perl_pp_shutdown -#define Perl_pp_shutdown pPerl->Perl_pp_shutdown -#undef pp_shutdown -#define pp_shutdown Perl_pp_shutdown -#undef Perl_pp_sin -#define Perl_pp_sin pPerl->Perl_pp_sin -#undef pp_sin -#define pp_sin Perl_pp_sin -#undef Perl_pp_sle -#define Perl_pp_sle pPerl->Perl_pp_sle -#undef pp_sle -#define pp_sle Perl_pp_sle -#undef Perl_pp_sleep -#define Perl_pp_sleep pPerl->Perl_pp_sleep -#undef pp_sleep -#define pp_sleep Perl_pp_sleep -#undef Perl_pp_slt -#define Perl_pp_slt pPerl->Perl_pp_slt -#undef pp_slt -#define pp_slt Perl_pp_slt -#undef Perl_pp_sne -#define Perl_pp_sne pPerl->Perl_pp_sne -#undef pp_sne -#define pp_sne Perl_pp_sne -#undef Perl_pp_snetent -#define Perl_pp_snetent pPerl->Perl_pp_snetent -#undef pp_snetent -#define pp_snetent Perl_pp_snetent -#undef Perl_pp_socket -#define Perl_pp_socket pPerl->Perl_pp_socket -#undef pp_socket -#define pp_socket Perl_pp_socket -#undef Perl_pp_sockpair -#define Perl_pp_sockpair pPerl->Perl_pp_sockpair -#undef pp_sockpair -#define pp_sockpair Perl_pp_sockpair -#undef Perl_pp_sort -#define Perl_pp_sort pPerl->Perl_pp_sort -#undef pp_sort -#define pp_sort Perl_pp_sort -#undef Perl_pp_splice -#define Perl_pp_splice pPerl->Perl_pp_splice -#undef pp_splice -#define pp_splice Perl_pp_splice -#undef Perl_pp_split -#define Perl_pp_split pPerl->Perl_pp_split -#undef pp_split -#define pp_split Perl_pp_split -#undef Perl_pp_sprintf -#define Perl_pp_sprintf pPerl->Perl_pp_sprintf -#undef pp_sprintf -#define pp_sprintf Perl_pp_sprintf -#undef Perl_pp_sprotoent -#define Perl_pp_sprotoent pPerl->Perl_pp_sprotoent -#undef pp_sprotoent -#define pp_sprotoent Perl_pp_sprotoent -#undef Perl_pp_spwent -#define Perl_pp_spwent pPerl->Perl_pp_spwent -#undef pp_spwent -#define pp_spwent Perl_pp_spwent -#undef Perl_pp_sqrt -#define Perl_pp_sqrt pPerl->Perl_pp_sqrt -#undef pp_sqrt -#define pp_sqrt Perl_pp_sqrt -#undef Perl_pp_srand -#define Perl_pp_srand pPerl->Perl_pp_srand -#undef pp_srand -#define pp_srand Perl_pp_srand -#undef Perl_pp_srefgen -#define Perl_pp_srefgen pPerl->Perl_pp_srefgen -#undef pp_srefgen -#define pp_srefgen Perl_pp_srefgen -#undef Perl_pp_sselect -#define Perl_pp_sselect pPerl->Perl_pp_sselect -#undef pp_sselect -#define pp_sselect Perl_pp_sselect -#undef Perl_pp_sservent -#define Perl_pp_sservent pPerl->Perl_pp_sservent -#undef pp_sservent -#define pp_sservent Perl_pp_sservent -#undef Perl_pp_ssockopt -#define Perl_pp_ssockopt pPerl->Perl_pp_ssockopt -#undef pp_ssockopt -#define pp_ssockopt Perl_pp_ssockopt -#undef Perl_pp_stat -#define Perl_pp_stat pPerl->Perl_pp_stat -#undef pp_stat -#define pp_stat Perl_pp_stat -#undef Perl_pp_stringify -#define Perl_pp_stringify pPerl->Perl_pp_stringify -#undef pp_stringify -#define pp_stringify Perl_pp_stringify -#undef Perl_pp_stub -#define Perl_pp_stub pPerl->Perl_pp_stub -#undef pp_stub -#define pp_stub Perl_pp_stub -#undef Perl_pp_study -#define Perl_pp_study pPerl->Perl_pp_study -#undef pp_study -#define pp_study Perl_pp_study -#undef Perl_pp_subst -#define Perl_pp_subst pPerl->Perl_pp_subst -#undef pp_subst -#define pp_subst Perl_pp_subst -#undef Perl_pp_substcont -#define Perl_pp_substcont pPerl->Perl_pp_substcont -#undef pp_substcont -#define pp_substcont Perl_pp_substcont -#undef Perl_pp_substr -#define Perl_pp_substr pPerl->Perl_pp_substr -#undef pp_substr -#define pp_substr Perl_pp_substr -#undef Perl_pp_subtract -#define Perl_pp_subtract pPerl->Perl_pp_subtract -#undef pp_subtract -#define pp_subtract Perl_pp_subtract -#undef Perl_pp_symlink -#define Perl_pp_symlink pPerl->Perl_pp_symlink -#undef pp_symlink -#define pp_symlink Perl_pp_symlink -#undef Perl_pp_syscall -#define Perl_pp_syscall pPerl->Perl_pp_syscall -#undef pp_syscall -#define pp_syscall Perl_pp_syscall -#undef Perl_pp_sysopen -#define Perl_pp_sysopen pPerl->Perl_pp_sysopen -#undef pp_sysopen -#define pp_sysopen Perl_pp_sysopen -#undef Perl_pp_sysread -#define Perl_pp_sysread pPerl->Perl_pp_sysread -#undef pp_sysread -#define pp_sysread Perl_pp_sysread -#undef Perl_pp_sysseek -#define Perl_pp_sysseek pPerl->Perl_pp_sysseek -#undef pp_sysseek -#define pp_sysseek Perl_pp_sysseek -#undef Perl_pp_system -#define Perl_pp_system pPerl->Perl_pp_system -#undef pp_system -#define pp_system Perl_pp_system -#undef Perl_pp_syswrite -#define Perl_pp_syswrite pPerl->Perl_pp_syswrite -#undef pp_syswrite -#define pp_syswrite Perl_pp_syswrite -#undef Perl_pp_tell -#define Perl_pp_tell pPerl->Perl_pp_tell -#undef pp_tell -#define pp_tell Perl_pp_tell -#undef Perl_pp_telldir -#define Perl_pp_telldir pPerl->Perl_pp_telldir -#undef pp_telldir -#define pp_telldir Perl_pp_telldir -#undef Perl_pp_threadsv -#define Perl_pp_threadsv pPerl->Perl_pp_threadsv -#undef pp_threadsv -#define pp_threadsv Perl_pp_threadsv -#undef Perl_pp_tie -#define Perl_pp_tie pPerl->Perl_pp_tie -#undef pp_tie -#define pp_tie Perl_pp_tie -#undef Perl_pp_tied -#define Perl_pp_tied pPerl->Perl_pp_tied -#undef pp_tied -#define pp_tied Perl_pp_tied -#undef Perl_pp_time -#define Perl_pp_time pPerl->Perl_pp_time -#undef pp_time -#define pp_time Perl_pp_time -#undef Perl_pp_tms -#define Perl_pp_tms pPerl->Perl_pp_tms -#undef pp_tms -#define pp_tms Perl_pp_tms -#undef Perl_pp_trans -#define Perl_pp_trans pPerl->Perl_pp_trans -#undef pp_trans -#define pp_trans Perl_pp_trans -#undef Perl_pp_truncate -#define Perl_pp_truncate pPerl->Perl_pp_truncate -#undef pp_truncate -#define pp_truncate Perl_pp_truncate -#undef Perl_pp_uc -#define Perl_pp_uc pPerl->Perl_pp_uc -#undef pp_uc -#define pp_uc Perl_pp_uc -#undef Perl_pp_ucfirst -#define Perl_pp_ucfirst pPerl->Perl_pp_ucfirst -#undef pp_ucfirst -#define pp_ucfirst Perl_pp_ucfirst -#undef Perl_pp_umask -#define Perl_pp_umask pPerl->Perl_pp_umask -#undef pp_umask -#define pp_umask Perl_pp_umask -#undef Perl_pp_undef -#define Perl_pp_undef pPerl->Perl_pp_undef -#undef pp_undef -#define pp_undef Perl_pp_undef -#undef Perl_pp_unlink -#define Perl_pp_unlink pPerl->Perl_pp_unlink -#undef pp_unlink -#define pp_unlink Perl_pp_unlink -#undef Perl_pp_unpack -#define Perl_pp_unpack pPerl->Perl_pp_unpack -#undef pp_unpack -#define pp_unpack Perl_pp_unpack -#undef Perl_pp_unshift -#define Perl_pp_unshift pPerl->Perl_pp_unshift -#undef pp_unshift -#define pp_unshift Perl_pp_unshift -#undef Perl_pp_unstack -#define Perl_pp_unstack pPerl->Perl_pp_unstack -#undef pp_unstack -#define pp_unstack Perl_pp_unstack -#undef Perl_pp_untie -#define Perl_pp_untie pPerl->Perl_pp_untie -#undef pp_untie -#define pp_untie Perl_pp_untie -#undef Perl_pp_utime -#define Perl_pp_utime pPerl->Perl_pp_utime -#undef pp_utime -#define pp_utime Perl_pp_utime -#undef Perl_pp_values -#define Perl_pp_values pPerl->Perl_pp_values -#undef pp_values -#define pp_values Perl_pp_values -#undef Perl_pp_vec -#define Perl_pp_vec pPerl->Perl_pp_vec -#undef pp_vec -#define pp_vec Perl_pp_vec -#undef Perl_pp_wait -#define Perl_pp_wait pPerl->Perl_pp_wait -#undef pp_wait -#define pp_wait Perl_pp_wait -#undef Perl_pp_waitpid -#define Perl_pp_waitpid pPerl->Perl_pp_waitpid -#undef pp_waitpid -#define pp_waitpid Perl_pp_waitpid -#undef Perl_pp_wantarray -#define Perl_pp_wantarray pPerl->Perl_pp_wantarray -#undef pp_wantarray -#define pp_wantarray Perl_pp_wantarray -#undef Perl_pp_warn -#define Perl_pp_warn pPerl->Perl_pp_warn -#undef pp_warn -#define pp_warn Perl_pp_warn -#undef Perl_pp_xor -#define Perl_pp_xor pPerl->Perl_pp_xor -#undef pp_xor -#define pp_xor Perl_pp_xor #endif /* PERL_CORE && PERL_OBJECT */ #endif /* __objXSUB_h__ */ diff --git a/op.c b/op.c index f5938c3..02edc8d 100644 --- a/op.c +++ b/op.c @@ -4601,6 +4601,15 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) } /* XXX unsafe for threads if eval_owner isn't held */ +/* +=for apidoc newCONSTSUB + +Creates a constant sub equivalent to Perl C which is +eligible for inlining at compile-time. + +=cut +*/ + void Perl_newCONSTSUB(pTHX_ HV *stash, char *name, SV *sv) { @@ -4635,6 +4644,14 @@ Perl_newCONSTSUB(pTHX_ HV *stash, char *name, SV *sv) LEAVE; } +/* +=for apidoc U||newXS + +Used by C to hook up XSUBs as Perl subs. + +=cut +*/ + CV * Perl_newXS(pTHX_ char *name, XSUBADDR_t subaddr, char *filename) { diff --git a/op.h b/op.h index 91cdb6b..fc38b9c 100644 --- a/op.h +++ b/op.h @@ -52,6 +52,20 @@ typedef U32 PADOFFSET; ((op)->op_flags & OPf_WANT) == OPf_WANT_LIST ? G_ARRAY : \ dfl) +/* +=for apidoc Amn|U32|GIMME_V +The XSUB-writer's equivalent to Perl's C. Returns C, +C or C for void, scalar or array context, +respectively. + +=for apidoc Amn|U32|GIMME +A backward-compatible version of C which can only return +C or C; in a void context, it returns C. +Deprecated. Use C instead. + +=cut +*/ + #define GIMME_V OP_GIMME(PL_op, block_gimme()) /* Public flags */ @@ -85,6 +99,7 @@ typedef U32 PADOFFSET; /* old names; don't use in new code, but don't break them, either */ #define OPf_LIST OPf_WANT_LIST #define OPf_KNOW OPf_WANT + #define GIMME \ (PL_op->op_flags & OPf_WANT \ ? ((PL_op->op_flags & OPf_WANT) == OPf_WANT_LIST \ diff --git a/perl.c b/perl.c index 7f1e3f6..3153f59 100644 --- a/perl.c +++ b/perl.c @@ -86,6 +86,15 @@ perl_alloc_using(struct IPerlMem* ipM, struct IPerlMem* ipMS, return my_perl; } #else + +/* +=for apidoc perl_alloc + +Allocates a new Perl interpreter. See L. + +=cut +*/ + PerlInterpreter * perl_alloc(void) { @@ -99,6 +108,14 @@ perl_alloc(void) } #endif /* PERL_IMPLICIT_SYS */ +/* +=for apidoc perl_construct + +Initializes a new Perl interpreter. See L. + +=cut +*/ + void perl_construct(pTHXx) { @@ -239,6 +256,14 @@ perl_construct(pTHXx) ENTER; } +/* +=for apidoc perl_destruct + +Shuts down a Perl interpreter. See L. + +=cut +*/ + void perl_destruct(pTHXx) { @@ -664,6 +689,14 @@ perl_destruct(pTHXx) } } +/* +=for apidoc perl_free + +Releases a Perl interpreter. See L. + +=cut +*/ + void perl_free(pTHXx) { @@ -683,6 +716,14 @@ Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr) ++PL_exitlistlen; } +/* +=for apidoc perl_parse + +Tells a Perl interpreter to parse a Perl script. See L. + +=cut +*/ + int perl_parse(pTHXx_ XSINIT_t xsinit, int argc, char **argv, char **env) { @@ -1152,6 +1193,14 @@ print \" \\@INC:\\n @INC\\n\";"); return NULL; } +/* +=for apidoc perl_run + +Tells a Perl interpreter to run. See L. + +=cut +*/ + int perl_run(pTHXx) { @@ -1241,6 +1290,16 @@ S_run_body(pTHX_ va_list args) return NULL; } +/* +=for apidoc p||get_sv + +Returns the SV of the specified Perl scalar. If C is set and the +Perl variable does not exist then it will be created. If C is not +set and the variable does not exist then NULL is returned. + +=cut +*/ + SV* Perl_get_sv(pTHX_ const char *name, I32 create) { @@ -1260,6 +1319,16 @@ Perl_get_sv(pTHX_ const char *name, I32 create) return Nullsv; } +/* +=for apidoc p||get_av + +Returns the AV of the specified Perl array. If C is set and the +Perl variable does not exist then it will be created. If C is not +set and the variable does not exist then NULL is returned. + +=cut +*/ + AV* Perl_get_av(pTHX_ const char *name, I32 create) { @@ -1271,6 +1340,16 @@ Perl_get_av(pTHX_ const char *name, I32 create) return Nullav; } +/* +=for apidoc p||get_hv + +Returns the HV of the specified Perl hash. If C is set and the +Perl variable does not exist then it will be created. If C is not +set and the variable does not exist then NULL is returned. + +=cut +*/ + HV* Perl_get_hv(pTHX_ const char *name, I32 create) { @@ -1282,6 +1361,17 @@ Perl_get_hv(pTHX_ const char *name, I32 create) return Nullhv; } +/* +=for apidoc p||get_cv + +Returns the CV of the specified Perl subroutine. If C is set and +the Perl subroutine does not exist then it will be declared (which has the +same effect as saying C). If C is not set and the +subroutine does not exist then NULL is returned. + +=cut +*/ + CV* Perl_get_cv(pTHX_ const char *name, I32 create) { @@ -1302,6 +1392,14 @@ Perl_get_cv(pTHX_ const char *name, I32 create) /* Be sure to refetch the stack pointer after calling these routines. */ +/* +=for apidoc p||call_argv + +Performs a callback to the specified Perl sub. See L. + +=cut +*/ + I32 Perl_call_argv(pTHX_ const char *sub_name, I32 flags, register char **argv) @@ -1321,6 +1419,14 @@ Perl_call_argv(pTHX_ const char *sub_name, I32 flags, register char **argv) return call_pv(sub_name, flags); } +/* +=for apidoc p||call_pv + +Performs a callback to the specified Perl sub. See L. + +=cut +*/ + I32 Perl_call_pv(pTHX_ const char *sub_name, I32 flags) /* name of the subroutine */ @@ -1329,6 +1435,15 @@ Perl_call_pv(pTHX_ const char *sub_name, I32 flags) return call_sv((SV*)get_cv(sub_name, TRUE), flags); } +/* +=for apidoc p||call_method + +Performs a callback to the specified Perl method. The blessed object must +be on the stack. See L. + +=cut +*/ + I32 Perl_call_method(pTHX_ const char *methname, I32 flags) /* name of the subroutine */ @@ -1347,6 +1462,15 @@ Perl_call_method(pTHX_ const char *methname, I32 flags) } /* May be called with any of a CV, a GV, or an SV containing the name. */ +/* +=for apidoc p||call_sv + +Performs a callback to the Perl sub whose name is in the SV. See +L. + +=cut +*/ + I32 Perl_call_sv(pTHX_ SV *sv, I32 flags) @@ -1509,6 +1633,14 @@ S_call_xbody(pTHX_ OP *myop, int is_eval) /* Eval a string. The G_EVAL flag is always assumed. */ +/* +=for apidoc p||eval_sv + +Tells Perl to C the string in the SV. + +=cut +*/ + I32 Perl_eval_sv(pTHX_ SV *sv, I32 flags) @@ -1591,6 +1723,14 @@ Perl_eval_sv(pTHX_ SV *sv, I32 flags) return retval; } +/* +=for apidoc p||eval_pv + +Tells Perl to C the given string and return an SV* result. + +=cut +*/ + SV* Perl_eval_pv(pTHX_ const char *p, I32 croak_on_error) { @@ -1615,6 +1755,14 @@ Perl_eval_pv(pTHX_ const char *p, I32 croak_on_error) /* Require a module. */ +/* +=for apidoc p||require_pv + +Tells Perl to C a module. + +=cut +*/ + void Perl_require_pv(pTHX_ const char *pv) { diff --git a/perlapi.c b/perlapi.c index b28c4b5..f9b37aa 100644 --- a/perlapi.c +++ b/perlapi.c @@ -83,27 +83,6 @@ Perl_Gv_AMupdate(pTHXo_ HV* stash) return ((CPerlObj*)pPerl)->Perl_Gv_AMupdate(stash); } -#undef Perl_append_elem -OP* -Perl_append_elem(pTHXo_ I32 optype, OP* head, OP* tail) -{ - return ((CPerlObj*)pPerl)->Perl_append_elem(optype, head, tail); -} - -#undef Perl_append_list -OP* -Perl_append_list(pTHXo_ I32 optype, LISTOP* first, LISTOP* last) -{ - return ((CPerlObj*)pPerl)->Perl_append_list(optype, first, last); -} - -#undef Perl_apply -I32 -Perl_apply(pTHXo_ I32 type, SV** mark, SV** sp) -{ - return ((CPerlObj*)pPerl)->Perl_apply(type, mark, sp); -} - #undef Perl_avhv_delete_ent SV* Perl_avhv_delete_ent(pTHXo_ AV *ar, SV* keysv, I32 flags, U32 hash) @@ -258,20 +237,6 @@ Perl_av_unshift(pTHXo_ AV* ar, I32 num) ((CPerlObj*)pPerl)->Perl_av_unshift(ar, num); } -#undef Perl_bind_match -OP* -Perl_bind_match(pTHXo_ I32 type, OP* left, OP* pat) -{ - return ((CPerlObj*)pPerl)->Perl_bind_match(type, left, pat); -} - -#undef Perl_block_end -OP* -Perl_block_end(pTHXo_ I32 floor, OP* seq) -{ - return ((CPerlObj*)pPerl)->Perl_block_end(floor, seq); -} - #undef Perl_block_gimme I32 Perl_block_gimme(pTHXo) @@ -279,34 +244,6 @@ Perl_block_gimme(pTHXo) return ((CPerlObj*)pPerl)->Perl_block_gimme(); } -#undef Perl_block_start -int -Perl_block_start(pTHXo_ int full) -{ - return ((CPerlObj*)pPerl)->Perl_block_start(full); -} - -#undef Perl_boot_core_UNIVERSAL -void -Perl_boot_core_UNIVERSAL(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_boot_core_UNIVERSAL(); -} - -#undef Perl_call_list -void -Perl_call_list(pTHXo_ I32 oldscope, AV* av_list) -{ - ((CPerlObj*)pPerl)->Perl_call_list(oldscope, av_list); -} - -#undef Perl_cando -bool -Perl_cando(pTHXo_ Mode_t mode, Uid_t effective, Stat_t* statbufp) -{ - return ((CPerlObj*)pPerl)->Perl_cando(mode, effective, statbufp); -} - #undef Perl_cast_ulong U32 Perl_cast_ulong(pTHXo_ NV f) @@ -344,22 +281,8 @@ Perl_my_chsize(pTHXo_ int fd, Off_t length) } #endif #if defined(USE_THREADS) - -#undef Perl_condpair_magic -MAGIC* -Perl_condpair_magic(pTHXo_ SV *sv) -{ - return ((CPerlObj*)pPerl)->Perl_condpair_magic(sv); -} #endif -#undef Perl_convert -OP* -Perl_convert(pTHXo_ I32 optype, I32 flags, OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_convert(optype, flags, o); -} - #undef Perl_croak void Perl_croak(pTHXo_ const char* pat, ...) @@ -525,41 +448,6 @@ Perl_sv_setpvf_mg_nocontext(SV* sv, const char* pat, ...) #undef Perl_fprintf_nocontext #endif -#undef Perl_cv_ckproto -void -Perl_cv_ckproto(pTHXo_ CV* cv, GV* gv, char* p) -{ - ((CPerlObj*)pPerl)->Perl_cv_ckproto(cv, gv, p); -} - -#undef Perl_cv_clone -CV* -Perl_cv_clone(pTHXo_ CV* proto) -{ - return ((CPerlObj*)pPerl)->Perl_cv_clone(proto); -} - -#undef Perl_cv_const_sv -SV* -Perl_cv_const_sv(pTHXo_ CV* cv) -{ - return ((CPerlObj*)pPerl)->Perl_cv_const_sv(cv); -} - -#undef Perl_op_const_sv -SV* -Perl_op_const_sv(pTHXo_ OP* o, CV* cv) -{ - return ((CPerlObj*)pPerl)->Perl_op_const_sv(o, cv); -} - -#undef Perl_cv_undef -void -Perl_cv_undef(pTHXo_ CV* cv) -{ - ((CPerlObj*)pPerl)->Perl_cv_undef(cv); -} - #undef Perl_cx_dump void Perl_cx_dump(pTHXo_ PERL_CONTEXT* cs) @@ -602,20 +490,6 @@ Perl_get_op_names(pTHXo) return ((CPerlObj*)pPerl)->Perl_get_op_names(); } -#undef Perl_get_no_modify -char* -Perl_get_no_modify(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_get_no_modify(); -} - -#undef Perl_get_opargs -U32* -Perl_get_opargs(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_get_opargs(); -} - #undef Perl_get_ppaddr PPADDR_t* Perl_get_ppaddr(pTHXo) @@ -623,13 +497,6 @@ Perl_get_ppaddr(pTHXo) return ((CPerlObj*)pPerl)->Perl_get_ppaddr(); } -#undef Perl_cxinc -I32 -Perl_cxinc(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_cxinc(); -} - #undef Perl_deb void Perl_deb(pTHXo_ const char* pat, ...) @@ -682,170 +549,17 @@ Perl_delimcpy(pTHXo_ char* to, char* toend, char* from, char* fromend, int delim return ((CPerlObj*)pPerl)->Perl_delimcpy(to, toend, from, fromend, delim, retlen); } -#undef Perl_deprecate -void -Perl_deprecate(pTHXo_ char* s) -{ - ((CPerlObj*)pPerl)->Perl_deprecate(s); -} - -#undef Perl_die -OP* -Perl_die(pTHXo_ const char* pat, ...) -{ - OP* retval; - va_list args; - va_start(args, pat); - retval = ((CPerlObj*)pPerl)->Perl_vdie(pat, &args); - va_end(args); - return retval; - -} - -#undef Perl_vdie -OP* -Perl_vdie(pTHXo_ const char* pat, va_list* args) -{ - return ((CPerlObj*)pPerl)->Perl_vdie(pat, args); -} - -#undef Perl_die_where -OP* -Perl_die_where(pTHXo_ char* message, STRLEN msglen) -{ - return ((CPerlObj*)pPerl)->Perl_die_where(message, msglen); -} - -#undef Perl_dounwind -void -Perl_dounwind(pTHXo_ I32 cxix) -{ - ((CPerlObj*)pPerl)->Perl_dounwind(cxix); -} - -#undef Perl_do_aexec -bool -Perl_do_aexec(pTHXo_ SV* really, SV** mark, SV** sp) -{ - return ((CPerlObj*)pPerl)->Perl_do_aexec(really, mark, sp); -} - -#undef Perl_do_aexec5 -bool -Perl_do_aexec5(pTHXo_ SV* really, SV** mark, SV** sp, int fd, int flag) -{ - return ((CPerlObj*)pPerl)->Perl_do_aexec5(really, mark, sp, fd, flag); -} - #undef Perl_do_binmode int Perl_do_binmode(pTHXo_ PerlIO *fp, int iotype, int flag) { return ((CPerlObj*)pPerl)->Perl_do_binmode(fp, iotype, flag); } - -#undef Perl_do_chop -void -Perl_do_chop(pTHXo_ SV* asv, SV* sv) -{ - ((CPerlObj*)pPerl)->Perl_do_chop(asv, sv); -} - -#undef Perl_do_close -bool -Perl_do_close(pTHXo_ GV* gv, bool not_implicit) -{ - return ((CPerlObj*)pPerl)->Perl_do_close(gv, not_implicit); -} - -#undef Perl_do_eof -bool -Perl_do_eof(pTHXo_ GV* gv) -{ - return ((CPerlObj*)pPerl)->Perl_do_eof(gv); -} - -#undef Perl_do_exec -bool -Perl_do_exec(pTHXo_ char* cmd) -{ - return ((CPerlObj*)pPerl)->Perl_do_exec(cmd); -} #if !defined(WIN32) - -#undef Perl_do_exec3 -bool -Perl_do_exec3(pTHXo_ char* cmd, int fd, int flag) -{ - return ((CPerlObj*)pPerl)->Perl_do_exec3(cmd, fd, flag); -} #endif - -#undef Perl_do_execfree -void -Perl_do_execfree(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_do_execfree(); -} #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) - -#undef Perl_do_ipcctl -I32 -Perl_do_ipcctl(pTHXo_ I32 optype, SV** mark, SV** sp) -{ - return ((CPerlObj*)pPerl)->Perl_do_ipcctl(optype, mark, sp); -} - -#undef Perl_do_ipcget -I32 -Perl_do_ipcget(pTHXo_ I32 optype, SV** mark, SV** sp) -{ - return ((CPerlObj*)pPerl)->Perl_do_ipcget(optype, mark, sp); -} - -#undef Perl_do_msgrcv -I32 -Perl_do_msgrcv(pTHXo_ SV** mark, SV** sp) -{ - return ((CPerlObj*)pPerl)->Perl_do_msgrcv(mark, sp); -} - -#undef Perl_do_msgsnd -I32 -Perl_do_msgsnd(pTHXo_ SV** mark, SV** sp) -{ - return ((CPerlObj*)pPerl)->Perl_do_msgsnd(mark, sp); -} - -#undef Perl_do_semop -I32 -Perl_do_semop(pTHXo_ SV** mark, SV** sp) -{ - return ((CPerlObj*)pPerl)->Perl_do_semop(mark, sp); -} - -#undef Perl_do_shmio -I32 -Perl_do_shmio(pTHXo_ I32 optype, SV** mark, SV** sp) -{ - return ((CPerlObj*)pPerl)->Perl_do_shmio(optype, mark, sp); -} #endif -#undef Perl_do_join -void -Perl_do_join(pTHXo_ 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(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_do_kv(); -} - #undef Perl_do_open bool Perl_do_open(pTHXo_ GV* gv, char* name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO* supplied_fp) @@ -860,97 +574,6 @@ Perl_do_open9(pTHXo_ GV *gv, char *name, I32 len, int as_raw, int rawmode, int r return ((CPerlObj*)pPerl)->Perl_do_open9(gv, name, len, as_raw, rawmode, rawperm, supplied_fp, svs, num); } -#undef Perl_do_pipe -void -Perl_do_pipe(pTHXo_ SV* sv, GV* rgv, GV* wgv) -{ - ((CPerlObj*)pPerl)->Perl_do_pipe(sv, rgv, wgv); -} - -#undef Perl_do_print -bool -Perl_do_print(pTHXo_ SV* sv, PerlIO* fp) -{ - return ((CPerlObj*)pPerl)->Perl_do_print(sv, fp); -} - -#undef Perl_do_readline -OP* -Perl_do_readline(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_do_readline(); -} - -#undef Perl_do_chomp -I32 -Perl_do_chomp(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_do_chomp(sv); -} - -#undef Perl_do_seek -bool -Perl_do_seek(pTHXo_ GV* gv, Off_t pos, int whence) -{ - return ((CPerlObj*)pPerl)->Perl_do_seek(gv, pos, whence); -} - -#undef Perl_do_sprintf -void -Perl_do_sprintf(pTHXo_ SV* sv, I32 len, SV** sarg) -{ - ((CPerlObj*)pPerl)->Perl_do_sprintf(sv, len, sarg); -} - -#undef Perl_do_sysseek -Off_t -Perl_do_sysseek(pTHXo_ 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(pTHXo_ GV* gv) -{ - return ((CPerlObj*)pPerl)->Perl_do_tell(gv); -} - -#undef Perl_do_trans -I32 -Perl_do_trans(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_do_trans(sv); -} - -#undef Perl_do_vecget -UV -Perl_do_vecget(pTHXo_ SV* sv, I32 offset, I32 size) -{ - return ((CPerlObj*)pPerl)->Perl_do_vecget(sv, offset, size); -} - -#undef Perl_do_vecset -void -Perl_do_vecset(pTHXo_ SV* sv) -{ - ((CPerlObj*)pPerl)->Perl_do_vecset(sv); -} - -#undef Perl_do_vop -void -Perl_do_vop(pTHXo_ I32 optype, SV* sv, SV* left, SV* right) -{ - ((CPerlObj*)pPerl)->Perl_do_vop(optype, sv, left, right); -} - -#undef Perl_dofile -OP* -Perl_dofile(pTHXo_ OP* term) -{ - return ((CPerlObj*)pPerl)->Perl_dofile(term); -} - #undef Perl_dowantarray I32 Perl_dowantarray(pTHXo) @@ -1036,37 +659,9 @@ Perl_fbm_instr(pTHXo_ unsigned char* big, unsigned char* bigend, SV* littlesv, U { return ((CPerlObj*)pPerl)->Perl_fbm_instr(big, bigend, littlesv, flags); } - -#undef Perl_find_script -char* -Perl_find_script(pTHXo_ 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(pTHXo_ const char *name) -{ - return ((CPerlObj*)pPerl)->Perl_find_threadsv(name); -} #endif -#undef Perl_force_list -OP* -Perl_force_list(pTHXo_ OP* arg) -{ - return ((CPerlObj*)pPerl)->Perl_force_list(arg); -} - -#undef Perl_fold_constants -OP* -Perl_fold_constants(pTHXo_ OP* arg) -{ - return ((CPerlObj*)pPerl)->Perl_fold_constants(arg); -} - #undef Perl_form char* Perl_form(pTHXo_ const char* pat, ...) @@ -1093,21 +688,7 @@ Perl_free_tmps(pTHXo) { ((CPerlObj*)pPerl)->Perl_free_tmps(); } - -#undef Perl_gen_constant_list -OP* -Perl_gen_constant_list(pTHXo_ OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_gen_constant_list(o); -} #if !defined(HAS_GETENV_LEN) - -#undef Perl_getenv_len -char* -Perl_getenv_len(pTHXo_ char* key, unsigned long *len) -{ - return ((CPerlObj*)pPerl)->Perl_getenv_len(key, len); -} #endif #undef Perl_gp_free @@ -1404,67 +985,25 @@ Perl_ibcmp_locale(pTHXo_ const char* a, const char* b, I32 len) return ((CPerlObj*)pPerl)->Perl_ibcmp_locale(a, b, len); } -#undef Perl_ingroup -bool -Perl_ingroup(pTHXo_ Gid_t testgid, Uid_t effective) +#undef Perl_instr +char* +Perl_instr(pTHXo_ const char* big, const char* little) { - return ((CPerlObj*)pPerl)->Perl_ingroup(testgid, effective); + return ((CPerlObj*)pPerl)->Perl_instr(big, little); } -#undef Perl_init_debugger -void -Perl_init_debugger(pTHXo) +#undef Perl_is_uni_alnum +bool +Perl_is_uni_alnum(pTHXo_ U32 c) { - ((CPerlObj*)pPerl)->Perl_init_debugger(); + return ((CPerlObj*)pPerl)->Perl_is_uni_alnum(c); } -#undef Perl_init_stacks -void -Perl_init_stacks(pTHXo) +#undef Perl_is_uni_alnumc +bool +Perl_is_uni_alnumc(pTHXo_ U32 c) { - ((CPerlObj*)pPerl)->Perl_init_stacks(); -} - -#undef Perl_intro_my -U32 -Perl_intro_my(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_intro_my(); -} - -#undef Perl_instr -char* -Perl_instr(pTHXo_ const char* big, const char* little) -{ - return ((CPerlObj*)pPerl)->Perl_instr(big, little); -} - -#undef Perl_io_close -bool -Perl_io_close(pTHXo_ IO* io, bool not_implicit) -{ - return ((CPerlObj*)pPerl)->Perl_io_close(io, not_implicit); -} - -#undef Perl_invert -OP* -Perl_invert(pTHXo_ OP* cmd) -{ - return ((CPerlObj*)pPerl)->Perl_invert(cmd); -} - -#undef Perl_is_uni_alnum -bool -Perl_is_uni_alnum(pTHXo_ U32 c) -{ - return ((CPerlObj*)pPerl)->Perl_is_uni_alnum(c); -} - -#undef Perl_is_uni_alnumc -bool -Perl_is_uni_alnumc(pTHXo_ U32 c) -{ - return ((CPerlObj*)pPerl)->Perl_is_uni_alnumc(c); + return ((CPerlObj*)pPerl)->Perl_is_uni_alnumc(c); } #undef Perl_is_uni_idfirst @@ -1796,6058 +1335,2305 @@ Perl_is_utf8_mark(pTHXo_ U8 *p) return ((CPerlObj*)pPerl)->Perl_is_utf8_mark(p); } -#undef Perl_jmaybe -OP* -Perl_jmaybe(pTHXo_ OP* arg) -{ - return ((CPerlObj*)pPerl)->Perl_jmaybe(arg); -} - -#undef Perl_keyword +#undef Perl_looks_like_number I32 -Perl_keyword(pTHXo_ char* d, I32 len) -{ - return ((CPerlObj*)pPerl)->Perl_keyword(d, len); -} - -#undef Perl_leave_scope -void -Perl_leave_scope(pTHXo_ I32 base) +Perl_looks_like_number(pTHXo_ SV* sv) { - ((CPerlObj*)pPerl)->Perl_leave_scope(base); + return ((CPerlObj*)pPerl)->Perl_looks_like_number(sv); } +#if defined(USE_THREADS) +#endif +#if defined(USE_LOCALE_COLLATE) +#endif -#undef Perl_lex_end +#undef Perl_markstack_grow void -Perl_lex_end(pTHXo) +Perl_markstack_grow(pTHXo) { - ((CPerlObj*)pPerl)->Perl_lex_end(); + ((CPerlObj*)pPerl)->Perl_markstack_grow(); } +#if defined(USE_LOCALE_COLLATE) +#endif -#undef Perl_lex_start -void -Perl_lex_start(pTHXo_ SV* line) +#undef Perl_mess +SV* +Perl_mess(pTHXo_ const char* pat, ...) { - ((CPerlObj*)pPerl)->Perl_lex_start(line); -} + SV* retval; + va_list args; + va_start(args, pat); + retval = ((CPerlObj*)pPerl)->Perl_vmess(pat, &args); + va_end(args); + return retval; -#undef Perl_linklist -OP* -Perl_linklist(pTHXo_ OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_linklist(o); } -#undef Perl_list -OP* -Perl_list(pTHXo_ OP* o) +#undef Perl_vmess +SV* +Perl_vmess(pTHXo_ const char* pat, va_list* args) { - return ((CPerlObj*)pPerl)->Perl_list(o); + return ((CPerlObj*)pPerl)->Perl_vmess(pat, args); } -#undef Perl_listkids -OP* -Perl_listkids(pTHXo_ OP* o) +#undef Perl_mg_clear +int +Perl_mg_clear(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_listkids(o); + return ((CPerlObj*)pPerl)->Perl_mg_clear(sv); } -#undef Perl_localize -OP* -Perl_localize(pTHXo_ OP* arg, I32 lexical) +#undef Perl_mg_copy +int +Perl_mg_copy(pTHXo_ SV* sv, SV* nsv, const char* key, I32 klen) { - return ((CPerlObj*)pPerl)->Perl_localize(arg, lexical); + return ((CPerlObj*)pPerl)->Perl_mg_copy(sv, nsv, key, klen); } -#undef Perl_looks_like_number -I32 -Perl_looks_like_number(pTHXo_ SV* sv) +#undef Perl_mg_find +MAGIC* +Perl_mg_find(pTHXo_ SV* sv, int type) { - return ((CPerlObj*)pPerl)->Perl_looks_like_number(sv); + return ((CPerlObj*)pPerl)->Perl_mg_find(sv, type); } -#undef Perl_magic_clearenv +#undef Perl_mg_free int -Perl_magic_clearenv(pTHXo_ SV* sv, MAGIC* mg) +Perl_mg_free(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_magic_clearenv(sv, mg); + return ((CPerlObj*)pPerl)->Perl_mg_free(sv); } -#undef Perl_magic_clear_all_env +#undef Perl_mg_get int -Perl_magic_clear_all_env(pTHXo_ SV* sv, MAGIC* mg) +Perl_mg_get(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_magic_clear_all_env(sv, mg); + return ((CPerlObj*)pPerl)->Perl_mg_get(sv); } -#undef Perl_magic_clearpack -int -Perl_magic_clearpack(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_mg_length +U32 +Perl_mg_length(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_magic_clearpack(sv, mg); + return ((CPerlObj*)pPerl)->Perl_mg_length(sv); } -#undef Perl_magic_clearsig -int -Perl_magic_clearsig(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_mg_magical +void +Perl_mg_magical(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_magic_clearsig(sv, mg); + ((CPerlObj*)pPerl)->Perl_mg_magical(sv); } -#undef Perl_magic_existspack +#undef Perl_mg_set int -Perl_magic_existspack(pTHXo_ SV* sv, MAGIC* mg) +Perl_mg_set(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_magic_existspack(sv, mg); + return ((CPerlObj*)pPerl)->Perl_mg_set(sv); } -#undef Perl_magic_freeregexp -int -Perl_magic_freeregexp(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_mg_size +I32 +Perl_mg_size(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_magic_freeregexp(sv, mg); + return ((CPerlObj*)pPerl)->Perl_mg_size(sv); } -#undef Perl_magic_get -int -Perl_magic_get(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_my_atof +NV +Perl_my_atof(pTHXo_ const char *s) { - return ((CPerlObj*)pPerl)->Perl_magic_get(sv, mg); + return ((CPerlObj*)pPerl)->Perl_my_atof(s); } +#if !defined(HAS_BCOPY) || !defined(HAS_SAFE_BCOPY) -#undef Perl_magic_getarylen -int -Perl_magic_getarylen(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_my_bcopy +char* +Perl_my_bcopy(const char* from, char* to, I32 len) { - return ((CPerlObj*)pPerl)->Perl_magic_getarylen(sv, mg); + dTHXo; + return ((CPerlObj*)pPerl)->Perl_my_bcopy(from, to, len); } +#endif +#if !defined(HAS_BZERO) && !defined(HAS_MEMSET) -#undef Perl_magic_getdefelem -int -Perl_magic_getdefelem(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_my_bzero +char* +Perl_my_bzero(char* loc, I32 len) { - return ((CPerlObj*)pPerl)->Perl_magic_getdefelem(sv, mg); + dTHXo; + return ((CPerlObj*)pPerl)->Perl_my_bzero(loc, len); } +#endif -#undef Perl_magic_getglob -int -Perl_magic_getglob(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_my_exit +void +Perl_my_exit(pTHXo_ U32 status) { - return ((CPerlObj*)pPerl)->Perl_magic_getglob(sv, mg); + ((CPerlObj*)pPerl)->Perl_my_exit(status); } -#undef Perl_magic_getnkeys -int -Perl_magic_getnkeys(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_my_failure_exit +void +Perl_my_failure_exit(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_magic_getnkeys(sv, mg); + ((CPerlObj*)pPerl)->Perl_my_failure_exit(); } -#undef Perl_magic_getpack -int -Perl_magic_getpack(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_my_fflush_all +I32 +Perl_my_fflush_all(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_magic_getpack(sv, mg); + return ((CPerlObj*)pPerl)->Perl_my_fflush_all(); } -#undef Perl_magic_getpos -int -Perl_magic_getpos(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_my_lstat +I32 +Perl_my_lstat(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_magic_getpos(sv, mg); + return ((CPerlObj*)pPerl)->Perl_my_lstat(); } +#if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP) -#undef Perl_magic_getsig -int -Perl_magic_getsig(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_my_memcmp +I32 +Perl_my_memcmp(const char* s1, const char* s2, I32 len) { - return ((CPerlObj*)pPerl)->Perl_magic_getsig(sv, mg); + dTHXo; + return ((CPerlObj*)pPerl)->Perl_my_memcmp(s1, s2, len); } +#endif +#if !defined(HAS_MEMSET) -#undef Perl_magic_getsubstr -int -Perl_magic_getsubstr(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_my_memset +void* +Perl_my_memset(char* loc, I32 ch, I32 len) { - return ((CPerlObj*)pPerl)->Perl_magic_getsubstr(sv, mg); + dTHXo; + return ((CPerlObj*)pPerl)->Perl_my_memset(loc, ch, len); } +#endif +#if !defined(PERL_OBJECT) -#undef Perl_magic_gettaint -int -Perl_magic_gettaint(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_my_pclose +I32 +Perl_my_pclose(pTHXo_ PerlIO* ptr) { - return ((CPerlObj*)pPerl)->Perl_magic_gettaint(sv, mg); + return ((CPerlObj*)pPerl)->Perl_my_pclose(ptr); } -#undef Perl_magic_getuvar -int -Perl_magic_getuvar(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_my_popen +PerlIO* +Perl_my_popen(pTHXo_ char* cmd, char* mode) { - return ((CPerlObj*)pPerl)->Perl_magic_getuvar(sv, mg); + return ((CPerlObj*)pPerl)->Perl_my_popen(cmd, mode); } +#endif -#undef Perl_magic_getvec -int -Perl_magic_getvec(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_my_setenv +void +Perl_my_setenv(pTHXo_ char* nam, char* val) { - return ((CPerlObj*)pPerl)->Perl_magic_getvec(sv, mg); + ((CPerlObj*)pPerl)->Perl_my_setenv(nam, val); } -#undef Perl_magic_len -U32 -Perl_magic_len(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_my_stat +I32 +Perl_my_stat(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_magic_len(sv, mg); + return ((CPerlObj*)pPerl)->Perl_my_stat(); } -#if defined(USE_THREADS) +#if defined(MYSWAP) -#undef Perl_magic_mutexfree -int -Perl_magic_mutexfree(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_my_swap +short +Perl_my_swap(pTHXo_ short s) { - return ((CPerlObj*)pPerl)->Perl_magic_mutexfree(sv, mg); + return ((CPerlObj*)pPerl)->Perl_my_swap(s); } -#endif -#undef Perl_magic_nextpack -int -Perl_magic_nextpack(pTHXo_ SV* sv, MAGIC* mg, SV* key) +#undef Perl_my_htonl +long +Perl_my_htonl(pTHXo_ long l) { - return ((CPerlObj*)pPerl)->Perl_magic_nextpack(sv, mg, key); + return ((CPerlObj*)pPerl)->Perl_my_htonl(l); } -#undef Perl_magic_regdata_cnt -U32 -Perl_magic_regdata_cnt(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_my_ntohl +long +Perl_my_ntohl(pTHXo_ long l) { - return ((CPerlObj*)pPerl)->Perl_magic_regdata_cnt(sv, mg); + return ((CPerlObj*)pPerl)->Perl_my_ntohl(l); } +#endif -#undef Perl_magic_regdatum_get -int -Perl_magic_regdatum_get(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_newANONLIST +OP* +Perl_newANONLIST(pTHXo_ OP* o) { - return ((CPerlObj*)pPerl)->Perl_magic_regdatum_get(sv, mg); + return ((CPerlObj*)pPerl)->Perl_newANONLIST(o); } -#undef Perl_magic_set -int -Perl_magic_set(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_newANONHASH +OP* +Perl_newANONHASH(pTHXo_ OP* o) { - return ((CPerlObj*)pPerl)->Perl_magic_set(sv, mg); + return ((CPerlObj*)pPerl)->Perl_newANONHASH(o); } -#undef Perl_magic_setamagic -int -Perl_magic_setamagic(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_newANONSUB +OP* +Perl_newANONSUB(pTHXo_ I32 floor, OP* proto, OP* block) { - return ((CPerlObj*)pPerl)->Perl_magic_setamagic(sv, mg); + return ((CPerlObj*)pPerl)->Perl_newANONSUB(floor, proto, block); } -#undef Perl_magic_setarylen -int -Perl_magic_setarylen(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_newASSIGNOP +OP* +Perl_newASSIGNOP(pTHXo_ I32 flags, OP* left, I32 optype, OP* right) { - return ((CPerlObj*)pPerl)->Perl_magic_setarylen(sv, mg); + return ((CPerlObj*)pPerl)->Perl_newASSIGNOP(flags, left, optype, right); } -#undef Perl_magic_setbm -int -Perl_magic_setbm(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_newCONDOP +OP* +Perl_newCONDOP(pTHXo_ I32 flags, OP* expr, OP* trueop, OP* falseop) { - return ((CPerlObj*)pPerl)->Perl_magic_setbm(sv, mg); + return ((CPerlObj*)pPerl)->Perl_newCONDOP(flags, expr, trueop, falseop); } -#undef Perl_magic_setdbline -int -Perl_magic_setdbline(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_newCONSTSUB +void +Perl_newCONSTSUB(pTHXo_ HV* stash, char* name, SV* sv) { - return ((CPerlObj*)pPerl)->Perl_magic_setdbline(sv, mg); + ((CPerlObj*)pPerl)->Perl_newCONSTSUB(stash, name, sv); } -#if defined(USE_LOCALE_COLLATE) -#undef Perl_magic_setcollxfrm -int -Perl_magic_setcollxfrm(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_newFORM +void +Perl_newFORM(pTHXo_ I32 floor, OP* o, OP* block) { - return ((CPerlObj*)pPerl)->Perl_magic_setcollxfrm(sv, mg); + ((CPerlObj*)pPerl)->Perl_newFORM(floor, o, block); } -#endif -#undef Perl_magic_setdefelem -int -Perl_magic_setdefelem(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_newFOROP +OP* +Perl_newFOROP(pTHXo_ I32 flags, char* label, line_t forline, OP* sclr, OP* expr, OP*block, OP*cont) { - return ((CPerlObj*)pPerl)->Perl_magic_setdefelem(sv, mg); + return ((CPerlObj*)pPerl)->Perl_newFOROP(flags, label, forline, sclr, expr, block, cont); } -#undef Perl_magic_setenv -int -Perl_magic_setenv(pTHXo_ SV* sv, MAGIC* mg) +#undef Perl_newLOGOP +OP* +Perl_newLOGOP(pTHXo_ I32 optype, I32 flags, OP* left, OP* right) { - return ((CPerlObj*)pPerl)->Perl_magic_setenv(sv, mg); + return ((CPerlObj*)pPerl)->Perl_newLOGOP(optype, flags, left, right); } -#undef Perl_magic_setfm -int -Perl_magic_setfm(pTHXo_ SV* sv, MAGIC* mg) -{ - return ((CPerlObj*)pPerl)->Perl_magic_setfm(sv, mg); -} - -#undef Perl_magic_setisa -int -Perl_magic_setisa(pTHXo_ SV* sv, MAGIC* mg) -{ - return ((CPerlObj*)pPerl)->Perl_magic_setisa(sv, mg); -} - -#undef Perl_magic_setglob -int -Perl_magic_setglob(pTHXo_ SV* sv, MAGIC* mg) -{ - return ((CPerlObj*)pPerl)->Perl_magic_setglob(sv, mg); -} - -#undef Perl_magic_setmglob -int -Perl_magic_setmglob(pTHXo_ SV* sv, MAGIC* mg) -{ - return ((CPerlObj*)pPerl)->Perl_magic_setmglob(sv, mg); -} - -#undef Perl_magic_setnkeys -int -Perl_magic_setnkeys(pTHXo_ SV* sv, MAGIC* mg) -{ - return ((CPerlObj*)pPerl)->Perl_magic_setnkeys(sv, mg); -} - -#undef Perl_magic_setpack -int -Perl_magic_setpack(pTHXo_ SV* sv, MAGIC* mg) -{ - return ((CPerlObj*)pPerl)->Perl_magic_setpack(sv, mg); -} - -#undef Perl_magic_setpos -int -Perl_magic_setpos(pTHXo_ SV* sv, MAGIC* mg) -{ - return ((CPerlObj*)pPerl)->Perl_magic_setpos(sv, mg); -} - -#undef Perl_magic_setsig -int -Perl_magic_setsig(pTHXo_ SV* sv, MAGIC* mg) -{ - return ((CPerlObj*)pPerl)->Perl_magic_setsig(sv, mg); -} - -#undef Perl_magic_setsubstr -int -Perl_magic_setsubstr(pTHXo_ SV* sv, MAGIC* mg) -{ - return ((CPerlObj*)pPerl)->Perl_magic_setsubstr(sv, mg); -} - -#undef Perl_magic_settaint -int -Perl_magic_settaint(pTHXo_ SV* sv, MAGIC* mg) -{ - return ((CPerlObj*)pPerl)->Perl_magic_settaint(sv, mg); -} - -#undef Perl_magic_setuvar -int -Perl_magic_setuvar(pTHXo_ SV* sv, MAGIC* mg) -{ - return ((CPerlObj*)pPerl)->Perl_magic_setuvar(sv, mg); -} - -#undef Perl_magic_setvec -int -Perl_magic_setvec(pTHXo_ SV* sv, MAGIC* mg) -{ - return ((CPerlObj*)pPerl)->Perl_magic_setvec(sv, mg); -} - -#undef Perl_magic_set_all_env -int -Perl_magic_set_all_env(pTHXo_ SV* sv, MAGIC* mg) -{ - return ((CPerlObj*)pPerl)->Perl_magic_set_all_env(sv, mg); -} - -#undef Perl_magic_sizepack -U32 -Perl_magic_sizepack(pTHXo_ SV* sv, MAGIC* mg) -{ - return ((CPerlObj*)pPerl)->Perl_magic_sizepack(sv, mg); -} - -#undef Perl_magic_wipepack -int -Perl_magic_wipepack(pTHXo_ SV* sv, MAGIC* mg) -{ - return ((CPerlObj*)pPerl)->Perl_magic_wipepack(sv, mg); -} - -#undef Perl_magicname -void -Perl_magicname(pTHXo_ char* sym, char* name, I32 namlen) -{ - ((CPerlObj*)pPerl)->Perl_magicname(sym, name, namlen); -} - -#undef Perl_markstack_grow -void -Perl_markstack_grow(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_markstack_grow(); -} -#if defined(USE_LOCALE_COLLATE) - -#undef Perl_mem_collxfrm -char* -Perl_mem_collxfrm(pTHXo_ const char* s, STRLEN len, STRLEN* xlen) -{ - return ((CPerlObj*)pPerl)->Perl_mem_collxfrm(s, len, xlen); -} -#endif - -#undef Perl_mess -SV* -Perl_mess(pTHXo_ const char* pat, ...) -{ - SV* retval; - va_list args; - va_start(args, pat); - retval = ((CPerlObj*)pPerl)->Perl_vmess(pat, &args); - va_end(args); - return retval; - -} - -#undef Perl_vmess -SV* -Perl_vmess(pTHXo_ const char* pat, va_list* args) -{ - return ((CPerlObj*)pPerl)->Perl_vmess(pat, args); -} - -#undef Perl_qerror -void -Perl_qerror(pTHXo_ SV* err) -{ - ((CPerlObj*)pPerl)->Perl_qerror(err); -} - -#undef Perl_mg_clear -int -Perl_mg_clear(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_mg_clear(sv); -} - -#undef Perl_mg_copy -int -Perl_mg_copy(pTHXo_ 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(pTHXo_ SV* sv, int type) -{ - return ((CPerlObj*)pPerl)->Perl_mg_find(sv, type); -} - -#undef Perl_mg_free -int -Perl_mg_free(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_mg_free(sv); -} - -#undef Perl_mg_get -int -Perl_mg_get(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_mg_get(sv); -} - -#undef Perl_mg_length -U32 -Perl_mg_length(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_mg_length(sv); -} - -#undef Perl_mg_magical -void -Perl_mg_magical(pTHXo_ SV* sv) -{ - ((CPerlObj*)pPerl)->Perl_mg_magical(sv); -} - -#undef Perl_mg_set -int -Perl_mg_set(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_mg_set(sv); -} - -#undef Perl_mg_size -I32 -Perl_mg_size(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_mg_size(sv); -} - -#undef Perl_mod -OP* -Perl_mod(pTHXo_ OP* o, I32 type) -{ - return ((CPerlObj*)pPerl)->Perl_mod(o, type); -} - -#undef Perl_moreswitches -char* -Perl_moreswitches(pTHXo_ char* s) -{ - return ((CPerlObj*)pPerl)->Perl_moreswitches(s); -} - -#undef Perl_my -OP* -Perl_my(pTHXo_ OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_my(o); -} - -#undef Perl_my_atof -NV -Perl_my_atof(pTHXo_ 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(const char* from, char* to, I32 len) -{ - dTHXo; - 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(char* loc, I32 len) -{ - dTHXo; - return ((CPerlObj*)pPerl)->Perl_my_bzero(loc, len); -} -#endif - -#undef Perl_my_exit -void -Perl_my_exit(pTHXo_ U32 status) -{ - ((CPerlObj*)pPerl)->Perl_my_exit(status); -} - -#undef Perl_my_failure_exit -void -Perl_my_failure_exit(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_my_failure_exit(); -} - -#undef Perl_my_fflush_all -I32 -Perl_my_fflush_all(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_my_fflush_all(); -} - -#undef Perl_my_lstat -I32 -Perl_my_lstat(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_my_lstat(); -} -#if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP) - -#undef Perl_my_memcmp -I32 -Perl_my_memcmp(const char* s1, const char* s2, I32 len) -{ - dTHXo; - return ((CPerlObj*)pPerl)->Perl_my_memcmp(s1, s2, len); -} -#endif -#if !defined(HAS_MEMSET) - -#undef Perl_my_memset -void* -Perl_my_memset(char* loc, I32 ch, I32 len) -{ - dTHXo; - return ((CPerlObj*)pPerl)->Perl_my_memset(loc, ch, len); -} -#endif -#if !defined(PERL_OBJECT) - -#undef Perl_my_pclose -I32 -Perl_my_pclose(pTHXo_ PerlIO* ptr) -{ - return ((CPerlObj*)pPerl)->Perl_my_pclose(ptr); -} - -#undef Perl_my_popen -PerlIO* -Perl_my_popen(pTHXo_ char* cmd, char* mode) -{ - return ((CPerlObj*)pPerl)->Perl_my_popen(cmd, mode); -} -#endif - -#undef Perl_my_setenv -void -Perl_my_setenv(pTHXo_ char* nam, char* val) -{ - ((CPerlObj*)pPerl)->Perl_my_setenv(nam, val); -} - -#undef Perl_my_stat -I32 -Perl_my_stat(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_my_stat(); -} -#if defined(MYSWAP) - -#undef Perl_my_swap -short -Perl_my_swap(pTHXo_ short s) -{ - return ((CPerlObj*)pPerl)->Perl_my_swap(s); -} - -#undef Perl_my_htonl -long -Perl_my_htonl(pTHXo_ long l) -{ - return ((CPerlObj*)pPerl)->Perl_my_htonl(l); -} - -#undef Perl_my_ntohl -long -Perl_my_ntohl(pTHXo_ long l) -{ - return ((CPerlObj*)pPerl)->Perl_my_ntohl(l); -} -#endif - -#undef Perl_my_unexec -void -Perl_my_unexec(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_my_unexec(); -} - -#undef Perl_newANONLIST -OP* -Perl_newANONLIST(pTHXo_ OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_newANONLIST(o); -} - -#undef Perl_newANONHASH -OP* -Perl_newANONHASH(pTHXo_ OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_newANONHASH(o); -} - -#undef Perl_newANONSUB -OP* -Perl_newANONSUB(pTHXo_ I32 floor, OP* proto, OP* block) -{ - return ((CPerlObj*)pPerl)->Perl_newANONSUB(floor, proto, block); -} - -#undef Perl_newASSIGNOP -OP* -Perl_newASSIGNOP(pTHXo_ I32 flags, OP* left, I32 optype, OP* right) -{ - return ((CPerlObj*)pPerl)->Perl_newASSIGNOP(flags, left, optype, right); -} - -#undef Perl_newCONDOP -OP* -Perl_newCONDOP(pTHXo_ I32 flags, OP* expr, OP* trueop, OP* falseop) -{ - return ((CPerlObj*)pPerl)->Perl_newCONDOP(flags, expr, trueop, falseop); -} - -#undef Perl_newCONSTSUB -void -Perl_newCONSTSUB(pTHXo_ HV* stash, char* name, SV* sv) -{ - ((CPerlObj*)pPerl)->Perl_newCONSTSUB(stash, name, sv); -} - -#undef Perl_newFORM -void -Perl_newFORM(pTHXo_ I32 floor, OP* o, OP* block) -{ - ((CPerlObj*)pPerl)->Perl_newFORM(floor, o, block); -} - -#undef Perl_newFOROP -OP* -Perl_newFOROP(pTHXo_ 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(pTHXo_ I32 optype, I32 flags, OP* left, OP* right) -{ - return ((CPerlObj*)pPerl)->Perl_newLOGOP(optype, flags, left, right); -} - -#undef Perl_newLOOPEX -OP* -Perl_newLOOPEX(pTHXo_ I32 type, OP* label) -{ - return ((CPerlObj*)pPerl)->Perl_newLOOPEX(type, label); -} - -#undef Perl_newLOOPOP -OP* -Perl_newLOOPOP(pTHXo_ I32 flags, I32 debuggable, OP* expr, OP* block) -{ - return ((CPerlObj*)pPerl)->Perl_newLOOPOP(flags, debuggable, expr, block); -} - -#undef Perl_newNULLLIST -OP* -Perl_newNULLLIST(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_newNULLLIST(); -} - -#undef Perl_newOP -OP* -Perl_newOP(pTHXo_ I32 optype, I32 flags) -{ - return ((CPerlObj*)pPerl)->Perl_newOP(optype, flags); -} - -#undef Perl_newPROG -void -Perl_newPROG(pTHXo_ OP* o) -{ - ((CPerlObj*)pPerl)->Perl_newPROG(o); -} - -#undef Perl_newRANGE -OP* -Perl_newRANGE(pTHXo_ I32 flags, OP* left, OP* right) -{ - return ((CPerlObj*)pPerl)->Perl_newRANGE(flags, left, right); -} - -#undef Perl_newSLICEOP -OP* -Perl_newSLICEOP(pTHXo_ I32 flags, OP* subscript, OP* listop) -{ - return ((CPerlObj*)pPerl)->Perl_newSLICEOP(flags, subscript, listop); -} - -#undef Perl_newSTATEOP -OP* -Perl_newSTATEOP(pTHXo_ I32 flags, char* label, OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_newSTATEOP(flags, label, o); -} - -#undef Perl_newSUB -CV* -Perl_newSUB(pTHXo_ I32 floor, OP* o, OP* proto, OP* block) -{ - return ((CPerlObj*)pPerl)->Perl_newSUB(floor, o, proto, block); -} - -#undef Perl_newXS -CV* -Perl_newXS(pTHXo_ char* name, XSUBADDR_t f, char* filename) -{ - return ((CPerlObj*)pPerl)->Perl_newXS(name, f, filename); -} - -#undef Perl_newAV -AV* -Perl_newAV(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_newAV(); -} - -#undef Perl_newAVREF -OP* -Perl_newAVREF(pTHXo_ OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_newAVREF(o); -} - -#undef Perl_newBINOP -OP* -Perl_newBINOP(pTHXo_ I32 type, I32 flags, OP* first, OP* last) -{ - return ((CPerlObj*)pPerl)->Perl_newBINOP(type, flags, first, last); -} - -#undef Perl_newCVREF -OP* -Perl_newCVREF(pTHXo_ I32 flags, OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_newCVREF(flags, o); -} - -#undef Perl_newGVOP -OP* -Perl_newGVOP(pTHXo_ I32 type, I32 flags, GV* gv) -{ - return ((CPerlObj*)pPerl)->Perl_newGVOP(type, flags, gv); -} - -#undef Perl_newGVgen -GV* -Perl_newGVgen(pTHXo_ char* pack) -{ - return ((CPerlObj*)pPerl)->Perl_newGVgen(pack); -} - -#undef Perl_newGVREF -OP* -Perl_newGVREF(pTHXo_ I32 type, OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_newGVREF(type, o); -} - -#undef Perl_newHVREF -OP* -Perl_newHVREF(pTHXo_ OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_newHVREF(o); -} - -#undef Perl_newHV -HV* -Perl_newHV(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_newHV(); -} - -#undef Perl_newHVhv -HV* -Perl_newHVhv(pTHXo_ HV* hv) -{ - return ((CPerlObj*)pPerl)->Perl_newHVhv(hv); -} - -#undef Perl_newIO -IO* -Perl_newIO(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_newIO(); -} - -#undef Perl_newLISTOP -OP* -Perl_newLISTOP(pTHXo_ I32 type, I32 flags, OP* first, OP* last) -{ - return ((CPerlObj*)pPerl)->Perl_newLISTOP(type, flags, first, last); -} - -#undef Perl_newPADOP -OP* -Perl_newPADOP(pTHXo_ I32 type, I32 flags, SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_newPADOP(type, flags, sv); -} - -#undef Perl_newPMOP -OP* -Perl_newPMOP(pTHXo_ I32 type, I32 flags) -{ - return ((CPerlObj*)pPerl)->Perl_newPMOP(type, flags); -} - -#undef Perl_newPVOP -OP* -Perl_newPVOP(pTHXo_ I32 type, I32 flags, char* pv) -{ - return ((CPerlObj*)pPerl)->Perl_newPVOP(type, flags, pv); -} - -#undef Perl_newRV -SV* -Perl_newRV(pTHXo_ SV* pref) -{ - return ((CPerlObj*)pPerl)->Perl_newRV(pref); -} - -#undef Perl_newRV_noinc -SV* -Perl_newRV_noinc(pTHXo_ SV *sv) -{ - return ((CPerlObj*)pPerl)->Perl_newRV_noinc(sv); -} - -#undef Perl_newSV -SV* -Perl_newSV(pTHXo_ STRLEN len) -{ - return ((CPerlObj*)pPerl)->Perl_newSV(len); -} - -#undef Perl_newSVREF -OP* -Perl_newSVREF(pTHXo_ OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_newSVREF(o); -} - -#undef Perl_newSVOP -OP* -Perl_newSVOP(pTHXo_ I32 type, I32 flags, SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_newSVOP(type, flags, sv); -} - -#undef Perl_newSViv -SV* -Perl_newSViv(pTHXo_ IV i) -{ - return ((CPerlObj*)pPerl)->Perl_newSViv(i); -} - -#undef Perl_newSVnv -SV* -Perl_newSVnv(pTHXo_ NV n) -{ - return ((CPerlObj*)pPerl)->Perl_newSVnv(n); -} - -#undef Perl_newSVpv -SV* -Perl_newSVpv(pTHXo_ const char* s, STRLEN len) -{ - return ((CPerlObj*)pPerl)->Perl_newSVpv(s, len); -} - -#undef Perl_newSVpvn -SV* -Perl_newSVpvn(pTHXo_ const char* s, STRLEN len) -{ - return ((CPerlObj*)pPerl)->Perl_newSVpvn(s, len); -} - -#undef Perl_newSVpvf -SV* -Perl_newSVpvf(pTHXo_ const char* pat, ...) -{ - SV* retval; - va_list args; - va_start(args, pat); - retval = ((CPerlObj*)pPerl)->Perl_vnewSVpvf(pat, &args); - va_end(args); - return retval; - -} - -#undef Perl_vnewSVpvf -SV* -Perl_vnewSVpvf(pTHXo_ const char* pat, va_list* args) -{ - return ((CPerlObj*)pPerl)->Perl_vnewSVpvf(pat, args); -} - -#undef Perl_newSVrv -SV* -Perl_newSVrv(pTHXo_ SV* rv, const char* classname) -{ - return ((CPerlObj*)pPerl)->Perl_newSVrv(rv, classname); -} - -#undef Perl_newSVsv -SV* -Perl_newSVsv(pTHXo_ SV* old) -{ - return ((CPerlObj*)pPerl)->Perl_newSVsv(old); -} - -#undef Perl_newUNOP -OP* -Perl_newUNOP(pTHXo_ I32 type, I32 flags, OP* first) -{ - return ((CPerlObj*)pPerl)->Perl_newUNOP(type, flags, first); -} - -#undef Perl_newWHILEOP -OP* -Perl_newWHILEOP(pTHXo_ 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); -} - -#undef Perl_new_stackinfo -PERL_SI* -Perl_new_stackinfo(pTHXo_ I32 stitems, I32 cxitems) -{ - return ((CPerlObj*)pPerl)->Perl_new_stackinfo(stitems, cxitems); -} - -#undef Perl_nextargv -PerlIO* -Perl_nextargv(pTHXo_ GV* gv) -{ - return ((CPerlObj*)pPerl)->Perl_nextargv(gv); -} - -#undef Perl_ninstr -char* -Perl_ninstr(pTHXo_ 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(pTHXo_ OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_oopsCV(o); -} - -#undef Perl_op_free -void -Perl_op_free(pTHXo_ OP* arg) -{ - ((CPerlObj*)pPerl)->Perl_op_free(arg); -} - -#undef Perl_package -void -Perl_package(pTHXo_ OP* o) -{ - ((CPerlObj*)pPerl)->Perl_package(o); -} - -#undef Perl_pad_alloc -PADOFFSET -Perl_pad_alloc(pTHXo_ I32 optype, U32 tmptype) -{ - return ((CPerlObj*)pPerl)->Perl_pad_alloc(optype, tmptype); -} - -#undef Perl_pad_allocmy -PADOFFSET -Perl_pad_allocmy(pTHXo_ char* name) -{ - return ((CPerlObj*)pPerl)->Perl_pad_allocmy(name); -} - -#undef Perl_pad_findmy -PADOFFSET -Perl_pad_findmy(pTHXo_ char* name) -{ - return ((CPerlObj*)pPerl)->Perl_pad_findmy(name); -} - -#undef Perl_oopsAV -OP* -Perl_oopsAV(pTHXo_ OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_oopsAV(o); -} - -#undef Perl_oopsHV -OP* -Perl_oopsHV(pTHXo_ OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_oopsHV(o); -} - -#undef Perl_pad_leavemy -void -Perl_pad_leavemy(pTHXo_ I32 fill) -{ - ((CPerlObj*)pPerl)->Perl_pad_leavemy(fill); -} - -#undef Perl_pad_sv -SV* -Perl_pad_sv(pTHXo_ PADOFFSET po) -{ - return ((CPerlObj*)pPerl)->Perl_pad_sv(po); -} - -#undef Perl_pad_free -void -Perl_pad_free(pTHXo_ PADOFFSET po) -{ - ((CPerlObj*)pPerl)->Perl_pad_free(po); -} - -#undef Perl_pad_reset -void -Perl_pad_reset(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_pad_reset(); -} - -#undef Perl_pad_swipe -void -Perl_pad_swipe(pTHXo_ PADOFFSET po) -{ - ((CPerlObj*)pPerl)->Perl_pad_swipe(po); -} - -#undef Perl_peep -void -Perl_peep(pTHXo_ OP* o) -{ - ((CPerlObj*)pPerl)->Perl_peep(o); -} -#if defined(PERL_OBJECT) - -#undef Perl_construct -void -Perl_construct(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_construct(); -} - -#undef Perl_destruct -void -Perl_destruct(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_destruct(); -} - -#undef Perl_free -void -Perl_free(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_free(); -} - -#undef Perl_run -int -Perl_run(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_run(); -} - -#undef Perl_parse -int -Perl_parse(pTHXo_ XSINIT_t xsinit, int argc, char** argv, char** env) -{ - return ((CPerlObj*)pPerl)->Perl_parse(xsinit, argc, argv, env); -} -#endif -#if defined(USE_THREADS) - -#undef Perl_new_struct_thread -struct perl_thread* -Perl_new_struct_thread(pTHXo_ struct perl_thread *t) -{ - return ((CPerlObj*)pPerl)->Perl_new_struct_thread(t); -} -#endif - -#undef Perl_call_atexit -void -Perl_call_atexit(pTHXo_ ATEXIT_t fn, void *ptr) -{ - ((CPerlObj*)pPerl)->Perl_call_atexit(fn, ptr); -} - -#undef Perl_call_argv -I32 -Perl_call_argv(pTHXo_ 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(pTHXo_ const char* methname, I32 flags) -{ - return ((CPerlObj*)pPerl)->Perl_call_method(methname, flags); -} - -#undef Perl_call_pv -I32 -Perl_call_pv(pTHXo_ const char* sub_name, I32 flags) -{ - return ((CPerlObj*)pPerl)->Perl_call_pv(sub_name, flags); -} - -#undef Perl_call_sv -I32 -Perl_call_sv(pTHXo_ SV* sv, I32 flags) -{ - return ((CPerlObj*)pPerl)->Perl_call_sv(sv, flags); -} - -#undef Perl_eval_pv -SV* -Perl_eval_pv(pTHXo_ 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(pTHXo_ SV* sv, I32 flags) -{ - return ((CPerlObj*)pPerl)->Perl_eval_sv(sv, flags); -} - -#undef Perl_get_sv -SV* -Perl_get_sv(pTHXo_ const char* name, I32 create) -{ - return ((CPerlObj*)pPerl)->Perl_get_sv(name, create); -} - -#undef Perl_get_av -AV* -Perl_get_av(pTHXo_ const char* name, I32 create) -{ - return ((CPerlObj*)pPerl)->Perl_get_av(name, create); -} - -#undef Perl_get_hv -HV* -Perl_get_hv(pTHXo_ const char* name, I32 create) -{ - return ((CPerlObj*)pPerl)->Perl_get_hv(name, create); -} - -#undef Perl_get_cv -CV* -Perl_get_cv(pTHXo_ const char* name, I32 create) -{ - return ((CPerlObj*)pPerl)->Perl_get_cv(name, create); -} - -#undef Perl_init_i18nl10n -int -Perl_init_i18nl10n(pTHXo_ int printwarn) -{ - return ((CPerlObj*)pPerl)->Perl_init_i18nl10n(printwarn); -} - -#undef Perl_init_i18nl14n -int -Perl_init_i18nl14n(pTHXo_ int printwarn) -{ - return ((CPerlObj*)pPerl)->Perl_init_i18nl14n(printwarn); -} - -#undef Perl_new_collate -void -Perl_new_collate(pTHXo_ const char* newcoll) -{ - ((CPerlObj*)pPerl)->Perl_new_collate(newcoll); -} - -#undef Perl_new_ctype -void -Perl_new_ctype(pTHXo_ const char* newctype) -{ - ((CPerlObj*)pPerl)->Perl_new_ctype(newctype); -} - -#undef Perl_new_numeric -void -Perl_new_numeric(pTHXo_ const char* newcoll) -{ - ((CPerlObj*)pPerl)->Perl_new_numeric(newcoll); -} - -#undef Perl_set_numeric_local -void -Perl_set_numeric_local(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_set_numeric_local(); -} - -#undef Perl_set_numeric_radix -void -Perl_set_numeric_radix(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_set_numeric_radix(); -} - -#undef Perl_set_numeric_standard -void -Perl_set_numeric_standard(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_set_numeric_standard(); -} - -#undef Perl_require_pv -void -Perl_require_pv(pTHXo_ const char* pv) -{ - ((CPerlObj*)pPerl)->Perl_require_pv(pv); -} - -#undef Perl_pidgone -void -Perl_pidgone(pTHXo_ Pid_t pid, int status) -{ - ((CPerlObj*)pPerl)->Perl_pidgone(pid, status); -} - -#undef Perl_pmflag -void -Perl_pmflag(pTHXo_ U16* pmfl, int ch) -{ - ((CPerlObj*)pPerl)->Perl_pmflag(pmfl, ch); -} - -#undef Perl_pmruntime -OP* -Perl_pmruntime(pTHXo_ OP* pm, OP* expr, OP* repl) -{ - return ((CPerlObj*)pPerl)->Perl_pmruntime(pm, expr, repl); -} - -#undef Perl_pmtrans -OP* -Perl_pmtrans(pTHXo_ OP* o, OP* expr, OP* repl) -{ - return ((CPerlObj*)pPerl)->Perl_pmtrans(o, expr, repl); -} - -#undef Perl_pop_return -OP* -Perl_pop_return(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pop_return(); -} - -#undef Perl_pop_scope -void -Perl_pop_scope(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_pop_scope(); -} - -#undef Perl_prepend_elem -OP* -Perl_prepend_elem(pTHXo_ I32 optype, OP* head, OP* tail) -{ - return ((CPerlObj*)pPerl)->Perl_prepend_elem(optype, head, tail); -} - -#undef Perl_push_return -void -Perl_push_return(pTHXo_ OP* o) -{ - ((CPerlObj*)pPerl)->Perl_push_return(o); -} - -#undef Perl_push_scope -void -Perl_push_scope(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_push_scope(); -} - -#undef Perl_ref -OP* -Perl_ref(pTHXo_ OP* o, I32 type) -{ - return ((CPerlObj*)pPerl)->Perl_ref(o, type); -} - -#undef Perl_refkids -OP* -Perl_refkids(pTHXo_ OP* o, I32 type) -{ - return ((CPerlObj*)pPerl)->Perl_refkids(o, type); -} - -#undef Perl_regdump -void -Perl_regdump(pTHXo_ regexp* r) -{ - ((CPerlObj*)pPerl)->Perl_regdump(r); -} - -#undef Perl_pregexec -I32 -Perl_pregexec(pTHXo_ 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(pTHXo_ struct regexp* r) -{ - ((CPerlObj*)pPerl)->Perl_pregfree(r); -} - -#undef Perl_pregcomp -regexp* -Perl_pregcomp(pTHXo_ char* exp, char* xend, PMOP* pm) -{ - return ((CPerlObj*)pPerl)->Perl_pregcomp(exp, xend, pm); -} - -#undef Perl_re_intuit_start -char* -Perl_re_intuit_start(pTHXo_ 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(pTHXo_ regexp* prog) -{ - return ((CPerlObj*)pPerl)->Perl_re_intuit_string(prog); -} - -#undef Perl_regexec_flags -I32 -Perl_regexec_flags(pTHXo_ 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(pTHXo_ regnode* p) -{ - return ((CPerlObj*)pPerl)->Perl_regnext(p); -} - -#undef Perl_regprop -void -Perl_regprop(pTHXo_ SV* sv, regnode* o) -{ - ((CPerlObj*)pPerl)->Perl_regprop(sv, o); -} - -#undef Perl_repeatcpy -void -Perl_repeatcpy(pTHXo_ char* to, const char* from, I32 len, I32 count) -{ - ((CPerlObj*)pPerl)->Perl_repeatcpy(to, from, len, count); -} - -#undef Perl_rninstr -char* -Perl_rninstr(pTHXo_ 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(pTHXo_ int i, Sighandler_t t) -{ - return ((CPerlObj*)pPerl)->Perl_rsignal(i, t); -} - -#undef Perl_rsignal_restore -int -Perl_rsignal_restore(pTHXo_ int i, Sigsave_t* t) -{ - return ((CPerlObj*)pPerl)->Perl_rsignal_restore(i, t); -} - -#undef Perl_rsignal_save -int -Perl_rsignal_save(pTHXo_ 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(pTHXo_ int i) -{ - return ((CPerlObj*)pPerl)->Perl_rsignal_state(i); -} - -#undef Perl_rxres_free -void -Perl_rxres_free(pTHXo_ void** rsp) -{ - ((CPerlObj*)pPerl)->Perl_rxres_free(rsp); -} - -#undef Perl_rxres_restore -void -Perl_rxres_restore(pTHXo_ void** rsp, REGEXP* prx) -{ - ((CPerlObj*)pPerl)->Perl_rxres_restore(rsp, prx); -} - -#undef Perl_rxres_save -void -Perl_rxres_save(pTHXo_ void** rsp, REGEXP* prx) -{ - ((CPerlObj*)pPerl)->Perl_rxres_save(rsp, prx); -} -#if !defined(HAS_RENAME) - -#undef Perl_same_dirent -I32 -Perl_same_dirent(pTHXo_ char* a, char* b) -{ - return ((CPerlObj*)pPerl)->Perl_same_dirent(a, b); -} -#endif - -#undef Perl_savepv -char* -Perl_savepv(pTHXo_ const char* sv) -{ - return ((CPerlObj*)pPerl)->Perl_savepv(sv); -} - -#undef Perl_savepvn -char* -Perl_savepvn(pTHXo_ const char* sv, I32 len) -{ - return ((CPerlObj*)pPerl)->Perl_savepvn(sv, len); -} - -#undef Perl_savestack_grow -void -Perl_savestack_grow(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_savestack_grow(); -} - -#undef Perl_save_aelem -void -Perl_save_aelem(pTHXo_ AV* av, I32 idx, SV **sptr) -{ - ((CPerlObj*)pPerl)->Perl_save_aelem(av, idx, sptr); -} - -#undef Perl_save_alloc -I32 -Perl_save_alloc(pTHXo_ I32 size, I32 pad) -{ - return ((CPerlObj*)pPerl)->Perl_save_alloc(size, pad); -} - -#undef Perl_save_aptr -void -Perl_save_aptr(pTHXo_ AV** aptr) -{ - ((CPerlObj*)pPerl)->Perl_save_aptr(aptr); -} - -#undef Perl_save_ary -AV* -Perl_save_ary(pTHXo_ GV* gv) -{ - return ((CPerlObj*)pPerl)->Perl_save_ary(gv); -} - -#undef Perl_save_clearsv -void -Perl_save_clearsv(pTHXo_ SV** svp) -{ - ((CPerlObj*)pPerl)->Perl_save_clearsv(svp); -} - -#undef Perl_save_delete -void -Perl_save_delete(pTHXo_ HV* hv, char* key, I32 klen) -{ - ((CPerlObj*)pPerl)->Perl_save_delete(hv, key, klen); -} - -#undef Perl_save_destructor -void -Perl_save_destructor(pTHXo_ DESTRUCTORFUNC_NOCONTEXT_t f, void* p) -{ - ((CPerlObj*)pPerl)->Perl_save_destructor(f, p); -} - -#undef Perl_save_destructor_x -void -Perl_save_destructor_x(pTHXo_ DESTRUCTORFUNC_t f, void* p) -{ - ((CPerlObj*)pPerl)->Perl_save_destructor_x(f, p); -} - -#undef Perl_save_freesv -void -Perl_save_freesv(pTHXo_ SV* sv) -{ - ((CPerlObj*)pPerl)->Perl_save_freesv(sv); -} - -#undef Perl_save_freeop -void -Perl_save_freeop(pTHXo_ OP* o) -{ - ((CPerlObj*)pPerl)->Perl_save_freeop(o); -} - -#undef Perl_save_freepv -void -Perl_save_freepv(pTHXo_ char* pv) -{ - ((CPerlObj*)pPerl)->Perl_save_freepv(pv); -} - -#undef Perl_save_generic_svref -void -Perl_save_generic_svref(pTHXo_ SV** sptr) -{ - ((CPerlObj*)pPerl)->Perl_save_generic_svref(sptr); -} - -#undef Perl_save_gp -void -Perl_save_gp(pTHXo_ GV* gv, I32 empty) -{ - ((CPerlObj*)pPerl)->Perl_save_gp(gv, empty); -} - -#undef Perl_save_hash -HV* -Perl_save_hash(pTHXo_ GV* gv) -{ - return ((CPerlObj*)pPerl)->Perl_save_hash(gv); -} - -#undef Perl_save_helem -void -Perl_save_helem(pTHXo_ HV* hv, SV *key, SV **sptr) -{ - ((CPerlObj*)pPerl)->Perl_save_helem(hv, key, sptr); -} - -#undef Perl_save_hints -void -Perl_save_hints(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_save_hints(); -} - -#undef Perl_save_hptr -void -Perl_save_hptr(pTHXo_ HV** hptr) -{ - ((CPerlObj*)pPerl)->Perl_save_hptr(hptr); -} - -#undef Perl_save_I16 -void -Perl_save_I16(pTHXo_ I16* intp) -{ - ((CPerlObj*)pPerl)->Perl_save_I16(intp); -} - -#undef Perl_save_I32 -void -Perl_save_I32(pTHXo_ I32* intp) -{ - ((CPerlObj*)pPerl)->Perl_save_I32(intp); -} - -#undef Perl_save_I8 -void -Perl_save_I8(pTHXo_ I8* bytep) -{ - ((CPerlObj*)pPerl)->Perl_save_I8(bytep); -} - -#undef Perl_save_int -void -Perl_save_int(pTHXo_ int* intp) -{ - ((CPerlObj*)pPerl)->Perl_save_int(intp); -} - -#undef Perl_save_item -void -Perl_save_item(pTHXo_ SV* item) -{ - ((CPerlObj*)pPerl)->Perl_save_item(item); -} - -#undef Perl_save_iv -void -Perl_save_iv(pTHXo_ IV* iv) -{ - ((CPerlObj*)pPerl)->Perl_save_iv(iv); -} - -#undef Perl_save_list -void -Perl_save_list(pTHXo_ SV** sarg, I32 maxsarg) -{ - ((CPerlObj*)pPerl)->Perl_save_list(sarg, maxsarg); -} - -#undef Perl_save_long -void -Perl_save_long(pTHXo_ long* longp) -{ - ((CPerlObj*)pPerl)->Perl_save_long(longp); -} - -#undef Perl_save_nogv -void -Perl_save_nogv(pTHXo_ GV* gv) -{ - ((CPerlObj*)pPerl)->Perl_save_nogv(gv); -} - -#undef Perl_save_op -void -Perl_save_op(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_save_op(); -} - -#undef Perl_save_scalar -SV* -Perl_save_scalar(pTHXo_ GV* gv) -{ - return ((CPerlObj*)pPerl)->Perl_save_scalar(gv); -} - -#undef Perl_save_pptr -void -Perl_save_pptr(pTHXo_ char** pptr) -{ - ((CPerlObj*)pPerl)->Perl_save_pptr(pptr); -} - -#undef Perl_save_vptr -void -Perl_save_vptr(pTHXo_ void* pptr) -{ - ((CPerlObj*)pPerl)->Perl_save_vptr(pptr); -} - -#undef Perl_save_re_context -void -Perl_save_re_context(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_save_re_context(); -} - -#undef Perl_save_sptr -void -Perl_save_sptr(pTHXo_ SV** sptr) -{ - ((CPerlObj*)pPerl)->Perl_save_sptr(sptr); -} - -#undef Perl_save_svref -SV* -Perl_save_svref(pTHXo_ SV** sptr) -{ - return ((CPerlObj*)pPerl)->Perl_save_svref(sptr); -} - -#undef Perl_save_threadsv -SV** -Perl_save_threadsv(pTHXo_ PADOFFSET i) -{ - return ((CPerlObj*)pPerl)->Perl_save_threadsv(i); -} - -#undef Perl_sawparens -OP* -Perl_sawparens(pTHXo_ OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_sawparens(o); -} - -#undef Perl_scalar -OP* -Perl_scalar(pTHXo_ OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_scalar(o); -} - -#undef Perl_scalarkids -OP* -Perl_scalarkids(pTHXo_ OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_scalarkids(o); -} - -#undef Perl_scalarseq -OP* -Perl_scalarseq(pTHXo_ OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_scalarseq(o); -} - -#undef Perl_scalarvoid -OP* -Perl_scalarvoid(pTHXo_ OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_scalarvoid(o); -} - -#undef Perl_scan_bin -NV -Perl_scan_bin(pTHXo_ char* start, I32 len, I32* retlen) -{ - return ((CPerlObj*)pPerl)->Perl_scan_bin(start, len, retlen); -} - -#undef Perl_scan_hex -NV -Perl_scan_hex(pTHXo_ char* start, I32 len, I32* retlen) -{ - return ((CPerlObj*)pPerl)->Perl_scan_hex(start, len, retlen); -} - -#undef Perl_scan_num -char* -Perl_scan_num(pTHXo_ char* s) -{ - return ((CPerlObj*)pPerl)->Perl_scan_num(s); -} - -#undef Perl_scan_oct -NV -Perl_scan_oct(pTHXo_ char* start, I32 len, I32* retlen) -{ - return ((CPerlObj*)pPerl)->Perl_scan_oct(start, len, retlen); -} - -#undef Perl_scope -OP* -Perl_scope(pTHXo_ OP* o) -{ - return ((CPerlObj*)pPerl)->Perl_scope(o); -} - -#undef Perl_screaminstr -char* -Perl_screaminstr(pTHXo_ 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(pTHXo_ char* nam) -{ - return ((CPerlObj*)pPerl)->Perl_setenv_getix(nam); -} -#endif - -#undef Perl_setdefout -void -Perl_setdefout(pTHXo_ GV* gv) -{ - ((CPerlObj*)pPerl)->Perl_setdefout(gv); -} - -#undef Perl_sharepvn -char* -Perl_sharepvn(pTHXo_ const char* sv, I32 len, U32 hash) -{ - return ((CPerlObj*)pPerl)->Perl_sharepvn(sv, len, hash); -} - -#undef Perl_share_hek -HEK* -Perl_share_hek(pTHXo_ const char* sv, I32 len, U32 hash) -{ - return ((CPerlObj*)pPerl)->Perl_share_hek(sv, len, hash); -} - -#undef Perl_sighandler -Signal_t -Perl_sighandler(int sig) -{ - dTHXo; - ((CPerlObj*)pPerl)->Perl_sighandler(sig); -} - -#undef Perl_stack_grow -SV** -Perl_stack_grow(pTHXo_ SV** sp, SV**p, int n) -{ - return ((CPerlObj*)pPerl)->Perl_stack_grow(sp, p, n); -} - -#undef Perl_start_subparse -I32 -Perl_start_subparse(pTHXo_ I32 is_format, U32 flags) -{ - return ((CPerlObj*)pPerl)->Perl_start_subparse(is_format, flags); -} - -#undef Perl_sub_crush_depth -void -Perl_sub_crush_depth(pTHXo_ CV* cv) -{ - ((CPerlObj*)pPerl)->Perl_sub_crush_depth(cv); -} - -#undef Perl_sv_2bool -bool -Perl_sv_2bool(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_2bool(sv); -} - -#undef Perl_sv_2cv -CV* -Perl_sv_2cv(pTHXo_ 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(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_2io(sv); -} - -#undef Perl_sv_2iv -IV -Perl_sv_2iv(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_2iv(sv); -} - -#undef Perl_sv_2mortal -SV* -Perl_sv_2mortal(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_2mortal(sv); -} - -#undef Perl_sv_2nv -NV -Perl_sv_2nv(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_2nv(sv); -} - -#undef Perl_sv_2pv -char* -Perl_sv_2pv(pTHXo_ SV* sv, STRLEN* lp) -{ - return ((CPerlObj*)pPerl)->Perl_sv_2pv(sv, lp); -} - -#undef Perl_sv_2pvutf8 -char* -Perl_sv_2pvutf8(pTHXo_ SV* sv, STRLEN* lp) -{ - return ((CPerlObj*)pPerl)->Perl_sv_2pvutf8(sv, lp); -} - -#undef Perl_sv_2pvbyte -char* -Perl_sv_2pvbyte(pTHXo_ SV* sv, STRLEN* lp) -{ - return ((CPerlObj*)pPerl)->Perl_sv_2pvbyte(sv, lp); -} - -#undef Perl_sv_2uv -UV -Perl_sv_2uv(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_2uv(sv); -} - -#undef Perl_sv_iv -IV -Perl_sv_iv(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_iv(sv); -} - -#undef Perl_sv_uv -UV -Perl_sv_uv(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_uv(sv); -} - -#undef Perl_sv_nv -NV -Perl_sv_nv(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_nv(sv); -} - -#undef Perl_sv_pvn -char* -Perl_sv_pvn(pTHXo_ SV *sv, STRLEN *len) -{ - return ((CPerlObj*)pPerl)->Perl_sv_pvn(sv, len); -} - -#undef Perl_sv_pvutf8n -char* -Perl_sv_pvutf8n(pTHXo_ SV *sv, STRLEN *len) -{ - return ((CPerlObj*)pPerl)->Perl_sv_pvutf8n(sv, len); -} - -#undef Perl_sv_pvbyten -char* -Perl_sv_pvbyten(pTHXo_ SV *sv, STRLEN *len) -{ - return ((CPerlObj*)pPerl)->Perl_sv_pvbyten(sv, len); -} - -#undef Perl_sv_true -I32 -Perl_sv_true(pTHXo_ SV *sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_true(sv); -} - -#undef Perl_sv_add_arena -void -Perl_sv_add_arena(pTHXo_ char* ptr, U32 size, U32 flags) -{ - ((CPerlObj*)pPerl)->Perl_sv_add_arena(ptr, size, flags); -} - -#undef Perl_sv_backoff -int -Perl_sv_backoff(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_backoff(sv); -} - -#undef Perl_sv_bless -SV* -Perl_sv_bless(pTHXo_ SV* sv, HV* stash) -{ - return ((CPerlObj*)pPerl)->Perl_sv_bless(sv, stash); -} - -#undef Perl_sv_catpvf -void -Perl_sv_catpvf(pTHXo_ SV* sv, const char* pat, ...) -{ - va_list args; - va_start(args, pat); - ((CPerlObj*)pPerl)->Perl_sv_vcatpvf(sv, pat, &args); - va_end(args); -} - -#undef Perl_sv_vcatpvf -void -Perl_sv_vcatpvf(pTHXo_ SV* sv, const char* pat, va_list* args) -{ - ((CPerlObj*)pPerl)->Perl_sv_vcatpvf(sv, pat, args); -} - -#undef Perl_sv_catpv -void -Perl_sv_catpv(pTHXo_ SV* sv, const char* ptr) -{ - ((CPerlObj*)pPerl)->Perl_sv_catpv(sv, ptr); -} - -#undef Perl_sv_catpvn -void -Perl_sv_catpvn(pTHXo_ SV* sv, const char* ptr, STRLEN len) -{ - ((CPerlObj*)pPerl)->Perl_sv_catpvn(sv, ptr, len); -} - -#undef Perl_sv_catsv -void -Perl_sv_catsv(pTHXo_ SV* dsv, SV* ssv) -{ - ((CPerlObj*)pPerl)->Perl_sv_catsv(dsv, ssv); -} - -#undef Perl_sv_chop -void -Perl_sv_chop(pTHXo_ SV* sv, char* ptr) -{ - ((CPerlObj*)pPerl)->Perl_sv_chop(sv, ptr); -} - -#undef Perl_sv_clean_all -void -Perl_sv_clean_all(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_sv_clean_all(); -} - -#undef Perl_sv_clean_objs -void -Perl_sv_clean_objs(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_sv_clean_objs(); -} - -#undef Perl_sv_clear -void -Perl_sv_clear(pTHXo_ SV* sv) -{ - ((CPerlObj*)pPerl)->Perl_sv_clear(sv); -} - -#undef Perl_sv_cmp -I32 -Perl_sv_cmp(pTHXo_ SV* sv1, SV* sv2) -{ - return ((CPerlObj*)pPerl)->Perl_sv_cmp(sv1, sv2); -} - -#undef Perl_sv_cmp_locale -I32 -Perl_sv_cmp_locale(pTHXo_ 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(pTHXo_ SV* sv, STRLEN* nxp) -{ - return ((CPerlObj*)pPerl)->Perl_sv_collxfrm(sv, nxp); -} -#endif - -#undef Perl_sv_compile_2op -OP* -Perl_sv_compile_2op(pTHXo_ 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(pTHXo_ SV* sv) -{ - ((CPerlObj*)pPerl)->Perl_sv_dec(sv); -} - -#undef Perl_sv_dump -void -Perl_sv_dump(pTHXo_ SV* sv) -{ - ((CPerlObj*)pPerl)->Perl_sv_dump(sv); -} - -#undef Perl_sv_derived_from -bool -Perl_sv_derived_from(pTHXo_ SV* sv, const char* name) -{ - return ((CPerlObj*)pPerl)->Perl_sv_derived_from(sv, name); -} - -#undef Perl_sv_eq -I32 -Perl_sv_eq(pTHXo_ SV* sv1, SV* sv2) -{ - return ((CPerlObj*)pPerl)->Perl_sv_eq(sv1, sv2); -} - -#undef Perl_sv_free -void -Perl_sv_free(pTHXo_ SV* sv) -{ - ((CPerlObj*)pPerl)->Perl_sv_free(sv); -} - -#undef Perl_sv_free_arenas -void -Perl_sv_free_arenas(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_sv_free_arenas(); -} - -#undef Perl_sv_gets -char* -Perl_sv_gets(pTHXo_ SV* sv, PerlIO* fp, I32 append) -{ - return ((CPerlObj*)pPerl)->Perl_sv_gets(sv, fp, append); -} - -#undef Perl_sv_grow -char* -Perl_sv_grow(pTHXo_ SV* sv, STRLEN newlen) -{ - return ((CPerlObj*)pPerl)->Perl_sv_grow(sv, newlen); -} - -#undef Perl_sv_inc -void -Perl_sv_inc(pTHXo_ SV* sv) -{ - ((CPerlObj*)pPerl)->Perl_sv_inc(sv); -} - -#undef Perl_sv_insert -void -Perl_sv_insert(pTHXo_ 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(pTHXo_ SV* sv, const char* name) -{ - return ((CPerlObj*)pPerl)->Perl_sv_isa(sv, name); -} - -#undef Perl_sv_isobject -int -Perl_sv_isobject(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_isobject(sv); -} - -#undef Perl_sv_len -STRLEN -Perl_sv_len(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_len(sv); -} - -#undef Perl_sv_len_utf8 -STRLEN -Perl_sv_len_utf8(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_len_utf8(sv); -} - -#undef Perl_sv_magic -void -Perl_sv_magic(pTHXo_ 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(pTHXo_ SV* oldsv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_mortalcopy(oldsv); -} - -#undef Perl_sv_newmortal -SV* -Perl_sv_newmortal(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_sv_newmortal(); -} - -#undef Perl_sv_newref -SV* -Perl_sv_newref(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_newref(sv); -} - -#undef Perl_sv_peek -char* -Perl_sv_peek(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_peek(sv); -} - -#undef Perl_sv_pos_u2b -void -Perl_sv_pos_u2b(pTHXo_ 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(pTHXo_ SV* sv, I32* offsetp) -{ - ((CPerlObj*)pPerl)->Perl_sv_pos_b2u(sv, offsetp); -} - -#undef Perl_sv_pvn_force -char* -Perl_sv_pvn_force(pTHXo_ SV* sv, STRLEN* lp) -{ - return ((CPerlObj*)pPerl)->Perl_sv_pvn_force(sv, lp); -} - -#undef Perl_sv_pvutf8n_force -char* -Perl_sv_pvutf8n_force(pTHXo_ SV* sv, STRLEN* lp) -{ - return ((CPerlObj*)pPerl)->Perl_sv_pvutf8n_force(sv, lp); -} - -#undef Perl_sv_pvbyten_force -char* -Perl_sv_pvbyten_force(pTHXo_ SV* sv, STRLEN* lp) -{ - return ((CPerlObj*)pPerl)->Perl_sv_pvbyten_force(sv, lp); -} - -#undef Perl_sv_reftype -char* -Perl_sv_reftype(pTHXo_ SV* sv, int ob) -{ - return ((CPerlObj*)pPerl)->Perl_sv_reftype(sv, ob); -} - -#undef Perl_sv_replace -void -Perl_sv_replace(pTHXo_ SV* sv, SV* nsv) -{ - ((CPerlObj*)pPerl)->Perl_sv_replace(sv, nsv); -} - -#undef Perl_sv_report_used -void -Perl_sv_report_used(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_sv_report_used(); -} - -#undef Perl_sv_reset -void -Perl_sv_reset(pTHXo_ char* s, HV* stash) -{ - ((CPerlObj*)pPerl)->Perl_sv_reset(s, stash); -} - -#undef Perl_sv_setpvf -void -Perl_sv_setpvf(pTHXo_ SV* sv, const char* pat, ...) -{ - va_list args; - va_start(args, pat); - ((CPerlObj*)pPerl)->Perl_sv_vsetpvf(sv, pat, &args); - va_end(args); -} - -#undef Perl_sv_vsetpvf -void -Perl_sv_vsetpvf(pTHXo_ SV* sv, const char* pat, va_list* args) -{ - ((CPerlObj*)pPerl)->Perl_sv_vsetpvf(sv, pat, args); -} - -#undef Perl_sv_setiv -void -Perl_sv_setiv(pTHXo_ SV* sv, IV num) -{ - ((CPerlObj*)pPerl)->Perl_sv_setiv(sv, num); -} - -#undef Perl_sv_setpviv -void -Perl_sv_setpviv(pTHXo_ SV* sv, IV num) -{ - ((CPerlObj*)pPerl)->Perl_sv_setpviv(sv, num); -} - -#undef Perl_sv_setuv -void -Perl_sv_setuv(pTHXo_ SV* sv, UV num) -{ - ((CPerlObj*)pPerl)->Perl_sv_setuv(sv, num); -} - -#undef Perl_sv_setnv -void -Perl_sv_setnv(pTHXo_ SV* sv, NV num) -{ - ((CPerlObj*)pPerl)->Perl_sv_setnv(sv, num); -} - -#undef Perl_sv_setref_iv -SV* -Perl_sv_setref_iv(pTHXo_ 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(pTHXo_ 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(pTHXo_ 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(pTHXo_ 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(pTHXo_ SV* sv, const char* ptr) -{ - ((CPerlObj*)pPerl)->Perl_sv_setpv(sv, ptr); -} - -#undef Perl_sv_setpvn -void -Perl_sv_setpvn(pTHXo_ SV* sv, const char* ptr, STRLEN len) -{ - ((CPerlObj*)pPerl)->Perl_sv_setpvn(sv, ptr, len); -} - -#undef Perl_sv_setsv -void -Perl_sv_setsv(pTHXo_ SV* dsv, SV* ssv) -{ - ((CPerlObj*)pPerl)->Perl_sv_setsv(dsv, ssv); -} - -#undef Perl_sv_taint -void -Perl_sv_taint(pTHXo_ SV* sv) -{ - ((CPerlObj*)pPerl)->Perl_sv_taint(sv); -} - -#undef Perl_sv_tainted -bool -Perl_sv_tainted(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_tainted(sv); -} - -#undef Perl_sv_unmagic -int -Perl_sv_unmagic(pTHXo_ SV* sv, int type) -{ - return ((CPerlObj*)pPerl)->Perl_sv_unmagic(sv, type); -} - -#undef Perl_sv_unref -void -Perl_sv_unref(pTHXo_ SV* sv) -{ - ((CPerlObj*)pPerl)->Perl_sv_unref(sv); -} - -#undef Perl_sv_untaint -void -Perl_sv_untaint(pTHXo_ SV* sv) -{ - ((CPerlObj*)pPerl)->Perl_sv_untaint(sv); -} - -#undef Perl_sv_upgrade -bool -Perl_sv_upgrade(pTHXo_ SV* sv, U32 mt) -{ - return ((CPerlObj*)pPerl)->Perl_sv_upgrade(sv, mt); -} - -#undef Perl_sv_usepvn -void -Perl_sv_usepvn(pTHXo_ SV* sv, char* ptr, STRLEN len) -{ - ((CPerlObj*)pPerl)->Perl_sv_usepvn(sv, ptr, len); -} - -#undef Perl_sv_vcatpvfn -void -Perl_sv_vcatpvfn(pTHXo_ SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted) -{ - ((CPerlObj*)pPerl)->Perl_sv_vcatpvfn(sv, pat, patlen, args, svargs, svmax, maybe_tainted); -} - -#undef Perl_sv_vsetpvfn -void -Perl_sv_vsetpvfn(pTHXo_ SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted) -{ - ((CPerlObj*)pPerl)->Perl_sv_vsetpvfn(sv, pat, patlen, args, svargs, svmax, maybe_tainted); -} - -#undef Perl_swash_init -SV* -Perl_swash_init(pTHXo_ 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(pTHXo_ SV *sv, U8 *ptr) -{ - return ((CPerlObj*)pPerl)->Perl_swash_fetch(sv, ptr); -} - -#undef Perl_taint_env -void -Perl_taint_env(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_taint_env(); -} - -#undef Perl_taint_proper -void -Perl_taint_proper(pTHXo_ const char* f, const char* s) -{ - ((CPerlObj*)pPerl)->Perl_taint_proper(f, s); -} - -#undef Perl_to_utf8_lower -UV -Perl_to_utf8_lower(pTHXo_ U8 *p) -{ - return ((CPerlObj*)pPerl)->Perl_to_utf8_lower(p); -} - -#undef Perl_to_utf8_upper -UV -Perl_to_utf8_upper(pTHXo_ U8 *p) -{ - return ((CPerlObj*)pPerl)->Perl_to_utf8_upper(p); -} - -#undef Perl_to_utf8_title -UV -Perl_to_utf8_title(pTHXo_ U8 *p) -{ - return ((CPerlObj*)pPerl)->Perl_to_utf8_title(p); -} -#if defined(UNLINK_ALL_VERSIONS) - -#undef Perl_unlnk -I32 -Perl_unlnk(pTHXo_ char* f) -{ - return ((CPerlObj*)pPerl)->Perl_unlnk(f); -} -#endif -#if defined(USE_THREADS) - -#undef Perl_unlock_condpair -void -Perl_unlock_condpair(pTHXo_ void* svv) -{ - ((CPerlObj*)pPerl)->Perl_unlock_condpair(svv); -} -#endif - -#undef Perl_unsharepvn -void -Perl_unsharepvn(pTHXo_ const char* sv, I32 len, U32 hash) -{ - ((CPerlObj*)pPerl)->Perl_unsharepvn(sv, len, hash); -} - -#undef Perl_unshare_hek -void -Perl_unshare_hek(pTHXo_ HEK* hek) -{ - ((CPerlObj*)pPerl)->Perl_unshare_hek(hek); -} - -#undef Perl_utilize -void -Perl_utilize(pTHXo_ 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(pTHXo_ 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(pTHXo_ 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(pTHXo_ U8 *a, U8 *b) -{ - return ((CPerlObj*)pPerl)->Perl_utf8_distance(a, b); -} - -#undef Perl_utf8_hop -U8* -Perl_utf8_hop(pTHXo_ U8 *s, I32 off) -{ - return ((CPerlObj*)pPerl)->Perl_utf8_hop(s, off); -} - -#undef Perl_utf8_to_uv -UV -Perl_utf8_to_uv(pTHXo_ U8 *s, I32* retlen) -{ - return ((CPerlObj*)pPerl)->Perl_utf8_to_uv(s, retlen); -} - -#undef Perl_uv_to_utf8 -U8* -Perl_uv_to_utf8(pTHXo_ U8 *d, UV uv) -{ - return ((CPerlObj*)pPerl)->Perl_uv_to_utf8(d, uv); -} - -#undef Perl_vivify_defelem -void -Perl_vivify_defelem(pTHXo_ SV* sv) -{ - ((CPerlObj*)pPerl)->Perl_vivify_defelem(sv); -} - -#undef Perl_vivify_ref -void -Perl_vivify_ref(pTHXo_ SV* sv, U32 to_what) -{ - ((CPerlObj*)pPerl)->Perl_vivify_ref(sv, to_what); -} - -#undef Perl_wait4pid -I32 -Perl_wait4pid(pTHXo_ Pid_t pid, int* statusp, int flags) -{ - return ((CPerlObj*)pPerl)->Perl_wait4pid(pid, statusp, flags); -} - -#undef Perl_report_closed_fh -void -Perl_report_closed_fh(pTHXo_ GV *gv, IO *io, const char *func, const char *obj) -{ - ((CPerlObj*)pPerl)->Perl_report_closed_fh(gv, io, func, obj); -} - -#undef Perl_report_uninit -void -Perl_report_uninit(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_report_uninit(); -} - -#undef Perl_warn -void -Perl_warn(pTHXo_ const char* pat, ...) -{ - va_list args; - va_start(args, pat); - ((CPerlObj*)pPerl)->Perl_vwarn(pat, &args); - va_end(args); -} - -#undef Perl_vwarn -void -Perl_vwarn(pTHXo_ const char* pat, va_list* args) -{ - ((CPerlObj*)pPerl)->Perl_vwarn(pat, args); -} - -#undef Perl_warner -void -Perl_warner(pTHXo_ U32 err, const char* pat, ...) -{ - va_list args; - va_start(args, pat); - ((CPerlObj*)pPerl)->Perl_vwarner(err, pat, &args); - va_end(args); -} - -#undef Perl_vwarner -void -Perl_vwarner(pTHXo_ U32 err, const char* pat, va_list* args) -{ - ((CPerlObj*)pPerl)->Perl_vwarner(err, pat, args); -} - -#undef Perl_watch -void -Perl_watch(pTHXo_ char** addr) -{ - ((CPerlObj*)pPerl)->Perl_watch(addr); -} - -#undef Perl_whichsig -I32 -Perl_whichsig(pTHXo_ char* sig) -{ - return ((CPerlObj*)pPerl)->Perl_whichsig(sig); -} - -#undef Perl_yyerror -int -Perl_yyerror(pTHXo_ char* s) -{ - return ((CPerlObj*)pPerl)->Perl_yyerror(s); -} -#if defined(USE_PURE_BISON) - -#undef Perl_yylex -int -Perl_yylex(pTHXo_ YYSTYPE *lvalp, int *lcharp) -{ - return ((CPerlObj*)pPerl)->Perl_yylex(lvalp, lcharp); -} -#else - -#undef Perl_yylex -int -Perl_yylex(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_yylex(); -} -#endif - -#undef Perl_yyparse -int -Perl_yyparse(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_yyparse(); -} - -#undef Perl_yywarn -int -Perl_yywarn(pTHXo_ char* s) -{ - return ((CPerlObj*)pPerl)->Perl_yywarn(s); -} -#if defined(MYMALLOC) - -#undef Perl_dump_mstats -void -Perl_dump_mstats(pTHXo_ char* s) -{ - ((CPerlObj*)pPerl)->Perl_dump_mstats(s); -} -#endif - -#undef Perl_safesysmalloc -Malloc_t -Perl_safesysmalloc(MEM_SIZE nbytes) -{ - dTHXo; - return ((CPerlObj*)pPerl)->Perl_safesysmalloc(nbytes); -} - -#undef Perl_safesyscalloc -Malloc_t -Perl_safesyscalloc(MEM_SIZE elements, MEM_SIZE size) -{ - dTHXo; - return ((CPerlObj*)pPerl)->Perl_safesyscalloc(elements, size); -} - -#undef Perl_safesysrealloc -Malloc_t -Perl_safesysrealloc(Malloc_t where, MEM_SIZE nbytes) -{ - dTHXo; - return ((CPerlObj*)pPerl)->Perl_safesysrealloc(where, nbytes); -} - -#undef Perl_safesysfree -Free_t -Perl_safesysfree(Malloc_t where) -{ - dTHXo; - ((CPerlObj*)pPerl)->Perl_safesysfree(where); -} -#if defined(LEAKTEST) - -#undef Perl_safexmalloc -Malloc_t -Perl_safexmalloc(I32 x, MEM_SIZE size) -{ - dTHXo; - return ((CPerlObj*)pPerl)->Perl_safexmalloc(x, size); -} - -#undef Perl_safexcalloc -Malloc_t -Perl_safexcalloc(I32 x, MEM_SIZE elements, MEM_SIZE size) -{ - dTHXo; - return ((CPerlObj*)pPerl)->Perl_safexcalloc(x, elements, size); -} - -#undef Perl_safexrealloc -Malloc_t -Perl_safexrealloc(Malloc_t where, MEM_SIZE size) -{ - dTHXo; - return ((CPerlObj*)pPerl)->Perl_safexrealloc(where, size); -} - -#undef Perl_safexfree -void -Perl_safexfree(Malloc_t where) -{ - dTHXo; - ((CPerlObj*)pPerl)->Perl_safexfree(where); -} -#endif -#if defined(PERL_GLOBAL_STRUCT) - -#undef Perl_GetVars -struct perl_vars * -Perl_GetVars(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_GetVars(); -} -#endif - -#undef Perl_runops_standard -int -Perl_runops_standard(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_runops_standard(); -} - -#undef Perl_runops_debug -int -Perl_runops_debug(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_runops_debug(); -} - -#undef Perl_sv_catpvf_mg -void -Perl_sv_catpvf_mg(pTHXo_ SV *sv, const char* pat, ...) -{ - va_list args; - va_start(args, pat); - ((CPerlObj*)pPerl)->Perl_sv_vcatpvf_mg(sv, pat, &args); - va_end(args); -} - -#undef Perl_sv_vcatpvf_mg -void -Perl_sv_vcatpvf_mg(pTHXo_ SV* sv, const char* pat, va_list* args) -{ - ((CPerlObj*)pPerl)->Perl_sv_vcatpvf_mg(sv, pat, args); -} - -#undef Perl_sv_catpv_mg -void -Perl_sv_catpv_mg(pTHXo_ SV *sv, const char *ptr) -{ - ((CPerlObj*)pPerl)->Perl_sv_catpv_mg(sv, ptr); -} - -#undef Perl_sv_catpvn_mg -void -Perl_sv_catpvn_mg(pTHXo_ 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(pTHXo_ SV *dstr, SV *sstr) -{ - ((CPerlObj*)pPerl)->Perl_sv_catsv_mg(dstr, sstr); -} - -#undef Perl_sv_setpvf_mg -void -Perl_sv_setpvf_mg(pTHXo_ SV *sv, const char* pat, ...) -{ - va_list args; - va_start(args, pat); - ((CPerlObj*)pPerl)->Perl_sv_vsetpvf_mg(sv, pat, &args); - va_end(args); -} - -#undef Perl_sv_vsetpvf_mg -void -Perl_sv_vsetpvf_mg(pTHXo_ SV* sv, const char* pat, va_list* args) -{ - ((CPerlObj*)pPerl)->Perl_sv_vsetpvf_mg(sv, pat, args); -} - -#undef Perl_sv_setiv_mg -void -Perl_sv_setiv_mg(pTHXo_ SV *sv, IV i) -{ - ((CPerlObj*)pPerl)->Perl_sv_setiv_mg(sv, i); -} - -#undef Perl_sv_setpviv_mg -void -Perl_sv_setpviv_mg(pTHXo_ SV *sv, IV iv) -{ - ((CPerlObj*)pPerl)->Perl_sv_setpviv_mg(sv, iv); -} - -#undef Perl_sv_setuv_mg -void -Perl_sv_setuv_mg(pTHXo_ SV *sv, UV u) -{ - ((CPerlObj*)pPerl)->Perl_sv_setuv_mg(sv, u); -} - -#undef Perl_sv_setnv_mg -void -Perl_sv_setnv_mg(pTHXo_ SV *sv, NV num) -{ - ((CPerlObj*)pPerl)->Perl_sv_setnv_mg(sv, num); -} - -#undef Perl_sv_setpv_mg -void -Perl_sv_setpv_mg(pTHXo_ SV *sv, const char *ptr) -{ - ((CPerlObj*)pPerl)->Perl_sv_setpv_mg(sv, ptr); -} - -#undef Perl_sv_setpvn_mg -void -Perl_sv_setpvn_mg(pTHXo_ 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(pTHXo_ SV *dstr, SV *sstr) -{ - ((CPerlObj*)pPerl)->Perl_sv_setsv_mg(dstr, sstr); -} - -#undef Perl_sv_usepvn_mg -void -Perl_sv_usepvn_mg(pTHXo_ SV *sv, char *ptr, STRLEN len) -{ - ((CPerlObj*)pPerl)->Perl_sv_usepvn_mg(sv, ptr, len); -} - -#undef Perl_get_vtbl -MGVTBL* -Perl_get_vtbl(pTHXo_ int vtbl_id) -{ - return ((CPerlObj*)pPerl)->Perl_get_vtbl(vtbl_id); -} - -#undef Perl_pv_display -char* -Perl_pv_display(pTHXo_ SV *sv, char *pv, STRLEN cur, STRLEN len, STRLEN pvlim) -{ - return ((CPerlObj*)pPerl)->Perl_pv_display(sv, pv, cur, len, pvlim); -} - -#undef Perl_dump_indent -void -Perl_dump_indent(pTHXo_ I32 level, PerlIO *file, const char* pat, ...) -{ - va_list args; - va_start(args, pat); - ((CPerlObj*)pPerl)->Perl_dump_vindent(level, file, pat, &args); - va_end(args); -} - -#undef Perl_dump_vindent -void -Perl_dump_vindent(pTHXo_ I32 level, PerlIO *file, const char* pat, va_list *args) -{ - ((CPerlObj*)pPerl)->Perl_dump_vindent(level, file, pat, args); -} - -#undef Perl_do_gv_dump -void -Perl_do_gv_dump(pTHXo_ 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(pTHXo_ 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(pTHXo_ 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(pTHXo_ 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(pTHXo_ 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(pTHXo_ 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(pTHXo_ 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(pTHXo_ MAGIC *mg) -{ - ((CPerlObj*)pPerl)->Perl_magic_dump(mg); -} - -#undef Perl_default_protect -void* -Perl_default_protect(pTHXo_ volatile JMPENV *je, int *excpt, protect_body_t body, ...) -{ - void* retval; - va_list args; - va_start(args, body); - retval = ((CPerlObj*)pPerl)->Perl_vdefault_protect(je, excpt, body, &args); - va_end(args); - return retval; - -} - -#undef Perl_vdefault_protect -void* -Perl_vdefault_protect(pTHXo_ volatile JMPENV *je, int *excpt, protect_body_t body, va_list *args) -{ - return ((CPerlObj*)pPerl)->Perl_vdefault_protect(je, excpt, body, args); -} - -#undef Perl_reginitcolors -void -Perl_reginitcolors(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_reginitcolors(); -} - -#undef Perl_sv_2pv_nolen -char* -Perl_sv_2pv_nolen(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_2pv_nolen(sv); -} - -#undef Perl_sv_2pvutf8_nolen -char* -Perl_sv_2pvutf8_nolen(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_2pvutf8_nolen(sv); -} - -#undef Perl_sv_2pvbyte_nolen -char* -Perl_sv_2pvbyte_nolen(pTHXo_ SV* sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_2pvbyte_nolen(sv); -} - -#undef Perl_sv_pv -char* -Perl_sv_pv(pTHXo_ SV *sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_pv(sv); -} - -#undef Perl_sv_pvutf8 -char* -Perl_sv_pvutf8(pTHXo_ SV *sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_pvutf8(sv); -} - -#undef Perl_sv_pvbyte -char* -Perl_sv_pvbyte(pTHXo_ SV *sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_pvbyte(sv); -} - -#undef Perl_sv_force_normal -void -Perl_sv_force_normal(pTHXo_ SV *sv) -{ - ((CPerlObj*)pPerl)->Perl_sv_force_normal(sv); -} - -#undef Perl_tmps_grow -void -Perl_tmps_grow(pTHXo_ I32 n) -{ - ((CPerlObj*)pPerl)->Perl_tmps_grow(n); -} - -#undef Perl_sv_rvweaken -SV* -Perl_sv_rvweaken(pTHXo_ SV *sv) -{ - return ((CPerlObj*)pPerl)->Perl_sv_rvweaken(sv); -} - -#undef Perl_magic_killbackrefs -int -Perl_magic_killbackrefs(pTHXo_ SV *sv, MAGIC *mg) -{ - return ((CPerlObj*)pPerl)->Perl_magic_killbackrefs(sv, mg); -} - -#undef Perl_newANONATTRSUB -OP* -Perl_newANONATTRSUB(pTHXo_ I32 floor, OP *proto, OP *attrs, OP *block) -{ - return ((CPerlObj*)pPerl)->Perl_newANONATTRSUB(floor, proto, attrs, block); -} - -#undef Perl_newATTRSUB -CV* -Perl_newATTRSUB(pTHXo_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) -{ - return ((CPerlObj*)pPerl)->Perl_newATTRSUB(floor, o, proto, attrs, block); -} - -#undef Perl_newMYSUB -void -Perl_newMYSUB(pTHXo_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) -{ - ((CPerlObj*)pPerl)->Perl_newMYSUB(floor, o, proto, attrs, block); -} - -#undef Perl_my_attrs -OP * -Perl_my_attrs(pTHXo_ OP *o, OP *attrs) -{ - return ((CPerlObj*)pPerl)->Perl_my_attrs(o, attrs); -} - -#undef Perl_boot_core_xsutils -void -Perl_boot_core_xsutils(pTHXo) -{ - ((CPerlObj*)pPerl)->Perl_boot_core_xsutils(); -} -#if defined(USE_ITHREADS) - -#undef Perl_cx_dup -PERL_CONTEXT* -Perl_cx_dup(pTHXo_ PERL_CONTEXT* cx, I32 ix, I32 max) -{ - return ((CPerlObj*)pPerl)->Perl_cx_dup(cx, ix, max); -} - -#undef Perl_si_dup -PERL_SI* -Perl_si_dup(pTHXo_ PERL_SI* si) -{ - return ((CPerlObj*)pPerl)->Perl_si_dup(si); -} - -#undef Perl_ss_dup -ANY* -Perl_ss_dup(pTHXo_ PerlInterpreter* proto_perl) -{ - return ((CPerlObj*)pPerl)->Perl_ss_dup(proto_perl); -} - -#undef Perl_any_dup -void* -Perl_any_dup(pTHXo_ void* v, PerlInterpreter* proto_perl) -{ - return ((CPerlObj*)pPerl)->Perl_any_dup(v, proto_perl); -} - -#undef Perl_he_dup -HE* -Perl_he_dup(pTHXo_ HE* e, bool shared) -{ - return ((CPerlObj*)pPerl)->Perl_he_dup(e, shared); -} - -#undef Perl_re_dup -REGEXP* -Perl_re_dup(pTHXo_ REGEXP* r) -{ - return ((CPerlObj*)pPerl)->Perl_re_dup(r); -} - -#undef Perl_fp_dup -PerlIO* -Perl_fp_dup(pTHXo_ PerlIO* fp, char type) -{ - return ((CPerlObj*)pPerl)->Perl_fp_dup(fp, type); -} - -#undef Perl_dirp_dup -DIR* -Perl_dirp_dup(pTHXo_ DIR* dp) -{ - return ((CPerlObj*)pPerl)->Perl_dirp_dup(dp); -} - -#undef Perl_gp_dup -GP* -Perl_gp_dup(pTHXo_ GP* gp) -{ - return ((CPerlObj*)pPerl)->Perl_gp_dup(gp); -} - -#undef Perl_mg_dup -MAGIC* -Perl_mg_dup(pTHXo_ MAGIC* mg) -{ - return ((CPerlObj*)pPerl)->Perl_mg_dup(mg); -} - -#undef Perl_sv_dup -SV* -Perl_sv_dup(pTHXo_ SV* sstr) -{ - return ((CPerlObj*)pPerl)->Perl_sv_dup(sstr); -} -#if defined(HAVE_INTERP_INTERN) - -#undef Perl_sys_intern_dup -void -Perl_sys_intern_dup(pTHXo_ struct interp_intern* src, struct interp_intern* dst) -{ - ((CPerlObj*)pPerl)->Perl_sys_intern_dup(src, dst); -} -#endif - -#undef Perl_ptr_table_new -PTR_TBL_t* -Perl_ptr_table_new(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_ptr_table_new(); -} - -#undef Perl_ptr_table_fetch -void* -Perl_ptr_table_fetch(pTHXo_ PTR_TBL_t *tbl, void *sv) -{ - return ((CPerlObj*)pPerl)->Perl_ptr_table_fetch(tbl, sv); -} - -#undef Perl_ptr_table_store -void -Perl_ptr_table_store(pTHXo_ PTR_TBL_t *tbl, void *oldsv, void *newsv) -{ - ((CPerlObj*)pPerl)->Perl_ptr_table_store(tbl, oldsv, newsv); -} - -#undef Perl_ptr_table_split -void -Perl_ptr_table_split(pTHXo_ PTR_TBL_t *tbl) -{ - ((CPerlObj*)pPerl)->Perl_ptr_table_split(tbl); -} -#endif -#if defined(PERL_OBJECT) -#else -#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(PERL_CR_FILTER) -# 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 -#if defined(PERL_OBJECT) -#endif - -#undef Perl_ck_anoncode -OP * -Perl_ck_anoncode(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_anoncode(o); -} - -#undef Perl_ck_bitop -OP * -Perl_ck_bitop(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_bitop(o); -} - -#undef Perl_ck_concat -OP * -Perl_ck_concat(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_concat(o); -} - -#undef Perl_ck_defined -OP * -Perl_ck_defined(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_defined(o); -} - -#undef Perl_ck_delete -OP * -Perl_ck_delete(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_delete(o); -} - -#undef Perl_ck_eof -OP * -Perl_ck_eof(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_eof(o); -} - -#undef Perl_ck_eval -OP * -Perl_ck_eval(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_eval(o); -} - -#undef Perl_ck_exec -OP * -Perl_ck_exec(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_exec(o); -} - -#undef Perl_ck_exists -OP * -Perl_ck_exists(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_exists(o); -} - -#undef Perl_ck_ftst -OP * -Perl_ck_ftst(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_ftst(o); -} - -#undef Perl_ck_fun -OP * -Perl_ck_fun(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_fun(o); -} - -#undef Perl_ck_fun_locale -OP * -Perl_ck_fun_locale(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_fun_locale(o); -} - -#undef Perl_ck_glob -OP * -Perl_ck_glob(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_glob(o); -} - -#undef Perl_ck_grep -OP * -Perl_ck_grep(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_grep(o); -} - -#undef Perl_ck_index -OP * -Perl_ck_index(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_index(o); -} - -#undef Perl_ck_join -OP * -Perl_ck_join(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_join(o); -} - -#undef Perl_ck_lengthconst -OP * -Perl_ck_lengthconst(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_lengthconst(o); -} - -#undef Perl_ck_lfun -OP * -Perl_ck_lfun(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_lfun(o); -} - -#undef Perl_ck_listiob -OP * -Perl_ck_listiob(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_listiob(o); -} - -#undef Perl_ck_match -OP * -Perl_ck_match(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_match(o); -} - -#undef Perl_ck_method -OP * -Perl_ck_method(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_method(o); -} - -#undef Perl_ck_null -OP * -Perl_ck_null(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_null(o); -} - -#undef Perl_ck_repeat -OP * -Perl_ck_repeat(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_repeat(o); -} - -#undef Perl_ck_require -OP * -Perl_ck_require(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_require(o); -} - -#undef Perl_ck_rfun -OP * -Perl_ck_rfun(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_rfun(o); -} - -#undef Perl_ck_rvconst -OP * -Perl_ck_rvconst(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_rvconst(o); -} - -#undef Perl_ck_sassign -OP * -Perl_ck_sassign(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_sassign(o); -} - -#undef Perl_ck_scmp -OP * -Perl_ck_scmp(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_scmp(o); -} - -#undef Perl_ck_select -OP * -Perl_ck_select(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_select(o); -} - -#undef Perl_ck_shift -OP * -Perl_ck_shift(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_shift(o); -} - -#undef Perl_ck_sort -OP * -Perl_ck_sort(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_sort(o); -} - -#undef Perl_ck_spair -OP * -Perl_ck_spair(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_spair(o); -} - -#undef Perl_ck_split -OP * -Perl_ck_split(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_split(o); -} - -#undef Perl_ck_subr -OP * -Perl_ck_subr(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_subr(o); -} - -#undef Perl_ck_svconst -OP * -Perl_ck_svconst(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_svconst(o); -} - -#undef Perl_ck_trunc -OP * -Perl_ck_trunc(pTHXo_ OP *o) -{ - return ((CPerlObj*)pPerl)->Perl_ck_trunc(o); -} - -#undef Perl_pp_aassign -OP * -Perl_pp_aassign(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_aassign(); -} - -#undef Perl_pp_abs -OP * -Perl_pp_abs(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_abs(); -} - -#undef Perl_pp_accept -OP * -Perl_pp_accept(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_accept(); -} - -#undef Perl_pp_add -OP * -Perl_pp_add(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_add(); -} - -#undef Perl_pp_aelem -OP * -Perl_pp_aelem(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_aelem(); -} - -#undef Perl_pp_aelemfast -OP * -Perl_pp_aelemfast(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_aelemfast(); -} - -#undef Perl_pp_alarm -OP * -Perl_pp_alarm(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_alarm(); -} - -#undef Perl_pp_and -OP * -Perl_pp_and(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_and(); -} - -#undef Perl_pp_andassign -OP * -Perl_pp_andassign(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_andassign(); -} - -#undef Perl_pp_anoncode -OP * -Perl_pp_anoncode(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_anoncode(); -} - -#undef Perl_pp_anonhash -OP * -Perl_pp_anonhash(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_anonhash(); -} - -#undef Perl_pp_anonlist -OP * -Perl_pp_anonlist(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_anonlist(); -} - -#undef Perl_pp_aslice -OP * -Perl_pp_aslice(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_aslice(); -} - -#undef Perl_pp_atan2 -OP * -Perl_pp_atan2(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_atan2(); -} - -#undef Perl_pp_av2arylen -OP * -Perl_pp_av2arylen(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_av2arylen(); -} - -#undef Perl_pp_backtick -OP * -Perl_pp_backtick(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_backtick(); -} - -#undef Perl_pp_bind -OP * -Perl_pp_bind(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_bind(); -} - -#undef Perl_pp_binmode -OP * -Perl_pp_binmode(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_binmode(); -} - -#undef Perl_pp_bit_and -OP * -Perl_pp_bit_and(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_bit_and(); -} - -#undef Perl_pp_bit_or -OP * -Perl_pp_bit_or(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_bit_or(); -} - -#undef Perl_pp_bit_xor -OP * -Perl_pp_bit_xor(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_bit_xor(); -} - -#undef Perl_pp_bless -OP * -Perl_pp_bless(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_bless(); -} - -#undef Perl_pp_caller -OP * -Perl_pp_caller(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_caller(); -} - -#undef Perl_pp_chdir -OP * -Perl_pp_chdir(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_chdir(); -} - -#undef Perl_pp_chmod -OP * -Perl_pp_chmod(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_chmod(); -} - -#undef Perl_pp_chomp -OP * -Perl_pp_chomp(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_chomp(); -} - -#undef Perl_pp_chop -OP * -Perl_pp_chop(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_chop(); -} - -#undef Perl_pp_chown -OP * -Perl_pp_chown(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_chown(); -} - -#undef Perl_pp_chr -OP * -Perl_pp_chr(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_chr(); -} - -#undef Perl_pp_chroot -OP * -Perl_pp_chroot(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_chroot(); -} - -#undef Perl_pp_close -OP * -Perl_pp_close(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_close(); -} - -#undef Perl_pp_closedir -OP * -Perl_pp_closedir(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_closedir(); -} - -#undef Perl_pp_complement -OP * -Perl_pp_complement(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_complement(); -} - -#undef Perl_pp_concat -OP * -Perl_pp_concat(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_concat(); -} - -#undef Perl_pp_cond_expr -OP * -Perl_pp_cond_expr(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_cond_expr(); -} - -#undef Perl_pp_connect -OP * -Perl_pp_connect(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_connect(); -} - -#undef Perl_pp_const -OP * -Perl_pp_const(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_const(); -} - -#undef Perl_pp_cos -OP * -Perl_pp_cos(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_cos(); -} - -#undef Perl_pp_crypt -OP * -Perl_pp_crypt(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_crypt(); -} - -#undef Perl_pp_dbmclose -OP * -Perl_pp_dbmclose(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_dbmclose(); -} - -#undef Perl_pp_dbmopen -OP * -Perl_pp_dbmopen(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_dbmopen(); -} - -#undef Perl_pp_dbstate -OP * -Perl_pp_dbstate(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_dbstate(); -} - -#undef Perl_pp_defined -OP * -Perl_pp_defined(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_defined(); -} - -#undef Perl_pp_delete -OP * -Perl_pp_delete(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_delete(); -} - -#undef Perl_pp_die -OP * -Perl_pp_die(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_die(); -} - -#undef Perl_pp_divide -OP * -Perl_pp_divide(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_divide(); -} - -#undef Perl_pp_dofile -OP * -Perl_pp_dofile(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_dofile(); -} - -#undef Perl_pp_dump -OP * -Perl_pp_dump(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_dump(); -} - -#undef Perl_pp_each -OP * -Perl_pp_each(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_each(); -} - -#undef Perl_pp_egrent -OP * -Perl_pp_egrent(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_egrent(); -} - -#undef Perl_pp_ehostent -OP * -Perl_pp_ehostent(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_ehostent(); -} - -#undef Perl_pp_enetent -OP * -Perl_pp_enetent(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_enetent(); -} - -#undef Perl_pp_enter -OP * -Perl_pp_enter(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_enter(); -} - -#undef Perl_pp_entereval -OP * -Perl_pp_entereval(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_entereval(); -} - -#undef Perl_pp_enteriter -OP * -Perl_pp_enteriter(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_enteriter(); -} - -#undef Perl_pp_enterloop -OP * -Perl_pp_enterloop(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_enterloop(); -} - -#undef Perl_pp_entersub -OP * -Perl_pp_entersub(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_entersub(); -} - -#undef Perl_pp_entertry -OP * -Perl_pp_entertry(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_entertry(); -} - -#undef Perl_pp_enterwrite -OP * -Perl_pp_enterwrite(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_enterwrite(); -} - -#undef Perl_pp_eof -OP * -Perl_pp_eof(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_eof(); -} - -#undef Perl_pp_eprotoent -OP * -Perl_pp_eprotoent(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_eprotoent(); -} - -#undef Perl_pp_epwent -OP * -Perl_pp_epwent(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_epwent(); -} - -#undef Perl_pp_eq -OP * -Perl_pp_eq(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_eq(); -} - -#undef Perl_pp_eservent -OP * -Perl_pp_eservent(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_eservent(); -} - -#undef Perl_pp_exec -OP * -Perl_pp_exec(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_exec(); -} - -#undef Perl_pp_exists -OP * -Perl_pp_exists(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_exists(); -} - -#undef Perl_pp_exit -OP * -Perl_pp_exit(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_exit(); -} - -#undef Perl_pp_exp -OP * -Perl_pp_exp(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_exp(); -} - -#undef Perl_pp_fcntl -OP * -Perl_pp_fcntl(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_fcntl(); -} - -#undef Perl_pp_fileno -OP * -Perl_pp_fileno(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_fileno(); -} - -#undef Perl_pp_flip -OP * -Perl_pp_flip(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_flip(); -} - -#undef Perl_pp_flock -OP * -Perl_pp_flock(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_flock(); -} - -#undef Perl_pp_flop -OP * -Perl_pp_flop(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_flop(); -} - -#undef Perl_pp_fork -OP * -Perl_pp_fork(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_fork(); -} - -#undef Perl_pp_formline -OP * -Perl_pp_formline(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_formline(); -} - -#undef Perl_pp_ftatime -OP * -Perl_pp_ftatime(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_ftatime(); -} - -#undef Perl_pp_ftbinary -OP * -Perl_pp_ftbinary(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_ftbinary(); -} - -#undef Perl_pp_ftblk -OP * -Perl_pp_ftblk(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_ftblk(); -} - -#undef Perl_pp_ftchr -OP * -Perl_pp_ftchr(pTHXo) +#undef Perl_newLOOPEX +OP* +Perl_newLOOPEX(pTHXo_ I32 type, OP* label) { - return ((CPerlObj*)pPerl)->Perl_pp_ftchr(); + return ((CPerlObj*)pPerl)->Perl_newLOOPEX(type, label); } -#undef Perl_pp_ftctime -OP * -Perl_pp_ftctime(pTHXo) +#undef Perl_newLOOPOP +OP* +Perl_newLOOPOP(pTHXo_ I32 flags, I32 debuggable, OP* expr, OP* block) { - return ((CPerlObj*)pPerl)->Perl_pp_ftctime(); + return ((CPerlObj*)pPerl)->Perl_newLOOPOP(flags, debuggable, expr, block); } -#undef Perl_pp_ftdir -OP * -Perl_pp_ftdir(pTHXo) +#undef Perl_newNULLLIST +OP* +Perl_newNULLLIST(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_ftdir(); + return ((CPerlObj*)pPerl)->Perl_newNULLLIST(); } -#undef Perl_pp_fteexec -OP * -Perl_pp_fteexec(pTHXo) +#undef Perl_newOP +OP* +Perl_newOP(pTHXo_ I32 optype, I32 flags) { - return ((CPerlObj*)pPerl)->Perl_pp_fteexec(); + return ((CPerlObj*)pPerl)->Perl_newOP(optype, flags); } -#undef Perl_pp_fteowned -OP * -Perl_pp_fteowned(pTHXo) +#undef Perl_newPROG +void +Perl_newPROG(pTHXo_ OP* o) { - return ((CPerlObj*)pPerl)->Perl_pp_fteowned(); + ((CPerlObj*)pPerl)->Perl_newPROG(o); } -#undef Perl_pp_fteread -OP * -Perl_pp_fteread(pTHXo) +#undef Perl_newRANGE +OP* +Perl_newRANGE(pTHXo_ I32 flags, OP* left, OP* right) { - return ((CPerlObj*)pPerl)->Perl_pp_fteread(); + return ((CPerlObj*)pPerl)->Perl_newRANGE(flags, left, right); } -#undef Perl_pp_ftewrite -OP * -Perl_pp_ftewrite(pTHXo) +#undef Perl_newSLICEOP +OP* +Perl_newSLICEOP(pTHXo_ I32 flags, OP* subscript, OP* listop) { - return ((CPerlObj*)pPerl)->Perl_pp_ftewrite(); + return ((CPerlObj*)pPerl)->Perl_newSLICEOP(flags, subscript, listop); } -#undef Perl_pp_ftfile -OP * -Perl_pp_ftfile(pTHXo) +#undef Perl_newSTATEOP +OP* +Perl_newSTATEOP(pTHXo_ I32 flags, char* label, OP* o) { - return ((CPerlObj*)pPerl)->Perl_pp_ftfile(); + return ((CPerlObj*)pPerl)->Perl_newSTATEOP(flags, label, o); } -#undef Perl_pp_ftis -OP * -Perl_pp_ftis(pTHXo) +#undef Perl_newSUB +CV* +Perl_newSUB(pTHXo_ I32 floor, OP* o, OP* proto, OP* block) { - return ((CPerlObj*)pPerl)->Perl_pp_ftis(); + return ((CPerlObj*)pPerl)->Perl_newSUB(floor, o, proto, block); } -#undef Perl_pp_ftlink -OP * -Perl_pp_ftlink(pTHXo) +#undef Perl_newXS +CV* +Perl_newXS(pTHXo_ char* name, XSUBADDR_t f, char* filename) { - return ((CPerlObj*)pPerl)->Perl_pp_ftlink(); + return ((CPerlObj*)pPerl)->Perl_newXS(name, f, filename); } -#undef Perl_pp_ftmtime -OP * -Perl_pp_ftmtime(pTHXo) +#undef Perl_newAV +AV* +Perl_newAV(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_ftmtime(); + return ((CPerlObj*)pPerl)->Perl_newAV(); } -#undef Perl_pp_ftpipe -OP * -Perl_pp_ftpipe(pTHXo) +#undef Perl_newAVREF +OP* +Perl_newAVREF(pTHXo_ OP* o) { - return ((CPerlObj*)pPerl)->Perl_pp_ftpipe(); + return ((CPerlObj*)pPerl)->Perl_newAVREF(o); } -#undef Perl_pp_ftrexec -OP * -Perl_pp_ftrexec(pTHXo) +#undef Perl_newBINOP +OP* +Perl_newBINOP(pTHXo_ I32 type, I32 flags, OP* first, OP* last) { - return ((CPerlObj*)pPerl)->Perl_pp_ftrexec(); + return ((CPerlObj*)pPerl)->Perl_newBINOP(type, flags, first, last); } -#undef Perl_pp_ftrowned -OP * -Perl_pp_ftrowned(pTHXo) +#undef Perl_newCVREF +OP* +Perl_newCVREF(pTHXo_ I32 flags, OP* o) { - return ((CPerlObj*)pPerl)->Perl_pp_ftrowned(); + return ((CPerlObj*)pPerl)->Perl_newCVREF(flags, o); } -#undef Perl_pp_ftrread -OP * -Perl_pp_ftrread(pTHXo) +#undef Perl_newGVOP +OP* +Perl_newGVOP(pTHXo_ I32 type, I32 flags, GV* gv) { - return ((CPerlObj*)pPerl)->Perl_pp_ftrread(); + return ((CPerlObj*)pPerl)->Perl_newGVOP(type, flags, gv); } -#undef Perl_pp_ftrwrite -OP * -Perl_pp_ftrwrite(pTHXo) +#undef Perl_newGVgen +GV* +Perl_newGVgen(pTHXo_ char* pack) { - return ((CPerlObj*)pPerl)->Perl_pp_ftrwrite(); + return ((CPerlObj*)pPerl)->Perl_newGVgen(pack); } -#undef Perl_pp_ftsgid -OP * -Perl_pp_ftsgid(pTHXo) +#undef Perl_newGVREF +OP* +Perl_newGVREF(pTHXo_ I32 type, OP* o) { - return ((CPerlObj*)pPerl)->Perl_pp_ftsgid(); + return ((CPerlObj*)pPerl)->Perl_newGVREF(type, o); } -#undef Perl_pp_ftsize -OP * -Perl_pp_ftsize(pTHXo) +#undef Perl_newHVREF +OP* +Perl_newHVREF(pTHXo_ OP* o) { - return ((CPerlObj*)pPerl)->Perl_pp_ftsize(); + return ((CPerlObj*)pPerl)->Perl_newHVREF(o); } -#undef Perl_pp_ftsock -OP * -Perl_pp_ftsock(pTHXo) +#undef Perl_newHV +HV* +Perl_newHV(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_ftsock(); + return ((CPerlObj*)pPerl)->Perl_newHV(); } -#undef Perl_pp_ftsuid -OP * -Perl_pp_ftsuid(pTHXo) +#undef Perl_newHVhv +HV* +Perl_newHVhv(pTHXo_ HV* hv) { - return ((CPerlObj*)pPerl)->Perl_pp_ftsuid(); + return ((CPerlObj*)pPerl)->Perl_newHVhv(hv); } -#undef Perl_pp_ftsvtx -OP * -Perl_pp_ftsvtx(pTHXo) +#undef Perl_newIO +IO* +Perl_newIO(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_ftsvtx(); + return ((CPerlObj*)pPerl)->Perl_newIO(); } -#undef Perl_pp_fttext -OP * -Perl_pp_fttext(pTHXo) +#undef Perl_newLISTOP +OP* +Perl_newLISTOP(pTHXo_ I32 type, I32 flags, OP* first, OP* last) { - return ((CPerlObj*)pPerl)->Perl_pp_fttext(); + return ((CPerlObj*)pPerl)->Perl_newLISTOP(type, flags, first, last); } -#undef Perl_pp_fttty -OP * -Perl_pp_fttty(pTHXo) +#undef Perl_newPADOP +OP* +Perl_newPADOP(pTHXo_ I32 type, I32 flags, SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_fttty(); + return ((CPerlObj*)pPerl)->Perl_newPADOP(type, flags, sv); } -#undef Perl_pp_ftzero -OP * -Perl_pp_ftzero(pTHXo) +#undef Perl_newPMOP +OP* +Perl_newPMOP(pTHXo_ I32 type, I32 flags) { - return ((CPerlObj*)pPerl)->Perl_pp_ftzero(); + return ((CPerlObj*)pPerl)->Perl_newPMOP(type, flags); } -#undef Perl_pp_ge -OP * -Perl_pp_ge(pTHXo) +#undef Perl_newPVOP +OP* +Perl_newPVOP(pTHXo_ I32 type, I32 flags, char* pv) { - return ((CPerlObj*)pPerl)->Perl_pp_ge(); + return ((CPerlObj*)pPerl)->Perl_newPVOP(type, flags, pv); } -#undef Perl_pp_gelem -OP * -Perl_pp_gelem(pTHXo) +#undef Perl_newRV +SV* +Perl_newRV(pTHXo_ SV* pref) { - return ((CPerlObj*)pPerl)->Perl_pp_gelem(); + return ((CPerlObj*)pPerl)->Perl_newRV(pref); } -#undef Perl_pp_getc -OP * -Perl_pp_getc(pTHXo) +#undef Perl_newRV_noinc +SV* +Perl_newRV_noinc(pTHXo_ SV *sv) { - return ((CPerlObj*)pPerl)->Perl_pp_getc(); + return ((CPerlObj*)pPerl)->Perl_newRV_noinc(sv); } -#undef Perl_pp_getlogin -OP * -Perl_pp_getlogin(pTHXo) +#undef Perl_newSV +SV* +Perl_newSV(pTHXo_ STRLEN len) { - return ((CPerlObj*)pPerl)->Perl_pp_getlogin(); + return ((CPerlObj*)pPerl)->Perl_newSV(len); } -#undef Perl_pp_getpeername -OP * -Perl_pp_getpeername(pTHXo) +#undef Perl_newSVREF +OP* +Perl_newSVREF(pTHXo_ OP* o) { - return ((CPerlObj*)pPerl)->Perl_pp_getpeername(); + return ((CPerlObj*)pPerl)->Perl_newSVREF(o); } -#undef Perl_pp_getpgrp -OP * -Perl_pp_getpgrp(pTHXo) +#undef Perl_newSVOP +OP* +Perl_newSVOP(pTHXo_ I32 type, I32 flags, SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_getpgrp(); + return ((CPerlObj*)pPerl)->Perl_newSVOP(type, flags, sv); } -#undef Perl_pp_getppid -OP * -Perl_pp_getppid(pTHXo) +#undef Perl_newSViv +SV* +Perl_newSViv(pTHXo_ IV i) { - return ((CPerlObj*)pPerl)->Perl_pp_getppid(); + return ((CPerlObj*)pPerl)->Perl_newSViv(i); } -#undef Perl_pp_getpriority -OP * -Perl_pp_getpriority(pTHXo) +#undef Perl_newSVnv +SV* +Perl_newSVnv(pTHXo_ NV n) { - return ((CPerlObj*)pPerl)->Perl_pp_getpriority(); + return ((CPerlObj*)pPerl)->Perl_newSVnv(n); } -#undef Perl_pp_getsockname -OP * -Perl_pp_getsockname(pTHXo) +#undef Perl_newSVpv +SV* +Perl_newSVpv(pTHXo_ const char* s, STRLEN len) { - return ((CPerlObj*)pPerl)->Perl_pp_getsockname(); + return ((CPerlObj*)pPerl)->Perl_newSVpv(s, len); } -#undef Perl_pp_ggrent -OP * -Perl_pp_ggrent(pTHXo) +#undef Perl_newSVpvn +SV* +Perl_newSVpvn(pTHXo_ const char* s, STRLEN len) { - return ((CPerlObj*)pPerl)->Perl_pp_ggrent(); + return ((CPerlObj*)pPerl)->Perl_newSVpvn(s, len); } -#undef Perl_pp_ggrgid -OP * -Perl_pp_ggrgid(pTHXo) +#undef Perl_newSVpvf +SV* +Perl_newSVpvf(pTHXo_ const char* pat, ...) { - return ((CPerlObj*)pPerl)->Perl_pp_ggrgid(); -} + SV* retval; + va_list args; + va_start(args, pat); + retval = ((CPerlObj*)pPerl)->Perl_vnewSVpvf(pat, &args); + va_end(args); + return retval; -#undef Perl_pp_ggrnam -OP * -Perl_pp_ggrnam(pTHXo) -{ - return ((CPerlObj*)pPerl)->Perl_pp_ggrnam(); } -#undef Perl_pp_ghbyaddr -OP * -Perl_pp_ghbyaddr(pTHXo) +#undef Perl_vnewSVpvf +SV* +Perl_vnewSVpvf(pTHXo_ const char* pat, va_list* args) { - return ((CPerlObj*)pPerl)->Perl_pp_ghbyaddr(); + return ((CPerlObj*)pPerl)->Perl_vnewSVpvf(pat, args); } -#undef Perl_pp_ghbyname -OP * -Perl_pp_ghbyname(pTHXo) +#undef Perl_newSVrv +SV* +Perl_newSVrv(pTHXo_ SV* rv, const char* classname) { - return ((CPerlObj*)pPerl)->Perl_pp_ghbyname(); + return ((CPerlObj*)pPerl)->Perl_newSVrv(rv, classname); } -#undef Perl_pp_ghostent -OP * -Perl_pp_ghostent(pTHXo) +#undef Perl_newSVsv +SV* +Perl_newSVsv(pTHXo_ SV* old) { - return ((CPerlObj*)pPerl)->Perl_pp_ghostent(); + return ((CPerlObj*)pPerl)->Perl_newSVsv(old); } -#undef Perl_pp_glob -OP * -Perl_pp_glob(pTHXo) +#undef Perl_newUNOP +OP* +Perl_newUNOP(pTHXo_ I32 type, I32 flags, OP* first) { - return ((CPerlObj*)pPerl)->Perl_pp_glob(); + return ((CPerlObj*)pPerl)->Perl_newUNOP(type, flags, first); } -#undef Perl_pp_gmtime -OP * -Perl_pp_gmtime(pTHXo) +#undef Perl_newWHILEOP +OP* +Perl_newWHILEOP(pTHXo_ I32 flags, I32 debuggable, LOOP* loop, I32 whileline, OP* expr, OP* block, OP* cont) { - return ((CPerlObj*)pPerl)->Perl_pp_gmtime(); + return ((CPerlObj*)pPerl)->Perl_newWHILEOP(flags, debuggable, loop, whileline, expr, block, cont); } -#undef Perl_pp_gnbyaddr -OP * -Perl_pp_gnbyaddr(pTHXo) +#undef Perl_ninstr +char* +Perl_ninstr(pTHXo_ const char* big, const char* bigend, const char* little, const char* lend) { - return ((CPerlObj*)pPerl)->Perl_pp_gnbyaddr(); + return ((CPerlObj*)pPerl)->Perl_ninstr(big, bigend, little, lend); } +#if defined(PERL_OBJECT) -#undef Perl_pp_gnbyname -OP * -Perl_pp_gnbyname(pTHXo) +#undef Perl_construct +void +Perl_construct(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_gnbyname(); + ((CPerlObj*)pPerl)->Perl_construct(); } -#undef Perl_pp_gnetent -OP * -Perl_pp_gnetent(pTHXo) +#undef Perl_destruct +void +Perl_destruct(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_gnetent(); + ((CPerlObj*)pPerl)->Perl_destruct(); } -#undef Perl_pp_goto -OP * -Perl_pp_goto(pTHXo) +#undef Perl_free +void +Perl_free(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_goto(); + ((CPerlObj*)pPerl)->Perl_free(); } -#undef Perl_pp_gpbyname -OP * -Perl_pp_gpbyname(pTHXo) +#undef Perl_run +int +Perl_run(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_gpbyname(); + return ((CPerlObj*)pPerl)->Perl_run(); } -#undef Perl_pp_gpbynumber -OP * -Perl_pp_gpbynumber(pTHXo) +#undef Perl_parse +int +Perl_parse(pTHXo_ XSINIT_t xsinit, int argc, char** argv, char** env) { - return ((CPerlObj*)pPerl)->Perl_pp_gpbynumber(); + return ((CPerlObj*)pPerl)->Perl_parse(xsinit, argc, argv, env); } +#endif +#if defined(USE_THREADS) -#undef Perl_pp_gprotoent -OP * -Perl_pp_gprotoent(pTHXo) +#undef Perl_new_struct_thread +struct perl_thread* +Perl_new_struct_thread(pTHXo_ struct perl_thread *t) { - return ((CPerlObj*)pPerl)->Perl_pp_gprotoent(); + return ((CPerlObj*)pPerl)->Perl_new_struct_thread(t); } +#endif -#undef Perl_pp_gpwent -OP * -Perl_pp_gpwent(pTHXo) +#undef Perl_call_atexit +void +Perl_call_atexit(pTHXo_ ATEXIT_t fn, void *ptr) { - return ((CPerlObj*)pPerl)->Perl_pp_gpwent(); + ((CPerlObj*)pPerl)->Perl_call_atexit(fn, ptr); } -#undef Perl_pp_gpwnam -OP * -Perl_pp_gpwnam(pTHXo) +#undef Perl_call_argv +I32 +Perl_call_argv(pTHXo_ const char* sub_name, I32 flags, char** argv) { - return ((CPerlObj*)pPerl)->Perl_pp_gpwnam(); + return ((CPerlObj*)pPerl)->Perl_call_argv(sub_name, flags, argv); } -#undef Perl_pp_gpwuid -OP * -Perl_pp_gpwuid(pTHXo) +#undef Perl_call_method +I32 +Perl_call_method(pTHXo_ const char* methname, I32 flags) { - return ((CPerlObj*)pPerl)->Perl_pp_gpwuid(); + return ((CPerlObj*)pPerl)->Perl_call_method(methname, flags); } -#undef Perl_pp_grepstart -OP * -Perl_pp_grepstart(pTHXo) +#undef Perl_call_pv +I32 +Perl_call_pv(pTHXo_ const char* sub_name, I32 flags) { - return ((CPerlObj*)pPerl)->Perl_pp_grepstart(); + return ((CPerlObj*)pPerl)->Perl_call_pv(sub_name, flags); } -#undef Perl_pp_grepwhile -OP * -Perl_pp_grepwhile(pTHXo) +#undef Perl_call_sv +I32 +Perl_call_sv(pTHXo_ SV* sv, I32 flags) { - return ((CPerlObj*)pPerl)->Perl_pp_grepwhile(); + return ((CPerlObj*)pPerl)->Perl_call_sv(sv, flags); } -#undef Perl_pp_gsbyname -OP * -Perl_pp_gsbyname(pTHXo) +#undef Perl_eval_pv +SV* +Perl_eval_pv(pTHXo_ const char* p, I32 croak_on_error) { - return ((CPerlObj*)pPerl)->Perl_pp_gsbyname(); + return ((CPerlObj*)pPerl)->Perl_eval_pv(p, croak_on_error); } -#undef Perl_pp_gsbyport -OP * -Perl_pp_gsbyport(pTHXo) +#undef Perl_eval_sv +I32 +Perl_eval_sv(pTHXo_ SV* sv, I32 flags) { - return ((CPerlObj*)pPerl)->Perl_pp_gsbyport(); + return ((CPerlObj*)pPerl)->Perl_eval_sv(sv, flags); } -#undef Perl_pp_gservent -OP * -Perl_pp_gservent(pTHXo) +#undef Perl_get_sv +SV* +Perl_get_sv(pTHXo_ const char* name, I32 create) { - return ((CPerlObj*)pPerl)->Perl_pp_gservent(); + return ((CPerlObj*)pPerl)->Perl_get_sv(name, create); } -#undef Perl_pp_gsockopt -OP * -Perl_pp_gsockopt(pTHXo) +#undef Perl_get_av +AV* +Perl_get_av(pTHXo_ const char* name, I32 create) { - return ((CPerlObj*)pPerl)->Perl_pp_gsockopt(); + return ((CPerlObj*)pPerl)->Perl_get_av(name, create); } -#undef Perl_pp_gt -OP * -Perl_pp_gt(pTHXo) +#undef Perl_get_hv +HV* +Perl_get_hv(pTHXo_ const char* name, I32 create) { - return ((CPerlObj*)pPerl)->Perl_pp_gt(); + return ((CPerlObj*)pPerl)->Perl_get_hv(name, create); } -#undef Perl_pp_gv -OP * -Perl_pp_gv(pTHXo) +#undef Perl_get_cv +CV* +Perl_get_cv(pTHXo_ const char* name, I32 create) { - return ((CPerlObj*)pPerl)->Perl_pp_gv(); + return ((CPerlObj*)pPerl)->Perl_get_cv(name, create); } -#undef Perl_pp_gvsv -OP * -Perl_pp_gvsv(pTHXo) +#undef Perl_new_collate +void +Perl_new_collate(pTHXo_ const char* newcoll) { - return ((CPerlObj*)pPerl)->Perl_pp_gvsv(); + ((CPerlObj*)pPerl)->Perl_new_collate(newcoll); } -#undef Perl_pp_helem -OP * -Perl_pp_helem(pTHXo) +#undef Perl_new_ctype +void +Perl_new_ctype(pTHXo_ const char* newctype) { - return ((CPerlObj*)pPerl)->Perl_pp_helem(); + ((CPerlObj*)pPerl)->Perl_new_ctype(newctype); } -#undef Perl_pp_hex -OP * -Perl_pp_hex(pTHXo) +#undef Perl_new_numeric +void +Perl_new_numeric(pTHXo_ const char* newcoll) { - return ((CPerlObj*)pPerl)->Perl_pp_hex(); + ((CPerlObj*)pPerl)->Perl_new_numeric(newcoll); } -#undef Perl_pp_hslice -OP * -Perl_pp_hslice(pTHXo) +#undef Perl_set_numeric_local +void +Perl_set_numeric_local(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_hslice(); + ((CPerlObj*)pPerl)->Perl_set_numeric_local(); } -#undef Perl_pp_i_add -OP * -Perl_pp_i_add(pTHXo) +#undef Perl_set_numeric_radix +void +Perl_set_numeric_radix(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_i_add(); + ((CPerlObj*)pPerl)->Perl_set_numeric_radix(); } -#undef Perl_pp_i_divide -OP * -Perl_pp_i_divide(pTHXo) +#undef Perl_set_numeric_standard +void +Perl_set_numeric_standard(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_i_divide(); + ((CPerlObj*)pPerl)->Perl_set_numeric_standard(); } -#undef Perl_pp_i_eq -OP * -Perl_pp_i_eq(pTHXo) +#undef Perl_require_pv +void +Perl_require_pv(pTHXo_ const char* pv) { - return ((CPerlObj*)pPerl)->Perl_pp_i_eq(); + ((CPerlObj*)pPerl)->Perl_require_pv(pv); } -#undef Perl_pp_i_ge -OP * -Perl_pp_i_ge(pTHXo) +#undef Perl_pop_scope +void +Perl_pop_scope(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_i_ge(); + ((CPerlObj*)pPerl)->Perl_pop_scope(); } -#undef Perl_pp_i_gt -OP * -Perl_pp_i_gt(pTHXo) +#undef Perl_push_scope +void +Perl_push_scope(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_i_gt(); + ((CPerlObj*)pPerl)->Perl_push_scope(); } -#undef Perl_pp_i_le -OP * -Perl_pp_i_le(pTHXo) +#undef Perl_regdump +void +Perl_regdump(pTHXo_ regexp* r) { - return ((CPerlObj*)pPerl)->Perl_pp_i_le(); + ((CPerlObj*)pPerl)->Perl_regdump(r); } -#undef Perl_pp_i_lt -OP * -Perl_pp_i_lt(pTHXo) +#undef Perl_rninstr +char* +Perl_rninstr(pTHXo_ const char* big, const char* bigend, const char* little, const char* lend) { - return ((CPerlObj*)pPerl)->Perl_pp_i_lt(); + return ((CPerlObj*)pPerl)->Perl_rninstr(big, bigend, little, lend); } +#if !defined(HAS_RENAME) +#endif -#undef Perl_pp_i_modulo -OP * -Perl_pp_i_modulo(pTHXo) +#undef Perl_savepv +char* +Perl_savepv(pTHXo_ const char* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_i_modulo(); + return ((CPerlObj*)pPerl)->Perl_savepv(sv); } -#undef Perl_pp_i_multiply -OP * -Perl_pp_i_multiply(pTHXo) +#undef Perl_savepvn +char* +Perl_savepvn(pTHXo_ const char* sv, I32 len) { - return ((CPerlObj*)pPerl)->Perl_pp_i_multiply(); + return ((CPerlObj*)pPerl)->Perl_savepvn(sv, len); } -#undef Perl_pp_i_ncmp -OP * -Perl_pp_i_ncmp(pTHXo) +#undef Perl_savestack_grow +void +Perl_savestack_grow(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_i_ncmp(); + ((CPerlObj*)pPerl)->Perl_savestack_grow(); } -#undef Perl_pp_i_ne -OP * -Perl_pp_i_ne(pTHXo) +#undef Perl_save_aelem +void +Perl_save_aelem(pTHXo_ AV* av, I32 idx, SV **sptr) { - return ((CPerlObj*)pPerl)->Perl_pp_i_ne(); + ((CPerlObj*)pPerl)->Perl_save_aelem(av, idx, sptr); } -#undef Perl_pp_i_negate -OP * -Perl_pp_i_negate(pTHXo) +#undef Perl_save_alloc +I32 +Perl_save_alloc(pTHXo_ I32 size, I32 pad) { - return ((CPerlObj*)pPerl)->Perl_pp_i_negate(); + return ((CPerlObj*)pPerl)->Perl_save_alloc(size, pad); } -#undef Perl_pp_i_subtract -OP * -Perl_pp_i_subtract(pTHXo) +#undef Perl_save_aptr +void +Perl_save_aptr(pTHXo_ AV** aptr) { - return ((CPerlObj*)pPerl)->Perl_pp_i_subtract(); + ((CPerlObj*)pPerl)->Perl_save_aptr(aptr); } -#undef Perl_pp_index -OP * -Perl_pp_index(pTHXo) +#undef Perl_save_ary +AV* +Perl_save_ary(pTHXo_ GV* gv) { - return ((CPerlObj*)pPerl)->Perl_pp_index(); + return ((CPerlObj*)pPerl)->Perl_save_ary(gv); } -#undef Perl_pp_int -OP * -Perl_pp_int(pTHXo) +#undef Perl_save_clearsv +void +Perl_save_clearsv(pTHXo_ SV** svp) { - return ((CPerlObj*)pPerl)->Perl_pp_int(); + ((CPerlObj*)pPerl)->Perl_save_clearsv(svp); } -#undef Perl_pp_ioctl -OP * -Perl_pp_ioctl(pTHXo) +#undef Perl_save_delete +void +Perl_save_delete(pTHXo_ HV* hv, char* key, I32 klen) { - return ((CPerlObj*)pPerl)->Perl_pp_ioctl(); + ((CPerlObj*)pPerl)->Perl_save_delete(hv, key, klen); } -#undef Perl_pp_iter -OP * -Perl_pp_iter(pTHXo) +#undef Perl_save_destructor +void +Perl_save_destructor(pTHXo_ DESTRUCTORFUNC_NOCONTEXT_t f, void* p) { - return ((CPerlObj*)pPerl)->Perl_pp_iter(); + ((CPerlObj*)pPerl)->Perl_save_destructor(f, p); } -#undef Perl_pp_join -OP * -Perl_pp_join(pTHXo) +#undef Perl_save_destructor_x +void +Perl_save_destructor_x(pTHXo_ DESTRUCTORFUNC_t f, void* p) { - return ((CPerlObj*)pPerl)->Perl_pp_join(); + ((CPerlObj*)pPerl)->Perl_save_destructor_x(f, p); } -#undef Perl_pp_keys -OP * -Perl_pp_keys(pTHXo) +#undef Perl_save_freesv +void +Perl_save_freesv(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_keys(); + ((CPerlObj*)pPerl)->Perl_save_freesv(sv); } -#undef Perl_pp_kill -OP * -Perl_pp_kill(pTHXo) +#undef Perl_save_freepv +void +Perl_save_freepv(pTHXo_ char* pv) { - return ((CPerlObj*)pPerl)->Perl_pp_kill(); + ((CPerlObj*)pPerl)->Perl_save_freepv(pv); } -#undef Perl_pp_last -OP * -Perl_pp_last(pTHXo) +#undef Perl_save_generic_svref +void +Perl_save_generic_svref(pTHXo_ SV** sptr) { - return ((CPerlObj*)pPerl)->Perl_pp_last(); + ((CPerlObj*)pPerl)->Perl_save_generic_svref(sptr); } -#undef Perl_pp_lc -OP * -Perl_pp_lc(pTHXo) +#undef Perl_save_gp +void +Perl_save_gp(pTHXo_ GV* gv, I32 empty) { - return ((CPerlObj*)pPerl)->Perl_pp_lc(); + ((CPerlObj*)pPerl)->Perl_save_gp(gv, empty); } -#undef Perl_pp_lcfirst -OP * -Perl_pp_lcfirst(pTHXo) +#undef Perl_save_hash +HV* +Perl_save_hash(pTHXo_ GV* gv) { - return ((CPerlObj*)pPerl)->Perl_pp_lcfirst(); + return ((CPerlObj*)pPerl)->Perl_save_hash(gv); } -#undef Perl_pp_le -OP * -Perl_pp_le(pTHXo) +#undef Perl_save_helem +void +Perl_save_helem(pTHXo_ HV* hv, SV *key, SV **sptr) { - return ((CPerlObj*)pPerl)->Perl_pp_le(); + ((CPerlObj*)pPerl)->Perl_save_helem(hv, key, sptr); } -#undef Perl_pp_leave -OP * -Perl_pp_leave(pTHXo) +#undef Perl_save_hints +void +Perl_save_hints(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_leave(); + ((CPerlObj*)pPerl)->Perl_save_hints(); } -#undef Perl_pp_leaveeval -OP * -Perl_pp_leaveeval(pTHXo) +#undef Perl_save_hptr +void +Perl_save_hptr(pTHXo_ HV** hptr) { - return ((CPerlObj*)pPerl)->Perl_pp_leaveeval(); + ((CPerlObj*)pPerl)->Perl_save_hptr(hptr); } -#undef Perl_pp_leaveloop -OP * -Perl_pp_leaveloop(pTHXo) +#undef Perl_save_I16 +void +Perl_save_I16(pTHXo_ I16* intp) { - return ((CPerlObj*)pPerl)->Perl_pp_leaveloop(); + ((CPerlObj*)pPerl)->Perl_save_I16(intp); } -#undef Perl_pp_leavesub -OP * -Perl_pp_leavesub(pTHXo) +#undef Perl_save_I32 +void +Perl_save_I32(pTHXo_ I32* intp) { - return ((CPerlObj*)pPerl)->Perl_pp_leavesub(); + ((CPerlObj*)pPerl)->Perl_save_I32(intp); } -#undef Perl_pp_leavesublv -OP * -Perl_pp_leavesublv(pTHXo) +#undef Perl_save_I8 +void +Perl_save_I8(pTHXo_ I8* bytep) { - return ((CPerlObj*)pPerl)->Perl_pp_leavesublv(); + ((CPerlObj*)pPerl)->Perl_save_I8(bytep); } -#undef Perl_pp_leavetry -OP * -Perl_pp_leavetry(pTHXo) +#undef Perl_save_int +void +Perl_save_int(pTHXo_ int* intp) { - return ((CPerlObj*)pPerl)->Perl_pp_leavetry(); + ((CPerlObj*)pPerl)->Perl_save_int(intp); } -#undef Perl_pp_leavewrite -OP * -Perl_pp_leavewrite(pTHXo) +#undef Perl_save_item +void +Perl_save_item(pTHXo_ SV* item) { - return ((CPerlObj*)pPerl)->Perl_pp_leavewrite(); + ((CPerlObj*)pPerl)->Perl_save_item(item); } -#undef Perl_pp_left_shift -OP * -Perl_pp_left_shift(pTHXo) +#undef Perl_save_iv +void +Perl_save_iv(pTHXo_ IV* iv) { - return ((CPerlObj*)pPerl)->Perl_pp_left_shift(); + ((CPerlObj*)pPerl)->Perl_save_iv(iv); } -#undef Perl_pp_length -OP * -Perl_pp_length(pTHXo) +#undef Perl_save_list +void +Perl_save_list(pTHXo_ SV** sarg, I32 maxsarg) { - return ((CPerlObj*)pPerl)->Perl_pp_length(); + ((CPerlObj*)pPerl)->Perl_save_list(sarg, maxsarg); } -#undef Perl_pp_lineseq -OP * -Perl_pp_lineseq(pTHXo) +#undef Perl_save_long +void +Perl_save_long(pTHXo_ long* longp) { - return ((CPerlObj*)pPerl)->Perl_pp_lineseq(); + ((CPerlObj*)pPerl)->Perl_save_long(longp); } -#undef Perl_pp_link -OP * -Perl_pp_link(pTHXo) +#undef Perl_save_nogv +void +Perl_save_nogv(pTHXo_ GV* gv) { - return ((CPerlObj*)pPerl)->Perl_pp_link(); + ((CPerlObj*)pPerl)->Perl_save_nogv(gv); } -#undef Perl_pp_list -OP * -Perl_pp_list(pTHXo) +#undef Perl_save_scalar +SV* +Perl_save_scalar(pTHXo_ GV* gv) { - return ((CPerlObj*)pPerl)->Perl_pp_list(); + return ((CPerlObj*)pPerl)->Perl_save_scalar(gv); } -#undef Perl_pp_listen -OP * -Perl_pp_listen(pTHXo) +#undef Perl_save_pptr +void +Perl_save_pptr(pTHXo_ char** pptr) { - return ((CPerlObj*)pPerl)->Perl_pp_listen(); + ((CPerlObj*)pPerl)->Perl_save_pptr(pptr); } -#undef Perl_pp_localtime -OP * -Perl_pp_localtime(pTHXo) +#undef Perl_save_vptr +void +Perl_save_vptr(pTHXo_ void* pptr) { - return ((CPerlObj*)pPerl)->Perl_pp_localtime(); + ((CPerlObj*)pPerl)->Perl_save_vptr(pptr); } -#undef Perl_pp_lock -OP * -Perl_pp_lock(pTHXo) +#undef Perl_save_re_context +void +Perl_save_re_context(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_lock(); + ((CPerlObj*)pPerl)->Perl_save_re_context(); } -#undef Perl_pp_log -OP * -Perl_pp_log(pTHXo) +#undef Perl_save_sptr +void +Perl_save_sptr(pTHXo_ SV** sptr) { - return ((CPerlObj*)pPerl)->Perl_pp_log(); + ((CPerlObj*)pPerl)->Perl_save_sptr(sptr); } -#undef Perl_pp_lslice -OP * -Perl_pp_lslice(pTHXo) +#undef Perl_save_svref +SV* +Perl_save_svref(pTHXo_ SV** sptr) { - return ((CPerlObj*)pPerl)->Perl_pp_lslice(); + return ((CPerlObj*)pPerl)->Perl_save_svref(sptr); } -#undef Perl_pp_lstat -OP * -Perl_pp_lstat(pTHXo) +#undef Perl_save_threadsv +SV** +Perl_save_threadsv(pTHXo_ PADOFFSET i) { - return ((CPerlObj*)pPerl)->Perl_pp_lstat(); + return ((CPerlObj*)pPerl)->Perl_save_threadsv(i); } +#if !defined(VMS) +#endif -#undef Perl_pp_lt -OP * -Perl_pp_lt(pTHXo) +#undef Perl_stack_grow +SV** +Perl_stack_grow(pTHXo_ SV** sp, SV**p, int n) { - return ((CPerlObj*)pPerl)->Perl_pp_lt(); + return ((CPerlObj*)pPerl)->Perl_stack_grow(sp, p, n); } -#undef Perl_pp_mapstart -OP * -Perl_pp_mapstart(pTHXo) +#undef Perl_start_subparse +I32 +Perl_start_subparse(pTHXo_ I32 is_format, U32 flags) { - return ((CPerlObj*)pPerl)->Perl_pp_mapstart(); + return ((CPerlObj*)pPerl)->Perl_start_subparse(is_format, flags); } -#undef Perl_pp_mapwhile -OP * -Perl_pp_mapwhile(pTHXo) +#undef Perl_sv_2bool +bool +Perl_sv_2bool(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_mapwhile(); + return ((CPerlObj*)pPerl)->Perl_sv_2bool(sv); } -#undef Perl_pp_match -OP * -Perl_pp_match(pTHXo) +#undef Perl_sv_2cv +CV* +Perl_sv_2cv(pTHXo_ SV* sv, HV** st, GV** gvp, I32 lref) { - return ((CPerlObj*)pPerl)->Perl_pp_match(); + return ((CPerlObj*)pPerl)->Perl_sv_2cv(sv, st, gvp, lref); } -#undef Perl_pp_method -OP * -Perl_pp_method(pTHXo) +#undef Perl_sv_2io +IO* +Perl_sv_2io(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_method(); + return ((CPerlObj*)pPerl)->Perl_sv_2io(sv); } -#undef Perl_pp_method_named -OP * -Perl_pp_method_named(pTHXo) +#undef Perl_sv_2iv +IV +Perl_sv_2iv(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_method_named(); + return ((CPerlObj*)pPerl)->Perl_sv_2iv(sv); } -#undef Perl_pp_mkdir -OP * -Perl_pp_mkdir(pTHXo) +#undef Perl_sv_2mortal +SV* +Perl_sv_2mortal(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_mkdir(); + return ((CPerlObj*)pPerl)->Perl_sv_2mortal(sv); } -#undef Perl_pp_modulo -OP * -Perl_pp_modulo(pTHXo) +#undef Perl_sv_2nv +NV +Perl_sv_2nv(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_modulo(); + return ((CPerlObj*)pPerl)->Perl_sv_2nv(sv); } -#undef Perl_pp_msgctl -OP * -Perl_pp_msgctl(pTHXo) +#undef Perl_sv_2pv +char* +Perl_sv_2pv(pTHXo_ SV* sv, STRLEN* lp) { - return ((CPerlObj*)pPerl)->Perl_pp_msgctl(); + return ((CPerlObj*)pPerl)->Perl_sv_2pv(sv, lp); } -#undef Perl_pp_msgget -OP * -Perl_pp_msgget(pTHXo) +#undef Perl_sv_2pvutf8 +char* +Perl_sv_2pvutf8(pTHXo_ SV* sv, STRLEN* lp) { - return ((CPerlObj*)pPerl)->Perl_pp_msgget(); + return ((CPerlObj*)pPerl)->Perl_sv_2pvutf8(sv, lp); } -#undef Perl_pp_msgrcv -OP * -Perl_pp_msgrcv(pTHXo) +#undef Perl_sv_2pvbyte +char* +Perl_sv_2pvbyte(pTHXo_ SV* sv, STRLEN* lp) { - return ((CPerlObj*)pPerl)->Perl_pp_msgrcv(); + return ((CPerlObj*)pPerl)->Perl_sv_2pvbyte(sv, lp); } -#undef Perl_pp_msgsnd -OP * -Perl_pp_msgsnd(pTHXo) +#undef Perl_sv_2uv +UV +Perl_sv_2uv(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_msgsnd(); + return ((CPerlObj*)pPerl)->Perl_sv_2uv(sv); } -#undef Perl_pp_multiply -OP * -Perl_pp_multiply(pTHXo) +#undef Perl_sv_iv +IV +Perl_sv_iv(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_multiply(); + return ((CPerlObj*)pPerl)->Perl_sv_iv(sv); } -#undef Perl_pp_ncmp -OP * -Perl_pp_ncmp(pTHXo) +#undef Perl_sv_uv +UV +Perl_sv_uv(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_ncmp(); + return ((CPerlObj*)pPerl)->Perl_sv_uv(sv); } -#undef Perl_pp_ne -OP * -Perl_pp_ne(pTHXo) +#undef Perl_sv_nv +NV +Perl_sv_nv(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_ne(); + return ((CPerlObj*)pPerl)->Perl_sv_nv(sv); } -#undef Perl_pp_negate -OP * -Perl_pp_negate(pTHXo) +#undef Perl_sv_pvn +char* +Perl_sv_pvn(pTHXo_ SV *sv, STRLEN *len) { - return ((CPerlObj*)pPerl)->Perl_pp_negate(); + return ((CPerlObj*)pPerl)->Perl_sv_pvn(sv, len); } -#undef Perl_pp_next -OP * -Perl_pp_next(pTHXo) +#undef Perl_sv_pvutf8n +char* +Perl_sv_pvutf8n(pTHXo_ SV *sv, STRLEN *len) { - return ((CPerlObj*)pPerl)->Perl_pp_next(); + return ((CPerlObj*)pPerl)->Perl_sv_pvutf8n(sv, len); } -#undef Perl_pp_nextstate -OP * -Perl_pp_nextstate(pTHXo) +#undef Perl_sv_pvbyten +char* +Perl_sv_pvbyten(pTHXo_ SV *sv, STRLEN *len) { - return ((CPerlObj*)pPerl)->Perl_pp_nextstate(); + return ((CPerlObj*)pPerl)->Perl_sv_pvbyten(sv, len); } -#undef Perl_pp_not -OP * -Perl_pp_not(pTHXo) +#undef Perl_sv_true +I32 +Perl_sv_true(pTHXo_ SV *sv) { - return ((CPerlObj*)pPerl)->Perl_pp_not(); + return ((CPerlObj*)pPerl)->Perl_sv_true(sv); } -#undef Perl_pp_null -OP * -Perl_pp_null(pTHXo) +#undef Perl_sv_backoff +int +Perl_sv_backoff(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_null(); + return ((CPerlObj*)pPerl)->Perl_sv_backoff(sv); } -#undef Perl_pp_oct -OP * -Perl_pp_oct(pTHXo) +#undef Perl_sv_bless +SV* +Perl_sv_bless(pTHXo_ SV* sv, HV* stash) { - return ((CPerlObj*)pPerl)->Perl_pp_oct(); + return ((CPerlObj*)pPerl)->Perl_sv_bless(sv, stash); } -#undef Perl_pp_open -OP * -Perl_pp_open(pTHXo) +#undef Perl_sv_catpvf +void +Perl_sv_catpvf(pTHXo_ SV* sv, const char* pat, ...) { - return ((CPerlObj*)pPerl)->Perl_pp_open(); + va_list args; + va_start(args, pat); + ((CPerlObj*)pPerl)->Perl_sv_vcatpvf(sv, pat, &args); + va_end(args); } -#undef Perl_pp_open_dir -OP * -Perl_pp_open_dir(pTHXo) +#undef Perl_sv_vcatpvf +void +Perl_sv_vcatpvf(pTHXo_ SV* sv, const char* pat, va_list* args) { - return ((CPerlObj*)pPerl)->Perl_pp_open_dir(); + ((CPerlObj*)pPerl)->Perl_sv_vcatpvf(sv, pat, args); } -#undef Perl_pp_or -OP * -Perl_pp_or(pTHXo) +#undef Perl_sv_catpv +void +Perl_sv_catpv(pTHXo_ SV* sv, const char* ptr) { - return ((CPerlObj*)pPerl)->Perl_pp_or(); + ((CPerlObj*)pPerl)->Perl_sv_catpv(sv, ptr); } -#undef Perl_pp_orassign -OP * -Perl_pp_orassign(pTHXo) +#undef Perl_sv_catpvn +void +Perl_sv_catpvn(pTHXo_ SV* sv, const char* ptr, STRLEN len) { - return ((CPerlObj*)pPerl)->Perl_pp_orassign(); + ((CPerlObj*)pPerl)->Perl_sv_catpvn(sv, ptr, len); } -#undef Perl_pp_ord -OP * -Perl_pp_ord(pTHXo) +#undef Perl_sv_catsv +void +Perl_sv_catsv(pTHXo_ SV* dsv, SV* ssv) { - return ((CPerlObj*)pPerl)->Perl_pp_ord(); + ((CPerlObj*)pPerl)->Perl_sv_catsv(dsv, ssv); } -#undef Perl_pp_pack -OP * -Perl_pp_pack(pTHXo) +#undef Perl_sv_chop +void +Perl_sv_chop(pTHXo_ SV* sv, char* ptr) { - return ((CPerlObj*)pPerl)->Perl_pp_pack(); + ((CPerlObj*)pPerl)->Perl_sv_chop(sv, ptr); } -#undef Perl_pp_padany -OP * -Perl_pp_padany(pTHXo) +#undef Perl_sv_clear +void +Perl_sv_clear(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_padany(); + ((CPerlObj*)pPerl)->Perl_sv_clear(sv); } -#undef Perl_pp_padav -OP * -Perl_pp_padav(pTHXo) +#undef Perl_sv_cmp +I32 +Perl_sv_cmp(pTHXo_ SV* sv1, SV* sv2) { - return ((CPerlObj*)pPerl)->Perl_pp_padav(); + return ((CPerlObj*)pPerl)->Perl_sv_cmp(sv1, sv2); } -#undef Perl_pp_padhv -OP * -Perl_pp_padhv(pTHXo) +#undef Perl_sv_cmp_locale +I32 +Perl_sv_cmp_locale(pTHXo_ SV* sv1, SV* sv2) { - return ((CPerlObj*)pPerl)->Perl_pp_padhv(); + return ((CPerlObj*)pPerl)->Perl_sv_cmp_locale(sv1, sv2); } +#if defined(USE_LOCALE_COLLATE) -#undef Perl_pp_padsv -OP * -Perl_pp_padsv(pTHXo) +#undef Perl_sv_collxfrm +char* +Perl_sv_collxfrm(pTHXo_ SV* sv, STRLEN* nxp) { - return ((CPerlObj*)pPerl)->Perl_pp_padsv(); + return ((CPerlObj*)pPerl)->Perl_sv_collxfrm(sv, nxp); } +#endif -#undef Perl_pp_pipe_op -OP * -Perl_pp_pipe_op(pTHXo) +#undef Perl_sv_dec +void +Perl_sv_dec(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_pipe_op(); + ((CPerlObj*)pPerl)->Perl_sv_dec(sv); } -#undef Perl_pp_pop -OP * -Perl_pp_pop(pTHXo) +#undef Perl_sv_dump +void +Perl_sv_dump(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_pop(); + ((CPerlObj*)pPerl)->Perl_sv_dump(sv); } -#undef Perl_pp_pos -OP * -Perl_pp_pos(pTHXo) +#undef Perl_sv_derived_from +bool +Perl_sv_derived_from(pTHXo_ SV* sv, const char* name) { - return ((CPerlObj*)pPerl)->Perl_pp_pos(); + return ((CPerlObj*)pPerl)->Perl_sv_derived_from(sv, name); } -#undef Perl_pp_postdec -OP * -Perl_pp_postdec(pTHXo) +#undef Perl_sv_eq +I32 +Perl_sv_eq(pTHXo_ SV* sv1, SV* sv2) { - return ((CPerlObj*)pPerl)->Perl_pp_postdec(); + return ((CPerlObj*)pPerl)->Perl_sv_eq(sv1, sv2); } -#undef Perl_pp_postinc -OP * -Perl_pp_postinc(pTHXo) +#undef Perl_sv_free +void +Perl_sv_free(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_postinc(); + ((CPerlObj*)pPerl)->Perl_sv_free(sv); } -#undef Perl_pp_pow -OP * -Perl_pp_pow(pTHXo) +#undef Perl_sv_grow +char* +Perl_sv_grow(pTHXo_ SV* sv, STRLEN newlen) { - return ((CPerlObj*)pPerl)->Perl_pp_pow(); + return ((CPerlObj*)pPerl)->Perl_sv_grow(sv, newlen); } -#undef Perl_pp_predec -OP * -Perl_pp_predec(pTHXo) +#undef Perl_sv_inc +void +Perl_sv_inc(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_predec(); + ((CPerlObj*)pPerl)->Perl_sv_inc(sv); } -#undef Perl_pp_preinc -OP * -Perl_pp_preinc(pTHXo) +#undef Perl_sv_insert +void +Perl_sv_insert(pTHXo_ SV* bigsv, STRLEN offset, STRLEN len, char* little, STRLEN littlelen) { - return ((CPerlObj*)pPerl)->Perl_pp_preinc(); + ((CPerlObj*)pPerl)->Perl_sv_insert(bigsv, offset, len, little, littlelen); } -#undef Perl_pp_print -OP * -Perl_pp_print(pTHXo) +#undef Perl_sv_isa +int +Perl_sv_isa(pTHXo_ SV* sv, const char* name) { - return ((CPerlObj*)pPerl)->Perl_pp_print(); + return ((CPerlObj*)pPerl)->Perl_sv_isa(sv, name); } -#undef Perl_pp_prototype -OP * -Perl_pp_prototype(pTHXo) +#undef Perl_sv_isobject +int +Perl_sv_isobject(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_prototype(); + return ((CPerlObj*)pPerl)->Perl_sv_isobject(sv); } -#undef Perl_pp_prtf -OP * -Perl_pp_prtf(pTHXo) +#undef Perl_sv_len +STRLEN +Perl_sv_len(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_prtf(); + return ((CPerlObj*)pPerl)->Perl_sv_len(sv); } -#undef Perl_pp_push -OP * -Perl_pp_push(pTHXo) +#undef Perl_sv_len_utf8 +STRLEN +Perl_sv_len_utf8(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_push(); + return ((CPerlObj*)pPerl)->Perl_sv_len_utf8(sv); } -#undef Perl_pp_pushmark -OP * -Perl_pp_pushmark(pTHXo) +#undef Perl_sv_magic +void +Perl_sv_magic(pTHXo_ SV* sv, SV* obj, int how, const char* name, I32 namlen) { - return ((CPerlObj*)pPerl)->Perl_pp_pushmark(); + ((CPerlObj*)pPerl)->Perl_sv_magic(sv, obj, how, name, namlen); } -#undef Perl_pp_pushre -OP * -Perl_pp_pushre(pTHXo) +#undef Perl_sv_mortalcopy +SV* +Perl_sv_mortalcopy(pTHXo_ SV* oldsv) { - return ((CPerlObj*)pPerl)->Perl_pp_pushre(); + return ((CPerlObj*)pPerl)->Perl_sv_mortalcopy(oldsv); } -#undef Perl_pp_qr -OP * -Perl_pp_qr(pTHXo) +#undef Perl_sv_newmortal +SV* +Perl_sv_newmortal(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_qr(); + return ((CPerlObj*)pPerl)->Perl_sv_newmortal(); } -#undef Perl_pp_quotemeta -OP * -Perl_pp_quotemeta(pTHXo) +#undef Perl_sv_newref +SV* +Perl_sv_newref(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_quotemeta(); + return ((CPerlObj*)pPerl)->Perl_sv_newref(sv); } -#undef Perl_pp_rand -OP * -Perl_pp_rand(pTHXo) +#undef Perl_sv_peek +char* +Perl_sv_peek(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_rand(); + return ((CPerlObj*)pPerl)->Perl_sv_peek(sv); } -#undef Perl_pp_range -OP * -Perl_pp_range(pTHXo) +#undef Perl_sv_pos_u2b +void +Perl_sv_pos_u2b(pTHXo_ SV* sv, I32* offsetp, I32* lenp) { - return ((CPerlObj*)pPerl)->Perl_pp_range(); + ((CPerlObj*)pPerl)->Perl_sv_pos_u2b(sv, offsetp, lenp); } -#undef Perl_pp_rcatline -OP * -Perl_pp_rcatline(pTHXo) +#undef Perl_sv_pos_b2u +void +Perl_sv_pos_b2u(pTHXo_ SV* sv, I32* offsetp) { - return ((CPerlObj*)pPerl)->Perl_pp_rcatline(); + ((CPerlObj*)pPerl)->Perl_sv_pos_b2u(sv, offsetp); } -#undef Perl_pp_read -OP * -Perl_pp_read(pTHXo) +#undef Perl_sv_pvn_force +char* +Perl_sv_pvn_force(pTHXo_ SV* sv, STRLEN* lp) { - return ((CPerlObj*)pPerl)->Perl_pp_read(); + return ((CPerlObj*)pPerl)->Perl_sv_pvn_force(sv, lp); } -#undef Perl_pp_readdir -OP * -Perl_pp_readdir(pTHXo) +#undef Perl_sv_pvutf8n_force +char* +Perl_sv_pvutf8n_force(pTHXo_ SV* sv, STRLEN* lp) { - return ((CPerlObj*)pPerl)->Perl_pp_readdir(); + return ((CPerlObj*)pPerl)->Perl_sv_pvutf8n_force(sv, lp); } -#undef Perl_pp_readline -OP * -Perl_pp_readline(pTHXo) +#undef Perl_sv_pvbyten_force +char* +Perl_sv_pvbyten_force(pTHXo_ SV* sv, STRLEN* lp) { - return ((CPerlObj*)pPerl)->Perl_pp_readline(); + return ((CPerlObj*)pPerl)->Perl_sv_pvbyten_force(sv, lp); } -#undef Perl_pp_readlink -OP * -Perl_pp_readlink(pTHXo) +#undef Perl_sv_reftype +char* +Perl_sv_reftype(pTHXo_ SV* sv, int ob) { - return ((CPerlObj*)pPerl)->Perl_pp_readlink(); + return ((CPerlObj*)pPerl)->Perl_sv_reftype(sv, ob); } -#undef Perl_pp_recv -OP * -Perl_pp_recv(pTHXo) +#undef Perl_sv_replace +void +Perl_sv_replace(pTHXo_ SV* sv, SV* nsv) { - return ((CPerlObj*)pPerl)->Perl_pp_recv(); + ((CPerlObj*)pPerl)->Perl_sv_replace(sv, nsv); } -#undef Perl_pp_redo -OP * -Perl_pp_redo(pTHXo) +#undef Perl_sv_report_used +void +Perl_sv_report_used(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_redo(); + ((CPerlObj*)pPerl)->Perl_sv_report_used(); } -#undef Perl_pp_ref -OP * -Perl_pp_ref(pTHXo) +#undef Perl_sv_reset +void +Perl_sv_reset(pTHXo_ char* s, HV* stash) { - return ((CPerlObj*)pPerl)->Perl_pp_ref(); + ((CPerlObj*)pPerl)->Perl_sv_reset(s, stash); } -#undef Perl_pp_refgen -OP * -Perl_pp_refgen(pTHXo) +#undef Perl_sv_setpvf +void +Perl_sv_setpvf(pTHXo_ SV* sv, const char* pat, ...) { - return ((CPerlObj*)pPerl)->Perl_pp_refgen(); + va_list args; + va_start(args, pat); + ((CPerlObj*)pPerl)->Perl_sv_vsetpvf(sv, pat, &args); + va_end(args); } -#undef Perl_pp_regcmaybe -OP * -Perl_pp_regcmaybe(pTHXo) +#undef Perl_sv_vsetpvf +void +Perl_sv_vsetpvf(pTHXo_ SV* sv, const char* pat, va_list* args) { - return ((CPerlObj*)pPerl)->Perl_pp_regcmaybe(); + ((CPerlObj*)pPerl)->Perl_sv_vsetpvf(sv, pat, args); } -#undef Perl_pp_regcomp -OP * -Perl_pp_regcomp(pTHXo) +#undef Perl_sv_setiv +void +Perl_sv_setiv(pTHXo_ SV* sv, IV num) { - return ((CPerlObj*)pPerl)->Perl_pp_regcomp(); + ((CPerlObj*)pPerl)->Perl_sv_setiv(sv, num); } -#undef Perl_pp_regcreset -OP * -Perl_pp_regcreset(pTHXo) +#undef Perl_sv_setpviv +void +Perl_sv_setpviv(pTHXo_ SV* sv, IV num) { - return ((CPerlObj*)pPerl)->Perl_pp_regcreset(); + ((CPerlObj*)pPerl)->Perl_sv_setpviv(sv, num); } -#undef Perl_pp_rename -OP * -Perl_pp_rename(pTHXo) +#undef Perl_sv_setuv +void +Perl_sv_setuv(pTHXo_ SV* sv, UV num) { - return ((CPerlObj*)pPerl)->Perl_pp_rename(); + ((CPerlObj*)pPerl)->Perl_sv_setuv(sv, num); } -#undef Perl_pp_repeat -OP * -Perl_pp_repeat(pTHXo) +#undef Perl_sv_setnv +void +Perl_sv_setnv(pTHXo_ SV* sv, NV num) { - return ((CPerlObj*)pPerl)->Perl_pp_repeat(); + ((CPerlObj*)pPerl)->Perl_sv_setnv(sv, num); } -#undef Perl_pp_require -OP * -Perl_pp_require(pTHXo) +#undef Perl_sv_setref_iv +SV* +Perl_sv_setref_iv(pTHXo_ SV* rv, const char* classname, IV iv) { - return ((CPerlObj*)pPerl)->Perl_pp_require(); + return ((CPerlObj*)pPerl)->Perl_sv_setref_iv(rv, classname, iv); } -#undef Perl_pp_reset -OP * -Perl_pp_reset(pTHXo) +#undef Perl_sv_setref_nv +SV* +Perl_sv_setref_nv(pTHXo_ SV* rv, const char* classname, NV nv) { - return ((CPerlObj*)pPerl)->Perl_pp_reset(); + return ((CPerlObj*)pPerl)->Perl_sv_setref_nv(rv, classname, nv); } -#undef Perl_pp_return -OP * -Perl_pp_return(pTHXo) +#undef Perl_sv_setref_pv +SV* +Perl_sv_setref_pv(pTHXo_ SV* rv, const char* classname, void* pv) { - return ((CPerlObj*)pPerl)->Perl_pp_return(); + return ((CPerlObj*)pPerl)->Perl_sv_setref_pv(rv, classname, pv); } -#undef Perl_pp_reverse -OP * -Perl_pp_reverse(pTHXo) +#undef Perl_sv_setref_pvn +SV* +Perl_sv_setref_pvn(pTHXo_ SV* rv, const char* classname, char* pv, STRLEN n) { - return ((CPerlObj*)pPerl)->Perl_pp_reverse(); + return ((CPerlObj*)pPerl)->Perl_sv_setref_pvn(rv, classname, pv, n); } -#undef Perl_pp_rewinddir -OP * -Perl_pp_rewinddir(pTHXo) +#undef Perl_sv_setpv +void +Perl_sv_setpv(pTHXo_ SV* sv, const char* ptr) { - return ((CPerlObj*)pPerl)->Perl_pp_rewinddir(); + ((CPerlObj*)pPerl)->Perl_sv_setpv(sv, ptr); } -#undef Perl_pp_right_shift -OP * -Perl_pp_right_shift(pTHXo) +#undef Perl_sv_setpvn +void +Perl_sv_setpvn(pTHXo_ SV* sv, const char* ptr, STRLEN len) { - return ((CPerlObj*)pPerl)->Perl_pp_right_shift(); + ((CPerlObj*)pPerl)->Perl_sv_setpvn(sv, ptr, len); } -#undef Perl_pp_rindex -OP * -Perl_pp_rindex(pTHXo) +#undef Perl_sv_setsv +void +Perl_sv_setsv(pTHXo_ SV* dsv, SV* ssv) { - return ((CPerlObj*)pPerl)->Perl_pp_rindex(); + ((CPerlObj*)pPerl)->Perl_sv_setsv(dsv, ssv); } -#undef Perl_pp_rmdir -OP * -Perl_pp_rmdir(pTHXo) +#undef Perl_sv_taint +void +Perl_sv_taint(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_rmdir(); + ((CPerlObj*)pPerl)->Perl_sv_taint(sv); } -#undef Perl_pp_rv2av -OP * -Perl_pp_rv2av(pTHXo) +#undef Perl_sv_tainted +bool +Perl_sv_tainted(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_rv2av(); + return ((CPerlObj*)pPerl)->Perl_sv_tainted(sv); } -#undef Perl_pp_rv2cv -OP * -Perl_pp_rv2cv(pTHXo) +#undef Perl_sv_unmagic +int +Perl_sv_unmagic(pTHXo_ SV* sv, int type) { - return ((CPerlObj*)pPerl)->Perl_pp_rv2cv(); + return ((CPerlObj*)pPerl)->Perl_sv_unmagic(sv, type); } -#undef Perl_pp_rv2gv -OP * -Perl_pp_rv2gv(pTHXo) +#undef Perl_sv_unref +void +Perl_sv_unref(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_rv2gv(); + ((CPerlObj*)pPerl)->Perl_sv_unref(sv); } -#undef Perl_pp_rv2hv -OP * -Perl_pp_rv2hv(pTHXo) +#undef Perl_sv_untaint +void +Perl_sv_untaint(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_rv2hv(); + ((CPerlObj*)pPerl)->Perl_sv_untaint(sv); } -#undef Perl_pp_rv2sv -OP * -Perl_pp_rv2sv(pTHXo) +#undef Perl_sv_upgrade +bool +Perl_sv_upgrade(pTHXo_ SV* sv, U32 mt) { - return ((CPerlObj*)pPerl)->Perl_pp_rv2sv(); + return ((CPerlObj*)pPerl)->Perl_sv_upgrade(sv, mt); } -#undef Perl_pp_sassign -OP * -Perl_pp_sassign(pTHXo) +#undef Perl_sv_usepvn +void +Perl_sv_usepvn(pTHXo_ SV* sv, char* ptr, STRLEN len) { - return ((CPerlObj*)pPerl)->Perl_pp_sassign(); + ((CPerlObj*)pPerl)->Perl_sv_usepvn(sv, ptr, len); } -#undef Perl_pp_scalar -OP * -Perl_pp_scalar(pTHXo) +#undef Perl_sv_vcatpvfn +void +Perl_sv_vcatpvfn(pTHXo_ SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted) { - return ((CPerlObj*)pPerl)->Perl_pp_scalar(); + ((CPerlObj*)pPerl)->Perl_sv_vcatpvfn(sv, pat, patlen, args, svargs, svmax, maybe_tainted); } -#undef Perl_pp_schomp -OP * -Perl_pp_schomp(pTHXo) +#undef Perl_sv_vsetpvfn +void +Perl_sv_vsetpvfn(pTHXo_ SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted) { - return ((CPerlObj*)pPerl)->Perl_pp_schomp(); + ((CPerlObj*)pPerl)->Perl_sv_vsetpvfn(sv, pat, patlen, args, svargs, svmax, maybe_tainted); } -#undef Perl_pp_schop -OP * -Perl_pp_schop(pTHXo) +#undef Perl_taint_env +void +Perl_taint_env(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_schop(); + ((CPerlObj*)pPerl)->Perl_taint_env(); } -#undef Perl_pp_scmp -OP * -Perl_pp_scmp(pTHXo) +#undef Perl_taint_proper +void +Perl_taint_proper(pTHXo_ const char* f, const char* s) { - return ((CPerlObj*)pPerl)->Perl_pp_scmp(); + ((CPerlObj*)pPerl)->Perl_taint_proper(f, s); } -#undef Perl_pp_scope -OP * -Perl_pp_scope(pTHXo) +#undef Perl_to_utf8_lower +UV +Perl_to_utf8_lower(pTHXo_ U8 *p) { - return ((CPerlObj*)pPerl)->Perl_pp_scope(); + return ((CPerlObj*)pPerl)->Perl_to_utf8_lower(p); } -#undef Perl_pp_seek -OP * -Perl_pp_seek(pTHXo) +#undef Perl_to_utf8_upper +UV +Perl_to_utf8_upper(pTHXo_ U8 *p) { - return ((CPerlObj*)pPerl)->Perl_pp_seek(); + return ((CPerlObj*)pPerl)->Perl_to_utf8_upper(p); } -#undef Perl_pp_seekdir -OP * -Perl_pp_seekdir(pTHXo) +#undef Perl_to_utf8_title +UV +Perl_to_utf8_title(pTHXo_ U8 *p) { - return ((CPerlObj*)pPerl)->Perl_pp_seekdir(); + return ((CPerlObj*)pPerl)->Perl_to_utf8_title(p); } +#if defined(UNLINK_ALL_VERSIONS) -#undef Perl_pp_select -OP * -Perl_pp_select(pTHXo) +#undef Perl_unlnk +I32 +Perl_unlnk(pTHXo_ char* f) { - return ((CPerlObj*)pPerl)->Perl_pp_select(); + return ((CPerlObj*)pPerl)->Perl_unlnk(f); } +#endif +#if defined(USE_THREADS) +#endif -#undef Perl_pp_semctl -OP * -Perl_pp_semctl(pTHXo) +#undef Perl_utf16_to_utf8 +U8* +Perl_utf16_to_utf8(pTHXo_ U16* p, U8 *d, I32 bytelen) { - return ((CPerlObj*)pPerl)->Perl_pp_semctl(); + return ((CPerlObj*)pPerl)->Perl_utf16_to_utf8(p, d, bytelen); } -#undef Perl_pp_semget -OP * -Perl_pp_semget(pTHXo) +#undef Perl_utf16_to_utf8_reversed +U8* +Perl_utf16_to_utf8_reversed(pTHXo_ U16* p, U8 *d, I32 bytelen) { - return ((CPerlObj*)pPerl)->Perl_pp_semget(); + return ((CPerlObj*)pPerl)->Perl_utf16_to_utf8_reversed(p, d, bytelen); } -#undef Perl_pp_semop -OP * -Perl_pp_semop(pTHXo) +#undef Perl_utf8_distance +I32 +Perl_utf8_distance(pTHXo_ U8 *a, U8 *b) { - return ((CPerlObj*)pPerl)->Perl_pp_semop(); + return ((CPerlObj*)pPerl)->Perl_utf8_distance(a, b); } -#undef Perl_pp_send -OP * -Perl_pp_send(pTHXo) +#undef Perl_utf8_hop +U8* +Perl_utf8_hop(pTHXo_ U8 *s, I32 off) { - return ((CPerlObj*)pPerl)->Perl_pp_send(); + return ((CPerlObj*)pPerl)->Perl_utf8_hop(s, off); } -#undef Perl_pp_seq -OP * -Perl_pp_seq(pTHXo) +#undef Perl_utf8_to_uv +UV +Perl_utf8_to_uv(pTHXo_ U8 *s, I32* retlen) { - return ((CPerlObj*)pPerl)->Perl_pp_seq(); + return ((CPerlObj*)pPerl)->Perl_utf8_to_uv(s, retlen); } -#undef Perl_pp_setpgrp -OP * -Perl_pp_setpgrp(pTHXo) +#undef Perl_uv_to_utf8 +U8* +Perl_uv_to_utf8(pTHXo_ U8 *d, UV uv) { - return ((CPerlObj*)pPerl)->Perl_pp_setpgrp(); + return ((CPerlObj*)pPerl)->Perl_uv_to_utf8(d, uv); } -#undef Perl_pp_setpriority -OP * -Perl_pp_setpriority(pTHXo) +#undef Perl_warn +void +Perl_warn(pTHXo_ const char* pat, ...) { - return ((CPerlObj*)pPerl)->Perl_pp_setpriority(); + va_list args; + va_start(args, pat); + ((CPerlObj*)pPerl)->Perl_vwarn(pat, &args); + va_end(args); } -#undef Perl_pp_setstate -OP * -Perl_pp_setstate(pTHXo) +#undef Perl_vwarn +void +Perl_vwarn(pTHXo_ const char* pat, va_list* args) { - return ((CPerlObj*)pPerl)->Perl_pp_setstate(); + ((CPerlObj*)pPerl)->Perl_vwarn(pat, args); } -#undef Perl_pp_sge -OP * -Perl_pp_sge(pTHXo) +#undef Perl_warner +void +Perl_warner(pTHXo_ U32 err, const char* pat, ...) { - return ((CPerlObj*)pPerl)->Perl_pp_sge(); + va_list args; + va_start(args, pat); + ((CPerlObj*)pPerl)->Perl_vwarner(err, pat, &args); + va_end(args); } -#undef Perl_pp_sgrent -OP * -Perl_pp_sgrent(pTHXo) +#undef Perl_vwarner +void +Perl_vwarner(pTHXo_ U32 err, const char* pat, va_list* args) { - return ((CPerlObj*)pPerl)->Perl_pp_sgrent(); + ((CPerlObj*)pPerl)->Perl_vwarner(err, pat, args); } +#if defined(USE_PURE_BISON) +#else +#endif +#if defined(MYMALLOC) -#undef Perl_pp_sgt -OP * -Perl_pp_sgt(pTHXo) +#undef Perl_dump_mstats +void +Perl_dump_mstats(pTHXo_ char* s) { - return ((CPerlObj*)pPerl)->Perl_pp_sgt(); + ((CPerlObj*)pPerl)->Perl_dump_mstats(s); } +#endif -#undef Perl_pp_shift -OP * -Perl_pp_shift(pTHXo) +#undef Perl_safesysmalloc +Malloc_t +Perl_safesysmalloc(MEM_SIZE nbytes) { - return ((CPerlObj*)pPerl)->Perl_pp_shift(); + dTHXo; + return ((CPerlObj*)pPerl)->Perl_safesysmalloc(nbytes); } -#undef Perl_pp_shmctl -OP * -Perl_pp_shmctl(pTHXo) +#undef Perl_safesyscalloc +Malloc_t +Perl_safesyscalloc(MEM_SIZE elements, MEM_SIZE size) { - return ((CPerlObj*)pPerl)->Perl_pp_shmctl(); + dTHXo; + return ((CPerlObj*)pPerl)->Perl_safesyscalloc(elements, size); } -#undef Perl_pp_shmget -OP * -Perl_pp_shmget(pTHXo) +#undef Perl_safesysrealloc +Malloc_t +Perl_safesysrealloc(Malloc_t where, MEM_SIZE nbytes) { - return ((CPerlObj*)pPerl)->Perl_pp_shmget(); + dTHXo; + return ((CPerlObj*)pPerl)->Perl_safesysrealloc(where, nbytes); } -#undef Perl_pp_shmread -OP * -Perl_pp_shmread(pTHXo) +#undef Perl_safesysfree +Free_t +Perl_safesysfree(Malloc_t where) { - return ((CPerlObj*)pPerl)->Perl_pp_shmread(); + dTHXo; + ((CPerlObj*)pPerl)->Perl_safesysfree(where); } +#if defined(LEAKTEST) -#undef Perl_pp_shmwrite -OP * -Perl_pp_shmwrite(pTHXo) +#undef Perl_safexmalloc +Malloc_t +Perl_safexmalloc(I32 x, MEM_SIZE size) { - return ((CPerlObj*)pPerl)->Perl_pp_shmwrite(); + dTHXo; + return ((CPerlObj*)pPerl)->Perl_safexmalloc(x, size); } -#undef Perl_pp_shostent -OP * -Perl_pp_shostent(pTHXo) +#undef Perl_safexcalloc +Malloc_t +Perl_safexcalloc(I32 x, MEM_SIZE elements, MEM_SIZE size) { - return ((CPerlObj*)pPerl)->Perl_pp_shostent(); + dTHXo; + return ((CPerlObj*)pPerl)->Perl_safexcalloc(x, elements, size); } -#undef Perl_pp_shutdown -OP * -Perl_pp_shutdown(pTHXo) +#undef Perl_safexrealloc +Malloc_t +Perl_safexrealloc(Malloc_t where, MEM_SIZE size) { - return ((CPerlObj*)pPerl)->Perl_pp_shutdown(); + dTHXo; + return ((CPerlObj*)pPerl)->Perl_safexrealloc(where, size); } -#undef Perl_pp_sin -OP * -Perl_pp_sin(pTHXo) +#undef Perl_safexfree +void +Perl_safexfree(Malloc_t where) { - return ((CPerlObj*)pPerl)->Perl_pp_sin(); + dTHXo; + ((CPerlObj*)pPerl)->Perl_safexfree(where); } +#endif +#if defined(PERL_GLOBAL_STRUCT) -#undef Perl_pp_sle -OP * -Perl_pp_sle(pTHXo) +#undef Perl_GetVars +struct perl_vars * +Perl_GetVars(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_sle(); + return ((CPerlObj*)pPerl)->Perl_GetVars(); } +#endif -#undef Perl_pp_sleep -OP * -Perl_pp_sleep(pTHXo) +#undef Perl_runops_standard +int +Perl_runops_standard(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_sleep(); + return ((CPerlObj*)pPerl)->Perl_runops_standard(); } -#undef Perl_pp_slt -OP * -Perl_pp_slt(pTHXo) +#undef Perl_runops_debug +int +Perl_runops_debug(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_slt(); + return ((CPerlObj*)pPerl)->Perl_runops_debug(); } -#undef Perl_pp_sne -OP * -Perl_pp_sne(pTHXo) +#undef Perl_sv_catpvf_mg +void +Perl_sv_catpvf_mg(pTHXo_ SV *sv, const char* pat, ...) { - return ((CPerlObj*)pPerl)->Perl_pp_sne(); + va_list args; + va_start(args, pat); + ((CPerlObj*)pPerl)->Perl_sv_vcatpvf_mg(sv, pat, &args); + va_end(args); } -#undef Perl_pp_snetent -OP * -Perl_pp_snetent(pTHXo) +#undef Perl_sv_vcatpvf_mg +void +Perl_sv_vcatpvf_mg(pTHXo_ SV* sv, const char* pat, va_list* args) { - return ((CPerlObj*)pPerl)->Perl_pp_snetent(); + ((CPerlObj*)pPerl)->Perl_sv_vcatpvf_mg(sv, pat, args); } -#undef Perl_pp_socket -OP * -Perl_pp_socket(pTHXo) +#undef Perl_sv_catpv_mg +void +Perl_sv_catpv_mg(pTHXo_ SV *sv, const char *ptr) { - return ((CPerlObj*)pPerl)->Perl_pp_socket(); + ((CPerlObj*)pPerl)->Perl_sv_catpv_mg(sv, ptr); } -#undef Perl_pp_sockpair -OP * -Perl_pp_sockpair(pTHXo) +#undef Perl_sv_catpvn_mg +void +Perl_sv_catpvn_mg(pTHXo_ SV *sv, const char *ptr, STRLEN len) { - return ((CPerlObj*)pPerl)->Perl_pp_sockpair(); + ((CPerlObj*)pPerl)->Perl_sv_catpvn_mg(sv, ptr, len); } -#undef Perl_pp_sort -OP * -Perl_pp_sort(pTHXo) +#undef Perl_sv_catsv_mg +void +Perl_sv_catsv_mg(pTHXo_ SV *dstr, SV *sstr) { - return ((CPerlObj*)pPerl)->Perl_pp_sort(); + ((CPerlObj*)pPerl)->Perl_sv_catsv_mg(dstr, sstr); } -#undef Perl_pp_splice -OP * -Perl_pp_splice(pTHXo) +#undef Perl_sv_setpvf_mg +void +Perl_sv_setpvf_mg(pTHXo_ SV *sv, const char* pat, ...) { - return ((CPerlObj*)pPerl)->Perl_pp_splice(); + va_list args; + va_start(args, pat); + ((CPerlObj*)pPerl)->Perl_sv_vsetpvf_mg(sv, pat, &args); + va_end(args); } -#undef Perl_pp_split -OP * -Perl_pp_split(pTHXo) +#undef Perl_sv_vsetpvf_mg +void +Perl_sv_vsetpvf_mg(pTHXo_ SV* sv, const char* pat, va_list* args) { - return ((CPerlObj*)pPerl)->Perl_pp_split(); + ((CPerlObj*)pPerl)->Perl_sv_vsetpvf_mg(sv, pat, args); } -#undef Perl_pp_sprintf -OP * -Perl_pp_sprintf(pTHXo) +#undef Perl_sv_setiv_mg +void +Perl_sv_setiv_mg(pTHXo_ SV *sv, IV i) { - return ((CPerlObj*)pPerl)->Perl_pp_sprintf(); + ((CPerlObj*)pPerl)->Perl_sv_setiv_mg(sv, i); } -#undef Perl_pp_sprotoent -OP * -Perl_pp_sprotoent(pTHXo) +#undef Perl_sv_setpviv_mg +void +Perl_sv_setpviv_mg(pTHXo_ SV *sv, IV iv) { - return ((CPerlObj*)pPerl)->Perl_pp_sprotoent(); + ((CPerlObj*)pPerl)->Perl_sv_setpviv_mg(sv, iv); } -#undef Perl_pp_spwent -OP * -Perl_pp_spwent(pTHXo) +#undef Perl_sv_setuv_mg +void +Perl_sv_setuv_mg(pTHXo_ SV *sv, UV u) { - return ((CPerlObj*)pPerl)->Perl_pp_spwent(); + ((CPerlObj*)pPerl)->Perl_sv_setuv_mg(sv, u); } -#undef Perl_pp_sqrt -OP * -Perl_pp_sqrt(pTHXo) +#undef Perl_sv_setnv_mg +void +Perl_sv_setnv_mg(pTHXo_ SV *sv, NV num) { - return ((CPerlObj*)pPerl)->Perl_pp_sqrt(); + ((CPerlObj*)pPerl)->Perl_sv_setnv_mg(sv, num); } -#undef Perl_pp_srand -OP * -Perl_pp_srand(pTHXo) +#undef Perl_sv_setpv_mg +void +Perl_sv_setpv_mg(pTHXo_ SV *sv, const char *ptr) { - return ((CPerlObj*)pPerl)->Perl_pp_srand(); + ((CPerlObj*)pPerl)->Perl_sv_setpv_mg(sv, ptr); } -#undef Perl_pp_srefgen -OP * -Perl_pp_srefgen(pTHXo) +#undef Perl_sv_setpvn_mg +void +Perl_sv_setpvn_mg(pTHXo_ SV *sv, const char *ptr, STRLEN len) { - return ((CPerlObj*)pPerl)->Perl_pp_srefgen(); + ((CPerlObj*)pPerl)->Perl_sv_setpvn_mg(sv, ptr, len); } -#undef Perl_pp_sselect -OP * -Perl_pp_sselect(pTHXo) +#undef Perl_sv_setsv_mg +void +Perl_sv_setsv_mg(pTHXo_ SV *dstr, SV *sstr) { - return ((CPerlObj*)pPerl)->Perl_pp_sselect(); + ((CPerlObj*)pPerl)->Perl_sv_setsv_mg(dstr, sstr); } -#undef Perl_pp_sservent -OP * -Perl_pp_sservent(pTHXo) +#undef Perl_sv_usepvn_mg +void +Perl_sv_usepvn_mg(pTHXo_ SV *sv, char *ptr, STRLEN len) { - return ((CPerlObj*)pPerl)->Perl_pp_sservent(); + ((CPerlObj*)pPerl)->Perl_sv_usepvn_mg(sv, ptr, len); } -#undef Perl_pp_ssockopt -OP * -Perl_pp_ssockopt(pTHXo) +#undef Perl_get_vtbl +MGVTBL* +Perl_get_vtbl(pTHXo_ int vtbl_id) { - return ((CPerlObj*)pPerl)->Perl_pp_ssockopt(); + return ((CPerlObj*)pPerl)->Perl_get_vtbl(vtbl_id); } -#undef Perl_pp_stat -OP * -Perl_pp_stat(pTHXo) +#undef Perl_dump_indent +void +Perl_dump_indent(pTHXo_ I32 level, PerlIO *file, const char* pat, ...) { - return ((CPerlObj*)pPerl)->Perl_pp_stat(); + va_list args; + va_start(args, pat); + ((CPerlObj*)pPerl)->Perl_dump_vindent(level, file, pat, &args); + va_end(args); } -#undef Perl_pp_stringify -OP * -Perl_pp_stringify(pTHXo) +#undef Perl_dump_vindent +void +Perl_dump_vindent(pTHXo_ I32 level, PerlIO *file, const char* pat, va_list *args) { - return ((CPerlObj*)pPerl)->Perl_pp_stringify(); + ((CPerlObj*)pPerl)->Perl_dump_vindent(level, file, pat, args); } -#undef Perl_pp_stub -OP * -Perl_pp_stub(pTHXo) +#undef Perl_do_gv_dump +void +Perl_do_gv_dump(pTHXo_ I32 level, PerlIO *file, char *name, GV *sv) { - return ((CPerlObj*)pPerl)->Perl_pp_stub(); + ((CPerlObj*)pPerl)->Perl_do_gv_dump(level, file, name, sv); } -#undef Perl_pp_study -OP * -Perl_pp_study(pTHXo) +#undef Perl_do_gvgv_dump +void +Perl_do_gvgv_dump(pTHXo_ I32 level, PerlIO *file, char *name, GV *sv) { - return ((CPerlObj*)pPerl)->Perl_pp_study(); + ((CPerlObj*)pPerl)->Perl_do_gvgv_dump(level, file, name, sv); } -#undef Perl_pp_subst -OP * -Perl_pp_subst(pTHXo) +#undef Perl_do_hv_dump +void +Perl_do_hv_dump(pTHXo_ I32 level, PerlIO *file, char *name, HV *sv) { - return ((CPerlObj*)pPerl)->Perl_pp_subst(); + ((CPerlObj*)pPerl)->Perl_do_hv_dump(level, file, name, sv); } -#undef Perl_pp_substcont -OP * -Perl_pp_substcont(pTHXo) +#undef Perl_do_magic_dump +void +Perl_do_magic_dump(pTHXo_ I32 level, PerlIO *file, MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim) { - return ((CPerlObj*)pPerl)->Perl_pp_substcont(); + ((CPerlObj*)pPerl)->Perl_do_magic_dump(level, file, mg, nest, maxnest, dumpops, pvlim); } -#undef Perl_pp_substr -OP * -Perl_pp_substr(pTHXo) +#undef Perl_do_op_dump +void +Perl_do_op_dump(pTHXo_ I32 level, PerlIO *file, OP *o) { - return ((CPerlObj*)pPerl)->Perl_pp_substr(); + ((CPerlObj*)pPerl)->Perl_do_op_dump(level, file, o); } -#undef Perl_pp_subtract -OP * -Perl_pp_subtract(pTHXo) +#undef Perl_do_pmop_dump +void +Perl_do_pmop_dump(pTHXo_ I32 level, PerlIO *file, PMOP *pm) { - return ((CPerlObj*)pPerl)->Perl_pp_subtract(); + ((CPerlObj*)pPerl)->Perl_do_pmop_dump(level, file, pm); } -#undef Perl_pp_symlink -OP * -Perl_pp_symlink(pTHXo) +#undef Perl_do_sv_dump +void +Perl_do_sv_dump(pTHXo_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim) { - return ((CPerlObj*)pPerl)->Perl_pp_symlink(); + ((CPerlObj*)pPerl)->Perl_do_sv_dump(level, file, sv, nest, maxnest, dumpops, pvlim); } -#undef Perl_pp_syscall -OP * -Perl_pp_syscall(pTHXo) +#undef Perl_magic_dump +void +Perl_magic_dump(pTHXo_ MAGIC *mg) { - return ((CPerlObj*)pPerl)->Perl_pp_syscall(); + ((CPerlObj*)pPerl)->Perl_magic_dump(mg); } -#undef Perl_pp_sysopen -OP * -Perl_pp_sysopen(pTHXo) +#undef Perl_default_protect +void* +Perl_default_protect(pTHXo_ volatile JMPENV *je, int *excpt, protect_body_t body, ...) { - return ((CPerlObj*)pPerl)->Perl_pp_sysopen(); + void* retval; + va_list args; + va_start(args, body); + retval = ((CPerlObj*)pPerl)->Perl_vdefault_protect(je, excpt, body, &args); + va_end(args); + return retval; + } -#undef Perl_pp_sysread -OP * -Perl_pp_sysread(pTHXo) +#undef Perl_vdefault_protect +void* +Perl_vdefault_protect(pTHXo_ volatile JMPENV *je, int *excpt, protect_body_t body, va_list *args) { - return ((CPerlObj*)pPerl)->Perl_pp_sysread(); + return ((CPerlObj*)pPerl)->Perl_vdefault_protect(je, excpt, body, args); } -#undef Perl_pp_sysseek -OP * -Perl_pp_sysseek(pTHXo) +#undef Perl_reginitcolors +void +Perl_reginitcolors(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_sysseek(); + ((CPerlObj*)pPerl)->Perl_reginitcolors(); } -#undef Perl_pp_system -OP * -Perl_pp_system(pTHXo) +#undef Perl_sv_2pv_nolen +char* +Perl_sv_2pv_nolen(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_system(); + return ((CPerlObj*)pPerl)->Perl_sv_2pv_nolen(sv); } -#undef Perl_pp_syswrite -OP * -Perl_pp_syswrite(pTHXo) +#undef Perl_sv_2pvutf8_nolen +char* +Perl_sv_2pvutf8_nolen(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_syswrite(); + return ((CPerlObj*)pPerl)->Perl_sv_2pvutf8_nolen(sv); } -#undef Perl_pp_tell -OP * -Perl_pp_tell(pTHXo) +#undef Perl_sv_2pvbyte_nolen +char* +Perl_sv_2pvbyte_nolen(pTHXo_ SV* sv) { - return ((CPerlObj*)pPerl)->Perl_pp_tell(); + return ((CPerlObj*)pPerl)->Perl_sv_2pvbyte_nolen(sv); } -#undef Perl_pp_telldir -OP * -Perl_pp_telldir(pTHXo) +#undef Perl_sv_pv +char* +Perl_sv_pv(pTHXo_ SV *sv) { - return ((CPerlObj*)pPerl)->Perl_pp_telldir(); + return ((CPerlObj*)pPerl)->Perl_sv_pv(sv); } -#undef Perl_pp_threadsv -OP * -Perl_pp_threadsv(pTHXo) +#undef Perl_sv_pvutf8 +char* +Perl_sv_pvutf8(pTHXo_ SV *sv) { - return ((CPerlObj*)pPerl)->Perl_pp_threadsv(); + return ((CPerlObj*)pPerl)->Perl_sv_pvutf8(sv); } -#undef Perl_pp_tie -OP * -Perl_pp_tie(pTHXo) +#undef Perl_sv_pvbyte +char* +Perl_sv_pvbyte(pTHXo_ SV *sv) { - return ((CPerlObj*)pPerl)->Perl_pp_tie(); + return ((CPerlObj*)pPerl)->Perl_sv_pvbyte(sv); } -#undef Perl_pp_tied -OP * -Perl_pp_tied(pTHXo) +#undef Perl_sv_force_normal +void +Perl_sv_force_normal(pTHXo_ SV *sv) { - return ((CPerlObj*)pPerl)->Perl_pp_tied(); + ((CPerlObj*)pPerl)->Perl_sv_force_normal(sv); } -#undef Perl_pp_time -OP * -Perl_pp_time(pTHXo) +#undef Perl_tmps_grow +void +Perl_tmps_grow(pTHXo_ I32 n) { - return ((CPerlObj*)pPerl)->Perl_pp_time(); + ((CPerlObj*)pPerl)->Perl_tmps_grow(n); } -#undef Perl_pp_tms -OP * -Perl_pp_tms(pTHXo) +#undef Perl_sv_rvweaken +SV* +Perl_sv_rvweaken(pTHXo_ SV *sv) { - return ((CPerlObj*)pPerl)->Perl_pp_tms(); + return ((CPerlObj*)pPerl)->Perl_sv_rvweaken(sv); } -#undef Perl_pp_trans -OP * -Perl_pp_trans(pTHXo) +#undef Perl_newANONATTRSUB +OP* +Perl_newANONATTRSUB(pTHXo_ I32 floor, OP *proto, OP *attrs, OP *block) { - return ((CPerlObj*)pPerl)->Perl_pp_trans(); + return ((CPerlObj*)pPerl)->Perl_newANONATTRSUB(floor, proto, attrs, block); } -#undef Perl_pp_truncate -OP * -Perl_pp_truncate(pTHXo) +#undef Perl_newATTRSUB +CV* +Perl_newATTRSUB(pTHXo_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) { - return ((CPerlObj*)pPerl)->Perl_pp_truncate(); + return ((CPerlObj*)pPerl)->Perl_newATTRSUB(floor, o, proto, attrs, block); } -#undef Perl_pp_uc -OP * -Perl_pp_uc(pTHXo) +#undef Perl_newMYSUB +void +Perl_newMYSUB(pTHXo_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) { - return ((CPerlObj*)pPerl)->Perl_pp_uc(); + ((CPerlObj*)pPerl)->Perl_newMYSUB(floor, o, proto, attrs, block); } +#if defined(USE_ITHREADS) -#undef Perl_pp_ucfirst -OP * -Perl_pp_ucfirst(pTHXo) +#undef Perl_cx_dup +PERL_CONTEXT* +Perl_cx_dup(pTHXo_ PERL_CONTEXT* cx, I32 ix, I32 max) { - return ((CPerlObj*)pPerl)->Perl_pp_ucfirst(); + return ((CPerlObj*)pPerl)->Perl_cx_dup(cx, ix, max); } -#undef Perl_pp_umask -OP * -Perl_pp_umask(pTHXo) +#undef Perl_si_dup +PERL_SI* +Perl_si_dup(pTHXo_ PERL_SI* si) { - return ((CPerlObj*)pPerl)->Perl_pp_umask(); + return ((CPerlObj*)pPerl)->Perl_si_dup(si); } -#undef Perl_pp_undef -OP * -Perl_pp_undef(pTHXo) +#undef Perl_ss_dup +ANY* +Perl_ss_dup(pTHXo_ PerlInterpreter* proto_perl) { - return ((CPerlObj*)pPerl)->Perl_pp_undef(); + return ((CPerlObj*)pPerl)->Perl_ss_dup(proto_perl); } -#undef Perl_pp_unlink -OP * -Perl_pp_unlink(pTHXo) +#undef Perl_any_dup +void* +Perl_any_dup(pTHXo_ void* v, PerlInterpreter* proto_perl) { - return ((CPerlObj*)pPerl)->Perl_pp_unlink(); + return ((CPerlObj*)pPerl)->Perl_any_dup(v, proto_perl); } -#undef Perl_pp_unpack -OP * -Perl_pp_unpack(pTHXo) +#undef Perl_he_dup +HE* +Perl_he_dup(pTHXo_ HE* e, bool shared) { - return ((CPerlObj*)pPerl)->Perl_pp_unpack(); + return ((CPerlObj*)pPerl)->Perl_he_dup(e, shared); } -#undef Perl_pp_unshift -OP * -Perl_pp_unshift(pTHXo) +#undef Perl_re_dup +REGEXP* +Perl_re_dup(pTHXo_ REGEXP* r) { - return ((CPerlObj*)pPerl)->Perl_pp_unshift(); + return ((CPerlObj*)pPerl)->Perl_re_dup(r); } -#undef Perl_pp_unstack -OP * -Perl_pp_unstack(pTHXo) +#undef Perl_fp_dup +PerlIO* +Perl_fp_dup(pTHXo_ PerlIO* fp, char type) { - return ((CPerlObj*)pPerl)->Perl_pp_unstack(); + return ((CPerlObj*)pPerl)->Perl_fp_dup(fp, type); } -#undef Perl_pp_untie -OP * -Perl_pp_untie(pTHXo) +#undef Perl_dirp_dup +DIR* +Perl_dirp_dup(pTHXo_ DIR* dp) { - return ((CPerlObj*)pPerl)->Perl_pp_untie(); + return ((CPerlObj*)pPerl)->Perl_dirp_dup(dp); } -#undef Perl_pp_utime -OP * -Perl_pp_utime(pTHXo) +#undef Perl_gp_dup +GP* +Perl_gp_dup(pTHXo_ GP* gp) { - return ((CPerlObj*)pPerl)->Perl_pp_utime(); + return ((CPerlObj*)pPerl)->Perl_gp_dup(gp); } -#undef Perl_pp_values -OP * -Perl_pp_values(pTHXo) +#undef Perl_mg_dup +MAGIC* +Perl_mg_dup(pTHXo_ MAGIC* mg) { - return ((CPerlObj*)pPerl)->Perl_pp_values(); + return ((CPerlObj*)pPerl)->Perl_mg_dup(mg); } -#undef Perl_pp_vec -OP * -Perl_pp_vec(pTHXo) +#undef Perl_sv_dup +SV* +Perl_sv_dup(pTHXo_ SV* sstr) { - return ((CPerlObj*)pPerl)->Perl_pp_vec(); + return ((CPerlObj*)pPerl)->Perl_sv_dup(sstr); } +#if defined(HAVE_INTERP_INTERN) -#undef Perl_pp_wait -OP * -Perl_pp_wait(pTHXo) +#undef Perl_sys_intern_dup +void +Perl_sys_intern_dup(pTHXo_ struct interp_intern* src, struct interp_intern* dst) { - return ((CPerlObj*)pPerl)->Perl_pp_wait(); + ((CPerlObj*)pPerl)->Perl_sys_intern_dup(src, dst); } +#endif -#undef Perl_pp_waitpid -OP * -Perl_pp_waitpid(pTHXo) +#undef Perl_ptr_table_new +PTR_TBL_t* +Perl_ptr_table_new(pTHXo) { - return ((CPerlObj*)pPerl)->Perl_pp_waitpid(); + return ((CPerlObj*)pPerl)->Perl_ptr_table_new(); } -#undef Perl_pp_wantarray -OP * -Perl_pp_wantarray(pTHXo) +#undef Perl_ptr_table_fetch +void* +Perl_ptr_table_fetch(pTHXo_ PTR_TBL_t *tbl, void *sv) { - return ((CPerlObj*)pPerl)->Perl_pp_wantarray(); + return ((CPerlObj*)pPerl)->Perl_ptr_table_fetch(tbl, sv); } -#undef Perl_pp_warn -OP * -Perl_pp_warn(pTHXo) +#undef Perl_ptr_table_store +void +Perl_ptr_table_store(pTHXo_ PTR_TBL_t *tbl, void *oldsv, void *newsv) { - return ((CPerlObj*)pPerl)->Perl_pp_warn(); + ((CPerlObj*)pPerl)->Perl_ptr_table_store(tbl, oldsv, newsv); } -#undef Perl_pp_xor -OP * -Perl_pp_xor(pTHXo) +#undef Perl_ptr_table_split +void +Perl_ptr_table_split(pTHXo_ PTR_TBL_t *tbl) { - return ((CPerlObj*)pPerl)->Perl_pp_xor(); + ((CPerlObj*)pPerl)->Perl_ptr_table_split(tbl); } +#endif +#if defined(PERL_OBJECT) +#else +#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(PERL_CR_FILTER) +# 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 +#if defined(PERL_OBJECT) +#endif #undef Perl_fprintf_nocontext int diff --git a/pod/Makefile b/pod/Makefile index 3aadd9e..8199390 100644 --- a/pod/Makefile +++ b/pod/Makefile @@ -62,6 +62,8 @@ POD = \ perlcall.pod \ perlcompile.pod \ perltodo.pod \ + perlapi.pod \ + perlintern.pod \ perlhack.pod \ perlhist.pod \ perlfaq.pod \ @@ -124,6 +126,8 @@ MAN = \ perlcall.man \ perlcompile.man \ perltodo.man \ + perlapi.man \ + perlintern.man \ perlhack.man \ perlhist.man \ perlfaq.man \ @@ -186,6 +190,8 @@ HTML = \ perlcall.html \ perlcompile.html \ perltodo.html \ + perlapi.html \ + perlintern.html \ perlhack.html \ perlhist.html \ perlfaq.html \ @@ -248,6 +254,8 @@ TEX = \ perlcall.tex \ perlcompile.tex \ perltodo.tex \ + perlapi.tex \ + perlintern.tex \ perlhack.tex \ perlhist.tex \ perlfaq.tex \ diff --git a/pod/buildtoc b/pod/buildtoc index 8192b5b..f158cba 100644 --- a/pod/buildtoc +++ b/pod/buildtoc @@ -14,7 +14,7 @@ sub output ($); perldbmfilter perldebug perldiag perlsec perltrap perlport perlstyle perlpod perlbook perlembed perlapio perlxs perlxstut perlguts perlcall perlcompile - perlhist + perlapi perlintern perlhist ); for (@pods) { s/$/.pod/ } diff --git a/pod/perl.pod b/pod/perl.pod index 9b5db82..d52aff3 100644 --- a/pod/perl.pod +++ b/pod/perl.pod @@ -68,6 +68,8 @@ sections: perlxstut Perl XS tutorial perlguts Perl internal functions for those doing extensions perlcall Perl calling conventions from C + perlapi Perl API listing (autogenerated) + perlintern Perl internal functions (autogenerated) perltodo Perl things to do perlhack Perl hackers guide diff --git a/pod/perlapi.pod b/pod/perlapi.pod new file mode 100644 index 0000000..897fcdc --- /dev/null +++ b/pod/perlapi.pod @@ -0,0 +1,2225 @@ +=head1 NAME + +perlapi - autogenerated documentation for the perl public API + +=head1 DESCRIPTION + +This file contains the documentation of the perl public API generated by +embed.pl, specifically a listing of functions, macros, flags, and variables +that may be used by extension writers. The interfaces of any functions that +are not listed here are subject to change without notice. For this reason, +blindly using functions listed in proto.h is to be avoided when writing +extensions. + +Note that all Perl API global variables must be referenced with the C +prefix. Some macros are provided for compatibility with the older, +unadorned names, but this support may be disabled in a future release. + +The listing is alphabetical, case insensitive. + +=over 8 + +=item AvFILL + +Same as C. Deprecated, use C instead. + + int AvFILL(AV* av) + +=item av_clear + +Clears an array, making it empty. Does not free the memory used by the +array itself. + + void av_clear(AV* ar) + +=item av_extend + +Pre-extend an array. The C is the index to which the array should be +extended. + + void av_extend(AV* ar, I32 key) + +=item av_fetch + +Returns the SV at the specified index in the array. The C is the +index. If C is set then the fetch will be part of a store. Check +that the return value is non-null before dereferencing it to a C. + +See L for more information +on how to use this function on tied arrays. + + SV** av_fetch(AV* ar, I32 key, I32 lval) + +=item av_len + +Returns the highest index in the array. Returns -1 if the array is +empty. + + I32 av_len(AV* ar) + +=item av_make + +Creates a new AV and populates it with a list of SVs. The SVs are copied +into the array, so they may be freed after the call to av_make. The new AV +will have a reference count of 1. + + AV* av_make(I32 size, SV** svp) + +=item av_pop + +Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array +is empty. + + SV* av_pop(AV* ar) + +=item av_push + +Pushes an SV onto the end of the array. The array will grow automatically +to accommodate the addition. + + void av_push(AV* ar, SV* val) + +=item av_shift + +Shifts an SV off the beginning of the array. + + SV* av_shift(AV* ar) + +=item av_store + +Stores an SV in an array. The array index is specified as C. The +return value will be NULL if the operation failed or if the value did not +need to be actually stored within the array (as in the case of tied +arrays). Otherwise it can be dereferenced to get the original C. Note +that the caller is responsible for suitably incrementing the reference +count of C before the call, and decrementing it if the function +returned NULL. + +See L for +more information on how to use this function on tied arrays. + + SV** av_store(AV* ar, I32 key, SV* val) + +=item av_undef + +Undefines the array. Frees the memory used by the array itself. + + void av_undef(AV* ar) + +=item av_unshift + +Unshift the given number of C values onto the beginning of the +array. The array will grow automatically to accommodate the addition. You +must then use C to assign values to these new elements. + + void av_unshift(AV* ar, I32 num) + +=item call_argv + +Performs a callback to the specified Perl sub. See L. + +NOTE: the perl_ form of this function is deprecated. + + I32 call_argv(const char* sub_name, I32 flags, char** argv) + +=item call_method + +Performs a callback to the specified Perl method. The blessed object must +be on the stack. See L. + +NOTE: the perl_ form of this function is deprecated. + + I32 call_method(const char* methname, I32 flags) + +=item call_pv + +Performs a callback to the specified Perl sub. See L. + +NOTE: the perl_ form of this function is deprecated. + + I32 call_pv(const char* sub_name, I32 flags) + +=item call_sv + +Performs a callback to the Perl sub whose name is in the SV. See +L. + +NOTE: the perl_ form of this function is deprecated. + + I32 call_sv(SV* sv, I32 flags) + +=item CLASS + +Variable which is setup by C to indicate the +class name for a C++ XS constructor. This is always a C. See C. + + char* CLASS + +=item Copy + +The XSUB-writer's interface to the C C function. The C is the +source, C is the destination, C is the number of items, and C is +the type. May fail on overlapping copies. See also C. + + void Copy(void* src, void* dest, int nitems, type) + +=item croak + +This is the XSUB-writer's interface to Perl's C function. Use this +function the same way you use the C C function. See +C. + + void croak(const char* pat, ...) + +=item CvSTASH + +Returns the stash of the CV. + + HV* CvSTASH(CV* cv) + +=item dMARK + +Declare a stack marker variable, C, for the XSUB. See C and +C. + + dMARK; + +=item dORIGMARK + +Saves the original stack mark for the XSUB. See C. + + dORIGMARK; + +=item dSP + +Declares a local copy of perl's stack pointer for the XSUB, available via +the C macro. See C. + + dSP; + +=item dXSARGS + +Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. This +is usually handled automatically by C. Declares the C +variable to indicate the number of items on the stack. + + dXSARGS; + +=item dXSI32 + +Sets up the C variable for an XSUB which has aliases. This is usually +handled automatically by C. + + dXSI32; + +=item ENTER + +Opening bracket on a callback. See C and L. + + ENTER; + +=item eval_pv + +Tells Perl to C the given string and return an SV* result. + +NOTE: the perl_ form of this function is deprecated. + + SV* eval_pv(const char* p, I32 croak_on_error) + +=item eval_sv + +Tells Perl to C the string in the SV. + +NOTE: the perl_ form of this function is deprecated. + + I32 eval_sv(SV* sv, I32 flags) + +=item EXTEND + +Used to extend the argument stack for an XSUB's return values. Once +used, guarrantees that there is room for at least C to be pushed +onto the stack. + + void EXTEND(SP, int nitems) + +=item fbm_compile + +Analyses the string in order to make fast searches on it using fbm_instr() +-- the Boyer-Moore algorithm. + + void fbm_compile(SV* sv, U32 flags) + +=item fbm_instr + +Returns the location of the SV in the string delimited by C and +C. It returns C if the string can't be found. The C +does not have to be fbm_compiled, but the search will not be as fast +then. + + char* fbm_instr(unsigned char* big, unsigned char* bigend, SV* littlesv, U32 flags) + +=item FREETMPS + +Closing bracket for temporaries on a callback. See C and +L. + + FREETMPS; + +=item get_av + +Returns the AV of the specified Perl array. If C is set and the +Perl variable does not exist then it will be created. If C is not +set and the variable does not exist then NULL is returned. + +NOTE: the perl_ form of this function is deprecated. + + AV* get_av(const char* name, I32 create) + +=item get_cv + +Returns the CV of the specified Perl subroutine. If C is set and +the Perl subroutine does not exist then it will be declared (which has the +same effect as saying C). If C is not set and the +subroutine does not exist then NULL is returned. + +NOTE: the perl_ form of this function is deprecated. + + CV* get_cv(const char* name, I32 create) + +=item get_hv + +Returns the HV of the specified Perl hash. If C is set and the +Perl variable does not exist then it will be created. If C is not +set and the variable does not exist then NULL is returned. + +NOTE: the perl_ form of this function is deprecated. + + HV* get_hv(const char* name, I32 create) + +=item get_sv + +Returns the SV of the specified Perl scalar. If C is set and the +Perl variable does not exist then it will be created. If C is not +set and the variable does not exist then NULL is returned. + +NOTE: the perl_ form of this function is deprecated. + + SV* get_sv(const char* name, I32 create) + +=item GIMME + +A backward-compatible version of C which can only return +C or C; in a void context, it returns C. +Deprecated. Use C instead. + + U32 GIMME + +=item GIMME_V + +The XSUB-writer's equivalent to Perl's C. Returns C, +C or C for void, scalar or array context, +respectively. + + U32 GIMME_V + +=item GvSV + +Return the SV from the GV. + + SV* GvSV(GV* gv) + +=item gv_fetchmeth + +Returns the glob with the given C and a defined subroutine or +C. The glob lives in the given C, or in the stashes +accessible via @ISA and @UNIVERSAL. + +The argument C should be either 0 or -1. If C, as a +side-effect creates a glob with the given C in the given C +which in the case of success contains an alias for the subroutine, and sets +up caching info for this glob. Similarly for all the searched stashes. + +This function grants C<"SUPER"> token as a postfix of the stash name. The +GV returned from C may be a method cache entry, which is not +visible to Perl code. So when calling C, you should not use +the GV directly; instead, you should use the method's CV, which can be +obtained from the GV with the C macro. + + GV* gv_fetchmeth(HV* stash, const char* name, STRLEN len, I32 level) + +=item gv_fetchmethod + +See L. In fact in the presence of autoloading this may be the +glob for "AUTOLOAD". In this case the corresponding variable $AUTOLOAD is +already setup. + +The third parameter of C determines whether +AUTOLOAD lookup is performed if the given method is not present: non-zero +means yes, look for AUTOLOAD; zero means no, don't look for AUTOLOAD. +Calling C is equivalent to calling C +with a non-zero C parameter. + +These functions grant C<"SUPER"> token as a prefix of the method name. Note +that if you want to keep the returned glob for a long time, you need to +check for it being "AUTOLOAD", since at the later time the call may load a +different subroutine due to $AUTOLOAD changing its value. Use the glob +created via a side effect to do this. + +These functions have the same side-effects and as C with +C. C should be writable if contains C<':'> or C<' +''>. The warning against passing the GV returned by C to +C apply equally to these functions. + + GV* gv_fetchmethod_autoload(HV* stash, const char* name, I32 autoload) + +=item gv_stashpv + +Returns a pointer to the stash for a specified package. If C is +set then the package will be created if it does not already exist. If +C is not set and the package does not exist then NULL is +returned. + + HV* gv_stashpv(const char* name, I32 create) + +=item gv_stashsv + +Returns a pointer to the stash for a specified package. See +C. + + HV* gv_stashsv(SV* sv, I32 create) + +=item G_ARRAY + +Used to indicate array context. See C, C and +L. + +=item G_DISCARD + +Indicates that arguments returned from a callback should be discarded. See +L. + +=item G_EVAL + +Used to force a Perl C wrapper around a callback. See +L. + +=item G_NOARGS + +Indicates that no arguments are being sent to a callback. See +L. + +=item G_SCALAR + +Used to indicate scalar context. See C, C, and +L. + +=item G_VOID + +Used to indicate void context. See C and L. + +=item HEf_SVKEY + +This flag, used in the length slot of hash entries and magic structures, +specifies the structure contains a C pointer where a C pointer +is to be expected. (For information only--not to be used). + +=item HeHASH + +Returns the computed hash stored in the hash entry. + + U32 HeHASH(HE* he) + +=item HeKEY + +Returns the actual pointer stored in the key slot of the hash entry. The +pointer may be either C or C, depending on the value of +C. Can be assigned to. The C or C macros are +usually preferable for finding the value of a key. + + void* HeKEY(HE* he) + +=item HeKLEN + +If this is negative, and amounts to C, it indicates the entry +holds an C key. Otherwise, holds the actual length of the key. Can +be assigned to. The C macro is usually preferable for finding key +lengths. + + STRLEN HeKLEN(HE* he) + +=item HePV + +Returns the key slot of the hash entry as a C value, doing any +necessary dereferencing of possibly C keys. The length of the string +is placed in C (this is a macro, so do I use C<&len>). If you do +not care about what the length of the key is, you may use the global +variable C, though this is rather less efficient than using a local +variable. Remember though, that hash keys in perl are free to contain +embedded nulls, so using C or similar is not a good way to find +the length of hash keys. This is very similar to the C macro +described elsewhere in this document. + + char* HePV(HE* he, STRLEN len) + +=item HeSVKEY + +Returns the key as an C, or C if the hash entry does not +contain an C key. + + SV* HeSVKEY(HE* he) + +=item HeSVKEY_force + +Returns the key as an C. Will create and return a temporary mortal +C if the hash entry contains only a C key. + + SV* HeSVKEY_force(HE* he) + +=item HeSVKEY_set + +Sets the key to a given C, taking care to set the appropriate flags to +indicate the presence of an C key, and returns the same +C. + + SV* HeSVKEY_set(HE* he, SV* sv) + +=item HeVAL + +Returns the value slot (type C) stored in the hash entry. + + SV* HeVAL(HE* he) + +=item HvNAME + +Returns the package name of a stash. See C, C. + + char* HvNAME(HV* stash) + +=item hv_clear + +Clears a hash, making it empty. + + void hv_clear(HV* tb) + +=item hv_delete + +Deletes a key/value pair in the hash. The value SV is removed from the +hash and returned to the caller. The C is the length of the key. +The C value will normally be zero; if set to G_DISCARD then NULL +will be returned. + + SV* hv_delete(HV* tb, const char* key, U32 klen, I32 flags) + +=item hv_delete_ent + +Deletes a key/value pair in the hash. The value SV is removed from the +hash and returned to the caller. The C value will normally be zero; +if set to G_DISCARD then NULL will be returned. C can be a valid +precomputed hash value, or 0 to ask for it to be computed. + + SV* hv_delete_ent(HV* tb, SV* key, I32 flags, U32 hash) + +=item hv_exists + +Returns a boolean indicating whether the specified hash key exists. The +C is the length of the key. + + bool hv_exists(HV* tb, const char* key, U32 klen) + +=item hv_exists_ent + +Returns a boolean indicating whether the specified hash key exists. C +can be a valid precomputed hash value, or 0 to ask for it to be +computed. + + bool hv_exists_ent(HV* tb, SV* key, U32 hash) + +=item hv_fetch + +Returns the SV which corresponds to the specified key in the hash. The +C is the length of the key. If C is set then the fetch will be +part of a store. Check that the return value is non-null before +dereferencing it to a C. + +See L for more +information on how to use this function on tied hashes. + + SV** hv_fetch(HV* tb, const char* key, U32 klen, I32 lval) + +=item hv_fetch_ent + +Returns the hash entry which corresponds to the specified key in the hash. +C must be a valid precomputed hash number for the given C, or 0 +if you want the function to compute it. IF C is set then the fetch +will be part of a store. Make sure the return value is non-null before +accessing it. The return value when C is a tied hash is a pointer to a +static location, so be sure to make a copy of the structure if you need to +store it somewhere. + +See L for more +information on how to use this function on tied hashes. + + HE* hv_fetch_ent(HV* tb, SV* key, I32 lval, U32 hash) + +=item hv_iterinit + +Prepares a starting point to traverse a hash table. Returns the number of +keys in the hash (i.e. the same as C). The return value is +currently only meaningful for hashes without tie magic. + +NOTE: Before version 5.004_65, C used to return the number of +hash buckets that happen to be in use. If you still need that esoteric +value, you can get it through the macro C. + + I32 hv_iterinit(HV* tb) + +=item hv_iterkey + +Returns the key from the current position of the hash iterator. See +C. + + char* hv_iterkey(HE* entry, I32* retlen) + +=item hv_iterkeysv + +Returns the key as an C from the current position of the hash +iterator. The return value will always be a mortal copy of the key. Also +see C. + + SV* hv_iterkeysv(HE* entry) + +=item hv_iternext + +Returns entries from a hash iterator. See C. + + HE* hv_iternext(HV* tb) + +=item hv_iternextsv + +Performs an C, C, and C in one +operation. + + SV* hv_iternextsv(HV* hv, char** key, I32* retlen) + +=item hv_iterval + +Returns the value from the current position of the hash iterator. See +C. + + SV* hv_iterval(HV* tb, HE* entry) + +=item hv_magic + +Adds magic to a hash. See C. + + void hv_magic(HV* hv, GV* gv, int how) + +=item hv_store + +Stores an SV in a hash. The hash key is specified as C and C is +the length of the key. The C parameter is the precomputed hash +value; if it is zero then Perl will compute it. The return value will be +NULL if the operation failed or if the value did not need to be actually +stored within the hash (as in the case of tied hashes). Otherwise it can +be dereferenced to get the original C. Note that the caller is +responsible for suitably incrementing the reference count of C before +the call, and decrementing it if the function returned NULL. + +See L for more +information on how to use this function on tied hashes. + + SV** hv_store(HV* tb, const char* key, U32 klen, SV* val, U32 hash) + +=item hv_store_ent + +Stores C in a hash. The hash key is specified as C. The C +parameter is the precomputed hash value; if it is zero then Perl will +compute it. The return value is the new hash entry so created. It will be +NULL if the operation failed or if the value did not need to be actually +stored within the hash (as in the case of tied hashes). Otherwise the +contents of the return value can be accessed using the C macros +described here. Note that the caller is responsible for suitably +incrementing the reference count of C before the call, and +decrementing it if the function returned NULL. + +See L for more +information on how to use this function on tied hashes. + + HE* hv_store_ent(HV* tb, SV* key, SV* val, U32 hash) + +=item hv_undef + +Undefines the hash. + + void hv_undef(HV* tb) + +=item isALNUM + +Returns a boolean indicating whether the C C is an ascii alphanumeric +character or digit. + + bool isALNUM(char ch) + +=item isALPHA + +Returns a boolean indicating whether the C C is an ascii alphabetic +character. + + bool isALPHA(char ch) + +=item isDIGIT + +Returns a boolean indicating whether the C C is an ascii +digit. + + bool isDIGIT(char ch) + +=item isLOWER + +Returns a boolean indicating whether the C C is a lowercase +character. + + bool isLOWER(char ch) + +=item isSPACE + +Returns a boolean indicating whether the C C is whitespace. + + bool isSPACE(char ch) + +=item isUPPER + +Returns a boolean indicating whether the C C is an uppercase +character. + + bool isUPPER(char ch) + +=item items + +Variable which is setup by C to indicate the number of +items on the stack. See L. + + I32 items + +=item ix + +Variable which is setup by C to indicate which of an +XSUB's aliases was used to invoke it. See L. + + I32 ix + +=item LEAVE + +Closing bracket on a callback. See C and L. + + LEAVE; + +=item looks_like_number + +Test if an the content of an SV looks like a number (or is a +number). + + I32 looks_like_number(SV* sv) + +=item MARK + +Stack marker variable for the XSUB. See C. + +=item mg_clear + +Clear something magical that the SV represents. See C. + + int mg_clear(SV* sv) + +=item mg_copy + +Copies the magic from one SV to another. See C. + + int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen) + +=item mg_find + +Finds the magic pointer for type matching the SV. See C. + + MAGIC* mg_find(SV* sv, int type) + +=item mg_free + +Free any magic storage used by the SV. See C. + + int mg_free(SV* sv) + +=item mg_get + +Do magic after a value is retrieved from the SV. See C. + + int mg_get(SV* sv) + +=item mg_length + +Report on the SV's length. See C. + + U32 mg_length(SV* sv) + +=item mg_magical + +Turns on the magical status of an SV. See C. + + void mg_magical(SV* sv) + +=item mg_set + +Do magic after a value is assigned to the SV. See C. + + int mg_set(SV* sv) + +=item Move + +The XSUB-writer's interface to the C C function. The C is the +source, C is the destination, C is the number of items, and C is +the type. Can do overlapping moves. See also C. + + void Move(void* src, void* dest, int nitems, type) + +=item New + +The XSUB-writer's interface to the C C function. + + void New(int id, void* ptr, int nitems, type) + +=item newAV + +Creates a new AV. The reference count is set to 1. + + AV* newAV() + +=item Newc + +The XSUB-writer's interface to the C C function, with +cast. + + void Newc(int id, void* ptr, int nitems, type, cast) + +=item newCONSTSUB + +Creates a constant sub equivalent to Perl C which is +eligible for inlining at compile-time. + + void newCONSTSUB(HV* stash, char* name, SV* sv) + +=item newHV + +Creates a new HV. The reference count is set to 1. + + HV* newHV() + +=item newRV_inc + +Creates an RV wrapper for an SV. The reference count for the original SV is +incremented. + + SV* newRV_inc(SV* sv) + +=item newRV_noinc + +Creates an RV wrapper for an SV. The reference count for the original +SV is B incremented. + + SV* newRV_noinc(SV *sv) + +=item NEWSV + +Creates a new SV. A non-zero C parameter indicates the number of +bytes of preallocated string space the SV should have. An extra byte for a +tailing NUL is also reserved. (SvPOK is not set for the SV even if string +space is allocated.) The reference count for the new SV is set to 1. +C is an integer id between 0 and 1299 (used to identify leaks). + + SV* NEWSV(int id, STRLEN len) + +=item newSViv + +Creates a new SV and copies an integer into it. The reference count for the +SV is set to 1. + + SV* newSViv(IV i) + +=item newSVnv + +Creates a new SV and copies a floating point value into it. +The reference count for the SV is set to 1. + + SV* newSVnv(NV n) + +=item newSVpv + +Creates a new SV and copies a string into it. The reference count for the +SV is set to 1. If C is zero, Perl will compute the length using +strlen(). For efficiency, consider using C instead. + + SV* newSVpv(const char* s, STRLEN len) + +=item newSVpvf + +Creates a new SV an initialize it with the string formatted like +C. + + SV* newSVpvf(const char* pat, ...) + +=item newSVpvn + +Creates a new SV and copies a string into it. The reference count for the +SV is set to 1. Note that if C is zero, Perl will create a zero length +string. You are responsible for ensuring that the source string is at least +C bytes long. + + SV* newSVpvn(const char* s, STRLEN len) + +=item newSVrv + +Creates a new SV for the RV, C, to point to. If C is not an RV then +it will be upgraded to one. If C is non-null then the new SV will +be blessed in the specified package. The new SV is returned and its +reference count is 1. + + SV* newSVrv(SV* rv, const char* classname) + +=item newSVsv + +Creates a new SV which is an exact duplicate of the original SV. + + SV* newSVsv(SV* old) + +=item newXS + +Used by C to hook up XSUBs as Perl subs. + +=item newXSproto + +Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to +the subs. + +=item Newz + +The XSUB-writer's interface to the C C function. The allocated +memory is zeroed with C. + + void Newz(int id, void* ptr, int nitems, type) + +=item Nullav + +Null AV pointer. + +=item Nullch + +Null character pointer. + +=item Nullcv + +Null CV pointer. + +=item Nullhv + +Null HV pointer. + +=item Nullsv + +Null SV pointer. + +=item ORIGMARK + +The original stack mark for the XSUB. See C. + +=item perl_alloc + +Allocates a new Perl interpreter. See L. + + PerlInterpreter* perl_alloc() + +=item perl_construct + +Initializes a new Perl interpreter. See L. + + void perl_construct(PerlInterpreter* interp) + +=item perl_destruct + +Shuts down a Perl interpreter. See L. + + void perl_destruct(PerlInterpreter* interp) + +=item perl_free + +Releases a Perl interpreter. See L. + + void perl_free(PerlInterpreter* interp) + +=item perl_parse + +Tells a Perl interpreter to parse a Perl script. See L. + + int perl_parse(PerlInterpreter* interp, XSINIT_t xsinit, int argc, char** argv, char** env) + +=item perl_run + +Tells a Perl interpreter to run. See L. + + int perl_run(PerlInterpreter* interp) + +=item PL_DBsingle + +When Perl is run in debugging mode, with the B<-d> switch, this SV is a +boolean which indicates whether subs are being single-stepped. +Single-stepping is automatically turned on after every step. This is the C +variable which corresponds to Perl's $DB::single variable. See +C. + + SV * PL_DBsingle + +=item PL_DBsub + +When Perl is run in debugging mode, with the B<-d> switch, this GV contains +the SV which holds the name of the sub being debugged. This is the C +variable which corresponds to Perl's $DB::sub variable. See +C. + + GV * PL_DBsub + +=item PL_DBtrace + +Trace variable used when Perl is run in debugging mode, with the B<-d> +switch. This is the C variable which corresponds to Perl's $DB::trace +variable. See C. + + SV * PL_DBtrace + +=item PL_dowarn + +The C variable which corresponds to Perl's $^W warning variable. + + bool PL_dowarn + +=item PL_modglobal + +C is a general purpose, interpreter global HV for use by +extensions that need to keep information on a per-interpreter basis. +In a pinch, it can also be used as a symbol table for extensions +to share data among each other. It is a good idea to use keys +prefixed by the package name of the extension that owns the data. + + HV* PL_modglobal + +=item PL_na + +A convenience variable which is typically used with C when one +doesn't care about the length of the string. It is usually more efficient +to either declare a local variable and use that instead or to use the +C macro. + + STRLEN PL_na + +=item PL_sv_no + +This is the C SV. See C. Always refer to this as +C<&PL_sv_no>. + + SV PL_sv_no + +=item PL_sv_undef + +This is the C SV. Always refer to this as C<&PL_sv_undef>. + + SV PL_sv_undef + +=item PL_sv_yes + +This is the C SV. See C. Always refer to this as +C<&PL_sv_yes>. + + SV PL_sv_yes + +=item POPi + +Pops an integer off the stack. + + IV POPi + +=item POPl + +Pops a long off the stack. + + long POPl + +=item POPn + +Pops a double off the stack. + + NV POPn + +=item POPp + +Pops a string off the stack. + + char* POPp + +=item POPs + +Pops an SV off the stack. + + SV* POPs + +=item PUSHi + +Push an integer onto the stack. The stack must have room for this element. +Handles 'set' magic. See C. + + void PUSHi(IV iv) + +=item PUSHMARK + +Opening bracket for arguments on a callback. See C and +L. + + PUSHMARK; + +=item PUSHn + +Push a double onto the stack. The stack must have room for this element. +Handles 'set' magic. See C. + + void PUSHn(NV nv) + +=item PUSHp + +Push a string onto the stack. The stack must have room for this element. +The C indicates the length of the string. Handles 'set' magic. See +C. + + void PUSHp(char* str, STRLEN len) + +=item PUSHs + +Push an SV onto the stack. The stack must have room for this element. +Does not handle 'set' magic. See C. + + void PUSHs(SV* sv) + +=item PUSHu + +Push an unsigned integer onto the stack. The stack must have room for this +element. See C. + + void PUSHu(UV uv) + +=item PUTBACK + +Closing bracket for XSUB arguments. This is usually handled by C. +See C and L for other uses. + + PUTBACK; + +=item Renew + +The XSUB-writer's interface to the C C function. + + void Renew(void* ptr, int nitems, type) + +=item Renewc + +The XSUB-writer's interface to the C C function, with +cast. + + void Renewc(void* ptr, int nitems, type, cast) + +=item require_pv + +Tells Perl to C a module. + +NOTE: the perl_ form of this function is deprecated. + + void require_pv(const char* pv) + +=item RETVAL + +Variable which is setup by C to hold the return value for an +XSUB. This is always the proper type for the XSUB. See +L. + + (whatever) RETVAL + +=item Safefree + +The XSUB-writer's interface to the C C function. + + void Safefree(void* src, void* dest, int nitems, type) + +=item savepv + +Copy a string to a safe spot. This does not use an SV. + + char* savepv(const char* sv) + +=item savepvn + +Copy a string to a safe spot. The C indicates number of bytes to +copy. This does not use an SV. + + char* savepvn(const char* sv, I32 len) + +=item SAVETMPS + +Opening bracket for temporaries on a callback. See C and +L. + + SAVETMPS; + +=item SP + +Stack pointer. This is usually handled by C. See C and +C. + +=item SPAGAIN + +Refetch the stack pointer. Used after a callback. See L. + + SPAGAIN; + +=item ST + +Used to access elements on the XSUB's stack. + + SV* ST(int ix) + +=item strEQ + +Test two strings to see if they are equal. Returns true or false. + + bool strEQ(char* s1, char* s2) + +=item strGE + +Test two strings to see if the first, C, is greater than or equal to +the second, C. Returns true or false. + + bool strGE(char* s1, char* s2) + +=item strGT + +Test two strings to see if the first, C, is greater than the second, +C. Returns true or false. + + bool strGT(char* s1, char* s2) + +=item strLE + +Test two strings to see if the first, C, is less than or equal to the +second, C. Returns true or false. + + bool strLE(char* s1, char* s2) + +=item strLT + +Test two strings to see if the first, C, is less than the second, +C. Returns true or false. + + bool strLT(char* s1, char* s2) + +=item strNE + +Test two strings to see if they are different. Returns true or +false. + + bool strNE(char* s1, char* s2) + +=item strnEQ + +Test two strings to see if they are equal. The C parameter indicates +the number of bytes to compare. Returns true or false. (A wrapper for +C). + + bool strnEQ(char* s1, char* s2, STRLEN len) + +=item strnNE + +Test two strings to see if they are different. The C parameter +indicates the number of bytes to compare. Returns true or false. (A +wrapper for C). + + bool strnNE(char* s1, char* s2, STRLEN len) + +=item StructCopy + +This is an architecture-independant macro to copy one structure to another. + + void StructCopy(type src, type dest, type) + +=item SvCUR + +Returns the length of the string which is in the SV. See C. + + STRLEN SvCUR(SV* sv) + +=item SvCUR_set + +Set the length of the string which is in the SV. See C. + + void SvCUR_set(SV* sv, STRLEN len) + +=item SvEND + +Returns a pointer to the last character in the string which is in the SV. +See C. Access the character as *(SvEND(sv)). + + char* SvEND(SV* sv) + +=item SvGETMAGIC + +Invokes C on an SV if it has 'get' magic. This macro evaluates its +argument more than once. + + void SvGETMAGIC(SV* sv) + +=item SvGROW + +Expands the character buffer in the SV so that it has room for the +indicated number of bytes (remember to reserve space for an extra trailing +NUL character). Calls C to perform the expansion if necessary. +Returns a pointer to the character buffer. + + void SvGROW(SV* sv, STRLEN len) + +=item SvIOK + +Returns a boolean indicating whether the SV contains an integer. + + bool SvIOK(SV* sv) + +=item SvIOKp + +Returns a boolean indicating whether the SV contains an integer. Checks +the B setting. Use C. + + bool SvIOKp(SV* sv) + +=item SvIOK_off + +Unsets the IV status of an SV. + + void SvIOK_off(SV* sv) + +=item SvIOK_on + +Tells an SV that it is an integer. + + void SvIOK_on(SV* sv) + +=item SvIOK_only + +Tells an SV that it is an integer and disables all other OK bits. + + void SvIOK_only(SV* sv) + +=item SvIV + +Coerces the given SV to an integer and returns it. + + IV SvIV(SV* sv) + +=item SvIVX + +Returns the integer which is stored in the SV, assuming SvIOK is +true. + + IV SvIVX(SV* sv) + +=item SvLEN + +Returns the size of the string buffer in the SV. See C. + + STRLEN SvLEN(SV* sv) + +=item SvNIOK + +Returns a boolean indicating whether the SV contains a number, integer or +double. + + bool SvNIOK(SV* sv) + +=item SvNIOKp + +Returns a boolean indicating whether the SV contains a number, integer or +double. Checks the B setting. Use C. + + bool SvNIOKp(SV* sv) + +=item SvNIOK_off + +Unsets the NV/IV status of an SV. + + void SvNIOK_off(SV* sv) + +=item SvNOK + +Returns a boolean indicating whether the SV contains a double. + + bool SvNOK(SV* sv) + +=item SvNOKp + +Returns a boolean indicating whether the SV contains a double. Checks the +B setting. Use C. + + bool SvNOKp(SV* sv) + +=item SvNOK_off + +Unsets the NV status of an SV. + + void SvNOK_off(SV* sv) + +=item SvNOK_on + +Tells an SV that it is a double. + + void SvNOK_on(SV* sv) + +=item SvNOK_only + +Tells an SV that it is a double and disables all other OK bits. + + void SvNOK_only(SV* sv) + +=item SvNV + +Coerce the given SV to a double and return it. + + NV SvNV(SV* sv) + +=item SvNVX + +Returns the double which is stored in the SV, assuming SvNOK is +true. + + NV SvNVX(SV* sv) + +=item SvOK + +Returns a boolean indicating whether the value is an SV. + + bool SvOK(SV* sv) + +=item SvOOK + +Returns a boolean indicating whether the SvIVX is a valid offset value for +the SvPVX. This hack is used internally to speed up removal of characters +from the beginning of a SvPV. When SvOOK is true, then the start of the +allocated string buffer is really (SvPVX - SvIVX). + + bool SvOOK(SV* sv) + +=item SvPOK + +Returns a boolean indicating whether the SV contains a character +string. + + bool SvPOK(SV* sv) + +=item SvPOKp + +Returns a boolean indicating whether the SV contains a character string. +Checks the B setting. Use C. + + bool SvPOKp(SV* sv) + +=item SvPOK_off + +Unsets the PV status of an SV. + + void SvPOK_off(SV* sv) + +=item SvPOK_on + +Tells an SV that it is a string. + + void SvPOK_on(SV* sv) + +=item SvPOK_only + +Tells an SV that it is a string and disables all other OK bits. + + void SvPOK_only(SV* sv) + +=item SvPV + +Returns a pointer to the string in the SV, or a stringified form of the SV +if the SV does not contain a string. Handles 'get' magic. + + char* SvPV(SV* sv, STRLEN len) + +=item SvPVX + +Returns a pointer to the string in the SV. The SV must contain a +string. + + char* SvPVX(SV* sv) + +=item SvPV_force + +Like but will force the SV into becoming a string (SvPOK). You want +force if you are going to update the SvPVX directly. + + char* SvPV_force(SV* sv, STRLEN len) + +=item SvPV_nolen + +Returns a pointer to the string in the SV, or a stringified form of the SV +if the SV does not contain a string. Handles 'get' magic. + + char* SvPV_nolen(SV* sv) + +=item SvREFCNT + +Returns the value of the object's reference count. + + U32 SvREFCNT(SV* sv) + +=item SvREFCNT_dec + +Decrements the reference count of the given SV. + + void SvREFCNT_dec(SV* sv) + +=item SvREFCNT_inc + +Increments the reference count of the given SV. + + SV* SvREFCNT_inc(SV* sv) + +=item SvROK + +Tests if the SV is an RV. + + bool SvROK(SV* sv) + +=item SvROK_off + +Unsets the RV status of an SV. + + void SvROK_off(SV* sv) + +=item SvROK_on + +Tells an SV that it is an RV. + + void SvROK_on(SV* sv) + +=item SvRV + +Dereferences an RV to return the SV. + + SV* SvRV(SV* sv) + +=item SvSETMAGIC + +Invokes C on an SV if it has 'set' magic. This macro evaluates its +argument more than once. + + void SvSETMAGIC(SV* sv) + +=item SvSetSV + +Calls C if dsv is not the same as ssv. May evaluate arguments +more than once. + + void SvSetSV(SV* dsb, SV* ssv) + +=item SvSetSV_nosteal + +Calls a non-destructive version of C if dsv is not the same as +ssv. May evaluate arguments more than once. + + void SvSetSV_nosteal(SV* dsv, SV* ssv) + +=item SvSTASH + +Returns the stash of the SV. + + HV* SvSTASH(SV* sv) + +=item SvTAINT + +Taints an SV if tainting is enabled + + void SvTAINT(SV* sv) + +=item SvTAINTED + +Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if +not. + + bool SvTAINTED(SV* sv) + +=item SvTAINTED_off + +Untaints an SV. Be I careful with this routine, as it short-circuits +some of Perl's fundamental security features. XS module authors should not +use this function unless they fully understand all the implications of +unconditionally untainting the value. Untainting should be done in the +standard perl fashion, via a carefully crafted regexp, rather than directly +untainting variables. + + void SvTAINTED_off(SV* sv) + +=item SvTAINTED_on + +Marks an SV as tainted. + + void SvTAINTED_on(SV* sv) + +=item SvTRUE + +Returns a boolean indicating whether Perl would evaluate the SV as true or +false, defined or undefined. Does not handle 'get' magic. + + bool SvTRUE(SV* sv) + +=item SvTYPE + +Returns the type of the SV. See C. + + svtype SvTYPE(SV* sv) + +=item svtype + +An enum of flags for Perl types. These are found in the file B +in the C enum. Test these flags with the C macro. + +=item SVt_IV + +Integer type flag for scalars. See C. + +=item SVt_NV + +Double type flag for scalars. See C. + +=item SVt_PV + +Pointer type flag for scalars. See C. + +=item SVt_PVAV + +Type flag for arrays. See C. + +=item SVt_PVCV + +Type flag for code refs. See C. + +=item SVt_PVHV + +Type flag for hashes. See C. + +=item SVt_PVMG + +Type flag for blessed scalars. See C. + +=item SvUPGRADE + +Used to upgrade an SV to a more complex form. Uses C to +perform the upgrade if necessary. See C. + + void SvUPGRADE(SV* sv, svtype type) + +=item SvUV + +Coerces the given SV to an unsigned integer and returns it. + + UV SvUV(SV* sv) + +=item SvUVX + +Returns the unsigned integer which is stored in the SV, assuming SvIOK is +true. + + UV SvUVX(SV* sv) + +=item sv_2mortal + +Marks an SV as mortal. The SV will be destroyed when the current context +ends. + + SV* sv_2mortal(SV* sv) + +=item sv_bless + +Blesses an SV into a specified package. The SV must be an RV. The package +must be designated by its stash (see C). The reference count +of the SV is unaffected. + + SV* sv_bless(SV* sv, HV* stash) + +=item sv_catpv + +Concatenates the string onto the end of the string which is in the SV. +Handles 'get' magic, but not 'set' magic. See C. + + void sv_catpv(SV* sv, const char* ptr) + +=item sv_catpvf + +Processes its arguments like C and appends the formatted output +to an SV. Handles 'get' magic, but not 'set' magic. C must +typically be called after calling this function to handle 'set' magic. + + void sv_catpvf(SV* sv, const char* pat, ...) + +=item sv_catpvf_mg + +Like C, but also handles 'set' magic. + + void sv_catpvf_mg(SV *sv, const char* pat, ...) + +=item sv_catpvn + +Concatenates the string onto the end of the string which is in the SV. The +C indicates number of bytes to copy. Handles 'get' magic, but not +'set' magic. See C. + + void sv_catpvn(SV* sv, const char* ptr, STRLEN len) + +=item sv_catpvn_mg + +Like C, but also handles 'set' magic. + + void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len) + +=item sv_catpv_mg + +Like C, but also handles 'set' magic. + + void sv_catpv_mg(SV *sv, const char *ptr) + +=item sv_catsv + +Concatenates the string from SV C onto the end of the string in SV +C. Handles 'get' magic, but not 'set' magic. See C. + + void sv_catsv(SV* dsv, SV* ssv) + +=item sv_catsv_mg + +Like C, but also handles 'set' magic. + + void sv_catsv_mg(SV *dstr, SV *sstr) + +=item sv_chop + +Efficient removal of characters from the beginning of the string buffer. +SvPOK(sv) must be true and the C must be a pointer to somewhere inside +the string buffer. The C becomes the first character of the adjusted +string. + + void sv_chop(SV* sv, char* ptr) + +=item sv_cmp + +Compares the strings in two SVs. Returns -1, 0, or 1 indicating whether the +string in C is less than, equal to, or greater than the string in +C. + + I32 sv_cmp(SV* sv1, SV* sv2) + +=item sv_dec + +Auto-decrement of the value in the SV. + + void sv_dec(SV* sv) + +=item sv_derived_from + +Returns a boolean indicating whether the SV is derived from the specified +class. This is the function that implements C. It works +for class names as well as for objects. + + bool sv_derived_from(SV* sv, const char* name) + +=item sv_eq + +Returns a boolean indicating whether the strings in the two SVs are +identical. + + I32 sv_eq(SV* sv1, SV* sv2) + +=item sv_grow + +Expands the character buffer in the SV. This will use C and will +upgrade the SV to C. Returns a pointer to the character buffer. +Use C. + + char* sv_grow(SV* sv, STRLEN newlen) + +=item sv_inc + +Auto-increment of the value in the SV. + + void sv_inc(SV* sv) + +=item sv_insert + +Inserts a string at the specified offset/length within the SV. Similar to +the Perl substr() function. + + void sv_insert(SV* bigsv, STRLEN offset, STRLEN len, char* little, STRLEN littlelen) + +=item sv_isa + +Returns a boolean indicating whether the SV is blessed into the specified +class. This does not check for subtypes; use C to verify +an inheritance relationship. + + int sv_isa(SV* sv, const char* name) + +=item sv_isobject + +Returns a boolean indicating whether the SV is an RV pointing to a blessed +object. If the SV is not an RV, or if the object is not blessed, then this +will return false. + + int sv_isobject(SV* sv) + +=item sv_len + +Returns the length of the string in the SV. See also C. + + STRLEN sv_len(SV* sv) + +=item sv_magic + +Adds magic to an SV. + + void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen) + +=item sv_mortalcopy + +Creates a new SV which is a copy of the original SV. The new SV is marked +as mortal. + + SV* sv_mortalcopy(SV* oldsv) + +=item sv_newmortal + +Creates a new SV which is mortal. The reference count of the SV is set to 1. + + SV* sv_newmortal() + +=item sv_setiv + +Copies an integer into the given SV. Does not handle 'set' magic. See +C. + + void sv_setiv(SV* sv, IV num) + +=item sv_setiv_mg + +Like C, but also handles 'set' magic. + + void sv_setiv_mg(SV *sv, IV i) + +=item sv_setnv + +Copies a double into the given SV. Does not handle 'set' magic. See +C. + + void sv_setnv(SV* sv, NV num) + +=item sv_setnv_mg + +Like C, but also handles 'set' magic. + + void sv_setnv_mg(SV *sv, NV num) + +=item sv_setpv + +Copies a string into an SV. The string must be null-terminated. Does not +handle 'set' magic. See C. + + void sv_setpv(SV* sv, const char* ptr) + +=item sv_setpvf + +Processes its arguments like C and sets an SV to the formatted +output. Does not handle 'set' magic. See C. + + void sv_setpvf(SV* sv, const char* pat, ...) + +=item sv_setpvf_mg + +Like C, but also handles 'set' magic. + + void sv_setpvf_mg(SV *sv, const char* pat, ...) + +=item sv_setpviv + +Copies an integer into the given SV, also updating its string value. +Does not handle 'set' magic. See C. + + void sv_setpviv(SV* sv, IV num) + +=item sv_setpviv_mg + +Like C, but also handles 'set' magic. + + void sv_setpviv_mg(SV *sv, IV iv) + +=item sv_setpvn + +Copies a string into an SV. The C parameter indicates the number of +bytes to be copied. Does not handle 'set' magic. See C. + + void sv_setpvn(SV* sv, const char* ptr, STRLEN len) + +=item sv_setpvn_mg + +Like C, but also handles 'set' magic. + + void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len) + +=item sv_setpv_mg + +Like C, but also handles 'set' magic. + + void sv_setpv_mg(SV *sv, const char *ptr) + +=item sv_setref_iv + +Copies an integer into a new SV, optionally blessing the SV. The C +argument will be upgraded to an RV. That RV will be modified to point to +the new SV. The C argument indicates the package for the +blessing. Set C to C to avoid the blessing. The new SV +will be returned and will have a reference count of 1. + + SV* sv_setref_iv(SV* rv, const char* classname, IV iv) + +=item sv_setref_nv + +Copies a double into a new SV, optionally blessing the SV. The C +argument will be upgraded to an RV. That RV will be modified to point to +the new SV. The C argument indicates the package for the +blessing. Set C to C to avoid the blessing. The new SV +will be returned and will have a reference count of 1. + + SV* sv_setref_nv(SV* rv, const char* classname, NV nv) + +=item sv_setref_pv + +Copies a pointer into a new SV, optionally blessing the SV. The C +argument will be upgraded to an RV. That RV will be modified to point to +the new SV. If the C argument is NULL then C will be placed +into the SV. The C argument indicates the package for the +blessing. Set C to C to avoid the blessing. The new SV +will be returned and will have a reference count of 1. + +Do not use with other Perl types such as HV, AV, SV, CV, because those +objects will become corrupted by the pointer copy process. + +Note that C copies the string while this copies the pointer. + + SV* sv_setref_pv(SV* rv, const char* classname, void* pv) + +=item sv_setref_pvn + +Copies a string into a new SV, optionally blessing the SV. The length of the +string must be specified with C. The C argument will be upgraded to +an RV. That RV will be modified to point to the new SV. The C +argument indicates the package for the blessing. Set C to +C to avoid the blessing. The new SV will be returned and will have +a reference count of 1. + +Note that C copies the pointer while this copies the string. + + SV* sv_setref_pvn(SV* rv, const char* classname, char* pv, STRLEN n) + +=item sv_setsv + +Copies the contents of the source SV C into the destination SV C. +The source SV may be destroyed if it is mortal. Does not handle 'set' +magic. See the macro forms C, C and +C. + + void sv_setsv(SV* dsv, SV* ssv) + +=item sv_setsv_mg + +Like C, but also handles 'set' magic. + + void sv_setsv_mg(SV *dstr, SV *sstr) + +=item sv_setuv + +Copies an unsigned integer into the given SV. Does not handle 'set' magic. +See C. + + void sv_setuv(SV* sv, UV num) + +=item sv_setuv_mg + +Like C, but also handles 'set' magic. + + void sv_setuv_mg(SV *sv, UV u) + +=item sv_unref + +Unsets the RV status of the SV, and decrements the reference count of +whatever was being referenced by the RV. This can almost be thought of +as a reversal of C. See C. + + void sv_unref(SV* sv) + +=item sv_upgrade + +Upgrade an SV to a more complex form. Use C. See +C. + + bool sv_upgrade(SV* sv, U32 mt) + +=item sv_usepvn + +Tells an SV to use C to find its string value. Normally the string is +stored inside the SV but sv_usepvn allows the SV to use an outside string. +The C should point to memory that was allocated by C. The +string length, C, must be supplied. This function will realloc the +memory pointed to by C, so that pointer should not be freed or used by +the programmer after giving it to sv_usepvn. Does not handle 'set' magic. +See C. + + void sv_usepvn(SV* sv, char* ptr, STRLEN len) + +=item sv_usepvn_mg + +Like C, but also handles 'set' magic. + + void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len) + +=item sv_vcatpvfn + +Processes its arguments like C and appends the formatted output +to an SV. Uses an array of SVs if the C style variable argument list is +missing (NULL). When running with taint checks enabled, indicates via +C if results are untrustworthy (often due to the use of +locales). + + void sv_vcatpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted) + +=item sv_vsetpvfn + +Works like C but copies the text into the SV instead of +appending it. + + void sv_vsetpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted) + +=item THIS + +Variable which is setup by C to designate the object in a C++ +XSUB. This is always the proper type for the C++ object. See C and +L. + + (whatever) THIS + +=item toLOWER + +Converts the specified character to lowercase. + + char toLOWER(char ch) + +=item toUPPER + +Converts the specified character to uppercase. + + char toUPPER(char ch) + +=item warn + +This is the XSUB-writer's interface to Perl's C function. Use this +function the same way you use the C C function. See +C. + + void warn(const char* pat, ...) + +=item XPUSHi + +Push an integer onto the stack, extending the stack if necessary. Handles +'set' magic. See C. + + void XPUSHi(IV iv) + +=item XPUSHn + +Push a double onto the stack, extending the stack if necessary. Handles +'set' magic. See C. + + void XPUSHn(NV nv) + +=item XPUSHp + +Push a string onto the stack, extending the stack if necessary. The C +indicates the length of the string. Handles 'set' magic. See +C. + + void XPUSHp(char* str, STRLEN len) + +=item XPUSHs + +Push an SV onto the stack, extending the stack if necessary. Does not +handle 'set' magic. See C. + + void XPUSHs(SV* sv) + +=item XPUSHu + +Push an unsigned integer onto the stack, extending the stack if necessary. +See C. + + void XPUSHu(UV uv) + +=item XS + +Macro to declare an XSUB and its C parameter list. This is handled by +C. + +=item XSRETURN + +Return from XSUB, indicating number of items on the stack. This is usually +handled by C. + + void XSRETURN(int nitems) + +=item XSRETURN_EMPTY + +Return an empty list from an XSUB immediately. + + XSRETURN_EMPTY; + +=item XSRETURN_IV + +Return an integer from an XSUB immediately. Uses C. + + void XSRETURN_IV(IV iv) + +=item XSRETURN_NO + +Return C<&PL_sv_no> from an XSUB immediately. Uses C. + + XSRETURN_NO; + +=item XSRETURN_NV + +Return an double from an XSUB immediately. Uses C. + + void XSRETURN_NV(NV nv) + +=item XSRETURN_PV + +Return a copy of a string from an XSUB immediately. Uses C. + + void XSRETURN_PV(char* str) + +=item XSRETURN_UNDEF + +Return C<&PL_sv_undef> from an XSUB immediately. Uses C. + + XSRETURN_UNDEF; + +=item XSRETURN_YES + +Return C<&PL_sv_yes> from an XSUB immediately. Uses C. + + XSRETURN_YES; + +=item XST_mIV + +Place an integer into the specified position C on the stack. The +value is stored in a new mortal SV. + + void XST_mIV(int pos, IV iv) + +=item XST_mNO + +Place C<&PL_sv_no> into the specified position C on the +stack. + + void XST_mNO(int pos) + +=item XST_mNV + +Place a double into the specified position C on the stack. The value +is stored in a new mortal SV. + + void XST_mNV(int pos, NV nv) + +=item XST_mPV + +Place a copy of a string into the specified position C on the stack. +The value is stored in a new mortal SV. + + void XST_mPV(int pos, char* str) + +=item XST_mUNDEF + +Place C<&PL_sv_undef> into the specified position C on the +stack. + + void XST_mUNDEF(int pos) + +=item XST_mYES + +Place C<&PL_sv_yes> into the specified position C on the +stack. + + void XST_mYES(int pos) + +=item XS_VERSION + +The version identifier for an XS module. This is usually +handled automatically by C. See C. + +=item XS_VERSION_BOOTCHECK + +Macro to verify that a PM module's $VERSION variable matches the XS +module's C variable. This is usually handled automatically by +C. See L. + + XS_VERSION_BOOTCHECK; + +=item Zero + +The XSUB-writer's interface to the C C function. The C is the +destination, C is the number of items, and C is the type. + + void Zero(void* dest, int nitems, type) + +=back + +=head1 AUTHORS + +Until May 1997, this document was maintained by Jeff Okamoto +. It is now maintained as part of Perl itself. + +With lots of help and suggestions from Dean Roehrich, Malcolm Beattie, +Andreas Koenig, Paul Hudson, Ilya Zakharevich, Paul Marquess, Neil +Bowers, Matthew Green, Tim Bunce, Spider Boardman, Ulrich Pfeifer, +Stephen McCamant, and Gurusamy Sarathy. + +API Listing originally by Dean Roehrich . + +Updated to be autogenerated from comments in the source by Benjamin Stuhl. + +=head1 SEE ALSO + +perlguts(1), perlxs(1), perlxstut(1), perlintern(1) + diff --git a/pod/perldelta.pod b/pod/perldelta.pod index f61ee69..1339b04 100644 --- a/pod/perldelta.pod +++ b/pod/perldelta.pod @@ -1523,6 +1523,10 @@ change#4232 =over 4 +=item perlapi.pod + +The official list of public Perl API functions. + =item perlcompile.pod An introduction to using the Perl Compiler suite. @@ -1535,6 +1539,11 @@ An introduction to writing Perl source filters. Some guidelines for hacking the Perl source code. +=item perlintern.pod + +A list of internal functions in the Perl source code. +(List is currently empty.) + =item perlopentut.pod A tutorial on using open() effectively. diff --git a/pod/perlguts.pod b/pod/perlguts.pod index a8d820e..eec6edc 100644 --- a/pod/perlguts.pod +++ b/pod/perlguts.pod @@ -1,12 +1,13 @@ =head1 NAME -perlguts - Perl's Internal Functions +perlguts - Introduction to the Perl API =head1 DESCRIPTION -This document attempts to describe some of the internal functions of the -Perl executable. It is far from complete and probably contains many errors. -Please refer any questions or comments to the author below. +This document attempts to describe how to use the Perl API, as well as containing +some info on the basic workings of the Perl core. It is far from complete +and probably contains many errors. Please refer any questions or +comments to the author below. =head1 Variables @@ -22,11 +23,13 @@ Each typedef has specific routines that manipulate the various data types. =head2 What is an "IV"? -Perl uses a special typedef IV which is a simple integer type that is +Perl uses a special typedef IV which is a simple signed integer type that is guaranteed to be large enough to hold a pointer (as well as an integer). +Additionally, there is the UV, which is simply an unsigned IV. Perl also uses two special typedefs, I32 and I16, which will always be at -least 32-bits and 16-bits long, respectively. +least 32-bits and 16-bits long, respectively. (Again, there are U32 and U16, +as well.) =head2 Working with SVs @@ -87,11 +90,12 @@ in an SV to a C function or system call. To access the actual value that an SV points to, you can use the macros: SvIV(SV*) + SvUV(SV*) SvNV(SV*) SvPV(SV*, STRLEN len) SvPV_nolen(SV*) -which will automatically coerce the actual scalar type into an IV, double, +which will automatically coerce the actual scalar type into an IV, UV, double, or string. In the C macro, the length of the string returned is placed into the @@ -817,6 +821,8 @@ to an C of '\0') contains: Thus, when an SV is determined to be magical and of type '\0', if a get operation is being performed, the routine C is called. All the various routines for the various magical types begin with C. +NOTE: the magic routines are not considered part of the Perl API, and may +not be exported by the Perl library. The current kinds of Magic Virtual Tables are: @@ -1218,12 +1224,12 @@ For more information, consult L and L. There are four routines that can be used to call a Perl subroutine from within a C program. These four are: - I32 perl_call_sv(SV*, I32); - I32 perl_call_pv(const char*, I32); - I32 perl_call_method(const char*, I32); - I32 perl_call_argv(const char*, I32, register char**); + I32 call_sv(SV*, I32); + I32 call_pv(const char*, I32); + I32 call_method(const char*, I32); + I32 call_argv(const char*, I32, register char**); -The routine most often used is C. The C argument +The routine most often used is C. The C argument contains either the name of the Perl subroutine to be called, or a reference to the subroutine. The second argument consists of flags that control the context in which the subroutine is called, whether @@ -1233,7 +1239,11 @@ trapped, and how to treat return values. All four routines return the number of arguments that the subroutine returned on the Perl stack. -When using any of these routines (except C), the programmer +These routines used to be called C etc., before Perl v5.6.0, +but those names are now deprecated; macros of the same name are provided for +compatibility. + +When using any of these routines (except C), the programmer must manipulate the Perl stack. These include the following macros and functions: @@ -1512,7 +1522,7 @@ additional complications for conditionals). These optimizations are done in the subroutine peep(). Optimizations performed at this stage are subject to the same restrictions as in the pass 2. -=head1 The Perl Internal API +=head1 How multiple interpreters and concurrency are supported WARNING: This information is subject to radical changes prior to the Perl 5.6 release. Use with caution. @@ -1545,13 +1555,20 @@ the Perl source (as it does in so many other situations) makes heavy use of macros and subroutine naming conventions. First problem: deciding which functions will be public API functions and -which will be private. Those functions whose names begin C are -public, and those whose names begin C are private (think "S" for -"secret" or "static"). - -Some functions have no prefix (e.g., restore_rsfp in toke.c). These -are not parts of the object or pseudo-structure because you need to -pass pointers to them to other subroutines. +which will be private. All functions whose names begin C are private +(think "S" for "secret" or "static"). All other functions begin with +"Perl_", but just because a function begins with "Perl_" does not mean it is +part of the API. The easiest way to be B a function is part of the API +is to find its entry in L. If it exists in L, it's part +of the API. If it doesn't, and you think it should be (i.e., you need it fo +r your extension), send mail via L explaining why you think it +should be. + +(L itself is generated by embed.pl, a Perl script that generates +significant portions of the Perl source code. It has a list of almost +all the functions defined by the Perl interpreter along with their calling +characteristics and some flags. Functions that are part of the public API +are marked with an 'A' in its flags.) Second problem: there must be a syntax so that the same subroutine declarations and calls can pass a structure as their first argument, @@ -1766,2111 +1783,22 @@ The Perl engine/interpreter and the host are orthogonal entities. There could be one or more interpreters in a process, and one or more "hosts", with free association between them. -=head1 API LISTING - -This is a listing of functions, macros, flags, and variables that may be -used by extension writers. The interfaces of any functions that are not -listed here are subject to change without notice. For this reason, -blindly using functions listed in proto.h is to be avoided when writing -extensions. - -Note that all Perl API global variables must be referenced with the C -prefix. Some macros are provided for compatibility with the older, -unadorned names, but this support may be disabled in a future release. - -The sort order of the listing is case insensitive, with any -occurrences of '_' ignored for the purpose of sorting. - -=over 8 - -=item av_clear - -Clears an array, making it empty. Does not free the memory used by the -array itself. - - void av_clear (AV* ar) - -=item av_extend - -Pre-extend an array. The C is the index to which the array should be -extended. - - void av_extend (AV* ar, I32 key) - -=item av_fetch - -Returns the SV at the specified index in the array. The C is the -index. If C is set then the fetch will be part of a store. Check -that the return value is non-null before dereferencing it to a C. - -See L for more -information on how to use this function on tied arrays. - - SV** av_fetch (AV* ar, I32 key, I32 lval) - -=item AvFILL - -Same as C. Deprecated, use C instead. - -=item av_len - -Returns the highest index in the array. Returns -1 if the array is empty. - - I32 av_len (AV* ar) - -=item av_make - -Creates a new AV and populates it with a list of SVs. The SVs are copied -into the array, so they may be freed after the call to av_make. The new AV -will have a reference count of 1. - - AV* av_make (I32 size, SV** svp) - -=item av_pop - -Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array is -empty. - - SV* av_pop (AV* ar) - -=item av_push - -Pushes an SV onto the end of the array. The array will grow automatically -to accommodate the addition. - - void av_push (AV* ar, SV* val) - -=item av_shift - -Shifts an SV off the beginning of the array. - - SV* av_shift (AV* ar) - -=item av_store - -Stores an SV in an array. The array index is specified as C. The -return value will be NULL if the operation failed or if the value did not -need to be actually stored within the array (as in the case of tied arrays). -Otherwise it can be dereferenced to get the original C. Note that the -caller is responsible for suitably incrementing the reference count of C -before the call, and decrementing it if the function returned NULL. - -See L for more -information on how to use this function on tied arrays. - - SV** av_store (AV* ar, I32 key, SV* val) - -=item av_undef - -Undefines the array. Frees the memory used by the array itself. - - void av_undef (AV* ar) - -=item av_unshift - -Unshift the given number of C values onto the beginning of the -array. The array will grow automatically to accommodate the addition. -You must then use C to assign values to these new elements. - - void av_unshift (AV* ar, I32 num) - -=item CLASS - -Variable which is setup by C to indicate the class name for a C++ XS -constructor. This is always a C. See C and -L. - -=item Copy - -The XSUB-writer's interface to the C C function. The C is the -source, C is the destination, C is the number of items, and C is -the type. May fail on overlapping copies. See also C. - - void Copy( s, d, n, t ) - -=item croak - -This is the XSUB-writer's interface to Perl's C function. Use this -function the same way you use the C C function. See C. - -=item CvSTASH - -Returns the stash of the CV. - - HV* CvSTASH( SV* sv ) - -=item PL_DBsingle - -When Perl is run in debugging mode, with the B<-d> switch, this SV is a -boolean which indicates whether subs are being single-stepped. -Single-stepping is automatically turned on after every step. This is the C -variable which corresponds to Perl's $DB::single variable. See C. - -=item PL_DBsub - -When Perl is run in debugging mode, with the B<-d> switch, this GV contains -the SV which holds the name of the sub being debugged. This is the C -variable which corresponds to Perl's $DB::sub variable. See C. -The sub name can be found by - - SvPV( GvSV( PL_DBsub ), len ) - -=item PL_DBtrace - -Trace variable used when Perl is run in debugging mode, with the B<-d> -switch. This is the C variable which corresponds to Perl's $DB::trace -variable. See C. - -=item dMARK - -Declare a stack marker variable, C, for the XSUB. See C and -C. - -=item dORIGMARK - -Saves the original stack mark for the XSUB. See C. - -=item PL_dowarn - -The C variable which corresponds to Perl's $^W warning variable. - -=item dSP - -Declares a local copy of perl's stack pointer for the XSUB, available via -the C macro. See C. - -=item dXSARGS - -Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. This is -usually handled automatically by C. Declares the C variable -to indicate the number of items on the stack. - -=item dXSI32 - -Sets up the C variable for an XSUB which has aliases. This is usually -handled automatically by C. - -=item do_binmode - -Switches filehandle to binmode. C is what C would -contain. - - do_binmode(fp, iotype, TRUE); - -=item ENTER - -Opening bracket on a callback. See C and L. - - ENTER; - -=item EXTEND - -Used to extend the argument stack for an XSUB's return values. - - EXTEND( sp, int x ) - -=item fbm_compile - -Analyses the string in order to make fast searches on it using fbm_instr() -- -the Boyer-Moore algorithm. - - void fbm_compile(SV* sv, U32 flags) - -=item fbm_instr - -Returns the location of the SV in the string delimited by C and -C. It returns C if the string can't be found. The -C does not have to be fbm_compiled, but the search will not be as -fast then. - - char* fbm_instr(char *str, char *strend, SV *sv, U32 flags) - -=item FREETMPS - -Closing bracket for temporaries on a callback. See C and -L. - - FREETMPS; - -=item G_ARRAY - -Used to indicate array context. See C, C and L. - -=item G_DISCARD - -Indicates that arguments returned from a callback should be discarded. See -L. - -=item G_EVAL - -Used to force a Perl C wrapper around a callback. See L. - -=item GIMME - -A backward-compatible version of C which can only return -C or C; in a void context, it returns C. - -=item GIMME_V - -The XSUB-writer's equivalent to Perl's C. Returns -C, C or C for void, scalar or array -context, respectively. - -=item G_NOARGS - -Indicates that no arguments are being sent to a callback. See L. - -=item G_SCALAR - -Used to indicate scalar context. See C, C, and L. - -=item gv_fetchmeth - -Returns the glob with the given C and a defined subroutine or -C. The glob lives in the given C, or in the stashes -accessible via @ISA and @UNIVERSAL. - -The argument C should be either 0 or -1. If C, as a -side-effect creates a glob with the given C in the given -C which in the case of success contains an alias for the -subroutine, and sets up caching info for this glob. Similarly for all -the searched stashes. - -This function grants C<"SUPER"> token as a postfix of the stash name. - -The GV returned from C may be a method cache entry, -which is not visible to Perl code. So when calling C, -you should not use the GV directly; instead, you should use the -method's CV, which can be obtained from the GV with the C macro. - - GV* gv_fetchmeth (HV* stash, const char* name, STRLEN len, I32 level) - -=item gv_fetchmethod - -=item gv_fetchmethod_autoload - -Returns the glob which contains the subroutine to call to invoke the -method on the C. In fact in the presence of autoloading this may -be the glob for "AUTOLOAD". In this case the corresponding variable -$AUTOLOAD is already setup. - -The third parameter of C determines whether AUTOLOAD -lookup is performed if the given method is not present: non-zero means -yes, look for AUTOLOAD; zero means no, don't look for AUTOLOAD. Calling -C is equivalent to calling C with a -non-zero C parameter. - -These functions grant C<"SUPER"> token as a prefix of the method name. - -Note that if you want to keep the returned glob for a long time, you -need to check for it being "AUTOLOAD", since at the later time the call -may load a different subroutine due to $AUTOLOAD changing its value. -Use the glob created via a side effect to do this. - -These functions have the same side-effects and as C with -C. C should be writable if contains C<':'> or C<'\''>. -The warning against passing the GV returned by C to -C apply equally to these functions. - - GV* gv_fetchmethod (HV* stash, const char* name) - GV* gv_fetchmethod_autoload (HV* stash, const char* name, I32 autoload) - -=item G_VOID - -Used to indicate void context. See C and L. - -=item gv_stashpv - -Returns a pointer to the stash for a specified package. If C is set -then the package will be created if it does not already exist. If C -is not set and the package does not exist then NULL is returned. - - HV* gv_stashpv (const char* name, I32 create) - -=item gv_stashsv - -Returns a pointer to the stash for a specified package. See C. - - HV* gv_stashsv (SV* sv, I32 create) - -=item GvSV - -Return the SV from the GV. - -=item HEf_SVKEY - -This flag, used in the length slot of hash entries and magic -structures, specifies the structure contains a C pointer where a -C pointer is to be expected. (For information only--not to be used). - -=item HeHASH - -Returns the computed hash stored in the hash entry. - - U32 HeHASH(HE* he) - -=item HeKEY - -Returns the actual pointer stored in the key slot of the hash entry. -The pointer may be either C or C, depending on the value of -C. Can be assigned to. The C or C macros -are usually preferable for finding the value of a key. - - char* HeKEY(HE* he) - -=item HeKLEN - -If this is negative, and amounts to C, it indicates the entry -holds an C key. Otherwise, holds the actual length of the key. -Can be assigned to. The C macro is usually preferable for finding -key lengths. - - int HeKLEN(HE* he) - -=item HePV - -Returns the key slot of the hash entry as a C value, doing any -necessary dereferencing of possibly C keys. The length of -the string is placed in C (this is a macro, so do I use -C<&len>). If you do not care about what the length of the key is, -you may use the global variable C, though this is rather less -efficient than using a local variable. Remember though, that hash -keys in perl are free to contain embedded nulls, so using C -or similar is not a good way to find the length of hash keys. -This is very similar to the C macro described elsewhere in -this document. - - char* HePV(HE* he, STRLEN len) - -=item HeSVKEY - -Returns the key as an C, or C if the hash entry -does not contain an C key. - - HeSVKEY(HE* he) - -=item HeSVKEY_force - -Returns the key as an C. Will create and return a temporary -mortal C if the hash entry contains only a C key. - - HeSVKEY_force(HE* he) - -=item HeSVKEY_set - -Sets the key to a given C, taking care to set the appropriate flags -to indicate the presence of an C key, and returns the same C. - - HeSVKEY_set(HE* he, SV* sv) - -=item HeVAL - -Returns the value slot (type C) stored in the hash entry. - - HeVAL(HE* he) - -=item hv_clear - -Clears a hash, making it empty. - - void hv_clear (HV* tb) - -=item hv_delete - -Deletes a key/value pair in the hash. The value SV is removed from the hash -and returned to the caller. The C is the length of the key. The -C value will normally be zero; if set to G_DISCARD then NULL will be -returned. - - SV* hv_delete (HV* tb, const char* key, U32 klen, I32 flags) - -=item hv_delete_ent - -Deletes a key/value pair in the hash. The value SV is removed from the hash -and returned to the caller. The C value will normally be zero; if set -to G_DISCARD then NULL will be returned. C can be a valid precomputed -hash value, or 0 to ask for it to be computed. - - SV* hv_delete_ent (HV* tb, SV* key, I32 flags, U32 hash) - -=item hv_exists - -Returns a boolean indicating whether the specified hash key exists. The -C is the length of the key. - - bool hv_exists (HV* tb, const char* key, U32 klen) - -=item hv_exists_ent - -Returns a boolean indicating whether the specified hash key exists. C -can be a valid precomputed hash value, or 0 to ask for it to be computed. - - bool hv_exists_ent (HV* tb, SV* key, U32 hash) - -=item hv_fetch - -Returns the SV which corresponds to the specified key in the hash. The -C is the length of the key. If C is set then the fetch will be -part of a store. Check that the return value is non-null before -dereferencing it to a C. - -See L for more -information on how to use this function on tied hashes. - - SV** hv_fetch (HV* tb, const char* key, U32 klen, I32 lval) - -=item hv_fetch_ent - -Returns the hash entry which corresponds to the specified key in the hash. -C must be a valid precomputed hash number for the given C, or -0 if you want the function to compute it. IF C is set then the -fetch will be part of a store. Make sure the return value is non-null -before accessing it. The return value when C is a tied hash -is a pointer to a static location, so be sure to make a copy of the -structure if you need to store it somewhere. - -See L for more -information on how to use this function on tied hashes. - - HE* hv_fetch_ent (HV* tb, SV* key, I32 lval, U32 hash) - -=item hv_iterinit - -Prepares a starting point to traverse a hash table. - - I32 hv_iterinit (HV* tb) - -Returns the number of keys in the hash (i.e. the same as C). -The return value is currently only meaningful for hashes without tie -magic. - -NOTE: Before version 5.004_65, C used to return the number -of hash buckets that happen to be in use. If you still need that -esoteric value, you can get it through the macro C. - -=item hv_iterkey - -Returns the key from the current position of the hash iterator. See -C. - - char* hv_iterkey (HE* entry, I32* retlen) - -=item hv_iterkeysv - -Returns the key as an C from the current position of the hash -iterator. The return value will always be a mortal copy of the -key. Also see C. - - SV* hv_iterkeysv (HE* entry) - -=item hv_iternext - -Returns entries from a hash iterator. See C. - - HE* hv_iternext (HV* tb) - -=item hv_iternextsv - -Performs an C, C, and C in one -operation. - - SV* hv_iternextsv (HV* hv, char** key, I32* retlen) - -=item hv_iterval - -Returns the value from the current position of the hash iterator. See -C. - - SV* hv_iterval (HV* tb, HE* entry) - -=item hv_magic - -Adds magic to a hash. See C. - - void hv_magic (HV* hv, GV* gv, int how) - -=item HvNAME - -Returns the package name of a stash. See C, C. - - char* HvNAME (HV* stash) - -=item hv_store - -Stores an SV in a hash. The hash key is specified as C and C is -the length of the key. The C parameter is the precomputed hash -value; if it is zero then Perl will compute it. The return value will be -NULL if the operation failed or if the value did not need to be actually -stored within the hash (as in the case of tied hashes). Otherwise it can -be dereferenced to get the original C. Note that the caller is -responsible for suitably incrementing the reference count of C -before the call, and decrementing it if the function returned NULL. - -See L for more -information on how to use this function on tied hashes. - - SV** hv_store (HV* tb, const char* key, U32 klen, SV* val, U32 hash) - -=item hv_store_ent - -Stores C in a hash. The hash key is specified as C. The C -parameter is the precomputed hash value; if it is zero then Perl will -compute it. The return value is the new hash entry so created. It will be -NULL if the operation failed or if the value did not need to be actually -stored within the hash (as in the case of tied hashes). Otherwise the -contents of the return value can be accessed using the C macros -described here. Note that the caller is responsible for suitably -incrementing the reference count of C before the call, and decrementing -it if the function returned NULL. - -See L for more -information on how to use this function on tied hashes. - - HE* hv_store_ent (HV* tb, SV* key, SV* val, U32 hash) - -=item hv_undef - -Undefines the hash. - - void hv_undef (HV* tb) - -=item isALNUM - -Returns a boolean indicating whether the C C is an ascii alphanumeric -character or digit. - - int isALNUM (char c) - -=item isALPHA - -Returns a boolean indicating whether the C C is an ascii alphabetic -character. - - int isALPHA (char c) - -=item isDIGIT - -Returns a boolean indicating whether the C C is an ascii digit. - - int isDIGIT (char c) - -=item isLOWER - -Returns a boolean indicating whether the C C is a lowercase character. - - int isLOWER (char c) - -=item isSPACE - -Returns a boolean indicating whether the C C is whitespace. - - int isSPACE (char c) - -=item isUPPER - -Returns a boolean indicating whether the C C is an uppercase character. - - int isUPPER (char c) - -=item items - -Variable which is setup by C to indicate the number of items on the -stack. See L. - -=item ix - -Variable which is setup by C to indicate which of an XSUB's aliases -was used to invoke it. See L. - -=item LEAVE - -Closing bracket on a callback. See C and L. - - LEAVE; - -=item looks_like_number - -Test if an the content of an SV looks like a number (or is a number). - - int looks_like_number(SV*) - +=head1 AUTHORS -=item MARK +Until May 1997, this document was maintained by Jeff Okamoto +. It is now maintained as part of Perl itself +by the Perl 5 Porters . -Stack marker variable for the XSUB. See C. +With lots of help and suggestions from Dean Roehrich, Malcolm Beattie, +Andreas Koenig, Paul Hudson, Ilya Zakharevich, Paul Marquess, Neil +Bowers, Matthew Green, Tim Bunce, Spider Boardman, Ulrich Pfeifer, +Stephen McCamant, and Gurusamy Sarathy. -=item mg_clear +API Listing originally by Dean Roehrich . -Clear something magical that the SV represents. See C. +Modifications to autogenerate the API listing (L) by Benjamin +Stuhl. - int mg_clear (SV* sv) +=head1 SEE ALSO -=item mg_copy - -Copies the magic from one SV to another. See C. - - int mg_copy (SV *, SV *, const char *, STRLEN) - -=item mg_find - -Finds the magic pointer for type matching the SV. See C. - - MAGIC* mg_find (SV* sv, int type) - -=item mg_free - -Free any magic storage used by the SV. See C. - - int mg_free (SV* sv) - -=item mg_get - -Do magic after a value is retrieved from the SV. See C. - - int mg_get (SV* sv) - -=item mg_len - -Report on the SV's length. See C. - - U32 mg_len (SV* sv) - -=item mg_magical - -Turns on the magical status of an SV. See C. - - void mg_magical (SV* sv) - -=item mg_set - -Do magic after a value is assigned to the SV. See C. - - int mg_set (SV* sv) - -=item modglobal - -C is a general purpose, interpreter global HV for use by -extensions that need to keep information on a per-interpreter basis. -In a pinch, it can also be used as a symbol table for extensions -to share data among each other. It is a good idea to use keys -prefixed by the package name of the extension that owns the data. - -=item Move - -The XSUB-writer's interface to the C C function. The C is the -source, C is the destination, C is the number of items, and C is -the type. Can do overlapping moves. See also C. - - void Move( s, d, n, t ) - -=item PL_na - -A convenience variable which is typically used with C when one doesn't -care about the length of the string. It is usually more efficient to -either declare a local variable and use that instead or to use the C -macro. - -=item New - -The XSUB-writer's interface to the C C function. - - void* New( x, void *ptr, int size, type ) - -=item newAV - -Creates a new AV. The reference count is set to 1. - - AV* newAV (void) - -=item Newc - -The XSUB-writer's interface to the C C function, with cast. - - void* Newc( x, void *ptr, int size, type, cast ) - -=item newCONSTSUB - -Creates a constant sub equivalent to Perl C -which is eligible for inlining at compile-time. - - void newCONSTSUB(HV* stash, char* name, SV* sv) - -=item newHV - -Creates a new HV. The reference count is set to 1. - - HV* newHV (void) - -=item newRV_inc - -Creates an RV wrapper for an SV. The reference count for the original SV is -incremented. - - SV* newRV_inc (SV* ref) - -For historical reasons, "newRV" is a synonym for "newRV_inc". - -=item newRV_noinc - -Creates an RV wrapper for an SV. The reference count for the original -SV is B incremented. - - SV* newRV_noinc (SV* ref) - -=item NEWSV - -Creates a new SV. A non-zero C parameter indicates the number of -bytes of preallocated string space the SV should have. An extra byte -for a tailing NUL is also reserved. (SvPOK is not set for the SV even -if string space is allocated.) The reference count for the new SV is -set to 1. C is an integer id between 0 and 1299 (used to identify -leaks). - - SV* NEWSV (int id, STRLEN len) - -=item newSViv - -Creates a new SV and copies an integer into it. The reference count for the -SV is set to 1. - - SV* newSViv (IV i) - -=item newSVnv - -Creates a new SV and copies a double into it. The reference count for the -SV is set to 1. - - SV* newSVnv (NV i) - -=item newSVpv - -Creates a new SV and copies a string into it. The reference count for the -SV is set to 1. If C is zero, Perl will compute the length using -strlen(). For efficiency, consider using C instead. - - SV* newSVpv (const char* s, STRLEN len) - -=item newSVpvf - -Creates a new SV an initialize it with the string formatted like -C. - - SV* newSVpvf(const char* pat, ...) - -=item newSVpvn - -Creates a new SV and copies a string into it. The reference count for the -SV is set to 1. Note that if C is zero, Perl will create a zero length -string. You are responsible for ensuring that the source string is at least -C bytes long. - - SV* newSVpvn (const char* s, STRLEN len) - -=item newSVrv - -Creates a new SV for the RV, C, to point to. If C is not an RV then -it will be upgraded to one. If C is non-null then the new SV will -be blessed in the specified package. The new SV is returned and its -reference count is 1. - - SV* newSVrv (SV* rv, const char* classname) - -=item newSVsv - -Creates a new SV which is an exact duplicate of the original SV. - - SV* newSVsv (SV* old) - -=item newXS - -Used by C to hook up XSUBs as Perl subs. - -=item newXSproto - -Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to -the subs. - -=item Newz - -The XSUB-writer's interface to the C C function. The allocated -memory is zeroed with C. - - void* Newz( x, void *ptr, int size, type ) - -=item Nullav - -Null AV pointer. - -=item Nullch - -Null character pointer. - -=item Nullcv - -Null CV pointer. - -=item Nullhv - -Null HV pointer. - -=item Nullsv - -Null SV pointer. - -=item ORIGMARK - -The original stack mark for the XSUB. See C. - -=item perl_alloc - -Allocates a new Perl interpreter. See L. - -=item perl_call_argv - -Performs a callback to the specified Perl sub. See L. - - I32 perl_call_argv (const char* subname, I32 flags, char** argv) - -=item perl_call_method - -Performs a callback to the specified Perl method. The blessed object must -be on the stack. See L. - - I32 perl_call_method (const char* methname, I32 flags) - -=item perl_call_pv - -Performs a callback to the specified Perl sub. See L. - - I32 perl_call_pv (const char* subname, I32 flags) - -=item perl_call_sv - -Performs a callback to the Perl sub whose name is in the SV. See -L. - - I32 perl_call_sv (SV* sv, I32 flags) - -=item perl_construct - -Initializes a new Perl interpreter. See L. - -=item perl_destruct - -Shuts down a Perl interpreter. See L. - -=item perl_eval_sv - -Tells Perl to C the string in the SV. - - I32 perl_eval_sv (SV* sv, I32 flags) - -=item perl_eval_pv - -Tells Perl to C the given string and return an SV* result. - - SV* perl_eval_pv (const char* p, I32 croak_on_error) - -=item perl_free - -Releases a Perl interpreter. See L. - -=item perl_get_av - -Returns the AV of the specified Perl array. If C is set and the -Perl variable does not exist then it will be created. If C is not -set and the variable does not exist then NULL is returned. - - AV* perl_get_av (const char* name, I32 create) - -=item perl_get_cv - -Returns the CV of the specified Perl subroutine. If C is set and -the Perl subroutine does not exist then it will be declared (which has -the same effect as saying C). If C is not -set and the subroutine does not exist then NULL is returned. - - CV* perl_get_cv (const char* name, I32 create) - -=item perl_get_hv - -Returns the HV of the specified Perl hash. If C is set and the Perl -variable does not exist then it will be created. If C is not -set and the variable does not exist then NULL is returned. - - HV* perl_get_hv (const char* name, I32 create) - -=item perl_get_sv - -Returns the SV of the specified Perl scalar. If C is set and the -Perl variable does not exist then it will be created. If C is not -set and the variable does not exist then NULL is returned. - - SV* perl_get_sv (const char* name, I32 create) - -=item perl_parse - -Tells a Perl interpreter to parse a Perl script. See L. - -=item perl_require_pv - -Tells Perl to C a module. - - void perl_require_pv (const char* pv) - -=item perl_run - -Tells a Perl interpreter to run. See L. - -=item POPi - -Pops an integer off the stack. - - int POPi() - -=item POPl - -Pops a long off the stack. - - long POPl() - -=item POPp - -Pops a string off the stack. - - char* POPp() - -=item POPn - -Pops a double off the stack. - - double POPn() - -=item POPs - -Pops an SV off the stack. - - SV* POPs() - -=item PUSHMARK - -Opening bracket for arguments on a callback. See C and L. - - PUSHMARK(p) - -=item PUSHi - -Push an integer onto the stack. The stack must have room for this element. -Handles 'set' magic. See C. - - void PUSHi(int d) - -=item PUSHn - -Push a double onto the stack. The stack must have room for this element. -Handles 'set' magic. See C. - - void PUSHn(double d) - -=item PUSHp - -Push a string onto the stack. The stack must have room for this element. -The C indicates the length of the string. Handles 'set' magic. See -C. - - void PUSHp(char *c, int len ) - -=item PUSHs - -Push an SV onto the stack. The stack must have room for this element. Does -not handle 'set' magic. See C. - - void PUSHs(sv) - -=item PUSHu - -Push an unsigned integer onto the stack. The stack must have room for -this element. See C. - - void PUSHu(unsigned int d) - - -=item PUTBACK - -Closing bracket for XSUB arguments. This is usually handled by C. -See C and L for other uses. - - PUTBACK; - -=item Renew - -The XSUB-writer's interface to the C C function. - - void* Renew( void *ptr, int size, type ) - -=item Renewc - -The XSUB-writer's interface to the C C function, with cast. - - void* Renewc( void *ptr, int size, type, cast ) - -=item RETVAL - -Variable which is setup by C to hold the return value for an XSUB. -This is always the proper type for the XSUB. -See L. - -=item safefree - -The XSUB-writer's interface to the C C function. - -=item safemalloc - -The XSUB-writer's interface to the C C function. - -=item saferealloc - -The XSUB-writer's interface to the C C function. - -=item savepv - -Copy a string to a safe spot. This does not use an SV. - - char* savepv (const char* sv) - -=item savepvn - -Copy a string to a safe spot. The C indicates number of bytes to -copy. This does not use an SV. - - char* savepvn (const char* sv, I32 len) - -=item SAVETMPS - -Opening bracket for temporaries on a callback. See C and -L. - - SAVETMPS; - -=item SP - -Stack pointer. This is usually handled by C. See C and -C. - -=item SPAGAIN - -Refetch the stack pointer. Used after a callback. See L. - - SPAGAIN; - -=item ST - -Used to access elements on the XSUB's stack. - - SV* ST(int x) - -=item strEQ - -Test two strings to see if they are equal. Returns true or false. - - int strEQ( char *s1, char *s2 ) - -=item strGE - -Test two strings to see if the first, C, is greater than or equal to the -second, C. Returns true or false. - - int strGE( char *s1, char *s2 ) - -=item strGT - -Test two strings to see if the first, C, is greater than the second, -C. Returns true or false. - - int strGT( char *s1, char *s2 ) - -=item strLE - -Test two strings to see if the first, C, is less than or equal to the -second, C. Returns true or false. - - int strLE( char *s1, char *s2 ) - -=item strLT - -Test two strings to see if the first, C, is less than the second, -C. Returns true or false. - - int strLT( char *s1, char *s2 ) - -=item strNE - -Test two strings to see if they are different. Returns true or false. - - int strNE( char *s1, char *s2 ) - -=item strnEQ - -Test two strings to see if they are equal. The C parameter indicates -the number of bytes to compare. Returns true or false. -(A wrapper for C). - - int strnEQ( const char *s1, const char *s2, size_t len ) - -=item strnNE - -Test two strings to see if they are different. The C parameter -indicates the number of bytes to compare. Returns true or false. -(A wrapper for C). - - int strnNE( const char *s1, const char *s2, size_t len ) - -=item sv_2mortal - -Marks an SV as mortal. The SV will be destroyed when the current context -ends. - - SV* sv_2mortal (SV* sv) - -=item sv_bless - -Blesses an SV into a specified package. The SV must be an RV. The package -must be designated by its stash (see C). The reference count -of the SV is unaffected. - - SV* sv_bless (SV* sv, HV* stash) - -=item sv_catpv - -Concatenates the string onto the end of the string which is in the SV. -Handles 'get' magic, but not 'set' magic. See C. - - void sv_catpv (SV* sv, const char* ptr) - -=item sv_catpv_mg - -Like C, but also handles 'set' magic. - - void sv_catpvn (SV* sv, const char* ptr) - -=item sv_catpvn - -Concatenates the string onto the end of the string which is in the SV. The -C indicates number of bytes to copy. Handles 'get' magic, but not -'set' magic. See C. - - void sv_catpvn (SV* sv, const char* ptr, STRLEN len) - -=item sv_catpvn_mg - -Like C, but also handles 'set' magic. - - void sv_catpvn_mg (SV* sv, const char* ptr, STRLEN len) - -=item sv_catpvf - -Processes its arguments like C and appends the formatted output -to an SV. Handles 'get' magic, but not 'set' magic. C must -typically be called after calling this function to handle 'set' magic. - - void sv_catpvf (SV* sv, const char* pat, ...) - -=item sv_catpvf_mg - -Like C, but also handles 'set' magic. - - void sv_catpvf_mg (SV* sv, const char* pat, ...) - -=item sv_catsv - -Concatenates the string from SV C onto the end of the string in SV -C. Handles 'get' magic, but not 'set' magic. See C. - - void sv_catsv (SV* dsv, SV* ssv) - -=item sv_catsv_mg - -Like C, but also handles 'set' magic. - - void sv_catsv_mg (SV* dsv, SV* ssv) - -=item sv_chop - -Efficient removal of characters from the beginning of the string -buffer. SvPOK(sv) must be true and the C must be a pointer to -somewhere inside the string buffer. The C becomes the first -character of the adjusted string. - - void sv_chop(SV* sv, const char *ptr) - - -=item sv_cmp - -Compares the strings in two SVs. Returns -1, 0, or 1 indicating whether the -string in C is less than, equal to, or greater than the string in -C. - - I32 sv_cmp (SV* sv1, SV* sv2) - -=item SvCUR - -Returns the length of the string which is in the SV. See C. - - int SvCUR (SV* sv) - -=item SvCUR_set - -Set the length of the string which is in the SV. See C. - - void SvCUR_set (SV* sv, int val) - -=item sv_dec - -Auto-decrement of the value in the SV. - - void sv_dec (SV* sv) - -=item sv_derived_from - -Returns a boolean indicating whether the SV is derived from the specified -class. This is the function that implements C. It works -for class names as well as for objects. - - bool sv_derived_from (SV* sv, const char* name); - -=item SvEND - -Returns a pointer to the last character in the string which is in the SV. -See C. Access the character as - - char* SvEND(sv) - -=item sv_eq - -Returns a boolean indicating whether the strings in the two SVs are -identical. - - I32 sv_eq (SV* sv1, SV* sv2) - -=item SvGETMAGIC - -Invokes C on an SV if it has 'get' magic. This macro evaluates -its argument more than once. - - void SvGETMAGIC(SV *sv) - -=item SvGROW - -Expands the character buffer in the SV so that it has room for the -indicated number of bytes (remember to reserve space for an extra -trailing NUL character). Calls C to perform the expansion if -necessary. Returns a pointer to the character buffer. - - char* SvGROW(SV* sv, STRLEN len) - -=item sv_grow - -Expands the character buffer in the SV. This will use C and will -upgrade the SV to C. Returns a pointer to the character buffer. -Use C. - -=item sv_inc - -Auto-increment of the value in the SV. - - void sv_inc (SV* sv) - -=item sv_insert - -Inserts a string at the specified offset/length within the SV. -Similar to the Perl substr() function. - - void sv_insert(SV *sv, STRLEN offset, STRLEN len, - char *str, STRLEN strlen) - -=item SvIOK - -Returns a boolean indicating whether the SV contains an integer. - - int SvIOK (SV* SV) - -=item SvIOK_off - -Unsets the IV status of an SV. - - void SvIOK_off (SV* sv) - -=item SvIOK_on - -Tells an SV that it is an integer. - - void SvIOK_on (SV* sv) - -=item SvIOK_only - -Tells an SV that it is an integer and disables all other OK bits. - - void SvIOK_only (SV* sv) - -=item SvIOKp - -Returns a boolean indicating whether the SV contains an integer. Checks the -B setting. Use C. - - int SvIOKp (SV* SV) - -=item sv_isa - -Returns a boolean indicating whether the SV is blessed into the specified -class. This does not check for subtypes; use C to verify -an inheritance relationship. - - int sv_isa (SV* sv, char* name) - -=item sv_isobject - -Returns a boolean indicating whether the SV is an RV pointing to a blessed -object. If the SV is not an RV, or if the object is not blessed, then this -will return false. - - int sv_isobject (SV* sv) - -=item SvIV - -Coerces the given SV to an integer and returns it. - - int SvIV (SV* sv) - -=item SvIVX - -Returns the integer which is stored in the SV, assuming SvIOK is true. - - int SvIVX (SV* sv) - -=item SvLEN - -Returns the size of the string buffer in the SV. See C. - - int SvLEN (SV* sv) - -=item sv_len - -Returns the length of the string in the SV. Use C. - - STRLEN sv_len (SV* sv) - -=item sv_magic - -Adds magic to an SV. - - void sv_magic (SV* sv, SV* obj, int how, const char* name, I32 namlen) - -=item sv_mortalcopy - -Creates a new SV which is a copy of the original SV. The new SV is marked -as mortal. - - SV* sv_mortalcopy (SV* oldsv) - -=item sv_newmortal - -Creates a new SV which is mortal. The reference count of the SV is set to 1. - - SV* sv_newmortal (void) - -=item SvNIOK - -Returns a boolean indicating whether the SV contains a number, integer or -double. - - int SvNIOK (SV* SV) - -=item SvNIOK_off - -Unsets the NV/IV status of an SV. - - void SvNIOK_off (SV* sv) - -=item SvNIOKp - -Returns a boolean indicating whether the SV contains a number, integer or -double. Checks the B setting. Use C. - - int SvNIOKp (SV* SV) - -=item PL_sv_no - -This is the C SV. See C. Always refer to this as C<&PL_sv_no>. - -=item SvNOK - -Returns a boolean indicating whether the SV contains a double. - - int SvNOK (SV* SV) - -=item SvNOK_off - -Unsets the NV status of an SV. - - void SvNOK_off (SV* sv) - -=item SvNOK_on - -Tells an SV that it is a double. - - void SvNOK_on (SV* sv) - -=item SvNOK_only - -Tells an SV that it is a double and disables all other OK bits. - - void SvNOK_only (SV* sv) - -=item SvNOKp - -Returns a boolean indicating whether the SV contains a double. Checks the -B setting. Use C. - - int SvNOKp (SV* SV) - -=item SvNV - -Coerce the given SV to a double and return it. - - double SvNV (SV* sv) - -=item SvNVX - -Returns the double which is stored in the SV, assuming SvNOK is true. - - double SvNVX (SV* sv) - -=item SvOK - -Returns a boolean indicating whether the value is an SV. - - int SvOK (SV* sv) - -=item SvOOK - -Returns a boolean indicating whether the SvIVX is a valid offset value -for the SvPVX. This hack is used internally to speed up removal of -characters from the beginning of a SvPV. When SvOOK is true, then the -start of the allocated string buffer is really (SvPVX - SvIVX). - - int SvOOK(SV* sv) - -=item SvPOK - -Returns a boolean indicating whether the SV contains a character string. - - int SvPOK (SV* SV) - -=item SvPOK_off - -Unsets the PV status of an SV. - - void SvPOK_off (SV* sv) - -=item SvPOK_on - -Tells an SV that it is a string. - - void SvPOK_on (SV* sv) - -=item SvPOK_only - -Tells an SV that it is a string and disables all other OK bits. - - void SvPOK_only (SV* sv) - -=item SvPOKp - -Returns a boolean indicating whether the SV contains a character string. -Checks the B setting. Use C. - - int SvPOKp (SV* SV) - -=item SvPV - -Returns a pointer to the string in the SV, or a stringified form of the SV -if the SV does not contain a string. Handles 'get' magic. - - char* SvPV (SV* sv, STRLEN len) - -=item SvPV_force - -Like but will force the SV into becoming a string (SvPOK). You -want force if you are going to update the SvPVX directly. - - char* SvPV_force(SV* sv, STRLEN len) - -=item SvPV_nolen - -Returns a pointer to the string in the SV, or a stringified form of the SV -if the SV does not contain a string. Handles 'get' magic. - - char* SvPV_nolen (SV* sv) - -=item SvPVX - -Returns a pointer to the string in the SV. The SV must contain a string. - - char* SvPVX (SV* sv) - -=item SvREFCNT - -Returns the value of the object's reference count. - - int SvREFCNT (SV* sv) - -=item SvREFCNT_dec - -Decrements the reference count of the given SV. - - void SvREFCNT_dec (SV* sv) - -=item SvREFCNT_inc - -Increments the reference count of the given SV. - - void SvREFCNT_inc (SV* sv) - -=item SvROK - -Tests if the SV is an RV. - - int SvROK (SV* sv) - -=item SvROK_off - -Unsets the RV status of an SV. - - void SvROK_off (SV* sv) - -=item SvROK_on - -Tells an SV that it is an RV. - - void SvROK_on (SV* sv) - -=item SvRV - -Dereferences an RV to return the SV. - - SV* SvRV (SV* sv) - -=item SvSETMAGIC - -Invokes C on an SV if it has 'set' magic. This macro evaluates -its argument more than once. - - void SvSETMAGIC( SV *sv ) - -=item sv_setiv - -Copies an integer into the given SV. Does not handle 'set' magic. -See C. - - void sv_setiv (SV* sv, IV num) - -=item sv_setiv_mg - -Like C, but also handles 'set' magic. - - void sv_setiv_mg (SV* sv, IV num) - -=item sv_setnv - -Copies a double into the given SV. Does not handle 'set' magic. -See C. - - void sv_setnv (SV* sv, double num) - -=item sv_setnv_mg - -Like C, but also handles 'set' magic. - - void sv_setnv_mg (SV* sv, double num) - -=item sv_setpv - -Copies a string into an SV. The string must be null-terminated. -Does not handle 'set' magic. See C. - - void sv_setpv (SV* sv, const char* ptr) - -=item sv_setpv_mg - -Like C, but also handles 'set' magic. - - void sv_setpv_mg (SV* sv, const char* ptr) - -=item sv_setpviv - -Copies an integer into the given SV, also updating its string value. -Does not handle 'set' magic. See C. - - void sv_setpviv (SV* sv, IV num) - -=item sv_setpviv_mg - -Like C, but also handles 'set' magic. - - void sv_setpviv_mg (SV* sv, IV num) - -=item sv_setpvn - -Copies a string into an SV. The C parameter indicates the number of -bytes to be copied. Does not handle 'set' magic. See C. - - void sv_setpvn (SV* sv, const char* ptr, STRLEN len) - -=item sv_setpvn_mg - -Like C, but also handles 'set' magic. - - void sv_setpvn_mg (SV* sv, const char* ptr, STRLEN len) - -=item sv_setpvf - -Processes its arguments like C and sets an SV to the formatted -output. Does not handle 'set' magic. See C. - - void sv_setpvf (SV* sv, const char* pat, ...) - -=item sv_setpvf_mg - -Like C, but also handles 'set' magic. - - void sv_setpvf_mg (SV* sv, const char* pat, ...) - -=item sv_setref_iv - -Copies an integer into a new SV, optionally blessing the SV. The C -argument will be upgraded to an RV. That RV will be modified to point to -the new SV. The C argument indicates the package for the -blessing. Set C to C to avoid the blessing. The new SV -will be returned and will have a reference count of 1. - - SV* sv_setref_iv (SV *rv, char *classname, IV iv) - -=item sv_setref_nv - -Copies a double into a new SV, optionally blessing the SV. The C -argument will be upgraded to an RV. That RV will be modified to point to -the new SV. The C argument indicates the package for the -blessing. Set C to C to avoid the blessing. The new SV -will be returned and will have a reference count of 1. - - SV* sv_setref_nv (SV *rv, char *classname, double nv) - -=item sv_setref_pv - -Copies a pointer into a new SV, optionally blessing the SV. The C -argument will be upgraded to an RV. That RV will be modified to point to -the new SV. If the C argument is NULL then C will be placed -into the SV. The C argument indicates the package for the -blessing. Set C to C to avoid the blessing. The new SV -will be returned and will have a reference count of 1. - - SV* sv_setref_pv (SV *rv, char *classname, void* pv) - -Do not use with integral Perl types such as HV, AV, SV, CV, because those -objects will become corrupted by the pointer copy process. - -Note that C copies the string while this copies the pointer. - -=item sv_setref_pvn - -Copies a string into a new SV, optionally blessing the SV. The length of the -string must be specified with C. The C argument will be upgraded to -an RV. That RV will be modified to point to the new SV. The C -argument indicates the package for the blessing. Set C to -C to avoid the blessing. The new SV will be returned and will have -a reference count of 1. - - SV* sv_setref_pvn (SV *rv, char *classname, char* pv, I32 n) - -Note that C copies the pointer while this copies the string. - -=item SvSetSV - -Calls C if dsv is not the same as ssv. May evaluate arguments -more than once. - - void SvSetSV (SV* dsv, SV* ssv) - -=item SvSetSV_nosteal - -Calls a non-destructive version of C if dsv is not the same as ssv. -May evaluate arguments more than once. - - void SvSetSV_nosteal (SV* dsv, SV* ssv) - -=item sv_setsv - -Copies the contents of the source SV C into the destination SV C. -The source SV may be destroyed if it is mortal. Does not handle 'set' magic. -See the macro forms C, C and C. - - void sv_setsv (SV* dsv, SV* ssv) - -=item sv_setsv_mg - -Like C, but also handles 'set' magic. - - void sv_setsv_mg (SV* dsv, SV* ssv) - -=item sv_setuv - -Copies an unsigned integer into the given SV. Does not handle 'set' magic. -See C. - - void sv_setuv (SV* sv, UV num) - -=item sv_setuv_mg - -Like C, but also handles 'set' magic. - - void sv_setuv_mg (SV* sv, UV num) - -=item SvSTASH - -Returns the stash of the SV. - - HV* SvSTASH (SV* sv) - -=item SvTAINT - -Taints an SV if tainting is enabled - - void SvTAINT (SV* sv) - -=item SvTAINTED - -Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. - - int SvTAINTED (SV* sv) - -=item SvTAINTED_off - -Untaints an SV. Be I careful with this routine, as it short-circuits -some of Perl's fundamental security features. XS module authors should -not use this function unless they fully understand all the implications -of unconditionally untainting the value. Untainting should be done in -the standard perl fashion, via a carefully crafted regexp, rather than -directly untainting variables. - - void SvTAINTED_off (SV* sv) - -=item SvTAINTED_on - -Marks an SV as tainted. - - void SvTAINTED_on (SV* sv) - -=item SVt_IV - -Integer type flag for scalars. See C. - -=item SVt_PV - -Pointer type flag for scalars. See C. - -=item SVt_PVAV - -Type flag for arrays. See C. - -=item SVt_PVCV - -Type flag for code refs. See C. - -=item SVt_PVHV - -Type flag for hashes. See C. - -=item SVt_PVMG - -Type flag for blessed scalars. See C. - -=item SVt_NV - -Double type flag for scalars. See C. - -=item SvTRUE - -Returns a boolean indicating whether Perl would evaluate the SV as true or -false, defined or undefined. Does not handle 'get' magic. - - int SvTRUE (SV* sv) - -=item SvTYPE - -Returns the type of the SV. See C. - - svtype SvTYPE (SV* sv) - -=item svtype - -An enum of flags for Perl types. These are found in the file B in the -C enum. Test these flags with the C macro. - -=item PL_sv_undef - -This is the C SV. Always refer to this as C<&PL_sv_undef>. - -=item sv_unref - -Unsets the RV status of the SV, and decrements the reference count of -whatever was being referenced by the RV. This can almost be thought of -as a reversal of C. See C. - - void sv_unref (SV* sv) - -=item SvUPGRADE - -Used to upgrade an SV to a more complex form. Uses C to perform -the upgrade if necessary. See C. - - bool SvUPGRADE (SV* sv, svtype mt) - -=item sv_upgrade - -Upgrade an SV to a more complex form. Use C. See C. - -=item sv_usepvn - -Tells an SV to use C to find its string value. Normally the string is -stored inside the SV but sv_usepvn allows the SV to use an outside string. -The C should point to memory that was allocated by C. The -string length, C, must be supplied. This function will realloc the -memory pointed to by C, so that pointer should not be freed or used by -the programmer after giving it to sv_usepvn. Does not handle 'set' magic. -See C. - - void sv_usepvn (SV* sv, char* ptr, STRLEN len) - -=item sv_usepvn_mg - -Like C, but also handles 'set' magic. - - void sv_usepvn_mg (SV* sv, char* ptr, STRLEN len) - -=item sv_vcatpvfn - -Processes its arguments like C and appends the formatted output -to an SV. Uses an array of SVs if the C style variable argument list is -missing (NULL). When running with taint checks enabled, indicates via -C if results are untrustworthy (often due to the use of -locales). - - void sv_catpvfn (SV* sv, const char* pat, STRLEN patlen, - va_list *args, SV **svargs, I32 svmax, - bool *maybe_tainted); - -=item sv_vsetpvfn - -Works like C but copies the text into the SV instead of -appending it. - - void sv_setpvfn (SV* sv, const char* pat, STRLEN patlen, - va_list *args, SV **svargs, I32 svmax, - bool *maybe_tainted); - -=item SvUV - -Coerces the given SV to an unsigned integer and returns it. - - UV SvUV(SV* sv) - -=item SvUVX - -Returns the unsigned integer which is stored in the SV, assuming SvIOK is true. - - UV SvUVX(SV* sv) - -=item PL_sv_yes - -This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. - -=item THIS - -Variable which is setup by C to designate the object in a C++ XSUB. -This is always the proper type for the C++ object. See C and -L. - -=item toLOWER - -Converts the specified character to lowercase. - - int toLOWER (char c) - -=item toUPPER - -Converts the specified character to uppercase. - - int toUPPER (char c) - -=item warn - -This is the XSUB-writer's interface to Perl's C function. Use this -function the same way you use the C C function. See C. - -=item XPUSHi - -Push an integer onto the stack, extending the stack if necessary. Handles -'set' magic. See C. - - XPUSHi(int d) - -=item XPUSHn - -Push a double onto the stack, extending the stack if necessary. Handles 'set' -magic. See C. - - XPUSHn(double d) - -=item XPUSHp - -Push a string onto the stack, extending the stack if necessary. The C -indicates the length of the string. Handles 'set' magic. See C. - - XPUSHp(char *c, int len) - -=item XPUSHs - -Push an SV onto the stack, extending the stack if necessary. Does not -handle 'set' magic. See C. - - XPUSHs(sv) - -=item XPUSHu - -Push an unsigned integer onto the stack, extending the stack if -necessary. See C. - -=item XS - -Macro to declare an XSUB and its C parameter list. This is handled by -C. - -=item XSRETURN - -Return from XSUB, indicating number of items on the stack. This is usually -handled by C. - - XSRETURN(int x) - -=item XSRETURN_EMPTY - -Return an empty list from an XSUB immediately. - - XSRETURN_EMPTY; - -=item XSRETURN_IV - -Return an integer from an XSUB immediately. Uses C. - - XSRETURN_IV(IV v) - -=item XSRETURN_NO - -Return C<&PL_sv_no> from an XSUB immediately. Uses C. - - XSRETURN_NO; - -=item XSRETURN_NV - -Return an double from an XSUB immediately. Uses C. - - XSRETURN_NV(NV v) - -=item XSRETURN_PV - -Return a copy of a string from an XSUB immediately. Uses C. - - XSRETURN_PV(char *v) - -=item XSRETURN_UNDEF - -Return C<&PL_sv_undef> from an XSUB immediately. Uses C. - - XSRETURN_UNDEF; - -=item XSRETURN_YES - -Return C<&PL_sv_yes> from an XSUB immediately. Uses C. - - XSRETURN_YES; - -=item XST_mIV - -Place an integer into the specified position C on the stack. The value is -stored in a new mortal SV. - - XST_mIV( int i, IV v ) - -=item XST_mNV - -Place a double into the specified position C on the stack. The value is -stored in a new mortal SV. - - XST_mNV( int i, NV v ) - -=item XST_mNO - -Place C<&PL_sv_no> into the specified position C on the stack. - - XST_mNO( int i ) - -=item XST_mPV - -Place a copy of a string into the specified position C on the stack. The -value is stored in a new mortal SV. - - XST_mPV( int i, char *v ) - -=item XST_mUNDEF - -Place C<&PL_sv_undef> into the specified position C on the stack. - - XST_mUNDEF( int i ) - -=item XST_mYES - -Place C<&PL_sv_yes> into the specified position C on the stack. - - XST_mYES( int i ) - -=item XS_VERSION - -The version identifier for an XS module. This is usually handled -automatically by C. See C. - -=item XS_VERSION_BOOTCHECK - -Macro to verify that a PM module's $VERSION variable matches the XS module's -C variable. This is usually handled automatically by -C. See L. - -=item Zero - -The XSUB-writer's interface to the C C function. The C is the -destination, C is the number of items, and C is the type. - - void Zero( d, n, t ) - -=back - -=head1 AUTHORS - -Until May 1997, this document was maintained by Jeff Okamoto -. It is now maintained as part of Perl itself. - -With lots of help and suggestions from Dean Roehrich, Malcolm Beattie, -Andreas Koenig, Paul Hudson, Ilya Zakharevich, Paul Marquess, Neil -Bowers, Matthew Green, Tim Bunce, Spider Boardman, Ulrich Pfeifer, -Stephen McCamant, and Gurusamy Sarathy. - -API Listing originally by Dean Roehrich . +perlapi(1), perlintern(1), perlxs(1), perlembed(1) diff --git a/pod/perlintern.pod b/pod/perlintern.pod new file mode 100644 index 0000000..58eeac6 --- /dev/null +++ b/pod/perlintern.pod @@ -0,0 +1,26 @@ +=head1 NAME + +perlintern - autogenerated documentation of purely B + Perl functions + +=head1 DESCRIPTION + +This file is the autogenerated documentation of functions in the +Perl intrepreter that are documented using Perl's internal documentation +format but are not marked as part of the Perl API. In other words, +B! + +=over 8 + +=back + +=head1 AUTHORS + +The autodocumentation system was orignally added to the Perl core by +Benjamin Stuhl. Documentation is by whoever was kind enough to +document their functions. + +=head1 SEE ALSO + +perlguts(1), perlapi(1) + diff --git a/pod/perltoc.pod b/pod/perltoc.pod index 8f56d7a..96ec7f0 100644 --- a/pod/perltoc.pod +++ b/pod/perltoc.pod @@ -1390,8 +1390,8 @@ Time::Local, Win32, DBM Filters =item Documentation Changes -perlcompile.pod, perlfilter.pod, perlhack.pod, perlopentut.pod, -perlreftut.pod, perltootc.pod +perlapi.pod, perlcompile.pod, perlfilter.pod, perlhack.pod, perlintern.pod, +perlopentut.pod, perlreftut.pod, perltootc.pod =item New or Changed Diagnostics @@ -2064,8 +2064,9 @@ files, directories and network sockets =item CAVEATS AND LIMITATIONS -BEGIN blocks, Open filehandles, Global state maintained by XSUBs, -Interpreter embedded in larger application, Thread-safety of extensions +BEGIN blocks, Open filehandles, Forking pipe open() not yet implemented, +Global state maintained by XSUBs, Interpreter embedded in larger +application, Thread-safety of extensions =back @@ -3409,7 +3410,7 @@ B, B =back -=head2 perlguts - Perl's Internal Functions +=head2 perlguts - Introduction to the Perl API =over @@ -3507,7 +3508,7 @@ C =back -=item The Perl Internal API +=item How multiple interpreters and concurrency are supported =over @@ -3519,55 +3520,10 @@ C =back -=item API LISTING - -av_clear, av_extend, av_fetch, AvFILL, av_len, av_make, av_pop, av_push, -av_shift, av_store, av_undef, av_unshift, CLASS, Copy, croak, CvSTASH, -PL_DBsingle, PL_DBsub, PL_DBtrace, dMARK, dORIGMARK, PL_dowarn, dSP, -dXSARGS, dXSI32, do_binmode, ENTER, EXTEND, fbm_compile, fbm_instr, -FREETMPS, G_ARRAY, G_DISCARD, G_EVAL, GIMME, GIMME_V, G_NOARGS, G_SCALAR, -gv_fetchmeth, gv_fetchmethod, gv_fetchmethod_autoload, G_VOID, gv_stashpv, -gv_stashsv, GvSV, HEf_SVKEY, HeHASH, HeKEY, HeKLEN, HePV, HeSVKEY, -HeSVKEY_force, HeSVKEY_set, HeVAL, hv_clear, hv_delete, hv_delete_ent, -hv_exists, hv_exists_ent, hv_fetch, hv_fetch_ent, hv_iterinit, hv_iterkey, -hv_iterkeysv, hv_iternext, hv_iternextsv, hv_iterval, hv_magic, HvNAME, -hv_store, hv_store_ent, hv_undef, isALNUM, isALPHA, isDIGIT, isLOWER, -isSPACE, isUPPER, items, ix, LEAVE, looks_like_number, MARK, mg_clear, -mg_copy, mg_find, mg_free, mg_get, mg_len, mg_magical, mg_set, modglobal, -Move, PL_na, New, newAV, Newc, newCONSTSUB, newHV, newRV_inc, newRV_noinc, -NEWSV, newSViv, newSVnv, newSVpv, newSVpvf, newSVpvn, newSVrv, newSVsv, -newXS, newXSproto, Newz, Nullav, Nullch, Nullcv, Nullhv, Nullsv, ORIGMARK, -perl_alloc, perl_call_argv, perl_call_method, perl_call_pv, perl_call_sv, -perl_construct, perl_destruct, perl_eval_sv, perl_eval_pv, perl_free, -perl_get_av, perl_get_cv, perl_get_hv, perl_get_sv, perl_parse, -perl_require_pv, perl_run, POPi, POPl, POPp, POPn, POPs, PUSHMARK, PUSHi, -PUSHn, PUSHp, PUSHs, PUSHu, PUTBACK, Renew, Renewc, RETVAL, safefree, -safemalloc, saferealloc, savepv, savepvn, SAVETMPS, SP, SPAGAIN, ST, strEQ, -strGE, strGT, strLE, strLT, strNE, strnEQ, strnNE, sv_2mortal, sv_bless, -sv_catpv, sv_catpv_mg, sv_catpvn, sv_catpvn_mg, sv_catpvf, sv_catpvf_mg, -sv_catsv, sv_catsv_mg, sv_chop, sv_cmp, SvCUR, SvCUR_set, sv_dec, -sv_derived_from, SvEND, sv_eq, SvGETMAGIC, SvGROW, sv_grow, sv_inc, -sv_insert, SvIOK, SvIOK_off, SvIOK_on, SvIOK_only, SvIOKp, sv_isa, -sv_isobject, SvIV, SvIVX, SvLEN, sv_len, sv_magic, sv_mortalcopy, -sv_newmortal, SvNIOK, SvNIOK_off, SvNIOKp, PL_sv_no, SvNOK, SvNOK_off, -SvNOK_on, SvNOK_only, SvNOKp, SvNV, SvNVX, SvOK, SvOOK, SvPOK, SvPOK_off, -SvPOK_on, SvPOK_only, SvPOKp, SvPV, SvPV_force, SvPV_nolen, SvPVX, -SvREFCNT, SvREFCNT_dec, SvREFCNT_inc, SvROK, SvROK_off, SvROK_on, SvRV, -SvSETMAGIC, sv_setiv, sv_setiv_mg, sv_setnv, sv_setnv_mg, sv_setpv, -sv_setpv_mg, sv_setpviv, sv_setpviv_mg, sv_setpvn, sv_setpvn_mg, sv_setpvf, -sv_setpvf_mg, sv_setref_iv, sv_setref_nv, sv_setref_pv, sv_setref_pvn, -SvSetSV, SvSetSV_nosteal, sv_setsv, sv_setsv_mg, sv_setuv, sv_setuv_mg, -SvSTASH, SvTAINT, SvTAINTED, SvTAINTED_off, SvTAINTED_on, SVt_IV, SVt_PV, -SVt_PVAV, SVt_PVCV, SVt_PVHV, SVt_PVMG, SVt_NV, SvTRUE, SvTYPE, svtype, -PL_sv_undef, sv_unref, SvUPGRADE, sv_upgrade, sv_usepvn, sv_usepvn_mg, -sv_vcatpvfn, sv_vsetpvfn, SvUV, SvUVX, PL_sv_yes, THIS, toLOWER, toUPPER, -warn, XPUSHi, XPUSHn, XPUSHp, XPUSHs, XPUSHu, XS, XSRETURN, XSRETURN_EMPTY, -XSRETURN_IV, XSRETURN_NO, XSRETURN_NV, XSRETURN_PV, XSRETURN_UNDEF, -XSRETURN_YES, XST_mIV, XST_mNV, XST_mNO, XST_mPV, XST_mUNDEF, XST_mYES, -XS_VERSION, XS_VERSION_BOOTCHECK, Zero - =item AUTHORS +=item SEE ALSO + =back =head2 perlcall - Perl calling conventions from C @@ -3694,13 +3650,77 @@ B::Stash, B::Terse, B::Xref =back +=item KNOWN PROBLEMS + +=item AUTHOR + =back +=head2 perlapi - autogenerated documentation for the perl public API + =over -=item KNOWN PROBLEMS +=item DESCRIPTION -=item AUTHOR +AvFILL, av_clear, av_extend, av_fetch, av_len, av_make, av_pop, av_push, +av_shift, av_store, av_undef, av_unshift, call_argv, call_method, call_pv, +call_sv, CLASS, Copy, croak, CvSTASH, dMARK, dORIGMARK, dSP, dXSARGS, +dXSI32, ENTER, eval_pv, eval_sv, EXTEND, fbm_compile, fbm_instr, FREETMPS, +get_av, get_cv, get_hv, get_sv, GIMME, GIMME_V, GvSV, gv_fetchmeth, +gv_fetchmethod, gv_fetchmethod_autoload, gv_stashpv, gv_stashsv, G_ARRAY, +G_DISCARD, G_EVAL, G_NOARGS, G_SCALAR, G_VOID, HEf_SVKEY, HeHASH, HeKEY, +HeKLEN, HePV, HeSVKEY, HeSVKEY_force, HeSVKEY_set, HeVAL, HvNAME, hv_clear, +hv_delete, hv_delete_ent, hv_exists, hv_exists_ent, hv_fetch, hv_fetch_ent, +hv_iterinit, hv_iterkey, hv_iterkeysv, hv_iternext, hv_iternextsv, +hv_iterval, hv_magic, hv_store, hv_store_ent, hv_undef, isALNUM, isALPHA, +isDIGIT, isLOWER, isSPACE, isUPPER, items, ix, LEAVE, looks_like_number, +MARK, mg_clear, mg_copy, mg_find, mg_free, mg_get, mg_length, mg_magical, +mg_set, Move, New, newAV, Newc, newCONSTSUB, newHV, newRV_inc, newRV_noinc, +NEWSV, newSViv, newSVnv, newSVpv, newSVpvf, newSVpvn, newSVrv, newSVsv, +newXS, newXSproto, Newz, Nullav, Nullch, Nullcv, Nullhv, Nullsv, ORIGMARK, +perl_alloc, perl_construct, perl_destruct, perl_free, perl_parse, perl_run, +PL_DBsingle, PL_DBsub, PL_DBtrace, PL_dowarn, PL_modglobal, PL_na, +PL_sv_no, PL_sv_undef, PL_sv_yes, POPi, POPl, POPn, POPp, POPs, PUSHi, +PUSHMARK, PUSHn, PUSHp, PUSHs, PUSHu, PUTBACK, Renew, Renewc, require_pv, +RETVAL, Safefree, savepv, savepvn, SAVETMPS, SP, SPAGAIN, ST, strEQ, strGE, +strGT, strLE, strLT, strNE, strnEQ, strnNE, StructCopy, SvCUR, SvCUR_set, +SvEND, SvGETMAGIC, SvGROW, SvIOK, SvIOKp, SvIOK_off, SvIOK_on, SvIOK_only, +SvIV, SvIVX, SvLEN, SvNIOK, SvNIOKp, SvNIOK_off, SvNOK, SvNOKp, SvNOK_off, +SvNOK_on, SvNOK_only, SvNV, SvNVX, SvOK, SvOOK, SvPOK, SvPOKp, SvPOK_off, +SvPOK_on, SvPOK_only, SvPV, SvPVX, SvPV_force, SvPV_nolen, SvREFCNT, +SvREFCNT_dec, SvREFCNT_inc, SvROK, SvROK_off, SvROK_on, SvRV, SvSETMAGIC, +SvSetSV, SvSetSV_nosteal, SvSTASH, SvTAINT, SvTAINTED, SvTAINTED_off, +SvTAINTED_on, SvTRUE, SvTYPE, svtype, SVt_IV, SVt_NV, SVt_PV, SVt_PVAV, +SVt_PVCV, SVt_PVHV, SVt_PVMG, SvUPGRADE, SvUV, SvUVX, sv_2mortal, sv_bless, +sv_catpv, sv_catpvf, sv_catpvf_mg, sv_catpvn, sv_catpvn_mg, sv_catpv_mg, +sv_catsv, sv_catsv_mg, sv_chop, sv_cmp, sv_dec, sv_derived_from, sv_eq, +sv_grow, sv_inc, sv_insert, sv_isa, sv_isobject, sv_len, sv_magic, +sv_mortalcopy, sv_newmortal, sv_setiv, sv_setiv_mg, sv_setnv, sv_setnv_mg, +sv_setpv, sv_setpvf, sv_setpvf_mg, sv_setpviv, sv_setpviv_mg, sv_setpvn, +sv_setpvn_mg, sv_setpv_mg, sv_setref_iv, sv_setref_nv, sv_setref_pv, +sv_setref_pvn, sv_setsv, sv_setsv_mg, sv_setuv, sv_setuv_mg, sv_unref, +sv_upgrade, sv_usepvn, sv_usepvn_mg, sv_vcatpvfn, sv_vsetpvfn, THIS, +toLOWER, toUPPER, warn, XPUSHi, XPUSHn, XPUSHp, XPUSHs, XPUSHu, XS, +XSRETURN, XSRETURN_EMPTY, XSRETURN_IV, XSRETURN_NO, XSRETURN_NV, +XSRETURN_PV, XSRETURN_UNDEF, XSRETURN_YES, XST_mIV, XST_mNO, XST_mNV, +XST_mPV, XST_mUNDEF, XST_mYES, XS_VERSION, XS_VERSION_BOOTCHECK, Zero + +=item AUTHORS + +=item SEE ALSO + +=back + +=head2 perlintern - autogenerated documentation of purely B + Perl functions + +=over + +=item DESCRIPTION + +=item AUTHORS + +=item SEE ALSO =back @@ -7764,6 +7784,28 @@ hostpath(), peerpath() =back +=head2 IPC::Msg - SysV Msg IPC object class + +=over + +=item SYNOPSIS + +=item DESCRIPTION + +=item METHODS + +new ( KEY , FLAGS ), id, rcv ( BUF, LEN [, TYPE [, FLAGS ]] ), remove, set +( STAT ), set ( NAME => VALUE [, NAME => VALUE ...] ), snd ( TYPE, MSG [, +FLAGS ] ), stat + +=item SEE ALSO + +=item AUTHOR + +=item COPYRIGHT + +=back + =head2 IPC::Open2, open2 - open a process for both reading and writing =over @@ -7791,6 +7833,29 @@ handling =back +=head2 IPC::Semaphore - SysV Semaphore IPC object class + +=over + +=item SYNOPSIS + +=item DESCRIPTION + +=item METHODS + +new ( KEY , NSEMS , FLAGS ), getall, getncnt ( SEM ), getpid ( SEM ), +getval ( SEM ), getzcnt ( SEM ), id, op ( OPLIST ), remove, set ( STAT ), +set ( NAME => VALUE [, NAME => VALUE ...] ), setall ( VALUES ), setval ( N +, VALUE ), stat + +=item SEE ALSO + +=item AUTHOR + +=item COPYRIGHT + +=back + =head2 IPC::SysV - SysV IPC constants =over diff --git a/pod/roffitall b/pod/roffitall index 7ddffe7..9f9e3e9 100644 --- a/pod/roffitall +++ b/pod/roffitall @@ -71,6 +71,8 @@ toroff=` $mandir/perlcall.1 \ $mandir/perlcompile.1 \ $mandir/perltodo.1 \ + $mandir/perlapi.1 \ + $mandir/perlintern.1 \ $mandir/perlhack.1 \ $mandir/perlhist.1 \ $mandir/perldelta.1 \ diff --git a/pp.h b/pp.h index ec701f3..49155c3 100644 --- a/pp.h +++ b/pp.h @@ -17,6 +17,38 @@ #define PP(s) OP * Perl_##s(pTHX) +/* +=for apidoc AmU||SP +Stack pointer. This is usually handled by C. See C and +C. + +=for apidoc AmU||MARK +Stack marker variable for the XSUB. See C. + +=for apidoc Ams||PUSHMARK +Opening bracket for arguments on a callback. See C and +L. + +=for apidoc Ams||dSP +Declares a local copy of perl's stack pointer for the XSUB, available via +the C macro. See C. + +=for apidoc Ams||dMARK +Declare a stack marker variable, C, for the XSUB. See C and +C. + +=for apidoc Ams||dORIGMARK +Saves the original stack mark for the XSUB. See C. + +=for apidoc AmU||ORIGMARK +The original stack mark for the XSUB. See C. + +=for apidoc Ams||SPAGAIN +Refetch the stack pointer. Used after a callback. See L. + +=cut +*/ + #define SP sp #define MARK mark #define TARG targ @@ -52,6 +84,29 @@ #define NORMAL PL_op->op_next #define DIE return Perl_die +/* +=for apidoc Ams||PUTBACK +Closing bracket for XSUB arguments. This is usually handled by C. +See C and L for other uses. + +=for apidoc Amn|SV*|POPs +Pops an SV off the stack. + +=for apidoc Amn|char*|POPp +Pops a string off the stack. + +=for apidoc Amn|NV|POPn +Pops a double off the stack. + +=for apidoc Amn|IV|POPi +Pops an integer off the stack. + +=for apidoc Amn|long|POPl +Pops a long off the stack. + +=cut +*/ + #define PUTBACK PL_stack_sp = sp #define RETURN return PUTBACK, NORMAL #define RETURNOP(o) return PUTBACK, o @@ -84,6 +139,58 @@ #endif /* Go to some pains in the rare event that we must extend the stack. */ + +/* +=for apidoc Am|void|EXTEND|SP|int nitems +Used to extend the argument stack for an XSUB's return values. Once +used, guarrantees that there is room for at least C to be pushed +onto the stack. + +=for apidoc Am|void|PUSHs|SV* sv +Push an SV onto the stack. The stack must have room for this element. +Does not handle 'set' magic. See C. + +=for apidoc Am|void|PUSHp|char* str|STRLEN len +Push a string onto the stack. The stack must have room for this element. +The C indicates the length of the string. Handles 'set' magic. See +C. + +=for apidoc Am|void|PUSHn|NV nv +Push a double onto the stack. The stack must have room for this element. +Handles 'set' magic. See C. + +=for apidoc Am|void|PUSHi|IV iv +Push an integer onto the stack. The stack must have room for this element. +Handles 'set' magic. See C. + +=for apidoc Am|void|PUSHu|UV uv +Push an unsigned integer onto the stack. The stack must have room for this +element. See C. + +=for apidoc Am|void|XPUSHs|SV* sv +Push an SV onto the stack, extending the stack if necessary. Does not +handle 'set' magic. See C. + +=for apidoc Am|void|XPUSHp|char* str|STRLEN len +Push a string onto the stack, extending the stack if necessary. The C +indicates the length of the string. Handles 'set' magic. See +C. + +=for apidoc Am|void|XPUSHn|NV nv +Push a double onto the stack, extending the stack if necessary. Handles +'set' magic. See C. + +=for apidoc Am|void|XPUSHi|IV iv +Push an integer onto the stack, extending the stack if necessary. Handles +'set' magic. See C. + +=for apidoc Am|void|XPUSHu|UV uv +Push an unsigned integer onto the stack, extending the stack if necessary. +See C. + +=cut +*/ + #define EXTEND(p,n) STMT_START { if (PL_stack_max - p < (n)) { \ sp = stack_grow(sp,p, (int) (n)); \ } } STMT_END diff --git a/scope.h b/scope.h index 6944630..f90e7c5 100644 --- a/scope.h +++ b/scope.h @@ -46,6 +46,24 @@ #define SSPOPDPTR (PL_savestack[--PL_savestack_ix].any_dptr) #define SSPOPDXPTR (PL_savestack[--PL_savestack_ix].any_dxptr) +/* +=for apidoc Ams||SAVETMPS +Opening bracket for temporaries on a callback. See C and +L. + +=for apidoc Ams||FREETMPS +Closing bracket for temporaries on a callback. See C and +L. + +=for apidoc Ams||ENTER +Opening bracket on a callback. See C and L. + +=for apidoc Ams||LEAVE +Closing bracket on a callback. See C and L. + +=cut +*/ + #define SAVETMPS save_int((int*)&PL_tmps_floor), PL_tmps_floor = PL_tmps_ix #define FREETMPS if (PL_tmps_ix > PL_tmps_floor) free_tmps() diff --git a/sv.c b/sv.c index 7d837d2..834dac3 100644 --- a/sv.c +++ b/sv.c @@ -921,6 +921,15 @@ S_my_safemalloc(MEM_SIZE size) #define new_XPVIO() (void*)my_safemalloc(sizeof(XPVIO)) #define del_XPVIO(p) my_safefree((char*)p) +/* +=for apidoc sv_upgrade + +Upgrade an SV to a more complex form. Use C. See +C. + +=cut +*/ + bool Perl_sv_upgrade(pTHX_ register SV *sv, U32 mt) { @@ -1210,6 +1219,16 @@ Perl_sv_backoff(pTHX_ register SV *sv) return 0; } +/* +=for apidoc sv_grow + +Expands the character buffer in the SV. This will use C and will +upgrade the SV to C. Returns a pointer to the character buffer. +Use C. + +=cut +*/ + char * Perl_sv_grow(pTHX_ register SV *sv, register STRLEN newlen) { @@ -1259,6 +1278,15 @@ Perl_sv_grow(pTHX_ register SV *sv, register STRLEN newlen) return s; } +/* +=for apidoc sv_setiv + +Copies an integer into the given SV. Does not handle 'set' magic. See +C. + +=cut +*/ + void Perl_sv_setiv(pTHX_ register SV *sv, IV i) { @@ -1292,6 +1320,14 @@ Perl_sv_setiv(pTHX_ register SV *sv, IV i) SvTAINT(sv); } +/* +=for apidoc sv_setiv_mg + +Like C, but also handles 'set' magic. + +=cut +*/ + void Perl_sv_setiv_mg(pTHX_ register SV *sv, IV i) { @@ -1299,6 +1335,15 @@ Perl_sv_setiv_mg(pTHX_ register SV *sv, IV i) SvSETMAGIC(sv); } +/* +=for apidoc sv_setuv + +Copies an unsigned integer into the given SV. Does not handle 'set' magic. +See C. + +=cut +*/ + void Perl_sv_setuv(pTHX_ register SV *sv, UV u) { @@ -1307,6 +1352,14 @@ Perl_sv_setuv(pTHX_ register SV *sv, UV u) SvUVX(sv) = u; } +/* +=for apidoc sv_setuv_mg + +Like C, but also handles 'set' magic. + +=cut +*/ + void Perl_sv_setuv_mg(pTHX_ register SV *sv, UV u) { @@ -1314,6 +1367,15 @@ Perl_sv_setuv_mg(pTHX_ register SV *sv, UV u) SvSETMAGIC(sv); } +/* +=for apidoc sv_setnv + +Copies a double into the given SV. Does not handle 'set' magic. See +C. + +=cut +*/ + void Perl_sv_setnv(pTHX_ register SV *sv, NV num) { @@ -1346,6 +1408,14 @@ Perl_sv_setnv(pTHX_ register SV *sv, NV num) SvTAINT(sv); } +/* +=for apidoc sv_setnv_mg + +Like C, but also handles 'set' magic. + +=cut +*/ + void Perl_sv_setnv_mg(pTHX_ register SV *sv, NV num) { @@ -1872,6 +1942,15 @@ S_asUV(pTHX_ SV *sv) * with a possible addition of IS_NUMBER_NEG. */ +/* +=for apidoc looks_like_number + +Test if an the content of an SV looks like a number (or is a +number). + +=cut +*/ + I32 Perl_looks_like_number(pTHX_ SV *sv) { @@ -2325,6 +2404,17 @@ Perl_sv_2bool(pTHX_ register SV *sv) * as temporary. */ +/* +=for apidoc sv_setsv + +Copies the contents of the source SV C into the destination SV C. +The source SV may be destroyed if it is mortal. Does not handle 'set' +magic. See the macro forms C, C and +C. + +=cut +*/ + void Perl_sv_setsv(pTHX_ SV *dstr, register SV *sstr) { @@ -2721,6 +2811,14 @@ Perl_sv_setsv(pTHX_ SV *dstr, register SV *sstr) SvTAINT(dstr); } +/* +=for apidoc sv_setsv_mg + +Like C, but also handles 'set' magic. + +=cut +*/ + void Perl_sv_setsv_mg(pTHX_ SV *dstr, register SV *sstr) { @@ -2728,6 +2826,15 @@ Perl_sv_setsv_mg(pTHX_ SV *dstr, register SV *sstr) SvSETMAGIC(dstr); } +/* +=for apidoc sv_setpvn + +Copies a string into an SV. The C parameter indicates the number of +bytes to be copied. Does not handle 'set' magic. See C. + +=cut +*/ + void Perl_sv_setpvn(pTHX_ register SV *sv, register const char *ptr, register STRLEN len) { @@ -2750,6 +2857,14 @@ Perl_sv_setpvn(pTHX_ register SV *sv, register const char *ptr, register STRLEN SvTAINT(sv); } +/* +=for apidoc sv_setpvn_mg + +Like C, but also handles 'set' magic. + +=cut +*/ + void Perl_sv_setpvn_mg(pTHX_ register SV *sv, register const char *ptr, register STRLEN len) { @@ -2757,6 +2872,15 @@ Perl_sv_setpvn_mg(pTHX_ register SV *sv, register const char *ptr, register STRL SvSETMAGIC(sv); } +/* +=for apidoc sv_setpv + +Copies a string into an SV. The string must be null-terminated. Does not +handle 'set' magic. See C. + +=cut +*/ + void Perl_sv_setpv(pTHX_ register SV *sv, register const char *ptr) { @@ -2777,6 +2901,14 @@ Perl_sv_setpv(pTHX_ register SV *sv, register const char *ptr) SvTAINT(sv); } +/* +=for apidoc sv_setpv_mg + +Like C, but also handles 'set' magic. + +=cut +*/ + void Perl_sv_setpv_mg(pTHX_ register SV *sv, register const char *ptr) { @@ -2784,6 +2916,20 @@ Perl_sv_setpv_mg(pTHX_ register SV *sv, register const char *ptr) SvSETMAGIC(sv); } +/* +=for apidoc sv_usepvn + +Tells an SV to use C to find its string value. Normally the string is +stored inside the SV but sv_usepvn allows the SV to use an outside string. +The C should point to memory that was allocated by C. The +string length, C, must be supplied. This function will realloc the +memory pointed to by C, so that pointer should not be freed or used by +the programmer after giving it to sv_usepvn. Does not handle 'set' magic. +See C. + +=cut +*/ + void Perl_sv_usepvn(pTHX_ register SV *sv, register char *ptr, register STRLEN len) { @@ -2805,6 +2951,14 @@ Perl_sv_usepvn(pTHX_ register SV *sv, register char *ptr, register STRLEN len) SvTAINT(sv); } +/* +=for apidoc sv_usepvn_mg + +Like C, but also handles 'set' magic. + +=cut +*/ + void Perl_sv_usepvn_mg(pTHX_ register SV *sv, register char *ptr, register STRLEN len) { @@ -2826,6 +2980,17 @@ Perl_sv_force_normal(pTHX_ register SV *sv) sv_unglob(sv); } +/* +=for apidoc sv_chop + +Efficient removal of characters from the beginning of the string buffer. +SvPOK(sv) must be true and the C must be a pointer to somewhere inside +the string buffer. The C becomes the first character of the adjusted +string. + +=cut +*/ + void Perl_sv_chop(pTHX_ register SV *sv, register char *ptr) /* like set but assuming ptr is in sv */ @@ -2858,6 +3023,16 @@ Perl_sv_chop(pTHX_ register SV *sv, register char *ptr) /* like set but assuming SvIVX(sv) += delta; } +/* +=for apidoc sv_catpvn + +Concatenates the string onto the end of the string which is in the SV. The +C indicates number of bytes to copy. Handles 'get' magic, but not +'set' magic. See C. + +=cut +*/ + void Perl_sv_catpvn(pTHX_ register SV *sv, register const char *ptr, register STRLEN len) { @@ -2875,6 +3050,14 @@ Perl_sv_catpvn(pTHX_ register SV *sv, register const char *ptr, register STRLEN SvTAINT(sv); } +/* +=for apidoc sv_catpvn_mg + +Like C, but also handles 'set' magic. + +=cut +*/ + void Perl_sv_catpvn_mg(pTHX_ register SV *sv, register const char *ptr, register STRLEN len) { @@ -2882,6 +3065,15 @@ Perl_sv_catpvn_mg(pTHX_ register SV *sv, register const char *ptr, register STRL SvSETMAGIC(sv); } +/* +=for apidoc sv_catsv + +Concatenates the string from SV C onto the end of the string in SV +C. Handles 'get' magic, but not 'set' magic. See C. + +=cut +*/ + void Perl_sv_catsv(pTHX_ SV *dstr, register SV *sstr) { @@ -2893,6 +3085,14 @@ Perl_sv_catsv(pTHX_ SV *dstr, register SV *sstr) sv_catpvn(dstr,s,len); } +/* +=for apidoc sv_catsv_mg + +Like C, but also handles 'set' magic. + +=cut +*/ + void Perl_sv_catsv_mg(pTHX_ SV *dstr, register SV *sstr) { @@ -2900,6 +3100,15 @@ Perl_sv_catsv_mg(pTHX_ SV *dstr, register SV *sstr) SvSETMAGIC(dstr); } +/* +=for apidoc sv_catpv + +Concatenates the string onto the end of the string which is in the SV. +Handles 'get' magic, but not 'set' magic. See C. + +=cut +*/ + void Perl_sv_catpv(pTHX_ register SV *sv, register const char *ptr) { @@ -2920,6 +3129,14 @@ Perl_sv_catpv(pTHX_ register SV *sv, register const char *ptr) SvTAINT(sv); } +/* +=for apidoc sv_catpv_mg + +Like C, but also handles 'set' magic. + +=cut +*/ + void Perl_sv_catpv_mg(pTHX_ register SV *sv, register const char *ptr) { @@ -2942,6 +3159,14 @@ Perl_newSV(pTHX_ STRLEN len) /* name is assumed to contain an SV* if (name && namelen == HEf_SVKEY) */ +/* +=for apidoc sv_magic + +Adds magic to an SV. + +=cut +*/ + void Perl_sv_magic(pTHX_ register SV *sv, SV *obj, int how, const char *name, I32 namlen) { @@ -3190,6 +3415,15 @@ S_sv_del_backref(pTHX_ SV *sv) } } +/* +=for apidoc sv_insert + +Inserts a string at the specified offset/length within the SV. Similar to +the Perl substr() function. + +=cut +*/ + void Perl_sv_insert(pTHX_ SV *bigstr, STRLEN offset, STRLEN len, char *little, STRLEN littlelen) { @@ -3540,6 +3774,14 @@ Perl_sv_free(pTHX_ SV *sv) del_SV(sv); } +/* +=for apidoc sv_len + +Returns the length of the string in the SV. See also C. + +=cut +*/ + STRLEN Perl_sv_len(pTHX_ register SV *sv) { @@ -3641,6 +3883,15 @@ Perl_sv_pos_b2u(pTHX_ register SV *sv, I32* offsetp) return; } +/* +=for apidoc sv_eq + +Returns a boolean indicating whether the strings in the two SVs are +identical. + +=cut +*/ + I32 Perl_sv_eq(pTHX_ register SV *str1, register SV *str2) { @@ -3667,6 +3918,16 @@ Perl_sv_eq(pTHX_ register SV *str1, register SV *str2) return memEQ(pv1, pv2, cur1); } +/* +=for apidoc sv_cmp + +Compares the strings in two SVs. Returns -1, 0, or 1 indicating whether the +string in C is less than, equal to, or greater than the string in +C. + +=cut +*/ + I32 Perl_sv_cmp(pTHX_ register SV *str1, register SV *str2) { @@ -4063,6 +4324,14 @@ screamer2: } +/* +=for apidoc sv_inc + +Auto-increment of the value in the SV. + +=cut +*/ + void Perl_sv_inc(pTHX_ register SV *sv) { @@ -4164,6 +4433,14 @@ Perl_sv_inc(pTHX_ register SV *sv) *d = d[1]; } +/* +=for apidoc sv_dec + +Auto-decrement of the value in the SV. + +=cut +*/ + void Perl_sv_dec(pTHX_ register SV *sv) { @@ -4224,6 +4501,15 @@ Perl_sv_dec(pTHX_ register SV *sv) sv_setnv(sv,Atof(SvPVX(sv)) - 1.0); /* punt */ } +/* +=for apidoc sv_mortalcopy + +Creates a new SV which is a copy of the original SV. The new SV is marked +as mortal. + +=cut +*/ + /* Make a string that will exist for the duration of the expression * evaluation. Actually, it may have to last longer than that, but * hopefully we won't free it until it has been assigned to a @@ -4243,6 +4529,14 @@ Perl_sv_mortalcopy(pTHX_ SV *oldstr) return sv; } +/* +=for apidoc sv_newmortal + +Creates a new SV which is mortal. The reference count of the SV is set to 1. + +=cut +*/ + SV * Perl_sv_newmortal(pTHX) { @@ -4256,6 +4550,15 @@ Perl_sv_newmortal(pTHX) return sv; } +/* +=for apidoc sv_2mortal + +Marks an SV as mortal. The SV will be destroyed when the current context +ends. + +=cut +*/ + /* same thing without the copying */ SV * @@ -4272,6 +4575,16 @@ Perl_sv_2mortal(pTHX_ register SV *sv) return sv; } +/* +=for apidoc newSVpv + +Creates a new SV and copies a string into it. The reference count for the +SV is set to 1. If C is zero, Perl will compute the length using +strlen(). For efficiency, consider using C instead. + +=cut +*/ + SV * Perl_newSVpv(pTHX_ const char *s, STRLEN len) { @@ -4284,6 +4597,17 @@ Perl_newSVpv(pTHX_ const char *s, STRLEN len) return sv; } +/* +=for apidoc newSVpvn + +Creates a new SV and copies a string into it. The reference count for the +SV is set to 1. Note that if C is zero, Perl will create a zero length +string. You are responsible for ensuring that the source string is at least +C bytes long. + +=cut +*/ + SV * Perl_newSVpvn(pTHX_ const char *s, STRLEN len) { @@ -4308,6 +4632,15 @@ Perl_newSVpvf_nocontext(const char* pat, ...) } #endif +/* +=for apidoc newSVpvf + +Creates a new SV an initialize it with the string formatted like +C. + +=cut +*/ + SV * Perl_newSVpvf(pTHX_ const char* pat, ...) { @@ -4328,6 +4661,15 @@ Perl_vnewSVpvf(pTHX_ const char* pat, va_list* args) return sv; } +/* +=for apidoc newSVnv + +Creates a new SV and copies a floating point value into it. +The reference count for the SV is set to 1. + +=cut +*/ + SV * Perl_newSVnv(pTHX_ NV n) { @@ -4338,6 +4680,15 @@ Perl_newSVnv(pTHX_ NV n) return sv; } +/* +=for apidoc newSViv + +Creates a new SV and copies an integer into it. The reference count for the +SV is set to 1. + +=cut +*/ + SV * Perl_newSViv(pTHX_ IV i) { @@ -4348,6 +4699,15 @@ Perl_newSViv(pTHX_ IV i) return sv; } +/* +=for apidoc newRV_noinc + +Creates an RV wrapper for an SV. The reference count for the original +SV is B incremented. + +=cut +*/ + SV * Perl_newRV_noinc(pTHX_ SV *tmpRef) { @@ -4362,12 +4722,21 @@ Perl_newRV_noinc(pTHX_ SV *tmpRef) return sv; } +/* newRV_inc is #defined to newRV in sv.h */ SV * Perl_newRV(pTHX_ SV *tmpRef) { return newRV_noinc(SvREFCNT_inc(tmpRef)); } +/* +=for apidoc newSVsv + +Creates a new SV which is an exact duplicate of the original SV. + +=cut +*/ + /* make an exact duplicate of old */ SV * @@ -4758,6 +5127,16 @@ Perl_sv_reftype(pTHX_ SV *sv, int ob) } } +/* +=for apidoc sv_isobject + +Returns a boolean indicating whether the SV is an RV pointing to a blessed +object. If the SV is not an RV, or if the object is not blessed, then this +will return false. + +=cut +*/ + int Perl_sv_isobject(pTHX_ SV *sv) { @@ -4773,6 +5152,16 @@ Perl_sv_isobject(pTHX_ SV *sv) return 1; } +/* +=for apidoc sv_isa + +Returns a boolean indicating whether the SV is blessed into the specified +class. This does not check for subtypes; use C to verify +an inheritance relationship. + +=cut +*/ + int Perl_sv_isa(pTHX_ SV *sv, const char *name) { @@ -4789,6 +5178,17 @@ Perl_sv_isa(pTHX_ SV *sv, const char *name) return strEQ(HvNAME(SvSTASH(sv)), name); } +/* +=for apidoc newSVrv + +Creates a new SV for the RV, C, to point to. If C is not an RV then +it will be upgraded to one. If C is non-null then the new SV will +be blessed in the specified package. The new SV is returned and its +reference count is 1. + +=cut +*/ + SV* Perl_newSVrv(pTHX_ SV *rv, const char *classname) { @@ -4814,6 +5214,24 @@ Perl_newSVrv(pTHX_ SV *rv, const char *classname) return sv; } +/* +=for apidoc sv_setref_pv + +Copies a pointer into a new SV, optionally blessing the SV. The C +argument will be upgraded to an RV. That RV will be modified to point to +the new SV. If the C argument is NULL then C will be placed +into the SV. The C argument indicates the package for the +blessing. Set C to C to avoid the blessing. The new SV +will be returned and will have a reference count of 1. + +Do not use with other Perl types such as HV, AV, SV, CV, because those +objects will become corrupted by the pointer copy process. + +Note that C copies the string while this copies the pointer. + +=cut +*/ + SV* Perl_sv_setref_pv(pTHX_ SV *rv, const char *classname, void *pv) { @@ -4826,6 +5244,18 @@ Perl_sv_setref_pv(pTHX_ SV *rv, const char *classname, void *pv) return rv; } +/* +=for apidoc sv_setref_iv + +Copies an integer into a new SV, optionally blessing the SV. The C +argument will be upgraded to an RV. That RV will be modified to point to +the new SV. The C argument indicates the package for the +blessing. Set C to C to avoid the blessing. The new SV +will be returned and will have a reference count of 1. + +=cut +*/ + SV* Perl_sv_setref_iv(pTHX_ SV *rv, const char *classname, IV iv) { @@ -4833,6 +5263,18 @@ Perl_sv_setref_iv(pTHX_ SV *rv, const char *classname, IV iv) return rv; } +/* +=for apidoc sv_setref_nv + +Copies a double into a new SV, optionally blessing the SV. The C +argument will be upgraded to an RV. That RV will be modified to point to +the new SV. The C argument indicates the package for the +blessing. Set C to C to avoid the blessing. The new SV +will be returned and will have a reference count of 1. + +=cut +*/ + SV* Perl_sv_setref_nv(pTHX_ SV *rv, const char *classname, NV nv) { @@ -4840,6 +5282,21 @@ Perl_sv_setref_nv(pTHX_ SV *rv, const char *classname, NV nv) return rv; } +/* +=for apidoc sv_setref_pvn + +Copies a string into a new SV, optionally blessing the SV. The length of the +string must be specified with C. The C argument will be upgraded to +an RV. That RV will be modified to point to the new SV. The C +argument indicates the package for the blessing. Set C to +C to avoid the blessing. The new SV will be returned and will have +a reference count of 1. + +Note that C copies the pointer while this copies the string. + +=cut +*/ + SV* Perl_sv_setref_pvn(pTHX_ SV *rv, const char *classname, char *pv, STRLEN n) { @@ -4847,6 +5304,16 @@ Perl_sv_setref_pvn(pTHX_ SV *rv, const char *classname, char *pv, STRLEN n) return rv; } +/* +=for apidoc sv_bless + +Blesses an SV into a specified package. The SV must be an RV. The package +must be designated by its stash (see C). The reference count +of the SV is unaffected. + +=cut +*/ + SV* Perl_sv_bless(pTHX_ SV *sv, HV *stash) { @@ -4896,6 +5363,16 @@ S_sv_unglob(pTHX_ SV *sv) SvFLAGS(sv) |= SVt_PVMG; } +/* +=for apidoc sv_unref + +Unsets the RV status of the SV, and decrements the reference count of +whatever was being referenced by the RV. This can almost be thought of +as a reversal of C. See C. + +=cut +*/ + void Perl_sv_unref(pTHX_ SV *sv) { @@ -4942,6 +5419,15 @@ Perl_sv_tainted(pTHX_ SV *sv) return FALSE; } +/* +=for apidoc sv_setpviv + +Copies an integer into the given SV, also updating its string value. +Does not handle 'set' magic. See C. + +=cut +*/ + void Perl_sv_setpviv(pTHX_ SV *sv, IV iv) { @@ -4953,6 +5439,14 @@ Perl_sv_setpviv(pTHX_ SV *sv, IV iv) } +/* +=for apidoc sv_setpviv_mg + +Like C, but also handles 'set' magic. + +=cut +*/ + void Perl_sv_setpviv_mg(pTHX_ SV *sv, IV iv) { @@ -4987,6 +5481,15 @@ Perl_sv_setpvf_mg_nocontext(SV *sv, const char* pat, ...) } #endif +/* +=for apidoc sv_setpvf + +Processes its arguments like C and sets an SV to the formatted +output. Does not handle 'set' magic. See C. + +=cut +*/ + void Perl_sv_setpvf(pTHX_ SV *sv, const char* pat, ...) { @@ -5002,6 +5505,14 @@ Perl_sv_vsetpvf(pTHX_ SV *sv, const char* pat, va_list* args) sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); } +/* +=for apidoc sv_setpvf_mg + +Like C, but also handles 'set' magic. + +=cut +*/ + void Perl_sv_setpvf_mg(pTHX_ SV *sv, const char* pat, ...) { @@ -5040,6 +5551,16 @@ Perl_sv_catpvf_mg_nocontext(SV *sv, const char* pat, ...) } #endif +/* +=for apidoc sv_catpvf + +Processes its arguments like C and appends the formatted output +to an SV. Handles 'get' magic, but not 'set' magic. C must +typically be called after calling this function to handle 'set' magic. + +=cut +*/ + void Perl_sv_catpvf(pTHX_ SV *sv, const char* pat, ...) { @@ -5055,6 +5576,14 @@ Perl_sv_vcatpvf(pTHX_ SV *sv, const char* pat, va_list* args) sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); } +/* +=for apidoc sv_catpvf_mg + +Like C, but also handles 'set' magic. + +=cut +*/ + void Perl_sv_catpvf_mg(pTHX_ SV *sv, const char* pat, ...) { @@ -5071,6 +5600,15 @@ Perl_sv_vcatpvf_mg(pTHX_ SV *sv, const char* pat, va_list* args) SvSETMAGIC(sv); } +/* +=for apidoc sv_vsetpvfn + +Works like C but copies the text into the SV instead of +appending it. + +=cut +*/ + void Perl_sv_vsetpvfn(pTHX_ SV *sv, const char *pat, STRLEN patlen, va_list *args, SV **svargs, I32 svmax, bool *maybe_tainted) { @@ -5078,6 +5616,18 @@ Perl_sv_vsetpvfn(pTHX_ SV *sv, const char *pat, STRLEN patlen, va_list *args, SV sv_vcatpvfn(sv, pat, patlen, args, svargs, svmax, maybe_tainted); } +/* +=for apidoc sv_vcatpvfn + +Processes its arguments like C and appends the formatted output +to an SV. Uses an array of SVs if the C style variable argument list is +missing (NULL). When running with taint checks enabled, indicates via +C if results are untrustworthy (often due to the use of +locales). + +=cut +*/ + void Perl_sv_vcatpvfn(pTHX_ SV *sv, const char *pat, STRLEN patlen, va_list *args, SV **svargs, I32 svmax, bool *maybe_tainted) { diff --git a/sv.h b/sv.h index eea984a..91fd17b 100644 --- a/sv.h +++ b/sv.h @@ -11,6 +11,35 @@ #undef sv_flags /* Convex has this in for sigvec() */ #endif +/* +=for apidoc AmU||svtype +An enum of flags for Perl types. These are found in the file B +in the C enum. Test these flags with the C macro. + +=for apidoc AmU||SVt_PV +Pointer type flag for scalars. See C. + +=for apidoc AmU||SVt_IV +Integer type flag for scalars. See C. + +=for apidoc AmU||SVt_NV +Double type flag for scalars. See C. + +=for apidoc AmU||SVt_PVMG +Type flag for blessed scalars. See C. + +=for apidoc AmU||SVt_PVAV +Type flag for arrays. See C. + +=for apidoc AmU||SVt_PVHV +Type flag for hashes. See C. + +=for apidoc AmU||SVt_PVCV +Type flag for code refs. See C. + +=cut +*/ + typedef enum { SVt_NULL, /* 0 */ SVt_IV, /* 1 */ @@ -68,6 +97,26 @@ struct io { U32 sv_flags; /* what we are */ }; +/* +=for apidoc Am|U32|SvREFCNT|SV* sv +Returns the value of the object's reference count. + +=for apidoc Am|SV*|SvREFCNT_inc|SV* sv +Increments the reference count of the given SV. + +=for apidoc Am|void|SvREFCNT_dec|SV* sv +Decrements the reference count of the given SV. + +=for apidoc Am|svtype|SvTYPE|SV* sv +Returns the type of the SV. See C. + +=for apidoc Am|void|SvUPGRADE|SV* sv|svtype type +Used to upgrade an SV to a more complex form. Uses C to +perform the upgrade if necessary. See C. + +=cut +*/ + #define SvANY(sv) (sv)->sv_any #define SvFLAGS(sv) (sv)->sv_flags #define SvREFCNT(sv) (sv)->sv_refcnt @@ -330,6 +379,123 @@ struct xpvio { /* The following macros define implementation-independent predicates on SVs. */ +/* +=for apidoc Am|bool|SvNIOK|SV* sv +Returns a boolean indicating whether the SV contains a number, integer or +double. + +=for apidoc Am|bool|SvNIOKp|SV* sv +Returns a boolean indicating whether the SV contains a number, integer or +double. Checks the B setting. Use C. + +=for apidoc Am|void|SvNIOK_off|SV* sv +Unsets the NV/IV status of an SV. + +=for apidoc Am|bool|SvOK|SV* sv +Returns a boolean indicating whether the value is an SV. + +=for apidoc Am|bool|SvIOKp|SV* sv +Returns a boolean indicating whether the SV contains an integer. Checks +the B setting. Use C. + +=for apidoc Am|bool|SvNOKp|SV* sv +Returns a boolean indicating whether the SV contains a double. Checks the +B setting. Use C. + +=for apidoc Am|bool|SvPOKp|SV* sv +Returns a boolean indicating whether the SV contains a character string. +Checks the B setting. Use C. + +=for apidoc Am|bool|SvIOK|SV* sv +Returns a boolean indicating whether the SV contains an integer. + +=for apidoc Am|void|SvIOK_on|SV* sv +Tells an SV that it is an integer. + +=for apidoc Am|void|SvIOK_off|SV* sv +Unsets the IV status of an SV. + +=for apidoc Am|void|SvIOK_only|SV* sv +Tells an SV that it is an integer and disables all other OK bits. + +=for apidoc Am|bool|SvNOK|SV* sv +Returns a boolean indicating whether the SV contains a double. + +=for apidoc Am|void|SvNOK_on|SV* sv +Tells an SV that it is a double. + +=for apidoc Am|void|SvNOK_off|SV* sv +Unsets the NV status of an SV. + +=for apidoc Am|void|SvNOK_only|SV* sv +Tells an SV that it is a double and disables all other OK bits. + +=for apidoc Am|bool|SvPOK|SV* sv +Returns a boolean indicating whether the SV contains a character +string. + +=for apidoc Am|void|SvPOK_on|SV* sv +Tells an SV that it is a string. + +=for apidoc Am|void|SvPOK_off|SV* sv +Unsets the PV status of an SV. + +=for apidoc Am|void|SvPOK_only|SV* sv +Tells an SV that it is a string and disables all other OK bits. + +=for apidoc Am|bool|SvOOK|SV* sv +Returns a boolean indicating whether the SvIVX is a valid offset value for +the SvPVX. This hack is used internally to speed up removal of characters +from the beginning of a SvPV. When SvOOK is true, then the start of the +allocated string buffer is really (SvPVX - SvIVX). + +=for apidoc Am|bool|SvROK|SV* sv +Tests if the SV is an RV. + +=for apidoc Am|void|SvROK_on|SV* sv +Tells an SV that it is an RV. + +=for apidoc Am|void|SvROK_off|SV* sv +Unsets the RV status of an SV. + +=for apidoc Am|SV*|SvRV|SV* sv +Dereferences an RV to return the SV. + +=for apidoc Am|IV|SvIVX|SV* sv +Returns the integer which is stored in the SV, assuming SvIOK is +true. + +=for apidoc Am|UV|SvUVX|SV* sv +Returns the unsigned integer which is stored in the SV, assuming SvIOK is +true. + +=for apidoc Am|NV|SvNVX|SV* sv +Returns the double which is stored in the SV, assuming SvNOK is +true. + +=for apidoc Am|char*|SvPVX|SV* sv +Returns a pointer to the string in the SV. The SV must contain a +string. + +=for apidoc Am|STRLEN|SvCUR|SV* sv +Returns the length of the string which is in the SV. See C. + +=for apidoc Am|STRLEN|SvLEN|SV* sv +Returns the size of the string buffer in the SV. See C. + +=for apidoc Am|char*|SvEND|SV* sv +Returns a pointer to the last character in the string which is in the SV. +See C. Access the character as *(SvEND(sv)). + +=for apidoc Am|HV*|SvSTASH|SV* sv +Returns the stash of the SV. + +=for apidoc Am|void|SvCUR_set|SV* sv|STRLEN len +Set the length of the string which is in the SV. See C. + +=cut +*/ + #define SvNIOK(sv) (SvFLAGS(sv) & (SVf_IOK|SVf_NOK)) #define SvNIOKp(sv) (SvFLAGS(sv) & (SVp_IOK|SVp_NOK)) #define SvNIOK_off(sv) (SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK| \ @@ -537,6 +703,28 @@ struct xpvio { #define IoTYPE(sv) ((XPVIO*) SvANY(sv))->xio_type #define IoFLAGS(sv) ((XPVIO*) SvANY(sv))->xio_flags +/* +=for apidoc Am|bool|SvTAINTED|SV* sv +Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if +not. + +=for apidoc Am|void|SvTAINTED_on|SV* sv +Marks an SV as tainted. + +=for apidoc Am|void|SvTAINTED_off|SV* sv +Untaints an SV. Be I careful with this routine, as it short-circuits +some of Perl's fundamental security features. XS module authors should not +use this function unless they fully understand all the implications of +unconditionally untainting the value. Untainting should be done in the +standard perl fashion, via a carefully crafted regexp, rather than directly +untainting variables. + +=for apidoc Am|void|SvTAINT|SV* sv +Taints an SV if tainting is enabled + +=cut +*/ + #define SvTAINTED(sv) (SvMAGICAL(sv) && sv_tainted(sv)) #define SvTAINTED_on(sv) STMT_START{ if(PL_tainting){sv_taint(sv);} }STMT_END #define SvTAINTED_off(sv) STMT_START{ if(PL_tainting){sv_untaint(sv);} }STMT_END @@ -550,6 +738,35 @@ struct xpvio { } \ } STMT_END +/* +=for apidoc Am|char*|SvPV_force|SV* sv|STRLEN len +Like but will force the SV into becoming a string (SvPOK). You want +force if you are going to update the SvPVX directly. + +=for apidoc Am|char*|SvPV|SV* sv|STRLEN len +Returns a pointer to the string in the SV, or a stringified form of the SV +if the SV does not contain a string. Handles 'get' magic. + +=for apidoc Am|char*|SvPV_nolen|SV* sv +Returns a pointer to the string in the SV, or a stringified form of the SV +if the SV does not contain a string. Handles 'get' magic. + +=for apidoc Am|IV|SvIV|SV* sv +Coerces the given SV to an integer and returns it. + +=for apidoc Am|NV|SvNV|SV* sv +Coerce the given SV to a double and return it. + +=for apidoc Am|UV|SvUV|SV* sv +Coerces the given SV to an unsigned integer and returns it. + +=for apidoc Am|bool|SvTRUE|SV* sv +Returns a boolean indicating whether Perl would evaluate the SV as true or +false, defined or undefined. Does not handle 'get' magic. + +=cut +*/ + #define SvPV_force(sv, lp) sv_pvn_force(sv, &lp) #define SvPV(sv, lp) sv_pvn(sv, &lp) #define SvPV_nolen(sv) sv_pv(sv) @@ -726,10 +943,45 @@ struct xpvio { #endif /* !__GNU__ */ #endif /* !CRIPPLED_CC */ +/* +=for apidoc Am|SV*|newRV_inc|SV* sv + +Creates an RV wrapper for an SV. The reference count for the original SV is +incremented. + +=cut +*/ + #define newRV_inc(sv) newRV(sv) /* the following macros update any magic values this sv is associated with */ +/* +=for apidoc Am|void|SvGETMAGIC|SV* sv +Invokes C on an SV if it has 'get' magic. This macro evaluates its +argument more than once. + +=for apidoc Am|void|SvSETMAGIC|SV* sv +Invokes C on an SV if it has 'set' magic. This macro evaluates its +argument more than once. + +=for apidoc Am|void|SvSetSV|SV* dsb|SV* ssv +Calls C if dsv is not the same as ssv. May evaluate arguments +more than once. + +=for apidoc Am|void|SvSetSV_nosteal|SV* dsv|SV* ssv +Calls a non-destructive version of C if dsv is not the same as +ssv. May evaluate arguments more than once. + +=for apidoc Am|void|SvGROW|SV* sv|STRLEN len +Expands the character buffer in the SV so that it has room for the +indicated number of bytes (remember to reserve space for an extra trailing +NUL character). Calls C to perform the expansion if necessary. +Returns a pointer to the character buffer. + +=cut +*/ + #define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END #define SvSETMAGIC(x) STMT_START { if (SvSMAGICAL(x)) mg_set(x); } STMT_END diff --git a/thrdvar.h b/thrdvar.h index d228ee2..814842c 100644 --- a/thrdvar.h +++ b/thrdvar.h @@ -56,6 +56,18 @@ PERLVAR(Tretstack_max, I32) PERLVAR(TSv, SV *) /* used to hold temporary values */ PERLVAR(TXpv, XPV *) /* used to hold temporary values */ + +/* +=for apidoc Amn|STRLEN|PL_na + +A convenience variable which is typically used with C when one +doesn't care about the length of the string. It is usually more efficient +to either declare a local variable and use that instead or to use the +C macro. + +=cut +*/ + PERLVAR(Tna, STRLEN) /* for use in SvPV when length is Not Applicable */ diff --git a/universal.c b/universal.c index aa5487f..1e5a1a0 100644 --- a/universal.c +++ b/universal.c @@ -73,6 +73,16 @@ S_isa_lookup(pTHX_ HV *stash, const char *name, int len, int level) return boolSV(strEQ(name, "UNIVERSAL")); } +/* +=for apidoc sv_derived_from + +Returns a boolean indicating whether the SV is derived from the specified +class. This is the function that implements C. It works +for class names as well as for objects. + +=cut +*/ + bool Perl_sv_derived_from(pTHX_ SV *sv, const char *name) { diff --git a/util.c b/util.c index 09fa027..13b0010 100644 --- a/util.c +++ b/util.c @@ -912,6 +912,15 @@ Perl_mem_collxfrm(pTHX_ const char *s, STRLEN len, STRLEN *xlen) If FBMcf_TAIL, the table is created as if the string has a trailing \n. */ +/* +=for apidoc fbm_compile + +Analyses the string in order to make fast searches on it using fbm_instr() +-- the Boyer-Moore algorithm. + +=cut +*/ + void Perl_fbm_compile(pTHX_ SV *sv, U32 flags) { @@ -972,6 +981,17 @@ Perl_fbm_compile(pTHX_ SV *sv, U32 flags) /* If SvTAIL is actually due to \Z or \z, this gives false positives if multiline */ +/* +=for apidoc fbm_instr + +Returns the location of the SV in the string delimited by C and +C. It returns C if the string can't be found. The C +does not have to be fbm_compiled, but the search will not be as fast +then. + +=cut +*/ + char * Perl_fbm_instr(pTHX_ unsigned char *big, register unsigned char *bigend, SV *littlestr, U32 flags) { @@ -1304,6 +1324,14 @@ Perl_ibcmp_locale(pTHX_ const char *s1, const char *s2, register I32 len) /* copy a string to a safe spot */ +/* +=for apidoc savepv + +Copy a string to a safe spot. This does not use an SV. + +=cut +*/ + char * Perl_savepv(pTHX_ const char *sv) { @@ -1316,6 +1344,15 @@ Perl_savepv(pTHX_ const char *sv) /* same thing but with a known length */ +/* +=for apidoc savepvn + +Copy a string to a safe spot. The C indicates number of bytes to +copy. This does not use an SV. + +=cut +*/ + char * Perl_savepvn(pTHX_ const char *sv, register I32 len) { @@ -1620,6 +1657,16 @@ Perl_croak_nocontext(const char *pat, ...) } #endif /* PERL_IMPLICIT_CONTEXT */ +/* +=for apidoc croak + +This is the XSUB-writer's interface to Perl's C function. Use this +function the same way you use the C C function. See +C. + +=cut +*/ + void Perl_croak(pTHX_ const char *pat, ...) { @@ -1699,6 +1746,16 @@ Perl_warn_nocontext(const char *pat, ...) } #endif /* PERL_IMPLICIT_CONTEXT */ +/* +=for apidoc warn + +This is the XSUB-writer's interface to Perl's C function. Use this +function the same way you use the C C function. See +C. + +=cut +*/ + void Perl_warn(pTHX_ const char *pat, ...) { -- 2.7.4