• TemplateToolkit2
• Catalyst
• AWStats
• 

• NAME
• DESCRIPTION
• ``Gimme'' Values
• Array Manipulation Functions
• Callback Functions
• Character classes
• Cloning an interpreter
• CV Manipulation Functions
• Embedding Functions
• Functions in file pp_pack.c
• Global Variables
• GV Functions
• Handy Values
• Hash Manipulation Functions
• Magical Functions
• Memory Management
• Miscellaneous Functions
• Numeric functions
• Optree Manipulation Functions
• Pad Data Structures
• Stack Manipulation Macros
• SV Flags
• SV Manipulation Functions
• Unicode Support
• Variables created by xsubpp and xsubpp internal functions
• Warning and Dieing
• AUTHORS
• SEE ALSO

---

NAME

perlapi - autogenerated documentation for the perl public API

voltar para o topo

---

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 PL_ 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.

voltar para o topo

---

``Gimme'' Values

GIMME

A backward-compatible version of GIMME_V which can only return

G_SCALAR or G_ARRAY; in a void context, it returns G_SCALAR.

Deprecated. Use GIMME_V instead.

        U32     GIMME

Found in file op.h

GIMME_V

The XSUB-writer's equivalent to Perl's wantarray. Returns G_VOID,

G_SCALAR or G_ARRAY for void, scalar or list context,

respectively.

        U32     GIMME_V

Found in file op.h

G_ARRAY

Used to indicate list context. See GIMME_V, GIMME and

the perlcall manpage.

Found in file cop.h

G_DISCARD

Indicates that arguments returned from a callback should be discarded. See

the perlcall manpage.

Found in file cop.h

G_EVAL

Used to force a Perl eval wrapper around a callback. See

the perlcall manpage.

Found in file cop.h

G_NOARGS

Indicates that no arguments are being sent to a callback. See

the perlcall manpage.

Found in file cop.h

G_SCALAR

Used to indicate scalar context. See GIMME_V, GIMME, and

the perlcall manpage.

Found in file cop.h

G_VOID

Used to indicate void context. See GIMME_V and the perlcall manpage.

Found in file cop.h

voltar para o topo

---

Array Manipulation Functions

AvFILL

Same as av_len(). Deprecated, use av_len() instead.

        int     AvFILL(AV* av)

Found in file av.h

av_clear

Clears an array, making it empty. Does not free the memory used by the

array itself.

        void    av_clear(AV* ar)

Found in file av.c

av_delete

Deletes the element indexed by key from the array. Returns the

deleted element. If flags equals G_DISCARD, the element is freed

and null is returned.

        SV*     av_delete(AV* ar, I32 key, I32 flags)

Found in file av.c

av_exists

Returns true if the element indexed by key has been initialized.

This relies on the fact that uninitialized array elements are set to

&PL_sv_undef.

        bool    av_exists(AV* ar, I32 key)

Found in file av.c

av_extend

Pre-extend an array. The key is the index to which the array should be

extended.

        void    av_extend(AV* ar, I32 key)

Found in file av.c

av_fetch

Returns the SV at the specified index in the array. The key is the

index. If lval is set then the fetch will be part of a store. Check

that the return value is non-null before dereferencing it to a SV*.

See Understanding the Magic of Tied Hashes and Arrays in the perlguts manpage for

more information on how to use this function on tied arrays.

        SV**    av_fetch(AV* ar, I32 key, I32 lval)

Found in file av.c

av_fill

Ensure than an array has a given number of elements, equivalent to

Perl's $#array = $fill;.

        void    av_fill(AV* ar, I32 fill)

Found in file av.c

av_len

Returns the highest index in the array. Returns -1 if the array is

empty.

        I32     av_len(AV* ar)

Found in file av.c

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)

Found in file av.c

av_pop

Pops an SV off the end of the array. Returns &PL_sv_undef if the array

is empty.

        SV*     av_pop(AV* ar)

Found in file av.c

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)

Found in file av.c

av_shift

Shifts an SV off the beginning of the array.

        SV*     av_shift(AV* ar)

Found in file av.c

av_store

Stores an SV in an array. The array index is specified as key. 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 SV*. Note

that the caller is responsible for suitably incrementing the reference

count of val before the call, and decrementing it if the function

returned NULL.

See Understanding the Magic of Tied Hashes and Arrays in the perlguts manpage for

more information on how to use this function on tied arrays.

        SV**    av_store(AV* ar, I32 key, SV* val)

Found in file av.c

av_undef

Undefines the array. Frees the memory used by the array itself.

        void    av_undef(AV* ar)

Found in file av.c

av_unshift

Unshift the given number of undef values onto the beginning of the

array. The array will grow automatically to accommodate the addition. You

must then use av_store to assign values to these new elements.

        void    av_unshift(AV* ar, I32 num)

Found in file av.c

get_av

Returns the AV of the specified Perl array. If create is set and the

Perl variable does not exist then it will be created. If create 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)

Found in file perl.c

newAV

Creates a new AV. The reference count is set to 1.

        AV*     newAV()

Found in file av.c

sortsv

Sort an array. Here is an example:

    sortsv(AvARRAY(av), av_len(av)+1, Perl_sv_cmp_locale);

See lib/sort.pm for details about controlling the sorting algorithm.

        void    sortsv(SV ** array, size_t num_elts, SVCOMPARE_t cmp)

Found in file pp_sort.c

voltar para o topo

---

Callback Functions

call_argv

Performs a callback to the specified Perl sub. See the perlcall manpage.

NOTE: the perl_ form of this function is deprecated.

        I32     call_argv(const char* sub_name, I32 flags, char** argv)

Found in file perl.c

call_method

Performs a callback to the specified Perl method. The blessed object must

be on the stack. See the perlcall manpage.

NOTE: the perl_ form of this function is deprecated.

        I32     call_method(const char* methname, I32 flags)

Found in file perl.c

call_pv

Performs a callback to the specified Perl sub. See the perlcall manpage.

NOTE: the perl_ form of this function is deprecated.

        I32     call_pv(const char* sub_name, I32 flags)

Found in file perl.c

call_sv

Performs a callback to the Perl sub whose name is in the SV. See

the perlcall manpage.

NOTE: the perl_ form of this function is deprecated.

        I32     call_sv(SV* sv, I32 flags)

Found in file perl.c

ENTER

Opening bracket on a callback. See LEAVE and the perlcall manpage.

                ENTER;

Found in file scope.h

eval_pv

Tells Perl to eval 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)

Found in file perl.c

eval_sv

Tells Perl to eval the string in the SV.

NOTE: the perl_ form of this function is deprecated.

        I32     eval_sv(SV* sv, I32 flags)

Found in file perl.c

FREETMPS

Closing bracket for temporaries on a callback. See SAVETMPS and

the perlcall manpage.

                FREETMPS;

Found in file scope.h

LEAVE

Closing bracket on a callback. See ENTER and the perlcall manpage.

                LEAVE;

Found in file scope.h

SAVETMPS

Opening bracket for temporaries on a callback. See FREETMPS and

the perlcall manpage.

                SAVETMPS;

Found in file scope.h

voltar para o topo

---

Character classes

isALNUM

Returns a boolean indicating whether the C char is an ASCII alphanumeric

character (including underscore) or digit.

        bool    isALNUM(char ch)

Found in file handy.h

isALPHA

Returns a boolean indicating whether the C char is an ASCII alphabetic

character.

        bool    isALPHA(char ch)

Found in file handy.h

isDIGIT

Returns a boolean indicating whether the C char is an ASCII

digit.

        bool    isDIGIT(char ch)

Found in file handy.h

isLOWER

Returns a boolean indicating whether the C char is a lowercase

character.

        bool    isLOWER(char ch)

Found in file handy.h

isSPACE

Returns a boolean indicating whether the C char is whitespace.

        bool    isSPACE(char ch)

Found in file handy.h

isUPPER

Returns a boolean indicating whether the C char is an uppercase

character.

        bool    isUPPER(char ch)

Found in file handy.h

toLOWER

Converts the specified character to lowercase.

        char    toLOWER(char ch)

Found in file handy.h

toUPPER

Converts the specified character to uppercase.

        char    toUPPER(char ch)

Found in file handy.h

voltar para o topo

---

Cloning an interpreter

perl_clone

Create and return a new interpreter by cloning the current one.

perl_clone takes these flags as parameters:

CLONEf_COPY_STACKS - is used to, well, copy the stacks also,

without it we only clone the data and zero the stacks,

with it we copy the stacks and the new perl interpreter is

ready to run at the exact same point as the previous one.

The pseudo-fork code uses COPY_STACKS while the

threads->new doesn't.

CLONEf_KEEP_PTR_TABLE

perl_clone keeps a ptr_table with the pointer of the old

variable as a key and the new variable as a value,

this allows it to check if something has been cloned and not

clone it again but rather just use the value and increase the

refcount. If KEEP_PTR_TABLE is not set then perl_clone will kill

the ptr_table using the function

ptr_table_free(PL_ptr_table); PL_ptr_table = NULL;,

reason to keep it around is if you want to dup some of your own

variable who are outside the graph perl scans, example of this

code is in threads.xs create

CLONEf_CLONE_HOST

This is a win32 thing, it is ignored on unix, it tells perls

win32host code (which is c++) to clone itself, this is needed on

win32 if you want to run two threads at the same time,

if you just want to do some stuff in a separate perl interpreter

and then throw it away and return to the original one,

you don't need to do anything.

        PerlInterpreter*        perl_clone(PerlInterpreter* interp, UV flags)

Found in file sv.c

voltar para o topo

---

CV Manipulation Functions

CvSTASH

Returns the stash of the CV.

        HV*     CvSTASH(CV* cv)

Found in file cv.h

get_cv

Returns the CV of the specified Perl subroutine. If create is set and

the Perl subroutine does not exist then it will be declared (which has the

same effect as saying sub name;). If create 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)

Found in file perl.c

voltar para o topo

---

Embedding Functions

cv_undef

Clear out all the active components of a CV. This can happen either

by an explicit undef &foo, or by the reference count going to zero.

In the former case, we keep the CvOUTSIDE? pointer, so that any anonymous

children can still follow the full lexical scope chain.

        void    cv_undef(CV* cv)

Found in file op.c

load_module

Loads the module whose name is pointed to by the string part of name.

Note that the actual module name, not its filename, should be given.

Eg, ``Foo::Bar'' instead of ``Foo/Bar.pm''. flags can be any of

PERL_LOADMOD_DENY, PERL_LOADMOD_NOIMPORT, or PERL_LOADMOD_IMPORT_OPS

(or 0 for no flags). ver, if specified, provides version semantics

similar to use Foo::Bar VERSION. The optional trailing SV*

arguments can be used to specify arguments to the module's import()

method, similar to use Foo::Bar VERSION LIST.

        void    load_module(U32 flags, SV* name, SV* ver, ...)

Found in file op.c

nothreadhook

Stub that provides thread hook for perl_destruct when there are

no threads.

        int     nothreadhook()

Found in file perl.c

perl_alloc

Allocates a new Perl interpreter. See the perlembed manpage.

        PerlInterpreter*        perl_alloc()

Found in file perl.c

perl_construct

Initializes a new Perl interpreter. See the perlembed manpage.

        void    perl_construct(PerlInterpreter* interp)

Found in file perl.c

perl_destruct

Shuts down a Perl interpreter. See the perlembed manpage.

        int     perl_destruct(PerlInterpreter* interp)

Found in file perl.c

perl_free

Releases a Perl interpreter. See the perlembed manpage.

        void    perl_free(PerlInterpreter* interp)

Found in file perl.c

perl_parse

Tells a Perl interpreter to parse a Perl script. See the perlembed manpage.

        int     perl_parse(PerlInterpreter* interp, XSINIT_t xsinit, int argc, char** argv, char** env)

Found in file perl.c

perl_run

Tells a Perl interpreter to run. See the perlembed manpage.

        int     perl_run(PerlInterpreter* interp)

Found in file perl.c

require_pv

Tells Perl to require the file named by the string argument. It is

analogous to the Perl code eval "require '$file'". It's even

implemented that way; consider using load_module instead.

NOTE: the perl_ form of this function is deprecated.

        void    require_pv(const char* pv)

Found in file perl.c

voltar para o topo

---

Functions in file pp_pack.c

packlist

The engine implementing pack() Perl function.

        void    packlist(SV *cat, char *pat, char *patend, SV **beglist, SV **endlist)

Found in file pp_pack.c

pack_cat

The engine implementing pack() Perl function. Note: parameters next_in_list and

flags are not used. This call should not be used; use packlist instead.

        void    pack_cat(SV *cat, char *pat, char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)

Found in file pp_pack.c

unpackstring

The engine implementing unpack() Perl function. unpackstring puts the

extracted list items on the stack and returns the number of elements.

Issue PUTBACK before and SPAGAIN after the call to this function.

        I32     unpackstring(char *pat, char *patend, char *s, char *strend, U32 flags)

Found in file pp_pack.c

unpack_str

The engine implementing unpack() Perl function. Note: parameters strbeg, new_s

and ocnt are not used. This call should not be used, use unpackstring instead.

        I32     unpack_str(char *pat, char *patend, char *s, char *strbeg, char *strend, char **new_s, I32 ocnt, U32 flags)

Found in file pp_pack.c

voltar para o topo

---

Global Variables

PL_modglobal

PL_modglobal 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

Found in file intrpvar.h

PL_na

A convenience variable which is typically used with SvPV 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

SvPV_nolen macro.

        STRLEN  PL_na

Found in file thrdvar.h

PL_sv_no

This is the false SV. See PL_sv_yes. Always refer to this as

&PL_sv_no.

        SV      PL_sv_no

Found in file intrpvar.h

PL_sv_undef

This is the undef SV. Always refer to this as &PL_sv_undef.

        SV      PL_sv_undef

Found in file intrpvar.h

PL_sv_yes

This is the true SV. See PL_sv_no. Always refer to this as

&PL_sv_yes.

        SV      PL_sv_yes

Found in file intrpvar.h

voltar para o topo

---

GV Functions

GvSV

Return the SV from the GV.

        SV*     GvSV(GV* gv)

Found in file gv.h

gv_fetchmeth

Returns the glob with the given name and a defined subroutine or

NULL. The glob lives in the given stash, or in the stashes

accessible via @ISA and UNIVERSAL::.

The argument level should be either 0 or -1. If level==0, as a

side-effect creates a glob with the given name in the given stash

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 "SUPER" token as a postfix of the stash name. The

GV returned from gv_fetchmeth may be a method cache entry, which is not

visible to Perl code. So when calling call_sv, you should not use

the GV directly; instead, you should use the method's CV, which can be

obtained from the GV with the GvCV macro.

        GV*     gv_fetchmeth(HV* stash, const char* name, STRLEN len, I32 level)

Found in file gv.c

gv_fetchmethod

See the gv_fetchmethod_autoload manpage.

        GV*     gv_fetchmethod(HV* stash, const char* name)

Found in file gv.c

gv_fetchmethod_autoload

Returns the glob which contains the subroutine to call to invoke the method

on the stash. 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 gv_fetchmethod_autoload 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 gv_fetchmethod is equivalent to calling gv_fetchmethod_autoload

with a non-zero autoload parameter.

These functions grant "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 gv_fetchmeth with

level==0. name should be writable if contains ':' or '

''>. The warning against passing the GV returned by gv_fetchmeth to

call_sv apply equally to these functions.

        GV*     gv_fetchmethod_autoload(HV* stash, const char* name, I32 autoload)

Found in file gv.c

gv_fetchmeth_autoload

Same as gv_fetchmeth(), but looks for autoloaded subroutines too.

Returns a glob for the subroutine.

For an autoloaded subroutine without a GV, will create a GV even

if level < 0. For an autoloaded subroutine without a stub, GvCV()

of the result may be zero.

        GV*     gv_fetchmeth_autoload(HV* stash, const char* name, STRLEN len, I32 level)

Found in file gv.c

gv_stashpv

Returns a pointer to the stash for a specified package. name should

be a valid UTF-8 string and must be null-terminated. If create is set

then the package will be created if it does not already exist. If create

is not set and the package does not exist then NULL is returned.

        HV*     gv_stashpv(const char* name, I32 create)

Found in file gv.c

gv_stashpvn

Returns a pointer to the stash for a specified package. name should

be a valid UTF-8 string. The namelen parameter indicates the length of

the name, in bytes. If create is set then the package will be

created if it does not already exist. If create is not set and the

package does not exist then NULL is returned.

        HV*     gv_stashpvn(const char* name, U32 namelen, I32 create)

Found in file gv.c

gv_stashsv

Returns a pointer to the stash for a specified package, which must be a

valid UTF-8 string. See gv_stashpv.

        HV*     gv_stashsv(SV* sv, I32 create)

Found in file gv.c

voltar para o topo

---

Handy Values

Nullav

Null AV pointer.

Found in file av.h

Nullch

Null character pointer.

Found in file handy.h

Nullcv

Null CV pointer.

Found in file cv.h

Nullhv

Null HV pointer.

Found in file hv.h

Nullsv

Null SV pointer.

Found in file handy.h

voltar para o topo

---

Hash Manipulation Functions

get_hv

Returns the HV of the specified Perl hash. If create is set and the

Perl variable does not exist then it will be created. If create 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)

Found in file perl.c

HEf_SVKEY

This flag, used in the length slot of hash entries and magic structures,

specifies the structure contains an SV* pointer where a char* pointer

is to be expected. (For information only--not to be used).

Found in file hv.h

HeHASH

Returns the computed hash stored in the hash entry.

        U32     HeHASH(HE* he)

Found in file hv.h

HeKEY

Returns the actual pointer stored in the key slot of the hash entry. The

pointer may be either char* or SV*, depending on the value of

HeKLEN(). Can be assigned to. The HePV() or HeSVKEY() macros are

usually preferable for finding the value of a key.

        void*   HeKEY(HE* he)

Found in file hv.h

HeKLEN

If this is negative, and amounts to HEf_SVKEY, it indicates the entry

holds an SV* key. Otherwise, holds the actual length of the key. Can

be assigned to. The HePV() macro is usually preferable for finding key

lengths.

        STRLEN  HeKLEN(HE* he)

Found in file hv.h

HePV

Returns the key slot of the hash entry as a char* value, doing any

necessary dereferencing of possibly SV* keys. The length of the string

is placed in len (this is a macro, so do not use &len). If you do

not care about what the length of the key is, you may use the global

variable PL_na, 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 strlen() or similar is not a good way to find

the length of hash keys. This is very similar to the SvPV() macro

described elsewhere in this document.

        char*   HePV(HE* he, STRLEN len)

Found in file hv.h

HeSVKEY

Returns the key as an SV*, or Nullsv if the hash entry does not

contain an SV* key.

        SV*     HeSVKEY(HE* he)

Found in file hv.h

HeSVKEY_force

Returns the key as an SV*. Will create and return a temporary mortal

SV* if the hash entry contains only a char* key.

        SV*     HeSVKEY_force(HE* he)

Found in file hv.h

HeSVKEY_set

Sets the key to a given SV*, taking care to set the appropriate flags to

indicate the presence of an SV* key, and returns the same

SV*.

        SV*     HeSVKEY_set(HE* he, SV* sv)

Found in file hv.h

HeVAL

Returns the value slot (type SV*) stored in the hash entry.

        SV*     HeVAL(HE* he)

Found in file hv.h

HvNAME

Returns the package name of a stash. See SvSTASH, CvSTASH.

        char*   HvNAME(HV* stash)

Found in file hv.h

hv_clear

Clears a hash, making it empty.

        void    hv_clear(HV* tb)

Found in file hv.c

hv_clear_placeholders

Clears any placeholders from a hash. If a restricted hash has any of its keys

marked as readonly and the key is subsequently deleted, the key is not actually

deleted but is marked by assigning it a value of &PL_sv_placeholder. This tags

it so it will be ignored by future operations such as iterating over the hash,

but will still allow the hash to have a value reassigned to the key at some

future point. This function clears any such placeholder keys from the hash.

See Hash::Util::lock_keys() for an example of its use.

        void    hv_clear_placeholders(HV* hb)

Found in file hv.c

hv_delete

Deletes a key/value pair in the hash. The value SV is removed from the

hash and returned to the caller. The klen is the length of the key.

The flags value will normally be zero; if set to G_DISCARD then NULL

will be returned.

        SV*     hv_delete(HV* tb, const char* key, I32 klen, I32 flags)

Found in file hv.c

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 flags value will normally be zero;

if set to G_DISCARD then NULL will be returned. hash 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)

Found in file hv.c

hv_exists

Returns a boolean indicating whether the specified hash key exists. The

klen is the length of the key.

        bool    hv_exists(HV* tb, const char* key, I32 klen)

Found in file hv.c

hv_exists_ent

Returns a boolean indicating whether the specified hash key exists. hash

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)

Found in file hv.c

hv_fetch

Returns the SV which corresponds to the specified key in the hash. The

klen is the length of the key. If lval is set then the fetch will be

part of a store. Check that the return value is non-null before

dereferencing it to an SV*.

See Understanding the Magic of Tied Hashes and Arrays in the perlguts manpage for more

information on how to use this function on tied hashes.

        SV**    hv_fetch(HV* tb, const char* key, I32 klen, I32 lval)

Found in file hv.c

hv_fetch_ent

Returns the hash entry which corresponds to the specified key in the hash.

hash must be a valid precomputed hash number for the given key, or 0

if you want the function to compute it. IF lval 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 tb 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 Understanding the Magic of Tied Hashes and Arrays in the perlguts manpage for more

information on how to use this function on tied hashes.

        HE*     hv_fetch_ent(HV* tb, SV* key, I32 lval, U32 hash)

Found in file hv.c

hv_iterinit

Prepares a starting point to traverse a hash table. Returns the number of

keys in the hash (i.e. the same as HvKEYS(tb)). The return value is

currently only meaningful for hashes without tie magic.

NOTE: Before version 5.004_65, hv_iterinit 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 HvFILL(tb).

        I32     hv_iterinit(HV* tb)

Found in file hv.c

hv_iterkey

Returns the key from the current position of the hash iterator. See

hv_iterinit.

        char*   hv_iterkey(HE* entry, I32* retlen)

Found in file hv.c

hv_iterkeysv

Returns the key as an SV* from the current position of the hash

iterator. The return value will always be a mortal copy of the key. Also

see hv_iterinit.

        SV*     hv_iterkeysv(HE* entry)

Found in file hv.c

hv_iternext

Returns entries from a hash iterator. See hv_iterinit.

You may call hv_delete or hv_delete_ent on the hash entry that the

iterator currently points to, without losing your place or invalidating your

iterator. Note that in this case the current entry is deleted from the hash

with your iterator holding the last reference to it. Your iterator is flagged

to free the entry on the next call to hv_iternext, so you must not discard

your iterator immediately else the entry will leak - call hv_iternext to

trigger the resource deallocation.

        HE*     hv_iternext(HV* tb)

Found in file hv.c

hv_iternextsv

Performs an hv_iternext, hv_iterkey, and hv_iterval in one

operation.

        SV*     hv_iternextsv(HV* hv, char** key, I32* retlen)

Found in file hv.c

hv_iternext_flags

Returns entries from a hash iterator. See hv_iterinit and hv_iternext.

The flags value will normally be zero; if HV_ITERNEXT_WANTPLACEHOLDERS is

set the placeholders keys (for restricted hashes) will be returned in addition

to normal keys. By default placeholders are automatically skipped over.

Currently a placeholder is implemented with a value that is

&Perl_sv_placeholder. Note that the implementation of placeholders and

restricted hashes may change, and the implementation currently is

insufficiently abstracted for any change to be tidy.

NOTE: this function is experimental and may change or be

removed without notice.

        HE*     hv_iternext_flags(HV* tb, I32 flags)

Found in file hv.c

hv_iterval

Returns the value from the current position of the hash iterator. See

hv_iterkey.

        SV*     hv_iterval(HV* tb, HE* entry)

Found in file hv.c

hv_magic

Adds magic to a hash. See sv_magic.

        void    hv_magic(HV* hv, GV* gv, int how)

Found in file hv.c

hv_scalar

Evaluates the hash in scalar context and returns the result. Handles magic when the hash is tied.

        SV*     hv_scalar(HV* hv)

Found in file hv.c

hv_store

Stores an SV in a hash. The hash key is specified as key and klen is

the length of the key. The hash 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 SV*. Note that the caller is

responsible for suitably incrementing the reference count of val before

the call, and decrementing it if the function returned NULL. Effectively

a successful hv_store takes ownership of one reference to val. This is

usually what you want; a newly created SV has a reference count of one, so

if all your code does is create SVs then store them in a hash, hv_store

will own the only reference to the new SV, and your code doesn't need to do

anything further to tidy up. hv_store is not implemented as a call to

hv_store_ent, and does not create a temporary SV for the key, so if your

key data is not already in SV form then use hv_store in preference to

hv_store_ent.

See Understanding the Magic of Tied Hashes and Arrays in the perlguts manpage for more

information on how to use this function on tied hashes.

        SV**    hv_store(HV* tb, const char* key, I32 klen, SV* val, U32 hash)

Found in file hv.c

hv_store_ent

Stores val in a hash. The hash key is specified as key. The hash

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 He? macros

described here. Note that the caller is responsible for suitably

incrementing the reference count of val before the call, and

decrementing it if the function returned NULL. Effectively a successful

hv_store_ent takes ownership of one reference to val. This is

usually what you want; a newly created SV has a reference count of one, so

if all your code does is create SVs then store them in a hash, hv_store

will own the only reference to the new SV, and your code doesn't need to do

anything further to tidy up. Note that hv_store_ent only reads the key;

unlike val it does not take ownership of it, so maintaining the correct

reference count on key is entirely the caller's responsibility. hv_store

is not implemented as a call to hv_store_ent, and does not create a temporary

SV for the key, so if your key data is not already in SV form then use

hv_store in preference to hv_store_ent.

See Understanding the Magic of Tied Hashes and Arrays in the perlguts manpage for more

information on how to use this function on tied hashes.

        HE*     hv_store_ent(HV* tb, SV* key, SV* val, U32 hash)

Found in file hv.c

hv_undef

Undefines the hash.

        void    hv_undef(HV* tb)

Found in file hv.c

newHV

Creates a new HV. The reference count is set to 1.

        HV*     newHV()

Found in file hv.c

voltar para o topo

---

Magical Functions

mg_clear

Clear something magical that the SV represents. See sv_magic.

        int     mg_clear(SV* sv)

Found in file mg.c

mg_copy

Copies the magic from one SV to another. See sv_magic.

        int     mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)

Found in file mg.c

mg_find

Finds the magic pointer for type matching the SV. See sv_magic.

        MAGIC*  mg_find(SV* sv, int type)

Found in file mg.c

mg_free

Free any magic storage used by the SV. See sv_magic.

        int     mg_free(SV* sv)

Found in file mg.c

mg_get

Do magic after a value is retrieved from the SV. See sv_magic.

        int     mg_get(SV* sv)

Found in file mg.c

mg_length

Report on the SV's length. See sv_magic.

        U32     mg_length(SV* sv)

Found in file mg.c

mg_magical

Turns on the magical status of an SV. See sv_magic.

        void    mg_magical(SV* sv)

Found in file mg.c

mg_set

Do magic after a value is assigned to the SV. See sv_magic.

        int     mg_set(SV* sv)

Found in file mg.c

SvGETMAGIC

Invokes mg_get on an SV if it has 'get' magic. This macro evaluates its

argument more than once.

        void    SvGETMAGIC(SV* sv)

Found in file sv.h

SvLOCK

Arranges for a mutual exclusion lock to be obtained on sv if a suitable module

has been loaded.

        void    SvLOCK(SV* sv)

Found in file sv.h

SvSETMAGIC

Invokes mg_set on an SV if it has 'set' magic. This macro evaluates its

argument more than once.

        void    SvSETMAGIC(SV* sv)

Found in file sv.h

SvSetMagicSV

Like SvSetSV, but does any set magic required afterwards.

        void    SvSetMagicSV(SV* dsb, SV* ssv)

Found in file sv.h

SvSetMagicSV_nosteal

Like SvSetSV_nosteal, but does any set magic required afterwards.

        void    SvSetMagicSV_nosteal(SV* dsv, SV* ssv)

Found in file sv.h

SvSetSV

Calls sv_setsv if dsv is not the same as ssv. May evaluate arguments

more than once.

        void    SvSetSV(SV* dsb, SV* ssv)

Found in file sv.h

SvSetSV_nosteal

Calls a non-destructive version of sv_setsv if dsv is not the same as

ssv. May evaluate arguments more than once.

        void    SvSetSV_nosteal(SV* dsv, SV* ssv)

Found in file sv.h

SvSHARE

Arranges for sv to be shared between threads if a suitable module

has been loaded.

        void    SvSHARE(SV* sv)

Found in file sv.h

SvUNLOCK

Releases a mutual exclusion lock on sv if a suitable module

has been loaded.

        void    SvUNLOCK(SV* sv)

Found in file sv.h

voltar para o topo

---

Memory Management

Copy

The XSUB-writer's interface to the C memcpy function. The src is the

source, dest is the destination, nitems is the number of items, and type is

the type. May fail on overlapping copies. See also Move.

        void    Copy(void* src, void* dest, int nitems, type)

Found in file handy.h

CopyD

Like Copy but returns dest. Useful for encouraging compilers to tail-call

optimise.

        void *  CopyD(void* src, void* dest, int nitems, type)

Found in file handy.h

Move

The XSUB-writer's interface to the C memmove function. The src is the

source, dest is the destination, nitems is the number of items, and type is

the type. Can do overlapping moves. See also Copy.

        void    Move(void* src, void* dest, int nitems, type)

Found in file handy.h

MoveD

Like Move but returns dest. Useful for encouraging compilers to tail-call

optimise.

        void *  MoveD(void* src, void* dest, int nitems, type)

Found in file handy.h

New

The XSUB-writer's interface to the C malloc function.

        void    New(int id, void* ptr, int nitems, type)

Found in file handy.h

Newc

The XSUB-writer's interface to the C malloc function, with

cast.

        void    Newc(int id, void* ptr, int nitems, type, cast)

Found in file handy.h

Newz

The XSUB-writer's interface to the C malloc function. The allocated

memory is zeroed with memzero.

        void    Newz(int id, void* ptr, int nitems, type)

Found in file handy.h

Poison

Fill up memory with a pattern (byte 0xAB over and over again) that

hopefully catches attempts to access uninitialized memory.

        void    Poison(void* dest, int nitems, type)

Found in file handy.h

Renew

The XSUB-writer's interface to the C realloc function.

        void    Renew(void* ptr, int nitems, type)

Found in file handy.h

Renewc

The XSUB-writer's interface to the C realloc function, with

cast.

        void    Renewc(void* ptr, int nitems, type, cast)

Found in file handy.h

Safefree

The XSUB-writer's interface to the C free function.

        void    Safefree(void* ptr)

Found in file handy.h

savepv

Perl's version of strdup(). Returns a pointer to a newly allocated

string which is a duplicate of pv. The size of the string is

determined by strlen(). The memory allocated for the new string can

be freed with the Safefree() function.

        char*   savepv(const char* pv)

Found in file util.c

savepvn

Perl's version of what strndup() would be if it existed. Returns a

pointer to a newly allocated string which is a duplicate of the first

len bytes from pv. The memory allocated for the new string can be

freed with the Safefree() function.

        char*   savepvn(const char* pv, I32 len)

Found in file util.c

savesharedpv

A version of savepv() which allocates the duplicate string in memory

which is shared between threads.

        char*   savesharedpv(const char* pv)

Found in file util.c

savesvpv

A version of savepv()/savepvn() which gets the string to duplicate from

the passed in SV using SvPV()

        char*   savesvpv(SV* sv)

Found in file util.c

StructCopy

This is an architecture-independent macro to copy one structure to another.

        void    StructCopy(type src, type dest, type)

Found in file handy.h

Zero

The XSUB-writer's interface to the C memzero function. The dest is the

destination, nitems is the number of items, and type is the type.

        void    Zero(void* dest, int nitems, type)

Found in file handy.h

ZeroD

Like Zero but returns dest. Useful for encouraging compilers to tail-call

optimise.

        void *  ZeroD(void* dest, int nitems, type)

Found in file handy.h

voltar para o topo

---

Miscellaneous Functions

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)

Found in file util.c

fbm_instr

Returns the location of the SV in the string delimited by str and

strend. It returns Nullch if the string can't be found. The sv

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)

Found in file util.c

form

Takes a sprintf-style format pattern and conventional

(non-SV) arguments and returns the formatted string.

    (char *) Perl_form(pTHX_ const char* pat, ...)

can be used any place a string (char *) is required:

    char * s = Perl_form("%d.%d",major,minor);

Uses a single private buffer so if you want to format several strings you

must explicitly copy the earlier strings away (and free the copies when you

are done).

        char*   form(const char* pat, ...)

Found in file util.c

getcwd_sv

Fill the sv with current working directory

        int     getcwd_sv(SV* sv)

Found in file util.c

strEQ

Test two strings to see if they are equal. Returns true or false.

        bool    strEQ(char* s1, char* s2)

Found in file handy.h

strGE

Test two strings to see if the first, s1, is greater than or equal to

the second, s2. Returns true or false.

        bool    strGE(char* s1, char* s2)

Found in file handy.h

strGT

Test two strings to see if the first, s1, is greater than the second,

s2. Returns true or false.

        bool    strGT(char* s1, char* s2)

Found in file handy.h

strLE

Test two strings to see if the first, s1, is less than or equal to the

second, s2. Returns true or false.

        bool    strLE(char* s1, char* s2)

Found in file handy.h

strLT

Test two strings to see if the first, s1, is less than the second,

s2. Returns true or false.

        bool    strLT(char* s1, char* s2)

Found in file handy.h

strNE

Test two strings to see if they are different. Returns true or

false.

        bool    strNE(char* s1, char* s2)

Found in file handy.h

strnEQ

Test two strings to see if they are equal. The len parameter indicates

the number of bytes to compare. Returns true or false. (A wrapper for

strncmp).

        bool    strnEQ(char* s1, char* s2, STRLEN len)

Found in file handy.h

strnNE

Test two strings to see if they are different. The len parameter

indicates the number of bytes to compare. Returns true or false. (A

wrapper for strncmp).

        bool    strnNE(char* s1, char* s2, STRLEN len)

Found in file handy.h

sv_nolocking

Dummy routine which ``locks'' an SV when there is no locking module present.

Exists to avoid test for a NULL function pointer and because it could potentially warn under

some level of strict-ness.

        void    sv_nolocking(SV *)

Found in file util.c

sv_nosharing

Dummy routine which ``shares'' an SV when there is no sharing module present.

Exists to avoid test for a NULL function pointer and because it could potentially warn under

some level of strict-ness.

        void    sv_nosharing(SV *)

Found in file util.c

sv_nounlocking

Dummy routine which ``unlocks'' an SV when there is no locking module present.

Exists to avoid test for a NULL function pointer and because it could potentially warn under

some level of strict-ness.

        void    sv_nounlocking(SV *)

Found in file util.c

voltar para o topo

---

Numeric functions

grok_bin

converts a string representing a binary number to numeric form.

On entry start and *len give the string to scan, *flags gives

conversion flags, and result should be NULL or a pointer to an NV.

The scan stops at the end of the string, or the first invalid character.

Unless PERL_SCAN_SILENT_ILLDIGIT is set in *flags, encountering an

invalid character will also trigger a warning.

On return *len is set to the length of the scanned string,

and *flags gives output flags.

If the value is <= UV_MAX it is returned as a UV, the output flags are clear,

and nothing is written to *result. If the value is > UV_MAX grok_bin

returns UV_MAX, sets PERL_SCAN_GREATER_THAN_UV_MAX in the output flags,

and writes the value to *result (or the value is discarded if result

is NULL).

The binary number may optionally be prefixed with ``0b'' or ``b'' unless

PERL_SCAN_DISALLOW_PREFIX is set in *flags on entry. If

PERL_SCAN_ALLOW_UNDERSCORES is set in *flags then the binary

number may use '_' characters to separate digits.

        UV      grok_bin(char* start, STRLEN* len, I32* flags, NV *result)

Found in file numeric.c

grok_hex

converts a string representing a hex number to numeric form.

On entry start and *len give the string to scan, *flags gives

conversion flags, and result should be NULL or a pointer to an NV.

The scan stops at the end of the string, or the first invalid character.

Unless PERL_SCAN_SILENT_ILLDIGIT is set in *flags, encountering an

invalid character will also trigger a warning.

On return *len is set to the length of the scanned string,

and *flags gives output flags.

If the value is <= UV_MAX it is returned as a UV, the output flags are clear,

and nothing is written to *result. If the value is > UV_MAX grok_hex

returns UV_MAX, sets PERL_SCAN_GREATER_THAN_UV_MAX in the output flags,

and writes the value to *result (or the value is discarded if result

is NULL).

The hex number may optionally be prefixed with ``0x'' or ``x'' unless

PERL_SCAN_DISALLOW_PREFIX is set in *flags on entry. If

PERL_SCAN_ALLOW_UNDERSCORES is set in *flags then the hex

number may use '_' characters to separate digits.

        UV      grok_hex(char* start, STRLEN* len, I32* flags, NV *result)

Found in file numeric.c

grok_number

Recognise (or not) a number. The type of the number is returned

(0 if unrecognised), otherwise it is a bit-ORed combination of

IS_NUMBER_IN_UV, IS_NUMBER_GREATER_THAN_UV_MAX, IS_NUMBER_NOT_INT,

IS_NUMBER_NEG, IS_NUMBER_INFINITY, IS_NUMBER_NAN (defined in perl.h).

If the value of the number can fit an in UV, it is returned in the *valuep

IS_NUMBER_IN_UV will be set to indicate that *valuep is valid, IS_NUMBER_IN_UV

will never be set unless *valuep is valid, but *valuep may have been assigned

to during processing even though IS_NUMBER_IN_UV is not set on return.

If valuep is NULL, IS_NUMBER_IN_UV will be set for the same cases as when

valuep is non-NULL, but no actual assignment (or SEGV) will occur.

IS_NUMBER_NOT_INT will be set with IS_NUMBER_IN_UV if trailing decimals were

seen (in which case *valuep gives the true value truncated to an integer), and

IS_NUMBER_NEG if the number is negative (in which case *valuep holds the

absolute value). IS_NUMBER_IN_UV is not set if e notation was used or the

number is larger than a UV.

        int     grok_number(const char *pv, STRLEN len, UV *valuep)

Found in file numeric.c

grok_numeric_radix

Scan and skip for a numeric decimal separator (radix).

        bool    grok_numeric_radix(const char **sp, const char *send)

Found in file numeric.c

grok_oct

converts a string representing an octal number to numeric form.

On entry start and *len give the string to scan, *flags gives

conversion flags, and result should be NULL or a pointer to an NV.

The scan stops at the end of the string, or the first invalid character.

Unless PERL_SCAN_SILENT_ILLDIGIT is set in *flags, encountering an

invalid character will also trigger a warning.

On return *len is set to the length of the scanned string,

and *flags gives output flags.

If the value is <= UV_MAX it is returned as a UV, the output flags are clear,

and nothing is written to *result. If the value is > UV_MAX grok_oct

returns UV_MAX, sets PERL_SCAN_GREATER_THAN_UV_MAX in the output flags,

and writes the value to *result (or the value is discarded if result

is NULL).

If PERL_SCAN_ALLOW_UNDERSCORES is set in *flags then the octal

number may use '_' characters to separate digits.

        UV      grok_oct(char* start, STRLEN* len, I32* flags, NV *result)

Found in file numeric.c

scan_bin

For backwards compatibility. Use grok_bin instead.

        NV      scan_bin(char* start, STRLEN len, STRLEN* retlen)

Found in file numeric.c

scan_hex

For backwards compatibility. Use grok_hex instead.

        NV      scan_hex(char* start, STRLEN len, STRLEN* retlen)

Found in file numeric.c

scan_oct

For backwards compatibility. Use grok_oct instead.

        NV      scan_oct(char* start, STRLEN len, STRLEN* retlen)

Found in file numeric.c

voltar para o topo

---

Optree Manipulation Functions

cv_const_sv

If cv is a constant sub eligible for inlining. returns the constant

value returned by the sub. Otherwise, returns NULL.

Constant subs can be created with newCONSTSUB or as described in

Constant Functions in the perlsub manpage.

        SV*     cv_const_sv(CV* cv)

Found in file op.c

newCONSTSUB

Creates a constant sub equivalent to Perl sub FOO () { 123 } which is

eligible for inlining at compile-time.

        CV*     newCONSTSUB(HV* stash, char* name, SV* sv)

Found in file op.c

newXS

Used by xsubpp to hook up XSUBs as Perl subs.

Found in file op.c

voltar para o topo

---

Pad Data Structures

pad_sv

Get the value at offset po in the current pad.

Use macro PAD_SV instead of calling this function directly.

        SV*     pad_sv(PADOFFSET po)

Found in file pad.c

voltar para o topo

---

Stack Manipulation Macros

dMARK

Declare a stack marker variable, mark, for the XSUB. See MARK and

dORIGMARK.

                dMARK;

Found in file pp.h

dORIGMARK

Saves the original stack mark for the XSUB. See ORIGMARK.

                dORIGMARK;

Found in file pp.h

dSP

Declares a local copy of perl's stack pointer for the XSUB, available via

the SP macro. See SP.

                dSP;

Found in file pp.h

EXTEND

Used to extend the argument stack for an XSUB's return values. Once

used, guarantees that there is room for at least nitems to be pushed

onto the stack.

        void    EXTEND(SP, int nitems)

Found in file pp.h

MARK

Stack marker variable for the XSUB. See dMARK.

Found in file pp.h

mPUSHi

Push an integer onto the stack. The stack must have room for this element.

Handles 'set' magic. Does not use TARG. See also PUSHi, mXPUSHi

and XPUSHi.

        void    mPUSHi(IV iv)

Found in file pp.h

mPUSHn

Push a double onto the stack. The stack must have room for this element.

Handles 'set' magic. Does not use TARG. See also PUSHn, mXPUSHn

and XPUSHn.

        void    mPUSHn(NV nv)

Found in file pp.h

mPUSHp

Push a string onto the stack. The stack must have room for this element.

The len indicates the length of the string. Handles 'set' magic. Does

not use TARG. See also PUSHp, mXPUSHp and XPUSHp.

        void    mPUSHp(char* str, STRLEN len)

Found in file pp.h

mPUSHu

Push an unsigned integer onto the stack. The stack must have room for this

element. Handles 'set' magic. Does not use TARG. See also PUSHu,

mXPUSHu and XPUSHu.

        void    mPUSHu(UV uv)

Found in file pp.h

mXPUSHi

Push an integer onto the stack, extending the stack if necessary. Handles

'set' magic. Does not use TARG. See also XPUSHi, mPUSHi and

PUSHi.

        void    mXPUSHi(IV iv)

Found in file pp.h

mXPUSHn

Push a double onto the stack, extending the stack if necessary. Handles

'set' magic. Does not use TARG. See also XPUSHn, mPUSHn and

PUSHn.

        void    mXPUSHn(NV nv)

Found in file pp.h

mXPUSHp

Push a string onto the stack, extending the stack if necessary. The len

indicates the length of the string. Handles 'set' magic. Does not use

TARG. See also XPUSHp, mPUSHp and PUSHp.

        void    mXPUSHp(char* str, STRLEN len)

Found in file pp.h

mXPUSHu

Push an unsigned integer onto the stack, extending the stack if necessary.

Handles 'set' magic. Does not use TARG. See also XPUSHu, mPUSHu

and PUSHu.

        void    mXPUSHu(UV uv)

Found in file pp.h

ORIGMARK

The original stack mark for the XSUB. See dORIGMARK.

Found in file pp.h

POPi

Pops an integer off the stack.

        IV      POPi

Found in file pp.h

POPl

Pops a long off the stack.

        long    POPl

Found in file pp.h

POPn

Pops a double off the stack.

        NV      POPn

Found in file pp.h

POPp

Pops a string off the stack. Deprecated. New code should provide

a STRLEN n_a and use POPpx.

        char*   POPp

Found in file pp.h

POPpbytex

Pops a string off the stack which must consist of bytes i.e. characters < 256.

Requires a variable STRLEN n_a in scope.

        char*   POPpbytex

Found in file pp.h

POPpx

Pops a string off the stack.

Requires a variable STRLEN n_a in scope.

        char*   POPpx

Found in file pp.h

POPs

Pops an SV off the stack.

        SV*     POPs

Found in file pp.h

PUSHi

Push an integer onto the stack. The stack must have room for this element.

Handles 'set' magic. Uses TARG, so dTARGET or dXSTARG should be

called to declare it. Do not call multiple TARG-oriented macros to

return lists from XSUB's - see mPUSHi instead. See also XPUSHi and

mXPUSHi.

        void    PUSHi(IV iv)

Found in file pp.h

PUSHMARK

Opening bracket for arguments on a callback. See PUTBACK and

the perlcall manpage.

        void    PUSHMARK(SP)

Found in file pp.h

PUSHmortal

Push a new mortal SV onto the stack. The stack must have room for this

element. Does not handle 'set' magic. Does not use TARG. See also

PUSHs, XPUSHmortal and XPUSHs.

        void    PUSHmortal()

Found in file pp.h

PUSHn

Push a double onto the stack. The stack must have room for this element.

Handles 'set' magic. Uses TARG, so dTARGET or dXSTARG should be

called to declare it. Do not call multiple TARG-oriented macros to

return lists from XSUB's - see mPUSHn instead. See also XPUSHn and

mXPUSHn.

        void    PUSHn(NV nv)

Found in file pp.h

PUSHp

Push a string onto the stack. The stack must have room for this element.

The len indicates the length of the string. Handles 'set' magic. Uses

TARG, so dTARGET or dXSTARG should be called to declare it. Do not

call multiple TARG-oriented macros to return lists from XSUB's - see

mPUSHp instead. See also XPUSHp and mXPUSHp.

        void    PUSHp(char* str, STRLEN len)

Found in file pp.h

PUSHs

Push an SV onto the stack. The stack must have room for this element.

Does not handle 'set' magic. Does not use TARG. See also PUSHmortal,

XPUSHs and XPUSHmortal.

        void    PUSHs(SV* sv)

Found in file pp.h

PUSHu

Push an unsigned integer onto the stack. The stack must have room for this

element. Handles 'set' magic. Uses TARG, so dTARGET or dXSTARG

should be called to declare it. Do not call multiple TARG-oriented

macros to return lists from XSUB's - see mPUSHu instead. See also

XPUSHu and mXPUSHu.

        void    PUSHu(UV uv)

Found in file pp.h

PUTBACK

Closing bracket for XSUB arguments. This is usually handled by xsubpp.

See PUSHMARK and the perlcall manpage for other uses.

                PUTBACK;

Found in file pp.h

SP

Stack pointer. This is usually handled by xsubpp. See dSP and

SPAGAIN.

Found in file pp.h

SPAGAIN

Refetch the stack pointer. Used after a callback. See the perlcall manpage.

                SPAGAIN;

Found in file pp.h

XPUSHi

Push an integer onto the stack, extending the stack if necessary. Handles

'set' magic. Uses TARG, so dTARGET or dXSTARG should be called to

declare it. Do not call multiple TARG-oriented macros to return lists

from XSUB's - see mXPUSHi instead. See also PUSHi and mPUSHi.

        void    XPUSHi(IV iv)

Found in file pp.h

XPUSHmortal

Push a new mortal SV onto the stack, extending the stack if necessary. Does

not handle 'set' magic. Does not use TARG. See also XPUSHs,

PUSHmortal and PUSHs.

        void    XPUSHmortal()

Found in file pp.h

XPUSHn

Push a double onto the stack, extending the stack if necessary. Handles

'set' magic. Uses TARG, so dTARGET or dXSTARG should be called to

declare it. Do not call multiple TARG-oriented macros to return lists

from XSUB's - see mXPUSHn instead. See also PUSHn and mPUSHn.

        void    XPUSHn(NV nv)

Found in file pp.h

XPUSHp

Push a string onto the stack, extending the stack if necessary. The len

indicates the length of the string. Handles 'set' magic. Uses TARG, so

dTARGET or dXSTARG should be called to declare it. Do not call

multiple TARG-oriented macros to return lists from XSUB's - see

mXPUSHp instead. See also PUSHp and mPUSHp.

        void    XPUSHp(char* str, STRLEN len)

Found in file pp.h

XPUSHs

Push an SV onto the stack, extending the stack if necessary. Does not

handle 'set' magic. Does not use TARG. See also XPUSHmortal,

PUSHs and PUSHmortal.

        void    XPUSHs(SV* sv)

Found in file pp.h

XPUSHu

Push an unsigned integer onto the stack, extending the stack if necessary.

Handles 'set' magic. Uses TARG, so dTARGET or dXSTARG should be

called to declare it. Do not call multiple TARG-oriented macros to

return lists from XSUB's - see mXPUSHu instead. See also PUSHu and

mPUSHu.

        void    XPUSHu(UV uv)

Found in file pp.h

XSRETURN

Return from XSUB, indicating number of items on the stack. This is usually

handled by xsubpp.

        void    XSRETURN(int nitems)

Found in file XSUB.h

XSRETURN_EMPTY

Return an empty list from an XSUB immediately.

                XSRETURN_EMPTY;

Found in file XSUB.h

XSRETURN_IV

Return an integer from an XSUB immediately. Uses XST_mIV.

        void    XSRETURN_IV(IV iv)

Found in file XSUB.h

XSRETURN_NO

Return &PL_sv_no from an XSUB immediately. Uses XST_mNO.

                XSRETURN_NO;

Found in file XSUB.h

XSRETURN_NV

Return a double from an XSUB immediately. Uses XST_mNV.

        void    XSRETURN_NV(NV nv)

Found in file XSUB.h

XSRETURN_PV

Return a copy of a string from an XSUB immediately. Uses XST_mPV.

        void    XSRETURN_PV(char* str)

Found in file XSUB.h

XSRETURN_UNDEF

Return &PL_sv_undef from an XSUB immediately. Uses XST_mUNDEF.

                XSRETURN_UNDEF;

Found in file XSUB.h

XSRETURN_UV

Return an integer from an XSUB immediately. Uses XST_mUV.

        void    XSRETURN_UV(IV uv)

Found in file XSUB.h

XSRETURN_YES

Return &PL_sv_yes from an XSUB immediately. Uses XST_mYES.

                XSRETURN_YES;

Found in file XSUB.h

XST_mIV

Place an integer into the specified position pos on the stack. The

value is stored in a new mortal SV.

        void    XST_mIV(int pos, IV iv)

Found in file XSUB.h

XST_mNO

Place &PL_sv_no into the specified position pos on the

stack.

        void    XST_mNO(int pos)

Found in file XSUB.h

XST_mNV

Place a double into the specified position pos on the stack. The value

is stored in a new mortal SV.

        void    XST_mNV(int pos, NV nv)

Found in file XSUB.h

XST_mPV

Place a copy of a string into the specified position pos on the stack.

The value is stored in a new mortal SV.

        void    XST_mPV(int pos, char* str)

Found in file XSUB.h

XST_mUNDEF

Place &PL_sv_undef into the specified position pos on the

stack.

        void    XST_mUNDEF(int pos)

Found in file XSUB.h