Perl-APIReference-0.16/0000755000175000017500000000000012264521751013257 5ustar tseetseePerl-APIReference-0.16/META.yml0000664000175000017500000000104112264521751014526 0ustar tseetsee--- abstract: 'Programmatically query the perlapi' author: - 'Steffen Mueller ' build_requires: ExtUtils::MakeMaker: 0 configure_requires: ExtUtils::MakeMaker: 0 dynamic_config: 1 generated_by: 'ExtUtils::MakeMaker version 6.64, CPAN::Meta::Converter version 2.120921' license: unknown meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: 1.4 name: Perl-APIReference no_index: directory: - t - inc requires: Class::XSAccessor: 1.05 Data::Dumper: 0 parent: 0 version: 0.16 Perl-APIReference-0.16/lib/0000755000175000017500000000000012264521751014025 5ustar tseetseePerl-APIReference-0.16/lib/Perl/0000755000175000017500000000000012264521751014727 5ustar tseetseePerl-APIReference-0.16/lib/Perl/APIReference/0000755000175000017500000000000012264521751017157 5ustar tseetseePerl-APIReference-0.16/lib/Perl/APIReference/V5_014_004.pm0000644000175000017500000000040712131462316020751 0ustar tseetseepackage Perl::APIReference::V5_014_004; use strict; use warnings; use parent 'Perl::APIReference::V5_014_000'; sub new { my $class = shift; my $obj = $class->SUPER::new(@_); $obj->{perl_version} = '5.014004'; bless $obj => $class; return $obj; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_008_005.pm0000644000175000017500000036021711653441731020773 0ustar tseetseepackage Perl::APIReference::V5_008_005; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'SvOOK' => {'text' => '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)','name' => 'SvOOK'},'hv_store_ent' => {'text' => '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. Effectively a successful hv_store_ent takes ownership of one reference to C. 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 C; unlike C it does not take ownership of it, so maintaining the correct reference count on C 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 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)','name' => 'hv_store_ent'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package, which must be a valid UTF-8 string. See C. HV* gv_stashsv(SV* sv, I32 create)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'strGE' => {'text' => '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)','name' => 'strGE'},'form' => {'text' => '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, ...)','name' => 'form'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified version becoming C. Handles \'get\' magic. See also C for a version which guarantees to evaluate sv only once. char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'is_utf8_string' => {'text' => 'Returns true if first C bytes of the given string form a valid UTF-8 string, false otherwise. Note that \'a valid UTF-8 string\' does not mean \'a string that contains code points above 0x7F encoded in UTF-8\' because a valid ASCII string is a valid UTF-8 string. bool is_utf8_string(U8 *s, STRLEN len)','name' => 'is_utf8_string'},'svtype' => {'text' => '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.','name' => 'svtype'},'hv_clear' => {'text' => 'Clears a hash, making it empty. void hv_clear(HV* tb)','name' => 'hv_clear'},'get_hv' => {'text' => '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)','name' => 'get_hv'},'load_module' => {'text' => '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 C. The optional trailing SV* arguments can be used to specify arguments to the module\'s import() method, similar to C. void load_module(U32 flags, SV* name, SV* ver, ...)','name' => 'load_module'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES;','name' => 'XSRETURN_YES'},'sv_nv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. NV sv_nv(SV* sv)','name' => 'sv_nv'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'Poison' => {'text' => '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)','name' => 'Poison'},'sv_insert' => {'text' => '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)','name' => 'sv_insert'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_catpvf_mg'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'SvPOK' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. bool SvPOK(SV* sv)','name' => 'SvPOK'},'get_sv' => {'text' => '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)','name' => 'get_sv'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHu(UV uv)','name' => 'PUSHu'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. (Uses C). SV* newSVsv(SV* old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C. void hv_magic(HV* hv, GV* gv, int how)','name' => 'hv_magic'},'SvPVutf8' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *sv, const char *ptr)','name' => 'sv_setpv_mg'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C.','name' => 'XS'},'scan_oct' => {'text' => 'For backwards compatibility. Use C instead. NV scan_oct(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_oct'},'sv_setpvn' => {'text' => 'Copies a string into an SV. The C parameter indicates the number of bytes to be copied. If the C argument is NULL the SV will become undefined. Does not handle \'set\' magic. See C. void sv_setpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_setpvn'},'sv_2mortal' => {'text' => 'Marks an existing SV as mortal. The SV will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_2mortal(SV* sv)','name' => 'sv_2mortal'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'newSVrv' => {'text' => '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)','name' => 'newSVrv'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself. void av_undef(AV* ar)','name' => 'av_undef'},'HeKEY' => {'text' => '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)','name' => 'HeKEY'},'pack_cat' => {'text' => '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)','name' => 'pack_cat'},'utf8n_to_uvuni' => {'text' => 'Bottom level UTF-8 decode routine. Returns the unicode code point value of the first character in the string C which is assumed to be in UTF-8 encoding and no longer than C; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, the behaviour is dependent on the value of C: if it contains UTF8_CHECK_ONLY, it is assumed that the caller will raise a warning, and this function will silently just set C to C<-1> and return zero. If the C does not contain UTF8_CHECK_ONLY, warnings about malformations will be given, C will be set to the expected length of the UTF-8 character in bytes, and zero will be returned. The C can also contain various flags to allow deviations from the strict UTF-8 encoding (see F). Most code should use utf8_to_uvchr() rather than call this directly. UV utf8n_to_uvuni(U8 *s, STRLEN curlen, STRLEN* retlen, U32 flags)','name' => 'utf8n_to_uvuni'},'sv_cmp' => {'text' => '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. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp(SV* sv1, SV* sv2)','name' => 'sv_cmp'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'SvEND' => {'text' => '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)','name' => 'SvEND'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C to type C if necessary, then adds a new magic item of type C to the head of the magic list. void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen)','name' => 'sv_magic'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C, C or C for void, scalar or list context, respectively. U32 GIMME_V','name' => 'GIMME_V'},'sv_force_normal_flags' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. The C parameter gets passed to C when unrefing. C calls this function with flags set to 0. void sv_force_normal_flags(SV *sv, U32 flags)','name' => 'sv_force_normal_flags'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'sv_setsv_flags' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. If the C parameter has the C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You probably want to use one of the assortment of wrappers, such as C, C, C and C. This is the primary function for copying scalars, and most other copy-ish functions and macros use this underneath. void sv_setsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_setsv_flags'},'sv_utf8_upgrade_flags' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade_flags(SV *sv, I32 flags)','name' => 'sv_utf8_upgrade_flags'},'New' => {'text' => 'The XSUB-writer\'s interface to the C C function. void New(int id, void* ptr, int nitems, type)','name' => 'New'},'is_utf8_char' => {'text' => 'Tests if some arbitrary number of bytes begins in a valid UTF-8 character. Note that an INVARIANT (i.e. ASCII) character is a valid UTF-8 character. The actual number of bytes in the UTF-8 character will be returned if it is valid, otherwise 0. STRLEN is_utf8_char(U8 *p)','name' => 'is_utf8_char'},'Copy' => {'text' => '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)','name' => 'Copy'},'ibcmp_utf8' => {'text' => 'Return true if the strings s1 and s2 differ case-insensitively, false if not (if they are equal case-insensitively). If u1 is true, the string s1 is assumed to be in UTF-8-encoded Unicode. If u2 is true, the string s2 is assumed to be in UTF-8-encoded Unicode. If u1 or u2 are false, the respective string is assumed to be in native 8-bit encoding. If the pe1 and pe2 are non-NULL, the scanning pointers will be copied in there (they will point at the beginning of the I character). If the pointers behind pe1 or pe2 are non-NULL, they are the end pointers beyond which scanning will not continue under any circustances. If the byte lengths l1 and l2 are non-zero, s1+l1 and s2+l2 will be used as goal end pointers that will also stop the scan, and which qualify towards defining a successful match: all the scans that define an explicit length must reach their goal pointers for a match to succeed). For case-insensitiveness, the "casefolding" of Unicode is used instead of upper/lowercasing both the characters, see http://www.unicode.org/unicode/reports/tr21/ (Case Mappings). I32 ibcmp_utf8(const char* a, char **pe1, UV l1, bool u1, const char* b, char **pe2, UV l2, bool u2)','name' => 'ibcmp_utf8'},'mXPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Handles \'set\' magic. Does not use C. See also C, C and C. void mXPUSHp(char* str, STRLEN len)','name' => 'mXPUSHp'},'CvSTASH' => {'text' => 'Returns the stash of the CV. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'sv_taint' => {'text' => 'Taint an SV. Use C instead. void sv_taint(SV* sv)','name' => 'sv_taint'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. The target SV physically takes over ownership of the body of the source SV and inherits its flags; however, the target keeps any magic it owns, and any magic in the source is discarded. Note that this is a rather specialist SV copying operation; most of the time you\'ll want to use C or one of its many macro front-ends. void sv_replace(SV* sv, SV* nsv)','name' => 'sv_replace'},'utf8n_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. Allows length and flags to be passed to low level routine. UV utf8n_to_uvchr(U8 *s, STRLEN curlen, STRLEN* retlen, U32 flags)','name' => 'utf8n_to_uvchr'},'sv_utf8_upgrade' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains a signed integer. bool SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and L.','name' => 'G_ARRAY'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. Sets up the C and C variables by calling C and C. This is usually handled automatically by C. dXSARGS;','name' => 'dXSARGS'},'sv_2iv' => {'text' => 'Return the integer value of an SV, doing any necessary string conversion, magic etc. Normally used via the C and C macros. IV sv_2iv(SV* sv)','name' => 'sv_2iv'},'savesharedpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* ptr)','name' => 'Safefree'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the C C is whitespace. bool isSPACE(char ch)','name' => 'isSPACE'},'SvROK' => {'text' => 'Tests if the SV is an RV. bool SvROK(SV* sv)','name' => 'SvROK'},'mXPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. Does not use C. See also C, C and C. void mXPUSHn(NV nv)','name' => 'mXPUSHn'},'sv_unref' => {'text' => '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. This is C with the C being zero. See C. void sv_unref(SV* sv)','name' => 'sv_unref'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dstr, SV *sstr)','name' => 'sv_catsv_mg'},'mPUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Does not use C. See also C, C and C. void mPUSHu(UV uv)','name' => 'mPUSHu'},'call_argv' => {'text' => '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)','name' => 'call_argv'},'SvPV_nolen' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified form becoming C. Handles \'get\' magic. char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'perl_clone' => {'text' => '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 C, 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)','name' => 'perl_clone'},'sv_setnv' => {'text' => 'Copies a double into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setnv(SV* sv, NV num)','name' => 'sv_setnv'},'sv_2nv' => {'text' => 'Return the num value of an SV, doing any necessary string or integer conversion, magic etc. Normally used via the C and C macros. NV sv_2nv(SV* sv)','name' => 'sv_2nv'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'XPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHp(char* str, STRLEN len)','name' => 'XPUSHp'},'sv_utf8_encode' => {'text' => 'Converts the PV of an SV to UTF-8, but then turns the C flag off so that it looks like octets again. void sv_utf8_encode(SV *sv)','name' => 'sv_utf8_encode'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1. HV* newHV()','name' => 'newHV'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or false. bool strNE(char* s1, char* s2)','name' => 'strNE'},'SvUTF8_on' => {'text' => 'Turn on the UTF-8 status of an SV (the data is not changed, just the flag). Do not use frivolously. void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_setpvn_mg'},'sv_pvutf8n_force' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n_force(SV* sv, STRLEN* lp)','name' => 'sv_pvutf8n_force'},'savepv' => {'text' => 'Perl\'s version of C. Returns a pointer to a newly allocated string which is a duplicate of C. The size of the string is determined by C. The memory allocated for the new string can be freed with the C function. char* savepv(const char* pv)','name' => 'savepv'},'toLOWER' => {'text' => 'Converts the specified character to lowercase. char toLOWER(char ch)','name' => 'toLOWER'},'bytes_from_utf8' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike but like C, returns a pointer to the newly-created string, and updates C to contain the new length. Returns the original string if no conversion occurs, C is unchanged. Do nothing if C points to 0. Sets C to 0 if C is converted or contains all 7bit characters. NOTE: this function is experimental and may change or be removed without notice. U8* bytes_from_utf8(U8 *s, STRLEN *len, bool *is_utf8)','name' => 'bytes_from_utf8'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1. AV* newAV()','name' => 'newAV'},'POPp' => {'text' => 'Pops a string off the stack. Deprecated. New code should provide a STRLEN n_a and use POPpx. char* POPp','name' => 'POPp'},'HvNAME' => {'text' => 'Returns the package name of a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV of the sv is assumed to be octets in that encoding, and the sv will be converted into Unicode (and UTF-8). If the sv already is UTF-8 (or if it is not POK), or if the encoding is not a reference, nothing is done to the sv. If the encoding is not an C Encoding object, bad things will happen. (See F and L). The PV of the sv is returned. char* sv_recode_to_utf8(SV* sv, SV *encoding)','name' => 'sv_recode_to_utf8'},'av_make' => {'text' => '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)','name' => 'av_make'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. See C for a version which guarantees to evaluate sv only once. UV SvUV(SV* sv)','name' => 'SvUV'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L. int perl_run(PerlInterpreter* interp)','name' => 'perl_run'},'sv_pvbyten' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten(SV *sv, STRLEN *len)','name' => 'sv_pvbyten'},'sv_catsv_flags' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. If C has C bit set, will C on the SVs if appropriate, else not. C and C are implemented in terms of this function. void sv_catsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_catsv_flags'},'Nullav' => {'text' => 'Null AV pointer.','name' => 'Nullav'},'sv_copypv' => {'text' => 'Copies a stringified representation of the source SV into the destination SV. Automatically performs any necessary mg_get and coercion of numeric values into strings. Guaranteed to preserve UTF-8 flag even from overloaded objects. Similar in nature to sv_2pv[_flags] but operates directly on an SV instead of just the string. Mostly uses sv_2pv_flags to do its work, except when that would lose the UTF-8\'ness of the PV. void sv_copypv(SV* dsv, SV* ssv)','name' => 'sv_copypv'},'sv_pv' => {'text' => 'Use the C macro instead char* sv_pv(SV *sv)','name' => 'sv_pv'},'SvPVutf8_nolen' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_nolen(SV* sv)','name' => 'SvPVutf8_nolen'},'sv_setpviv' => {'text' => '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)','name' => 'sv_setpviv'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setnv_mg(SV *sv, NV num)','name' => 'sv_setnv_mg'},'sv_true' => {'text' => 'Returns true if the SV has a true value by Perl\'s rules. Use the C macro instead, which may call C or may instead use an in-line version. I32 sv_true(SV *sv)','name' => 'sv_true'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV* hv, char** key, I32* retlen)','name' => 'hv_iternextsv'},'utf8_to_bytes' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike C, this over-writes the original string, and updates len to contain the new length. Returns zero on failure, setting C to -1. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_pvbyten_force' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten_force(SV* sv, STRLEN* lp)','name' => 'sv_pvbyten_force'},'sv_derived_from' => {'text' => '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)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. See also C. I32 sv_cmp_locale(SV* sv1, SV* sv2)','name' => 'sv_cmp_locale'},'uvuni_to_utf8_flags' => {'text' => 'Adds the UTF-8 representation of the Unicode codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvuni_to_utf8_flags(d, uv, flags); or, in most cases, d = uvuni_to_utf8(d, uv); (which is equivalent to) d = uvuni_to_utf8_flags(d, uv, 0); is the recommended Unicode-aware way of saying *(d++) = uv; U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)','name' => 'uvuni_to_utf8_flags'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'hv_exists' => {'text' => '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, I32 klen)','name' => 'hv_exists'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See L.','name' => 'G_DISCARD'},'Nullsv' => {'text' => 'Null SV pointer.','name' => 'Nullsv'},'mg_length' => {'text' => 'Report on the SV\'s length. See C. U32 mg_length(SV* sv)','name' => 'mg_length'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'SvPVX' => {'text' => 'Returns a pointer to the physical string in the SV. The SV must contain a string. char* SvPVX(SV* sv)','name' => 'SvPVX'},'XST_mNV' => {'text' => '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)','name' => 'XST_mNV'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'HEf_SVKEY' => {'text' => 'This flag, used in the length slot of hash entries and magic structures, specifies the structure contains an C pointer where a C pointer is to be expected. (For information only--not to be used).','name' => 'HEf_SVKEY'},'pad_sv' => {'text' => '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)','name' => 'pad_sv'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C in characters. Stops at C (inclusive). If C s> or if the scan would end up past C, croaks. STRLEN utf8_length(U8* s, U8 *e)','name' => 'utf8_length'},'SvPVutf8_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_force(SV* sv, STRLEN len)','name' => 'SvPVutf8_force'},'sv_2pvutf8_nolen' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8_nolen(SV* sv)','name' => 'sv_2pvutf8_nolen'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted if tainting is enabled. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'SvIOK_only_UV' => {'text' => 'Tells and SV that it is an unsigned integer and disables all other OK bits. void SvIOK_only_UV(SV* sv)','name' => 'SvIOK_only_UV'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C.','name' => 'SVt_NV'},'sv_nolocking' => {'text' => '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 *)','name' => 'sv_nolocking'},'sv_vcatpvfn' => {'text' => '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). Usually used via one of its frontends C and C. void sv_vcatpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vcatpvfn'},'SvPVbytex' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex(SV* sv, STRLEN len)','name' => 'SvPVbytex'},'av_store' => {'text' => '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)','name' => 'av_store'},'sv_2uv' => {'text' => 'Return the unsigned integer value of an SV, doing any necessary string conversion, magic etc. Normally used via the C and C macros. UV sv_2uv(SV* sv)','name' => 'sv_2uv'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and L. void PUSHMARK(SP)','name' => 'PUSHMARK'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. SV* ST(int ix)','name' => 'ST'},'strLT' => {'text' => '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)','name' => 'strLT'},'sv_pvutf8n' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n(SV *sv, STRLEN *len)','name' => 'sv_pvutf8n'},'call_pv' => {'text' => '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)','name' => 'call_pv'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. SV* av_shift(AV* ar)','name' => 'av_shift'},'newSV' => {'text' => 'Create a new null SV, or if len > 0, create a new empty SVt_PV type SV with an initial PV allocation of len+1. Normally accessed via the C macro. SV* newSV(STRLEN len)','name' => 'newSV'},'av_fetch' => {'text' => '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)','name' => 'av_fetch'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'gv_fetchmeth_autoload' => {'text' => '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 C. 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)','name' => 'gv_fetchmeth_autoload'},'sv_2pvutf8' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV, and set *lp to its length. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8(SV* sv, STRLEN* lp)','name' => 'sv_2pvutf8'},'sv_nounlocking' => {'text' => '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 *)','name' => 'sv_nounlocking'},'dITEMS' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dITEMS;','name' => 'dITEMS'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV* tb, HE* entry)','name' => 'hv_iterval'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. char* sv_reftype(SV* sv, int ob)','name' => 'sv_reftype'},'sv_pos_b2u' => {'text' => 'Converts the value pointed to by offsetp from a count of bytes from the start of the string, to a count of the equivalent number of UTF-8 chars. Handles magic and type coercion. void sv_pos_b2u(SV* sv, I32* offsetp)','name' => 'sv_pos_b2u'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C.','name' => 'SVt_IV'},'av_len' => {'text' => 'Returns the highest index in the array. Returns -1 if the array is empty. I32 av_len(AV* ar)','name' => 'av_len'},'SvIsCOW' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write. (either shared hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for COW) bool SvIsCOW(SV* sv)','name' => 'SvIsCOW'},'sv_unmagic' => {'text' => 'Removes all magic of type C from an SV. int sv_unmagic(SV* sv, int type)','name' => 'sv_unmagic'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *sv, IV i)','name' => 'sv_setiv_mg'},'sv_catsv' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catsv(SV* dsv, SV* ssv)','name' => 'sv_catsv'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled. void SvTAINT(SV* sv)','name' => 'SvTAINT'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C. See C and L for other uses. PUTBACK;','name' => 'PUTBACK'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'ax' => {'text' => 'Variable which is setup by C to indicate the stack base offset, used by the C, C and C macros. The C macro must be called prior to setup the C variable. I32 ax','name' => 'ax'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'SvCUR_set' => {'text' => 'Set the length of the string which is in the SV. See C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'to_utf8_fold' => {'text' => 'Convert the UTF-8 encoded character at p to its foldcase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_FOLD+1 bytes since the foldcase version may be longer than the original character (up to three characters). The first character of the foldcased version is returned (but note, as explained above, that there may be more.) UV to_utf8_fold(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_fold'},'to_utf8_upper' => {'text' => 'Convert the UTF-8 encoded character at p to its uppercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the uppercase version may be longer than the original character (up to two characters). The first character of the uppercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_upper(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_upper'},'SvNOK' => {'text' => 'Returns a boolean indicating whether the SV contains a double. bool SvNOK(SV* sv)','name' => 'SvNOK'},'mPUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. Does not use C. See also C, C and C. void mPUSHn(NV nv)','name' => 'mPUSHn'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. C should be a valid UTF-8 string. 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)','name' => 'gv_stashpv'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C, C, and L.','name' => 'G_SCALAR'},'SvPVutf8x_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x_force(SV* sv, STRLEN len)','name' => 'SvPVutf8x_force'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHi(IV iv)','name' => 'PUSHi'},'sv_reset' => {'text' => 'Underlying implementation for the C Perl function. Note that the perl-level function is vaguely deprecated. void sv_reset(char* s, HV* stash)','name' => 'sv_reset'},'mXPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Does not use C. See also C, C and C. void mXPUSHu(UV uv)','name' => 'mXPUSHu'},'hv_exists_ent' => {'text' => '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)','name' => 'hv_exists_ent'},'to_utf8_lower' => {'text' => 'Convert the UTF-8 encoded character at p to its lowercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the lowercase version may be longer than the original character (up to two characters). The first character of the lowercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_lower(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_lower'},'SvNIOK' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. bool SvNIOK(SV* sv)','name' => 'SvNIOK'},'sv_2pv_flags' => {'text' => 'Returns a pointer to the string value of an SV, and sets *lp to its length. If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string if necessary. Normally invoked via the C macro. C and C usually end up here too. char* sv_2pv_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_2pv_flags'},'SvTAINTED_off' => {'text' => '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)','name' => 'SvTAINTED_off'},'SvNVx' => {'text' => 'Coerces the given SV to a double and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. NV SvNVx(SV* sv)','name' => 'SvNVx'},'unpack_str' => {'text' => '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)','name' => 'unpack_str'},'newSVpvf' => {'text' => 'Creates a new SV and initializes it with the string formatted like C. SV* newSVpvf(const char* pat, ...)','name' => 'newSVpvf'},'require_pv' => {'text' => 'Tells Perl to C the file named by the string argument. It is analogous to the Perl code C. 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)','name' => 'require_pv'},'sv_upgrade' => {'text' => 'Upgrade an SV to a more complex form. Generally adds a new body type to the SV, then copies across as much information as possible from the old body. You generally want to use the C macro wrapper. See also C. bool sv_upgrade(SV* sv, U32 mt)','name' => 'sv_upgrade'},'strEQ' => {'text' => 'Test two strings to see if they are equal. Returns true or false. bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C wrapper instead. SV* sv_newref(SV* sv)','name' => 'sv_newref'},'hv_store' => {'text' => '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. Effectively a successful hv_store takes ownership of one reference to C. 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 L 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)','name' => 'hv_store'},'SvIVX' => {'text' => 'Returns the raw value in the SV\'s IV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. IV SvIVX(SV* sv)','name' => 'SvIVX'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L. int perl_destruct(PerlInterpreter* interp)','name' => 'perl_destruct'},'sv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the scalar sv, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument is as in pv_uni_display(). The pointer to the PV of the dsv is returned. char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim, UV flags)','name' => 'sv_uni_display'},'isUPPER' => {'text' => 'Returns a boolean indicating whether the C C is an uppercase character. bool isUPPER(char ch)','name' => 'isUPPER'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. You probably want to use one of the assortment of wrappers, such as C, C, C and C. void sv_setsv(SV* dsv, SV* ssv)','name' => 'sv_setsv'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the stack. void XST_mYES(int pos)','name' => 'XST_mYES'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C for a version which guarantees to evaluate sv only once. NV SvNV(SV* sv)','name' => 'SvNV'},'packlist' => {'text' => 'The engine implementing pack() Perl function. void packlist(SV *cat, char *pat, char *patend, SV **beglist, SV **endlist)','name' => 'packlist'},'SvUTF8' => {'text' => 'Returns a boolean indicating whether the SV contains UTF-8 encoded data. bool SvUTF8(SV* sv)','name' => 'SvUTF8'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'sv_setsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setsv_mg(SV *dstr, SV *sstr)','name' => 'sv_setsv_mg'},'hv_fetch_ent' => {'text' => '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)','name' => 'hv_fetch_ent'},'isLOWER' => {'text' => 'Returns a boolean indicating whether the C C is a lowercase character. bool isLOWER(char ch)','name' => 'isLOWER'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See C. char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an XSUB\'s aliases was used to invoke it. See L. I32 ix','name' => 'ix'},'SvNOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a double. Checks the B setting. Use C. bool SvNOKp(SV* sv)','name' => 'SvNOKp'},'XSRETURN_UV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_UV(IV uv)','name' => 'XSRETURN_UV'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'cv_undef' => {'text' => 'Clear out all the active components of a CV. This can happen either by an explicit C, 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)','name' => 'cv_undef'},'PUSHs' => {'text' => 'Push an SV onto the stack. The stack must have room for this element. Does not handle \'set\' magic. Does not use C. See also C, C and C. void PUSHs(SV* sv)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setuv(SV* sv, UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'utf8_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvchr(U8 *s, STRLEN* retlen)','name' => 'utf8_to_uvchr'},'nothreadhook' => {'text' => 'Stub that provides thread hook for perl_destruct when there are no threads. int nothreadhook()','name' => 'nothreadhook'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'bytes_to_utf8' => {'text' => 'Converts a string C of length C from ASCII into UTF-8 encoding. Returns a pointer to the newly-created string, and sets C to reflect the new length. If you want to convert to UTF-8 from other encodings than ASCII, see sv_recode_to_utf8(). NOTE: this function is experimental and may change or be removed without notice. U8* bytes_to_utf8(U8 *s, STRLEN *len)','name' => 'bytes_to_utf8'},'sv_pvn' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn(SV *sv, STRLEN *len)','name' => 'sv_pvn'},'SvIsCOW_shared_hash' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write shared hash key scalar. bool SvIsCOW_shared_hash(SV* sv)','name' => 'SvIsCOW_shared_hash'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'dXSI32' => {'text' => 'Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. dXSI32;','name' => 'dXSI32'},'sv_setref_iv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_iv(SV* rv, const char* classname, IV iv)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => '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. Uses the "OOK hack". Beware: after this function returns, C and SvPVX(sv) may no longer refer to the same chunk of data. void sv_chop(SV* sv, char* ptr)','name' => 'sv_chop'},'SvPVx' => {'text' => 'A version of C which guarantees to evaluate sv only once. char* SvPVx(SV* sv, STRLEN len)','name' => 'SvPVx'},'sv_backoff' => {'text' => 'Remove any string offset. You should normally use the C macro wrapper instead. int sv_backoff(SV* sv)','name' => 'sv_backoff'},'sv_tainted' => {'text' => 'Test an SV for taintedness. Use C instead. bool sv_tainted(SV* sv)','name' => 'sv_tainted'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. If necessary, uses C and upgrades the SV to C. Returns a pointer to the character buffer. Use the C wrapper instead. char* sv_grow(SV* sv, STRLEN newlen)','name' => 'sv_grow'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setuv_mg(SV *sv, UV u)','name' => 'sv_setuv_mg'},'cv_const_sv' => {'text' => 'If C is a constant sub eligible for inlining. returns the constant value returned by the sub. Otherwise, returns NULL. Constant subs can be created with C or as described in L. SV* cv_const_sv(CV* cv)','name' => 'cv_const_sv'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually handled automatically by C. See C.','name' => 'XS_VERSION'},'newSVnv' => {'text' => '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)','name' => 'newSVnv'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. Does not use C. See also C, C and C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry. SV* HeVAL(HE* he)','name' => 'HeVAL'},'PL_na' => {'text' => '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','name' => 'PL_na'},'HePV' => {'text' => '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)','name' => 'HePV'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the SV is set to 1. SV* newSViv(IV i)','name' => 'newSViv'},'sv_untaint' => {'text' => 'Untaint an SV. Use C instead. void sv_untaint(SV* sv)','name' => 'sv_untaint'},'sv_setpv' => {'text' => '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)','name' => 'sv_setpv'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See C.','name' => 'SVt_PVHV'},'pv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the string spv, length len, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument can have UNI_DISPLAY_ISPRINT set to display isPRINT()able characters as themselves, UNI_DISPLAY_BACKSLASH to display the \\\\[nrfta\\\\] as the backslashed versions (like \'\\n\') (UNI_DISPLAY_BACKSLASH is preferred over UNI_DISPLAY_ISPRINT for \\\\). UNI_DISPLAY_QQ (and its alias UNI_DISPLAY_REGEX) have both UNI_DISPLAY_BACKSLASH and UNI_DISPLAY_ISPRINT turned on. The pointer to the PV of the dsv is returned. char* pv_uni_display(SV *dsv, U8 *spv, STRLEN len, STRLEN pvlim, UV flags)','name' => 'pv_uni_display'},'gv_fetchmethod' => {'text' => 'See L. GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'SvGETMAGIC' => {'text' => 'Invokes C on an SV if it has \'get\' magic. This macro evaluates its argument more than once. void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'SvGROW' => {'text' => '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)','name' => 'SvGROW'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_inc(SV* sv)','name' => 'sv_inc'},'sv_usepvn' => {'text' => '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)','name' => 'sv_usepvn'},'SvPVbytex_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex_force(SV* sv, STRLEN len)','name' => 'SvPVbytex_force'},'sv_catpv' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpv(SV* sv, const char* ptr)','name' => 'sv_catpv'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'sv_len' => {'text' => 'Returns the length of the string in the SV. Handles magic and type coercion. See also C, which gives raw access to the xpv_cur slot. STRLEN sv_len(SV* sv)','name' => 'sv_len'},'warn' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Call this function the same way you call the C C function. See C. void warn(const char* pat, ...)','name' => 'warn'},'sv_pvutf8' => {'text' => 'Use the C macro instead char* sv_pvutf8(SV *sv)','name' => 'sv_pvutf8'},'SvPVbyte_nolen' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_nolen(SV* sv)','name' => 'SvPVbyte_nolen'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L. LEAVE;','name' => 'LEAVE'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See C.','name' => 'SVt_PVAV'},'hv_delete' => {'text' => '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, I32 klen, I32 flags)','name' => 'hv_delete'},'hv_undef' => {'text' => 'Undefines the hash. void hv_undef(HV* tb)','name' => 'hv_undef'},'SvSetMagicSV_nosteal' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetMagicSV_nosteal'},'hv_delete_ent' => {'text' => '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)','name' => 'hv_delete_ent'},'CLASS' => {'text' => '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','name' => 'CLASS'},'sv_isobject' => {'text' => '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)','name' => 'sv_isobject'},'Newc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Newc(int id, void* ptr, int nitems, type, cast)','name' => 'Newc'},'sv_pvn_force_flags' => {'text' => 'Get a sensible string out of the SV somehow. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You normally want to use the various wrapper macros instead: see C and C char* sv_pvn_force_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_pvn_force_flags'},'HeKLEN' => {'text' => '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)','name' => 'HeKLEN'},'to_utf8_title' => {'text' => 'Convert the UTF-8 encoded character at p to its titlecase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the titlecase version may be longer than the original character (up to two characters). The first character of the titlecased version is returned (but note, as explained above, that there may be more.) UV to_utf8_title(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_title'},'sv_cat_decode' => {'text' => 'The encoding is assumed to be an Encode object, the PV of the ssv is assumed to be octets in that encoding and decoding the input starts from the position which (PV + *offset) pointed to. The dsv will be concatenated the decoded UTF-8 string from ssv. Decoding will terminate when the string tstr appears in decoding output or the input ends on the PV of the ssv. The value which the offset points will be modified to the last input position on the ssv. Returns TRUE if the terminator was found, else returns FALSE. bool sv_cat_decode(SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen)','name' => 'sv_cat_decode'},'mPUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Does not use C. See also C, C and C. void mPUSHi(IV iv)','name' => 'mPUSHi'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHn(NV nv)','name' => 'PUSHn'},'sv_setiv' => {'text' => 'Copies an integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setiv(SV* sv, IV num)','name' => 'sv_setiv'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it. See C for a version which guarantees to evaluate sv only once. IV SvIV(SV* sv)','name' => 'SvIV'},'sv_report_used' => {'text' => 'Dump the contents of all SVs not yet freed. (Debugging aid). void sv_report_used()','name' => 'sv_report_used'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. void EXTEND(SP, int nitems)','name' => 'EXTEND'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. SV PL_sv_yes','name' => 'PL_sv_yes'},'SvNVX' => {'text' => 'Returns the raw value in the SV\'s NV slot, without checks or conversions. Only use when you are sure SvNOK is true. See also C. NV SvNVX(SV* sv)','name' => 'SvNVX'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(UV u)','name' => 'newSVuv'},'gv_fetchmeth' => {'text' => '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)','name' => 'gv_fetchmeth'},'sv_nosharing' => {'text' => '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 *)','name' => 'sv_nosharing'},'SvUTF8_off' => {'text' => 'Unsets the UTF-8 status of an SV. void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'looks_like_number' => {'text' => 'Test if the content of an SV looks like a number (or is a number). C and C are treated as numbers (so will not issue a non-numeric warning), even if your atof() doesn\'t grok them. I32 looks_like_number(SV* sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpv_mg(SV *sv, const char *ptr)','name' => 'sv_catpv_mg'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. U32 HeHASH(HE* he)','name' => 'HeHASH'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'sv_setref_uv' => {'text' => 'Copies an unsigned 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 have a reference count of 1, and the RV will be returned. SV* sv_setref_uv(SV* rv, const char* classname, UV uv)','name' => 'sv_setref_uv'},'SvIOK' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. bool SvIOK(SV* sv)','name' => 'SvIOK'},'getcwd_sv' => {'text' => 'Fill the sv with current working directory int getcwd_sv(SV* sv)','name' => 'getcwd_sv'},'newSVpv' => {'text' => '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)','name' => 'newSVpv'},'sv_2pvbyte' => {'text' => 'Return a pointer to the byte-encoded representation of the SV, and set *lp to its length. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte(SV* sv, STRLEN* lp)','name' => 'sv_2pvbyte'},'fbm_instr' => {'text' => '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)','name' => 'fbm_instr'},'sv_setpvf' => {'text' => '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, ...)','name' => 'sv_setpvf'},'SvPV_force' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHn(NV nv)','name' => 'XPUSHn'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part attributable to C. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'call_sv' => {'text' => '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)','name' => 'call_sv'},'SVt_PV' => {'text' => 'Pointer type flag for scalars. See C.','name' => 'SVt_PV'},'strGT' => {'text' => '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)','name' => 'strGT'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a string and disables all other OK bits, and leaves the UTF-8 status as it was. void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic after a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'},'sv_pos_u2b' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from the start of the string, to a count of the equivalent number of bytes; if lenp is non-zero, it does the same to lenp, but this time starting from the offset, rather than from the start of the string. Handles magic and type coercion. void sv_pos_u2b(SV* sv, I32* offsetp, I32* lenp)','name' => 'sv_pos_u2b'},'SvTRUE' => {'text' => '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)','name' => 'SvTRUE'},'HeSVKEY_set' => {'text' => '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)','name' => 'HeSVKEY_set'},'POPl' => {'text' => 'Pops a long off the stack. long POPl','name' => 'POPl'},'hv_iternext_flags' => {'text' => 'Returns entries from a hash iterator. See C and C. The C 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 C<&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)','name' => 'hv_iternext_flags'},'grok_hex' => {'text' => 'converts a string representing a hex number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first non-hex-digit character. On return I<*len> is set to the length scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0x" or "x" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the hex number may use \'_\' characters to separate digits. UV grok_hex(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_hex'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L. SPAGAIN;','name' => 'SPAGAIN'},'call_method' => {'text' => '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)','name' => 'call_method'},'SvLOCK' => {'text' => 'Arranges for a mutual exclusion lock to be obtained on sv if a suitable module has been loaded. void SvLOCK(SV* sv)','name' => 'SvLOCK'},'sv_vsetpvfn' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Usually used via one of its frontends C and C. void sv_vsetpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vsetpvfn'},'get_cv' => {'text' => '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)','name' => 'get_cv'},'SvIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. Checks the B setting. Use C. bool SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the stack. void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'perl_parse' => {'text' => '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)','name' => 'perl_parse'},'to_utf8_case' => {'text' => 'The "p" contains the pointer to the UTF-8 string encoding the character that is being converted. The "ustrp" is a pointer to the character buffer to put the conversion result to. The "lenp" is a pointer to the length of the result. The "swashp" is a pointer to the swash to use. Both the special and normal mappings are stored lib/unicore/To/Foo.pl, and loaded by SWASHGET, using lib/utf8_heavy.pl. The special (usually, but not always, a multicharacter mapping), is tried first. The "special" is a string like "utf8::ToSpecLower", which means the hash %utf8::ToSpecLower. The access to the hash is through Perl_to_utf8_case(). The "normal" is a string like "ToLower" which means the swash %utf8::ToLower. UV to_utf8_case(U8 *p, U8* ustrp, STRLEN *lenp, SV **swash, char *normal, char *special)','name' => 'to_utf8_case'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory used by the array itself. void av_clear(AV* ar)','name' => 'av_clear'},'sv_force_normal' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. See also C. void sv_force_normal(SV *sv)','name' => 'sv_force_normal'},'av_unshift' => {'text' => '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)','name' => 'av_unshift'},'SvUNLOCK' => {'text' => 'Releases a mutual exclusion lock on sv if a suitable module has been loaded. void SvUNLOCK(SV* sv)','name' => 'SvUNLOCK'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C. int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV (using C). The new SV is marked as mortal. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_mortalcopy(SV* oldsv)','name' => 'sv_mortalcopy'},'POPpbytex' => {'text' => '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','name' => 'POPpbytex'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. UV SvUVX(SV* sv)','name' => 'SvUVX'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See L.','name' => 'G_NOARGS'},'SvSetMagicSV' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV(SV* dsb, SV* ssv)','name' => 'SvSetMagicSV'},'sv_utf8_decode' => {'text' => 'If the PV of the SV is an octet sequence in UTF-8 and contains a multiple-byte character, the C flag is turned on so that it looks like a character. If the PV contains only single-byte characters, the C flag stays being off. Scans PV for validity and returns false if the PV is invalid UTF-8. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_decode(SV *sv)','name' => 'sv_utf8_decode'},'Newz' => {'text' => '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)','name' => 'Newz'},'savepvn' => {'text' => 'Perl\'s version of what C would be if it existed. Returns a pointer to a newly allocated string which is a duplicate of the first C bytes from C. The memory allocated for the new string can be freed with the C function. char* savepvn(const char* pv, I32 len)','name' => 'savepvn'},'eval_sv' => {'text' => '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)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized. This relies on the fact that uninitialized array elements are set to C<&PL_sv_undef>. bool av_exists(AV* ar, I32 key)','name' => 'av_exists'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C. STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'Move' => {'text' => '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)','name' => 'Move'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'sv_catpvn_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. void sv_catpvn_flags(SV* sv, const char* ptr, STRLEN len, I32 flags)','name' => 'sv_catpvn_flags'},'GIMME' => {'text' => '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','name' => 'GIMME'},'sv_bless' => {'text' => '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)','name' => 'sv_bless'},'NEWSV' => {'text' => '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)','name' => 'NEWSV'},'sv_isa' => {'text' => '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)','name' => 'sv_isa'},'isALNUM' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphanumeric character (including underscore) or digit. bool isALNUM(char ch)','name' => 'isALNUM'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs.','name' => 'newXS'},'sv_catpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. If the appended data contains "wide" characters (including, but not limited to, SVs with a UTF-8 PV formatted with %s, and characters >255 formatted with %c), the original SV might get upgraded to UTF-8. 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, ...)','name' => 'sv_catpvf'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. bool SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C. void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'utf8_to_uvuni' => {'text' => 'Returns the Unicode code point of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. This function should only be used when returned UV is considered an index into the Unicode semantic tables (e.g. swashes). If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvuni(U8 *s, STRLEN* retlen)','name' => 'utf8_to_uvuni'},'sv_2io' => {'text' => 'Using various gambits, try to get an IO from an SV: the IO slot if its a GV; or the recursive result if we\'re an RV; or the IO slot of the symbol named after the PV if we\'re a string. IO* sv_2io(SV* sv)','name' => 'sv_2io'},'PUSHmortal' => {'text' => 'Push a new mortal SV onto the stack. The stack must have room for this element. Does not handle \'set\' magic. Does not use C. See also C, C and C. void PUSHmortal()','name' => 'PUSHmortal'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphabetic character. bool isALPHA(char ch)','name' => 'isALPHA'},'Nullhv' => {'text' => 'Null HV pointer.','name' => 'Nullhv'},'av_fill' => {'text' => 'Ensure than an array has a given number of elements, equivalent to Perl\'s C<$#array = $fill;>. void av_fill(AV* ar, I32 fill)','name' => 'av_fill'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV. SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C. svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter* interp)','name' => 'perl_construct'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. void SvUOK(SV* sv)','name' => 'SvUOK'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_dec(SV* sv)','name' => 'sv_dec'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'strLE' => {'text' => '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)','name' => 'strLE'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'grok_bin' => {'text' => 'converts a string representing a binary number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. On return I<*len> is set to the length scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0b" or "b" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the binary number may use \'_\' characters to separate digits. UV grok_bin(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_bin'},'sv_2pvbyte_nolen' => {'text' => 'Return a pointer to the byte-encoded representation of the SV. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'SvOK' => {'text' => 'Returns a boolean indicating whether the value is an SV. It also tells whether the value is defined or not. bool SvOK(SV* sv)','name' => 'SvOK'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L. void perl_free(PerlInterpreter* interp)','name' => 'perl_free'},'sv_setref_nv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_nv(SV* rv, const char* classname, NV nv)','name' => 'sv_setref_nv'},'uvchr_to_utf8' => {'text' => 'Adds the UTF-8 representation of the Native codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvchr_to_utf8(d, uv); is the recommended wide native character-aware way of saying *(d++) = uv; U8* uvchr_to_utf8(U8 *d, UV uv)','name' => 'uvchr_to_utf8'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C. MAGIC* mg_find(SV* sv, int type)','name' => 'mg_find'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII digit. bool isDIGIT(char ch)','name' => 'isDIGIT'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'XPUSHmortal' => {'text' => 'Push a new mortal SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. Does not use C. See also C, C and C. void XPUSHmortal()','name' => 'XPUSHmortal'},'eval_pv' => {'text' => '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)','name' => 'eval_pv'},'newSVpvn_share' => {'text' => 'Creates a new SV with its SvPVX pointing to a shared string in the string table. If the string does not already exist in the table, it is created first. Turns on READONLY and FAKE. The string\'s hash is stored in the UV slot of the SV; if the C parameter is non-zero, that value is used; otherwise the hash is computed. The idea here is that as the string table is used for shared hash keys these strings will have SvPVX == HeKEY and hash lookup will avoid string compare. SV* newSVpvn_share(const char* s, I32 len, U32 hash)','name' => 'newSVpvn_share'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_setpvf_mg'},'SvPOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. Checks the B setting. Use C. bool SvPOKp(SV* sv)','name' => 'SvPOKp'},'sv_free' => {'text' => 'Decrement an SV\'s reference count, and if it drops to zero, call C to invoke destructors and free up any memory used by the body; finally, deallocate the SV\'s head itself. Normally called via a wrapper macro C. void sv_free(SV* sv)','name' => 'sv_free'},'sv_catpvn' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn'},'SvPVbyte_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_force(SV* sv, STRLEN len)','name' => 'SvPVbyte_force'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. CV* newCONSTSUB(HV* stash, char* name, SV* sv)','name' => 'newCONSTSUB'},'sv_setref_pv' => {'text' => '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 have a reference count of 1, and the RV will be returned. 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)','name' => 'sv_setref_pv'},'SvSHARE' => {'text' => 'Arranges for sv to be shared between threads if a suitable module has been loaded. void SvSHARE(SV* sv)','name' => 'SvSHARE'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_pop(AV* ar)','name' => 'av_pop'},'fbm_compile' => {'text' => '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)','name' => 'fbm_compile'},'sv_utf8_downgrade' => {'text' => 'Attempts to convert the PV of an SV from characters to bytes. If the PV contains a character beyond byte, this conversion will fail; in this case, either returns false or, if C is not true, croaks. This is not as a general purpose Unicode to byte encoding interface: use the Encode extension for that. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_downgrade(SV *sv, bool fail_ok)','name' => 'sv_utf8_downgrade'},'SvNIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. Checks the B setting. Use C. bool SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'croak' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Normally call this function the same way you call the C C function. Calling C returns control directly to Perl, sidestepping the normal C order of execution. See C. If you want to throw an exception object, assign the object to C<$@> and then pass C to croak(): errsv = get_sv("@", TRUE); sv_setsv(errsv, exception_object); croak(Nullch); void croak(const char* pat, ...)','name' => 'croak'},'sortsv' => {'text' => '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)','name' => 'sortsv'},'THIS' => {'text' => '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','name' => 'THIS'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either forward or backward. WARNING: do not use the following unless you *know* C is within the UTF-8 data pointed to by C *and* that on entry C is aligned on the first byte of character or just after the last byte of a character. U8* utf8_hop(U8 *s, I32 off)','name' => 'utf8_hop'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide UTF-8 bytes as a single character. Handles magic and type coercion. STRLEN sv_len_utf8(SV* sv)','name' => 'sv_len_utf8'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually handled by C. void XSRETURN(int nitems)','name' => 'XSRETURN'},'sv_setref_pvn' => {'text' => '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 have a reference count of 1, and the RV will be returned. Note that C copies the pointer while this copies the string. SV* sv_setref_pvn(SV* rv, const char* classname, char* pv, STRLEN n)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for blessed scalars. See C.','name' => 'SVt_PVMG'},'PUSHp' => {'text' => '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. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHp(char* str, STRLEN len)','name' => 'PUSHp'},'scan_bin' => {'text' => 'For backwards compatibility. Use C instead. NV scan_bin(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_bin'},'Nullcv' => {'text' => 'Null CV pointer.','name' => 'Nullcv'},'hv_clear_placeholders' => {'text' => '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 reaasigned 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)','name' => 'hv_clear_placeholders'},'mXPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Does not use C. See also C, C and C. void mXPUSHi(IV iv)','name' => 'mXPUSHi'},'dAX' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dAX;','name' => 'dAX'},'sv_2pv_nolen' => {'text' => 'Like C, but doesn\'t return the length too. You should usually use the macro wrapper C instead. char* sv_2pv_nolen(SV* sv)','name' => 'sv_2pv_nolen'},'get_av' => {'text' => '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)','name' => 'get_av'},'PL_sv_undef' => {'text' => 'This is the C SV. Always refer to this as C<&PL_sv_undef>. SV PL_sv_undef','name' => 'PL_sv_undef'},'SvPVbyte' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'hv_iterkeysv' => {'text' => '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)','name' => 'hv_iterkeysv'},'grok_number' => {'text' => '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)','name' => 'grok_number'},'SvIVx' => {'text' => 'Coerces the given SV to an integer and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. IV SvIVx(SV* sv)','name' => 'SvIVx'},'grok_numeric_radix' => {'text' => 'Scan and skip for a numeric decimal separator (radix). bool grok_numeric_radix(const char **sp, const char *send)','name' => 'grok_numeric_radix'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the stack. void XST_mNO(int pos)','name' => 'XST_mNO'},'toUPPER' => {'text' => 'Converts the specified character to uppercase. char toUPPER(char ch)','name' => 'toUPPER'},'mPUSHp' => {'text' => '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. Does not use C. See also C, C and C. void mPUSHp(char* str, STRLEN len)','name' => 'mPUSHp'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array. Returns the deleted element. C is currently ignored. SV* av_delete(AV* ar, I32 key, I32 flags)','name' => 'av_delete'},'is_utf8_string_loc' => {'text' => 'Like is_ut8_string but store the location of the failure in the last argument. bool is_utf8_string_loc(U8 *s, STRLEN len, U8 **p)','name' => 'is_utf8_string_loc'},'utf8_distance' => {'text' => 'Returns the number of UTF-8 characters between the UTF-8 pointers C and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. IV utf8_distance(U8 *a, U8 *b)','name' => 'utf8_distance'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally appending to the currently-stored string. char* sv_gets(SV* sv, PerlIO* fp, I32 append)','name' => 'sv_gets'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'SvPVutf8x' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'sv_collxfrm' => {'text' => 'Add Collate Transform magic to an SV if it doesn\'t already have it. Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the scalar data of the variable, but transformed to such a format that a normal memory comparison can be used to compare the data according to the locale settings. char* sv_collxfrm(SV* sv, STRLEN* nxp)','name' => 'sv_collxfrm'},'sv_2cv' => {'text' => 'Using various gambits, try to get a CV from an SV; in addition, try if possible to set C<*st> and C<*gvp> to the stash and GV associated with it. CV* sv_2cv(SV* sv, HV** st, GV** gvp, I32 lref)','name' => 'sv_2cv'},'SvPV_force_nomg' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. Doesn\'t process magic. char* SvPV_force_nomg(SV* sv, STRLEN len)','name' => 'SvPV_force_nomg'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. Will also turn off the UTF-8 status. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'POPpx' => {'text' => 'Pops a string off the stack. Requires a variable STRLEN n_a in scope. char* POPpx','name' => 'POPpx'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'sv_uv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. UV sv_uv(SV* sv)','name' => 'sv_uv'},'sv_pvbyte' => {'text' => 'Use C instead. char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'hv_fetch' => {'text' => '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 an C. See L for more information on how to use this function on tied hashes. SV** hv_fetch(HV* tb, const char* key, I32 klen, I32 lval)','name' => 'hv_fetch'},'Zero' => {'text' => '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)','name' => 'Zero'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_unref_flags' => {'text' => '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. The C argument can contain C to force the reference count to be decremented (otherwise the decrementing is conditional on the reference count being different from one or the reference being a readonly SV). See C. void sv_unref_flags(SV* sv, U32 flags)','name' => 'sv_unref_flags'},'sv_iv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. IV sv_iv(SV* sv)','name' => 'sv_iv'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'hv_scalar' => {'text' => 'Evaluates the hash in scalar context and returns the result. Handles magic when the hash is tied. SV* hv_scalar(HV* hv)','name' => 'hv_scalar'},'Nullch' => {'text' => 'Null character pointer.','name' => 'Nullch'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)','name' => 'mg_copy'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C flag on this RV; give the referred-to SV C magic if it hasn\'t already; and push a back-reference to this RV onto the array of backreferences associated with that magic. SV* sv_rvweaken(SV *sv)','name' => 'sv_rvweaken'},'grok_oct' => {'text' => 'UV grok_oct(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_oct'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'scan_hex' => {'text' => 'For backwards compatibility. Use C instead. NV scan_hex(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_hex'},'newSVpvn' => {'text' => '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. If the C argument is NULL the new SV will be undefined. SV* newSVpvn(const char* s, STRLEN len)','name' => 'newSVpvn'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the supplied vtable and returns pointer to the magic added. Note that sv_magicext will allow things that sv_magic will not. In particular you can add magic to SvREADONLY SVs and and more than one instance of the same \'how\' I C is greater then zero then a savepvn() I of C is stored, if C is zero then C is stored as-is and - as another special case - if C<(name && namelen == HEf_SVKEY)> then C is assumed to contain an C and has its REFCNT incremented (This is now used as a subroutine by sv_magic.) MAGIC * sv_magicext(SV* sv, SV* obj, int how, MGVTBL *vtbl, const char* name, I32 namlen )','name' => 'sv_magicext'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C.','name' => 'SVt_PVCV'},'av_push' => {'text' => '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)','name' => 'av_push'},'unpackstring' => {'text' => 'The engine implementing unpack() Perl function. C puts the extracted list items on the stack and returns the number of elements. Issue C before and C after the call to this function. I32 unpackstring(char *pat, char *patend, char *s, char *strend, U32 flags)','name' => 'unpackstring'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV* ar, I32 key)','name' => 'av_extend'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV *sv)','name' => 'newRV_noinc'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpviv_mg(SV *sv, IV iv)','name' => 'sv_setpviv_mg'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'sv_2bool' => {'text' => 'This function is only called on magical items, and is only used by sv_true() or its macro equivalent. bool sv_2bool(SV* sv)','name' => 'sv_2bool'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. You may call C or C 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 C, so you must not discard your iterator immediately else the entry will leak - call C to trigger the resource deallocation. HE* hv_iternext(HV* tb)','name' => 'hv_iternext'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'sv_newmortal' => {'text' => 'Creates a new null SV which is mortal. The reference count of the SV is set to 1. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_newmortal()','name' => 'sv_newmortal'},'sv_clear' => {'text' => 'Clear an SV: call any destructors, free up any memory used by the body, and free the body itself. The SV\'s head is I freed, although its type is set to all 1\'s so that it won\'t inadvertently be assumed to be live during global destruction etc. This function should only be called when REFCNT is zero. Most of the time you\'ll want to call C (or its macro wrapper C) instead. void sv_clear(SV* sv)','name' => 'sv_clear'},'hv_iterinit' => {'text' => '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)','name' => 'hv_iterinit'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.008005', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_012_001.pm0000644000175000017500000000040711653441731020752 0ustar tseetseepackage Perl::APIReference::V5_012_001; use strict; use warnings; use parent 'Perl::APIReference::V5_012_000'; sub new { my $class = shift; my $obj = $class->SUPER::new(@_); $obj->{perl_version} = '5.012001'; bless $obj => $class; return $obj; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_014_002.pm0000644000175000017500000000040711653442211020747 0ustar tseetseepackage Perl::APIReference::V5_014_002; use strict; use warnings; use parent 'Perl::APIReference::V5_014_000'; sub new { my $class = shift; my $obj = $class->SUPER::new(@_); $obj->{perl_version} = '5.014002'; bless $obj => $class; return $obj; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_006_001.pm0000644000175000017500000021267011653441731020764 0ustar tseetseepackage Perl::APIReference::V5_006_001; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'SvOOK' => {'text' => '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)','name' => 'SvOOK'},'hv_store_ent' => {'text' => '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)','name' => 'hv_store_ent'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package, which must be a valid UTF-8 string. See C. HV* gv_stashsv(SV* sv, I32 create)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'XSRETURN_NV' => {'text' => 'Return an double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'strGE' => {'text' => '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)','name' => 'strGE'},'SvPV' => {'text' => '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)','name' => 'SvPV'},'svtype' => {'text' => '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.','name' => 'svtype'},'is_utf8_string' => {'text' => 'Returns true if first C bytes of the given string form valid a UTF8 string, false otherwise. bool is_utf8_string(U8 *s, STRLEN len)','name' => 'is_utf8_string'},'hv_clear' => {'text' => 'Clears a hash, making it empty. void hv_clear(HV* tb)','name' => 'hv_clear'},'get_hv' => {'text' => '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)','name' => 'get_hv'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES;','name' => 'XSRETURN_YES'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'sv_insert' => {'text' => '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)','name' => 'sv_insert'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_catpvf_mg'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'SvPOK' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. bool SvPOK(SV* sv)','name' => 'SvPOK'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. See C. void PUSHu(UV uv)','name' => 'PUSHu'},'get_sv' => {'text' => '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)','name' => 'get_sv'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. SV* newSVsv(SV* old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C. void hv_magic(HV* hv, GV* gv, int how)','name' => 'hv_magic'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *sv, const char *ptr)','name' => 'sv_setpv_mg'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C.','name' => 'XS'},'sv_setpvn' => {'text' => '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)','name' => 'sv_setpvn'},'sv_2mortal' => {'text' => 'Marks an SV as mortal. The SV will be destroyed when the current context ends. SV* sv_2mortal(SV* sv)','name' => 'sv_2mortal'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'newSVrv' => {'text' => '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)','name' => 'newSVrv'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself. void av_undef(AV* ar)','name' => 'av_undef'},'HeKEY' => {'text' => '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)','name' => 'HeKEY'},'sv_cmp' => {'text' => '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)','name' => 'sv_cmp'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'SvEND' => {'text' => '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)','name' => 'SvEND'},'utf8_to_uv_simple' => {'text' => 'Returns the character value of the first character in the string C which is assumed to be in UTF8 encoding; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF8 character, zero is returned and retlen is set, if possible, to -1. NOTE: this function is experimental and may change or be removed without notice. UV utf8_to_uv_simple(U8 *s, STRLEN* retlen)','name' => 'utf8_to_uv_simple'},'sv_magic' => {'text' => 'Adds magic to an SV. void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen)','name' => 'sv_magic'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C, C or C for void, scalar or list context, respectively. U32 GIMME_V','name' => 'GIMME_V'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'New' => {'text' => 'The XSUB-writer\'s interface to the C C function. void New(int id, void* ptr, int nitems, type)','name' => 'New'},'is_utf8_char' => {'text' => 'Tests if some arbitrary number of bytes begins in a valid UTF-8 character. The actual number of bytes in the UTF-8 character will be returned if it is valid, otherwise 0. STRLEN is_utf8_char(U8 *p)','name' => 'is_utf8_char'},'Copy' => {'text' => '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)','name' => 'Copy'},'CvSTASH' => {'text' => 'Returns the stash of the CV. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. void sv_replace(SV* sv, SV* nsv)','name' => 'sv_replace'},'sv_utf8_upgrade' => {'text' => 'Convert the PV of an SV to its UTF8-encoded form. NOTE: this function is experimental and may change or be removed without notice. void sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains an signed integer. void SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and L.','name' => 'G_ARRAY'},'dXSARGS' => {'text' => '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;','name' => 'dXSARGS'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* ptr)','name' => 'Safefree'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the C C is whitespace. bool isSPACE(char ch)','name' => 'isSPACE'},'SvROK' => {'text' => 'Tests if the SV is an RV. bool SvROK(SV* sv)','name' => 'SvROK'},'sv_unref' => {'text' => '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)','name' => 'sv_unref'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dstr, SV *sstr)','name' => 'sv_catsv_mg'},'call_argv' => {'text' => '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)','name' => 'call_argv'},'SvPV_nolen' => {'text' => '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)','name' => 'SvPV_nolen'},'sv_setnv' => {'text' => 'Copies a double into the given SV. Does not handle \'set\' magic. See C. void sv_setnv(SV* sv, NV num)','name' => 'sv_setnv'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'XPUSHp' => {'text' => '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)','name' => 'XPUSHp'},'sv_utf8_encode' => {'text' => 'Convert the PV of an SV to UTF8-encoded, but then turn off the C flag so that it looks like bytes again. Nothing calls this. NOTE: this function is experimental and may change or be removed without notice. void sv_utf8_encode(SV *sv)','name' => 'sv_utf8_encode'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1. HV* newHV()','name' => 'newHV'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or false. bool strNE(char* s1, char* s2)','name' => 'strNE'},'SvUTF8_on' => {'text' => 'Tells an SV that it is a string and encoded in UTF8. Do not use frivolously. void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_setpvn_mg'},'sv_pvutf8n_force' => {'text' => 'Get a sensible UTF8-encoded string out of the SV somehow. See L. char* sv_pvutf8n_force(SV* sv, STRLEN* lp)','name' => 'sv_pvutf8n_force'},'savepv' => {'text' => 'Copy a string to a safe spot. This does not use an SV. char* savepv(const char* sv)','name' => 'savepv'},'toLOWER' => {'text' => 'Converts the specified character to lowercase. char toLOWER(char ch)','name' => 'toLOWER'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1. AV* newAV()','name' => 'newAV'},'bytes_from_utf8' => {'text' => 'Converts a string C of length C from UTF8 into byte encoding. Unlike but like C, returns a pointer to the newly-created string, and updates C to contain the new length. Returns the original string if no conversion occurs, C is unchanged. Do nothing if C points to 0. Sets C to 0 if C is converted or contains all 7bit characters. NOTE: this function is experimental and may change or be removed without notice. U8* bytes_from_utf8(U8 *s, STRLEN *len, bool *is_utf8)','name' => 'bytes_from_utf8'},'POPp' => {'text' => 'Pops a string off the stack. char* POPp','name' => 'POPp'},'HvNAME' => {'text' => 'Returns the package name of a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'av_make' => {'text' => '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)','name' => 'av_make'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. UV SvUV(SV* sv)','name' => 'SvUV'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L. int perl_run(PerlInterpreter* interp)','name' => 'perl_run'},'Nullav' => {'text' => 'Null AV pointer.','name' => 'Nullav'},'sv_setpviv' => {'text' => '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)','name' => 'sv_setpviv'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setnv_mg(SV *sv, NV num)','name' => 'sv_setnv_mg'},'sv_true' => {'text' => 'Returns true if the SV has a true value by Perl\'s rules. I32 sv_true(SV *sv)','name' => 'sv_true'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV* hv, char** key, I32* retlen)','name' => 'hv_iternextsv'},'utf8_to_bytes' => {'text' => 'Converts a string C of length C from UTF8 into byte encoding. Unlike C, this over-writes the original string, and updates len to contain the new length. Returns zero on failure, setting C to -1. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_derived_from' => {'text' => '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)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. See L I32 sv_cmp_locale(SV* sv1, SV* sv2)','name' => 'sv_cmp_locale'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'hv_exists' => {'text' => '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)','name' => 'hv_exists'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See L.','name' => 'G_DISCARD'},'Nullsv' => {'text' => 'Null SV pointer.','name' => 'Nullsv'},'mg_length' => {'text' => 'Report on the SV\'s length. See C. U32 mg_length(SV* sv)','name' => 'mg_length'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'SvPVX' => {'text' => 'Returns a pointer to the string in the SV. The SV must contain a string. char* SvPVX(SV* sv)','name' => 'SvPVX'},'XST_mNV' => {'text' => '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)','name' => 'XST_mNV'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. See C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'HEf_SVKEY' => {'text' => '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).','name' => 'HEf_SVKEY'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C in characters. Stops at C (inclusive). If C s> or if the scan would end up past C, croaks. NOTE: this function is experimental and may change or be removed without notice. STRLEN utf8_length(U8* s, U8 *e)','name' => 'utf8_length'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'SvIOK_only_UV' => {'text' => 'Tells and SV that it is an unsigned integer and disables all other OK bits. void SvIOK_only_UV(SV* sv)','name' => 'SvIOK_only_UV'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C.','name' => 'SVt_NV'},'sv_vcatpvfn' => {'text' => '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)','name' => 'sv_vcatpvfn'},'av_store' => {'text' => '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)','name' => 'av_store'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and L. PUSHMARK;','name' => 'PUSHMARK'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. SV* ST(int ix)','name' => 'ST'},'strLT' => {'text' => '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)','name' => 'strLT'},'call_pv' => {'text' => '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)','name' => 'call_pv'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. SV* av_shift(AV* ar)','name' => 'av_shift'},'av_fetch' => {'text' => '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)','name' => 'av_fetch'},'utf8_to_uv' => {'text' => 'Returns the character value of the first character in the string C which is assumed to be in UTF8 encoding and no longer than C; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF8 character, the behaviour is dependent on the value of C: if it contains UTF8_CHECK_ONLY, it is assumed that the caller will raise a warning, and this function will silently just set C to C<-1> and return zero. If the C does not contain UTF8_CHECK_ONLY, warnings about malformations will be given, C will be set to the expected length of the UTF-8 character in bytes, and zero will be returned. The C can also contain various flags to allow deviations from the strict UTF-8 encoding (see F). NOTE: this function is experimental and may change or be removed without notice. UV utf8_to_uv(U8 *s, STRLEN curlen, STRLEN* retlen, U32 flags)','name' => 'utf8_to_uv'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV* tb, HE* entry)','name' => 'hv_iterval'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. char* sv_reftype(SV* sv, int ob)','name' => 'sv_reftype'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C.','name' => 'SVt_IV'},'av_len' => {'text' => 'Returns the highest index in the array. Returns -1 if the array is empty. I32 av_len(AV* ar)','name' => 'av_len'},'sv_unmagic' => {'text' => 'Removes magic from an SV. int sv_unmagic(SV* sv, int type)','name' => 'sv_unmagic'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *sv, IV i)','name' => 'sv_setiv_mg'},'sv_catsv' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catsv(SV* dsv, SV* ssv)','name' => 'sv_catsv'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled void SvTAINT(SV* sv)','name' => 'SvTAINT'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C. See C and L for other uses. PUTBACK;','name' => 'PUTBACK'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'SvCUR_set' => {'text' => 'Set the length of the string which is in the SV. See C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'SvNOK' => {'text' => 'Returns a boolean indicating whether the SV contains a double. bool SvNOK(SV* sv)','name' => 'SvNOK'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. C should be a valid UTF-8 string. 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)','name' => 'gv_stashpv'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C, C, and L.','name' => 'G_SCALAR'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. See C. void PUSHi(IV iv)','name' => 'PUSHi'},'hv_exists_ent' => {'text' => '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)','name' => 'hv_exists_ent'},'SvNIOK' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. bool SvNIOK(SV* sv)','name' => 'SvNIOK'},'SvTAINTED_off' => {'text' => '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)','name' => 'SvTAINTED_off'},'newSVpvf' => {'text' => 'Creates a new SV an initialize it with the string formatted like C. SV* newSVpvf(const char* pat, ...)','name' => 'newSVpvf'},'require_pv' => {'text' => 'Tells Perl to C a module. NOTE: the perl_ form of this function is deprecated. void require_pv(const char* pv)','name' => 'require_pv'},'sv_upgrade' => {'text' => 'Upgrade an SV to a more complex form. Use C. See C. bool sv_upgrade(SV* sv, U32 mt)','name' => 'sv_upgrade'},'strEQ' => {'text' => 'Test two strings to see if they are equal. Returns true or false. bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'hv_store' => {'text' => '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)','name' => 'hv_store'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'SvIVX' => {'text' => 'Returns the integer which is stored in the SV, assuming SvIOK is true. IV SvIVX(SV* sv)','name' => 'SvIVX'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L. void perl_destruct(PerlInterpreter* interp)','name' => 'perl_destruct'},'isUPPER' => {'text' => 'Returns a boolean indicating whether the C C is an uppercase character. bool isUPPER(char ch)','name' => 'isUPPER'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the stack. void XST_mYES(int pos)','name' => 'XST_mYES'},'sv_setsv' => {'text' => '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)','name' => 'sv_setsv'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. NV SvNV(SV* sv)','name' => 'SvNV'},'SvUTF8' => {'text' => 'Returns a boolean indicating whether the SV contains UTF-8 encoded data. void SvUTF8(SV* sv)','name' => 'SvUTF8'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'sv_setsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setsv_mg(SV *dstr, SV *sstr)','name' => 'sv_setsv_mg'},'hv_fetch_ent' => {'text' => '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)','name' => 'hv_fetch_ent'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'isLOWER' => {'text' => 'Returns a boolean indicating whether the C C is a lowercase character. bool isLOWER(char ch)','name' => 'isLOWER'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See C. char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'SvNOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a double. Checks the B setting. Use C. bool SvNOKp(SV* sv)','name' => 'SvNOKp'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an XSUB\'s aliases was used to invoke it. See L. I32 ix','name' => 'ix'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'PUSHs' => {'text' => '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)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV. Does not handle \'set\' magic. See C. void sv_setuv(SV* sv, UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'bytes_to_utf8' => {'text' => 'Converts a string C of length C from ASCII into UTF8 encoding. Returns a pointer to the newly-created string, and sets C to reflect the new length. NOTE: this function is experimental and may change or be removed without notice. U8* bytes_to_utf8(U8 *s, STRLEN *len)','name' => 'bytes_to_utf8'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'dXSI32' => {'text' => 'Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. dXSI32;','name' => 'dXSI32'},'sv_setref_iv' => {'text' => '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)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => '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)','name' => 'sv_chop'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. See C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_grow' => {'text' => '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)','name' => 'sv_grow'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setuv_mg(SV *sv, UV u)','name' => 'sv_setuv_mg'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually handled automatically by C. See C.','name' => 'XS_VERSION'},'newSVnv' => {'text' => '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)','name' => 'newSVnv'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. See C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry. SV* HeVAL(HE* he)','name' => 'HeVAL'},'HePV' => {'text' => '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)','name' => 'HePV'},'PL_na' => {'text' => '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','name' => 'PL_na'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the SV is set to 1. SV* newSViv(IV i)','name' => 'newSViv'},'sv_setpv' => {'text' => '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)','name' => 'sv_setpv'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See C.','name' => 'SVt_PVHV'},'uv_to_utf8' => {'text' => 'Adds the UTF8 representation of the Unicode codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uv_to_utf8(d, uv); is the recommended Unicode-aware way of saying *(d++) = uv; NOTE: this function is experimental and may change or be removed without notice. U8* uv_to_utf8(U8 *d, UV uv)','name' => 'uv_to_utf8'},'gv_fetchmethod' => {'text' => 'See L. GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'SvGETMAGIC' => {'text' => 'Invokes C on an SV if it has \'get\' magic. This macro evaluates its argument more than once. void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'SvGROW' => {'text' => '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)','name' => 'SvGROW'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV. void sv_inc(SV* sv)','name' => 'sv_inc'},'sv_usepvn' => {'text' => '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)','name' => 'sv_usepvn'},'sv_catpv' => {'text' => '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)','name' => 'sv_catpv'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'sv_len' => {'text' => 'Returns the length of the string in the SV. See also C. STRLEN sv_len(SV* sv)','name' => 'sv_len'},'warn' => {'text' => '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, ...)','name' => 'warn'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L. LEAVE;','name' => 'LEAVE'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See C.','name' => 'SVt_PVAV'},'hv_delete' => {'text' => '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)','name' => 'hv_delete'},'hv_undef' => {'text' => 'Undefines the hash. void hv_undef(HV* tb)','name' => 'hv_undef'},'hv_delete_ent' => {'text' => '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)','name' => 'hv_delete_ent'},'CLASS' => {'text' => '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','name' => 'CLASS'},'sv_isobject' => {'text' => '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)','name' => 'sv_isobject'},'Newc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Newc(int id, void* ptr, int nitems, type, cast)','name' => 'Newc'},'HeKLEN' => {'text' => '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)','name' => 'HeKLEN'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. See C. void PUSHn(NV nv)','name' => 'PUSHn'},'sv_setiv' => {'text' => 'Copies an integer into the given SV. Does not handle \'set\' magic. See C. void sv_setiv(SV* sv, IV num)','name' => 'sv_setiv'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it. IV SvIV(SV* sv)','name' => 'SvIV'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. void EXTEND(SP, int nitems)','name' => 'EXTEND'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. SV PL_sv_yes','name' => 'PL_sv_yes'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(UV u)','name' => 'newSVuv'},'SvNVX' => {'text' => 'Returns the double which is stored in the SV, assuming SvNOK is true. NV SvNVX(SV* sv)','name' => 'SvNVX'},'gv_fetchmeth' => {'text' => '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)','name' => 'gv_fetchmeth'},'SvUTF8_off' => {'text' => 'Unsets the UTF8 status of an SV. void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'looks_like_number' => {'text' => 'Test if an the content of an SV looks like a number (or is a number). I32 looks_like_number(SV* sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpv_mg(SV *sv, const char *ptr)','name' => 'sv_catpv_mg'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. U32 HeHASH(HE* he)','name' => 'HeHASH'},'SvIOK' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. bool SvIOK(SV* sv)','name' => 'SvIOK'},'newSVpv' => {'text' => '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)','name' => 'newSVpv'},'fbm_instr' => {'text' => '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)','name' => 'fbm_instr'},'sv_setpvf' => {'text' => '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, ...)','name' => 'sv_setpvf'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. See C. void XPUSHn(NV nv)','name' => 'XPUSHn'},'SvPV_force' => {'text' => '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)','name' => 'SvPV_force'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part attributable to C. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'call_sv' => {'text' => '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)','name' => 'call_sv'},'SVt_PV' => {'text' => 'Pointer type flag for scalars. See C.','name' => 'SVt_PV'},'strGT' => {'text' => '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)','name' => 'strGT'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a UTF8 string (do not use frivolously) and disables all other OK bits. void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic after a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'},'SvTRUE' => {'text' => '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)','name' => 'SvTRUE'},'HeSVKEY_set' => {'text' => '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)','name' => 'HeSVKEY_set'},'POPl' => {'text' => 'Pops a long off the stack. long POPl','name' => 'POPl'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L. SPAGAIN;','name' => 'SPAGAIN'},'call_method' => {'text' => '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)','name' => 'call_method'},'sv_vsetpvfn' => {'text' => '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)','name' => 'sv_vsetpvfn'},'get_cv' => {'text' => '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)','name' => 'get_cv'},'SvIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. Checks the B setting. Use C. bool SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the stack. void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'perl_parse' => {'text' => '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)','name' => 'perl_parse'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory used by the array itself. void av_clear(AV* ar)','name' => 'av_clear'},'av_unshift' => {'text' => '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)','name' => 'av_unshift'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C. int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV. The new SV is marked as mortal. SV* sv_mortalcopy(SV* oldsv)','name' => 'sv_mortalcopy'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See L.','name' => 'G_NOARGS'},'SvUVX' => {'text' => 'Returns the unsigned integer which is stored in the SV, assuming SvIOK is true. UV SvUVX(SV* sv)','name' => 'SvUVX'},'Newz' => {'text' => '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)','name' => 'Newz'},'savepvn' => {'text' => '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)','name' => 'savepvn'},'eval_sv' => {'text' => '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)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized. This relies on the fact that uninitialized array elements are set to C<&PL_sv_undef>. bool av_exists(AV* ar, I32 key)','name' => 'av_exists'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C. STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'Move' => {'text' => '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)','name' => 'Move'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'GIMME' => {'text' => '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','name' => 'GIMME'},'NEWSV' => {'text' => '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)','name' => 'NEWSV'},'sv_bless' => {'text' => '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)','name' => 'sv_bless'},'sv_isa' => {'text' => '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)','name' => 'sv_isa'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs.','name' => 'newXS'},'isALNUM' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphanumeric character (including underscore) or digit. bool isALNUM(char ch)','name' => 'isALNUM'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. void SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'sv_catpvf' => {'text' => '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, ...)','name' => 'sv_catpvf'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C. void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphabetic character. bool isALPHA(char ch)','name' => 'isALPHA'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'Nullhv' => {'text' => 'Null HV pointer.','name' => 'Nullhv'},'av_fill' => {'text' => 'Ensure than an array has a given number of elements, equivalent to Perl\'s C<$#array = $fill;>. void av_fill(AV* ar, I32 fill)','name' => 'av_fill'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV. SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter* interp)','name' => 'perl_construct'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C. svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV. void sv_dec(SV* sv)','name' => 'sv_dec'},'strLE' => {'text' => '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)','name' => 'strLE'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L. void perl_free(PerlInterpreter* interp)','name' => 'perl_free'},'SvOK' => {'text' => 'Returns a boolean indicating whether the value is an SV. bool SvOK(SV* sv)','name' => 'SvOK'},'sv_setref_nv' => {'text' => '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)','name' => 'sv_setref_nv'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C. MAGIC* mg_find(SV* sv, int type)','name' => 'mg_find'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII digit. bool isDIGIT(char ch)','name' => 'isDIGIT'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'eval_pv' => {'text' => '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)','name' => 'eval_pv'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_setpvf_mg'},'SvPOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. Checks the B setting. Use C. bool SvPOKp(SV* sv)','name' => 'SvPOKp'},'sv_free' => {'text' => 'Free the memory used by an SV. void sv_free(SV* sv)','name' => 'sv_free'},'sv_catpvn' => {'text' => '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)','name' => 'sv_catpvn'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. void newCONSTSUB(HV* stash, char* name, SV* sv)','name' => 'newCONSTSUB'},'sv_setref_pv' => {'text' => '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)','name' => 'sv_setref_pv'},'fbm_compile' => {'text' => '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)','name' => 'fbm_compile'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_pop(AV* ar)','name' => 'av_pop'},'sv_utf8_downgrade' => {'text' => 'Attempt to convert the PV of an SV from UTF8-encoded to byte encoding. This may not be possible if the PV contains non-byte encoding characters; if this is the case, either returns false or, if C is not true, croaks. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_downgrade(SV *sv, bool fail_ok)','name' => 'sv_utf8_downgrade'},'SvNIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. Checks the B setting. Use C. bool SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'croak' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Normally use this function the same way you use the C C function. See C. If you want to throw an exception object, assign the object to C<$@> and then pass C to croak(): errsv = get_sv("@", TRUE); sv_setsv(errsv, exception_object); croak(Nullch); void croak(const char* pat, ...)','name' => 'croak'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either forward or backward. WARNING: do not use the following unless you *know* C is within the UTF-8 data pointed to by C *and* that on entry C is aligned on the first byte of character or just after the last byte of a character. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_hop(U8 *s, I32 off)','name' => 'utf8_hop'},'THIS' => {'text' => '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','name' => 'THIS'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide UTF8 bytes as a single character. STRLEN sv_len_utf8(SV* sv)','name' => 'sv_len_utf8'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually handled by C. void XSRETURN(int nitems)','name' => 'XSRETURN'},'sv_setref_pvn' => {'text' => '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)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for blessed scalars. See C.','name' => 'SVt_PVMG'},'PUSHp' => {'text' => '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)','name' => 'PUSHp'},'Nullcv' => {'text' => 'Null CV pointer.','name' => 'Nullcv'},'get_av' => {'text' => '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)','name' => 'get_av'},'PL_sv_undef' => {'text' => 'This is the C SV. Always refer to this as C<&PL_sv_undef>. SV PL_sv_undef','name' => 'PL_sv_undef'},'hv_iterkeysv' => {'text' => '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)','name' => 'hv_iterkeysv'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the stack. void XST_mNO(int pos)','name' => 'XST_mNO'},'toUPPER' => {'text' => 'Converts the specified character to uppercase. char toUPPER(char ch)','name' => 'toUPPER'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array. Returns the deleted element. C is currently ignored. SV* av_delete(AV* ar, I32 key, I32 flags)','name' => 'av_delete'},'utf8_distance' => {'text' => 'Returns the number of UTF8 characters between the UTF-8 pointers C and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. NOTE: this function is experimental and may change or be removed without notice. IV utf8_distance(U8 *a, U8 *b)','name' => 'utf8_distance'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally appending to the currently-stored string. char* sv_gets(SV* sv, PerlIO* fp, I32 append)','name' => 'sv_gets'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'Zero' => {'text' => '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)','name' => 'Zero'},'hv_fetch' => {'text' => '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)','name' => 'hv_fetch'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'Nullch' => {'text' => 'Null character pointer.','name' => 'Nullch'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)','name' => 'mg_copy'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'sv_rvweaken' => {'text' => 'Weaken a reference. SV* sv_rvweaken(SV *sv)','name' => 'sv_rvweaken'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'newSVpvn' => {'text' => '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)','name' => 'newSVpvn'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C.','name' => 'SVt_PVCV'},'av_push' => {'text' => '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)','name' => 'av_push'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV *sv)','name' => 'newRV_noinc'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV* ar, I32 key)','name' => 'av_extend'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpviv_mg(SV *sv, IV iv)','name' => 'sv_setpviv_mg'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. HE* hv_iternext(HV* tb)','name' => 'hv_iternext'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'sv_newmortal' => {'text' => 'Creates a new SV which is mortal. The reference count of the SV is set to 1. SV* sv_newmortal()','name' => 'sv_newmortal'},'hv_iterinit' => {'text' => '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)','name' => 'hv_iterinit'},'sv_clear' => {'text' => 'Clear an SV, making it empty. Does not free the memory used by the SV itself. void sv_clear(SV* sv)','name' => 'sv_clear'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.006001', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_006_000.pm0000644000175000017500000017201311653441731020757 0ustar tseetseepackage Perl::APIReference::V5_006_000; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'SvOOK' => {'text' => '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)','name' => 'SvOOK'},'hv_store_ent' => {'text' => '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)','name' => 'hv_store_ent'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package, which must be a valid UTF-8 string. See C. HV* gv_stashsv(SV* sv, I32 create)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'XSRETURN_NV' => {'text' => 'Return an double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'strGE' => {'text' => '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)','name' => 'strGE'},'SvPV' => {'text' => '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)','name' => 'SvPV'},'svtype' => {'text' => '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.','name' => 'svtype'},'hv_clear' => {'text' => 'Clears a hash, making it empty. void hv_clear(HV* tb)','name' => 'hv_clear'},'get_hv' => {'text' => '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)','name' => 'get_hv'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES;','name' => 'XSRETURN_YES'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'sv_insert' => {'text' => '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)','name' => 'sv_insert'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_catpvf_mg'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'SvPOK' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. bool SvPOK(SV* sv)','name' => 'SvPOK'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. See C. void PUSHu(UV uv)','name' => 'PUSHu'},'get_sv' => {'text' => '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)','name' => 'get_sv'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. SV* newSVsv(SV* old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C. void hv_magic(HV* hv, GV* gv, int how)','name' => 'hv_magic'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *sv, const char *ptr)','name' => 'sv_setpv_mg'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C.','name' => 'XS'},'sv_setpvn' => {'text' => '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)','name' => 'sv_setpvn'},'sv_2mortal' => {'text' => 'Marks an SV as mortal. The SV will be destroyed when the current context ends. SV* sv_2mortal(SV* sv)','name' => 'sv_2mortal'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'newSVrv' => {'text' => '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)','name' => 'newSVrv'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself. void av_undef(AV* ar)','name' => 'av_undef'},'HeKEY' => {'text' => '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)','name' => 'HeKEY'},'sv_cmp' => {'text' => '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)','name' => 'sv_cmp'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'SvEND' => {'text' => '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)','name' => 'SvEND'},'sv_magic' => {'text' => 'Adds magic to an SV. void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen)','name' => 'sv_magic'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C, C or C for void, scalar or array context, respectively. U32 GIMME_V','name' => 'GIMME_V'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'New' => {'text' => 'The XSUB-writer\'s interface to the C C function. void New(int id, void* ptr, int nitems, type)','name' => 'New'},'Copy' => {'text' => '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)','name' => 'Copy'},'CvSTASH' => {'text' => 'Returns the stash of the CV. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'G_ARRAY' => {'text' => 'Used to indicate array context. See C, C and L.','name' => 'G_ARRAY'},'dXSARGS' => {'text' => '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;','name' => 'dXSARGS'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* src, void* dest, int nitems, type)','name' => 'Safefree'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the C C is whitespace. bool isSPACE(char ch)','name' => 'isSPACE'},'SvROK' => {'text' => 'Tests if the SV is an RV. bool SvROK(SV* sv)','name' => 'SvROK'},'sv_unref' => {'text' => '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)','name' => 'sv_unref'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dstr, SV *sstr)','name' => 'sv_catsv_mg'},'call_argv' => {'text' => '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)','name' => 'call_argv'},'SvPV_nolen' => {'text' => '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)','name' => 'SvPV_nolen'},'sv_setnv' => {'text' => 'Copies a double into the given SV. Does not handle \'set\' magic. See C. void sv_setnv(SV* sv, NV num)','name' => 'sv_setnv'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'XPUSHp' => {'text' => '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)','name' => 'XPUSHp'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1. HV* newHV()','name' => 'newHV'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or false. bool strNE(char* s1, char* s2)','name' => 'strNE'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_setpvn_mg'},'savepv' => {'text' => 'Copy a string to a safe spot. This does not use an SV. char* savepv(const char* sv)','name' => 'savepv'},'toLOWER' => {'text' => 'Converts the specified character to lowercase. char toLOWER(char ch)','name' => 'toLOWER'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1. AV* newAV()','name' => 'newAV'},'POPp' => {'text' => 'Pops a string off the stack. char* POPp','name' => 'POPp'},'HvNAME' => {'text' => 'Returns the package name of a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'av_make' => {'text' => '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)','name' => 'av_make'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. UV SvUV(SV* sv)','name' => 'SvUV'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L. int perl_run(PerlInterpreter* interp)','name' => 'perl_run'},'Nullav' => {'text' => 'Null AV pointer.','name' => 'Nullav'},'PL_DBtrace' => {'text' => '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','name' => 'PL_DBtrace'},'sv_setpviv' => {'text' => '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)','name' => 'sv_setpviv'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setnv_mg(SV *sv, NV num)','name' => 'sv_setnv_mg'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV* hv, char** key, I32* retlen)','name' => 'hv_iternextsv'},'sv_derived_from' => {'text' => '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)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'hv_exists' => {'text' => '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)','name' => 'hv_exists'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See L.','name' => 'G_DISCARD'},'Nullsv' => {'text' => 'Null SV pointer.','name' => 'Nullsv'},'mg_length' => {'text' => 'Report on the SV\'s length. See C. U32 mg_length(SV* sv)','name' => 'mg_length'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'SvPVX' => {'text' => 'Returns a pointer to the string in the SV. The SV must contain a string. char* SvPVX(SV* sv)','name' => 'SvPVX'},'XST_mNV' => {'text' => '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)','name' => 'XST_mNV'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. See C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'HEf_SVKEY' => {'text' => '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).','name' => 'HEf_SVKEY'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C.','name' => 'SVt_NV'},'sv_vcatpvfn' => {'text' => '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)','name' => 'sv_vcatpvfn'},'av_store' => {'text' => '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)','name' => 'av_store'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and L. PUSHMARK;','name' => 'PUSHMARK'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. SV* ST(int ix)','name' => 'ST'},'strLT' => {'text' => '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)','name' => 'strLT'},'call_pv' => {'text' => '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)','name' => 'call_pv'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. SV* av_shift(AV* ar)','name' => 'av_shift'},'av_fetch' => {'text' => '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)','name' => 'av_fetch'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV* tb, HE* entry)','name' => 'hv_iterval'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C.','name' => 'SVt_IV'},'av_len' => {'text' => 'Returns the highest index in the array. Returns -1 if the array is empty. I32 av_len(AV* ar)','name' => 'av_len'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *sv, IV i)','name' => 'sv_setiv_mg'},'sv_catsv' => {'text' => '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)','name' => 'sv_catsv'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled void SvTAINT(SV* sv)','name' => 'SvTAINT'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C. See C and L for other uses. PUTBACK;','name' => 'PUTBACK'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'SvCUR_set' => {'text' => 'Set the length of the string which is in the SV. See C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'SvNOK' => {'text' => 'Returns a boolean indicating whether the SV contains a double. bool SvNOK(SV* sv)','name' => 'SvNOK'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. C should be a valid UTF-8 string. 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)','name' => 'gv_stashpv'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C, C, and L.','name' => 'G_SCALAR'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. See C. void PUSHi(IV iv)','name' => 'PUSHi'},'hv_exists_ent' => {'text' => '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)','name' => 'hv_exists_ent'},'SvNIOK' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. bool SvNIOK(SV* sv)','name' => 'SvNIOK'},'SvTAINTED_off' => {'text' => '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)','name' => 'SvTAINTED_off'},'newSVpvf' => {'text' => 'Creates a new SV an initialize it with the string formatted like C. SV* newSVpvf(const char* pat, ...)','name' => 'newSVpvf'},'require_pv' => {'text' => 'Tells Perl to C a module. NOTE: the perl_ form of this function is deprecated. void require_pv(const char* pv)','name' => 'require_pv'},'sv_upgrade' => {'text' => 'Upgrade an SV to a more complex form. Use C. See C. bool sv_upgrade(SV* sv, U32 mt)','name' => 'sv_upgrade'},'strEQ' => {'text' => 'Test two strings to see if they are equal. Returns true or false. bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'hv_store' => {'text' => '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)','name' => 'hv_store'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'SvIVX' => {'text' => 'Returns the integer which is stored in the SV, assuming SvIOK is true. IV SvIVX(SV* sv)','name' => 'SvIVX'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L. void perl_destruct(PerlInterpreter* interp)','name' => 'perl_destruct'},'isUPPER' => {'text' => 'Returns a boolean indicating whether the C C is an uppercase character. bool isUPPER(char ch)','name' => 'isUPPER'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the stack. void XST_mYES(int pos)','name' => 'XST_mYES'},'sv_setsv' => {'text' => '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)','name' => 'sv_setsv'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. NV SvNV(SV* sv)','name' => 'SvNV'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'sv_setsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setsv_mg(SV *dstr, SV *sstr)','name' => 'sv_setsv_mg'},'hv_fetch_ent' => {'text' => '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)','name' => 'hv_fetch_ent'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'isLOWER' => {'text' => 'Returns a boolean indicating whether the C C is a lowercase character. bool isLOWER(char ch)','name' => 'isLOWER'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See C. char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'SvNOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a double. Checks the B setting. Use C. bool SvNOKp(SV* sv)','name' => 'SvNOKp'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an XSUB\'s aliases was used to invoke it. See L. I32 ix','name' => 'ix'},'StructCopy' => {'text' => 'This is an architecture-independant macro to copy one structure to another. void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'PUSHs' => {'text' => '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)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV. Does not handle \'set\' magic. See C. void sv_setuv(SV* sv, UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'dXSI32' => {'text' => 'Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. dXSI32;','name' => 'dXSI32'},'sv_setref_iv' => {'text' => '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)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => '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)','name' => 'sv_chop'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. See C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_grow' => {'text' => '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)','name' => 'sv_grow'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setuv_mg(SV *sv, UV u)','name' => 'sv_setuv_mg'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually handled automatically by C. See C.','name' => 'XS_VERSION'},'newSVnv' => {'text' => '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)','name' => 'newSVnv'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. See C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry. SV* HeVAL(HE* he)','name' => 'HeVAL'},'HePV' => {'text' => '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)','name' => 'HePV'},'PL_na' => {'text' => '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','name' => 'PL_na'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the SV is set to 1. SV* newSViv(IV i)','name' => 'newSViv'},'sv_setpv' => {'text' => '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)','name' => 'sv_setpv'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See C.','name' => 'SVt_PVHV'},'gv_fetchmethod' => {'text' => 'See L. GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'PL_DBsub' => {'text' => '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','name' => 'PL_DBsub'},'SvGETMAGIC' => {'text' => 'Invokes C on an SV if it has \'get\' magic. This macro evaluates its argument more than once. void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'SvGROW' => {'text' => '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)','name' => 'SvGROW'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV. void sv_inc(SV* sv)','name' => 'sv_inc'},'sv_usepvn' => {'text' => '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)','name' => 'sv_usepvn'},'sv_catpv' => {'text' => '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)','name' => 'sv_catpv'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'sv_len' => {'text' => 'Returns the length of the string in the SV. See also C. STRLEN sv_len(SV* sv)','name' => 'sv_len'},'warn' => {'text' => '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, ...)','name' => 'warn'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L. LEAVE;','name' => 'LEAVE'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See C.','name' => 'SVt_PVAV'},'hv_delete' => {'text' => '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)','name' => 'hv_delete'},'hv_undef' => {'text' => 'Undefines the hash. void hv_undef(HV* tb)','name' => 'hv_undef'},'hv_delete_ent' => {'text' => '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)','name' => 'hv_delete_ent'},'CLASS' => {'text' => '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','name' => 'CLASS'},'Newc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Newc(int id, void* ptr, int nitems, type, cast)','name' => 'Newc'},'sv_isobject' => {'text' => '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)','name' => 'sv_isobject'},'HeKLEN' => {'text' => '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)','name' => 'HeKLEN'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. See C. void PUSHn(NV nv)','name' => 'PUSHn'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it. IV SvIV(SV* sv)','name' => 'SvIV'},'sv_setiv' => {'text' => 'Copies an integer into the given SV. Does not handle \'set\' magic. See C. void sv_setiv(SV* sv, IV num)','name' => 'sv_setiv'},'EXTEND' => {'text' => '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)','name' => 'EXTEND'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. SV PL_sv_yes','name' => 'PL_sv_yes'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(UV u)','name' => 'newSVuv'},'SvNVX' => {'text' => 'Returns the double which is stored in the SV, assuming SvNOK is true. NV SvNVX(SV* sv)','name' => 'SvNVX'},'gv_fetchmeth' => {'text' => '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)','name' => 'gv_fetchmeth'},'looks_like_number' => {'text' => 'Test if an the content of an SV looks like a number (or is a number). I32 looks_like_number(SV* sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpv_mg(SV *sv, const char *ptr)','name' => 'sv_catpv_mg'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. U32 HeHASH(HE* he)','name' => 'HeHASH'},'SvIOK' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. bool SvIOK(SV* sv)','name' => 'SvIOK'},'newSVpv' => {'text' => '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)','name' => 'newSVpv'},'fbm_instr' => {'text' => '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)','name' => 'fbm_instr'},'sv_setpvf' => {'text' => '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, ...)','name' => 'sv_setpvf'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. See C. void XPUSHn(NV nv)','name' => 'XPUSHn'},'SvPV_force' => {'text' => '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)','name' => 'SvPV_force'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'call_sv' => {'text' => '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)','name' => 'call_sv'},'SVt_PV' => {'text' => 'Pointer type flag for scalars. See C.','name' => 'SVt_PV'},'strGT' => {'text' => '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)','name' => 'strGT'},'mg_get' => {'text' => 'Do magic after a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'},'SvTRUE' => {'text' => '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)','name' => 'SvTRUE'},'HeSVKEY_set' => {'text' => '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)','name' => 'HeSVKEY_set'},'POPl' => {'text' => 'Pops a long off the stack. long POPl','name' => 'POPl'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L. SPAGAIN;','name' => 'SPAGAIN'},'call_method' => {'text' => '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)','name' => 'call_method'},'sv_vsetpvfn' => {'text' => '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)','name' => 'sv_vsetpvfn'},'get_cv' => {'text' => '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)','name' => 'get_cv'},'SvIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. Checks the B setting. Use C. bool SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the stack. void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'perl_parse' => {'text' => '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)','name' => 'perl_parse'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory used by the array itself. void av_clear(AV* ar)','name' => 'av_clear'},'av_unshift' => {'text' => '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)','name' => 'av_unshift'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C. int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV. The new SV is marked as mortal. SV* sv_mortalcopy(SV* oldsv)','name' => 'sv_mortalcopy'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See L.','name' => 'G_NOARGS'},'PL_DBsingle' => {'text' => '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','name' => 'PL_DBsingle'},'SvUVX' => {'text' => 'Returns the unsigned integer which is stored in the SV, assuming SvIOK is true. UV SvUVX(SV* sv)','name' => 'SvUVX'},'Newz' => {'text' => '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)','name' => 'Newz'},'savepvn' => {'text' => '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)','name' => 'savepvn'},'eval_sv' => {'text' => '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)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C. STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'Move' => {'text' => '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)','name' => 'Move'},'GIMME' => {'text' => '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','name' => 'GIMME'},'NEWSV' => {'text' => '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)','name' => 'NEWSV'},'sv_bless' => {'text' => '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)','name' => 'sv_bless'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs.','name' => 'newXS'},'isALNUM' => {'text' => 'Returns a boolean indicating whether the C C is an ascii alphanumeric character or digit. bool isALNUM(char ch)','name' => 'isALNUM'},'sv_isa' => {'text' => '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)','name' => 'sv_isa'},'sv_catpvf' => {'text' => '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, ...)','name' => 'sv_catpvf'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C. void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the C C is an ascii alphabetic character. bool isALPHA(char ch)','name' => 'isALPHA'},'Nullhv' => {'text' => 'Null HV pointer.','name' => 'Nullhv'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV. SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter* interp)','name' => 'perl_construct'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C. svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV. void sv_dec(SV* sv)','name' => 'sv_dec'},'strLE' => {'text' => '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)','name' => 'strLE'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L. void perl_free(PerlInterpreter* interp)','name' => 'perl_free'},'SvOK' => {'text' => 'Returns a boolean indicating whether the value is an SV. bool SvOK(SV* sv)','name' => 'SvOK'},'sv_setref_nv' => {'text' => '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)','name' => 'sv_setref_nv'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C. MAGIC* mg_find(SV* sv, int type)','name' => 'mg_find'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the C C is an ascii digit. bool isDIGIT(char ch)','name' => 'isDIGIT'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'eval_pv' => {'text' => '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)','name' => 'eval_pv'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_setpvf_mg'},'SvPOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. Checks the B setting. Use C. bool SvPOKp(SV* sv)','name' => 'SvPOKp'},'sv_catpvn' => {'text' => '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)','name' => 'sv_catpvn'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. void newCONSTSUB(HV* stash, char* name, SV* sv)','name' => 'newCONSTSUB'},'sv_setref_pv' => {'text' => '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)','name' => 'sv_setref_pv'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_pop(AV* ar)','name' => 'av_pop'},'fbm_compile' => {'text' => '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)','name' => 'fbm_compile'},'SvNIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. Checks the B setting. Use C. bool SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'croak' => {'text' => '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, ...)','name' => 'croak'},'THIS' => {'text' => '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','name' => 'THIS'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually handled by C. void XSRETURN(int nitems)','name' => 'XSRETURN'},'sv_setref_pvn' => {'text' => '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)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for blessed scalars. See C.','name' => 'SVt_PVMG'},'PUSHp' => {'text' => '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)','name' => 'PUSHp'},'Nullcv' => {'text' => 'Null CV pointer.','name' => 'Nullcv'},'get_av' => {'text' => '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)','name' => 'get_av'},'PL_sv_undef' => {'text' => 'This is the C SV. Always refer to this as C<&PL_sv_undef>. SV PL_sv_undef','name' => 'PL_sv_undef'},'hv_iterkeysv' => {'text' => '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)','name' => 'hv_iterkeysv'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the stack. void XST_mNO(int pos)','name' => 'XST_mNO'},'toUPPER' => {'text' => 'Converts the specified character to uppercase. char toUPPER(char ch)','name' => 'toUPPER'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'PL_dowarn' => {'text' => 'The C variable which corresponds to Perl\'s $^W warning variable. bool PL_dowarn','name' => 'PL_dowarn'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'Zero' => {'text' => '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)','name' => 'Zero'},'hv_fetch' => {'text' => '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)','name' => 'hv_fetch'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'Nullch' => {'text' => 'Null character pointer.','name' => 'Nullch'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)','name' => 'mg_copy'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'newSVpvn' => {'text' => '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)','name' => 'newSVpvn'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C.','name' => 'SVt_PVCV'},'av_push' => {'text' => '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)','name' => 'av_push'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV *sv)','name' => 'newRV_noinc'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV* ar, I32 key)','name' => 'av_extend'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpviv_mg(SV *sv, IV iv)','name' => 'sv_setpviv_mg'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. HE* hv_iternext(HV* tb)','name' => 'hv_iternext'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'sv_newmortal' => {'text' => 'Creates a new SV which is mortal. The reference count of the SV is set to 1. SV* sv_newmortal()','name' => 'sv_newmortal'},'hv_iterinit' => {'text' => '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)','name' => 'hv_iterinit'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.006', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_016_001.pm0000644000175000017500000000040712131460030020737 0ustar tseetseepackage Perl::APIReference::V5_016_001; use strict; use warnings; use parent 'Perl::APIReference::V5_016_000'; sub new { my $class = shift; my $obj = $class->SUPER::new(@_); $obj->{perl_version} = '5.016001'; bless $obj => $class; return $obj; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/Generator.pm0000644000175000017500000000622611653441731021451 0ustar tseetseepackage Perl::APIReference::Generator; use 5.006; use strict; use warnings; use Carp qw/croak/; use Pod::Eventual::Simple; use Perl::APIReference; our $VERSION = '0.01'; sub parse { shift if @_ and defined $_[0] and $_[0] eq __PACKAGE__; my %args = @_; my $perl_version = $args{perl_version}; croak("Bad perl version '$perl_version'") if not defined $perl_version or $perl_version !~ /^5/; my $file = $args{file}; croak("Bad input file") if not defined $file or not -e $file; my $output = Pod::Eventual::Simple->read_file($file); croak("Failed to parse POD") if not defined $output; my $entries = _get_entries($output); return Perl::APIReference->_new_from_parse( perl_version => $perl_version, index => $entries, ); } sub _get_entries { my $output = shift; my $in_entry = 0; my $entry = {}; my $entries = {}; # TODO add "section" # TODO review and robustify foreach my $node (@$output) { my $type = $node->{type}; next if $type eq 'nonpod'; my $command = $node->{command}; if ($in_entry) { if ($type eq 'command') { if ($command eq 'item') { _finish_entry($entry, $entries); $in_entry = _start_entry($entry, $node); } elsif ($command eq 'back') { $in_entry = 0; _finish_entry($entry, $entries); } } elsif ($type eq 'text' or $type eq 'blank') { $entry->{text} .= $node->{content}; } } # end if in entry else { if ($type eq 'command' and $command eq 'item') { $in_entry = _start_entry($entry, $node); } } # end if not in entry } _finish_entry($entry, $entries); return $entries; } sub _finish_entry { my $entry = shift; my $entries = shift; if (not defined $entry->{name} or not defined $entry->{text}) { return; } $entry->{text} =~ s/\s+$//; $entry->{text} =~ s/^\s+//; # TODO fix collisions! $entries->{$entry->{name}} = {%$entry}; %$entry = (); return(); } sub _start_entry { my $entry = shift; my $node = shift; my $name = $node->{content}; $name =~ s/\s+$//; $name =~ /([^\n]+)/ or return; $name = $1; %$entry = ( name => $name, text => '', ); return(1); } 1; __END__ =head1 NAME Perl::APIReference::Generator - Generate an APIReference from a perlapi.pod =head1 SYNOPSIS use Perl::APIReference::Generator; my $api = Perl::APIReference::Generator->parse( file => 'perlapi.5.10.0.pod', perl_version => '5.10.0', ); # $api is now a Perl::APIReference object =head1 DESCRIPTION Generate a perl API reference object from a F file. This is a maintainer's tool and requires L and a small change to the main F file if the perl API version isn't supported yet. =head1 SEE ALSO L L =head1 AUTHOR Steffen Mueller, Esmueller@cpan.orgE =head1 COPYRIGHT AND LICENSE Copyright (C) 2009 by Steffen Mueller This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself, either Perl version 5.6.0 or, at your option, any later version of Perl 5 you may have available. =cut Perl-APIReference-0.16/lib/Perl/APIReference/V5_016_002.pm0000644000175000017500000000071112131460064020745 0ustar tseetseepackage Perl::APIReference::V5_016_002; use strict; use warnings; use parent 'Perl::APIReference::V5_016_000'; sub new { my $class = shift; my $obj = $class->SUPER::new(@_); $obj->{perl_version} = '5.016002'; bless $obj => $class; # Override the only change since 5.16.0 $obj->{'index'}{'mg_get'} = {'text' => 'Do magic before a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'}; return $obj; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_014_001.pm0000644000175000017500000000040711653441731020754 0ustar tseetseepackage Perl::APIReference::V5_014_001; use strict; use warnings; use parent 'Perl::APIReference::V5_014_000'; sub new { my $class = shift; my $obj = $class->SUPER::new(@_); $obj->{perl_version} = '5.014001'; bless $obj => $class; return $obj; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_014_000.pm0000644000175000017500000104377211653441731020770 0ustar tseetseepackage Perl::APIReference::V5_014_000; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'newBINOP' => {'text' => 'Constructs, checks, and returns an op of any binary type. I is the opcode. I gives the eight bits of C, except that C will be set automatically, and, shifted up eight bits, the eight bits of C, except that the bit with value 1 or 2 is automatically set as required. I and I supply up to two ops to be the direct children of the binary op; they are consumed by this function and become part of the constructed op tree. OP * newBINOP(I32 type, I32 flags, OP *first, OP *last)','name' => 'newBINOP'},'strGE' => {'text' => '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)','name' => 'strGE'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified version becoming C. Handles \'get\' magic. See also C for a version which guarantees to evaluate sv only once. char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'sv_vsetpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vsetpvf_mg(SV *const sv, const char *const pat, va_list *const args)','name' => 'sv_vsetpvf_mg'},'SvPVutf8' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'sortsv_flags' => {'text' => 'Sort an array, with various options. void sortsv_flags(SV** array, size_t num_elts, SVCOMPARE_t cmp, U32 flags)','name' => 'sortsv_flags'},'vwarn' => {'text' => 'This is an XS interface to Perl\'s C function. C and C are a sprintf-style format pattern and encapsulated argument list. These are used to generate a string message. If the message does not end with a newline, then it will be extended with some indication of the current location in the code, as described for L. The error message or object will by default be written to standard error, but this is subject to modification by a C<$SIG{__WARN__}> handler. Unlike with L, C is not permitted to be null. void vwarn(const char *pat, va_list *args)','name' => 'vwarn'},'scan_oct' => {'text' => 'For backwards compatibility. Use C instead. NV scan_oct(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_oct'},'my_strlcat' => {'text' => '','name' => 'my_strlcat'},'av_arylen_p' => {'text' => '','name' => 'av_arylen_p'},'gv_add_by_type' => {'text' => '','name' => 'gv_add_by_type'},'newGVOP' => {'text' => 'Constructs, checks, and returns an op of any type that involves an embedded reference to a GV. I is the opcode. I gives the eight bits of C. I identifies the GV that the op should reference; calling this function does not transfer ownership of any reference to it. OP * newGVOP(I32 type, I32 flags, GV *gv)','name' => 'newGVOP'},'XopDISABLE' => {'text' => 'Temporarily disable a member of the XOP, by clearing the appropriate flag. void XopDISABLE(XOP *xop, which)','name' => 'XopDISABLE'},'is_uni_ascii' => {'text' => '','name' => 'is_uni_ascii'},'find_runcv' => {'text' => 'Locate the CV corresponding to the currently executing sub or eval. If db_seqp is non_null, skip CVs that are in the DB package and populate *db_seqp with the cop sequence number at the point that the DB:: code was entered. (allows debuggers to eval in the scope of the breakpoint rather than in the scope of the debugger itself). CV* find_runcv(U32 *db_seqp)','name' => 'find_runcv'},'utf8n_to_uvuni' => {'text' => 'Bottom level UTF-8 decode routine. Returns the code point value of the first character in the string C which is assumed to be in UTF-8 (or UTF-EBCDIC) encoding and no longer than C bytes; C will be set to the length, in bytes, of that character. The value of C determines the behavior when C does not point to a well-formed UTF-8 character. If C is 0, when a malformation is found, C is set to the expected length of the UTF-8 character in bytes, zero is returned, and if UTF-8 warnings haven\'t been lexically disabled, a warning is raised. Various ALLOW flags can be set in C to allow (and not warn on) individual types of malformations, such as the sequence being overlong (that is, when there is a shorter sequence that can express the same code point; overlong sequences are expressly forbidden in the UTF-8 standard due to potential security issues). Another malformation example is the first byte of a character not being a legal first byte. See F for the list of such flags. Of course, the value returned by this function under such conditions is not reliable. The UTF8_CHECK_ONLY flag overrides the behavior when a non-allowed (by other flags) malformation is found. If this flag is set, the routine assumes that the caller will raise a warning, and this function will silently just set C to C<-1> and return zero. Certain code points are considered problematic. These are Unicode surrogates, Unicode non-characters, and code points above the Unicode maximum of 0x10FFF. By default these are considered regular code points, but certain situations warrant special handling for them. if C contains UTF8_DISALLOW_ILLEGAL_INTERCHANGE, all three classes are treated as malformations and handled as such. The flags UTF8_DISALLOW_SURROGATE, UTF8_DISALLOW_NONCHAR, and UTF8_DISALLOW_SUPER (meaning above the legal Unicode maximum) can be set to disallow these categories individually. The flags UTF8_WARN_ILLEGAL_INTERCHANGE, UTF8_WARN_SURROGATE, UTF8_WARN_NONCHAR, and UTF8_WARN_SUPER will cause warning messages to be raised for their respective categories, but otherwise the code points are considered valid (not malformations). To get a category to both be treated as a malformation and raise a warning, specify both the WARN and DISALLOW flags. (But note that warnings are not raised if lexically disabled nor if UTF8_CHECK_ONLY is also specified.) Very large code points (above 0x7FFF_FFFF) are considered more problematic than the others that are above the Unicode legal maximum. There are several reasons, one of which is that the original UTF-8 specification never went above this number (the current 0x10FFF limit was imposed later). The UTF-8 encoding on ASCII platforms for these large code point begins with a byte containing 0xFE or 0xFF. The UTF8_DISALLOW_FE_FF flag will cause them to be treated as malformations, while allowing smaller above-Unicode code points. (Of course UTF8_DISALLOW_SUPER will treat all above-Unicode code points, including these, as malformations.) Similarly, UTF8_WARN_FE_FF acts just like the other WARN flags, but applies just to these code points. All other code points corresponding to Unicode characters, including private use and those yet to be assigned, are never considered malformed and never warn. Most code should use utf8_to_uvchr() rather than call this directly. UV utf8n_to_uvuni(const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvuni'},'newSVpvn_utf8' => {'text' => 'Creates a new SV and copies a string into it. If utf8 is true, calls C on the new SV. Implemented as a wrapper around C. SV* newSVpvn_utf8(NULLOK const char* s, STRLEN len, U32 utf8)','name' => 'newSVpvn_utf8'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'pregcomp' => {'text' => '','name' => 'pregcomp'},'my_cxt_index' => {'text' => '','name' => 'my_cxt_index'},'lex_discard_to' => {'text' => 'Discards the first part of the Llinestr> buffer, up to I. The remaining content of the buffer will be moved, and all pointers into the buffer updated appropriately. I must not be later in the buffer than the position of Lbufptr>: it is not permitted to discard text that has yet to be lexed. Normally it is not necessarily to do this directly, because it suffices to use the implicit discarding behaviour of L and things based on it. However, if a token stretches across multiple lines, and the lexing code has kept multiple lines of text in the buffer for that purpose, then after completion of the token it would be wise to explicitly discard the now-unneeded earlier lines, to avoid future multi-line tokens growing the buffer without bound. NOTE: this function is experimental and may change or be removed without notice. void lex_discard_to(char *ptr)','name' => 'lex_discard_to'},'markstack_grow' => {'text' => '','name' => 'markstack_grow'},'cv_get_call_checker' => {'text' => 'Retrieves the function that will be used to fix up a call to I. Specifically, the function is applied to an C op tree for a subroutine call, not marked with C<&>, where the callee can be identified at compile time as I. The C-level function pointer is returned in I<*ckfun_p>, and an SV argument for it is returned in I<*ckobj_p>. The function is intended to be called in this manner: entersubop = (*ckfun_p)(aTHX_ entersubop, namegv, (*ckobj_p)); In this call, I is a pointer to the C op, which may be replaced by the check function, and I is a GV supplying the name that should be used by the check function to refer to the callee of the C op if it needs to emit any diagnostics. It is permitted to apply the check function in non-standard situations, such as to a call to a different subroutine or to a method call. By default, the function is L, and the SV parameter is I itself. This implements standard prototype processing. It can be changed, for a particular subroutine, by L. void cv_get_call_checker(CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p)','name' => 'cv_get_call_checker'},'mXPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Does not use C. See also C, C and C. void mXPUSHp(char* str, STRLEN len)','name' => 'mXPUSHp'},'lex_stuff_sv' => {'text' => 'Insert characters into the lexer buffer (Llinestr>), immediately after the current lexing point (Lbufptr>), reallocating the buffer if necessary. This means that lexing code that runs later will see the characters as if they had appeared in the input. It is not recommended to do this as part of normal parsing, and most uses of this facility run the risk of the inserted characters being interpreted in an unintended manner. The string to be inserted is the string value of I. The characters are recoded for the lexer buffer, according to how the buffer is currently being interpreted (L). If a string to be inserted is not already a Perl scalar, the L function avoids the need to construct a scalar. NOTE: this function is experimental and may change or be removed without notice. void lex_stuff_sv(SV *sv, U32 flags)','name' => 'lex_stuff_sv'},'ibcmp_utf8' => {'text' => 'This is a synonym for (! foldEQ_utf8()) I32 ibcmp_utf8(const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2)','name' => 'ibcmp_utf8'},'CvSTASH' => {'text' => 'Returns the stash of the CV. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'gv_const_sv' => {'text' => 'If C is a typeglob whose subroutine entry is a constant sub eligible for inlining, or C is a placeholder reference that would be promoted to such a typeglob, then returns the value returned by the sub. Otherwise, returns NULL. SV* gv_const_sv(GV* gv)','name' => 'gv_const_sv'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. The target SV physically takes over ownership of the body of the source SV and inherits its flags; however, the target keeps any magic it owns, and any magic in the source is discarded. Note that this is a rather specialist SV copying operation; most of the time you\'ll want to use C or one of its many macro front-ends. void sv_replace(SV *const sv, SV *const nsv)','name' => 'sv_replace'},'utf8n_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. length and flags are the same as utf8n_to_uvuni(). UV utf8n_to_uvchr(const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvchr'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and L.','name' => 'G_ARRAY'},'sv_2iv' => {'text' => '','name' => 'sv_2iv'},'ck_warner_d' => {'text' => '','name' => 'ck_warner_d'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'mXPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void mXPUSHn(NV nv)','name' => 'mXPUSHn'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'is_utf8_punct' => {'text' => '','name' => 'is_utf8_punct'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dsv, SV *ssv)','name' => 'sv_catsv_mg'},'call_argv' => {'text' => '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)','name' => 'call_argv'},'save_freeop' => {'text' => '','name' => 'save_freeop'},'SvPV_nolen' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified form becoming C. Handles \'get\' magic. char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'perl_clone' => {'text' => '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->create 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 C, 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 *proto_perl, UV flags)','name' => 'perl_clone'},'save_alloc' => {'text' => '','name' => 'save_alloc'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'rninstr' => {'text' => '','name' => 'rninstr'},'hv_fetchs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV** hv_fetchs(HV* tb, const char* key, I32 lval)','name' => 'hv_fetchs'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'cophh_store_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of a string/length pair. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_store_pv(const COPHH *cophh, const char *key, U32 hash, SV *value, U32 flags)','name' => 'cophh_store_pv'},'savepv' => {'text' => 'Perl\'s version of C. Returns a pointer to a newly allocated string which is a duplicate of C. The size of the string is determined by C. The memory allocated for the new string can be freed with the C function. char* savepv(const char* pv)','name' => 'savepv'},'save_iv' => {'text' => '','name' => 'save_iv'},'HvNAME' => {'text' => 'Returns the package name of a stash, or NULL if C isn\'t a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV of the sv is assumed to be octets in that encoding, and the sv will be converted into Unicode (and UTF-8). If the sv already is UTF-8 (or if it is not POK), or if the encoding is not a reference, nothing is done to the sv. If the encoding is not an C Encoding object, bad things will happen. (See F and L). The PV of the sv is returned. char* sv_recode_to_utf8(SV* sv, SV *encoding)','name' => 'sv_recode_to_utf8'},'save_hptr' => {'text' => '','name' => 'save_hptr'},'runops_debug' => {'text' => '','name' => 'runops_debug'},'do_gvgv_dump' => {'text' => '','name' => 'do_gvgv_dump'},'PERL_SYS_INIT' => {'text' => 'Provides system-specific tune up of the C runtime environment necessary to run Perl interpreters. This should be called only once, before creating any Perl interpreters. void PERL_SYS_INIT(int argc, char** argv)','name' => 'PERL_SYS_INIT'},'vstringify' => {'text' => 'In order to maintain maximum compatibility with earlier versions of Perl, this function will return either the floating point notation or the multiple dotted notation, depending on whether the original version contained 1 or more dots, respectively. The SV returned has a refcount of 1. SV* vstringify(SV *vs)','name' => 'vstringify'},'sv_catsv_flags' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. If C has C bit set, will C on the SVs if appropriate, else not. C and C are implemented in terms of this function. void sv_catsv_flags(SV *const dsv, SV *const ssv, const I32 flags)','name' => 'sv_catsv_flags'},'is_uni_alpha' => {'text' => '','name' => 'is_uni_alpha'},'str_to_version' => {'text' => '','name' => 'str_to_version'},'sv_derived_from' => {'text' => 'Returns a boolean indicating whether the SV is derived from the specified class I. To check derivation at the Perl level, call C as a normal Perl method. bool sv_derived_from(SV* sv, const char *const name)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp_locale(SV *const sv1, SV *const sv2)','name' => 'sv_cmp_locale'},'sv_catpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_catpvs(SV* sv, const char* s)','name' => 'sv_catpvs'},'set_numeric_standard' => {'text' => '','name' => 'set_numeric_standard'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'Nullsv' => {'text' => 'Null SV pointer. (No longer available when C is defined.)','name' => 'Nullsv'},'scan_vstring' => {'text' => '','name' => 'scan_vstring'},'ptr_table_new' => {'text' => '','name' => 'ptr_table_new'},'do_op_dump' => {'text' => '','name' => 'do_op_dump'},'foldEQ' => {'text' => 'Returns true if the leading len bytes of the strings s1 and s2 are the same case-insensitively; false otherwise. Uppercase and lowercase ASCII range bytes match themselves and their opposite case counterparts. Non-cased and non-ASCII range bytes match only themselves. I32 foldEQ(const char* a, const char* b, I32 len)','name' => 'foldEQ'},'PerlIO_get_base' => {'text' => '','name' => 'PerlIO_get_base'},'SvPVX' => {'text' => 'Returns a pointer to the physical string in the SV. The SV must contain a string. char* SvPVX(SV* sv)','name' => 'SvPVX'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'is_utf8_perl_word' => {'text' => '','name' => 'is_utf8_perl_word'},'debop' => {'text' => '','name' => 'debop'},'ref' => {'text' => '','name' => 'ref'},'is_uni_print_lc' => {'text' => '','name' => 'is_uni_print_lc'},'SvOOK_offset' => {'text' => 'Reads into I the offset from SvPVX back to the true start of the allocated buffer, which will be non-zero if C has been used to efficiently remove characters from start of the buffer. Implemented as a macro, which takes the address of I, which must be of type C. Evaluates I more than once. Sets I to 0 if C is false. void SvOOK_offset(NN SV*sv, STRLEN len)','name' => 'SvOOK_offset'},'save_list' => {'text' => '','name' => 'save_list'},'is_uni_idfirst_lc' => {'text' => '','name' => 'is_uni_idfirst_lc'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted if tainting is enabled. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'newGIVENOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C block. I supplies the expression that will be locally assigned to a lexical variable, and I supplies the body of the C construct; they are consumed by this function and become part of the constructed op tree. I is the pad offset of the scalar lexical variable that will be affected. OP * newGIVENOP(OP *cond, OP *block, PADOFFSET defsv_off)','name' => 'newGIVENOP'},'sv_nolocking' => {'text' => '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. "Superseded" by sv_nosharing(). void sv_nolocking(SV *sv)','name' => 'sv_nolocking'},'parse_listexpr' => {'text' => 'Parse a Perl list expression. This may contain operators of precedence down to the comma operator. The expression must be followed (and thus terminated) either by a low-precedence logic operator such as C or by something that would normally terminate an expression such as semicolon. If I includes C then the expression is optional, otherwise it is mandatory. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed and the lexical context for the expression. The op tree representing the expression is returned. If an optional expression is absent, a null pointer is returned, otherwise the pointer will be non-null. If an error occurs in parsing or compilation, in most cases a valid op tree is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. Some compilation errors, however, will throw an exception immediately. NOTE: this function is experimental and may change or be removed without notice. OP * parse_listexpr(U32 flags)','name' => 'parse_listexpr'},'ibcmp' => {'text' => 'This is a synonym for (! foldEQ()) I32 ibcmp(const char* a, const char* b, I32 len)','name' => 'ibcmp'},'isWORDCHAR' => {'text' => 'Returns a boolean indicating whether the specified character is a character that is any of: alphabetic, numeric, or an underscore. This is the same as what C<\\w> matches in a regular expression. C is a synonym provided for backward compatibility. Note that it does not have the standard C language meaning of alphanumeric, since it matches an underscore and the standard meaning does not. See the L for an explanation of variants C and C. bool isWORDCHAR(char ch)','name' => 'isWORDCHAR'},'Slab_Alloc' => {'text' => '','name' => 'Slab_Alloc'},'strLT' => {'text' => '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)','name' => 'strLT'},'save_pushptr' => {'text' => '','name' => 'save_pushptr'},'save_clearsv' => {'text' => '','name' => 'save_clearsv'},'Slab_Free' => {'text' => '','name' => 'Slab_Free'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_shift(AV *av)','name' => 'av_shift'},'sv_setpvf_nocontext' => {'text' => '','name' => 'sv_setpvf_nocontext'},'sv_nounlocking' => {'text' => '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. "Superseded" by sv_nosharing(). void sv_nounlocking(SV *sv)','name' => 'sv_nounlocking'},'perl_clone_using' => {'text' => '','name' => 'perl_clone_using'},'PerlIO_context_layers' => {'text' => '','name' => 'PerlIO_context_layers'},'lex_unstuff' => {'text' => 'Discards text about to be lexed, from Lbufptr> up to I. Text following I will be moved, and the buffer shortened. This hides the discarded text from any lexing code that runs later, as if the text had never appeared. This is not the normal way to consume lexed text. For that, use L. NOTE: this function is experimental and may change or be removed without notice. void lex_unstuff(char *ptr)','name' => 'lex_unstuff'},'newSVpvf_nocontext' => {'text' => '','name' => 'newSVpvf_nocontext'},'SvUV_set' => {'text' => 'Set the value of the UV pointer in sv to val. See C. void SvUV_set(SV* sv, UV val)','name' => 'SvUV_set'},'rvpv_dup' => {'text' => '','name' => 'rvpv_dup'},'filter_read' => {'text' => '','name' => 'filter_read'},'ckwarn' => {'text' => '','name' => 'ckwarn'},'warner' => {'text' => '','name' => 'warner'},'savesharedsvpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedsvpv(SV *sv)','name' => 'savesharedsvpv'},'CopyD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * CopyD(void* src, void* dest, int nitems, type)','name' => 'CopyD'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *const sv, const IV i)','name' => 'sv_setiv_mg'},'newFOROP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C loop (iteration through a list of values). This is a heavyweight loop, with structure that allows exiting the loop by C and suchlike. I optionally supplies the variable that will be aliased to each item in turn; if null, it defaults to C<$_> (either lexical or global). I supplies the list of values to iterate over. I supplies the main body of the loop, and I optionally supplies a C block that operates as a second half of the body. All of these optree inputs are consumed by this function and become part of the constructed op tree. I gives the eight bits of C for the C op and, shifted up eight bits, the eight bits of C for the C op, except that (in both cases) some bits will be set automatically. OP * newFOROP(I32 flags, OP *sv, OP *expr, OP *block, OP *cont)','name' => 'newFOROP'},'HvENAME' => {'text' => 'Returns the effective name of a stash, or NULL if there is none. The effective name represents a location in the symbol table where this stash resides. It is updated automatically when packages are aliased or deleted. A stash that is no longer in the symbol table has no effective name. This name is preferable to C for use in MRO linearisations and isa caches. char* HvENAME(HV* stash)','name' => 'HvENAME'},'save_generic_svref' => {'text' => '','name' => 'save_generic_svref'},'savesharedpvn' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. (With the specific difference that a NULL pointer is not acceptable) char* savesharedpvn(const char *const pv, const STRLEN len)','name' => 'savesharedpvn'},'SvCUR_set' => {'text' => 'Set the current length of the string which is in the SV. See C and C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'sv_2pv' => {'text' => '','name' => 'sv_2pv'},'SvNOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a double. U32 SvNOK(SV* sv)','name' => 'SvNOK'},'mPUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void mPUSHn(NV nv)','name' => 'mPUSHn'},'is_uni_digit_lc' => {'text' => '','name' => 'is_uni_digit_lc'},'sv_reset' => {'text' => 'Underlying implementation for the C Perl function. Note that the perl-level function is vaguely deprecated. void sv_reset(const char* s, HV *const stash)','name' => 'sv_reset'},'cophh_delete_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of a string/length pair. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_delete_pv(const COPHH *cophh, const char *key, U32 hash, U32 flags)','name' => 'cophh_delete_pv'},'sv_2pv_flags' => {'text' => 'Returns a pointer to the string value of an SV, and sets *lp to its length. If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string if necessary. Normally invoked via the C macro. C and C usually end up here too. char* sv_2pv_flags(SV *const sv, STRLEN *const lp, const I32 flags)','name' => 'sv_2pv_flags'},'push_scope' => {'text' => '','name' => 'push_scope'},'SvNVx' => {'text' => 'Coerces the given SV to a double and returns it. Guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. NV SvNVx(SV* sv)','name' => 'SvNVx'},'setdefout' => {'text' => 'Sets PL_defoutgv, the default file handle for output, to the passed in typeglob. As PL_defoutgv "owns" a reference on its typeglob, the reference count of the passed in typeglob is increased by one, and the reference count of the typeglob that PL_defoutgv points to is decreased by one. void setdefout(GV* gv)','name' => 'setdefout'},'form_nocontext' => {'text' => '','name' => 'form_nocontext'},'hv_store' => {'text' => '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. Effectively a successful hv_store takes ownership of one reference to C. 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 L for more information on how to use this function on tied hashes. SV** hv_store(HV *hv, const char *key, I32 klen, SV *val, U32 hash)','name' => 'hv_store'},'sys_intern_dup' => {'text' => '','name' => 'sys_intern_dup'},'do_binmode' => {'text' => '','name' => 'do_binmode'},'get_op_names' => {'text' => '','name' => 'get_op_names'},'cop_hints_fetch_sv' => {'text' => 'Like L, but takes a Perl scalar instead of a string/length pair. SV * cop_hints_fetch_sv(const COP *cop, SV *key, U32 hash, U32 flags)','name' => 'cop_hints_fetch_sv'},'ck_entersub_args_proto_or_list' => {'text' => 'Performs the fixup of the arguments part of an C op tree either based on a subroutine prototype or using default list-context processing. This is the standard treatment used on a subroutine call, not marked with C<&>, where the callee can be identified at compile time. I supplies the subroutine prototype to be applied to the call, or indicates that there is no prototype. It may be a normal scalar, in which case if it is defined then the string value will be used as a prototype, and if it is undefined then there is no prototype. Alternatively, for convenience, it may be a subroutine object (a C that has been cast to C), of which the prototype will be used if it has one. The prototype (or lack thereof) supplied, in whichever form, does not need to match the actual callee referenced by the op tree. If the argument ops disagree with the prototype, for example by having an unacceptable number of arguments, a valid op tree is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. In the error message, the callee is referred to by the name defined by the I parameter. OP * ck_entersub_args_proto_or_list(OP *entersubop, GV *namegv, SV *protosv)','name' => 'ck_entersub_args_proto_or_list'},'op_null' => {'text' => '','name' => 'op_null'},'hv_fetch_ent' => {'text' => '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 *hv, SV *keysv, I32 lval, U32 hash)','name' => 'hv_fetch_ent'},'gv_fetchpvn_flags' => {'text' => '','name' => 'gv_fetchpvn_flags'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'Newx' => {'text' => 'The XSUB-writer\'s interface to the C C function. In 5.9.3, Newx() and friends replace the older New() API, and drops the first parameter, I, a debug aid which allowed callers to identify themselves. This aid has been superseded by a new build option, PERL_MEM_LOG (see L). The older API is still there for use in XS modules supporting older perls. void Newx(void* ptr, int nitems, type)','name' => 'Newx'},'newFORM' => {'text' => '','name' => 'newFORM'},'PUSHs' => {'text' => 'Push an SV onto the stack. The stack must have room for this element. Does not handle \'set\' magic. Does not use C. See also C, C and C. void PUSHs(SV* sv)','name' => 'PUSHs'},'to_uni_upper_lc' => {'text' => '','name' => 'to_uni_upper_lc'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setuv(SV *const sv, const UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'is_uni_upper_lc' => {'text' => '','name' => 'is_uni_upper_lc'},'do_aspawn' => {'text' => '','name' => 'do_aspawn'},'sv_pvn' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn(SV *sv, STRLEN *lp)','name' => 'sv_pvn'},'do_openn' => {'text' => '','name' => 'do_openn'},'mro_get_from_name' => {'text' => '','name' => 'mro_get_from_name'},'sv_setref_iv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_iv(SV *const rv, const char *const classname, const IV iv)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => '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. Uses the "OOK hack". Beware: after this function returns, C and SvPVX_const(sv) may no longer refer to the same chunk of data. void sv_chop(SV *const sv, const char *const ptr)','name' => 'sv_chop'},'sv_backoff' => {'text' => 'Remove any string offset. You should normally use the C macro wrapper instead. int sv_backoff(SV *const sv)','name' => 'sv_backoff'},'reentrant_retry' => {'text' => '','name' => 'reentrant_retry'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_pvn_nomg' => {'text' => '','name' => 'sv_pvn_nomg'},'is_uni_space_lc' => {'text' => '','name' => 'is_uni_space_lc'},'stack_grow' => {'text' => '','name' => 'stack_grow'},'dump_mstats' => {'text' => '','name' => 'dump_mstats'},'newLOOPEX' => {'text' => 'Constructs, checks, and returns a loop-exiting op (such as C or C). I is the opcode. I function may be more convenient. void croak_sv(SV *baseex)','name' => 'croak_sv'},'warn_nocontext' => {'text' => '','name' => 'warn_nocontext'},'my_swap' => {'text' => '','name' => 'my_swap'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'MoveD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * MoveD(void* src, void* dest, int nitems, type)','name' => 'MoveD'},'gv_IOadd' => {'text' => '','name' => 'gv_IOadd'},'grok_bin' => {'text' => 'converts a string representing a binary number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*flags> gives output flags. If the value is <= C it is returned as a UV, the output flags are clear, and nothing is written to I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The binary number may optionally be prefixed with "0b" or "b" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the binary number may use \'_\' characters to separate digits. UV grok_bin(const char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_bin'},'parse_barestmt' => {'text' => 'Parse a single unadorned Perl statement. This may be a normal imperative statement or a declaration that has compile-time effect. It does not include any label or other affixture. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed and the lexical context for the statement. The op tree representing the statement is returned. This may be a null pointer if the statement is null, for example if it was actually a subroutine definition (which has compile-time side effects). If not null, it will be ops directly implementing the statement, suitable to pass to L. It will not normally include a C or equivalent op (except for those embedded in a scope contained entirely within the statement). If an error occurs in parsing or compilation, in most cases a valid op tree (most likely null) is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. Some compilation errors, however, will throw an exception immediately. The I parameter is reserved for future use, and must always be zero. NOTE: this function is experimental and may change or be removed without notice. OP * parse_barestmt(U32 flags)','name' => 'parse_barestmt'},'cast_uv' => {'text' => '','name' => 'cast_uv'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L. void perl_free(PerlInterpreter *my_perl)','name' => 'perl_free'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C. MAGIC* mg_find(const SV* sv, int type)','name' => 'mg_find'},'safesysfree' => {'text' => '','name' => 'safesysfree'},'BhkENTRY_set' => {'text' => 'Set an entry in the BHK structure, and set the flags to indicate it is valid. I is a preprocessing token indicating which entry to set. The type of I depends on the entry. NOTE: this function is experimental and may change or be removed without notice. void BhkENTRY_set(BHK *hk, which, void *ptr)','name' => 'BhkENTRY_set'},'PL_parser-Elinestr' => {'text' => 'Buffer scalar containing the chunk currently under consideration of the text currently being lexed. This is always a plain string scalar (for which C is true). It is not intended to be used as a scalar by normal scalar means; instead refer to the buffer directly by the pointer variables described below. The lexer maintains various C pointers to things in the Clinestr> buffer. If Clinestr> is ever reallocated, all of these pointers must be updated. Don\'t attempt to do this manually, but rather use L if you need to reallocate the buffer. The content of the text chunk in the buffer is commonly exactly one complete line of input, up to and including a newline terminator, but there are situations where it is otherwise. The octets of the buffer may be intended to be interpreted as either UTF-8 or Latin-1. The function L tells you which. Do not use the C flag on this scalar, which may disagree with it. For direct examination of the buffer, the variable Lbufend> points to the end of the buffer. The current lexing position is pointed to by Lbufptr>. Direct use of these pointers is usually preferable to examination of the scalar through normal scalar means. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_parser-Elinestr'},'hv_riter_p' => {'text' => '','name' => 'hv_riter_p'},'newSVpvn_share' => {'text' => 'Creates a new SV with its SvPVX_const pointing to a shared string in the string table. If the string does not already exist in the table, it is created first. Turns on READONLY and FAKE. If the C parameter is non-zero, that value is used; otherwise the hash is computed. The string\'s hash can be later be retrieved from the SV with the C macro. The idea here is that as the string table is used for shared hash keys these strings will have SvPVX_const == HeKEY and hash lookup will avoid string compare. SV* newSVpvn_share(const char* s, I32 len, U32 hash)','name' => 'newSVpvn_share'},'mro_set_mro' => {'text' => '','name' => 'mro_set_mro'},'SvPOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a character string. Checks the B setting. Use C instead. U32 SvPOKp(SV* sv)','name' => 'SvPOKp'},'pregfree2' => {'text' => '','name' => 'pregfree2'},'sv_catpvn' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpvn(SV *dsv, const char *sstr, STRLEN len)','name' => 'sv_catpvn'},'my_socketpair' => {'text' => '','name' => 'my_socketpair'},'blockhook_register' => {'text' => 'Register a set of hooks to be called when the Perl lexical scope changes at compile time. See L. NOTE: this function is experimental and may change or be removed without notice. NOTE: this function must be explicitly called as Perl_blockhook_register with an aTHX_ parameter. void Perl_blockhook_register(pTHX_ BHK *hk)','name' => 'blockhook_register'},'init_global_struct' => {'text' => '','name' => 'init_global_struct'},'find_rundefsv' => {'text' => '','name' => 'find_rundefsv'},'sv_utf8_downgrade' => {'text' => 'Attempts to convert the PV of an SV from characters to bytes. If the PV contains a character that cannot fit in a byte, this conversion will fail; in this case, either returns false or, if C is not true, croaks. This is not as a general purpose Unicode to byte encoding interface: use the Encode extension for that. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_downgrade(SV *const sv, const bool fail_ok)','name' => 'sv_utf8_downgrade'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either forward or backward. WARNING: do not use the following unless you *know* C is within the UTF-8 data pointed to by C *and* that on entry C is aligned on the first byte of character or just after the last byte of a character. U8* utf8_hop(const U8 *s, I32 off)','name' => 'utf8_hop'},'newPROG' => {'text' => '','name' => 'newPROG'},'sv_setref_pvn' => {'text' => '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 have a reference count of 1, and the RV will be returned. Note that C copies the pointer while this copies the string. SV* sv_setref_pvn(SV *const rv, const char *const classname, const char *const pv, const STRLEN n)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for blessed scalars. See C.','name' => 'SVt_PVMG'},'gv_fetchsv' => {'text' => '','name' => 'gv_fetchsv'},'PUSHp' => {'text' => '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. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHp(char* str, STRLEN len)','name' => 'PUSHp'},'my_strftime' => {'text' => '','name' => 'my_strftime'},'mXPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void mXPUSHi(IV iv)','name' => 'mXPUSHi'},'PL_sv_undef' => {'text' => 'This is the C SV. Always refer to this as C<&PL_sv_undef>. SV PL_sv_undef','name' => 'PL_sv_undef'},'hv_iterkeysv' => {'text' => '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)','name' => 'hv_iterkeysv'},'sv_catpv_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. If C has C bit set, will C on the SVs if appropriate, else not. void sv_catpv_flags(SV *dstr, const char *sstr, const I32 flags)','name' => 'sv_catpv_flags'},'mPUSHp' => {'text' => 'Push a string onto the stack. The stack must have room for this element. The C indicates the length of the string. Does not use C. See also C, C and C. void mPUSHp(char* str, STRLEN len)','name' => 'mPUSHp'},'lex_stuff_pv' => {'text' => 'Insert characters into the lexer buffer (Llinestr>), immediately after the current lexing point (Lbufptr>), reallocating the buffer if necessary. This means that lexing code that runs later will see the characters as if they had appeared in the input. It is not recommended to do this as part of normal parsing, and most uses of this facility run the risk of the inserted characters being interpreted in an unintended manner. The string to be inserted is represented by octets starting at I and continuing to the first nul. These octets are interpreted as either UTF-8 or Latin-1, according to whether the C flag is set in I. The characters are recoded for the lexer buffer, according to how the buffer is currently being interpreted (L). If it is not convenient to nul-terminate a string to be inserted, the L function is more appropriate. NOTE: this function is experimental and may change or be removed without notice. void lex_stuff_pv(const char *pv, U32 flags)','name' => 'lex_stuff_pv'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array, makes the element mortal, and returns it. If C equals C, the element is freed and null is returned. Perl equivalent: C for the non-C version and a void-context C for the C version. SV* av_delete(AV *av, I32 key, I32 flags)','name' => 'av_delete'},'utf8_distance' => {'text' => 'Returns the number of UTF-8 characters between the UTF-8 pointers C and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. IV utf8_distance(const U8 *a, const U8 *b)','name' => 'utf8_distance'},'SvPV_nomg' => {'text' => 'Like C but doesn\'t process magic. char* SvPV_nomg(SV* sv, STRLEN len)','name' => 'SvPV_nomg'},'parser_dup' => {'text' => '','name' => 'parser_dup'},'do_sprintf' => {'text' => '','name' => 'do_sprintf'},'SvUV_nomg' => {'text' => 'Like C but doesn\'t process magic. UV SvUV_nomg(SV* sv)','name' => 'SvUV_nomg'},'save_I32' => {'text' => '','name' => 'save_I32'},'gv_autoload4' => {'text' => '','name' => 'gv_autoload4'},'POPpx' => {'text' => 'Pops a string off the stack. char* POPpx','name' => 'POPpx'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'newCONDOP' => {'text' => 'Constructs, checks, and returns a conditional-expression (C) op. I gives the eight bits of C, except that C will be set automatically, and, shifted up eight bits, the eight bits of C, except that the bit with value 1 is automatically set. I supplies the expression selecting between the two branches, and I and I supply the branches; they are consumed by this function and become part of the constructed op tree. OP * newCONDOP(I32 flags, OP *first, OP *trueop, OP *falseop)','name' => 'newCONDOP'},'save_pushi32ptr' => {'text' => '','name' => 'save_pushi32ptr'},'sv_setpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_setpvs(SV* sv, const char* s)','name' => 'sv_setpvs'},'is_uni_punct_lc' => {'text' => '','name' => 'is_uni_punct_lc'},'cxinc' => {'text' => '','name' => 'cxinc'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. Guarantees to C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'sv_clear' => {'text' => 'Clear an SV: call any destructors, free up any memory used by the body, and free the body itself. The SV\'s head is I freed, although its type is set to all 1\'s so that it won\'t inadvertently be assumed to be live during global destruction etc. This function should only be called when REFCNT is zero. Most of the time you\'ll want to call C (or its macro wrapper C) instead. void sv_clear(SV *const orig_sv)','name' => 'sv_clear'},'lex_read_space' => {'text' => 'Reads optional spaces, in Perl style, in the text currently being lexed. The spaces may include ordinary whitespace characters and Perl-style comments. C<#line> directives are processed if encountered. Lbufptr> is moved past the spaces, so that it points at a non-space character (or the end of the input text). If spaces extend into the next chunk of input text, the next chunk will be read in. Normally the current chunk will be discarded at the same time, but if I includes C then the current chunk will not be discarded. NOTE: this function is experimental and may change or be removed without notice. void lex_read_space(U32 flags)','name' => 'lex_read_space'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'SvGAMAGIC' => {'text' => 'Returns true if the SV has get magic or overloading. If either is true then the scalar is active data, and has the potential to return a new value every time it is accessed. Hence you must be careful to only read it once per user logical operation and work with that returned value. If neither is true then the scalar\'s value cannot change unless written to. U32 SvGAMAGIC(SV* sv)','name' => 'SvGAMAGIC'},'svtype' => {'text' => '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.','name' => 'svtype'},'hv_placeholders_get' => {'text' => '','name' => 'hv_placeholders_get'},'load_module' => {'text' => '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 C. The optional trailing SV* arguments can be used to specify arguments to the module\'s import() method, similar to C. They must be terminated with a final NULL pointer. Note that this list can only be omitted when the PERL_LOADMOD_NOIMPORT flag has been used. Otherwise at least a single NULL pointer to designate the default import list is required. void load_module(U32 flags, SV* name, SV* ver, ...)','name' => 'load_module'},'dump_eval' => {'text' => '','name' => 'dump_eval'},'Poison' => {'text' => 'PoisonWith(0xEF) for catching access to freed memory. void Poison(void* dest, int nitems, type)','name' => 'Poison'},'is_uni_alpha_lc' => {'text' => '','name' => 'is_uni_alpha_lc'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *const sv, const char *const pat, ...)','name' => 'sv_catpvf_mg'},'get_sv' => {'text' => 'Returns the SV of the specified Perl scalar. C are passed to C. If C is set and the Perl variable does not exist then it will be created. If C is zero 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 flags)','name' => 'get_sv'},'warn_sv' => {'text' => 'This is an XS interface to Perl\'s C function. C is the error message or object. If it is a reference, it will be used as-is. Otherwise it is used as a string, and if it does not end with a newline then it will be extended with some indication of the current location in the code, as described for L. The error message or object will by default be written to standard error, but this is subject to modification by a C<$SIG{__WARN__}> handler. To warn with a simple string message, the L function may be more convenient. void warn_sv(SV *baseex)','name' => 'warn_sv'},'GetVars' => {'text' => '','name' => 'GetVars'},'do_hv_dump' => {'text' => '','name' => 'do_hv_dump'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *const sv, const char *const ptr)','name' => 'sv_setpv_mg'},'whichsig' => {'text' => '','name' => 'whichsig'},'lex_next_chunk' => {'text' => 'Reads in the next chunk of text to be lexed, appending it to Llinestr>. This should be called when lexing code has looked to the end of the current chunk and wants to know more. It is usual, but not necessary, for lexing to have consumed the entirety of the current chunk at this time. If Lbufptr> is pointing to the very end of the current chunk (i.e., the current chunk has been entirely consumed), normally the current chunk will be discarded at the same time that the new chunk is read in. If I includes C, the current chunk will not be discarded. If the current chunk has not been entirely consumed, then it will not be discarded regardless of the flag. Returns true if some new text was added to the buffer, or false if the buffer has reached the end of the input text. NOTE: this function is experimental and may change or be removed without notice. bool lex_next_chunk(U32 flags)','name' => 'lex_next_chunk'},'sv_2mortal' => {'text' => 'Marks an existing SV as mortal. The SV will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. SvTEMP() is turned on which means that the SV\'s string buffer can be "stolen" if this SV is copied. See also C and C. SV* sv_2mortal(SV *const sv)','name' => 'sv_2mortal'},'sv_2bool_flags' => {'text' => 'This function is only used by sv_true() and friends, and only if the latter\'s argument is neither SvPOK, SvIOK nor SvNOK. If the flags contain SV_GMAGIC, then it does an mg_get() first. bool sv_2bool_flags(SV *const sv, const I32 flags)','name' => 'sv_2bool_flags'},'hv_store_flags' => {'text' => '','name' => 'hv_store_flags'},'is_uni_graph' => {'text' => '','name' => 'is_uni_graph'},'malloc' => {'text' => '','name' => 'malloc'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself. void av_undef(AV *av)','name' => 'av_undef'},'parse_label' => {'text' => 'Parse a single label, possibly optional, of the type that may prefix a Perl statement. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed. If I includes C then the label is optional, otherwise it is mandatory. The name of the label is returned in the form of a fresh scalar. If an optional label is absent, a null pointer is returned. If an error occurs in parsing, which can only occur if the label is mandatory, a valid label is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. NOTE: this function is experimental and may change or be removed without notice. SV * parse_label(U32 flags)','name' => 'parse_label'},'pack_cat' => {'text' => '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, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)','name' => 'pack_cat'},'PerlIO_read' => {'text' => '','name' => 'PerlIO_read'},'sv_cmp' => {'text' => '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. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp(SV *const sv1, SV *const sv2)','name' => 'sv_cmp'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'sv_force_normal_flags' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg; if we\'re a copy-on-write scalar, this is the on-write time when we do the copy, and is also used locally. If C is set then a copy-on-write scalar drops its PV buffer (if any) and becomes SvPOK_off rather than making a copy. (Used where this scalar is about to be set to some other value.) In addition, the C parameter gets passed to C when unreffing. C calls this function with flags set to 0. void sv_force_normal_flags(SV *const sv, const U32 flags)','name' => 'sv_force_normal_flags'},'cophh_fetch_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of a string/length pair. NOTE: this function is experimental and may change or be removed without notice. SV * cophh_fetch_pv(const COPHH *cophh, const char *key, U32 hash, U32 flags)','name' => 'cophh_fetch_pv'},'tmps_grow' => {'text' => '','name' => 'tmps_grow'},'is_utf8_char' => {'text' => 'Tests if some arbitrary number of bytes begins in a valid UTF-8 character. Note that an INVARIANT (i.e. ASCII on non-EBCDIC machines) character is a valid UTF-8 character. The actual number of bytes in the UTF-8 character will be returned if it is valid, otherwise 0. STRLEN is_utf8_char(const U8 *s)','name' => 'is_utf8_char'},'get_vtbl' => {'text' => '','name' => 'get_vtbl'},'save_hints' => {'text' => '','name' => 'save_hints'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'sv_utf8_upgrade' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Will C on C if appropriate. Always sets the SvUTF8 flag to avoid future validity checks even if the whole string is the same in UTF-8 as not. Returns the number of bytes in the converted string This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. Sets up the C and C variables by calling C and C. This is usually handled automatically by C. dXSARGS;','name' => 'dXSARGS'},'savesharedpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the specified character is a whitespace character in the platform\'s native character set. This is the same as what C<\\s> matches in a regular expression. See the L for an explanation of variants C and C. bool isSPACE(char ch)','name' => 'isSPACE'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* ptr)','name' => 'Safefree'},'custom_op_desc' => {'text' => 'Return the description of a given custom op. This was once used by the OP_DESC macro, but is no longer: it has only been kept for compatibility, and should not be used. const char * custom_op_desc(const OP *o)','name' => 'custom_op_desc'},'regdupe_internal' => {'text' => '','name' => 'regdupe_internal'},'gv_stashpvn' => {'text' => 'Returns a pointer to the stash for a specified package. The C parameter indicates the length of the C, in bytes. C is passed to C, so if set to C then the package will be created if it does not already exist. If the package does not exist and C is 0 (or any other setting that does not create packages) then NULL is returned. HV* gv_stashpvn(const char* name, U32 namelen, I32 flags)','name' => 'gv_stashpvn'},'vmess' => {'text' => 'C and C are a sprintf-style format pattern and encapsulated argument list. These are used to generate a string message. If the message does not end with a newline, then it will be extended with some indication of the current location in the code, as described for L. Normally, the resulting message is returned in a new mortal SV. During global destruction a single SV may be shared between uses of this function. SV * vmess(const char *pat, va_list *args)','name' => 'vmess'},'to_uni_fold' => {'text' => '','name' => 'to_uni_fold'},'new_collate' => {'text' => '','name' => 'new_collate'},'my_stat' => {'text' => '','name' => 'my_stat'},'my_setenv' => {'text' => '','name' => 'my_setenv'},'newSV_type' => {'text' => 'Creates a new SV, of the type specified. The reference count for the new SV is set to 1. SV* newSV_type(const svtype type)','name' => 'newSV_type'},'SvREFCNT_inc_void_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value, and you know that I is not NULL. The macro doesn\'t need to return a meaningful value, or check for NULLness, so it\'s smaller and faster. void SvREFCNT_inc_void_NN(SV* sv)','name' => 'SvREFCNT_inc_void_NN'},'Perl_signbit' => {'text' => 'Return a non-zero integer if the sign bit on an NV is set, and 0 if it is not. If Configure detects this system has a signbit() that will work with our NVs, then we just use it via the #define in perl.h. Otherwise, fall back on this implementation. As a first pass, this gets everything right except -0.0. Alas, catching -0.0 is the main use for this function, so this is not too helpful yet. Still, at least we have the scaffolding in place to support other systems, should that prove useful. Configure notes: This function is called \'Perl_signbit\' instead of a plain \'signbit\' because it is easy to imagine a system having a signbit() function or macro that doesn\'t happen to work with our particular choice of NVs. We shouldn\'t just re-#define signbit as Perl_signbit and expect the standard system headers to be happy. Also, this is a no-context function (no pTHX_) because Perl_signbit() is usually re-#defined in perl.h as a simple macro call to the system\'s signbit(). Users should just always call Perl_signbit(). NOTE: this function is experimental and may change or be removed without notice. int Perl_signbit(NV f)','name' => 'Perl_signbit'},'PUSH_MULTICALL' => {'text' => 'Opening bracket for a lightweight callback. See L. PUSH_MULTICALL;','name' => 'PUSH_MULTICALL'},'new_ctype' => {'text' => '','name' => 'new_ctype'},'save_svref' => {'text' => '','name' => 'save_svref'},'to_uni_upper' => {'text' => '','name' => 'to_uni_upper'},'newNULLLIST' => {'text' => 'Constructs, checks, and returns a new C op, which represents an empty list expression. OP * newNULLLIST()','name' => 'newNULLLIST'},'is_uni_cntrl_lc' => {'text' => '','name' => 'is_uni_cntrl_lc'},'is_utf8_lower' => {'text' => '','name' => 'is_utf8_lower'},'sv_pos_u2b_flags' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from the start of the string, to a count of the equivalent number of bytes; if lenp is non-zero, it does the same to lenp, but this time starting from the offset, rather than from the start of the string. Handles type coercion. I is passed to C, and usually should be C to handle magic. STRLEN sv_pos_u2b_flags(SV *const sv, STRLEN uoffset, STRLEN *const lenp, U32 flags)','name' => 'sv_pos_u2b_flags'},'init_tm' => {'text' => '','name' => 'init_tm'},'newWHILEOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C loop. This is a heavyweight loop, with structure that allows exiting the loop by C and suchlike. I is an optional preconstructed C op to use in the loop; if it is null then a suitable op will be constructed automatically. I supplies the loop\'s controlling expression. I supplies the main body of the loop, and I optionally supplies a C block that operates as a second half of the body. All of these optree inputs are consumed by this function and become part of the constructed op tree. I gives the eight bits of C for the C op and, shifted up eight bits, the eight bits of C for the C op, except that (in both cases) some bits will be set automatically. I is currently unused and should always be 1. I can be supplied as true to force the loop body to be enclosed in its own scope. OP * newWHILEOP(I32 flags, I32 debuggable, LOOP *loop, OP *expr, OP *block, OP *cont, I32 has_my)','name' => 'newWHILEOP'},'Gv_AMupdate' => {'text' => '','name' => 'Gv_AMupdate'},'filter_del' => {'text' => '','name' => 'filter_del'},'POPp' => {'text' => 'Pops a string off the stack. Deprecated. New code should use POPpx. char* POPp','name' => 'POPp'},'SvIV_nomg' => {'text' => 'Like C but doesn\'t process magic. IV SvIV_nomg(SV* sv)','name' => 'SvIV_nomg'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'newANONLIST' => {'text' => '','name' => 'newANONLIST'},'mg_findext' => {'text' => 'Finds the magic pointer of C with the given C for the C. See C. MAGIC* mg_findext(const SV* sv, int type, const MGVTBL *vtbl)','name' => 'mg_findext'},'my_memset' => {'text' => '','name' => 'my_memset'},'my_atof2' => {'text' => '','name' => 'my_atof2'},'PerlIO_get_ptr' => {'text' => '','name' => 'PerlIO_get_ptr'},'save_destructor' => {'text' => '','name' => 'save_destructor'},'sv_cmp_flags' => {'text' => '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. Is UTF-8 and \'use bytes\' aware and will coerce its args to strings if necessary. If the flags include SV_GMAGIC, it handles get magic. See also C. I32 sv_cmp_flags(SV *const sv1, SV *const sv2, const U32 flags)','name' => 'sv_cmp_flags'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV *hv, char **key, I32 *retlen)','name' => 'hv_iternextsv'},'lex_read_to' => {'text' => 'Consume text in the lexer buffer, from Lbufptr> up to I. This advances Lbufptr> to match I, performing the correct bookkeeping whenever a newline character is passed. This is the normal way to consume lexed text. Interpretation of the buffer\'s octets can be abstracted out by using the slightly higher-level functions L and L. NOTE: this function is experimental and may change or be removed without notice. void lex_read_to(char *ptr)','name' => 'lex_read_to'},'sv_pvbyten_force' => {'text' => 'The backend for the C macro. Always use the macro instead. char* sv_pvbyten_force(SV *const sv, STRLEN *const lp)','name' => 'sv_pvbyten_force'},'reg_named_buff_fetch' => {'text' => '','name' => 'reg_named_buff_fetch'},'ibcmp_locale' => {'text' => 'This is a synonym for (! foldEQ_locale()) I32 ibcmp_locale(const char* a, const char* b, I32 len)','name' => 'ibcmp_locale'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'save_pptr' => {'text' => '','name' => 'save_pptr'},'PerlIO_set_ptrcnt' => {'text' => '','name' => 'PerlIO_set_ptrcnt'},'mPUSHs' => {'text' => 'Push an SV onto the stack and mortalizes the SV. The stack must have room for this element. Does not use C. See also C and C. void mPUSHs(SV* sv)','name' => 'mPUSHs'},'dump_packsubs' => {'text' => '','name' => 'dump_packsubs'},'is_utf8_digit' => {'text' => '','name' => 'is_utf8_digit'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'init_i18nl10n' => {'text' => '','name' => 'init_i18nl10n'},'vform' => {'text' => '','name' => 'vform'},'get_op_descs' => {'text' => '','name' => 'get_op_descs'},'safesyscalloc' => {'text' => '','name' => 'safesyscalloc'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'parse_stmtseq' => {'text' => 'Parse a sequence of zero or more Perl statements. These may be normal imperative statements, including optional labels, or declarations that have compile-time effect, or any mixture thereof. The statement sequence ends when a closing brace or end-of-file is encountered in a place where a new statement could have validly started. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed and the lexical context for the statements. The op tree representing the statement sequence is returned. This may be a null pointer if the statements were all null, for example if there were no statements or if there were only subroutine definitions (which have compile-time side effects). If not null, it will be a C list, normally including C or equivalent ops. If an error occurs in parsing or compilation, in most cases a valid op tree is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. Some compilation errors, however, will throw an exception immediately. The I parameter is reserved for future use, and must always be zero. NOTE: this function is experimental and may change or be removed without notice. OP * parse_stmtseq(U32 flags)','name' => 'parse_stmtseq'},'sv_2pvutf8_nolen' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8_nolen(SV* sv)','name' => 'sv_2pvutf8_nolen'},'gv_HVadd' => {'text' => '','name' => 'gv_HVadd'},'custom_op_xop' => {'text' => 'Return the XOP structure for a given custom op. This function should be considered internal to OP_NAME and the other access macros: use them instead. NOTE: this function must be explicitly called as Perl_custom_op_xop with an aTHX_ parameter. const XOP * Perl_custom_op_xop(pTHX_ const OP *o)','name' => 'custom_op_xop'},'mro_get_linear_isa' => {'text' => 'Returns either C or C for the given stash, dependant upon which MRO is in effect for that stash. The return value is a read-only AV*. You are responsible for C on the return value if you plan to store it anywhere semi-permanently (otherwise it might be deleted out from under you the next time the cache is invalidated). AV* mro_get_linear_isa(HV* stash)','name' => 'mro_get_linear_isa'},'av_store' => {'text' => '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 *av, I32 key, SV *val)','name' => 'av_store'},'SvPVbytex' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex(SV* sv, STRLEN len)','name' => 'SvPVbytex'},'reg_named_buff_scalar' => {'text' => '','name' => 'reg_named_buff_scalar'},'unlnk' => {'text' => '','name' => 'unlnk'},'av_fetch' => {'text' => 'Returns the SV at the specified index in the array. The C is the index. If lval is true, you are guaranteed to get a real SV back (in case it wasn\'t real before), which you can then modify. 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. The rough perl equivalent is C<$myarray[$idx]>. SV** av_fetch(AV *av, I32 key, I32 lval)','name' => 'av_fetch'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV *hv, HE *entry)','name' => 'hv_iterval'},'is_uni_xdigit_lc' => {'text' => '','name' => 'is_uni_xdigit_lc'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. const char* sv_reftype(const SV *const sv, const int ob)','name' => 'sv_reftype'},'foldEQ_locale' => {'text' => 'Returns true if the leading len bytes of the strings s1 and s2 are the same case-insensitively in the current locale; false otherwise. I32 foldEQ_locale(const char* a, const char* b, I32 len)','name' => 'foldEQ_locale'},'cophh_2hv' => {'text' => 'Generates and returns a standard Perl hash representing the full set of key/value pairs in the cop hints hash I. I is currently unused and must be zero. NOTE: this function is experimental and may change or be removed without notice. HV * cophh_2hv(const COPHH *cophh, U32 flags)','name' => 'cophh_2hv'},'SvREFCNT_inc_simple_void_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value, and you know that I is not NULL. The macro doesn\'t need to return a meaningful value, or check for NULLness, so it\'s smaller and faster. void SvREFCNT_inc_simple_void_NN(SV* sv)','name' => 'SvREFCNT_inc_simple_void_NN'},'rsignal_state' => {'text' => '','name' => 'rsignal_state'},'av_len' => {'text' => 'Returns the highest index in the array. The number of elements in the array is C. Returns -1 if the array is empty. The Perl equivalent for this is C<$#myarray>. I32 av_len(AV *av)','name' => 'av_len'},'sv_unmagic' => {'text' => 'Removes all magic of type C from an SV. int sv_unmagic(SV *const sv, const int type)','name' => 'sv_unmagic'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled. void SvTAINT(SV* sv)','name' => 'SvTAINT'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'my_sprintf' => {'text' => 'The C library C, wrapped if necessary, to ensure that it will return the length of the string written to the buffer. Only rare pre-ANSI systems need the wrapper function - usually this is a direct call to C. int my_sprintf(char *buffer, const char *pat, ...)','name' => 'my_sprintf'},'to_utf8_fold' => {'text' => 'Convert the UTF-8 encoded character at p to its foldcase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the foldcase version may be longer than the original character (up to three characters). The first character of the foldcased version is returned (but note, as explained above, that there may be more.) UV to_utf8_fold(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_fold'},'regfree_internal' => {'text' => '','name' => 'regfree_internal'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. Uses C to determine the length of C, then calls C. HV* gv_stashpv(const char* name, I32 flags)','name' => 'gv_stashpv'},'sv_cmp_locale_flags' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware and will coerce its args to strings if necessary. If the flags contain SV_GMAGIC, it handles get magic. See also C. I32 sv_cmp_locale_flags(SV *const sv1, SV *const sv2, const U32 flags)','name' => 'sv_cmp_locale_flags'},'sv_vcatpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vcatpvf_mg(SV *const sv, const char *const pat, va_list *const args)','name' => 'sv_vcatpvf_mg'},'mXPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void mXPUSHu(UV uv)','name' => 'mXPUSHu'},'hv_exists_ent' => {'text' => '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 *hv, SV *keysv, U32 hash)','name' => 'hv_exists_ent'},'atfork_unlock' => {'text' => '','name' => 'atfork_unlock'},'SvNIOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a number, integer or double. U32 SvNIOK(SV* sv)','name' => 'SvNIOK'},'save_long' => {'text' => '','name' => 'save_long'},'mro_method_changed_in' => {'text' => 'Invalidates method caching on any child classes of the given stash, so that they might notice the changes in this one. Ideally, all instances of C in perl source outside of C should be replaced by calls to this. Perl automatically handles most of the common ways a method might be redefined. However, there are a few ways you could change a method in a stash without the cache code noticing, in which case you need to call this method afterwards: 1) Directly manipulating the stash HV entries from XS code. 2) Assigning a reference to a readonly scalar constant into a stash entry in order to create a constant subroutine (like constant.pm does). This same method is available from pure perl via, C. void mro_method_changed_in(HV* stash)','name' => 'mro_method_changed_in'},'unpack_str' => {'text' => '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(const char *pat, const char *patend, const char *s, const char *strbeg, const char *strend, char **new_s, I32 ocnt, U32 flags)','name' => 'unpack_str'},'my_fflush_all' => {'text' => '','name' => 'my_fflush_all'},'is_uni_print' => {'text' => '','name' => 'is_uni_print'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C wrapper instead. SV* sv_newref(SV *const sv)','name' => 'sv_newref'},'cop_hints_fetch_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of a string/length pair. SV * cop_hints_fetch_pv(const COP *cop, const char *key, U32 hash, U32 flags)','name' => 'cop_hints_fetch_pv'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'sv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the scalar sv, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument is as in pv_uni_display(). The pointer to the PV of the dsv is returned. char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim, UV flags)','name' => 'sv_uni_display'},'sv_unmagicext' => {'text' => 'Removes all magic of type C with the specified C from an SV. int sv_unmagicext(SV *const sv, const int type, MGVTBL *vtbl)','name' => 'sv_unmagicext'},'newSVpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV* newSVpvs(const char* s)','name' => 'newSVpvs'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'realloc' => {'text' => '','name' => 'realloc'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'packlist' => {'text' => 'The engine implementing pack() Perl function. void packlist(SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist)','name' => 'packlist'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C for a version which guarantees to evaluate sv only once. NV SvNV(SV* sv)','name' => 'SvNV'},'SvUTF8' => {'text' => 'Returns a U32 value indicating whether the SV contains UTF-8 encoded data. Call this after SvPV() in case any call to string overloading updates the internal flag. U32 SvUTF8(SV* sv)','name' => 'SvUTF8'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'op_dump' => {'text' => '','name' => 'op_dump'},'get_mstats' => {'text' => '','name' => 'get_mstats'},'savestack_grow' => {'text' => '','name' => 'savestack_grow'},'debstackptrs' => {'text' => '','name' => 'debstackptrs'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'ptr_table_store' => {'text' => '','name' => 'ptr_table_store'},'cv_undef' => {'text' => 'Clear out all the active components of a CV. This can happen either by an explicit C, 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)','name' => 'cv_undef'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'sv_catpvf_nocontext' => {'text' => '','name' => 'sv_catpvf_nocontext'},'save_padsv_and_mortalize' => {'text' => '','name' => 'save_padsv_and_mortalize'},'cophh_delete_pvs' => {'text' => 'Like L, but takes a literal string instead of a string/length pair, and no precomputed hash. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_delete_pvs(const COPHH *cophh, const char *key, U32 flags)','name' => 'cophh_delete_pvs'},'get_cvn_flags' => {'text' => 'Returns the CV of the specified Perl subroutine. C are passed to C. 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_cvn_flags(const char* name, STRLEN len, I32 flags)','name' => 'get_cvn_flags'},'XopENTRY_set' => {'text' => 'Set a member of the XOP structure. I is a cpp token indicating which entry to set. See L for details about the available members and how they are used. void XopENTRY_set(XOP *xop, which, value)','name' => 'XopENTRY_set'},'reentrant_free' => {'text' => '','name' => 'reentrant_free'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'dump_vindent' => {'text' => '','name' => 'dump_vindent'},'SvPVx' => {'text' => 'A version of C which guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. char* SvPVx(SV* sv, STRLEN len)','name' => 'SvPVx'},'dump_form' => {'text' => '','name' => 'dump_form'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. If necessary, uses C and upgrades the SV to C. Returns a pointer to the character buffer. Use the C wrapper instead. char* sv_grow(SV *const sv, STRLEN newlen)','name' => 'sv_grow'},'vnormal' => {'text' => 'Accepts a version object and returns the normalized string representation. Call like: sv = vnormal(rv); NOTE: you can pass either the object directly or the SV contained within the RV. The SV returned has a refcount of 1. SV* vnormal(SV *vs)','name' => 'vnormal'},'filter_add' => {'text' => '','name' => 'filter_add'},'newPVOP' => {'text' => 'Constructs, checks, and returns an op of any type that involves an embedded C-level pointer (PV). I is the opcode. I gives the eight bits of C. I supplies the C-level pointer, which must have been allocated using L; the memory will be freed when the op is destroyed. OP * newPVOP(I32 type, I32 flags, char *pv)','name' => 'newPVOP'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. Does not use C. See also C, C and C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'is_uni_graph_lc' => {'text' => '','name' => 'is_uni_graph_lc'},'is_utf8_alnum' => {'text' => '','name' => 'is_utf8_alnum'},'set_numeric_radix' => {'text' => '','name' => 'set_numeric_radix'},'is_utf8_upper' => {'text' => '','name' => 'is_utf8_upper'},'newIO' => {'text' => '','name' => 'newIO'},'do_join' => {'text' => '','name' => 'do_join'},'save_helem' => {'text' => '','name' => 'save_helem'},'die' => {'text' => 'Behaves the same as L, except for the return type. It should be used only where the C return type is required. The function never actually returns. OP * die(const char *pat, ...)','name' => 'die'},'sv_usepvn' => {'text' => 'Tells an SV to use C to find its string value. Implemented by calling C with C of 0, hence does not handle \'set\' magic. See C. void sv_usepvn(SV* sv, char* ptr, STRLEN len)','name' => 'sv_usepvn'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'swash_init' => {'text' => '','name' => 'swash_init'},'newANONSUB' => {'text' => '','name' => 'newANONSUB'},'warn' => {'text' => 'This is an XS interface to Perl\'s C function. Take a sprintf-style format pattern and argument list. These are used to generate a string message. If the message does not end with a newline, then it will be extended with some indication of the current location in the code, as described for L. The error message or object will by default be written to standard error, but this is subject to modification by a C<$SIG{__WARN__}> handler. Unlike with L, C is not permitted to be null. void warn(const char *pat, ...)','name' => 'warn'},'PerlIO_get_bufsiz' => {'text' => '','name' => 'PerlIO_get_bufsiz'},'to_uni_title_lc' => {'text' => '','name' => 'to_uni_title_lc'},'fp_dup' => {'text' => '','name' => 'fp_dup'},'hek_dup' => {'text' => '','name' => 'hek_dup'},'pmop_dump' => {'text' => '','name' => 'pmop_dump'},'newANONATTRSUB' => {'text' => '','name' => 'newANONATTRSUB'},'sv_catpvf_mg_nocontext' => {'text' => '','name' => 'sv_catpvf_mg_nocontext'},'reg_named_buff_all' => {'text' => '','name' => 'reg_named_buff_all'},'PerlIO_close' => {'text' => '','name' => 'PerlIO_close'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. void EXTEND(SP, int nitems)','name' => 'EXTEND'},'newOP' => {'text' => 'Constructs, checks, and returns an op of any base type (any type that has no extra fields). I is the opcode. I gives the eight bits of C, and, shifted up eight bits, the eight bits of C. OP * newOP(I32 type, I32 flags)','name' => 'newOP'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(const UV u)','name' => 'newSVuv'},'gv_fetchmeth' => {'text' => '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. 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)','name' => 'gv_fetchmeth'},'op_refcnt_lock' => {'text' => '','name' => 'op_refcnt_lock'},'newGVgen' => {'text' => '','name' => 'newGVgen'},'sv_does' => {'text' => 'Returns a boolean indicating whether the SV performs a specific, named role. The SV can be a Perl object or the name of a Perl class. bool sv_does(SV* sv, const char *const name)','name' => 'sv_does'},'delimcpy' => {'text' => '','name' => 'delimcpy'},'newLOOPOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a loop. This is only a loop in the control flow through the op tree; it does not have the heavyweight loop structure that allows exiting the loop by C and suchlike. I gives the eight bits of C for the top-level op, except that some bits will be set automatically as required. I supplies the expression controlling loop iteration, and I supplies the body of the loop; they are consumed by this function and become part of the constructed op tree. I is currently unused and should always be 1. OP * newLOOPOP(I32 flags, I32 debuggable, OP *expr, OP *block)','name' => 'newLOOPOP'},'reg_named_buff_firstkey' => {'text' => '','name' => 'reg_named_buff_firstkey'},'free_global_struct' => {'text' => '','name' => 'free_global_struct'},'uvuni_to_utf8' => {'text' => '','name' => 'uvuni_to_utf8'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part attributable to C. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'PerlIO_tell' => {'text' => '','name' => 'PerlIO_tell'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a string and disables all other OK bits, and leaves the UTF-8 status as it was. void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic after a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'},'SvTRUE' => {'text' => 'Returns a boolean indicating whether Perl would evaluate the SV as true or false. See SvOK() for a defined/undefined test. Handles \'get\' magic unless the scalar is already SvPOK, SvIOK or SvNOK (the public, not the private flags). bool SvTRUE(SV* sv)','name' => 'SvTRUE'},'regdump' => {'text' => '','name' => 'regdump'},'my_pclose' => {'text' => '','name' => 'my_pclose'},'hv_iternext_flags' => {'text' => 'Returns entries from a hash iterator. See C and C. The C 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 C<&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 *hv, I32 flags)','name' => 'hv_iternext_flags'},'is_utf8_string_loclen' => {'text' => 'Like is_utf8_string() but stores the location of the failure (in the case of "utf8ness failure") or the location s+len (in the case of "utf8ness success") in the C, and the number of UTF-8 encoded characters in the C. See also is_utf8_string_loc() and is_utf8_string(). bool is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el)','name' => 'is_utf8_string_loclen'},'call_method' => {'text' => '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)','name' => 'call_method'},'BhkENABLE' => {'text' => 'Re-enable an entry in this BHK structure, by setting the appropriate flag. I is a preprocessor token indicating which entry to enable. This will assert (under -DDEBUGGING) if the entry doesn\'t contain a valid pointer. NOTE: this function is experimental and may change or be removed without notice. void BhkENABLE(BHK *hk, which)','name' => 'BhkENABLE'},'sys_init' => {'text' => '','name' => 'sys_init'},'perl_parse' => {'text' => 'Tells a Perl interpreter to parse a Perl script. See L. int perl_parse(PerlInterpreter *my_perl, XSINIT_t xsinit, int argc, char** argv, char** env)','name' => 'perl_parse'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory used by the array itself. Perl equivalent: C<@myarray = ();>. void av_clear(AV *av)','name' => 'av_clear'},'sv_force_normal' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. See also C. void sv_force_normal(SV *sv)','name' => 'sv_force_normal'},'av_unshift' => {'text' => '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 *av, I32 num)','name' => 'av_unshift'},'save_set_svflags' => {'text' => '','name' => 'save_set_svflags'},'SvREFCNT_inc_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you know I is not NULL. Since we don\'t have to check the NULLness, it\'s faster and smaller. SV* SvREFCNT_inc_NN(SV* sv)','name' => 'SvREFCNT_inc_NN'},'sys_term' => {'text' => '','name' => 'sys_term'},'is_utf8_xidfirst' => {'text' => '','name' => 'is_utf8_xidfirst'},'re_intuit_start' => {'text' => '','name' => 're_intuit_start'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. UV SvUVX(SV* sv)','name' => 'SvUVX'},'hv_copy_hints_hv' => {'text' => 'A specialised version of L for copying C<%^H>. I must be a pointer to a hash (which may have C<%^H> magic, but should be generally non-magical), or C (interpreted as an empty hash). The content of I is copied to a new hash, which has the C<%^H>-specific magic added to it. A pointer to the new hash is returned. HV * hv_copy_hints_hv(HV *ohv)','name' => 'hv_copy_hints_hv'},'do_pmop_dump' => {'text' => '','name' => 'do_pmop_dump'},'sv_utf8_decode' => {'text' => 'If the PV of the SV is an octet sequence in UTF-8 and contains a multiple-byte character, the C flag is turned on so that it looks like a character. If the PV contains only single-byte characters, the C flag stays being off. Scans PV for validity and returns false if the PV is invalid UTF-8. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_decode(SV *const sv)','name' => 'sv_utf8_decode'},'op_refcnt_unlock' => {'text' => '','name' => 'op_refcnt_unlock'},'hv_stores' => {'text' => 'Like C, but takes a literal string instead of a string/length pair and omits the hash parameter. SV** hv_stores(HV* tb, const char* key, NULLOK SV* val)','name' => 'hv_stores'},'eval_sv' => {'text' => 'Tells Perl to C the string in the SV. It supports the same flags as C, with the obvious exception of G_EVAL. See L. NOTE: the perl_ form of this function is deprecated. I32 eval_sv(SV* sv, I32 flags)','name' => 'eval_sv'},'SvNV_nomg' => {'text' => 'Like C but doesn\'t process magic. NV SvNV_nomg(SV* sv)','name' => 'SvNV_nomg'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'sv_utf8_upgrade_nomg' => {'text' => 'Like sv_utf8_upgrade, but doesn\'t do magic on C STRLEN sv_utf8_upgrade_nomg(SV *sv)','name' => 'sv_utf8_upgrade_nomg'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'GIMME' => {'text' => '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','name' => 'GIMME'},'my_snprintf' => {'text' => 'The C library C functionality, if available and standards-compliant (uses C, actually). However, if the C is not available, will unfortunately use the unsafe C which can overrun the buffer (there is an overrun check, but that may be too late). Consider using C instead, or getting C. int my_snprintf(char *buffer, const Size_t len, const char *format, ...)','name' => 'my_snprintf'},'newLOGOP' => {'text' => 'Constructs, checks, and returns a logical (flow control) op. I is the opcode. I gives the eight bits of C, except that C will be set automatically, and, shifted up eight bits, the eight bits of C, except that the bit with value 1 is automatically set. I supplies the expression controlling the flow, and I supplies the side (alternate) chain of ops; they are consumed by this function and become part of the constructed op tree. OP * newLOGOP(I32 type, I32 flags, OP *first, OP *other)','name' => 'newLOGOP'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. bool SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'gp_ref' => {'text' => '','name' => 'gp_ref'},'save_op' => {'text' => '','name' => 'save_op'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter *my_perl)','name' => 'perl_construct'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. bool SvUOK(SV* sv)','name' => 'SvUOK'},'newWHENOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C block. I supplies the test expression, and I supplies the block that will be executed if the test evaluates to true; they are consumed by this function and become part of the constructed op tree. I will be interpreted DWIMically, often as a comparison against C<$_>, and may be null to generate a C block. OP * newWHENOP(OP *cond, OP *block)','name' => 'newWHENOP'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic and operator overloading. void sv_dec(SV *const sv)','name' => 'sv_dec'},'pv_display' => {'text' => 'Similar to pv_escape(dsv,pv,cur,pvlim,PERL_PV_ESCAPE_QUOTE); except that an additional "\\0" will be appended to the string when len > cur and pv[cur] is "\\0". Note that the final string may be up to 7 chars longer than pvlim. char* pv_display(SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)','name' => 'pv_display'},'newHVREF' => {'text' => '','name' => 'newHVREF'},'sv_2pvbyte_nolen' => {'text' => 'Return a pointer to the byte-encoded representation of the SV. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'is_uni_space' => {'text' => '','name' => 'is_uni_space'},'PerlIO_fileno' => {'text' => '','name' => 'PerlIO_fileno'},'uvchr_to_utf8' => {'text' => 'Adds the UTF-8 representation of the Native code point C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvchr_to_utf8(d, uv); is the recommended wide native character-aware way of saying *(d++) = uv; U8* uvchr_to_utf8(U8 *d, UV uv)','name' => 'uvchr_to_utf8'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the specified character is a digit in the platform\'s native character set. Variants C and C are identical to C. bool isDIGIT(char ch)','name' => 'isDIGIT'},'call_atexit' => {'text' => '','name' => 'call_atexit'},'is_utf8_alpha' => {'text' => '','name' => 'is_utf8_alpha'},'my_bzero' => {'text' => '','name' => 'my_bzero'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. Passing NULL for SV creates a constant sub equivalent to C, which won\'t be called if used as a destructor, but will suppress the overhead of a call to C. (This form, however, isn\'t eligible for inlining at compile time.) CV* newCONSTSUB(HV* stash, const char* name, SV* sv)','name' => 'newCONSTSUB'},'SvSHARE' => {'text' => 'Arranges for sv to be shared between threads if a suitable module has been loaded. void SvSHARE(SV* sv)','name' => 'SvSHARE'},'vwarner' => {'text' => '','name' => 'vwarner'},'sortsv' => {'text' => 'Sort an array. Here is an example: sortsv(AvARRAY(av), av_len(av)+1, Perl_sv_cmp_locale); Currently this always uses mergesort. See sortsv_flags for a more flexible routine. void sortsv(SV** array, size_t num_elts, SVCOMPARE_t cmp)','name' => 'sortsv'},'cophh_store_pvs' => {'text' => 'Like L, but takes a literal string instead of a string/length pair, and no precomputed hash. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_store_pvs(const COPHH *cophh, const char *key, SV *value, U32 flags)','name' => 'cophh_store_pvs'},'sys_intern_clear' => {'text' => '','name' => 'sys_intern_clear'},'my_ntohl' => {'text' => '','name' => 'my_ntohl'},'doref' => {'text' => '','name' => 'doref'},'scan_bin' => {'text' => 'For backwards compatibility. Use C instead. NV scan_bin(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_bin'},'Nullcv' => {'text' => 'Null CV pointer. (deprecated - use C<(CV *)NULL> instead)','name' => 'Nullcv'},'sv_catpvs_nomg' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_catpvs_nomg(SV* sv, const char* s)','name' => 'sv_catpvs_nomg'},'lex_bufutf8' => {'text' => 'Indicates whether the octets in the lexer buffer (Llinestr>) should be interpreted as the UTF-8 encoding of Unicode characters. If not, they should be interpreted as Latin-1 characters. This is analogous to the C flag for scalars. In UTF-8 mode, it is not guaranteed that the lexer buffer actually contains valid UTF-8. Lexing code must be robust in the face of invalid encoding. The actual C flag of the Llinestr> scalar is significant, but not the whole story regarding the input character encoding. Normally, when a file is being read, the scalar contains octets and its C flag is off, but the octets should be interpreted as UTF-8 if the C pragma is in effect. During a string eval, however, the scalar may have the C flag on, and in this case its octets should be interpreted as UTF-8 unless the C pragma is in effect. This logic may change in the future; use this function instead of implementing the logic yourself. NOTE: this function is experimental and may change or be removed without notice. bool lex_bufutf8()','name' => 'lex_bufutf8'},'MULTICALL' => {'text' => 'Make a lightweight callback. See L. MULTICALL;','name' => 'MULTICALL'},'debprofdump' => {'text' => '','name' => 'debprofdump'},'SvPVbyte' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'is_uni_lower' => {'text' => '','name' => 'is_uni_lower'},'savesharedpvs' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpvs(const char* s)','name' => 'savesharedpvs'},'sys_init3' => {'text' => '','name' => 'sys_init3'},'PerlIO_stdout' => {'text' => '','name' => 'PerlIO_stdout'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'SvPVutf8x' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'sv_2cv' => {'text' => 'Using various gambits, try to get a CV from an SV; in addition, try if possible to set C<*st> and C<*gvp> to the stash and GV associated with it. The flags in C are passed to gv_fetchsv. CV* sv_2cv(SV* sv, HV **const st, GV **const gvp, const I32 lref)','name' => 'sv_2cv'},'gp_free' => {'text' => '','name' => 'gp_free'},'SvPV_force_nomg' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. Doesn\'t process magic. char* SvPV_force_nomg(SV* sv, STRLEN len)','name' => 'SvPV_force_nomg'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. Will also turn off the UTF-8 status. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'save_destructor_x' => {'text' => '','name' => 'save_destructor_x'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'hv_fetch' => {'text' => '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 an C. See L for more information on how to use this function on tied hashes. SV** hv_fetch(HV *hv, const char *key, I32 klen, I32 lval)','name' => 'hv_fetch'},'sv_pvbyte' => {'text' => 'Use C instead. char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'XCPT_TRY_START' => {'text' => 'Starts a try block. See L.','name' => 'XCPT_TRY_START'},'sv_unref_flags' => {'text' => '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. The C argument can contain C to force the reference count to be decremented (otherwise the decrementing is conditional on the reference count being different from one or the reference being a readonly SV). See C. void sv_unref_flags(SV *const ref, const U32 flags)','name' => 'sv_unref_flags'},'hv_scalar' => {'text' => 'Evaluates the hash in scalar context and returns the result. Handles magic when the hash is tied. SV* hv_scalar(HV *hv)','name' => 'hv_scalar'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV *sv, SV *nsv, const char *key, I32 klen)','name' => 'mg_copy'},'save_I16' => {'text' => '','name' => 'save_I16'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C flag on this RV; give the referred-to SV C magic if it hasn\'t already; and push a back-reference to this RV onto the array of backreferences associated with that magic. If the RV is magical, set magic will be called after the RV is cleared. SV* sv_rvweaken(SV *const sv)','name' => 'sv_rvweaken'},'grok_oct' => {'text' => 'converts a string representing an octal number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an 8 or 9 will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). If C is set in I<*flags> then the octal number may use \'_\' characters to separate digits. UV grok_oct(const char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_oct'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'newSVpvn' => {'text' => '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. If the C argument is NULL the new SV will be undefined. SV* newSVpvn(const char *const s, const STRLEN len)','name' => 'newSVpvn'},'scan_hex' => {'text' => 'For backwards compatibility. Use C instead. NV scan_hex(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_hex'},'unpackstring' => {'text' => 'The engine implementing unpack() Perl function. C puts the extracted list items on the stack and returns the number of elements. Issue C before and C after the call to this function. I32 unpackstring(const char *pat, const char *patend, const char *s, const char *strend, U32 flags)','name' => 'unpackstring'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV *av, I32 key)','name' => 'av_extend'},'sv_peek' => {'text' => '','name' => 'sv_peek'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. You may call C or C 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 C, so you must not discard your iterator immediately else the entry will leak - call C to trigger the resource deallocation. HE* hv_iternext(HV *hv)','name' => 'hv_iternext'},'hv_store_ent' => {'text' => '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. Effectively a successful hv_store_ent takes ownership of one reference to C. 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 C; unlike C it does not take ownership of it, so maintaining the correct reference count on C 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 L for more information on how to use this function on tied hashes. HE* hv_store_ent(HV *hv, SV *key, SV *val, U32 hash)','name' => 'hv_store_ent'},'hv_eiter_set' => {'text' => '','name' => 'hv_eiter_set'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package. See C. HV* gv_stashsv(SV* sv, I32 flags)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'form' => {'text' => '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, ...)','name' => 'form'},'instr' => {'text' => '','name' => 'instr'},'pregexec' => {'text' => '','name' => 'pregexec'},'is_utf8_string' => {'text' => 'Returns true if first C bytes of the given string form a valid UTF-8 string, false otherwise. If C is 0, it will be calculated using C. Note that \'a valid UTF-8 string\' does not mean \'a string that contains code points above 0x7F encoded in UTF-8\' because a valid ASCII string is a valid UTF-8 string. See also is_ascii_string(), is_utf8_string_loclen(), and is_utf8_string_loc(). bool is_utf8_string(const U8 *s, STRLEN len)','name' => 'is_utf8_string'},'croak_xs_usage' => {'text' => 'A specialised variant of C for emitting the usage message for xsubs croak_xs_usage(cv, "eee_yow"); works out the package name and subroutine name from C, and then calls C. Hence if C is C<&ouch::awk>, it would call C as: Perl_croak(aTHX_ "Usage: %s::%s(%s)", "ouch" "awk", "eee_yow"); void croak_xs_usage(const CV *const cv, const char *const params)','name' => 'croak_xs_usage'},'sv_insert' => {'text' => 'Inserts a string at the specified offset/length within the SV. Similar to the Perl substr() function. Handles get magic. void sv_insert(SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen)','name' => 'sv_insert'},'SvPOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a character string. U32 SvPOK(SV* sv)','name' => 'SvPOK'},'pad_findmy' => {'text' => 'Given a lexical name, try to find its offset, first in the current pad, or failing that, in the pads of any lexically enclosing subs (including the complications introduced by eval). If the name is found in an outer pad, then a fake entry is added to the current pad. Returns the offset in the current pad, or NOT_IN_PAD on failure. NOTE: this function is experimental and may change or be removed without notice. PADOFFSET pad_findmy(const char* name, STRLEN len, U32 flags)','name' => 'pad_findmy'},'sv_destroyable' => {'text' => 'Dummy routine which reports that object can be destroyed when there is no sharing module present. It ignores its single SV argument, and returns \'true\'. Exists to avoid test for a NULL function pointer and because it could potentially warn under some level of strict-ness. bool sv_destroyable(SV *sv)','name' => 'sv_destroyable'},'save_aelem_flags' => {'text' => '','name' => 'save_aelem_flags'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C.','name' => 'XS'},'gv_check' => {'text' => '','name' => 'gv_check'},'sv_setpvn' => {'text' => 'Copies a string into an SV. The C parameter indicates the number of bytes to be copied. If the C argument is NULL the SV will become undefined. Does not handle \'set\' magic. See C. void sv_setpvn(SV *const sv, const char *const ptr, const STRLEN len)','name' => 'sv_setpvn'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'op_linklist' => {'text' => 'This function is the implementation of the L macro. It should not be called directly. OP* op_linklist(OP *o)','name' => 'op_linklist'},'newSVrv' => {'text' => '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 *const rv, const char *const classname)','name' => 'newSVrv'},'cast_i32' => {'text' => '','name' => 'cast_i32'},'is_utf8_posix_digit' => {'text' => '','name' => 'is_utf8_posix_digit'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'stashpv_hvname_match' => {'text' => '','name' => 'stashpv_hvname_match'},'sv_dup_inc' => {'text' => '','name' => 'sv_dup_inc'},'newMYSUB' => {'text' => '','name' => 'newMYSUB'},'PoisonWith' => {'text' => 'Fill up memory with a byte pattern (a byte repeated over and over again) that hopefully catches attempts to access uninitialized memory. void PoisonWith(void* dest, int nitems, type, U8 byte)','name' => 'PoisonWith'},'av_create_and_unshift_one' => {'text' => 'Unshifts an SV onto the beginning of the array, creating the array if necessary. A small internal helper function to remove a commonly duplicated idiom. NOTE: this function is experimental and may change or be removed without notice. SV** av_create_and_unshift_one(AV **const avp, SV *const val)','name' => 'av_create_and_unshift_one'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'bytes_cmp_utf8' => {'text' => 'Compares the sequence of characters (stored as octets) in b, blen with the sequence of characters (stored as UTF-8) in u, ulen. Returns 0 if they are equal, -1 or -2 if the first string is less than the second string, +1 or +2 if the first string is greater than the second string. -1 or +1 is returned if the shorter string was identical to the start of the longer string. -2 or +2 is returned if the was a difference between characters within the strings. int bytes_cmp_utf8(const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen)','name' => 'bytes_cmp_utf8'},'seed' => {'text' => '','name' => 'seed'},'is_uni_lower_lc' => {'text' => '','name' => 'is_uni_lower_lc'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C to type C if necessary, then adds a new magic item of type C to the head of the magic list. See C (which C now calls) for a description of the handling of the C and C arguments. You need to use C to add magic to SvREADONLY SVs and also to add more than one instance of the same \'how\'. void sv_magic(SV *const sv, SV *const obj, const int how, const char *const name, const I32 namlen)','name' => 'sv_magic'},'sv_utf8_upgrade_flags' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes are invariant in UTF-8. If C has C bit set, will C on C if appropriate, else not. Returns the number of bytes in the converted string C and C are implemented in terms of this function. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade_flags(SV *const sv, const I32 flags)','name' => 'sv_utf8_upgrade_flags'},'do_open9' => {'text' => '','name' => 'do_open9'},'magic_dump' => {'text' => '','name' => 'magic_dump'},'sv_catpvs_mg' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_catpvs_mg(SV* sv, const char* s)','name' => 'sv_catpvs_mg'},'sv_setpvs_mg' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_setpvs_mg(SV* sv, const char* s)','name' => 'sv_setpvs_mg'},'gv_fetchfile_flags' => {'text' => '','name' => 'gv_fetchfile_flags'},'SvREFCNT_inc_void' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value. The macro doesn\'t need to return a meaningful value. void SvREFCNT_inc_void(SV* sv)','name' => 'SvREFCNT_inc_void'},'leave_scope' => {'text' => '','name' => 'leave_scope'},'newSTATEOP' => {'text' => 'Constructs a state op (COP). The state op is normally a C op, but will be a C op if debugging is enabled for currently-compiled code. The state op is populated from L (or L). If I and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. IV utf8_distance(U8 *a, U8 *b)','name' => 'utf8_distance'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally appending to the currently-stored string. char* sv_gets(SV* sv, PerlIO* fp, I32 append)','name' => 'sv_gets'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'SvPVutf8x' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'sv_collxfrm' => {'text' => 'Add Collate Transform magic to an SV if it doesn\'t already have it. Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the scalar data of the variable, but transformed to such a format that a normal memory comparison can be used to compare the data according to the locale settings. char* sv_collxfrm(SV* sv, STRLEN* nxp)','name' => 'sv_collxfrm'},'sv_2cv' => {'text' => 'Using various gambits, try to get a CV from an SV; in addition, try if possible to set C<*st> and C<*gvp> to the stash and GV associated with it. CV* sv_2cv(SV* sv, HV** st, GV** gvp, I32 lref)','name' => 'sv_2cv'},'ZeroD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * ZeroD(void* dest, int nitems, type)','name' => 'ZeroD'},'SvPV_force_nomg' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. Doesn\'t process magic. char* SvPV_force_nomg(SV* sv, STRLEN len)','name' => 'SvPV_force_nomg'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. Will also turn off the UTF-8 status. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'POPpx' => {'text' => 'Pops a string off the stack. Requires a variable STRLEN n_a in scope. char* POPpx','name' => 'POPpx'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'sv_uv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. UV sv_uv(SV* sv)','name' => 'sv_uv'},'sv_pvbyte' => {'text' => 'Use C instead. char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'hv_fetch' => {'text' => '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 an C. See L for more information on how to use this function on tied hashes. SV** hv_fetch(HV* tb, const char* key, I32 klen, I32 lval)','name' => 'hv_fetch'},'Zero' => {'text' => '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)','name' => 'Zero'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_unref_flags' => {'text' => '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. The C argument can contain C to force the reference count to be decremented (otherwise the decrementing is conditional on the reference count being different from one or the reference being a readonly SV). See C. void sv_unref_flags(SV* sv, U32 flags)','name' => 'sv_unref_flags'},'sv_iv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. IV sv_iv(SV* sv)','name' => 'sv_iv'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'hv_scalar' => {'text' => 'Evaluates the hash in scalar context and returns the result. Handles magic when the hash is tied. SV* hv_scalar(HV* hv)','name' => 'hv_scalar'},'Nullch' => {'text' => 'Null character pointer.','name' => 'Nullch'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)','name' => 'mg_copy'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C flag on this RV; give the referred-to SV C magic if it hasn\'t already; and push a back-reference to this RV onto the array of backreferences associated with that magic. SV* sv_rvweaken(SV *sv)','name' => 'sv_rvweaken'},'grok_oct' => {'text' => 'converts a string representing an octal number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). If C is set in I<*flags> then the octal number may use \'_\' characters to separate digits. UV grok_oct(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_oct'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'scan_hex' => {'text' => 'For backwards compatibility. Use C instead. NV scan_hex(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_hex'},'newSVpvn' => {'text' => '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. If the C argument is NULL the new SV will be undefined. SV* newSVpvn(const char* s, STRLEN len)','name' => 'newSVpvn'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the supplied vtable and returns a pointer to the magic added. Note that C will allow things that C will not. In particular, you can add magic to SvREADONLY SVs, and add more than one instance of the same \'how\'. If C is greater than zero then a C I of C is stored, if C is zero then C is stored as-is and - as another special case - if C<(name && namlen == HEf_SVKEY)> then C is assumed to contain an C and is stored as-is with its REFCNT incremented. (This is now used as a subroutine by C.) MAGIC * sv_magicext(SV* sv, SV* obj, int how, MGVTBL *vtbl, const char* name, I32 namlen )','name' => 'sv_magicext'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C.','name' => 'SVt_PVCV'},'av_push' => {'text' => '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)','name' => 'av_push'},'unpackstring' => {'text' => 'The engine implementing unpack() Perl function. C puts the extracted list items on the stack and returns the number of elements. Issue C before and C after the call to this function. I32 unpackstring(char *pat, char *patend, char *s, char *strend, U32 flags)','name' => 'unpackstring'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV* ar, I32 key)','name' => 'av_extend'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV *sv)','name' => 'newRV_noinc'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpviv_mg(SV *sv, IV iv)','name' => 'sv_setpviv_mg'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'sv_2bool' => {'text' => 'This function is only called on magical items, and is only used by sv_true() or its macro equivalent. bool sv_2bool(SV* sv)','name' => 'sv_2bool'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. You may call C or C 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 C, so you must not discard your iterator immediately else the entry will leak - call C to trigger the resource deallocation. HE* hv_iternext(HV* tb)','name' => 'hv_iternext'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'sv_newmortal' => {'text' => 'Creates a new null SV which is mortal. The reference count of the SV is set to 1. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_newmortal()','name' => 'sv_newmortal'},'sv_clear' => {'text' => 'Clear an SV: call any destructors, free up any memory used by the body, and free the body itself. The SV\'s head is I freed, although its type is set to all 1\'s so that it won\'t inadvertently be assumed to be live during global destruction etc. This function should only be called when REFCNT is zero. Most of the time you\'ll want to call C (or its macro wrapper C) instead. void sv_clear(SV* sv)','name' => 'sv_clear'},'hv_iterinit' => {'text' => '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)','name' => 'hv_iterinit'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.008006', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_018_000.pm0000644000175000017500000120732212155264512020763 0ustar tseetseepackage Perl::APIReference::V5_018_000; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'newBINOP' => {'text' => 'Constructs, checks, and returns an op of any binary type. I is the opcode. I gives the eight bits of C, except that C will be set automatically, and, shifted up eight bits, the eight bits of C, except that the bit with value 1 or 2 is automatically set as required. I and I supply up to two ops to be the direct children of the binary op; they are consumed by this function and become part of the constructed op tree. OP * newBINOP(I32 type, I32 flags, OP *first, OP *last)','name' => 'newBINOP'},'strGE' => {'text' => '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)','name' => 'strGE'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified version becoming C. Handles \'get\' magic. See also C for a version which guarantees to evaluate sv only once. Note that there is no guarantee that the return value of C is equal to C, or that C contains valid data, or that successive calls to C. char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'sv_vsetpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vsetpvf_mg(SV *const sv, const char *const pat, va_list *const args)','name' => 'sv_vsetpvf_mg'},'SvPVutf8' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'sortsv_flags' => {'text' => 'Sort an array, with various options. void sortsv_flags(SV** array, size_t num_elts, SVCOMPARE_t cmp, U32 flags)','name' => 'sortsv_flags'},'vwarn' => {'text' => 'This is an XS interface to Perl\'s C function. C and C are a sprintf-style format pattern and encapsulated argument list. These are used to generate a string message. If the message does not end with a newline, then it will be extended with some indication of the current location in the code, as described for L. The error message or object will by default be written to standard error, but this is subject to modification by a C<$SIG{__WARN__}> handler. Unlike with L, C is not permitted to be null. void vwarn(const char *pat, va_list *args)','name' => 'vwarn'},'scan_oct' => {'text' => 'For backwards compatibility. Use C instead. NV scan_oct(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_oct'},'my_strlcat' => {'text' => '','name' => 'my_strlcat'},'av_arylen_p' => {'text' => '','name' => 'av_arylen_p'},'gv_add_by_type' => {'text' => '','name' => 'gv_add_by_type'},'newGVOP' => {'text' => 'Constructs, checks, and returns an op of any type that involves an embedded reference to a GV. I is the opcode. I gives the eight bits of C. I identifies the GV that the op should reference; calling this function does not transfer ownership of any reference to it. OP * newGVOP(I32 type, I32 flags, GV *gv)','name' => 'newGVOP'},'XopDISABLE' => {'text' => 'Temporarily disable a member of the XOP, by clearing the appropriate flag. void XopDISABLE(XOP *xop, which)','name' => 'XopDISABLE'},'hv_rand_set' => {'text' => '','name' => 'hv_rand_set'},'find_runcv' => {'text' => 'Locate the CV corresponding to the currently executing sub or eval. If db_seqp is non_null, skip CVs that are in the DB package and populate *db_seqp with the cop sequence number at the point that the DB:: code was entered. (allows debuggers to eval in the scope of the breakpoint rather than in the scope of the debugger itself). CV* find_runcv(U32 *db_seqp)','name' => 'find_runcv'},'utf8n_to_uvuni' => {'text' => 'Bottom level UTF-8 decode routine. Returns the code point value of the first character in the string C, which is assumed to be in UTF-8 (or UTF-EBCDIC) encoding, and no longer than C bytes; C<*retlen> (if C isn\'t NULL) will be set to the length, in bytes, of that character. The value of C determines the behavior when C does not point to a well-formed UTF-8 character. If C is 0, when a malformation is found, zero is returned and C<*retlen> is set so that (S + C<*retlen>>) is the next possible position in C that could begin a non-malformed character. Also, if UTF-8 warnings haven\'t been lexically disabled, a warning is raised. Various ALLOW flags can be set in C to allow (and not warn on) individual types of malformations, such as the sequence being overlong (that is, when there is a shorter sequence that can express the same code point; overlong sequences are expressly forbidden in the UTF-8 standard due to potential security issues). Another malformation example is the first byte of a character not being a legal first byte. See F for the list of such flags. For allowed 0 length strings, this function returns 0; for allowed overlong sequences, the computed code point is returned; for all other allowed malformations, the Unicode REPLACEMENT CHARACTER is returned, as these have no determinable reasonable value. The UTF8_CHECK_ONLY flag overrides the behavior when a non-allowed (by other flags) malformation is found. If this flag is set, the routine assumes that the caller will raise a warning, and this function will silently just set C to C<-1> (cast to C) and return zero. Note that this API requires disambiguation between successful decoding a NUL character, and an error return (unless the UTF8_CHECK_ONLY flag is set), as in both cases, 0 is returned. To disambiguate, upon a zero return, see if the first byte of C is 0 as well. If so, the input was a NUL; if not, the input had an error. Certain code points are considered problematic. These are Unicode surrogates, Unicode non-characters, and code points above the Unicode maximum of 0x10FFFF. By default these are considered regular code points, but certain situations warrant special handling for them. If C contains UTF8_DISALLOW_ILLEGAL_INTERCHANGE, all three classes are treated as malformations and handled as such. The flags UTF8_DISALLOW_SURROGATE, UTF8_DISALLOW_NONCHAR, and UTF8_DISALLOW_SUPER (meaning above the legal Unicode maximum) can be set to disallow these categories individually. The flags UTF8_WARN_ILLEGAL_INTERCHANGE, UTF8_WARN_SURROGATE, UTF8_WARN_NONCHAR, and UTF8_WARN_SUPER will cause warning messages to be raised for their respective categories, but otherwise the code points are considered valid (not malformations). To get a category to both be treated as a malformation and raise a warning, specify both the WARN and DISALLOW flags. (But note that warnings are not raised if lexically disabled nor if UTF8_CHECK_ONLY is also specified.) Very large code points (above 0x7FFF_FFFF) are considered more problematic than the others that are above the Unicode legal maximum. There are several reasons: they requre at least 32 bits to represent them on ASCII platforms, are not representable at all on EBCDIC platforms, and the original UTF-8 specification never went above this number (the current 0x10FFFF limit was imposed later). (The smaller ones, those that fit into 32 bits, are representable by a UV on ASCII platforms, but not by an IV, which means that the number of operations that can be performed on them is quite restricted.) The UTF-8 encoding on ASCII platforms for these large code points begins with a byte containing 0xFE or 0xFF. The UTF8_DISALLOW_FE_FF flag will cause them to be treated as malformations, while allowing smaller above-Unicode code points. (Of course UTF8_DISALLOW_SUPER will treat all above-Unicode code points, including these, as malformations.) Similarly, UTF8_WARN_FE_FF acts just like the other WARN flags, but applies just to these code points. All other code points corresponding to Unicode characters, including private use and those yet to be assigned, are never considered malformed and never warn. Most code should use L() rather than call this directly. UV utf8n_to_uvuni(const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvuni'},'newSVpvn_utf8' => {'text' => 'Creates a new SV and copies a string into it. If utf8 is true, calls C on the new SV. Implemented as a wrapper around C. SV* newSVpvn_utf8(NULLOK const char* s, STRLEN len, U32 utf8)','name' => 'newSVpvn_utf8'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'whichsig_pv' => {'text' => '','name' => 'whichsig_pv'},'gv_fetchmeth_sv_autoload' => {'text' => 'Exactly like L, but takes the name string in the form of an SV instead of a string/length pair. GV* gv_fetchmeth_sv_autoload(HV* stash, SV* namesv, I32 level, U32 flags)','name' => 'gv_fetchmeth_sv_autoload'},'pregcomp' => {'text' => '','name' => 'pregcomp'},'my_cxt_index' => {'text' => '','name' => 'my_cxt_index'},'lex_discard_to' => {'text' => 'Discards the first part of the Llinestr> buffer, up to I. The remaining content of the buffer will be moved, and all pointers into the buffer updated appropriately. I must not be later in the buffer than the position of Lbufptr>: it is not permitted to discard text that has yet to be lexed. Normally it is not necessarily to do this directly, because it suffices to use the implicit discarding behaviour of L and things based on it. However, if a token stretches across multiple lines, and the lexing code has kept multiple lines of text in the buffer for that purpose, then after completion of the token it would be wise to explicitly discard the now-unneeded earlier lines, to avoid future multi-line tokens growing the buffer without bound. NOTE: this function is experimental and may change or be removed without notice. void lex_discard_to(char *ptr)','name' => 'lex_discard_to'},'markstack_grow' => {'text' => '','name' => 'markstack_grow'},'cv_get_call_checker' => {'text' => 'Retrieves the function that will be used to fix up a call to I. Specifically, the function is applied to an C op tree for a subroutine call, not marked with C<&>, where the callee can be identified at compile time as I. The C-level function pointer is returned in I<*ckfun_p>, and an SV argument for it is returned in I<*ckobj_p>. The function is intended to be called in this manner: entersubop = (*ckfun_p)(aTHX_ entersubop, namegv, (*ckobj_p)); In this call, I is a pointer to the C op, which may be replaced by the check function, and I is a GV supplying the name that should be used by the check function to refer to the callee of the C op if it needs to emit any diagnostics. It is permitted to apply the check function in non-standard situations, such as to a call to a different subroutine or to a method call. By default, the function is L, and the SV parameter is I itself. This implements standard prototype processing. It can be changed, for a particular subroutine, by L. void cv_get_call_checker(CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p)','name' => 'cv_get_call_checker'},'mXPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Does not use C. See also C, C and C. void mXPUSHp(char* str, STRLEN len)','name' => 'mXPUSHp'},'lex_stuff_sv' => {'text' => 'Insert characters into the lexer buffer (Llinestr>), immediately after the current lexing point (Lbufptr>), reallocating the buffer if necessary. This means that lexing code that runs later will see the characters as if they had appeared in the input. It is not recommended to do this as part of normal parsing, and most uses of this facility run the risk of the inserted characters being interpreted in an unintended manner. The string to be inserted is the string value of I. The characters are recoded for the lexer buffer, according to how the buffer is currently being interpreted (L). If a string to be inserted is not already a Perl scalar, the L function avoids the need to construct a scalar. NOTE: this function is experimental and may change or be removed without notice. void lex_stuff_sv(SV *sv, U32 flags)','name' => 'lex_stuff_sv'},'ibcmp_utf8' => {'text' => 'This is a synonym for (! foldEQ_utf8()) I32 ibcmp_utf8(const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2)','name' => 'ibcmp_utf8'},'CvSTASH' => {'text' => 'Returns the stash of the CV. A stash is the symbol table hash, containing the package-scoped variables in the package where the subroutine was defined. For more information, see L. This also has a special use with XS AUTOLOAD subs. See L. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'gv_const_sv' => {'text' => 'If C is a typeglob whose subroutine entry is a constant sub eligible for inlining, or C is a placeholder reference that would be promoted to such a typeglob, then returns the value returned by the sub. Otherwise, returns NULL. SV* gv_const_sv(GV* gv)','name' => 'gv_const_sv'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. The target SV physically takes over ownership of the body of the source SV and inherits its flags; however, the target keeps any magic it owns, and any magic in the source is discarded. Note that this is a rather specialist SV copying operation; most of the time you\'ll want to use C or one of its many macro front-ends. void sv_replace(SV *const sv, SV *const nsv)','name' => 'sv_replace'},'utf8n_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. C and C are the same as L(). UV utf8n_to_uvchr(const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvchr'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and L.','name' => 'G_ARRAY'},'sv_2iv' => {'text' => '','name' => 'sv_2iv'},'ck_warner_d' => {'text' => '','name' => 'ck_warner_d'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'pad_compname_type' => {'text' => 'Looks up the type of the lexical variable at position I in the currently-compiling pad. If the variable is typed, the stash of the class to which it is typed is returned. If not, C is returned. HV * pad_compname_type(PADOFFSET po)','name' => 'pad_compname_type'},'mXPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void mXPUSHn(NV nv)','name' => 'mXPUSHn'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This is necessary after modifying a scalar, in case it is a magical variable like C<$|> or a tied variable (it calls C). This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dsv, SV *ssv)','name' => 'sv_catsv_mg'},'call_argv' => {'text' => 'Performs a callback to the specified named and package-scoped Perl subroutine with C (a NULL-terminated array of strings) as arguments. See L. Approximate Perl equivalent: C<&{"$sub_name"}(@$argv)>. NOTE: the perl_ form of this function is deprecated. I32 call_argv(const char* sub_name, I32 flags, char** argv)','name' => 'call_argv'},'save_freeop' => {'text' => '','name' => 'save_freeop'},'SvPV_nolen' => {'text' => 'Like C but doesn\'t set a length variable. char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'alloccopstash' => {'text' => 'Available only under threaded builds, this function allocates an entry in C for the stash passed to it. NOTE: this function is experimental and may change or be removed without notice. PADOFFSET alloccopstash(HV *hv)','name' => 'alloccopstash'},'perl_clone' => {'text' => '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->create 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 C, 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 *proto_perl, UV flags )','name' => 'perl_clone'},'save_alloc' => {'text' => '','name' => 'save_alloc'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'rninstr' => {'text' => '','name' => 'rninstr'},'pad_findmy_pvn' => {'text' => 'Given the name of a lexical variable, find its position in the currently-compiling pad. I/I specify the variable\'s name, including leading sigil. I is reserved and must be zero. If it is not in the current pad but appears in the pad of any lexically enclosing scope, then a pseudo-entry for it is added in the current pad. Returns the offset in the current pad, or C if no such lexical is in scope. PADOFFSET pad_findmy_pvn(const char *namepv, STRLEN namelen, U32 flags)','name' => 'pad_findmy_pvn'},'hv_fetchs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV** hv_fetchs(HV* tb, const char* key, I32 lval)','name' => 'hv_fetchs'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'cophh_store_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of a string/length pair. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_store_pv(const COPHH *cophh, const char *key, U32 hash, SV *value, U32 flags)','name' => 'cophh_store_pv'},'savepv' => {'text' => 'Perl\'s version of C. Returns a pointer to a newly allocated string which is a duplicate of C. The size of the string is determined by C. The memory allocated for the new string can be freed with the C function. char* savepv(const char* pv)','name' => 'savepv'},'save_iv' => {'text' => '','name' => 'save_iv'},'HvNAME' => {'text' => 'Returns the package name of a stash, or NULL if C isn\'t a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV of the sv is assumed to be octets in that encoding, and the sv will be converted into Unicode (and UTF-8). If the sv already is UTF-8 (or if it is not POK), or if the encoding is not a reference, nothing is done to the sv. If the encoding is not an C Encoding object, bad things will happen. (See F and L.) The PV of the sv is returned. char* sv_recode_to_utf8(SV* sv, SV *encoding)','name' => 'sv_recode_to_utf8'},'save_hptr' => {'text' => '','name' => 'save_hptr'},'runops_debug' => {'text' => '','name' => 'runops_debug'},'do_gvgv_dump' => {'text' => '','name' => 'do_gvgv_dump'},'PERL_SYS_INIT' => {'text' => 'Provides system-specific tune up of the C runtime environment necessary to run Perl interpreters. This should be called only once, before creating any Perl interpreters. void PERL_SYS_INIT(int *argc, char*** argv)','name' => 'PERL_SYS_INIT'},'vstringify' => {'text' => 'In order to maintain maximum compatibility with earlier versions of Perl, this function will return either the floating point notation or the multiple dotted notation, depending on whether the original version contained 1 or more dots, respectively. The SV returned has a refcount of 1. SV* vstringify(SV *vs)','name' => 'vstringify'},'sv_catsv_flags' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. If C is null, does nothing; otherwise modifies only C. If C include C bit set, will call C on both SVs if appropriate. If C include C, C will be called on the modified SV afterward, if appropriate. C, C, and C are implemented in terms of this function. void sv_catsv_flags(SV *const dsv, SV *const ssv, const I32 flags)','name' => 'sv_catsv_flags'},'str_to_version' => {'text' => '','name' => 'str_to_version'},'sv_derived_from' => {'text' => 'Exactly like L, but doesn\'t take a C parameter. bool sv_derived_from(SV* sv, const char *const name)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp_locale(SV *const sv1, SV *const sv2)','name' => 'sv_cmp_locale'},'sv_catpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_catpvs(SV* sv, const char* s)','name' => 'sv_catpvs'},'set_numeric_standard' => {'text' => '','name' => 'set_numeric_standard'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'Nullsv' => {'text' => 'Null SV pointer. (No longer available when C is defined.)','name' => 'Nullsv'},'scan_vstring' => {'text' => '','name' => 'scan_vstring'},'ptr_table_new' => {'text' => '','name' => 'ptr_table_new'},'do_op_dump' => {'text' => '','name' => 'do_op_dump'},'foldEQ' => {'text' => 'Returns true if the leading len bytes of the strings s1 and s2 are the same case-insensitively; false otherwise. Uppercase and lowercase ASCII range bytes match themselves and their opposite case counterparts. Non-cased and non-ASCII range bytes match only themselves. I32 foldEQ(const char* a, const char* b, I32 len)','name' => 'foldEQ'},'PerlIO_get_base' => {'text' => '','name' => 'PerlIO_get_base'},'SvPVX' => {'text' => 'Returns a pointer to the physical string in the SV. The SV must contain a string. Prior to 5.9.3 it is not safe to execute this macro unless the SV\'s type >= SVt_PV. This is also used to store the name of an autoloaded subroutine in an XS AUTOLOAD routine. See L. char* SvPVX(SV* sv)','name' => 'SvPVX'},'av_top_index' => {'text' => 'Returns the highest index in the array. The number of elements in the array is C. Returns -1 if the array is empty. The Perl equivalent for this is C<$#myarray>. (A slightly shorter form is C.) I32 av_top_index(AV *av)','name' => 'av_top_index'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'debop' => {'text' => '','name' => 'debop'},'ref' => {'text' => '','name' => 'ref'},'sv_does_sv' => {'text' => 'Returns a boolean indicating whether the SV performs a specific, named role. The SV can be a Perl object or the name of a Perl class. bool sv_does_sv(SV* sv, SV* namesv, U32 flags)','name' => 'sv_does_sv'},'SvOOK_offset' => {'text' => 'Reads into I the offset from SvPVX back to the true start of the allocated buffer, which will be non-zero if C has been used to efficiently remove characters from start of the buffer. Implemented as a macro, which takes the address of I, which must be of type C. Evaluates I more than once. Sets I to 0 if C is false. void SvOOK_offset(NN SV*sv, STRLEN len)','name' => 'SvOOK_offset'},'save_list' => {'text' => '','name' => 'save_list'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted if tainting is enabled. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'newGIVENOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C block. I supplies the expression that will be locally assigned to a lexical variable, and I supplies the body of the C construct; they are consumed by this function and become part of the constructed op tree. I is the pad offset of the scalar lexical variable that will be affected. If it is 0, the global $_ will be used. OP * newGIVENOP(OP *cond, OP *block, PADOFFSET defsv_off)','name' => 'newGIVENOP'},'sv_nolocking' => {'text' => '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. "Superseded" by sv_nosharing(). void sv_nolocking(SV *sv)','name' => 'sv_nolocking'},'parse_listexpr' => {'text' => 'Parse a Perl list expression. This may contain operators of precedence down to the comma operator. The expression must be followed (and thus terminated) either by a low-precedence logic operator such as C or by something that would normally terminate an expression such as semicolon. If I includes C then the expression is optional, otherwise it is mandatory. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed and the lexical context for the expression. The op tree representing the expression is returned. If an optional expression is absent, a null pointer is returned, otherwise the pointer will be non-null. If an error occurs in parsing or compilation, in most cases a valid op tree is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. Some compilation errors, however, will throw an exception immediately. NOTE: this function is experimental and may change or be removed without notice. OP * parse_listexpr(U32 flags)','name' => 'parse_listexpr'},'ibcmp' => {'text' => 'This is a synonym for (! foldEQ()) I32 ibcmp(const char* a, const char* b, I32 len)','name' => 'ibcmp'},'isWORDCHAR' => {'text' => 'Returns a boolean indicating whether the specified character is a character that is a word character, analogous to what C and C match in a regular expression. A word character is an alphabetic character, a decimal digit, a connecting punctuation character (such as an underscore), or a "mark" character that attaches to one of those (like some sort of accent). C is a synonym provided for backward compatibility, even though a word character includes more than the standard C language meaning of alphanumeric. See the L for an explanation of variants C, C, C, C, C, C, and C. bool isWORDCHAR(char ch)','name' => 'isWORDCHAR'},'strLT' => {'text' => '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)','name' => 'strLT'},'save_pushptr' => {'text' => '','name' => 'save_pushptr'},'save_clearsv' => {'text' => '','name' => 'save_clearsv'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. Returns C<&PL_sv_undef> if the array is empty. Perl equivalent: C SV* av_shift(AV *av)','name' => 'av_shift'},'sv_setpvf_nocontext' => {'text' => '','name' => 'sv_setpvf_nocontext'},'HvENAMEUTF8' => {'text' => 'Returns true if the effective name is in UTF8 encoding. unsigned char HvENAMEUTF8(HV *stash)','name' => 'HvENAMEUTF8'},'sv_nounlocking' => {'text' => '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. "Superseded" by sv_nosharing(). void sv_nounlocking(SV *sv)','name' => 'sv_nounlocking'},'perl_clone_using' => {'text' => '','name' => 'perl_clone_using'},'PerlIO_context_layers' => {'text' => '','name' => 'PerlIO_context_layers'},'lex_unstuff' => {'text' => 'Discards text about to be lexed, from Lbufptr> up to I. Text following I will be moved, and the buffer shortened. This hides the discarded text from any lexing code that runs later, as if the text had never appeared. This is not the normal way to consume lexed text. For that, use L. NOTE: this function is experimental and may change or be removed without notice. void lex_unstuff(char *ptr)','name' => 'lex_unstuff'},'newSVpvf_nocontext' => {'text' => '','name' => 'newSVpvf_nocontext'},'SvUV_set' => {'text' => 'Set the value of the UV pointer in sv to val. See C. void SvUV_set(SV* sv, UV val)','name' => 'SvUV_set'},'rvpv_dup' => {'text' => '','name' => 'rvpv_dup'},'filter_read' => {'text' => '','name' => 'filter_read'},'ckwarn' => {'text' => '','name' => 'ckwarn'},'warner' => {'text' => '','name' => 'warner'},'savesharedsvpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedsvpv(SV *sv)','name' => 'savesharedsvpv'},'CopyD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * CopyD(void* src, void* dest, int nitems, type)','name' => 'CopyD'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *const sv, const IV i)','name' => 'sv_setiv_mg'},'sv_does_pvn' => {'text' => 'Like L, but takes a string/length pair instead of an SV. bool sv_does_pvn(SV* sv, const char *const name, const STRLEN len, U32 flags)','name' => 'sv_does_pvn'},'newFOROP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C loop (iteration through a list of values). This is a heavyweight loop, with structure that allows exiting the loop by C and suchlike. I optionally supplies the variable that will be aliased to each item in turn; if null, it defaults to C<$_> (either lexical or global). I supplies the list of values to iterate over. I supplies the main body of the loop, and I optionally supplies a C block that operates as a second half of the body. All of these optree inputs are consumed by this function and become part of the constructed op tree. I gives the eight bits of C for the C op and, shifted up eight bits, the eight bits of C for the C op, except that (in both cases) some bits will be set automatically. OP * newFOROP(I32 flags, OP *sv, OP *expr, OP *block, OP *cont)','name' => 'newFOROP'},'HvENAME' => {'text' => 'Returns the effective name of a stash, or NULL if there is none. The effective name represents a location in the symbol table where this stash resides. It is updated automatically when packages are aliased or deleted. A stash that is no longer in the symbol table has no effective name. This name is preferable to C for use in MRO linearisations and isa caches. char* HvENAME(HV* stash)','name' => 'HvENAME'},'save_generic_svref' => {'text' => '','name' => 'save_generic_svref'},'savesharedpvn' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. (With the specific difference that a NULL pointer is not acceptable) char* savesharedpvn(const char *const pv, const STRLEN len)','name' => 'savesharedpvn'},'utf8_to_uvchr_buf' => {'text' => 'Returns the native code point of the first character in the string C which is assumed to be in UTF-8 encoding; C points to 1 beyond the end of C. C<*retlen> will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character and UTF8 warnings are enabled, zero is returned and C<*retlen> is set (if C isn\'t NULL) to -1. If those warnings are off, the computed value, if well-defined (or the Unicode REPLACEMENT CHARACTER if not), is silently returned, and C<*retlen> is set (if C isn\'t NULL) so that (S + C<*retlen>>) is the next possible position in C that could begin a non-malformed character. See L for details on when the REPLACEMENT CHARACTER is returned. UV utf8_to_uvchr_buf(const U8 *s, const U8 *send, STRLEN *retlen)','name' => 'utf8_to_uvchr_buf'},'SvCUR_set' => {'text' => 'Set the current length of the string which is in the SV. See C and C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'SVt_NULL' => {'text' => 'Type flag for scalars. See L.','name' => 'SVt_NULL'},'sv_2pv' => {'text' => '','name' => 'sv_2pv'},'SvNOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a double. U32 SvNOK(SV* sv)','name' => 'SvNOK'},'mPUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void mPUSHn(NV nv)','name' => 'mPUSHn'},'pad_setsv' => {'text' => 'Set the value at offset I in the current (compiling or executing) pad. Use the macro PAD_SETSV() rather than calling this function directly. void pad_setsv(PADOFFSET po, SV *sv)','name' => 'pad_setsv'},'sv_reset' => {'text' => 'Underlying implementation for the C Perl function. Note that the perl-level function is vaguely deprecated. void sv_reset(const char* s, HV *const stash)','name' => 'sv_reset'},'cophh_delete_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of a string/length pair. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_delete_pv(const COPHH *cophh, const char *key, U32 hash, U32 flags)','name' => 'cophh_delete_pv'},'sv_2pv_flags' => {'text' => 'Returns a pointer to the string value of an SV, and sets *lp to its length. If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string if necessary. Normally invoked via the C macro. C and C usually end up here too. char* sv_2pv_flags(SV *const sv, STRLEN *const lp, const I32 flags)','name' => 'sv_2pv_flags'},'push_scope' => {'text' => '','name' => 'push_scope'},'SvNVx' => {'text' => 'Coerces the given SV to a double and returns it. Guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. NV SvNVx(SV* sv)','name' => 'SvNVx'},'setdefout' => {'text' => 'Sets PL_defoutgv, the default file handle for output, to the passed in typeglob. As PL_defoutgv "owns" a reference on its typeglob, the reference count of the passed in typeglob is increased by one, and the reference count of the typeglob that PL_defoutgv points to is decreased by one. void setdefout(GV* gv)','name' => 'setdefout'},'form_nocontext' => {'text' => '','name' => 'form_nocontext'},'hv_store' => {'text' => 'Stores an SV in a hash. The hash key is specified as C and the absolute value of C is the length of the key. If C is negative the key is assumed to be in UTF-8-encoded Unicode. 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. Effectively a successful hv_store takes ownership of one reference to C. 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 L for more information on how to use this function on tied hashes. SV** hv_store(HV *hv, const char *key, I32 klen, SV *val, U32 hash)','name' => 'hv_store'},'sys_intern_dup' => {'text' => '','name' => 'sys_intern_dup'},'do_binmode' => {'text' => '','name' => 'do_binmode'},'get_op_names' => {'text' => '','name' => 'get_op_names'},'cop_hints_fetch_sv' => {'text' => 'Like L, but takes a Perl scalar instead of a string/length pair. SV * cop_hints_fetch_sv(const COP *cop, SV *key, U32 hash, U32 flags)','name' => 'cop_hints_fetch_sv'},'ck_entersub_args_proto_or_list' => {'text' => 'Performs the fixup of the arguments part of an C op tree either based on a subroutine prototype or using default list-context processing. This is the standard treatment used on a subroutine call, not marked with C<&>, where the callee can be identified at compile time. I supplies the subroutine prototype to be applied to the call, or indicates that there is no prototype. It may be a normal scalar, in which case if it is defined then the string value will be used as a prototype, and if it is undefined then there is no prototype. Alternatively, for convenience, it may be a subroutine object (a C that has been cast to C), of which the prototype will be used if it has one. The prototype (or lack thereof) supplied, in whichever form, does not need to match the actual callee referenced by the op tree. If the argument ops disagree with the prototype, for example by having an unacceptable number of arguments, a valid op tree is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. In the error message, the callee is referred to by the name defined by the I parameter. OP * ck_entersub_args_proto_or_list(OP *entersubop, GV *namegv, SV *protosv)','name' => 'ck_entersub_args_proto_or_list'},'op_null' => {'text' => '','name' => 'op_null'},'hv_fetch_ent' => {'text' => '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 *hv, SV *keysv, I32 lval, U32 hash)','name' => 'hv_fetch_ent'},'gv_fetchpvn_flags' => {'text' => '','name' => 'gv_fetchpvn_flags'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'Newx' => {'text' => 'The XSUB-writer\'s interface to the C C function. In 5.9.3, Newx() and friends replace the older New() API, and drops the first parameter, I, a debug aid which allowed callers to identify themselves. This aid has been superseded by a new build option, PERL_MEM_LOG (see L). The older API is still there for use in XS modules supporting older perls. void Newx(void* ptr, int nitems, type)','name' => 'Newx'},'newFORM' => {'text' => '','name' => 'newFORM'},'PUSHs' => {'text' => 'Push an SV onto the stack. The stack must have room for this element. Does not handle \'set\' magic. Does not use C. See also C, C and C. void PUSHs(SV* sv)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setuv(SV *const sv, const UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'cv_clone' => {'text' => 'Clone a CV, making a lexical closure. I supplies the prototype of the function: its code, pad structure, and other attributes. The prototype is combined with a capture of outer lexicals to which the code refers, which are taken from the currently-executing instance of the immediately surrounding code. CV * cv_clone(CV *proto)','name' => 'cv_clone'},'do_aspawn' => {'text' => '','name' => 'do_aspawn'},'sv_pvn' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn(SV *sv, STRLEN *lp)','name' => 'sv_pvn'},'do_openn' => {'text' => '','name' => 'do_openn'},'wrap_op_checker' => {'text' => 'Puts a C function into the chain of check functions for a specified op type. This is the preferred way to manipulate the L array. I specifies which type of op is to be affected. I is a pointer to the C function that is to be added to that opcode\'s check chain, and I points to the storage location where a pointer to the next function in the chain will be stored. The value of I is written into the L array, while the value previously stored there is written to I<*old_checker_p>. L is global to an entire process, and a module wishing to hook op checking may find itself invoked more than once per process, typically in different threads. To handle that situation, this function is idempotent. The location I<*old_checker_p> must initially (once per process) contain a null pointer. A C variable of static duration (declared at file scope, typically also marked C to give it internal linkage) will be implicitly initialised appropriately, if it does not have an explicit initialiser. This function will only actually modify the check chain if it finds I<*old_checker_p> to be null. This function is also thread safe on the small scale. It uses appropriate locking to avoid race conditions in accessing L. When this function is called, the function referenced by I must be ready to be called, except for I<*old_checker_p> being unfilled. In a threading situation, I may be called immediately, even before this function has returned. I<*old_checker_p> will always be appropriately set before I is called. If I decides not to do anything special with an op that it is given (which is the usual case for most uses of op check hooking), it must chain the check function referenced by I<*old_checker_p>. If you want to influence compilation of calls to a specific subroutine, then use L rather than hooking checking of all C ops. void wrap_op_checker(Optype opcode, Perl_check_t new_checker, Perl_check_t *old_checker_p)','name' => 'wrap_op_checker'},'mro_get_from_name' => {'text' => '','name' => 'mro_get_from_name'},'sv_setref_iv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_iv(SV *const rv, const char *const classname, const IV iv)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => 'Efficient removal of characters from the beginning of the string buffer. SvPOK(sv), or at least SvPOKp(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. Uses the "OOK hack". On return, only SvPOK(sv) and SvPOKp(sv) among the OK flags will be true. Beware: after this function returns, C and SvPVX_const(sv) may no longer refer to the same chunk of data. The unfortunate similarity of this function\'s name to that of Perl\'s C operator is strictly coincidental. This function works from the left; C works from the right. void sv_chop(SV *const sv, const char *const ptr)','name' => 'sv_chop'},'sv_backoff' => {'text' => 'Remove any string offset. You should normally use the C macro wrapper instead. int sv_backoff(SV *const sv)','name' => 'sv_backoff'},'reentrant_retry' => {'text' => '','name' => 'reentrant_retry'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_pvn_nomg' => {'text' => '','name' => 'sv_pvn_nomg'},'GvHV' => {'text' => 'Return the HV from the GV. HV* GvHV(GV* gv)','name' => 'GvHV'},'stack_grow' => {'text' => '','name' => 'stack_grow'},'dump_mstats' => {'text' => '','name' => 'dump_mstats'},'newLOOPEX' => {'text' => 'Constructs, checks, and returns a loop-exiting op (such as C or C). I is the opcode. I.','name' => 'SVt_PVHV'},'reentrant_init' => {'text' => '','name' => 'reentrant_init'},'save_pushptrptr' => {'text' => '','name' => 'save_pushptrptr'},'save_gp' => {'text' => '','name' => 'save_gp'},'parse_block' => {'text' => 'Parse a single complete Perl code block. This consists of an opening brace, a sequence of statements, and a closing brace. The block constitutes a lexical scope, so C variables and various compile-time effects can be contained within it. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed and the lexical context for the statement. The op tree representing the code block is returned. This is always a real op, never a null pointer. It will normally be a C list, including C or equivalent ops. No ops to construct any kind of runtime scope are included by virtue of it being a block. If an error occurs in parsing or compilation, in most cases a valid op tree (most likely null) is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. Some compilation errors, however, will throw an exception immediately. The I parameter is reserved for future use, and must always be zero. NOTE: this function is experimental and may change or be removed without notice. OP * parse_block(U32 flags)','name' => 'parse_block'},'SvRX' => {'text' => 'Convenience macro to get the REGEXP from a SV. This is approximately equivalent to the following snippet: if (SvMAGICAL(sv)) mg_get(sv); if (SvROK(sv)) sv = MUTABLE_SV(SvRV(sv)); if (SvTYPE(sv) == SVt_REGEXP) return (REGEXP*) sv; NULL will be returned if a REGEXP* is not found. REGEXP * SvRX(SV *sv)','name' => 'SvRX'},'newASSIGNOP' => {'text' => 'Constructs, checks, and returns an assignment op. I and I supply the parameters of the assignment; they are consumed by this function and become part of the constructed op tree. If I is C, C, or C, then a suitable conditional optree is constructed. If I is the opcode of a binary operator, such as C, then an op is constructed that performs the binary operation and assigns the result to the left argument. Either way, if I is non-zero then I has no effect. If I is zero, then a plain scalar or list assignment is constructed. Which type of assignment it is is automatically determined. I gives the eight bits of C, except that C will be set automatically, and, shifted up eight bits, the eight bits of C, except that the bit with value 1 or 2 is automatically set as required. OP * newASSIGNOP(I32 flags, OP *left, I32 optype, OP *right)','name' => 'newASSIGNOP'},'SvSetMagicSV_nosteal' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetMagicSV_nosteal'},'hv_undef' => {'text' => 'Undefines the hash. The XS equivalent of C. As well as freeing all the elements of the hash (like hv_clear()), this also frees any auxiliary data and storage associated with the hash. If any destructors are triggered as a result, the hv itself may be freed. See also L. void hv_undef(HV *hv)','name' => 'hv_undef'},'clone_params_del' => {'text' => '','name' => 'clone_params_del'},'sv_isobject' => {'text' => '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)','name' => 'sv_isobject'},'cop_hints_fetch_pvn' => {'text' => 'Look up the hint entry in the cop I with the key specified by I and I. If I has the C bit set, the key octets are interpreted as UTF-8, otherwise they are interpreted as Latin-1. I is a precomputed hash of the key string, or zero if it has not been precomputed. Returns a mortal scalar copy of the value associated with the key, or C<&PL_sv_placeholder> if there is no value associated with the key. SV * cop_hints_fetch_pvn(const COP *cop, const char *keypv, STRLEN keylen, U32 hash, U32 flags)','name' => 'cop_hints_fetch_pvn'},'gv_efullname4' => {'text' => '','name' => 'gv_efullname4'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it. See C for a version which guarantees to evaluate sv only once. IV SvIV(SV* sv)','name' => 'SvIV'},'isASCII' => {'text' => 'Returns a boolean indicating whether the specified character is one of the 128 characters in the ASCII character set, analogous to C. On non-ASCII platforms, it returns TRUE iff this character corresponds to an ASCII character. Variants C and C are identical to C. See the L for an explanation of variants C, C, C, C, and C. Note, however, that some platforms do not have the C library routine C. In these cases, the variants whose names contain C are the same as the corresponding ones without. bool isASCII(char ch)','name' => 'isASCII'},'PerlIO_eof' => {'text' => '','name' => 'PerlIO_eof'},'cop_hints_2hv' => {'text' => 'Generates and returns a standard Perl hash representing the full set of hint entries in the cop I. I is currently unused and must be zero. HV * cop_hints_2hv(const COP *cop, U32 flags)','name' => 'cop_hints_2hv'},'sv_collxfrm_flags' => {'text' => 'Add Collate Transform magic to an SV if it doesn\'t already have it. If the flags contain SV_GMAGIC, it handles get-magic. Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the scalar data of the variable, but transformed to such a format that a normal memory comparison can be used to compare the data according to the locale settings. char* sv_collxfrm_flags(SV *const sv, STRLEN *const nxp, I32 const flags)','name' => 'sv_collxfrm_flags'},'sv_copypv_flags' => {'text' => 'Implementation of sv_copypv and sv_copypv_nomg. Calls get magic iff flags include SV_GMAGIC. void sv_copypv_flags(SV *const dsv, SV *const ssv, const I32 flags)','name' => 'sv_copypv_flags'},'sv_setref_uv' => {'text' => 'Copies an unsigned 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 have a reference count of 1, and the RV will be returned. SV* sv_setref_uv(SV *const rv, const char *const classname, const UV uv)','name' => 'sv_setref_uv'},'get_ppaddr' => {'text' => '','name' => 'get_ppaddr'},'ck_entersub_args_proto' => {'text' => 'Performs the fixup of the arguments part of an C op tree based on a subroutine prototype. This makes various modifications to the argument ops, from applying context up to inserting C ops, and checking the number and syntactic types of arguments, as directed by the prototype. This is the standard treatment used on a subroutine call, not marked with C<&>, where the callee can be identified at compile time and has a prototype. I supplies the subroutine prototype to be applied to the call. It may be a normal defined scalar, of which the string value will be used. Alternatively, for convenience, it may be a subroutine object (a C that has been cast to C) which has a prototype. The prototype supplied, in whichever form, does not need to match the actual callee referenced by the op tree. If the argument ops disagree with the prototype, for example by having an unacceptable number of arguments, a valid op tree is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. In the error message, the callee is referred to by the name defined by the I parameter. OP * ck_entersub_args_proto(OP *entersubop, GV *namegv, SV *protosv)','name' => 'ck_entersub_args_proto'},'getcwd_sv' => {'text' => 'Fill the sv with current working directory int getcwd_sv(SV* sv)','name' => 'getcwd_sv'},'newSVpvs_share' => {'text' => 'Like C, but takes a literal string instead of a string/length pair and omits the hash parameter. SV* newSVpvs_share(const char* s)','name' => 'newSVpvs_share'},'newSVpv' => {'text' => '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 *const s, const STRLEN len)','name' => 'newSVpv'},'sv_2pvbyte' => {'text' => 'Return a pointer to the byte-encoded representation of the SV, and set *lp to its length. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte(SV *sv, STRLEN *const lp)','name' => 'sv_2pvbyte'},'fbm_instr' => {'text' => '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* littlestr, U32 flags)','name' => 'fbm_instr'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHn(NV nv)','name' => 'XPUSHn'},'PL_opfreehook' => {'text' => 'When non-C, the function pointed by this variable will be called each time an OP is freed with the corresponding OP as the argument. This allows extensions to free any extra attribute they have locally attached to an OP. It is also assured to first fire for the parent OP and then for its kids. When you replace this variable, it is considered a good practice to store the possibly previously installed hook and that you recall it inside your own. Perl_ophook_t PL_opfreehook','name' => 'PL_opfreehook'},'PadlistARRAY' => {'text' => 'The C array of a padlist, containing the pads. Only subscript it with numbers >= 1, as the 0th entry is not guaranteed to remain usable. NOTE: this function is experimental and may change or be removed without notice. PAD ** PadlistARRAY(PADLIST padlist)','name' => 'PadlistARRAY'},'dump_all' => {'text' => '','name' => 'dump_all'},'ninstr' => {'text' => '','name' => 'ninstr'},'sv_vcatpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. Does not handle \'set\' magic. See C. Usually used via its frontend C. void sv_vcatpvf(SV *const sv, const char *const pat, va_list *const args)','name' => 'sv_vcatpvf'},'sv_pos_u2b' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from the start of the string, to a count of the equivalent number of bytes; if lenp is non-zero, it does the same to lenp, but this time starting from the offset, rather than from the start of the string. Handles magic and type coercion. Use C in preference, which correctly handles strings longer than 2Gb. void sv_pos_u2b(SV *const sv, I32 *const offsetp, I32 *const lenp)','name' => 'sv_pos_u2b'},'boolSV' => {'text' => 'Returns a true SV if C is a true value, or a false SV if C is 0. See also C and C. SV * boolSV(bool b)','name' => 'boolSV'},'upg_version' => {'text' => 'In-place upgrade of the supplied SV to a version object. SV *sv = upg_version(SV *sv, bool qv); Returns a pointer to the upgraded SV. Set the boolean qv if you want to force this SV to be interpreted as an "extended" version. SV* upg_version(SV *ver, bool qv)','name' => 'upg_version'},'PERL_SYS_INIT3' => {'text' => 'Provides system-specific tune up of the C runtime environment necessary to run Perl interpreters. This should be called only once, before creating any Perl interpreters. void PERL_SYS_INIT3(int *argc, char*** argv, char*** env)','name' => 'PERL_SYS_INIT3'},'HeSVKEY_set' => {'text' => '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)','name' => 'HeSVKEY_set'},'sv_derived_from_sv' => {'text' => 'Exactly like L, but takes the name string in the form of an SV instead of a string/length pair. bool sv_derived_from_sv(SV* sv, SV *namesv, U32 flags)','name' => 'sv_derived_from_sv'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L. SPAGAIN;','name' => 'SPAGAIN'},'newCVREF' => {'text' => '','name' => 'newCVREF'},'gv_init_sv' => {'text' => 'Same as gv_init_pvn(), but takes an SV * for the name instead of separate char * and length parameters. C is currently unused. void gv_init_sv(GV* gv, HV* stash, SV* namesv, U32 flags)','name' => 'gv_init_sv'},'my_bcopy' => {'text' => '','name' => 'my_bcopy'},'PL_parser-Ebufptr' => {'text' => 'Points to the current position of lexing inside the lexer buffer. Characters around this point may be freely examined, within the range delimited by Clinestr>)> and Lbufend>. The octets of the buffer may be intended to be interpreted as either UTF-8 or Latin-1, as indicated by L. Lexing code (whether in the Perl core or not) moves this pointer past the characters that it consumes. It is also expected to perform some bookkeeping whenever a newline character is consumed. This movement can be more conveniently performed by the function L, which handles newlines appropriately. Interpretation of the buffer\'s octets can be abstracted out by using the slightly higher-level functions L and L. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_parser-Ebufptr'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See L.','name' => 'G_NOARGS'},'amagic_deref_call' => {'text' => '','name' => 'amagic_deref_call'},'lex_start' => {'text' => 'Creates and initialises a new lexer/parser state object, supplying a context in which to lex and parse from a new source of Perl code. A pointer to the new state object is placed in L. An entry is made on the save stack so that upon unwinding the new state object will be destroyed and the former value of L will be restored. Nothing else need be done to clean up the parsing context. The code to be parsed comes from I and I. I, if non-null, provides a string (in SV form) containing code to be parsed. A copy of the string is made, so subsequent modification of I does not affect parsing. I, if non-null, provides an input stream from which code will be read to be parsed. If both are non-null, the code in I comes first and must consist of complete lines of input, and I supplies the remainder of the source. The I parameter is reserved for future use. Currently it is only used by perl internally, so extensions should always pass zero. NOTE: this function is experimental and may change or be removed without notice. void lex_start(SV *line, PerlIO *rsfp, U32 flags)','name' => 'lex_start'},'hv_riter_set' => {'text' => '','name' => 'hv_riter_set'},'gv_autoload_pvn' => {'text' => '','name' => 'gv_autoload_pvn'},'gv_autoload_pv' => {'text' => '','name' => 'gv_autoload_pv'},'dounwind' => {'text' => '','name' => 'dounwind'},'ptr_table_clear' => {'text' => '','name' => 'ptr_table_clear'},'uvchr_to_utf8_flags' => {'text' => '','name' => 'uvchr_to_utf8_flags'},'save_hash' => {'text' => '','name' => 'save_hash'},'sv_isa' => {'text' => '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 *const name)','name' => 'sv_isa'},'cophh_free' => {'text' => 'Discard the cop hints hash I, freeing all resources associated with it. NOTE: this function is experimental and may change or be removed without notice. void cophh_free(COPHH *cophh)','name' => 'cophh_free'},'isXDIGIT' => {'text' => 'Returns a boolean indicating whether the specified character is a hexadecimal digit. In the ASCII range these are C<[0-9A-Fa-f]>. Variants C and C are identical to C. See the L for an explanation of variants C, C, C, C, and C. bool isXDIGIT(char ch)','name' => 'isXDIGIT'},'sv_catpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. If the appended data contains "wide" characters (including, but not limited to, SVs with a UTF-8 PV formatted with %s, and characters >255 formatted with %c), the original SV might get upgraded to UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. If the original SV was UTF-8, the pattern should be valid UTF-8; if the original SV was bytes, the pattern should be too. void sv_catpvf(SV *const sv, const char *const pat, ...)','name' => 'sv_catpvf'},'cop_fetch_label' => {'text' => 'Returns the label attached to a cop. The flags pointer may be set to C or 0. NOTE: this function is experimental and may change or be removed without notice. const char * cop_fetch_label(COP *const cop, STRLEN *len, U32 *flags)','name' => 'cop_fetch_label'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C. void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'utf8_to_uvuni' => {'text' => 'DEPRECATED! Returns the Unicode code point of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. This function should only be used when the returned UV is considered an index into the Unicode semantic tables (e.g. swashes). Some, but not all, UTF-8 malformations are detected, and in fact, some malformed input could cause reading beyond the end of the input buffer, which is why this function is deprecated. Use L instead. If C points to one of the detected malformations, and UTF8 warnings are enabled, zero is returned and C<*retlen> is set (if C doesn\'t point to NULL) to -1. If those warnings are off, the computed value if well-defined (or the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen> is set (if C isn\'t NULL) so that (S + C<*retlen>>) is the next possible position in C that could begin a non-malformed character. See L for details on when the REPLACEMENT CHARACTER is returned. UV utf8_to_uvuni(const U8 *s, STRLEN *retlen)','name' => 'utf8_to_uvuni'},'pad_alloc' => {'text' => 'Allocates a place in the currently-compiling pad, returning the offset of the allocated pad slot. No name is initially attached to the pad slot. I is a set of flags indicating the kind of pad entry required, which will be set in the value SV for the allocated pad entry: SVs_PADMY named lexical variable ("my", "our", "state") SVs_PADTMP unnamed temporary store I should be an opcode indicating the type of operation that the pad entry is to support. This doesn\'t affect operational semantics, but is used for debugging. NOTE: this function is experimental and may change or be removed without notice. PADOFFSET pad_alloc(I32 optype, U32 tmptype)','name' => 'pad_alloc'},'av_fill' => {'text' => 'Set the highest index in the array to the given number, equivalent to Perl\'s C<$#array = $fill;>. The number of elements in the an array will be C after av_fill() returns. If the array was previously shorter, then the additional elements appended are set to C. If the array was longer, then the excess elements are freed. C is the same as C. void av_fill(AV *av, I32 fill)','name' => 'av_fill'},'croak_sv' => {'text' => 'This is an XS interface to Perl\'s C function. C is the error message or object. If it is a reference, it will be used as-is. Otherwise it is used as a string, and if it does not end with a newline then it will be extended with some indication of the current location in the code, as described for L. The error message or object will be used as an exception, by default returning control to the nearest enclosing C, but subject to modification by a C<$SIG{__DIE__}> handler. In any case, the C function never returns normally. To die with a simple string message, the L function may be more convenient. void croak_sv(SV *baseex)','name' => 'croak_sv'},'warn_nocontext' => {'text' => '','name' => 'warn_nocontext'},'my_swap' => {'text' => '','name' => 'my_swap'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'MoveD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * MoveD(void* src, void* dest, int nitems, type)','name' => 'MoveD'},'gv_IOadd' => {'text' => '','name' => 'gv_IOadd'},'grok_bin' => {'text' => 'converts a string representing a binary number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*flags> gives output flags. If the value is <= C it is returned as a UV, the output flags are clear, and nothing is written to I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The binary number may optionally be prefixed with "0b" or "b" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the binary number may use \'_\' characters to separate digits. UV grok_bin(const char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_bin'},'parse_barestmt' => {'text' => 'Parse a single unadorned Perl statement. This may be a normal imperative statement or a declaration that has compile-time effect. It does not include any label or other affixture. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed and the lexical context for the statement. The op tree representing the statement is returned. This may be a null pointer if the statement is null, for example if it was actually a subroutine definition (which has compile-time side effects). If not null, it will be ops directly implementing the statement, suitable to pass to L. It will not normally include a C or equivalent op (except for those embedded in a scope contained entirely within the statement). If an error occurs in parsing or compilation, in most cases a valid op tree (most likely null) is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. Some compilation errors, however, will throw an exception immediately. The I parameter is reserved for future use, and must always be zero. NOTE: this function is experimental and may change or be removed without notice. OP * parse_barestmt(U32 flags)','name' => 'parse_barestmt'},'cast_uv' => {'text' => '','name' => 'cast_uv'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L. void perl_free(PerlInterpreter *my_perl)','name' => 'perl_free'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C. MAGIC* mg_find(const SV* sv, int type)','name' => 'mg_find'},'safesysfree' => {'text' => '','name' => 'safesysfree'},'PL_parser-Elinestr' => {'text' => 'Buffer scalar containing the chunk currently under consideration of the text currently being lexed. This is always a plain string scalar (for which C is true). It is not intended to be used as a scalar by normal scalar means; instead refer to the buffer directly by the pointer variables described below. The lexer maintains various C pointers to things in the Clinestr> buffer. If Clinestr> is ever reallocated, all of these pointers must be updated. Don\'t attempt to do this manually, but rather use L if you need to reallocate the buffer. The content of the text chunk in the buffer is commonly exactly one complete line of input, up to and including a newline terminator, but there are situations where it is otherwise. The octets of the buffer may be intended to be interpreted as either UTF-8 or Latin-1. The function L tells you which. Do not use the C flag on this scalar, which may disagree with it. For direct examination of the buffer, the variable Lbufend> points to the end of the buffer. The current lexing position is pointed to by Lbufptr>. Direct use of these pointers is usually preferable to examination of the scalar through normal scalar means. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_parser-Elinestr'},'BhkENTRY_set' => {'text' => 'Set an entry in the BHK structure, and set the flags to indicate it is valid. I is a preprocessing token indicating which entry to set. The type of I depends on the entry. NOTE: this function is experimental and may change or be removed without notice. void BhkENTRY_set(BHK *hk, which, void *ptr)','name' => 'BhkENTRY_set'},'hv_riter_p' => {'text' => '','name' => 'hv_riter_p'},'newSVpvn_share' => {'text' => 'Creates a new SV with its SvPVX_const pointing to a shared string in the string table. If the string does not already exist in the table, it is created first. Turns on the SvIsCOW flag (or READONLY and FAKE in 5.16 and earlier). If the C parameter is non-zero, that value is used; otherwise the hash is computed. The string\'s hash can later be retrieved from the SV with the C macro. The idea here is that as the string table is used for shared hash keys these strings will have SvPVX_const == HeKEY and hash lookup will avoid string compare. SV* newSVpvn_share(const char* s, I32 len, U32 hash)','name' => 'newSVpvn_share'},'mro_set_mro' => {'text' => '','name' => 'mro_set_mro'},'SvPOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a character string. Checks the B setting. Use C instead. U32 SvPOKp(SV* sv)','name' => 'SvPOKp'},'pregfree2' => {'text' => '','name' => 'pregfree2'},'sv_catpvn' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpvn(SV *dsv, const char *sstr, STRLEN len)','name' => 'sv_catpvn'},'my_socketpair' => {'text' => '','name' => 'my_socketpair'},'blockhook_register' => {'text' => 'Register a set of hooks to be called when the Perl lexical scope changes at compile time. See L. NOTE: this function is experimental and may change or be removed without notice. NOTE: this function must be explicitly called as Perl_blockhook_register with an aTHX_ parameter. void Perl_blockhook_register(pTHX_ BHK *hk)','name' => 'blockhook_register'},'init_global_struct' => {'text' => '','name' => 'init_global_struct'},'find_rundefsv' => {'text' => 'Find and return the variable that is named C<$_> in the lexical scope of the currently-executing function. This may be a lexical C<$_>, or will otherwise be the global one. SV * find_rundefsv()','name' => 'find_rundefsv'},'sv_utf8_downgrade' => {'text' => 'Attempts to convert the PV of an SV from characters to bytes. If the PV contains a character that cannot fit in a byte, this conversion will fail; in this case, either returns false or, if C is not true, croaks. This is not a general purpose Unicode to byte encoding interface: use the Encode extension for that. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_downgrade(SV *const sv, const bool fail_ok)','name' => 'sv_utf8_downgrade'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either forward or backward. WARNING: do not use the following unless you *know* C is within the UTF-8 data pointed to by C *and* that on entry C is aligned on the first byte of character or just after the last byte of a character. U8* utf8_hop(const U8 *s, I32 off)','name' => 'utf8_hop'},'newPROG' => {'text' => '','name' => 'newPROG'},'sv_setref_pvn' => {'text' => '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 have a reference count of 1, and the RV will be returned. Note that C copies the pointer while this copies the string. SV* sv_setref_pvn(SV *const rv, const char *const classname, const char *const pv, const STRLEN n)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for scalars. See L.','name' => 'SVt_PVMG'},'gv_fetchsv' => {'text' => '','name' => 'gv_fetchsv'},'PUSHp' => {'text' => '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. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHp(char* str, STRLEN len)','name' => 'PUSHp'},'my_strftime' => {'text' => '','name' => 'my_strftime'},'mXPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void mXPUSHi(IV iv)','name' => 'mXPUSHi'},'PL_sv_undef' => {'text' => 'This is the C SV. Always refer to this as C<&PL_sv_undef>. SV PL_sv_undef','name' => 'PL_sv_undef'},'hv_iterkeysv' => {'text' => '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)','name' => 'hv_iterkeysv'},'sv_catpv_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. If C has the C bit set, will C on the modified SV if appropriate. void sv_catpv_flags(SV *dstr, const char *sstr, const I32 flags)','name' => 'sv_catpv_flags'},'mPUSHp' => {'text' => 'Push a string onto the stack. The stack must have room for this element. The C indicates the length of the string. Does not use C. See also C, C and C. void mPUSHp(char* str, STRLEN len)','name' => 'mPUSHp'},'lex_stuff_pv' => {'text' => 'Insert characters into the lexer buffer (Llinestr>), immediately after the current lexing point (Lbufptr>), reallocating the buffer if necessary. This means that lexing code that runs later will see the characters as if they had appeared in the input. It is not recommended to do this as part of normal parsing, and most uses of this facility run the risk of the inserted characters being interpreted in an unintended manner. The string to be inserted is represented by octets starting at I and continuing to the first nul. These octets are interpreted as either UTF-8 or Latin-1, according to whether the C flag is set in I. The characters are recoded for the lexer buffer, according to how the buffer is currently being interpreted (L). If it is not convenient to nul-terminate a string to be inserted, the L function is more appropriate. NOTE: this function is experimental and may change or be removed without notice. void lex_stuff_pv(const char *pv, U32 flags)','name' => 'lex_stuff_pv'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array, makes the element mortal, and returns it. If C equals C, the element is freed and null is returned. Perl equivalent: C for the non-C version and a void-context C for the C version. SV* av_delete(AV *av, I32 key, I32 flags)','name' => 'av_delete'},'utf8_distance' => {'text' => 'Returns the number of UTF-8 characters between the UTF-8 pointers C and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. IV utf8_distance(const U8 *a, const U8 *b)','name' => 'utf8_distance'},'SvPV_nomg' => {'text' => 'Like C but doesn\'t process magic. char* SvPV_nomg(SV* sv, STRLEN len)','name' => 'SvPV_nomg'},'parser_dup' => {'text' => '','name' => 'parser_dup'},'SVt_PVLV' => {'text' => 'Type flag for scalars. See L.','name' => 'SVt_PVLV'},'do_sprintf' => {'text' => '','name' => 'do_sprintf'},'SvUV_nomg' => {'text' => 'Like C but doesn\'t process magic. UV SvUV_nomg(SV* sv)','name' => 'SvUV_nomg'},'save_I32' => {'text' => '','name' => 'save_I32'},'gv_autoload4' => {'text' => '','name' => 'gv_autoload4'},'POPpx' => {'text' => 'Pops a string off the stack. Identical to POPp. There are two names for historical reasons. char* POPpx','name' => 'POPpx'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'newCONDOP' => {'text' => 'Constructs, checks, and returns a conditional-expression (C) op. I gives the eight bits of C, except that C will be set automatically, and, shifted up eight bits, the eight bits of C, except that the bit with value 1 is automatically set. I supplies the expression selecting between the two branches, and I and I supply the branches; they are consumed by this function and become part of the constructed op tree. OP * newCONDOP(I32 flags, OP *first, OP *trueop, OP *falseop)','name' => 'newCONDOP'},'save_pushi32ptr' => {'text' => '','name' => 'save_pushi32ptr'},'sv_setpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_setpvs(SV* sv, const char* s)','name' => 'sv_setpvs'},'cxinc' => {'text' => '','name' => 'cxinc'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. Guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'sv_clear' => {'text' => 'Clear an SV: call any destructors, free up any memory used by the body, and free the body itself. The SV\'s head is I freed, although its type is set to all 1\'s so that it won\'t inadvertently be assumed to be live during global destruction etc. This function should only be called when REFCNT is zero. Most of the time you\'ll want to call C (or its macro wrapper C) instead. void sv_clear(SV *const orig_sv)','name' => 'sv_clear'},'lex_read_space' => {'text' => 'Reads optional spaces, in Perl style, in the text currently being lexed. The spaces may include ordinary whitespace characters and Perl-style comments. C<#line> directives are processed if encountered. Lbufptr> is moved past the spaces, so that it points at a non-space character (or the end of the input text). If spaces extend into the next chunk of input text, the next chunk will be read in. Normally the current chunk will be discarded at the same time, but if I includes C then the current chunk will not be discarded. NOTE: this function is experimental and may change or be removed without notice. void lex_read_space(U32 flags)','name' => 'lex_read_space'},'SvGAMAGIC' => {'text' => 'Returns true if the SV has get magic or overloading. If either is true then the scalar is active data, and has the potential to return a new value every time it is accessed. Hence you must be careful to only read it once per user logical operation and work with that returned value. If neither is true then the scalar\'s value cannot change unless written to. U32 SvGAMAGIC(SV* sv)','name' => 'SvGAMAGIC'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'svtype' => {'text' => '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. The types are: SVt_NULL SVt_BIND (unused) SVt_IV SVt_NV SVt_RV SVt_PV SVt_PVIV SVt_PVNV SVt_PVMG SVt_REGEXP SVt_PVGV SVt_PVLV SVt_PVAV SVt_PVHV SVt_PVCV SVt_PVFM SVt_PVIO These are most easily explained from the bottom up. SVt_PVIO is for I/O objects, SVt_PVFM for formats, SVt_PVCV for subroutines, SVt_PVHV for hashes and SVt_PVAV for arrays. All the others are scalar types, that is, things that can be bound to a C<$> variable. For these, the internal types are mostly orthogonal to types in the Perl language. Hence, checking C<< SvTYPE(sv) < SVt_PVAV >> is the best way to see whether something is a scalar. SVt_PVGV represents a typeglob. If !SvFAKE(sv), then it is a real, incoercible typeglob. If SvFAKE(sv), then it is a scalar to which a typeglob has been assigned. Assigning to it again will stop it from being a typeglob. SVt_PVLV represents a scalar that delegates to another scalar behind the scenes. It is used, e.g., for the return value of C and for tied hash and array elements. It can hold any scalar value, including a typeglob. SVt_REGEXP is for regular expressions. SVt_PVMG represents a "normal" scalar (not a typeglob, regular expression, or delegate). Since most scalars do not need all the internal fields of a PVMG, we save memory by allocating smaller structs when possible. All the other types are just simpler forms of SVt_PVMG, with fewer internal fields. SVt_NULL can only hold undef. SVt_IV can hold undef, an integer, or a reference. (SVt_RV is an alias for SVt_IV, which exists for backward compatibility.) SVt_NV can hold any of those or a double. SVt_PV can only hold undef or a string. SVt_PVIV is a superset of SVt_PV and SVt_IV. SVt_PVNV is similar. SVt_PVMG can hold anything SVt_PVNV can hold, but it can, but does not have to, be blessed or magical.','name' => 'svtype'},'hv_placeholders_get' => {'text' => '','name' => 'hv_placeholders_get'},'load_module' => {'text' => '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 and not NULL, provides version semantics similar to C. The optional trailing SV* arguments can be used to specify arguments to the module\'s import() method, similar to C. They must be terminated with a final NULL pointer. Note that this list can only be omitted when the PERL_LOADMOD_NOIMPORT flag has been used. Otherwise at least a single NULL pointer to designate the default import list is required. The reference count for each specified C parameter is decremented. void load_module(U32 flags, SV* name, SV* ver, ...)','name' => 'load_module'},'dump_eval' => {'text' => '','name' => 'dump_eval'},'Poison' => {'text' => 'PoisonWith(0xEF) for catching access to freed memory. void Poison(void* dest, int nitems, type)','name' => 'Poison'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *const sv, const char *const pat, ...)','name' => 'sv_catpvf_mg'},'get_sv' => {'text' => 'Returns the SV of the specified Perl scalar. C are passed to C. If C is set and the Perl variable does not exist then it will be created. If C is zero 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 flags)','name' => 'get_sv'},'warn_sv' => {'text' => 'This is an XS interface to Perl\'s C function. C is the error message or object. If it is a reference, it will be used as-is. Otherwise it is used as a string, and if it does not end with a newline then it will be extended with some indication of the current location in the code, as described for L. The error message or object will by default be written to standard error, but this is subject to modification by a C<$SIG{__WARN__}> handler. To warn with a simple string message, the L function may be more convenient. void warn_sv(SV *baseex)','name' => 'warn_sv'},'GetVars' => {'text' => '','name' => 'GetVars'},'do_hv_dump' => {'text' => '','name' => 'do_hv_dump'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *const sv, const char *const ptr)','name' => 'sv_setpv_mg'},'whichsig' => {'text' => '','name' => 'whichsig'},'lex_next_chunk' => {'text' => 'Reads in the next chunk of text to be lexed, appending it to Llinestr>. This should be called when lexing code has looked to the end of the current chunk and wants to know more. It is usual, but not necessary, for lexing to have consumed the entirety of the current chunk at this time. If Lbufptr> is pointing to the very end of the current chunk (i.e., the current chunk has been entirely consumed), normally the current chunk will be discarded at the same time that the new chunk is read in. If I includes C, the current chunk will not be discarded. If the current chunk has not been entirely consumed, then it will not be discarded regardless of the flag. Returns true if some new text was added to the buffer, or false if the buffer has reached the end of the input text. NOTE: this function is experimental and may change or be removed without notice. bool lex_next_chunk(U32 flags)','name' => 'lex_next_chunk'},'sv_2mortal' => {'text' => 'Marks an existing SV as mortal. The SV will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. SvTEMP() is turned on which means that the SV\'s string buffer can be "stolen" if this SV is copied. See also C and C. SV* sv_2mortal(SV *const sv)','name' => 'sv_2mortal'},'sv_2bool_flags' => {'text' => 'This function is only used by sv_true() and friends, and only if the latter\'s argument is neither SvPOK, SvIOK nor SvNOK. If the flags contain SV_GMAGIC, then it does an mg_get() first. bool sv_2bool_flags(SV *const sv, const I32 flags)','name' => 'sv_2bool_flags'},'malloc' => {'text' => '','name' => 'malloc'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the av to store its list of scalars. If any destructors are triggered as a result, the av itself may be freed. void av_undef(AV *av)','name' => 'av_undef'},'parse_label' => {'text' => 'Parse a single label, possibly optional, of the type that may prefix a Perl statement. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed. If I includes C then the label is optional, otherwise it is mandatory. The name of the label is returned in the form of a fresh scalar. If an optional label is absent, a null pointer is returned. If an error occurs in parsing, which can only occur if the label is mandatory, a valid label is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. NOTE: this function is experimental and may change or be removed without notice. SV * parse_label(U32 flags)','name' => 'parse_label'},'PL_check' => {'text' => 'Array, indexed by opcode, of functions that will be called for the "check" phase of optree building during compilation of Perl code. For most (but not all) types of op, once the op has been initially built and populated with child ops it will be filtered through the check function referenced by the appropriate element of this array. The new op is passed in as the sole argument to the check function, and the check function returns the completed op. The check function may (as the name suggests) check the op for validity and signal errors. It may also initialise or modify parts of the ops, or perform more radical surgery such as adding or removing child ops, or even throw the op away and return a different op in its place. This array of function pointers is a convenient place to hook into the compilation process. An XS module can put its own custom check function in place of any of the standard ones, to influence the compilation of a particular type of op. However, a custom check function must never fully replace a standard check function (or even a custom check function from another module). A module modifying checking must instead B the preexisting check function. A custom check function must be selective about when to apply its custom behaviour. In the usual case where it decides not to do anything special with an op, it must chain the preexisting op function. Check functions are thus linked in a chain, with the core\'s base checker at the end. For thread safety, modules should not write directly to this array. Instead, use the function L.','name' => 'PL_check'},'pack_cat' => {'text' => '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, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)','name' => 'pack_cat'},'PerlIO_read' => {'text' => '','name' => 'PerlIO_read'},'sv_cmp' => {'text' => '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. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp(SV *const sv1, SV *const sv2)','name' => 'sv_cmp'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'sv_force_normal_flags' => {'text' => 'Undo various types of fakery on an SV, where fakery means "more than" a string: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg; if we\'re a copy-on-write scalar, this is the on-write time when we do the copy, and is also used locally; if this is a vstring, drop the vstring magic. If C is set then a copy-on-write scalar drops its PV buffer (if any) and becomes SvPOK_off rather than making a copy. (Used where this scalar is about to be set to some other value.) In addition, the C parameter gets passed to C when unreffing. C calls this function with flags set to 0. void sv_force_normal_flags(SV *const sv, const U32 flags)','name' => 'sv_force_normal_flags'},'cophh_fetch_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of a string/length pair. NOTE: this function is experimental and may change or be removed without notice. SV * cophh_fetch_pv(const COPHH *cophh, const char *key, U32 hash, U32 flags)','name' => 'cophh_fetch_pv'},'tmps_grow' => {'text' => '','name' => 'tmps_grow'},'is_utf8_char' => {'text' => 'DEPRECATED! Tests if some arbitrary number of bytes begins in a valid UTF-8 character. Note that an INVARIANT (i.e. ASCII on non-EBCDIC machines) character is a valid UTF-8 character. The actual number of bytes in the UTF-8 character will be returned if it is valid, otherwise 0. This function is deprecated due to the possibility that malformed input could cause reading beyond the end of the input buffer. Use L instead. STRLEN is_utf8_char(const U8 *s)','name' => 'is_utf8_char'},'get_vtbl' => {'text' => '','name' => 'get_vtbl'},'save_hints' => {'text' => '','name' => 'save_hints'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'gv_fetchmeth_pv_autoload' => {'text' => 'Exactly like L, but takes a nul-terminated string instead of a string/length pair. GV* gv_fetchmeth_pv_autoload(HV* stash, const char* name, I32 level, U32 flags)','name' => 'gv_fetchmeth_pv_autoload'},'sv_utf8_upgrade' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Will C on C if appropriate. Always sets the SvUTF8 flag to avoid future validity checks even if the whole string is the same in UTF-8 as not. Returns the number of bytes in the converted string This is not a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. Sets up the C and C variables by calling C and C. This is usually handled automatically by C. dXSARGS;','name' => 'dXSARGS'},'savesharedpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the specified character is a whitespace character. This is analogous to what C matches in a regular expression. Starting in Perl 5.18 (experimentally), this also matches what C does. ("Experimentally" means that this change may be backed out in 5.20 or 5.22 if field experience indicates that it was unwise.) Prior to 5.18, only the locale forms of this macro (the ones with C in their names) matched precisely what C does. In those releases, the only difference, in the non-locale variants, was that C did not match a vertical tab. (See L for a macro that matches a vertical tab in all releases.) See the L for an explanation of variants C, C, C, C, C, C, and C. bool isSPACE(char ch)','name' => 'isSPACE'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* ptr)','name' => 'Safefree'},'custom_op_desc' => {'text' => 'Return the description of a given custom op. This was once used by the OP_DESC macro, but is no longer: it has only been kept for compatibility, and should not be used. const char * custom_op_desc(const OP *o)','name' => 'custom_op_desc'},'regdupe_internal' => {'text' => '','name' => 'regdupe_internal'},'gv_stashpvn' => {'text' => 'Returns a pointer to the stash for a specified package. The C parameter indicates the length of the C, in bytes. C is passed to C, so if set to C then the package will be created if it does not already exist. If the package does not exist and C is 0 (or any other setting that does not create packages) then NULL is returned. Flags may be one of: GV_ADD SVf_UTF8 GV_NOADD_NOINIT GV_NOINIT GV_NOEXPAND GV_ADDMG The most important of which are probably GV_ADD and SVf_UTF8. HV* gv_stashpvn(const char* name, U32 namelen, I32 flags)','name' => 'gv_stashpvn'},'vmess' => {'text' => 'C and C are a sprintf-style format pattern and encapsulated argument list. These are used to generate a string message. If the message does not end with a newline, then it will be extended with some indication of the current location in the code, as described for L. Normally, the resulting message is returned in a new mortal SV. During global destruction a single SV may be shared between uses of this function. SV * vmess(const char *pat, va_list *args)','name' => 'vmess'},'new_collate' => {'text' => '','name' => 'new_collate'},'my_stat' => {'text' => '','name' => 'my_stat'},'my_setenv' => {'text' => '','name' => 'my_setenv'},'newSV_type' => {'text' => 'Creates a new SV, of the type specified. The reference count for the new SV is set to 1. SV* newSV_type(const svtype type)','name' => 'newSV_type'},'SvREFCNT_inc_void_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value, and you know that I is not NULL. The macro doesn\'t need to return a meaningful value, or check for NULLness, so it\'s smaller and faster. void SvREFCNT_inc_void_NN(SV* sv)','name' => 'SvREFCNT_inc_void_NN'},'Perl_signbit' => {'text' => 'Return a non-zero integer if the sign bit on an NV is set, and 0 if it is not. If Configure detects this system has a signbit() that will work with our NVs, then we just use it via the #define in perl.h. Otherwise, fall back on this implementation. As a first pass, this gets everything right except -0.0. Alas, catching -0.0 is the main use for this function, so this is not too helpful yet. Still, at least we have the scaffolding in place to support other systems, should that prove useful. Configure notes: This function is called \'Perl_signbit\' instead of a plain \'signbit\' because it is easy to imagine a system having a signbit() function or macro that doesn\'t happen to work with our particular choice of NVs. We shouldn\'t just re-#define signbit as Perl_signbit and expect the standard system headers to be happy. Also, this is a no-context function (no pTHX_) because Perl_signbit() is usually re-#defined in perl.h as a simple macro call to the system\'s signbit(). Users should just always call Perl_signbit(). NOTE: this function is experimental and may change or be removed without notice. int Perl_signbit(NV f)','name' => 'Perl_signbit'},'PUSH_MULTICALL' => {'text' => 'Opening bracket for a lightweight callback. See L. PUSH_MULTICALL;','name' => 'PUSH_MULTICALL'},'new_ctype' => {'text' => '','name' => 'new_ctype'},'save_svref' => {'text' => '','name' => 'save_svref'},'newNULLLIST' => {'text' => 'Constructs, checks, and returns a new C op, which represents an empty list expression. OP * newNULLLIST()','name' => 'newNULLLIST'},'sv_pos_u2b_flags' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from the start of the string, to a count of the equivalent number of bytes; if lenp is non-zero, it does the same to lenp, but this time starting from the offset, rather than from the start of the string. Handles type coercion. I is passed to C, and usually should be C to handle magic. STRLEN sv_pos_u2b_flags(SV *const sv, STRLEN uoffset, STRLEN *const lenp, U32 flags)','name' => 'sv_pos_u2b_flags'},'init_tm' => {'text' => '','name' => 'init_tm'},'newWHILEOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C loop. This is a heavyweight loop, with structure that allows exiting the loop by C and suchlike. I is an optional preconstructed C op to use in the loop; if it is null then a suitable op will be constructed automatically. I supplies the loop\'s controlling expression. I supplies the main body of the loop, and I optionally supplies a C block that operates as a second half of the body. All of these optree inputs are consumed by this function and become part of the constructed op tree. I gives the eight bits of C for the C op and, shifted up eight bits, the eight bits of C for the C op, except that (in both cases) some bits will be set automatically. I is currently unused and should always be 1. I can be supplied as true to force the loop body to be enclosed in its own scope. OP * newWHILEOP(I32 flags, I32 debuggable, LOOP *loop, OP *expr, OP *block, OP *cont, I32 has_my)','name' => 'newWHILEOP'},'Gv_AMupdate' => {'text' => '','name' => 'Gv_AMupdate'},'filter_del' => {'text' => '','name' => 'filter_del'},'SvIV_nomg' => {'text' => 'Like C but doesn\'t process magic. IV SvIV_nomg(SV* sv)','name' => 'SvIV_nomg'},'POPp' => {'text' => 'Pops a string off the stack. char* POPp','name' => 'POPp'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'newANONLIST' => {'text' => '','name' => 'newANONLIST'},'mg_findext' => {'text' => 'Finds the magic pointer of C with the given C for the C. See C. MAGIC* mg_findext(const SV* sv, int type, const MGVTBL *vtbl)','name' => 'mg_findext'},'my_memset' => {'text' => '','name' => 'my_memset'},'my_atof2' => {'text' => '','name' => 'my_atof2'},'PerlIO_get_ptr' => {'text' => '','name' => 'PerlIO_get_ptr'},'save_destructor' => {'text' => '','name' => 'save_destructor'},'sv_cmp_flags' => {'text' => '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. Is UTF-8 and \'use bytes\' aware and will coerce its args to strings if necessary. If the flags include SV_GMAGIC, it handles get magic. See also C. I32 sv_cmp_flags(SV *const sv1, SV *const sv2, const U32 flags)','name' => 'sv_cmp_flags'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV *hv, char **key, I32 *retlen)','name' => 'hv_iternextsv'},'lex_read_to' => {'text' => 'Consume text in the lexer buffer, from Lbufptr> up to I. This advances Lbufptr> to match I, performing the correct bookkeeping whenever a newline character is passed. This is the normal way to consume lexed text. Interpretation of the buffer\'s octets can be abstracted out by using the slightly higher-level functions L and L. NOTE: this function is experimental and may change or be removed without notice. void lex_read_to(char *ptr)','name' => 'lex_read_to'},'sv_pvbyten_force' => {'text' => 'The backend for the C macro. Always use the macro instead. char* sv_pvbyten_force(SV *const sv, STRLEN *const lp)','name' => 'sv_pvbyten_force'},'reg_named_buff_fetch' => {'text' => '','name' => 'reg_named_buff_fetch'},'ibcmp_locale' => {'text' => 'This is a synonym for (! foldEQ_locale()) I32 ibcmp_locale(const char* a, const char* b, I32 len)','name' => 'ibcmp_locale'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'save_pptr' => {'text' => '','name' => 'save_pptr'},'PerlIO_set_ptrcnt' => {'text' => '','name' => 'PerlIO_set_ptrcnt'},'mPUSHs' => {'text' => 'Push an SV onto the stack and mortalizes the SV. The stack must have room for this element. Does not use C. See also C and C. void mPUSHs(SV* sv)','name' => 'mPUSHs'},'dump_packsubs' => {'text' => '','name' => 'dump_packsubs'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'isPRINT' => {'text' => 'Returns a boolean indicating whether the specified character is a printable character, analogous to C. See the L for an explanation of variants C, C, C, C, C, C, and C. bool isPRINT(char ch)','name' => 'isPRINT'},'init_i18nl10n' => {'text' => '','name' => 'init_i18nl10n'},'vform' => {'text' => '','name' => 'vform'},'get_op_descs' => {'text' => '','name' => 'get_op_descs'},'safesyscalloc' => {'text' => '','name' => 'safesyscalloc'},'PL_curpad' => {'text' => 'Points directly to the body of the L array. (I.e., this is C.) NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_curpad'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'parse_stmtseq' => {'text' => 'Parse a sequence of zero or more Perl statements. These may be normal imperative statements, including optional labels, or declarations that have compile-time effect, or any mixture thereof. The statement sequence ends when a closing brace or end-of-file is encountered in a place where a new statement could have validly started. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed and the lexical context for the statements. The op tree representing the statement sequence is returned. This may be a null pointer if the statements were all null, for example if there were no statements or if there were only subroutine definitions (which have compile-time side effects). If not null, it will be a C list, normally including C or equivalent ops. If an error occurs in parsing or compilation, in most cases a valid op tree is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. Some compilation errors, however, will throw an exception immediately. The I parameter is reserved for future use, and must always be zero. NOTE: this function is experimental and may change or be removed without notice. OP * parse_stmtseq(U32 flags)','name' => 'parse_stmtseq'},'sv_2pvutf8_nolen' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8_nolen(SV* sv)','name' => 'sv_2pvutf8_nolen'},'gv_HVadd' => {'text' => '','name' => 'gv_HVadd'},'custom_op_xop' => {'text' => 'Return the XOP structure for a given custom op. This function should be considered internal to OP_NAME and the other access macros: use them instead. NOTE: this function must be explicitly called as Perl_custom_op_xop with an aTHX_ parameter. const XOP * Perl_custom_op_xop(pTHX_ const OP *o)','name' => 'custom_op_xop'},'mro_get_linear_isa' => {'text' => 'Returns the mro linearisation for the given stash. By default, this will be whatever C returns unless some other MRO is in effect for the stash. The return value is a read-only AV*. You are responsible for C on the return value if you plan to store it anywhere semi-permanently (otherwise it might be deleted out from under you the next time the cache is invalidated). AV* mro_get_linear_isa(HV* stash)','name' => 'mro_get_linear_isa'},'SvPVbytex' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex(SV* sv, STRLEN len)','name' => 'SvPVbytex'},'av_store' => {'text' => '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 C that was stored there (= 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. Approximate Perl equivalent: C<$myarray[$key] = $val;>. See L for more information on how to use this function on tied arrays. SV** av_store(AV *av, I32 key, SV *val)','name' => 'av_store'},'reg_named_buff_scalar' => {'text' => '','name' => 'reg_named_buff_scalar'},'unlnk' => {'text' => '','name' => 'unlnk'},'av_fetch' => {'text' => 'Returns the SV at the specified index in the array. The C is the index. If lval is true, you are guaranteed to get a real SV back (in case it wasn\'t real before), which you can then modify. 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. The rough perl equivalent is C<$myarray[$idx]>. SV** av_fetch(AV *av, I32 key, I32 lval)','name' => 'av_fetch'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV *hv, HE *entry)','name' => 'hv_iterval'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. const char* sv_reftype(const SV *const sv, const int ob)','name' => 'sv_reftype'},'foldEQ_locale' => {'text' => 'Returns true if the leading len bytes of the strings s1 and s2 are the same case-insensitively in the current locale; false otherwise. I32 foldEQ_locale(const char* a, const char* b, I32 len)','name' => 'foldEQ_locale'},'cophh_2hv' => {'text' => 'Generates and returns a standard Perl hash representing the full set of key/value pairs in the cop hints hash I. I is currently unused and must be zero. NOTE: this function is experimental and may change or be removed without notice. HV * cophh_2hv(const COPHH *cophh, U32 flags)','name' => 'cophh_2hv'},'SvREFCNT_inc_simple_void_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value, and you know that I is not NULL. The macro doesn\'t need to return a meaningful value, or check for NULLness, so it\'s smaller and faster. void SvREFCNT_inc_simple_void_NN(SV* sv)','name' => 'SvREFCNT_inc_simple_void_NN'},'rsignal_state' => {'text' => '','name' => 'rsignal_state'},'av_len' => {'text' => 'Same as L. Returns the highest index in the array. Note that the return value is +1 what its name implies it returns; and hence differs in meaning from what the similarly named L returns. I32 av_len(AV *av)','name' => 'av_len'},'sv_unmagic' => {'text' => 'Removes all magic of type C from an SV. int sv_unmagic(SV *const sv, const int type)','name' => 'sv_unmagic'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled, and if some input to the current expression is tainted--usually a variable, but possibly also implicit inputs such as locale settings. C propagates that taintedness to the outputs of an expression in a pessimistic fashion; i.e., without paying attention to precisely which outputs are influenced by which inputs. void SvTAINT(SV* sv)','name' => 'SvTAINT'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'my_sprintf' => {'text' => 'The C library C, wrapped if necessary, to ensure that it will return the length of the string written to the buffer. Only rare pre-ANSI systems need the wrapper function - usually this is a direct call to C. int my_sprintf(char *buffer, const char *pat, ...)','name' => 'my_sprintf'},'to_utf8_fold' => {'text' => 'Convert the UTF-8 encoded character at C

to its foldcase version and store that in UTF-8 in C and its length in bytes in C. Note that the C needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the foldcase version may be longer than the original character (up to three characters). The first character of the foldcased version is returned (but note, as explained above, that there may be more.) The character at C

is assumed by this routine to be well-formed. UV to_utf8_fold(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_fold'},'regfree_internal' => {'text' => '','name' => 'regfree_internal'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. Uses C to determine the length of C, then calls C. HV* gv_stashpv(const char* name, I32 flags)','name' => 'gv_stashpv'},'sv_cmp_locale_flags' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware and will coerce its args to strings if necessary. If the flags contain SV_GMAGIC, it handles get magic. See also C. I32 sv_cmp_locale_flags(SV *const sv1, SV *const sv2, const U32 flags)','name' => 'sv_cmp_locale_flags'},'sv_vcatpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vcatpvf_mg(SV *const sv, const char *const pat, va_list *const args)','name' => 'sv_vcatpvf_mg'},'mXPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void mXPUSHu(UV uv)','name' => 'mXPUSHu'},'hv_exists_ent' => {'text' => '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 *hv, SV *keysv, U32 hash)','name' => 'hv_exists_ent'},'PL_comppad' => {'text' => 'During compilation, this points to the array containing the values part of the pad for the currently-compiling code. (At runtime a CV may have many such value arrays; at compile time just one is constructed.) At runtime, this points to the array containing the currently-relevant values for the pad for the currently-executing code. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_comppad'},'atfork_unlock' => {'text' => '','name' => 'atfork_unlock'},'SvNIOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a number, integer or double. U32 SvNIOK(SV* sv)','name' => 'SvNIOK'},'save_long' => {'text' => '','name' => 'save_long'},'mro_method_changed_in' => {'text' => 'Invalidates method caching on any child classes of the given stash, so that they might notice the changes in this one. Ideally, all instances of C in perl source outside of F should be replaced by calls to this. Perl automatically handles most of the common ways a method might be redefined. However, there are a few ways you could change a method in a stash without the cache code noticing, in which case you need to call this method afterwards: 1) Directly manipulating the stash HV entries from XS code. 2) Assigning a reference to a readonly scalar constant into a stash entry in order to create a constant subroutine (like constant.pm does). This same method is available from pure perl via, C. void mro_method_changed_in(HV* stash)','name' => 'mro_method_changed_in'},'unpack_str' => {'text' => '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(const char *pat, const char *patend, const char *s, const char *strbeg, const char *strend, char **new_s, I32 ocnt, U32 flags)','name' => 'unpack_str'},'my_fflush_all' => {'text' => '','name' => 'my_fflush_all'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C wrapper instead. SV* sv_newref(SV *const sv)','name' => 'sv_newref'},'cop_hints_fetch_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of a string/length pair. SV * cop_hints_fetch_pv(const COP *cop, const char *key, U32 hash, U32 flags)','name' => 'cop_hints_fetch_pv'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'sv_uni_display' => {'text' => 'Build to the scalar C a displayable version of the scalar C, the displayable version being at most C bytes long (if longer, the rest is truncated and "..." will be appended). The C argument is as in L(). The pointer to the PV of the C is returned. char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim, UV flags)','name' => 'sv_uni_display'},'sv_unmagicext' => {'text' => 'Removes all magic of type C with the specified C from an SV. int sv_unmagicext(SV *const sv, const int type, MGVTBL *vtbl)','name' => 'sv_unmagicext'},'newSVpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV* newSVpvs(const char* s)','name' => 'newSVpvs'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. I may be NULL. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'realloc' => {'text' => '','name' => 'realloc'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C for a version which guarantees to evaluate sv only once. NV SvNV(SV* sv)','name' => 'SvNV'},'packlist' => {'text' => 'The engine implementing pack() Perl function. void packlist(SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist)','name' => 'packlist'},'SvUTF8' => {'text' => 'Returns a U32 value indicating the UTF-8 status of an SV. If things are set-up properly, this indicates whether or not the SV contains UTF-8 encoded data. You should use this I a call to SvPV() or one of its variants, in case any call to string overloading updates the internal flag. U32 SvUTF8(SV* sv)','name' => 'SvUTF8'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'op_dump' => {'text' => '','name' => 'op_dump'},'get_mstats' => {'text' => '','name' => 'get_mstats'},'savestack_grow' => {'text' => '','name' => 'savestack_grow'},'debstackptrs' => {'text' => '','name' => 'debstackptrs'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'ptr_table_store' => {'text' => '','name' => 'ptr_table_store'},'cv_undef' => {'text' => 'Clear out all the active components of a CV. This can happen either by an explicit C, 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)','name' => 'cv_undef'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. void StructCopy(type *src, type *dest, type)','name' => 'StructCopy'},'sv_catpvf_nocontext' => {'text' => '','name' => 'sv_catpvf_nocontext'},'save_padsv_and_mortalize' => {'text' => '','name' => 'save_padsv_and_mortalize'},'gv_autoload_sv' => {'text' => '','name' => 'gv_autoload_sv'},'cophh_delete_pvs' => {'text' => 'Like L, but takes a literal string instead of a string/length pair, and no precomputed hash. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_delete_pvs(const COPHH *cophh, const char *key, U32 flags)','name' => 'cophh_delete_pvs'},'GvCV' => {'text' => 'Return the CV from the GV. CV* GvCV(GV* gv)','name' => 'GvCV'},'get_cvn_flags' => {'text' => 'Returns the CV of the specified Perl subroutine. C are passed to C. 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_cvn_flags(const char* name, STRLEN len, I32 flags)','name' => 'get_cvn_flags'},'XopENTRY_set' => {'text' => 'Set a member of the XOP structure. I is a cpp token indicating which entry to set. See L for details about the available members and how they are used. void XopENTRY_set(XOP *xop, which, value)','name' => 'XopENTRY_set'},'reentrant_free' => {'text' => '','name' => 'reentrant_free'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'dump_vindent' => {'text' => '','name' => 'dump_vindent'},'SvPVx' => {'text' => 'A version of C which guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. char* SvPVx(SV* sv, STRLEN len)','name' => 'SvPVx'},'dump_form' => {'text' => '','name' => 'dump_form'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. If necessary, uses C and upgrades the SV to C. Returns a pointer to the character buffer. Use the C wrapper instead. char* sv_grow(SV *const sv, STRLEN newlen)','name' => 'sv_grow'},'vnormal' => {'text' => 'Accepts a version object and returns the normalized string representation. Call like: sv = vnormal(rv); NOTE: you can pass either the object directly or the SV contained within the RV. The SV returned has a refcount of 1. SV* vnormal(SV *vs)','name' => 'vnormal'},'filter_add' => {'text' => '','name' => 'filter_add'},'newPVOP' => {'text' => 'Constructs, checks, and returns an op of any type that involves an embedded C-level pointer (PV). I is the opcode. I gives the eight bits of C. I supplies the C-level pointer, which must have been allocated using L; the memory will be freed when the op is destroyed. OP * newPVOP(I32 type, I32 flags, char *pv)','name' => 'newPVOP'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. Does not use C. See also C, C and C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'set_numeric_radix' => {'text' => '','name' => 'set_numeric_radix'},'newIO' => {'text' => '','name' => 'newIO'},'PadnameUTF8' => {'text' => 'Whether PadnamePV is in UTF8. NOTE: this function is experimental and may change or be removed without notice. bool PadnameUTF8(PADNAME pn)','name' => 'PadnameUTF8'},'do_join' => {'text' => '','name' => 'do_join'},'save_helem' => {'text' => '','name' => 'save_helem'},'die' => {'text' => 'Behaves the same as L, except for the return type. It should be used only where the C return type is required. The function never actually returns. OP * die(const char *pat, ...)','name' => 'die'},'sv_usepvn' => {'text' => 'Tells an SV to use C to find its string value. Implemented by calling C with C of 0, hence does not handle \'set\' magic. See C. void sv_usepvn(SV* sv, char* ptr, STRLEN len)','name' => 'sv_usepvn'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'newCONSTSUB_flags' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. Currently, the only useful value for C is SVf_UTF8. The newly created subroutine takes ownership of a reference to the passed in SV. Passing NULL for SV creates a constant sub equivalent to C, which won\'t be called if used as a destructor, but will suppress the overhead of a call to C. (This form, however, isn\'t eligible for inlining at compile time.) CV* newCONSTSUB_flags(HV* stash, const char* name, STRLEN len, U32 flags, SV* sv)','name' => 'newCONSTSUB_flags'},'swash_init' => {'text' => '','name' => 'swash_init'},'newANONSUB' => {'text' => '','name' => 'newANONSUB'},'warn' => {'text' => 'This is an XS interface to Perl\'s C function. Take a sprintf-style format pattern and argument list. These are used to generate a string message. If the message does not end with a newline, then it will be extended with some indication of the current location in the code, as described for L. The error message or object will by default be written to standard error, but this is subject to modification by a C<$SIG{__WARN__}> handler. Unlike with L, C is not permitted to be null. void warn(const char *pat, ...)','name' => 'warn'},'PerlIO_get_bufsiz' => {'text' => '','name' => 'PerlIO_get_bufsiz'},'fp_dup' => {'text' => '','name' => 'fp_dup'},'hek_dup' => {'text' => '','name' => 'hek_dup'},'pmop_dump' => {'text' => '','name' => 'pmop_dump'},'newANONATTRSUB' => {'text' => '','name' => 'newANONATTRSUB'},'CvPADLIST' => {'text' => 'CV\'s can have CvPADLIST(cv) set to point to a PADLIST. This is the CV\'s scratchpad, which stores lexical variables and opcode temporary and per-thread values. For these purposes "formats" are a kind-of CV; eval""s are too (except they\'re not callable at will and are always thrown away after the eval"" is done executing). Require\'d files are simply evals without any outer lexical scope. XSUBs don\'t have CvPADLIST set - dXSTARG fetches values from PL_curpad, but that is really the callers pad (a slot of which is allocated by every entersub). The PADLIST has a C array where pads are stored. The 0th entry of the PADLIST is a PADNAMELIST (which is actually just an AV, but that may change) which represents the "names" or rather the "static type information" for lexicals. The individual elements of a PADNAMELIST are PADNAMEs (just SVs; but, again, that may change). Future refactorings might stop the PADNAMELIST from being stored in the PADLIST\'s array, so don\'t rely on it. See L. The CvDEPTH\'th entry of a PADLIST is a PAD (an AV) which is the stack frame at that depth of recursion into the CV. The 0th slot of a frame AV is an AV which is @_. Other entries are storage for variables and op targets. Iterating over the PADNAMELIST iterates over all possible pad items. Pad slots that are SVs_PADTMP (targets/GVs/constants) end up having &PL_sv_undef "names" (see pad_alloc()). Only my/our variable (SvPADMY/PADNAME_isOUR) slots get valid names. The rest are op targets/GVs/constants which are statically allocated or resolved at compile time. These don\'t have names by which they can be looked up from Perl code at run time through eval"" the way my/our variables can be. Since they can\'t be looked up by "name" but only by their index allocated at compile time (which is usually in PL_op->op_targ), wasting a name SV for them doesn\'t make sense. The SVs in the names AV have their PV being the name of the variable. xlow+1..xhigh inclusive in the NV union is a range of cop_seq numbers for which the name is valid (accessed through the macros COP_SEQ_RANGE_LOW and _HIGH). During compilation, these fields may hold the special value PERL_PADSEQ_INTRO to indicate various stages: COP_SEQ_RANGE_LOW _HIGH ----------------- ----- PERL_PADSEQ_INTRO 0 variable not yet introduced: { my ($x valid-seq# PERL_PADSEQ_INTRO variable in scope: { my ($x) valid-seq# valid-seq# compilation of scope complete: { my ($x) } For typed lexicals name SV is SVt_PVMG and SvSTASH points at the type. For C lexicals, the type is also SVt_PVMG, with the SvOURSTASH slot pointing at the stash of the associated global (so that duplicate C declarations in the same package can be detected). SvUVX is sometimes hijacked to store the generation number during compilation. If PADNAME_OUTER (SvFAKE) is set on the name SV, then that slot in the frame AV is a REFCNT\'ed reference to a lexical from "outside". In this case, the name SV does not use xlow and xhigh to store a cop_seq range, since it is in scope throughout. Instead xhigh stores some flags containing info about the real lexical (is it declared in an anon, and is it capable of being instantiated multiple times?), and for fake ANONs, xlow contains the index within the parent\'s pad where the lexical\'s value is stored, to make cloning quicker. If the \'name\' is \'&\' the corresponding entry in the PAD is a CV representing a possible closure. (PADNAME_OUTER and name of \'&\' is not a meaningful combination currently but could become so if C is implemented.) Note that formats are treated as anon subs, and are cloned each time write is called (if necessary). The flag SVs_PADSTALE is cleared on lexicals each time the my() is executed, and set on scope exit. This allows the \'Variable $x is not available\' warning to be generated in evals, such as { my $x = 1; sub f { eval \'$x\'} } f(); For state vars, SVs_PADSTALE is overloaded to mean \'not yet initialised\'. NOTE: this function is experimental and may change or be removed without notice. PADLIST * CvPADLIST(CV *cv)','name' => 'CvPADLIST'},'HvNAMEUTF8' => {'text' => 'Returns true if the name is in UTF8 encoding. unsigned char HvNAMEUTF8(HV *stash)','name' => 'HvNAMEUTF8'},'SVt_PVGV' => {'text' => 'Type flag for typeglobs. See L.','name' => 'SVt_PVGV'},'sv_catpvf_mg_nocontext' => {'text' => '','name' => 'sv_catpvf_mg_nocontext'},'reg_named_buff_all' => {'text' => '','name' => 'reg_named_buff_all'},'PerlIO_close' => {'text' => '','name' => 'PerlIO_close'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. void EXTEND(SP, int nitems)','name' => 'EXTEND'},'newOP' => {'text' => 'Constructs, checks, and returns an op of any base type (any type that has no extra fields). I is the opcode. I gives the eight bits of C, and, shifted up eight bits, the eight bits of C. OP * newOP(I32 type, I32 flags)','name' => 'newOP'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(const UV u)','name' => 'newSVuv'},'gv_fetchmeth' => {'text' => 'Like L, but lacks a flags parameter. GV* gv_fetchmeth(HV* stash, const char* name, STRLEN len, I32 level)','name' => 'gv_fetchmeth'},'op_refcnt_lock' => {'text' => '','name' => 'op_refcnt_lock'},'gv_fetchmeth_pvn_autoload' => {'text' => 'Same as gv_fetchmeth_pvn(), 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 C. For an autoloaded subroutine without a stub, GvCV() of the result may be zero. Currently, the only significant value for C is SVf_UTF8. GV* gv_fetchmeth_pvn_autoload(HV* stash, const char* name, STRLEN len, I32 level, U32 flags)','name' => 'gv_fetchmeth_pvn_autoload'},'newGVgen' => {'text' => '','name' => 'newGVgen'},'sv_does' => {'text' => 'Like L, but doesn\'t take a C parameter. bool sv_does(SV* sv, const char *const name)','name' => 'sv_does'},'delimcpy' => {'text' => '','name' => 'delimcpy'},'newLOOPOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a loop. This is only a loop in the control flow through the op tree; it does not have the heavyweight loop structure that allows exiting the loop by C and suchlike. I gives the eight bits of C for the top-level op, except that some bits will be set automatically as required. I supplies the expression controlling loop iteration, and I supplies the body of the loop; they are consumed by this function and become part of the constructed op tree. I is currently unused and should always be 1. OP * newLOOPOP(I32 flags, I32 debuggable, OP *expr, OP *block)','name' => 'newLOOPOP'},'reg_named_buff_firstkey' => {'text' => '','name' => 'reg_named_buff_firstkey'},'free_global_struct' => {'text' => '','name' => 'free_global_struct'},'uvuni_to_utf8' => {'text' => '','name' => 'uvuni_to_utf8'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part attributable to C. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'PerlIO_tell' => {'text' => '','name' => 'PerlIO_tell'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a string and disables all other OK bits, and leaves the UTF-8 status as it was. void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic before a value is retrieved from the SV. The type of SV must be >= SVt_PVMG. See C. int mg_get(SV* sv)','name' => 'mg_get'},'SvTRUE' => {'text' => 'Returns a boolean indicating whether Perl would evaluate the SV as true or false. See SvOK() for a defined/undefined test. Handles \'get\' magic unless the scalar is already SvPOK, SvIOK or SvNOK (the public, not the private flags). bool SvTRUE(SV* sv)','name' => 'SvTRUE'},'regdump' => {'text' => '','name' => 'regdump'},'my_pclose' => {'text' => '','name' => 'my_pclose'},'hv_iternext_flags' => {'text' => 'Returns entries from a hash iterator. See C and C. The C 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 C<&PL_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 *hv, I32 flags)','name' => 'hv_iternext_flags'},'is_utf8_string_loclen' => {'text' => 'Like L() but stores the location of the failure (in the case of "utf8ness failure") or the location C+C (in the case of "utf8ness success") in the C, and the number of UTF-8 encoded characters in the C. See also L() and L(). bool is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el)','name' => 'is_utf8_string_loclen'},'call_method' => {'text' => '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)','name' => 'call_method'},'BhkENABLE' => {'text' => 'Re-enable an entry in this BHK structure, by setting the appropriate flag. I is a preprocessor token indicating which entry to enable. This will assert (under -DDEBUGGING) if the entry doesn\'t contain a valid pointer. NOTE: this function is experimental and may change or be removed without notice. void BhkENABLE(BHK *hk, which)','name' => 'BhkENABLE'},'sys_init' => {'text' => '','name' => 'sys_init'},'perl_parse' => {'text' => 'Tells a Perl interpreter to parse a Perl script. See L. int perl_parse(PerlInterpreter *my_perl, XSINIT_t xsinit, int argc, char** argv, char** env)','name' => 'perl_parse'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory the av uses to store its list of scalars. If any destructors are triggered as a result, the av itself may be freed when this function returns. Perl equivalent: C<@myarray = ();>. void av_clear(AV *av)','name' => 'av_clear'},'sv_force_normal' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. See also C. void sv_force_normal(SV *sv)','name' => 'sv_force_normal'},'av_unshift' => {'text' => '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. Perl equivalent: C void av_unshift(AV *av, I32 num)','name' => 'av_unshift'},'save_set_svflags' => {'text' => '','name' => 'save_set_svflags'},'SvREFCNT_inc_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you know I is not NULL. Since we don\'t have to check the NULLness, it\'s faster and smaller. SV* SvREFCNT_inc_NN(SV* sv)','name' => 'SvREFCNT_inc_NN'},'sys_term' => {'text' => '','name' => 'sys_term'},'re_intuit_start' => {'text' => '','name' => 're_intuit_start'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. UV SvUVX(SV* sv)','name' => 'SvUVX'},'hv_copy_hints_hv' => {'text' => 'A specialised version of L for copying C<%^H>. I must be a pointer to a hash (which may have C<%^H> magic, but should be generally non-magical), or C (interpreted as an empty hash). The content of I is copied to a new hash, which has the C<%^H>-specific magic added to it. A pointer to the new hash is returned. HV * hv_copy_hints_hv(HV *ohv)','name' => 'hv_copy_hints_hv'},'do_pmop_dump' => {'text' => '','name' => 'do_pmop_dump'},'sv_utf8_decode' => {'text' => 'If the PV of the SV is an octet sequence in UTF-8 and contains a multiple-byte character, the C flag is turned on so that it looks like a character. If the PV contains only single-byte characters, the C flag stays off. Scans PV for validity and returns false if the PV is invalid UTF-8. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_decode(SV *const sv)','name' => 'sv_utf8_decode'},'op_refcnt_unlock' => {'text' => '','name' => 'op_refcnt_unlock'},'hv_stores' => {'text' => 'Like C, but takes a literal string instead of a string/length pair and omits the hash parameter. SV** hv_stores(HV* tb, const char* key, NULLOK SV* val)','name' => 'hv_stores'},'SvNV_nomg' => {'text' => 'Like C but doesn\'t process magic. NV SvNV_nomg(SV* sv)','name' => 'SvNV_nomg'},'eval_sv' => {'text' => 'Tells Perl to C the string in the SV. It supports the same flags as C, with the obvious exception of G_EVAL. See L. NOTE: the perl_ form of this function is deprecated. I32 eval_sv(SV* sv, I32 flags)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'sv_utf8_upgrade_nomg' => {'text' => 'Like sv_utf8_upgrade, but doesn\'t do magic on C. STRLEN sv_utf8_upgrade_nomg(SV *sv)','name' => 'sv_utf8_upgrade_nomg'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'GIMME' => {'text' => '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','name' => 'GIMME'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an integer that must be interpreted as unsigned. A non-negative integer whose value is within the range of both an IV and a UV may be be flagged as either SvUOK or SVIOK. bool SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'my_snprintf' => {'text' => 'The C library C functionality, if available and standards-compliant (uses C, actually). However, if the C is not available, will unfortunately use the unsafe C which can overrun the buffer (there is an overrun check, but that may be too late). Consider using C instead, or getting C. int my_snprintf(char *buffer, const Size_t len, const char *format, ...)','name' => 'my_snprintf'},'newLOGOP' => {'text' => 'Constructs, checks, and returns a logical (flow control) op. I is the opcode. I gives the eight bits of C, except that C will be set automatically, and, shifted up eight bits, the eight bits of C, except that the bit with value 1 is automatically set. I supplies the expression controlling the flow, and I supplies the side (alternate) chain of ops; they are consumed by this function and become part of the constructed op tree. OP * newLOGOP(I32 type, I32 flags, OP *first, OP *other)','name' => 'newLOGOP'},'gp_ref' => {'text' => '','name' => 'gp_ref'},'save_op' => {'text' => '','name' => 'save_op'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter *my_perl)','name' => 'perl_construct'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an integer that must be interpreted as unsigned. A non-negative integer whose value is within the range of both an IV and a UV may be be flagged as either SvUOK or SVIOK. bool SvUOK(SV* sv)','name' => 'SvUOK'},'newWHENOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C block. I supplies the test expression, and I supplies the block that will be executed if the test evaluates to true; they are consumed by this function and become part of the constructed op tree. I will be interpreted DWIMically, often as a comparison against C<$_>, and may be null to generate a C block. OP * newWHENOP(OP *cond, OP *block)','name' => 'newWHENOP'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic and operator overloading. void sv_dec(SV *const sv)','name' => 'sv_dec'},'pv_display' => {'text' => 'Similar to pv_escape(dsv,pv,cur,pvlim,PERL_PV_ESCAPE_QUOTE); except that an additional "\\0" will be appended to the string when len > cur and pv[cur] is "\\0". Note that the final string may be up to 7 chars longer than pvlim. char* pv_display(SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)','name' => 'pv_display'},'newHVREF' => {'text' => '','name' => 'newHVREF'},'sv_2pvbyte_nolen' => {'text' => 'Return a pointer to the byte-encoded representation of the SV. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'PadlistMAX' => {'text' => 'The index of the last pad in the padlist. NOTE: this function is experimental and may change or be removed without notice. SSize_t PadlistMAX(PADLIST padlist)','name' => 'PadlistMAX'},'PerlIO_fileno' => {'text' => '','name' => 'PerlIO_fileno'},'uvchr_to_utf8' => {'text' => 'Adds the UTF-8 representation of the Native code point C to the end of the string C; C should have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvchr_to_utf8(d, uv); is the recommended wide native character-aware way of saying *(d++) = uv; U8* uvchr_to_utf8(U8 *d, UV uv)','name' => 'uvchr_to_utf8'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the specified character is a digit, analogous to C. Variants C and C are identical to C. See the L for an explanation of variants C, C, C, C, and C. bool isDIGIT(char ch)','name' => 'isDIGIT'},'call_atexit' => {'text' => '','name' => 'call_atexit'},'my_bzero' => {'text' => '','name' => 'my_bzero'},'newCONSTSUB' => {'text' => 'See L. CV* newCONSTSUB(HV* stash, const char* name, SV* sv)','name' => 'newCONSTSUB'},'SvSHARE' => {'text' => 'Arranges for sv to be shared between threads if a suitable module has been loaded. void SvSHARE(SV* sv)','name' => 'SvSHARE'},'vwarner' => {'text' => '','name' => 'vwarner'},'sortsv' => {'text' => 'Sort an array. Here is an example: sortsv(AvARRAY(av), av_top_index(av)+1, Perl_sv_cmp_locale); Currently this always uses mergesort. See sortsv_flags for a more flexible routine. void sortsv(SV** array, size_t num_elts, SVCOMPARE_t cmp)','name' => 'sortsv'},'av_tindex' => {'text' => 'Same as C. int av_tindex(AV* av)','name' => 'av_tindex'},'cophh_store_pvs' => {'text' => 'Like L, but takes a literal string instead of a string/length pair, and no precomputed hash. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_store_pvs(const COPHH *cophh, const char *key, SV *value, U32 flags)','name' => 'cophh_store_pvs'},'sys_intern_clear' => {'text' => '','name' => 'sys_intern_clear'},'my_ntohl' => {'text' => '','name' => 'my_ntohl'},'doref' => {'text' => '','name' => 'doref'},'scan_bin' => {'text' => 'For backwards compatibility. Use C instead. NV scan_bin(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_bin'},'Nullcv' => {'text' => 'Null CV pointer. (deprecated - use C<(CV *)NULL> instead)','name' => 'Nullcv'},'PadlistREFCNT' => {'text' => 'The reference count of the padlist. Currently this is always 1. NOTE: this function is experimental and may change or be removed without notice. U32 PadlistREFCNT(PADLIST padlist)','name' => 'PadlistREFCNT'},'sv_catpvs_nomg' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_catpvs_nomg(SV* sv, const char* s)','name' => 'sv_catpvs_nomg'},'lex_bufutf8' => {'text' => 'Indicates whether the octets in the lexer buffer (Llinestr>) should be interpreted as the UTF-8 encoding of Unicode characters. If not, they should be interpreted as Latin-1 characters. This is analogous to the C flag for scalars. In UTF-8 mode, it is not guaranteed that the lexer buffer actually contains valid UTF-8. Lexing code must be robust in the face of invalid encoding. The actual C flag of the Llinestr> scalar is significant, but not the whole story regarding the input character encoding. Normally, when a file is being read, the scalar contains octets and its C flag is off, but the octets should be interpreted as UTF-8 if the C pragma is in effect. During a string eval, however, the scalar may have the C flag on, and in this case its octets should be interpreted as UTF-8 unless the C pragma is in effect. This logic may change in the future; use this function instead of implementing the logic yourself. NOTE: this function is experimental and may change or be removed without notice. bool lex_bufutf8()','name' => 'lex_bufutf8'},'MULTICALL' => {'text' => 'Make a lightweight callback. See L. MULTICALL;','name' => 'MULTICALL'},'debprofdump' => {'text' => '','name' => 'debprofdump'},'SvPVbyte' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'savesharedpvs' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpvs(const char* s)','name' => 'savesharedpvs'},'sys_init3' => {'text' => '','name' => 'sys_init3'},'gv_fetchmeth_pv' => {'text' => 'Exactly like L, but takes a nul-terminated string instead of a string/length pair. GV* gv_fetchmeth_pv(HV* stash, const char* name, I32 level, U32 flags)','name' => 'gv_fetchmeth_pv'},'PerlIO_stdout' => {'text' => '','name' => 'PerlIO_stdout'},'XS_INTERNAL' => {'text' => 'Macro to declare an XSUB and its C parameter list without exporting the symbols. This is handled by C and generally preferable over exporting the XSUB symbols unnecessarily.','name' => 'XS_INTERNAL'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'SvPVutf8x' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'sv_2cv' => {'text' => 'Using various gambits, try to get a CV from an SV; in addition, try if possible to set C<*st> and C<*gvp> to the stash and GV associated with it. The flags in C are passed to gv_fetchsv. CV* sv_2cv(SV* sv, HV **const st, GV **const gvp, const I32 lref)','name' => 'sv_2cv'},'gp_free' => {'text' => '','name' => 'gp_free'},'SvPV_force_nomg' => {'text' => 'Like C, but doesn\'t process get magic. char* SvPV_force_nomg(SV* sv, STRLEN len)','name' => 'SvPV_force_nomg'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. Will also turn off the UTF-8 status. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'save_destructor_x' => {'text' => '','name' => 'save_destructor_x'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'hv_fetch' => {'text' => 'Returns the SV which corresponds to the specified key in the hash. The absolute value of C is the length of the key. If C is negative the key is assumed to be in UTF-8-encoded Unicode. If C is set then the fetch will be part of a store. This means that if there is no value in the hash associated with the given key, then one is created and a pointer to it is returned. The C it points to can be assigned to. But always check that the return value is non-null before dereferencing it to an C. See L for more information on how to use this function on tied hashes. SV** hv_fetch(HV *hv, const char *key, I32 klen, I32 lval)','name' => 'hv_fetch'},'sv_pvbyte' => {'text' => 'Use C instead. char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'XCPT_TRY_START' => {'text' => 'Starts a try block. See L.','name' => 'XCPT_TRY_START'},'sv_unref_flags' => {'text' => '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. The C argument can contain C to force the reference count to be decremented (otherwise the decrementing is conditional on the reference count being different from one or the reference being a readonly SV). See C. void sv_unref_flags(SV *const ref, const U32 flags)','name' => 'sv_unref_flags'},'isPSXSPC' => {'text' => '(short for Posix Space) Starting in 5.18, this is identical (experimentally) in all its forms to the corresponding C macros. ("Experimentally" means that this change may be backed out in 5.20 or 5.22 if field experience indicates that it was unwise.) The locale forms of this macro are identical to their corresponding C forms in all Perl releases. In releases prior to 5.18, the non-locale forms differ from their C forms only in that the C forms don\'t match a Vertical Tab, and the C forms do. Otherwise they are identical. Thus this macro is analogous to what C matches in a regular expression. See the L for an explanation of variants C, C, C, C, C, C, and C. bool isPSXSPC(char ch)','name' => 'isPSXSPC'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'hv_scalar' => {'text' => 'Evaluates the hash in scalar context and returns the result. Handles magic when the hash is tied. SV* hv_scalar(HV *hv)','name' => 'hv_scalar'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV *sv, SV *nsv, const char *key, I32 klen)','name' => 'mg_copy'},'save_I16' => {'text' => '','name' => 'save_I16'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C flag on this RV; give the referred-to SV C magic if it hasn\'t already; and push a back-reference to this RV onto the array of backreferences associated with that magic. If the RV is magical, set magic will be called after the RV is cleared. SV* sv_rvweaken(SV *const sv)','name' => 'sv_rvweaken'},'grok_oct' => {'text' => 'converts a string representing an octal number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an 8 or 9 will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). If C is set in I<*flags> then the octal number may use \'_\' characters to separate digits. UV grok_oct(const char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_oct'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'newSVpvn' => {'text' => 'Creates a new SV and copies a buffer into it, which may contain NUL characters (C<\\0>) and other binary data. The reference count for the SV is set to 1. Note that if C is zero, Perl will create a zero length (Perl) string. You are responsible for ensuring that the source buffer is at least C bytes long. If the C argument is NULL the new SV will be undefined. SV* newSVpvn(const char *const s, const STRLEN len)','name' => 'newSVpvn'},'scan_hex' => {'text' => 'For backwards compatibility. Use C instead. NV scan_hex(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_hex'},'unpackstring' => {'text' => 'The engine implementing the unpack() Perl function. Using the template pat..patend, this function unpacks the string s..strend into a number of mortal SVs, which it pushes onto the perl argument (@_) stack (so you will need to issue a C before and C after the call to this function). It returns the number of pushed elements. The strend and patend pointers should point to the byte following the last character of each string. Although this function returns its values on the perl argument stack, it doesn\'t take any parameters from that stack (and thus in particular there\'s no need to do a PUSHMARK before calling it, unlike L for example). I32 unpackstring(const char *pat, const char *patend, const char *s, const char *strend, U32 flags)','name' => 'unpackstring'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV *av, I32 key)','name' => 'av_extend'},'sv_peek' => {'text' => '','name' => 'sv_peek'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. You may call C or C 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 C, so you must not discard your iterator immediately else the entry will leak - call C to trigger the resource deallocation. HE* hv_iternext(HV *hv)','name' => 'hv_iternext'},'SVt_REGEXP' => {'text' => 'Type flag for regular expressions. See L.','name' => 'SVt_REGEXP'},'hv_store_ent' => {'text' => '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. Effectively a successful hv_store_ent takes ownership of one reference to C. 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 C; unlike C it does not take ownership of it, so maintaining the correct reference count on C 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 L for more information on how to use this function on tied hashes. HE* hv_store_ent(HV *hv, SV *key, SV *val, U32 hash)','name' => 'hv_store_ent'},'hv_eiter_set' => {'text' => '','name' => 'hv_eiter_set'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package. See C. HV* gv_stashsv(SV* sv, I32 flags)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'form' => {'text' => '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, ...)','name' => 'form'},'instr' => {'text' => '','name' => 'instr'},'pregexec' => {'text' => '','name' => 'pregexec'},'is_utf8_string' => {'text' => 'Returns true if the first C bytes of string C form a valid UTF-8 string, false otherwise. If C is 0, it will be calculated using C (which means if you use this option, that C has to have a terminating NUL byte). Note that all characters being ASCII constitute \'a valid UTF-8 string\'. See also L(), L(), and L(). bool is_utf8_string(const U8 *s, STRLEN len)','name' => 'is_utf8_string'},'PadnamelistARRAY' => {'text' => 'The C array of pad names. NOTE: this function is experimental and may change or be removed without notice. PADNAME ** PadnamelistARRAY(PADNAMELIST pnl)','name' => 'PadnamelistARRAY'},'croak_xs_usage' => {'text' => 'A specialised variant of C for emitting the usage message for xsubs croak_xs_usage(cv, "eee_yow"); works out the package name and subroutine name from C, and then calls C. Hence if C is C<&ouch::awk>, it would call C as: Perl_croak(aTHX_ "Usage: %"SVf"::%"SVf"(%s)", "ouch" "awk", "eee_yow"); void croak_xs_usage(const CV *const cv, const char *const params)','name' => 'croak_xs_usage'},'sv_insert' => {'text' => 'Inserts a string at the specified offset/length within the SV. Similar to the Perl substr() function. Handles get magic. void sv_insert(SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen)','name' => 'sv_insert'},'SvPOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a character string. U32 SvPOK(SV* sv)','name' => 'SvPOK'},'sv_destroyable' => {'text' => 'Dummy routine which reports that object can be destroyed when there is no sharing module present. It ignores its single SV argument, and returns \'true\'. Exists to avoid test for a NULL function pointer and because it could potentially warn under some level of strict-ness. bool sv_destroyable(SV *sv)','name' => 'sv_destroyable'},'save_aelem_flags' => {'text' => '','name' => 'save_aelem_flags'},'PadlistNAMES' => {'text' => 'The names associated with pad entries. NOTE: this function is experimental and may change or be removed without notice. PADNAMELIST * PadlistNAMES(PADLIST padlist)','name' => 'PadlistNAMES'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C. It is the same as using the more explicit XS_EXTERNAL macro.','name' => 'XS'},'gv_check' => {'text' => '','name' => 'gv_check'},'sv_setpvn' => {'text' => 'Copies a string into an SV. The C parameter indicates the number of bytes to be copied. If the C argument is NULL the SV will become undefined. Does not handle \'set\' magic. See C. void sv_setpvn(SV *const sv, const char *const ptr, const STRLEN len)','name' => 'sv_setpvn'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'op_linklist' => {'text' => 'This function is the implementation of the L macro. It should not be called directly. OP* op_linklist(OP *o)','name' => 'op_linklist'},'newSVrv' => {'text' => 'Creates a new SV for the existing 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. The reference count 1 is owned by C. SV* newSVrv(SV *const rv, const char *const classname)','name' => 'newSVrv'},'cast_i32' => {'text' => '','name' => 'cast_i32'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'sv_dup_inc' => {'text' => '','name' => 'sv_dup_inc'},'newMYSUB' => {'text' => '','name' => 'newMYSUB'},'PoisonWith' => {'text' => 'Fill up memory with a byte pattern (a byte repeated over and over again) that hopefully catches attempts to access uninitialized memory. void PoisonWith(void* dest, int nitems, type, U8 byte)','name' => 'PoisonWith'},'av_create_and_unshift_one' => {'text' => 'Unshifts an SV onto the beginning of the array, creating the array if necessary. A small internal helper function to remove a commonly duplicated idiom. NOTE: this function is experimental and may change or be removed without notice. SV** av_create_and_unshift_one(AV **const avp, SV *const val)','name' => 'av_create_and_unshift_one'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'bytes_cmp_utf8' => {'text' => 'Compares the sequence of characters (stored as octets) in C, C with the sequence of characters (stored as UTF-8) in C, C. Returns 0 if they are equal, -1 or -2 if the first string is less than the second string, +1 or +2 if the first string is greater than the second string. -1 or +1 is returned if the shorter string was identical to the start of the longer string. -2 or +2 is returned if the was a difference between characters within the strings. int bytes_cmp_utf8(const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen)','name' => 'bytes_cmp_utf8'},'seed' => {'text' => '','name' => 'seed'},'pad_findmy_pvs' => {'text' => 'Exactly like L, but takes a literal string instead of a string/length pair. PADOFFSET pad_findmy_pvs(const char *name, U32 flags)','name' => 'pad_findmy_pvs'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C to type C if necessary, then adds a new magic item of type C to the head of the magic list. See C (which C now calls) for a description of the handling of the C and C arguments. You need to use C to add magic to SvREADONLY SVs and also to add more than one instance of the same \'how\'. void sv_magic(SV *const sv, SV *const obj, const int how, const char *const name, const I32 namlen)','name' => 'sv_magic'},'sv_utf8_upgrade_flags' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes are invariant in UTF-8. If C has C bit set, will C on C if appropriate, else not. Returns the number of bytes in the converted string C and C are implemented in terms of this function. This is not a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade_flags(SV *const sv, const I32 flags)','name' => 'sv_utf8_upgrade_flags'},'do_open9' => {'text' => '','name' => 'do_open9'},'magic_dump' => {'text' => '','name' => 'magic_dump'},'sv_catpvs_mg' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_catpvs_mg(SV* sv, const char* s)','name' => 'sv_catpvs_mg'},'sv_setpvs_mg' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_setpvs_mg(SV* sv, const char* s)','name' => 'sv_setpvs_mg'},'gv_fetchfile_flags' => {'text' => '','name' => 'gv_fetchfile_flags'},'SvREFCNT_inc_void' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value. The macro doesn\'t need to return a meaningful value. void SvREFCNT_inc_void(SV* sv)','name' => 'SvREFCNT_inc_void'},'leave_scope' => {'text' => '','name' => 'leave_scope'},'newSTATEOP' => {'text' => 'Constructs a state op (COP). The state op is normally a C op, but will be a C op if debugging is enabled for currently-compiled code. The state op is populated from L (or L). If I. void mg_free_type(SV *sv, int how)','name' => 'mg_free_type'},'sv_catsv_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_catsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_catsv_nomg'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setuv_mg(SV *const sv, const UV u)','name' => 'sv_setuv_mg'},'sys_intern_init' => {'text' => '','name' => 'sys_intern_init'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually handled automatically by C. See C.','name' => 'XS_VERSION'},'find_rundefsvoffset' => {'text' => 'Find the position of the lexical C<$_> in the pad of the currently-executing function. Returns the offset in the current pad, or C if there is no lexical C<$_> in scope (in which case the global one should be used instead). L is likely to be more convenient. NOTE: the perl_ form of this function is deprecated. PADOFFSET find_rundefsvoffset()','name' => 'find_rundefsvoffset'},'sv_setpv' => {'text' => 'Copies a string into an SV. The string must be null-terminated. Does not handle \'set\' magic. See C. void sv_setpv(SV *const sv, const char *const ptr)','name' => 'sv_setpv'},'hv_placeholders_set' => {'text' => '','name' => 'hv_placeholders_set'},'parse_fullstmt' => {'text' => 'Parse a single complete Perl statement. This may be a normal imperative statement or a declaration that has compile-time effect, and may include optional labels. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed and the lexical context for the statement. The op tree representing the statement is returned. This may be a null pointer if the statement is null, for example if it was actually a subroutine definition (which has compile-time side effects). If not null, it will be the result of a L call, normally including a C or equivalent op. If an error occurs in parsing or compilation, in most cases a valid op tree (most likely null) is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. Some compilation errors, however, will throw an exception immediately. The I parameter is reserved for future use, and must always be zero. NOTE: this function is experimental and may change or be removed without notice. OP * parse_fullstmt(U32 flags)','name' => 'parse_fullstmt'},'atfork_lock' => {'text' => '','name' => 'atfork_lock'},'gv_fetchmethod' => {'text' => 'See L. GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'SvGROW' => {'text' => '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. SV must be of type >= SVt_PV. One alternative is to call C if you are not sure of the type of SV. char * SvGROW(SV* sv, STRLEN len)','name' => 'SvGROW'},'dMULTICALL' => {'text' => 'Declare local variables for a multicall. See L. dMULTICALL;','name' => 'dMULTICALL'},'isIDFIRST' => {'text' => 'Returns a boolean indicating whether the specified character can be the first character of an identifier. This is very close to, but not quite the same as the official Unicode property C. The difference is that this returns true only if the input character also matches L. See the L for an explanation of variants C, C, C, C, C, C, and C. bool isIDFIRST(char ch)','name' => 'isIDFIRST'},'sv_catpv' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpv(SV *const sv, const char* ptr)','name' => 'sv_catpv'},'fprintf_nocontext' => {'text' => '','name' => 'fprintf_nocontext'},'sv_len' => {'text' => 'Returns the length of the string in the SV. Handles magic and type coercion and sets the UTF8 flag appropriately. See also C, which gives raw access to the xpv_cur slot. STRLEN sv_len(SV *const sv)','name' => 'sv_len'},'PerlIO_stderr' => {'text' => '','name' => 'PerlIO_stderr'},'sv_pvutf8' => {'text' => 'Use the C macro instead char* sv_pvutf8(SV *sv)','name' => 'sv_pvutf8'},'SvPVbyte_nolen' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_nolen(SV* sv)','name' => 'SvPVbyte_nolen'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L. LEAVE;','name' => 'LEAVE'},'mess' => {'text' => 'Take a sprintf-style format pattern and argument list. These are used to generate a string message. If the message does not end with a newline, then it will be extended with some indication of the current location in the code, as described for L. Normally, the resulting message is returned in a new mortal SV. During global destruction a single SV may be shared between uses of this function. SV * mess(const char *pat, ...)','name' => 'mess'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See L.','name' => 'SVt_PVAV'},'hv_delete_ent' => {'text' => 'Deletes a key/value pair in the hash. The value SV is removed from the hash, made mortal, and returned to the caller. The C value will normally be zero; if set to G_DISCARD then NULL will be returned. NULL will also be returned if the key is not found. C can be a valid precomputed hash value, or 0 to ask for it to be computed. SV* hv_delete_ent(HV *hv, SV *keysv, I32 flags, U32 hash)','name' => 'hv_delete_ent'},'PL_keyword_plugin' => {'text' => 'Function pointer, pointing at a function used to handle extended keywords. The function should be declared as int keyword_plugin_function(pTHX_ char *keyword_ptr, STRLEN keyword_len, OP **op_ptr) The function is called from the tokeniser, whenever a possible keyword is seen. C points at the word in the parser\'s input buffer, and C gives its length; it is not null-terminated. The function is expected to examine the word, and possibly other state such as L<%^H|perlvar/%^H>, to decide whether it wants to handle it as an extended keyword. If it does not, the function should return C, and the normal parser process will continue. If the function wants to handle the keyword, it first must parse anything following the keyword that is part of the syntax introduced by the keyword. See L for details. When a keyword is being handled, the plugin function must build a tree of C structures, representing the code that was parsed. The root of the tree must be stored in C<*op_ptr>. The function then returns a constant indicating the syntactic role of the construct that it has parsed: C if it is a complete statement, or C if it is an expression. Note that a statement construct cannot be used inside an expression (except via C and similar), and an expression is not a complete statement (it requires at least a terminating semicolon). When a keyword is handled, the plugin function may also have (compile-time) side effects. It may modify C<%^H>, define functions, and so on. Typically, if side effects are the main purpose of a handler, it does not wish to generate any ops to be included in the normal compilation. In this case it is still required to supply an op tree, but it suffices to generate a single null op. That\'s how the C<*PL_keyword_plugin> function needs to behave overall. Conventionally, however, one does not completely replace the existing handler function. Instead, take a copy of C before assigning your own function pointer to it. Your handler function should look for keywords that it is interested in and handle those. Where it is not interested, it should call the saved plugin function, passing on the arguments it received. Thus C actually points at a chain of handler functions, all of which have an opportunity to handle keywords, and only the last function in the chain (built into the Perl core) will normally return C. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_keyword_plugin'},'LINKLIST' => {'text' => 'Given the root of an optree, link the tree in execution order using the C pointers and return the first op executed. If this has already been done, it will not be redone, and C<< o->op_next >> will be returned. If C<< o->op_next >> is not already set, I should be at least an C. OP* LINKLIST(OP *o)','name' => 'LINKLIST'},'utf8_to_uvuni_buf' => {'text' => 'Returns the Unicode code point of the first character in the string C which is assumed to be in UTF-8 encoding; C points to 1 beyond the end of C. C will be set to the length, in bytes, of that character. This function should only be used when the returned UV is considered an index into the Unicode semantic tables (e.g. swashes). If C does not point to a well-formed UTF-8 character and UTF8 warnings are enabled, zero is returned and C<*retlen> is set (if C isn\'t NULL) to -1. If those warnings are off, the computed value if well-defined (or the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen> is set (if C isn\'t NULL) so that (S + C<*retlen>>) is the next possible position in C that could begin a non-malformed character. See L for details on when the REPLACEMENT CHARACTER is returned. UV utf8_to_uvuni_buf(const U8 *s, const U8 *send, STRLEN *retlen)','name' => 'utf8_to_uvuni_buf'},'cast_iv' => {'text' => '','name' => 'cast_iv'},'savesvpv' => {'text' => 'A version of C/C which gets the string to duplicate from the passed in SV using C char* savesvpv(SV* sv)','name' => 'savesvpv'},'CLASS' => {'text' => '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','name' => 'CLASS'},'foldEQ_latin1' => {'text' => '','name' => 'foldEQ_latin1'},'newAVREF' => {'text' => '','name' => 'newAVREF'},'HeKLEN' => {'text' => '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)','name' => 'HeKLEN'},'sv_pvn_force_flags' => {'text' => 'Get a sensible string out of the SV somehow. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You normally want to use the various wrapper macros instead: see C and C char* sv_pvn_force_flags(SV *const sv, STRLEN *const lp, const I32 flags)','name' => 'sv_pvn_force_flags'},'sv_setpvf_mg_nocontext' => {'text' => '','name' => 'sv_setpvf_mg_nocontext'},'parse_termexpr' => {'text' => 'Parse a Perl term expression. This may contain operators of precedence down to the assignment operators. The expression must be followed (and thus terminated) either by a comma or lower-precedence operator or by something that would normally terminate an expression such as semicolon. If I includes C then the expression is optional, otherwise it is mandatory. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed and the lexical context for the expression. The op tree representing the expression is returned. If an optional expression is absent, a null pointer is returned, otherwise the pointer will be non-null. If an error occurs in parsing or compilation, in most cases a valid op tree is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. Some compilation errors, however, will throw an exception immediately. NOTE: this function is experimental and may change or be removed without notice. OP * parse_termexpr(U32 flags)','name' => 'parse_termexpr'},'mPUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void mPUSHi(IV iv)','name' => 'mPUSHi'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHn(NV nv)','name' => 'PUSHn'},'to_utf8_title' => {'text' => 'Convert the UTF-8 encoded character at C

to its titlecase version and store that in UTF-8 in C and its length in bytes in C. Note that the C needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the titlecase version may be longer than the original character. The first character of the titlecased version is returned (but note, as explained above, that there may be more.) The character at C

is assumed by this routine to be well-formed. UV to_utf8_title(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_title'},'PerlIO_unread' => {'text' => '','name' => 'PerlIO_unread'},'PadMAX' => {'text' => 'The index of the last pad entry. NOTE: this function is experimental and may change or be removed without notice. SSize_t PadMAX(PAD pad)','name' => 'PadMAX'},'gv_fullname' => {'text' => '','name' => 'gv_fullname'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. SV PL_sv_yes','name' => 'PL_sv_yes'},'pregfree' => {'text' => '','name' => 'pregfree'},'sv_nosharing' => {'text' => 'Dummy routine which "shares" an SV when there is no sharing module present. Or "locks" it. Or "unlocks" it. In other words, ignores its single SV argument. 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 *sv)','name' => 'sv_nosharing'},'ck_entersub_args_list' => {'text' => 'Performs the default fixup of the arguments part of an C op tree. This consists of applying list context to each of the argument ops. This is the standard treatment used on a call marked with C<&>, or a method call, or a call through a subroutine reference, or any other call where the callee can\'t be identified at compile time, or a call where the callee has no prototype. OP * ck_entersub_args_list(OP *entersubop)','name' => 'ck_entersub_args_list'},'ck_warner' => {'text' => '','name' => 'ck_warner'},'is_ascii_string' => {'text' => 'Returns true if the first C bytes of the string C are the same whether or not the string is encoded in UTF-8 (or UTF-EBCDIC on EBCDIC machines). That is, if they are invariant. On ASCII-ish machines, only ASCII characters fit this definition, hence the function\'s name. If C is 0, it will be calculated using C. See also L(), L(), and L(). bool is_ascii_string(const U8 *s, STRLEN len)','name' => 'is_ascii_string'},'SvUTF8_off' => {'text' => 'Unsets the UTF-8 status of an SV (the data is not changed, just the flag). Do not use frivolously. void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'sv_dec_nomg' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion if necessary. Handles operator overloading. Skips handling \'get\' magic. void sv_dec_nomg(SV *const sv)','name' => 'sv_dec_nomg'},'looks_like_number' => {'text' => 'Test if the content of an SV looks like a number (or is a number). C and C are treated as numbers (so will not issue a non-numeric warning), even if your atof() doesn\'t grok them. Get-magic is ignored. I32 looks_like_number(SV *const sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpv_mg(SV *const sv, const char *const ptr)','name' => 'sv_catpv_mg'},'save_vptr' => {'text' => '','name' => 'save_vptr'},'OP_NAME' => {'text' => 'Return the name of the provided OP. For core ops this looks up the name from the op_type; for custom ops from the op_ppaddr. const char * OP_NAME(OP *o)','name' => 'OP_NAME'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'SvREFCNT_dec_NN' => {'text' => 'Same as SvREFCNT_dec, but can only be used if you know I is not NULL. Since we don\'t have to check the NULLness, it\'s faster and smaller. void SvREFCNT_dec_NN(SV* sv)','name' => 'SvREFCNT_dec_NN'},'mro_get_private_data' => {'text' => '','name' => 'mro_get_private_data'},'XS_APIVERSION_BOOTCHECK' => {'text' => 'Macro to verify that the perl api version an XS module has been compiled against matches the api version of the perl interpreter it\'s being loaded into. XS_APIVERSION_BOOTCHECK;','name' => 'XS_APIVERSION_BOOTCHECK'},'hv_delayfree_ent' => {'text' => '','name' => 'hv_delayfree_ent'},'sv_setpvf' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Does not handle \'set\' magic. See C. void sv_setpvf(SV *const sv, const char *const pat, ...)','name' => 'sv_setpvf'},'custom_op_register' => {'text' => 'Register a custom op. See L. NOTE: this function must be explicitly called as Perl_custom_op_register with an aTHX_ parameter. void Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop)','name' => 'custom_op_register'},'scan_num' => {'text' => '','name' => 'scan_num'},'save_int' => {'text' => '','name' => 'save_int'},'call_sv' => {'text' => '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, VOL I32 flags)','name' => 'call_sv'},'SVt_PV' => {'text' => 'Type flag for scalars. See L.','name' => 'SVt_PV'},'strGT' => {'text' => '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)','name' => 'strGT'},'mXPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary and mortalizes the SV. Does not use C. See also C and C. void mXPUSHs(SV* sv)','name' => 'mXPUSHs'},'POPl' => {'text' => 'Pops a long off the stack. long POPl','name' => 'POPl'},'init_i18nl14n' => {'text' => '','name' => 'init_i18nl14n'},'scan_version' => {'text' => 'Returns a pointer to the next character after the parsed version string, as well as upgrading the passed in SV to an RV. Function must be called with an already existing SV like sv = newSV(0); s = scan_version(s, SV *sv, bool qv); Performs some preprocessing to the string to ensure that it has the correct characteristics of a version. Flags the object if it contains an underscore (which denotes this is an alpha version). The boolean qv denotes that the version should be interpreted as if it had multiple decimals, even if it doesn\'t. const char* scan_version(const char *s, SV *rv, bool qv)','name' => 'scan_version'},'hv_common_key_len' => {'text' => '','name' => 'hv_common_key_len'},'get_cv' => {'text' => 'Uses C to get the length of C, then calls C. NOTE: the perl_ form of this function is deprecated. CV* get_cv(const char* name, I32 flags)','name' => 'get_cv'},'vnumify' => {'text' => 'Accepts a version object and returns the normalized floating point representation. Call like: sv = vnumify(rv); NOTE: you can pass either the object directly or the SV contained within the RV. The SV returned has a refcount of 1. SV* vnumify(SV *vs)','name' => 'vnumify'},'SvIOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains an integer. Checks the B setting. Use C instead. U32 SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the stack. void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'ptr_table_free' => {'text' => '','name' => 'ptr_table_free'},'SVt_PVIV' => {'text' => 'Type flag for scalars. See L.','name' => 'SVt_PVIV'},'SvUNLOCK' => {'text' => 'Releases a mutual exclusion lock on sv if a suitable module has been loaded. void SvUNLOCK(SV* sv)','name' => 'SvUNLOCK'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C. int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV (using C). The new SV is marked as mortal. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_mortalcopy(SV *const oldsv)','name' => 'sv_mortalcopy'},'cophh_fetch_sv' => {'text' => 'Like L, but takes a Perl scalar instead of a string/length pair. NOTE: this function is experimental and may change or be removed without notice. SV * cophh_fetch_sv(const COPHH *cophh, SV *key, U32 hash, U32 flags)','name' => 'cophh_fetch_sv'},'PadARRAY' => {'text' => 'The C array of pad entries. NOTE: this function is experimental and may change or be removed without notice. SV ** PadARRAY(PAD pad)','name' => 'PadARRAY'},'sv_catpvn_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_catpvn_nomg(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn_nomg'},'newHVhv' => {'text' => '','name' => 'newHVhv'},'newSVpvs_flags' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV* newSVpvs_flags(const char* s, U32 flags)','name' => 'newSVpvs_flags'},'savepvn' => {'text' => 'Perl\'s version of what C would be if it existed. Returns a pointer to a newly allocated string which is a duplicate of the first C bytes from C, plus a trailing NUL byte. The memory allocated for the new string can be freed with the C function. char* savepvn(const char* pv, I32 len)','name' => 'savepvn'},'pad_findmy_sv' => {'text' => 'Exactly like L, but takes the name string in the form of an SV instead of a string/length pair. PADOFFSET pad_findmy_sv(SV *name, U32 flags)','name' => 'pad_findmy_sv'},'cophh_delete_sv' => {'text' => 'Like L, but takes a Perl scalar instead of a string/length pair. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_delete_sv(const COPHH *cophh, SV *key, U32 hash, U32 flags)','name' => 'cophh_delete_sv'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized. This relies on the fact that uninitialized array elements are set to C<&PL_sv_undef>. Perl equivalent: C. bool av_exists(AV *av, I32 key)','name' => 'av_exists'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C. STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'sv_2nv_flags' => {'text' => 'Return the num value of an SV, doing any necessary string or integer conversion. If flags includes SV_GMAGIC, does an mg_get() first. Normally used via the C and C macros. NV sv_2nv_flags(SV *const sv, const I32 flags)','name' => 'sv_2nv_flags'},'gv_init' => {'text' => 'The old form of gv_init_pvn(). It does not work with UTF8 strings, as it has no flags parameter. If the C parameter is set, the GV_ADDMULTI flag will be passed to gv_init_pvn(). void gv_init(GV* gv, HV* stash, const char* name, STRLEN len, int multi)','name' => 'gv_init'},'sv_bless' => {'text' => '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 *const sv, HV *const stash)','name' => 'sv_bless'},'cv_set_call_checker' => {'text' => 'Sets the function that will be used to fix up a call to I. Specifically, the function is applied to an C op tree for a subroutine call, not marked with C<&>, where the callee can be identified at compile time as I. The C-level function pointer is supplied in I, and an SV argument for it is supplied in I. The function is intended to be called in this manner: entersubop = ckfun(aTHX_ entersubop, namegv, ckobj); In this call, I is a pointer to the C op, which may be replaced by the check function, and I is a GV supplying the name that should be used by the check function to refer to the callee of the C op if it needs to emit any diagnostics. It is permitted to apply the check function in non-standard situations, such as to a call to a different subroutine or to a method call. The current setting for a particular CV can be retrieved by L. void cv_set_call_checker(CV *cv, Perl_call_checker ckfun, SV *ckobj)','name' => 'cv_set_call_checker'},'save_ary' => {'text' => '','name' => 'save_ary'},'sv_2io' => {'text' => 'Using various gambits, try to get an IO from an SV: the IO slot if its a GV; or the recursive result if we\'re an RV; or the IO slot of the symbol named after the PV if we\'re a string. \'Get\' magic is ignored on the sv passed in, but will be called on C if sv is an RV. IO* sv_2io(SV *const sv)','name' => 'sv_2io'},'SvMAGIC_set' => {'text' => 'Set the value of the MAGIC pointer in sv to val. See C. void SvMAGIC_set(SV* sv, MAGIC* val)','name' => 'SvMAGIC_set'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the specified character is an alphabetic character, analogous to C. See the L for an explanation of variants C, C, C, C, C, C, and C. bool isALPHA(char ch)','name' => 'isALPHA'},'newSVhek' => {'text' => 'Creates a new SV from the hash key structure. It will generate scalars that point to the shared string table where possible. Returns a new (undefined) SV if the hek is NULL. SV* newSVhek(const HEK *const hek)','name' => 'newSVhek'},'taint_env' => {'text' => '','name' => 'taint_env'},'Nullhv' => {'text' => 'Null HV pointer. (deprecated - use C<(HV *)NULL> instead)','name' => 'Nullhv'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV, returning the SV. All of the following SvREFCNT_inc* macros are optimized versions of SvREFCNT_inc, and can be replaced with SvREFCNT_inc. SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'newGVgen_flags' => {'text' => '','name' => 'newGVgen_flags'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C. svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'block_gimme' => {'text' => '','name' => 'block_gimme'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'XPUSHmortal' => {'text' => 'Push a new mortal SV onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void XPUSHmortal()','name' => 'XPUSHmortal'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'SvVOK' => {'text' => 'Returns a boolean indicating whether the SV contains a v-string. bool SvVOK(SV* sv)','name' => 'SvVOK'},'whichsig_pvn' => {'text' => '','name' => 'whichsig_pvn'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvf_mg(SV *const sv, const char *const pat, ...)','name' => 'sv_setpvf_mg'},'my_chsize' => {'text' => '','name' => 'my_chsize'},'newLISTOP' => {'text' => 'Constructs, checks, and returns an op of any list type. I is the opcode. I gives the eight bits of C, except that C will be set automatically if required. I and I supply up to two ops to be direct children of the list op; they are consumed by this function and become part of the constructed op tree. OP * newLISTOP(I32 type, I32 flags, OP *first, OP *last)','name' => 'newLISTOP'},'sv_setref_pv' => {'text' => '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 have a reference count of 1, and the RV will be returned. 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 *const rv, const char *const classname, void *const pv)','name' => 'sv_setref_pv'},'fbm_compile' => {'text' => '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)','name' => 'fbm_compile'},'SvNIOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a number, integer or double. Checks the B setting. Use C instead. U32 SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'PERL_SYS_TERM' => {'text' => 'Provides system-specific clean up of the C runtime environment after running Perl interpreters. This should be called only once, after freeing any remaining Perl interpreters. void PERL_SYS_TERM()','name' => 'PERL_SYS_TERM'},'mro_register' => {'text' => 'Registers a custom mro plugin. See L for details. void mro_register(const struct mro_alg *mro)','name' => 'mro_register'},'vnewSVpvf' => {'text' => '','name' => 'vnewSVpvf'},'rv2cv_op_cv' => {'text' => 'Examines an op, which is expected to identify a subroutine at runtime, and attempts to determine at compile time which subroutine it identifies. This is normally used during Perl compilation to determine whether a prototype can be applied to a function call. I is the op being considered, normally an C op. A pointer to the identified subroutine is returned, if it could be determined statically, and a null pointer is returned if it was not possible to determine statically. Currently, the subroutine can be identified statically if the RV that the C is to operate on is provided by a suitable C or C op. A C op is suitable if the GV\'s CV slot is populated. A C op is suitable if the constant value must be an RV pointing to a CV. Details of this process may change in future versions of Perl. If the C op has the C flag set then no attempt is made to identify the subroutine statically: this flag is used to suppress compile-time magic on a subroutine call, forcing it to use default runtime behaviour. If I has the bit C set, then the handling of a GV reference is modified. If a GV was examined and its CV slot was found to be empty, then the C op has the C flag set. If the op is not optimised away, and the CV slot is later populated with a subroutine having a prototype, that flag eventually triggers the warning "called too early to check prototype". If I has the bit C set, then instead of returning a pointer to the subroutine it returns a pointer to the GV giving the most appropriate name for the subroutine in this context. Normally this is just the C of the subroutine, but for an anonymous (C) subroutine that is referenced through a GV it will be the referencing GV. The resulting C is cast to C to be returned. A null pointer is returned as usual if there is no statically-determinable subroutine. CV * rv2cv_op_cv(OP *cvop, U32 flags)','name' => 'rv2cv_op_cv'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide UTF-8 bytes as a single character. Handles magic and type coercion. STRLEN sv_len_utf8(SV *const sv)','name' => 'sv_len_utf8'},'PerlIO_set_cnt' => {'text' => '','name' => 'PerlIO_set_cnt'},'SvREFCNT_inc_simple_void' => {'text' => 'Same as SvREFCNT_inc_simple, but can only be used if you don\'t need the return value. The macro doesn\'t need to return a meaningful value. void SvREFCNT_inc_simple_void(SV* sv)','name' => 'SvREFCNT_inc_simple_void'},'cx_dup' => {'text' => '','name' => 'cx_dup'},'hv_clear_placeholders' => {'text' => '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 *hv)','name' => 'hv_clear_placeholders'},'dAX' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dAX;','name' => 'dAX'},'SvRV_set' => {'text' => 'Set the value of the RV pointer in sv to val. See C. void SvRV_set(SV* sv, SV* val)','name' => 'SvRV_set'},'grok_number' => {'text' => '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)','name' => 'grok_number'},'csighandler' => {'text' => '','name' => 'csighandler'},'SvIVx' => {'text' => 'Coerces the given SV to an integer and returns it. Guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. IV SvIVx(SV* sv)','name' => 'SvIVx'},'grok_numeric_radix' => {'text' => 'Scan and skip for a numeric decimal separator (radix). bool grok_numeric_radix(const char **sp, const char *send)','name' => 'grok_numeric_radix'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the stack. void XST_mNO(int pos)','name' => 'XST_mNO'},'gp_dup' => {'text' => '','name' => 'gp_dup'},'sv_derived_from_pv' => {'text' => 'Exactly like L, but takes a nul-terminated string instead of a string/length pair. bool sv_derived_from_pv(SV* sv, const char *const name, U32 flags)','name' => 'sv_derived_from_pv'},'savepvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. char* savepvs(const char* s)','name' => 'savepvs'},'SvSTASH_set' => {'text' => 'Set the value of the STASH pointer in sv to val. See C. void SvSTASH_set(SV* sv, HV* val)','name' => 'SvSTASH_set'},'sv_catpv_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_catpv_nomg(SV* sv, const char* ptr)','name' => 'sv_catpv_nomg'},'ZeroD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * ZeroD(void* dest, int nitems, type)','name' => 'ZeroD'},'sv_collxfrm' => {'text' => 'This calls C with the SV_GMAGIC flag. See C. char* sv_collxfrm(SV *const sv, STRLEN *const nxp)','name' => 'sv_collxfrm'},'swash_fetch' => {'text' => '','name' => 'swash_fetch'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'op_lvalue' => {'text' => 'Propagate lvalue ("modifiable") context to an op and its children. I represents the context type, roughly based on the type of op that would do the modifying, although C is represented by OP_NULL, because it has no op type of its own (it is signalled by a flag on the lvalue op). This function detects things that can\'t be modified, such as C<$x+1>, and generates errors for them. For example, C<$x+1 = 2> would cause it to be called with an op of type OP_ADD and a C argument of OP_SASSIGN. It also flags things that need to behave specially in an lvalue context, such as C<$$x = 5> which might have to vivify a reference in C<$x>. NOTE: this function is experimental and may change or be removed without notice. OP * op_lvalue(OP *o, I32 type)','name' => 'op_lvalue'},'dirp_dup' => {'text' => '','name' => 'dirp_dup'},'gv_stashpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. HV* gv_stashpvs(const char* name, I32 create)','name' => 'gv_stashpvs'},'Zero' => {'text' => '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)','name' => 'Zero'},'vcmp' => {'text' => 'Version object aware cmp. Both operands must already have been converted into version objects. int vcmp(SV *lhv, SV *rhv)','name' => 'vcmp'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_iv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. IV sv_iv(SV* sv)','name' => 'sv_iv'},'PL_parser-Ebufend' => {'text' => 'Direct pointer to the end of the chunk of text currently being lexed, the end of the lexer buffer. This is equal to Clinestr) + SvCUR(PL_parser-Elinestr)>. A NUL character (zero octet) is always located at the end of the buffer, and does not count as part of the buffer\'s contents. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_parser-Ebufend'},'PerlIO_error' => {'text' => '','name' => 'PerlIO_error'},'pv_escape' => {'text' => 'Escapes at most the first "count" chars of pv and puts the results into dsv such that the size of the escaped string will not exceed "max" chars and will not contain any incomplete escape sequences. If flags contains PERL_PV_ESCAPE_QUOTE then any double quotes in the string will also be escaped. Normally the SV will be cleared before the escaped string is prepared, but when PERL_PV_ESCAPE_NOCLEAR is set this will not occur. If PERL_PV_ESCAPE_UNI is set then the input string is treated as Unicode, if PERL_PV_ESCAPE_UNI_DETECT is set then the input string is scanned using C to determine if it is Unicode. If PERL_PV_ESCAPE_ALL is set then all input chars will be output using C<\\x01F1> style escapes, otherwise if PERL_PV_ESCAPE_NONASCII is set, only chars above 127 will be escaped using this style; otherwise, only chars above 255 will be so escaped; other non printable chars will use octal or common escaped patterns like C<\\n>. Otherwise, if PERL_PV_ESCAPE_NOBACKSLASH then all chars below 255 will be treated as printable and will be output as literals. If PERL_PV_ESCAPE_FIRSTCHAR is set then only the first char of the string will be escaped, regardless of max. If the output is to be in hex, then it will be returned as a plain hex sequence. Thus the output will either be a single char, an octal escape sequence, a special escape like C<\\n> or a hex value. If PERL_PV_ESCAPE_RE is set then the escape char used will be a \'%\' and not a \'\\\\\'. This is because regexes very often contain backslashed sequences, whereas \'%\' is not a particularly common character in patterns. Returns a pointer to the escaped text as held by dsv. char* pv_escape(SV *dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags)','name' => 'pv_escape'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'my_exit' => {'text' => '','name' => 'my_exit'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'isPUNCT' => {'text' => 'Returns a boolean indicating whether the specified character is a punctuation character, analogous to C. Note that the definition of what is punctuation isn\'t as straightforward as one might desire. See L for details. See the L for an explanation of variants C, C, C, C, C, C, and C. bool isPUNCT(char ch)','name' => 'isPUNCT'},'SVt_PVCV' => {'text' => 'Type flag for subroutines. See L.','name' => 'SVt_PVCV'},'ss_dup' => {'text' => '','name' => 'ss_dup'},'gv_handler' => {'text' => '','name' => 'gv_handler'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpviv_mg(SV *const sv, const IV iv)','name' => 'sv_setpviv_mg'},'debstack' => {'text' => '','name' => 'debstack'},'sv_2bool' => {'text' => 'This macro is only used by sv_true() or its macro equivalent, and only if the latter\'s argument is neither SvPOK, SvIOK nor SvNOK. It calls sv_2bool_flags with the SV_GMAGIC flag. bool sv_2bool(SV *const sv)','name' => 'sv_2bool'},'lex_grow_linestr' => {'text' => 'Reallocates the lexer buffer (Llinestr>) to accommodate at least I octets (including terminating NUL). Returns a pointer to the reallocated buffer. This is necessary before making any direct modification of the buffer that would increase its length. L provides a more convenient way to insert text into the buffer. Do not use C or C directly on Clinestr>; this function updates all of the lexer\'s variables that point directly into the buffer. NOTE: this function is experimental and may change or be removed without notice. char * lex_grow_linestr(STRLEN len)','name' => 'lex_grow_linestr'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'sv_inc_nomg' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion if necessary. Handles operator overloading. Skips handling \'get\' magic. void sv_inc_nomg(SV *const sv)','name' => 'sv_inc_nomg'},'sv_newmortal' => {'text' => 'Creates a new null SV which is mortal. The reference count of the SV is set to 1. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_newmortal()','name' => 'sv_newmortal'},'SvOOK' => {'text' => 'Returns a U32 indicating whether the pointer to the string buffer is offset. 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 actually C bytes before SvPVX. This offset used to be stored in SvIVX, but is now stored within the spare part of the buffer. U32 SvOOK(SV* sv)','name' => 'SvOOK'},'SvPV_set' => {'text' => 'Set the value of the PV pointer in sv to val. See also C. Beware that the existing pointer may be involved in copy-on-write or other mischief, so do C and use C or C (or check the SvIsCOW flag) first to make sure this modification is safe. void SvPV_set(SV* sv, char* val)','name' => 'SvPV_set'},'mess_sv' => {'text' => 'Expands a message, intended for the user, to include an indication of the current location in the code, if the message does not already appear to be complete. C is the initial message or object. If it is a reference, it will be used as-is and will be the result of this function. Otherwise it is used as a string, and if it already ends with a newline, it is taken to be complete, and the result of this function will be the same string. If the message does not end with a newline, then a segment such as C will be appended, and possibly other clauses indicating the current state of execution. The resulting message will end with a dot and a newline. Normally, the resulting message is returned in a new mortal SV. During global destruction a single SV may be shared between uses of this function. If C is true, then the function is permitted (but not required) to modify and return C instead of allocating a new SV. SV * mess_sv(SV *basemsg, bool consume)','name' => 'mess_sv'},'hv_clear' => {'text' => 'Frees the all the elements of a hash, leaving it empty. The XS equivalent of C<%hash = ()>. See also L. If any destructors are triggered as a result, the hv itself may be freed. void hv_clear(HV *hv)','name' => 'hv_clear'},'get_hv' => {'text' => 'Returns the HV of the specified Perl hash. C are passed to C. If C is set and the Perl variable does not exist then it will be created. If C is zero 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 flags)','name' => 'get_hv'},'safesysrealloc' => {'text' => '','name' => 'safesysrealloc'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES;','name' => 'XSRETURN_YES'},'PoisonNew' => {'text' => 'PoisonWith(0xAB) for catching access to allocated but uninitialized memory. void PoisonNew(void* dest, int nitems, type)','name' => 'PoisonNew'},'op_scope' => {'text' => 'Wraps up an op tree with some additional ops so that at runtime a dynamic scope will be created. The original ops run in the new dynamic scope, and then, provided that they exit normally, the scope will be unwound. The additional ops used to create and unwind the dynamic scope will normally be an C/C pair, but a C op may be used instead if the ops are simple enough to not need the full dynamic scope structure. NOTE: this function is experimental and may change or be removed without notice. OP * op_scope(OP *o)','name' => 'op_scope'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'sv_nv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. NV sv_nv(SV* sv)','name' => 'sv_nv'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHu(UV uv)','name' => 'PUSHu'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. (Uses C.) SV* newSVsv(SV *const old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C. void hv_magic(HV *hv, GV *gv, int how)','name' => 'hv_magic'},'deb_nocontext' => {'text' => '','name' => 'deb_nocontext'},'new_stackinfo' => {'text' => '','name' => 'new_stackinfo'},'save_aelem' => {'text' => '','name' => 'save_aelem'},'PerlIO_clearerr' => {'text' => '','name' => 'PerlIO_clearerr'},'cx_dump' => {'text' => '','name' => 'cx_dump'},'SVt_PVIO' => {'text' => 'Type flag for I/O objects. See L.','name' => 'SVt_PVIO'},'hv_placeholders_p' => {'text' => '','name' => 'hv_placeholders_p'},'XCPT_TRY_END' => {'text' => 'Ends a try block. See L.','name' => 'XCPT_TRY_END'},'HeKEY' => {'text' => '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)','name' => 'HeKEY'},'SvEND' => {'text' => 'Returns a pointer to the spot just after the last character in the string which is in the SV, where there is usually a trailing null (even though Perl scalars do not strictly require it). See C. Access the character as *(SvEND(sv)). Warning: If C is equal to C, then C points to unallocated memory. char* SvEND(SV* sv)','name' => 'SvEND'},'save_delete' => {'text' => '','name' => 'save_delete'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C, C or C for void, scalar or list context, respectively. See L for a usage example. U32 GIMME_V','name' => 'GIMME_V'},'re_compile' => {'text' => '','name' => 're_compile'},'sv_setsv_flags' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. If the C parameter has the C bit set, will C on C if appropriate, else not. If the C parameter has the C bit set then the buffers of temps will not be stolen. and C are implemented in terms of this function. You probably want to use one of the assortment of wrappers, such as C, C, C and C. This is the primary function for copying scalars, and most other copy-ish functions and macros use this underneath. void sv_setsv_flags(SV *dstr, SV *sstr, const I32 flags)','name' => 'sv_setsv_flags'},'gv_init_pvn' => {'text' => 'Converts a scalar into a typeglob. This is an incoercible typeglob; assigning a reference to it will assign to one of its slots, instead of overwriting it as happens with typeglobs created by SvSetSV. Converting any scalar that is SvOK() may produce unpredictable results and is reserved for perl\'s internal use. C is the scalar to be converted. C is the parent stash/package, if any. C and C give the name. The name must be unqualified; that is, it must not include the package name. If C is a stash element, it is the caller\'s responsibility to ensure that the name passed to this function matches the name of the element. If it does not match, perl\'s internal bookkeeping will get out of sync. C can be set to SVf_UTF8 if C is a UTF8 string, or the return value of SvUTF8(sv). It can also take the GV_ADDMULTI flag, which means to pretend that the GV has been seen before (i.e., suppress "Used once" warnings). void gv_init_pvn(GV* gv, HV* stash, const char* name, STRLEN len, U32 flags)','name' => 'gv_init_pvn'},'gv_fetchmeth_sv' => {'text' => 'Exactly like L, but takes the name string in the form of an SV instead of a string/length pair. GV* gv_fetchmeth_sv(HV* stash, SV* namesv, I32 level, U32 flags)','name' => 'gv_fetchmeth_sv'},'newATTRSUB' => {'text' => '','name' => 'newATTRSUB'},'Copy' => {'text' => '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)','name' => 'Copy'},'newSVpv_share' => {'text' => 'Like C, but takes a nul-terminated string instead of a string/length pair. SV* newSVpv_share(const char* s, U32 hash)','name' => 'newSVpv_share'},'sv_taint' => {'text' => 'Taint an SV. Use C instead. void sv_taint(SV* sv)','name' => 'sv_taint'},'utf16_to_utf8' => {'text' => '','name' => 'utf16_to_utf8'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains a signed integer. bool SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'deb' => {'text' => '','name' => 'deb'},'PL_parser-Elinestart' => {'text' => 'Points to the start of the current line inside the lexer buffer. This is useful for indicating at which column an error occurred, and not much else. This must be updated by any lexing code that consumes a newline; the function L handles this detail. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_parser-Elinestart'},'pad_add_name_pvn' => {'text' => 'Allocates a place in the currently-compiling pad for a named lexical variable. Stores the name and other metadata in the name part of the pad, and makes preparations to manage the variable\'s lexical scoping. Returns the offset of the allocated pad slot. I/I specify the variable\'s name, including leading sigil. If I is non-null, the name is for a typed lexical, and this identifies the type. If I is non-null, it\'s a lexical reference to a package variable, and this identifies the package. The following flags can be OR\'ed together: padadd_OUR redundantly specifies if it\'s a package var padadd_STATE variable will retain value persistently padadd_NO_DUP_CHECK skip check for lexical shadowing PADOFFSET pad_add_name_pvn(const char *namepv, STRLEN namelen, U32 flags, HV *typestash, HV *ourstash)','name' => 'pad_add_name_pvn'},'he_dup' => {'text' => '','name' => 'he_dup'},'gv_fullname3' => {'text' => '','name' => 'gv_fullname3'},'SVt_PVNV' => {'text' => 'Type flag for scalars. See L.','name' => 'SVt_PVNV'},'mPUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void mPUSHu(UV uv)','name' => 'mPUSHu'},'gv_fetchmeth_pvn' => {'text' => '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. The only significant values for C are GV_SUPER and SVf_UTF8. GV_SUPER indicates that we want to look up the method in the superclasses of the C. 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_pvn(HV* stash, const char* name, STRLEN len, I32 level, U32 flags)','name' => 'gv_fetchmeth_pvn'},'cophh_new_empty' => {'text' => 'Generate and return a fresh cop hints hash containing no entries. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_new_empty()','name' => 'cophh_new_empty'},'sv_derived_from_pvn' => {'text' => 'Returns a boolean indicating whether the SV is derived from the specified class I. To check derivation at the Perl level, call C as a normal Perl method. Currently, the only significant value for C is SVf_UTF8. bool sv_derived_from_pvn(SV* sv, const char *const name, const STRLEN len, U32 flags)','name' => 'sv_derived_from_pvn'},'op_append_list' => {'text' => 'Concatenate the lists of ops contained directly within two list-type ops, returning the combined list. I and I are the list-type ops to concatenate. I specifies the intended opcode for the list. If either I or I is not already a list of the right type, it will be upgraded into one. If either I or I is null, the other is returned unchanged. OP * op_append_list(I32 optype, OP *first, OP *last)','name' => 'op_append_list'},'repeatcpy' => {'text' => '','name' => 'repeatcpy'},'do_spawn_nowait' => {'text' => '','name' => 'do_spawn_nowait'},'sv_setsv_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_setsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_setsv_nomg'},'load_module_nocontext' => {'text' => '','name' => 'load_module_nocontext'},'re_intuit_string' => {'text' => '','name' => 're_intuit_string'},'do_magic_dump' => {'text' => '','name' => 'do_magic_dump'},'HvNAMELEN' => {'text' => 'Returns the length of the stash\'s name. STRLEN HvNAMELEN(HV *stash)','name' => 'HvNAMELEN'},'XPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHp(char* str, STRLEN len)','name' => 'XPUSHp'},'av_create_and_push' => {'text' => 'Push an SV onto the end of the array, creating the array if necessary. A small internal helper function to remove a commonly duplicated idiom. NOTE: this function is experimental and may change or be removed without notice. void av_create_and_push(AV **const avp, SV *const val)','name' => 'av_create_and_push'},'sv_utf8_encode' => {'text' => 'Converts the PV of an SV to UTF-8, but then turns the C flag off so that it looks like octets again. void sv_utf8_encode(SV *const sv)','name' => 'sv_utf8_encode'},'SvUTF8_on' => {'text' => 'Turn on the UTF-8 status of an SV (the data is not changed, just the flag). Do not use frivolously. void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_does_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of an SV. bool sv_does_pv(SV* sv, const char *const name, U32 flags)','name' => 'sv_does_pv'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvn_mg(SV *const sv, const char *const ptr, const STRLEN len)','name' => 'sv_setpvn_mg'},'toLOWER' => {'text' => 'Converts the specified character to lowercase, if possible; otherwise returns the input character itself. char toLOWER(char ch)','name' => 'toLOWER'},'PadlistNAMESMAX' => {'text' => 'The index of the last pad name. NOTE: this function is experimental and may change or be removed without notice. SSize_t PadlistNAMESMAX(PADLIST padlist)','name' => 'PadlistNAMESMAX'},'av_iter_p' => {'text' => '','name' => 'av_iter_p'},'prescan_version' => {'text' => 'Validate that a given string can be parsed as a version object, but doesn\'t actually perform the parsing. Can use either strict or lax validation rules. Can optionally set a number of hint variables to save the parsing code some time when tokenizing. const char* prescan_version(const char *s, bool strict, const char** errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha)','name' => 'prescan_version'},'PerlIO_write' => {'text' => '','name' => 'PerlIO_write'},'hv_ksplit' => {'text' => '','name' => 'hv_ksplit'},'new_version' => {'text' => 'Returns a new version object based on the passed in SV: SV *sv = new_version(SV *ver); Does not alter the passed in ver SV. See "upg_version" if you want to upgrade the SV. SV* new_version(SV *ver)','name' => 'new_version'},'PerlIO_seek' => {'text' => '','name' => 'PerlIO_seek'},'free_tmps' => {'text' => '','name' => 'free_tmps'},'parse_arithexpr' => {'text' => 'Parse a Perl arithmetic expression. This may contain operators of precedence down to the bit shift operators. The expression must be followed (and thus terminated) either by a comparison or lower-precedence operator or by something that would normally terminate an expression such as semicolon. If I includes C then the expression is optional, otherwise it is mandatory. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed and the lexical context for the expression. The op tree representing the expression is returned. If an optional expression is absent, a null pointer is returned, otherwise the pointer will be non-null. If an error occurs in parsing or compilation, in most cases a valid op tree is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. Some compilation errors, however, will throw an exception immediately. NOTE: this function is experimental and may change or be removed without notice. OP * parse_arithexpr(U32 flags)','name' => 'parse_arithexpr'},'Nullav' => {'text' => 'Null AV pointer. (deprecated - use C<(AV *)NULL> instead)','name' => 'Nullav'},'sv_pvbyten' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten(SV *sv, STRLEN *lp)','name' => 'sv_pvbyten'},'isOCTAL' => {'text' => 'Returns a boolean indicating whether the specified character is an octal digit, [0-7]. The only two variants are C and C; each is identical to C. bool isOCTAL(char ch)','name' => 'isOCTAL'},'rsignal' => {'text' => '','name' => 'rsignal'},'sv_pv' => {'text' => 'Use the C macro instead char* sv_pv(SV *sv)','name' => 'sv_pv'},'perl_alloc_using' => {'text' => '','name' => 'perl_alloc_using'},'pv_pretty' => {'text' => 'Converts a string into something presentable, handling escaping via pv_escape() and supporting quoting and ellipses. If the PERL_PV_PRETTY_QUOTE flag is set then the result will be double quoted with any double quotes in the string escaped. Otherwise if the PERL_PV_PRETTY_LTGT flag is set then the result be wrapped in angle brackets. If the PERL_PV_PRETTY_ELLIPSES flag is set and not all characters in string were output then an ellipsis C<...> will be appended to the string. Note that this happens AFTER it has been quoted. If start_color is non-null then it will be inserted after the opening quote (if there is one) but before the escaped text. If end_color is non-null then it will be inserted after the escaped text but before any quotes or ellipses. Returns a pointer to the prettified text as held by dsv. char* pv_pretty(SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags)','name' => 'pv_pretty'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setnv_mg(SV *const sv, const NV num)','name' => 'sv_setnv_mg'},'utf8_to_bytes' => {'text' => 'Converts a string C of length C from UTF-8 into native byte encoding. Unlike L, this over-writes the original string, and updates C to contain the new length. Returns zero on failure, setting C to -1. If you need a copy of the string, see L. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_setref_pvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV * sv_setref_pvs(const char* s)','name' => 'sv_setref_pvs'},'re_dup_guts' => {'text' => '','name' => 're_dup_guts'},'si_dup' => {'text' => '','name' => 'si_dup'},'uvuni_to_utf8_flags' => {'text' => 'Adds the UTF-8 representation of the Unicode code point C to the end of the string C; C should have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvuni_to_utf8_flags(d, uv, flags); or, in most cases, d = uvuni_to_utf8(d, uv); (which is equivalent to) d = uvuni_to_utf8_flags(d, uv, 0); This is the recommended Unicode-aware way of saying *(d++) = uv; where uv is a code point expressed in Latin-1 or above, not the platform\'s native character set. B or L>. This function will convert to UTF-8 (and not warn) even code points that aren\'t legal Unicode or are problematic, unless C contains one or more of the following flags: If C is a Unicode surrogate code point and UNICODE_WARN_SURROGATE is set, the function will raise a warning, provided UTF8 warnings are enabled. If instead UNICODE_DISALLOW_SURROGATE is set, the function will fail and return NULL. If both flags are set, the function will both warn and return NULL. The UNICODE_WARN_NONCHAR and UNICODE_DISALLOW_NONCHAR flags correspondingly affect how the function handles a Unicode non-character. And likewise, the UNICODE_WARN_SUPER and UNICODE_DISALLOW_SUPER flags, affect the handling of code points that are above the Unicode maximum of 0x10FFFF. Code points above 0x7FFF_FFFF (which are even less portable) can be warned and/or disallowed even if other above-Unicode code points are accepted by the UNICODE_WARN_FE_FF and UNICODE_DISALLOW_FE_FF flags. And finally, the flag UNICODE_WARN_ILLEGAL_INTERCHANGE selects all four of the above WARN flags; and UNICODE_DISALLOW_ILLEGAL_INTERCHANGE selects all four DISALLOW flags. U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)','name' => 'uvuni_to_utf8_flags'},'PL_rpeepp' => {'text' => 'Pointer to the recursive peephole optimiser. This is a function that gets called at the end of compilation of a Perl subroutine (or equivalently independent piece of Perl code) to perform fixups of some ops and to perform small-scale optimisations. The function is called once for each chain of ops linked through their C fields; it is recursively called to handle each side chain. It is passed, as sole parameter, a pointer to the op that is at the head of the chain. It modifies the op tree in place. The peephole optimiser should never be completely replaced. Rather, add code to it by wrapping the existing optimiser. The basic way to do this can be seen in L. If the new code wishes to operate only on ops at a subroutine\'s top level, rather than throughout the structure, it is likely to be more convenient to wrap the L hook. peep_t PL_rpeepp','name' => 'PL_rpeepp'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See L.','name' => 'G_DISCARD'},'newGVREF' => {'text' => '','name' => 'newGVREF'},'XST_mNV' => {'text' => '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)','name' => 'XST_mNV'},'UNDERBAR' => {'text' => 'The SV* corresponding to the $_ variable. Works even if there is a lexical $_ in scope.','name' => 'UNDERBAR'},'newSVOP' => {'text' => 'Constructs, checks, and returns an op of any type that involves an embedded SV. I is the opcode. I gives the eight bits of C. I gives the SV to embed in the op; this function takes ownership of one reference to it. OP * newSVOP(I32 type, I32 flags, SV *sv)','name' => 'newSVOP'},'cophh_fetch_pvn' => {'text' => 'Look up the entry in the cop hints hash I with the key specified by I and I. If I has the C bit set, the key octets are interpreted as UTF-8, otherwise they are interpreted as Latin-1. I is a precomputed hash of the key string, or zero if it has not been precomputed. Returns a mortal scalar copy of the value associated with the key, or C<&PL_sv_placeholder> if there is no value associated with the key. NOTE: this function is experimental and may change or be removed without notice. SV * cophh_fetch_pvn(const COPHH *cophh, const char *keypv, STRLEN keylen, U32 hash, U32 flags)','name' => 'cophh_fetch_pvn'},'pad_sv' => {'text' => 'Get the value at offset I in the current (compiling or executing) pad. Use macro PAD_SV instead of calling this function directly. SV * pad_sv(PADOFFSET po)','name' => 'pad_sv'},'amagic_call' => {'text' => '','name' => 'amagic_call'},'op_free' => {'text' => '','name' => 'op_free'},'PadnameLEN' => {'text' => 'The length of the name. NOTE: this function is experimental and may change or be removed without notice. STRLEN PadnameLEN(PADNAME pn)','name' => 'PadnameLEN'},'SvPVutf8_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_force(SV* sv, STRLEN len)','name' => 'SvPVutf8_force'},'gv_AVadd' => {'text' => '','name' => 'gv_AVadd'},'pop_scope' => {'text' => '','name' => 'pop_scope'},'SVt_NV' => {'text' => 'Type flag for scalars. See L.','name' => 'SVt_NV'},'my_popen_list' => {'text' => '','name' => 'my_popen_list'},'sv_2uv' => {'text' => '','name' => 'sv_2uv'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and L. void PUSHMARK(SP)','name' => 'PUSHMARK'},'taint_proper' => {'text' => '','name' => 'taint_proper'},'save_generic_pvref' => {'text' => '','name' => 'save_generic_pvref'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. SV* ST(int ix)','name' => 'ST'},'call_pv' => {'text' => '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)','name' => 'call_pv'},'gv_fetchmeth_autoload' => {'text' => 'This is the old form of L, which has no flags parameter. GV* gv_fetchmeth_autoload(HV* stash, const char* name, STRLEN len, I32 level)','name' => 'gv_fetchmeth_autoload'},'save_mortalizesv' => {'text' => '','name' => 'save_mortalizesv'},'sv_pos_b2u' => {'text' => 'Converts the value pointed to by offsetp from a count of bytes from the start of the string, to a count of the equivalent number of UTF-8 chars. Handles magic and type coercion. void sv_pos_b2u(SV *const sv, I32 *const offsetp)','name' => 'sv_pos_b2u'},'sv_utf8_upgrade_flags_grow' => {'text' => '','name' => 'sv_utf8_upgrade_flags_grow'},'SVt_IV' => {'text' => 'Type flag for scalars. See L.','name' => 'SVt_IV'},'SvIsCOW' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write (either shared hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for COW). bool SvIsCOW(SV* sv)','name' => 'SvIsCOW'},'reentrant_size' => {'text' => '','name' => 'reentrant_size'},'printf_nocontext' => {'text' => '','name' => 'printf_nocontext'},'save_freesv' => {'text' => '','name' => 'save_freesv'},'sv_catsv' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. If C is null, does nothing; otherwise modifies only C. Handles \'get\' magic on both SVs, but no \'set\' magic. See C and C. void sv_catsv(SV *dstr, SV *sstr)','name' => 'sv_catsv'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'ax' => {'text' => 'Variable which is setup by C to indicate the stack base offset, used by the C, C and C macros. The C macro must be called prior to setup the C variable. I32 ax','name' => 'ax'},'regexec_flags' => {'text' => '','name' => 'regexec_flags'},'pad_add_name_sv' => {'text' => 'Exactly like L, but takes the name string in the form of an SV instead of a string/length pair. PADOFFSET pad_add_name_sv(SV *name, U32 flags, HV *typestash, HV *ourstash)','name' => 'pad_add_name_sv'},'to_utf8_upper' => {'text' => 'Convert the UTF-8 encoded character at C

to its uppercase version and store that in UTF-8 in C and its length in bytes in C. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the uppercase version may be longer than the original character. The first character of the uppercased version is returned (but note, as explained above, that there may be more.) The character at C

is assumed by this routine to be well-formed. UV to_utf8_upper(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_upper'},'newSVpadname' => {'text' => 'Creates a new SV containing the pad name. This is currently identical to C, but pad names may cease being SVs at some point, so C is preferable. NOTE: this function is experimental and may change or be removed without notice. SV* newSVpadname(PADNAME *pn)','name' => 'newSVpadname'},'SvPVutf8x_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x_force(SV* sv, STRLEN len)','name' => 'SvPVutf8x_force'},'warner_nocontext' => {'text' => '','name' => 'warner_nocontext'},'sv_eq_flags' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. Is UTF-8 and \'use bytes\' aware and coerces its args to strings if necessary. If the flags include SV_GMAGIC, it handles get-magic, too. I32 sv_eq_flags(SV* sv1, SV* sv2, const U32 flags)','name' => 'sv_eq_flags'},'my_htonl' => {'text' => '','name' => 'my_htonl'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHi(IV iv)','name' => 'PUSHi'},'SvLEN_set' => {'text' => 'Set the actual length of the string which is in the SV. See C. void SvLEN_set(SV* sv, STRLEN len)','name' => 'SvLEN_set'},'new_numeric' => {'text' => '','name' => 'new_numeric'},'to_utf8_lower' => {'text' => 'Convert the UTF-8 encoded character at C

to its lowercase version and store that in UTF-8 in ustrp and its length in bytes in C. Note that the C needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the lowercase version may be longer than the original character. The first character of the lowercased version is returned (but note, as explained above, that there may be more.) The character at C

is assumed by this routine to be well-formed. UV to_utf8_lower(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_lower'},'gv_init_pv' => {'text' => 'Same as gv_init_pvn(), but takes a nul-terminated string for the name instead of separate char * and length parameters. void gv_init_pv(GV* gv, HV* stash, const char* name, U32 flags)','name' => 'gv_init_pv'},'newSVpvf' => {'text' => 'Creates a new SV and initializes it with the string formatted like C. SV* newSVpvf(const char *const pat, ...)','name' => 'newSVpvf'},'doing_taint' => {'text' => '','name' => 'doing_taint'},'save_I8' => {'text' => '','name' => 'save_I8'},'Newxc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. See also C. void Newxc(void* ptr, int nitems, type, cast)','name' => 'Newxc'},'lex_stuff_pvs' => {'text' => 'Like L, but takes a literal string instead of a string/length pair. NOTE: this function is experimental and may change or be removed without notice. void lex_stuff_pvs(const char *pv, U32 flags)','name' => 'lex_stuff_pvs'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L. int perl_destruct(PerlInterpreter *my_perl)','name' => 'perl_destruct'},'SvIVX' => {'text' => 'Returns the raw value in the SV\'s IV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. IV SvIVX(SV* sv)','name' => 'SvIVX'},'custom_op_name' => {'text' => 'Return the name for a given custom op. This was once used by the OP_NAME macro, but is no longer: it has only been kept for compatibility, and should not be used. const char * custom_op_name(const OP *o)','name' => 'custom_op_name'},'sv_vsetpvf' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Does not handle \'set\' magic. See C. Usually used via its frontend C. void sv_vsetpvf(SV *const sv, const char *const pat, va_list *const args)','name' => 'sv_vsetpvf'},'any_dup' => {'text' => '','name' => 'any_dup'},'XCPT_CATCH' => {'text' => 'Introduces a catch block. See L.','name' => 'XCPT_CATCH'},'regclass_swash' => {'text' => '','name' => 'regclass_swash'},'my_dirfd' => {'text' => '','name' => 'my_dirfd'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the stack. void XST_mYES(int pos)','name' => 'XST_mYES'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. You probably want to use one of the assortment of wrappers, such as C, C, C and C. void sv_setsv(SV *dstr, SV *sstr)','name' => 'sv_setsv'},'PerlIO_stdin' => {'text' => '','name' => 'PerlIO_stdin'},'READ_XDIGIT' => {'text' => 'Returns the value of an ASCII-range hex digit and advances the string pointer. Behaviour is only well defined when isXDIGIT(*str) is true. U8 READ_XDIGIT(char str*)','name' => 'READ_XDIGIT'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an XSUB\'s aliases was used to invoke it. See L. I32 ix','name' => 'ix'},'XSRETURN_UV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_UV(IV uv)','name' => 'XSRETURN_UV'},'SvREFCNT_inc_simple' => {'text' => 'Same as SvREFCNT_inc, but can only be used with expressions without side effects. Since we don\'t have to store a temporary value, it\'s faster. SV* SvREFCNT_inc_simple(SV* sv)','name' => 'SvREFCNT_inc_simple'},'my_lstat' => {'text' => '','name' => 'my_lstat'},'my_atof' => {'text' => '','name' => 'my_atof'},'savestack_grow_cnt' => {'text' => '','name' => 'savestack_grow_cnt'},'PL_comppad_name' => {'text' => 'During compilation, this points to the array containing the names part of the pad for the currently-compiling code. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_comppad_name'},'SvTRUE_nomg' => {'text' => 'Returns a boolean indicating whether Perl would evaluate the SV as true or false. See SvOK() for a defined/undefined test. Does not handle \'get\' magic. bool SvTRUE_nomg(SV* sv)','name' => 'SvTRUE_nomg'},'vverify' => {'text' => 'Validates that the SV contains valid internal structure for a version object. It may be passed either the version object (RV) or the hash itself (HV). If the structure is valid, it returns the HV. If the structure is invalid, it returns NULL. SV *hv = vverify(sv); Note that it only confirms the bare minimum structure (so as not to get confused by derived classes which may contain additional hash entries): SV* vverify(SV *vs)','name' => 'vverify'},'dXSI32' => {'text' => 'Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. dXSI32;','name' => 'dXSI32'},'dXCPT' => {'text' => 'Set up necessary local variables for exception handling. See L. dXCPT;','name' => 'dXCPT'},'sv_tainted' => {'text' => 'Test an SV for taintedness. Use C instead. bool sv_tainted(SV *const sv)','name' => 'sv_tainted'},'mro_set_private_data' => {'text' => '','name' => 'mro_set_private_data'},'do_gv_dump' => {'text' => '','name' => 'do_gv_dump'},'reg_named_buff_nextkey' => {'text' => '','name' => 'reg_named_buff_nextkey'},'hv_fill' => {'text' => 'Returns the number of hash buckets that happen to be in use. This function is wrapped by the macro C. Previously this value was stored in the HV structure, rather than being calculated on demand. STRLEN hv_fill(HV const *const hv)','name' => 'hv_fill'},'cv_const_sv' => {'text' => 'If C is a constant sub eligible for inlining. returns the constant value returned by the sub. Otherwise, returns NULL. Constant subs can be created with C or as described in L. SV* cv_const_sv(const CV *const cv)','name' => 'cv_const_sv'},'pad_add_name_pvs' => {'text' => 'Exactly like L, but takes a literal string instead of a string/length pair. PADOFFSET pad_add_name_pvs(const char *name, U32 flags, HV *typestash, HV *ourstash)','name' => 'pad_add_name_pvs'},'newSVnv' => {'text' => 'Creates a new SV and copies a floating point value into it. The reference count for the SV is set to 1. SV* newSVnv(const NV n)','name' => 'newSVnv'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry. Can be assigned to. SV *foo= HeVAL(hv); HeVAL(hv)= sv; SV* HeVAL(HE* he)','name' => 'HeVAL'},'HePV' => {'text' => '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. See also C. If you are using C to get values to pass to C to create a new SV, you should consider using C as it is more efficient. char* HePV(HE* he, STRLEN len)','name' => 'HePV'},'hv_free_ent' => {'text' => '','name' => 'hv_free_ent'},'isIDCONT' => {'text' => 'Returns a boolean indicating whether the specified character can be the second or succeeding character of an identifier. This is very close to, but not quite the same as the official Unicode property C. The difference is that this returns true only if the input character also matches L. See the L for an explanation of variants C, C, C, C, C, C, and C. bool isIDCONT(char ch)','name' => 'isIDCONT'},'SvGETMAGIC' => {'text' => 'Invokes C on an SV if it has \'get\' magic. For example, this will call C on a tied variable. This macro evaluates its argument more than once. void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'PL_parser' => {'text' => 'Pointer to a structure encapsulating the state of the parsing operation currently in progress. The pointer can be locally changed to perform a nested parse without interfering with the state of an outer parse. Individual members of C have their own documentation.','name' => 'PL_parser'},'pv_uni_display' => {'text' => 'Build to the scalar C a displayable version of the string C, length C, the displayable version being at most C bytes long (if longer, the rest is truncated and "..." will be appended). The C argument can have UNI_DISPLAY_ISPRINT set to display isPRINT()able characters as themselves, UNI_DISPLAY_BACKSLASH to display the \\\\[nrfta\\\\] as the backslashed versions (like \'\\n\') (UNI_DISPLAY_BACKSLASH is preferred over UNI_DISPLAY_ISPRINT for \\\\). UNI_DISPLAY_QQ (and its alias UNI_DISPLAY_REGEX) have both UNI_DISPLAY_BACKSLASH and UNI_DISPLAY_ISPRINT turned on. The pointer to the PV of the C is returned. char* pv_uni_display(SV *dsv, const U8 *spv, STRLEN len, STRLEN pvlim, UV flags)','name' => 'pv_uni_display'},'init_stacks' => {'text' => '','name' => 'init_stacks'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic and operator overloading. void sv_inc(SV *const sv)','name' => 'sv_inc'},'SvPVbytex_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex_force(SV* sv, STRLEN len)','name' => 'SvPVbytex_force'},'op_prepend_elem' => {'text' => 'Prepend an item to the list of ops contained directly within a list-type op, returning the lengthened list. I is the op to prepend to the list, and I is the list-type op. I specifies the intended opcode for the list. If I is not already a list of the right type, it will be upgraded into one. If either I or I is null, the other is returned unchanged. OP * op_prepend_elem(I32 optype, OP *first, OP *last)','name' => 'op_prepend_elem'},'hv_delete' => {'text' => 'Deletes a key/value pair in the hash. The value\'s SV is removed from the hash, made mortal, and returned to the caller. The absolute value of C is the length of the key. If C is negative the key is assumed to be in UTF-8-encoded Unicode. The C value will normally be zero; if set to G_DISCARD then NULL will be returned. NULL will also be returned if the key is not found. SV* hv_delete(HV *hv, const char *key, I32 klen, I32 flags)','name' => 'hv_delete'},'pad_add_name_pv' => {'text' => 'Exactly like L, but takes a nul-terminated string instead of a string/length pair. PADOFFSET pad_add_name_pv(const char *name, U32 flags, HV *typestash, HV *ourstash)','name' => 'pad_add_name_pv'},'POP_MULTICALL' => {'text' => 'Closing bracket for a lightweight callback. See L. POP_MULTICALL;','name' => 'POP_MULTICALL'},'sv_cat_decode' => {'text' => 'The encoding is assumed to be an Encode object, the PV of the ssv is assumed to be octets in that encoding and decoding the input starts from the position which (PV + *offset) pointed to. The dsv will be concatenated the decoded UTF-8 string from ssv. Decoding will terminate when the string tstr appears in decoding output or the input ends on the PV of the ssv. The value which the offset points will be modified to the last input position on the ssv. Returns TRUE if the terminator was found, else returns FALSE. bool sv_cat_decode(SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen)','name' => 'sv_cat_decode'},'SvIV_set' => {'text' => 'Set the value of the IV pointer in sv to val. It is possible to perform the same function of this macro with an lvalue assignment to C. With future Perls, however, it will be more efficient to use C instead of the lvalue assignment to C. void SvIV_set(SV* sv, IV val)','name' => 'SvIV_set'},'sv_setiv' => {'text' => 'Copies an integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setiv(SV *const sv, const IV num)','name' => 'sv_setiv'},'gv_efullname' => {'text' => '','name' => 'gv_efullname'},'sv_report_used' => {'text' => 'Dump the contents of all SVs not yet freed (debugging aid). void sv_report_used()','name' => 'sv_report_used'},'save_sptr' => {'text' => '','name' => 'save_sptr'},'sv_vcatpvfn_flags' => {'text' => '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). If called as C or flags include C, calls get magic. Usually used via one of its frontends C and C. void sv_vcatpvfn_flags(SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted, const U32 flags)','name' => 'sv_vcatpvfn_flags'},'SvNVX' => {'text' => 'Returns the raw value in the SV\'s NV slot, without checks or conversions. Only use when you are sure SvNOK is true. See also C. NV SvNVX(SV* sv)','name' => 'SvNVX'},'do_open' => {'text' => '','name' => 'do_open'},'regnext' => {'text' => '','name' => 'regnext'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. U32 HeHASH(HE* he)','name' => 'HeHASH'},'SvIOK' => {'text' => 'Returns a U32 value indicating whether the SV contains an integer. U32 SvIOK(SV* sv)','name' => 'SvIOK'},'newANONHASH' => {'text' => '','name' => 'newANONHASH'},'PadnameSV' => {'text' => 'Returns the pad name as an SV. This is currently just C. It will begin returning a new mortal SV if pad names ever stop being SVs. NOTE: this function is experimental and may change or be removed without notice. SV * PadnameSV(PADNAME pn)','name' => 'PadnameSV'},'is_utf8_char_buf' => {'text' => 'Returns the number of bytes that comprise the first UTF-8 encoded character in buffer C. C should point to one position beyond the end of the buffer. 0 is returned if C does not point to a complete, valid UTF-8 encoded character. Note that an INVARIANT character (i.e. ASCII on non-EBCDIC machines) is a valid UTF-8 character. STRLEN is_utf8_char_buf(const U8 *buf, const U8 *buf_end)','name' => 'is_utf8_char_buf'},'SvPV_force' => {'text' => 'Like C but will force the SV into containing a string (C), and only a string (C), by hook or by crook. You need force if you are going to update the C directly. Processes get magic. Note that coercing an arbitrary scalar into a plain PV will potentially strip useful data from it. For example if the SV was C, then the referent will have its reference count decremented, and the SV itself may be converted to an C scalar with a string buffer containing a value such as C<"ARRAY(0x1234)">. char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'HeUTF8' => {'text' => 'Returns whether the C value returned by C is encoded in UTF-8, doing any necessary dereferencing of possibly C keys. The value returned will be 0 or non-0, not necessarily 1 (or even a value with any low bits set), so B blindly assign this to a C variable, as C may be a typedef for C. char* HeUTF8(HE* he)','name' => 'HeUTF8'},'newRANGE' => {'text' => 'Constructs and returns a C op, with subordinate C and C ops. I gives the eight bits of C for the C op and, shifted up eight bits, the eight bits of C for both the C and C ops, except that the bit with value 1 is automatically set. I and I supply the expressions controlling the endpoints of the range; they are consumed by this function and become part of the constructed op tree. OP * newRANGE(I32 flags, OP *left, OP *right)','name' => 'newRANGE'},'isCNTRL' => {'text' => 'Returns a boolean indicating whether the specified character is a control character, analogous to C. See the L for an explanation of variants C, C, C, C, C, C, and C On EBCDIC platforms, you almost always want to use the C variant. bool isCNTRL(char ch)','name' => 'isCNTRL'},'PadlistNAMESARRAY' => {'text' => 'The C array of pad names. NOTE: this function is experimental and may change or be removed without notice. PADNAME ** PadlistNAMESARRAY(PADLIST padlist)','name' => 'PadlistNAMESARRAY'},'cophh_delete_pvn' => {'text' => 'Delete a key and its associated value from the cop hints hash I, and returns the modified hash. The returned hash pointer is in general not the same as the hash pointer that was passed in. The input hash is consumed by the function, and the pointer to it must not be subsequently used. Use L if you need both hashes. The key is specified by I and I. If I has the C bit set, the key octets are interpreted as UTF-8, otherwise they are interpreted as Latin-1. I is a precomputed hash of the key string, or zero if it has not been precomputed. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_delete_pvn(COPHH *cophh, const char *keypv, STRLEN keylen, U32 hash, U32 flags)','name' => 'cophh_delete_pvn'},'grok_hex' => {'text' => 'converts a string representing a hex number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0x" or "x" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the hex number may use \'_\' characters to separate digits. UV grok_hex(const char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_hex'},'newRV' => {'text' => '','name' => 'newRV'},'SvLOCK' => {'text' => 'Arranges for a mutual exclusion lock to be obtained on sv if a suitable module has been loaded. void SvLOCK(SV* sv)','name' => 'SvLOCK'},'gv_fetchfile' => {'text' => '','name' => 'gv_fetchfile'},'sv_vsetpvfn' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Usually used via one of its frontends C and C. void sv_vsetpvfn(SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted)','name' => 'sv_vsetpvfn'},'PerlIO_get_cnt' => {'text' => '','name' => 'PerlIO_get_cnt'},'PerlIO_setlinebuf' => {'text' => '','name' => 'PerlIO_setlinebuf'},'utf16_to_utf8_reversed' => {'text' => '','name' => 'utf16_to_utf8_reversed'},'cast_ulong' => {'text' => '','name' => 'cast_ulong'},'to_utf8_case' => {'text' => 'The C

contains the pointer to the UTF-8 string encoding the character that is being converted. This routine assumes that the character at C

to its foldcase version and store that in UTF-8 in C and its length in bytes in C. Note that the C needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the foldcase version may be longer than the original character (up to three characters). The first character of the foldcased version is returned (but note, as explained above, that there may be more.) The character at C

is assumed by this routine to be well-formed. UV to_utf8_fold(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_fold'},'regfree_internal' => {'text' => '','name' => 'regfree_internal'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. Uses C to determine the length of C, then calls C. HV* gv_stashpv(const char* name, I32 flags)','name' => 'gv_stashpv'},'sv_cmp_locale_flags' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware and will coerce its args to strings if necessary. If the flags contain SV_GMAGIC, it handles get magic. See also C. I32 sv_cmp_locale_flags(SV *const sv1, SV *const sv2, const U32 flags)','name' => 'sv_cmp_locale_flags'},'sv_vcatpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vcatpvf_mg(SV *const sv, const char *const pat, va_list *const args)','name' => 'sv_vcatpvf_mg'},'mXPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void mXPUSHu(UV uv)','name' => 'mXPUSHu'},'hv_exists_ent' => {'text' => '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 *hv, SV *keysv, U32 hash)','name' => 'hv_exists_ent'},'PL_comppad' => {'text' => 'During compilation, this points to the array containing the values part of the pad for the currently-compiling code. (At runtime a CV may have many such value arrays; at compile time just one is constructed.) At runtime, this points to the array containing the currently-relevant values for the pad for the currently-executing code. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_comppad'},'atfork_unlock' => {'text' => '','name' => 'atfork_unlock'},'SvNIOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a number, integer or double. U32 SvNIOK(SV* sv)','name' => 'SvNIOK'},'save_long' => {'text' => '','name' => 'save_long'},'mro_method_changed_in' => {'text' => 'Invalidates method caching on any child classes of the given stash, so that they might notice the changes in this one. Ideally, all instances of C in perl source outside of F should be replaced by calls to this. Perl automatically handles most of the common ways a method might be redefined. However, there are a few ways you could change a method in a stash without the cache code noticing, in which case you need to call this method afterwards: 1) Directly manipulating the stash HV entries from XS code. 2) Assigning a reference to a readonly scalar constant into a stash entry in order to create a constant subroutine (like constant.pm does). This same method is available from pure perl via, C. void mro_method_changed_in(HV* stash)','name' => 'mro_method_changed_in'},'unpack_str' => {'text' => '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(const char *pat, const char *patend, const char *s, const char *strbeg, const char *strend, char **new_s, I32 ocnt, U32 flags)','name' => 'unpack_str'},'my_fflush_all' => {'text' => '','name' => 'my_fflush_all'},'is_uni_print' => {'text' => '','name' => 'is_uni_print'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C wrapper instead. SV* sv_newref(SV *const sv)','name' => 'sv_newref'},'cop_hints_fetch_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of a string/length pair. SV * cop_hints_fetch_pv(const COP *cop, const char *key, U32 hash, U32 flags)','name' => 'cop_hints_fetch_pv'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'sv_uni_display' => {'text' => 'Build to the scalar C a displayable version of the scalar C, the displayable version being at most C bytes long (if longer, the rest is truncated and "..." will be appended). The C argument is as in L(). The pointer to the PV of the C is returned. char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim, UV flags)','name' => 'sv_uni_display'},'sv_unmagicext' => {'text' => 'Removes all magic of type C with the specified C from an SV. int sv_unmagicext(SV *const sv, const int type, MGVTBL *vtbl)','name' => 'sv_unmagicext'},'newSVpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV* newSVpvs(const char* s)','name' => 'newSVpvs'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'realloc' => {'text' => '','name' => 'realloc'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'packlist' => {'text' => 'The engine implementing pack() Perl function. void packlist(SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist)','name' => 'packlist'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C for a version which guarantees to evaluate sv only once. NV SvNV(SV* sv)','name' => 'SvNV'},'SvUTF8' => {'text' => 'Returns a U32 value indicating the UTF-8 status of an SV. If things are set-up properly, this indicates whether or not the SV contains UTF-8 encoded data. Call this after SvPV() in case any call to string overloading updates the internal flag. U32 SvUTF8(SV* sv)','name' => 'SvUTF8'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'op_dump' => {'text' => '','name' => 'op_dump'},'get_mstats' => {'text' => '','name' => 'get_mstats'},'savestack_grow' => {'text' => '','name' => 'savestack_grow'},'debstackptrs' => {'text' => '','name' => 'debstackptrs'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'ptr_table_store' => {'text' => '','name' => 'ptr_table_store'},'cv_undef' => {'text' => 'Clear out all the active components of a CV. This can happen either by an explicit C, 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)','name' => 'cv_undef'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'sv_catpvf_nocontext' => {'text' => '','name' => 'sv_catpvf_nocontext'},'save_padsv_and_mortalize' => {'text' => '','name' => 'save_padsv_and_mortalize'},'gv_autoload_sv' => {'text' => '','name' => 'gv_autoload_sv'},'cophh_delete_pvs' => {'text' => 'Like L, but takes a literal string instead of a string/length pair, and no precomputed hash. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_delete_pvs(const COPHH *cophh, const char *key, U32 flags)','name' => 'cophh_delete_pvs'},'get_cvn_flags' => {'text' => 'Returns the CV of the specified Perl subroutine. C are passed to C. 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_cvn_flags(const char* name, STRLEN len, I32 flags)','name' => 'get_cvn_flags'},'XopENTRY_set' => {'text' => 'Set a member of the XOP structure. I is a cpp token indicating which entry to set. See L for details about the available members and how they are used. void XopENTRY_set(XOP *xop, which, value)','name' => 'XopENTRY_set'},'reentrant_free' => {'text' => '','name' => 'reentrant_free'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'dump_vindent' => {'text' => '','name' => 'dump_vindent'},'SvPVx' => {'text' => 'A version of C which guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. char* SvPVx(SV* sv, STRLEN len)','name' => 'SvPVx'},'dump_form' => {'text' => '','name' => 'dump_form'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. If necessary, uses C and upgrades the SV to C. Returns a pointer to the character buffer. Use the C wrapper instead. char* sv_grow(SV *const sv, STRLEN newlen)','name' => 'sv_grow'},'vnormal' => {'text' => 'Accepts a version object and returns the normalized string representation. Call like: sv = vnormal(rv); NOTE: you can pass either the object directly or the SV contained within the RV. The SV returned has a refcount of 1. SV* vnormal(SV *vs)','name' => 'vnormal'},'filter_add' => {'text' => '','name' => 'filter_add'},'newPVOP' => {'text' => 'Constructs, checks, and returns an op of any type that involves an embedded C-level pointer (PV). I is the opcode. I gives the eight bits of C. I supplies the C-level pointer, which must have been allocated using L; the memory will be freed when the op is destroyed. OP * newPVOP(I32 type, I32 flags, char *pv)','name' => 'newPVOP'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. Does not use C. See also C, C and C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'is_uni_graph_lc' => {'text' => '','name' => 'is_uni_graph_lc'},'is_utf8_alnum' => {'text' => '','name' => 'is_utf8_alnum'},'set_numeric_radix' => {'text' => '','name' => 'set_numeric_radix'},'is_utf8_upper' => {'text' => '','name' => 'is_utf8_upper'},'newIO' => {'text' => '','name' => 'newIO'},'do_join' => {'text' => '','name' => 'do_join'},'save_helem' => {'text' => '','name' => 'save_helem'},'die' => {'text' => 'Behaves the same as L, except for the return type. It should be used only where the C return type is required. The function never actually returns. OP * die(const char *pat, ...)','name' => 'die'},'sv_usepvn' => {'text' => 'Tells an SV to use C to find its string value. Implemented by calling C with C of 0, hence does not handle \'set\' magic. See C. void sv_usepvn(SV* sv, char* ptr, STRLEN len)','name' => 'sv_usepvn'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'newCONSTSUB_flags' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. Currently, the only useful value for C is SVf_UTF8. Passing NULL for SV creates a constant sub equivalent to C, which won\'t be called if used as a destructor, but will suppress the overhead of a call to C. (This form, however, isn\'t eligible for inlining at compile time.) CV* newCONSTSUB_flags(HV* stash, const char* name, STRLEN len, U32 flags, SV* sv)','name' => 'newCONSTSUB_flags'},'swash_init' => {'text' => '','name' => 'swash_init'},'newANONSUB' => {'text' => '','name' => 'newANONSUB'},'warn' => {'text' => 'This is an XS interface to Perl\'s C function. Take a sprintf-style format pattern and argument list. These are used to generate a string message. If the message does not end with a newline, then it will be extended with some indication of the current location in the code, as described for L. The error message or object will by default be written to standard error, but this is subject to modification by a C<$SIG{__WARN__}> handler. Unlike with L, C is not permitted to be null. void warn(const char *pat, ...)','name' => 'warn'},'PerlIO_get_bufsiz' => {'text' => '','name' => 'PerlIO_get_bufsiz'},'to_uni_title_lc' => {'text' => '','name' => 'to_uni_title_lc'},'fp_dup' => {'text' => '','name' => 'fp_dup'},'hek_dup' => {'text' => '','name' => 'hek_dup'},'pmop_dump' => {'text' => '','name' => 'pmop_dump'},'newANONATTRSUB' => {'text' => '','name' => 'newANONATTRSUB'},'CvPADLIST' => {'text' => 'CV\'s can have CvPADLIST(cv) set to point to an AV. This is the CV\'s scratchpad, which stores lexical variables and opcode temporary and per-thread values. For these purposes "forms" are a kind-of CV, eval""s are too (except they\'re not callable at will and are always thrown away after the eval"" is done executing). Require\'d files are simply evals without any outer lexical scope. XSUBs don\'t have CvPADLIST set - dXSTARG fetches values from PL_curpad, but that is really the callers pad (a slot of which is allocated by every entersub). The CvPADLIST AV has the REFCNT of its component items managed "manually" (mostly in pad.c) rather than by normal av.c rules. So we turn off AvREAL just before freeing it, to let av.c know not to touch the entries. The items in the AV are not SVs as for a normal AV, but other AVs: 0\'th Entry of the CvPADLIST is an AV which represents the "names" or rather the "static type information" for lexicals. The CvDEPTH\'th entry of CvPADLIST AV is an AV which is the stack frame at that depth of recursion into the CV. The 0\'th slot of a frame AV is an AV which is @_. other entries are storage for variables and op targets. Iterating over the names AV iterates over all possible pad items. Pad slots that are SVs_PADTMP (targets/GVs/constants) end up having &PL_sv_undef "names" (see pad_alloc()). Only my/our variable (SVs_PADMY/SVs_PADOUR) slots get valid names. The rest are op targets/GVs/constants which are statically allocated or resolved at compile time. These don\'t have names by which they can be looked up from Perl code at run time through eval"" like my/our variables can be. Since they can\'t be looked up by "name" but only by their index allocated at compile time (which is usually in PL_op->op_targ), wasting a name SV for them doesn\'t make sense. The SVs in the names AV have their PV being the name of the variable. xlow+1..xhigh inclusive in the NV union is a range of cop_seq numbers for which the name is valid (accessed through the macros COP_SEQ_RANGE_LOW and _HIGH). During compilation, these fields may hold the special value PERL_PADSEQ_INTRO to indicate various stages: COP_SEQ_RANGE_LOW _HIGH ----------------- ----- PERL_PADSEQ_INTRO 0 variable not yet introduced: { my ($x valid-seq# PERL_PADSEQ_INTRO variable in scope: { my ($x) valid-seq# valid-seq# compilation of scope complete: { my ($x) } For typed lexicals name SV is SVt_PVMG and SvSTASH points at the type. For C lexicals, the type is also SVt_PVMG, with the SvOURSTASH slot pointing at the stash of the associated global (so that duplicate C declarations in the same package can be detected). SvUVX is sometimes hijacked to store the generation number during compilation. If SvFAKE is set on the name SV, then that slot in the frame AV is a REFCNT\'ed reference to a lexical from "outside". In this case, the name SV does not use xlow and xhigh to store a cop_seq range, since it is in scope throughout. Instead xhigh stores some flags containing info about the real lexical (is it declared in an anon, and is it capable of being instantiated multiple times?), and for fake ANONs, xlow contains the index within the parent\'s pad where the lexical\'s value is stored, to make cloning quicker. If the \'name\' is \'&\' the corresponding entry in frame AV is a CV representing a possible closure. (SvFAKE and name of \'&\' is not a meaningful combination currently but could become so if C is implemented.) Note that formats are treated as anon subs, and are cloned each time write is called (if necessary). The flag SVs_PADSTALE is cleared on lexicals each time the my() is executed, and set on scope exit. This allows the \'Variable $x is not available\' warning to be generated in evals, such as { my $x = 1; sub f { eval \'$x\'} } f(); For state vars, SVs_PADSTALE is overloaded to mean \'not yet initialised\' NOTE: this function is experimental and may change or be removed without notice. PADLIST * CvPADLIST(CV *cv)','name' => 'CvPADLIST'},'HvNAMEUTF8' => {'text' => 'Returns true if the name is in UTF8 encoding. unsigned char HvNAMEUTF8(HV *stash)','name' => 'HvNAMEUTF8'},'sv_catpvf_mg_nocontext' => {'text' => '','name' => 'sv_catpvf_mg_nocontext'},'reg_named_buff_all' => {'text' => '','name' => 'reg_named_buff_all'},'PerlIO_close' => {'text' => '','name' => 'PerlIO_close'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. void EXTEND(SP, int nitems)','name' => 'EXTEND'},'newOP' => {'text' => 'Constructs, checks, and returns an op of any base type (any type that has no extra fields). I is the opcode. I gives the eight bits of C, and, shifted up eight bits, the eight bits of C. OP * newOP(I32 type, I32 flags)','name' => 'newOP'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(const UV u)','name' => 'newSVuv'},'gv_fetchmeth' => {'text' => 'Like L, but lacks a flags parameter. GV* gv_fetchmeth(HV* stash, const char* name, STRLEN len, I32 level)','name' => 'gv_fetchmeth'},'op_refcnt_lock' => {'text' => '','name' => 'op_refcnt_lock'},'gv_fetchmeth_pvn_autoload' => {'text' => 'Same as gv_fetchmeth_pvn(), 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 C. For an autoloaded subroutine without a stub, GvCV() of the result may be zero. Currently, the only significant value for C is SVf_UTF8. GV* gv_fetchmeth_pvn_autoload(HV* stash, const char* name, STRLEN len, I32 level, U32 flags)','name' => 'gv_fetchmeth_pvn_autoload'},'newGVgen' => {'text' => '','name' => 'newGVgen'},'sv_does' => {'text' => 'Like L, but doesn\'t take a C parameter. bool sv_does(SV* sv, const char *const name)','name' => 'sv_does'},'delimcpy' => {'text' => '','name' => 'delimcpy'},'newLOOPOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a loop. This is only a loop in the control flow through the op tree; it does not have the heavyweight loop structure that allows exiting the loop by C and suchlike. I gives the eight bits of C for the top-level op, except that some bits will be set automatically as required. I supplies the expression controlling loop iteration, and I supplies the body of the loop; they are consumed by this function and become part of the constructed op tree. I is currently unused and should always be 1. OP * newLOOPOP(I32 flags, I32 debuggable, OP *expr, OP *block)','name' => 'newLOOPOP'},'reg_named_buff_firstkey' => {'text' => '','name' => 'reg_named_buff_firstkey'},'free_global_struct' => {'text' => '','name' => 'free_global_struct'},'uvuni_to_utf8' => {'text' => '','name' => 'uvuni_to_utf8'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part attributable to C. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'PerlIO_tell' => {'text' => '','name' => 'PerlIO_tell'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a string and disables all other OK bits, and leaves the UTF-8 status as it was. void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic after a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'},'SvTRUE' => {'text' => 'Returns a boolean indicating whether Perl would evaluate the SV as true or false. See SvOK() for a defined/undefined test. Handles \'get\' magic unless the scalar is already SvPOK, SvIOK or SvNOK (the public, not the private flags). bool SvTRUE(SV* sv)','name' => 'SvTRUE'},'regdump' => {'text' => '','name' => 'regdump'},'my_pclose' => {'text' => '','name' => 'my_pclose'},'hv_iternext_flags' => {'text' => 'Returns entries from a hash iterator. See C and C. The C 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 C<&PL_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 *hv, I32 flags)','name' => 'hv_iternext_flags'},'is_utf8_string_loclen' => {'text' => 'Like L() but stores the location of the failure (in the case of "utf8ness failure") or the location C+C (in the case of "utf8ness success") in the C, and the number of UTF-8 encoded characters in the C. See also L() and L(). bool is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el)','name' => 'is_utf8_string_loclen'},'call_method' => {'text' => '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)','name' => 'call_method'},'BhkENABLE' => {'text' => 'Re-enable an entry in this BHK structure, by setting the appropriate flag. I is a preprocessor token indicating which entry to enable. This will assert (under -DDEBUGGING) if the entry doesn\'t contain a valid pointer. NOTE: this function is experimental and may change or be removed without notice. void BhkENABLE(BHK *hk, which)','name' => 'BhkENABLE'},'sys_init' => {'text' => '','name' => 'sys_init'},'perl_parse' => {'text' => 'Tells a Perl interpreter to parse a Perl script. See L. int perl_parse(PerlInterpreter *my_perl, XSINIT_t xsinit, int argc, char** argv, char** env)','name' => 'perl_parse'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory the av uses to store its list of scalars. If any destructors are triggered as a result, the av itself may be freed when this function returns. Perl equivalent: C<@myarray = ();>. void av_clear(AV *av)','name' => 'av_clear'},'sv_force_normal' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. See also C. void sv_force_normal(SV *sv)','name' => 'sv_force_normal'},'av_unshift' => {'text' => '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. Perl equivalent: C void av_unshift(AV *av, I32 num)','name' => 'av_unshift'},'save_set_svflags' => {'text' => '','name' => 'save_set_svflags'},'SvREFCNT_inc_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you know I is not NULL. Since we don\'t have to check the NULLness, it\'s faster and smaller. SV* SvREFCNT_inc_NN(SV* sv)','name' => 'SvREFCNT_inc_NN'},'sys_term' => {'text' => '','name' => 'sys_term'},'is_utf8_xidfirst' => {'text' => '','name' => 'is_utf8_xidfirst'},'re_intuit_start' => {'text' => '','name' => 're_intuit_start'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. UV SvUVX(SV* sv)','name' => 'SvUVX'},'hv_copy_hints_hv' => {'text' => 'A specialised version of L for copying C<%^H>. I must be a pointer to a hash (which may have C<%^H> magic, but should be generally non-magical), or C (interpreted as an empty hash). The content of I is copied to a new hash, which has the C<%^H>-specific magic added to it. A pointer to the new hash is returned. HV * hv_copy_hints_hv(HV *ohv)','name' => 'hv_copy_hints_hv'},'do_pmop_dump' => {'text' => '','name' => 'do_pmop_dump'},'sv_utf8_decode' => {'text' => 'If the PV of the SV is an octet sequence in UTF-8 and contains a multiple-byte character, the C flag is turned on so that it looks like a character. If the PV contains only single-byte characters, the C flag stays off. Scans PV for validity and returns false if the PV is invalid UTF-8. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_decode(SV *const sv)','name' => 'sv_utf8_decode'},'op_refcnt_unlock' => {'text' => '','name' => 'op_refcnt_unlock'},'hv_stores' => {'text' => 'Like C, but takes a literal string instead of a string/length pair and omits the hash parameter. SV** hv_stores(HV* tb, const char* key, NULLOK SV* val)','name' => 'hv_stores'},'eval_sv' => {'text' => 'Tells Perl to C the string in the SV. It supports the same flags as C, with the obvious exception of G_EVAL. See L. NOTE: the perl_ form of this function is deprecated. I32 eval_sv(SV* sv, I32 flags)','name' => 'eval_sv'},'SvNV_nomg' => {'text' => 'Like C but doesn\'t process magic. NV SvNV_nomg(SV* sv)','name' => 'SvNV_nomg'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'sv_utf8_upgrade_nomg' => {'text' => 'Like sv_utf8_upgrade, but doesn\'t do magic on C. STRLEN sv_utf8_upgrade_nomg(SV *sv)','name' => 'sv_utf8_upgrade_nomg'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'GIMME' => {'text' => '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','name' => 'GIMME'},'my_snprintf' => {'text' => 'The C library C functionality, if available and standards-compliant (uses C, actually). However, if the C is not available, will unfortunately use the unsafe C which can overrun the buffer (there is an overrun check, but that may be too late). Consider using C instead, or getting C. int my_snprintf(char *buffer, const Size_t len, const char *format, ...)','name' => 'my_snprintf'},'newLOGOP' => {'text' => 'Constructs, checks, and returns a logical (flow control) op. I is the opcode. I gives the eight bits of C, except that C will be set automatically, and, shifted up eight bits, the eight bits of C, except that the bit with value 1 is automatically set. I supplies the expression controlling the flow, and I supplies the side (alternate) chain of ops; they are consumed by this function and become part of the constructed op tree. OP * newLOGOP(I32 type, I32 flags, OP *first, OP *other)','name' => 'newLOGOP'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. bool SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'gp_ref' => {'text' => '','name' => 'gp_ref'},'save_op' => {'text' => '','name' => 'save_op'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter *my_perl)','name' => 'perl_construct'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. bool SvUOK(SV* sv)','name' => 'SvUOK'},'newWHENOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C block. I supplies the test expression, and I supplies the block that will be executed if the test evaluates to true; they are consumed by this function and become part of the constructed op tree. I will be interpreted DWIMically, often as a comparison against C<$_>, and may be null to generate a C block. OP * newWHENOP(OP *cond, OP *block)','name' => 'newWHENOP'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic and operator overloading. void sv_dec(SV *const sv)','name' => 'sv_dec'},'pv_display' => {'text' => 'Similar to pv_escape(dsv,pv,cur,pvlim,PERL_PV_ESCAPE_QUOTE); except that an additional "\\0" will be appended to the string when len > cur and pv[cur] is "\\0". Note that the final string may be up to 7 chars longer than pvlim. char* pv_display(SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)','name' => 'pv_display'},'newHVREF' => {'text' => '','name' => 'newHVREF'},'sv_2pvbyte_nolen' => {'text' => 'Return a pointer to the byte-encoded representation of the SV. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'is_uni_space' => {'text' => '','name' => 'is_uni_space'},'PerlIO_fileno' => {'text' => '','name' => 'PerlIO_fileno'},'uvchr_to_utf8' => {'text' => 'Adds the UTF-8 representation of the Native code point C to the end of the string C; C should have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvchr_to_utf8(d, uv); is the recommended wide native character-aware way of saying *(d++) = uv; U8* uvchr_to_utf8(U8 *d, UV uv)','name' => 'uvchr_to_utf8'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the specified character is a digit in the platform\'s native character set. Variants C and C are identical to C. bool isDIGIT(char ch)','name' => 'isDIGIT'},'call_atexit' => {'text' => '','name' => 'call_atexit'},'is_utf8_alpha' => {'text' => '','name' => 'is_utf8_alpha'},'my_bzero' => {'text' => '','name' => 'my_bzero'},'newCONSTSUB' => {'text' => 'See L. CV* newCONSTSUB(HV* stash, const char* name, SV* sv)','name' => 'newCONSTSUB'},'SvSHARE' => {'text' => 'Arranges for sv to be shared between threads if a suitable module has been loaded. void SvSHARE(SV* sv)','name' => 'SvSHARE'},'vwarner' => {'text' => '','name' => 'vwarner'},'sortsv' => {'text' => 'Sort an array. Here is an example: sortsv(AvARRAY(av), av_len(av)+1, Perl_sv_cmp_locale); Currently this always uses mergesort. See sortsv_flags for a more flexible routine. void sortsv(SV** array, size_t num_elts, SVCOMPARE_t cmp)','name' => 'sortsv'},'cophh_store_pvs' => {'text' => 'Like L, but takes a literal string instead of a string/length pair, and no precomputed hash. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_store_pvs(const COPHH *cophh, const char *key, SV *value, U32 flags)','name' => 'cophh_store_pvs'},'sys_intern_clear' => {'text' => '','name' => 'sys_intern_clear'},'my_ntohl' => {'text' => '','name' => 'my_ntohl'},'doref' => {'text' => '','name' => 'doref'},'scan_bin' => {'text' => 'For backwards compatibility. Use C instead. NV scan_bin(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_bin'},'Nullcv' => {'text' => 'Null CV pointer. (deprecated - use C<(CV *)NULL> instead)','name' => 'Nullcv'},'sv_catpvs_nomg' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_catpvs_nomg(SV* sv, const char* s)','name' => 'sv_catpvs_nomg'},'lex_bufutf8' => {'text' => 'Indicates whether the octets in the lexer buffer (Llinestr>) should be interpreted as the UTF-8 encoding of Unicode characters. If not, they should be interpreted as Latin-1 characters. This is analogous to the C flag for scalars. In UTF-8 mode, it is not guaranteed that the lexer buffer actually contains valid UTF-8. Lexing code must be robust in the face of invalid encoding. The actual C flag of the Llinestr> scalar is significant, but not the whole story regarding the input character encoding. Normally, when a file is being read, the scalar contains octets and its C flag is off, but the octets should be interpreted as UTF-8 if the C pragma is in effect. During a string eval, however, the scalar may have the C flag on, and in this case its octets should be interpreted as UTF-8 unless the C pragma is in effect. This logic may change in the future; use this function instead of implementing the logic yourself. NOTE: this function is experimental and may change or be removed without notice. bool lex_bufutf8()','name' => 'lex_bufutf8'},'MULTICALL' => {'text' => 'Make a lightweight callback. See L. MULTICALL;','name' => 'MULTICALL'},'debprofdump' => {'text' => '','name' => 'debprofdump'},'SvPVbyte' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'is_uni_lower' => {'text' => '','name' => 'is_uni_lower'},'savesharedpvs' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpvs(const char* s)','name' => 'savesharedpvs'},'sys_init3' => {'text' => '','name' => 'sys_init3'},'gv_fetchmeth_pv' => {'text' => 'Exactly like L, but takes a nul-terminated string instead of a string/length pair. GV* gv_fetchmeth_pv(HV* stash, const char* name, I32 level, U32 flags)','name' => 'gv_fetchmeth_pv'},'PerlIO_stdout' => {'text' => '','name' => 'PerlIO_stdout'},'XS_INTERNAL' => {'text' => 'Macro to declare an XSUB and its C parameter list without exporting the symbols. This is handled by C and generally preferable over exporting the XSUB symbols unnecessarily.','name' => 'XS_INTERNAL'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'SvPVutf8x' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'sv_2cv' => {'text' => 'Using various gambits, try to get a CV from an SV; in addition, try if possible to set C<*st> and C<*gvp> to the stash and GV associated with it. The flags in C are passed to gv_fetchsv. CV* sv_2cv(SV* sv, HV **const st, GV **const gvp, const I32 lref)','name' => 'sv_2cv'},'gp_free' => {'text' => '','name' => 'gp_free'},'SvPV_force_nomg' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. Doesn\'t process magic. char* SvPV_force_nomg(SV* sv, STRLEN len)','name' => 'SvPV_force_nomg'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. Will also turn off the UTF-8 status. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'save_destructor_x' => {'text' => '','name' => 'save_destructor_x'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'hv_fetch' => {'text' => 'Returns the SV which corresponds to the specified key in the hash. The absolute value of C is the length of the key. If C is negative the key is assumed to be in UTF-8-encoded Unicode. 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 an C. See L for more information on how to use this function on tied hashes. SV** hv_fetch(HV *hv, const char *key, I32 klen, I32 lval)','name' => 'hv_fetch'},'sv_pvbyte' => {'text' => 'Use C instead. char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'XCPT_TRY_START' => {'text' => 'Starts a try block. See L.','name' => 'XCPT_TRY_START'},'sv_unref_flags' => {'text' => '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. The C argument can contain C to force the reference count to be decremented (otherwise the decrementing is conditional on the reference count being different from one or the reference being a readonly SV). See C. void sv_unref_flags(SV *const ref, const U32 flags)','name' => 'sv_unref_flags'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'hv_scalar' => {'text' => 'Evaluates the hash in scalar context and returns the result. Handles magic when the hash is tied. SV* hv_scalar(HV *hv)','name' => 'hv_scalar'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV *sv, SV *nsv, const char *key, I32 klen)','name' => 'mg_copy'},'save_I16' => {'text' => '','name' => 'save_I16'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C flag on this RV; give the referred-to SV C magic if it hasn\'t already; and push a back-reference to this RV onto the array of backreferences associated with that magic. If the RV is magical, set magic will be called after the RV is cleared. SV* sv_rvweaken(SV *const sv)','name' => 'sv_rvweaken'},'grok_oct' => {'text' => 'converts a string representing an octal number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an 8 or 9 will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). If C is set in I<*flags> then the octal number may use \'_\' characters to separate digits. UV grok_oct(const char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_oct'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'newSVpvn' => {'text' => 'Creates a new SV and copies a buffer into it, which may contain NUL characters (C<\\0>) and other binary data. The reference count for the SV is set to 1. Note that if C is zero, Perl will create a zero length (Perl) string. You are responsible for ensuring that the source buffer is at least C bytes long. If the C argument is NULL the new SV will be undefined. SV* newSVpvn(const char *const s, const STRLEN len)','name' => 'newSVpvn'},'scan_hex' => {'text' => 'For backwards compatibility. Use C instead. NV scan_hex(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_hex'},'unpackstring' => {'text' => 'The engine implementing unpack() Perl function. C puts the extracted list items on the stack and returns the number of elements. Issue C before and C after the call to this function. I32 unpackstring(const char *pat, const char *patend, const char *s, const char *strend, U32 flags)','name' => 'unpackstring'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV *av, I32 key)','name' => 'av_extend'},'sv_peek' => {'text' => '','name' => 'sv_peek'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. You may call C or C 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 C, so you must not discard your iterator immediately else the entry will leak - call C to trigger the resource deallocation. HE* hv_iternext(HV *hv)','name' => 'hv_iternext'},'hv_store_ent' => {'text' => '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. Effectively a successful hv_store_ent takes ownership of one reference to C. 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 C; unlike C it does not take ownership of it, so maintaining the correct reference count on C 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 L for more information on how to use this function on tied hashes. HE* hv_store_ent(HV *hv, SV *key, SV *val, U32 hash)','name' => 'hv_store_ent'},'hv_eiter_set' => {'text' => '','name' => 'hv_eiter_set'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package. See C. HV* gv_stashsv(SV* sv, I32 flags)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'form' => {'text' => '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, ...)','name' => 'form'},'instr' => {'text' => '','name' => 'instr'},'pregexec' => {'text' => '','name' => 'pregexec'},'is_utf8_string' => {'text' => 'Returns true if the first C bytes of string C form a valid UTF-8 string, false otherwise. If C is 0, it will be calculated using C (which means if you use this option, that C has to have a terminating NUL byte). Note that all characters being ASCII constitute \'a valid UTF-8 string\'. See also L(), L(), and L(). bool is_utf8_string(const U8 *s, STRLEN len)','name' => 'is_utf8_string'},'croak_xs_usage' => {'text' => 'A specialised variant of C for emitting the usage message for xsubs croak_xs_usage(cv, "eee_yow"); works out the package name and subroutine name from C, and then calls C. Hence if C is C<&ouch::awk>, it would call C as: Perl_croak(aTHX_ "Usage: %"SVf"::%"SVf"(%s)", "ouch" "awk", "eee_yow"); void croak_xs_usage(const CV *const cv, const char *const params)','name' => 'croak_xs_usage'},'sv_insert' => {'text' => 'Inserts a string at the specified offset/length within the SV. Similar to the Perl substr() function. Handles get magic. void sv_insert(SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen)','name' => 'sv_insert'},'SvPOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a character string. U32 SvPOK(SV* sv)','name' => 'SvPOK'},'sv_destroyable' => {'text' => 'Dummy routine which reports that object can be destroyed when there is no sharing module present. It ignores its single SV argument, and returns \'true\'. Exists to avoid test for a NULL function pointer and because it could potentially warn under some level of strict-ness. bool sv_destroyable(SV *sv)','name' => 'sv_destroyable'},'save_aelem_flags' => {'text' => '','name' => 'save_aelem_flags'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C. It is the same as using the more explicit XS_EXTERNAL macro.','name' => 'XS'},'gv_check' => {'text' => '','name' => 'gv_check'},'sv_setpvn' => {'text' => 'Copies a string into an SV. The C parameter indicates the number of bytes to be copied. If the C argument is NULL the SV will become undefined. Does not handle \'set\' magic. See C. void sv_setpvn(SV *const sv, const char *const ptr, const STRLEN len)','name' => 'sv_setpvn'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'op_linklist' => {'text' => 'This function is the implementation of the L macro. It should not be called directly. OP* op_linklist(OP *o)','name' => 'op_linklist'},'newSVrv' => {'text' => '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 *const rv, const char *const classname)','name' => 'newSVrv'},'cast_i32' => {'text' => '','name' => 'cast_i32'},'is_utf8_posix_digit' => {'text' => '','name' => 'is_utf8_posix_digit'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'stashpv_hvname_match' => {'text' => '','name' => 'stashpv_hvname_match'},'sv_dup_inc' => {'text' => '','name' => 'sv_dup_inc'},'newMYSUB' => {'text' => '','name' => 'newMYSUB'},'PoisonWith' => {'text' => 'Fill up memory with a byte pattern (a byte repeated over and over again) that hopefully catches attempts to access uninitialized memory. void PoisonWith(void* dest, int nitems, type, U8 byte)','name' => 'PoisonWith'},'av_create_and_unshift_one' => {'text' => 'Unshifts an SV onto the beginning of the array, creating the array if necessary. A small internal helper function to remove a commonly duplicated idiom. NOTE: this function is experimental and may change or be removed without notice. SV** av_create_and_unshift_one(AV **const avp, SV *const val)','name' => 'av_create_and_unshift_one'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'bytes_cmp_utf8' => {'text' => 'Compares the sequence of characters (stored as octets) in C, C with the sequence of characters (stored as UTF-8) in C, C. Returns 0 if they are equal, -1 or -2 if the first string is less than the second string, +1 or +2 if the first string is greater than the second string. -1 or +1 is returned if the shorter string was identical to the start of the longer string. -2 or +2 is returned if the was a difference between characters within the strings. int bytes_cmp_utf8(const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen)','name' => 'bytes_cmp_utf8'},'seed' => {'text' => '','name' => 'seed'},'pad_findmy_pvs' => {'text' => 'Exactly like L, but takes a literal string instead of a string/length pair. PADOFFSET pad_findmy_pvs(const char *name, U32 flags)','name' => 'pad_findmy_pvs'},'is_uni_lower_lc' => {'text' => '','name' => 'is_uni_lower_lc'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C to type C if necessary, then adds a new magic item of type C to the head of the magic list. See C (which C now calls) for a description of the handling of the C and C arguments. You need to use C to add magic to SvREADONLY SVs and also to add more than one instance of the same \'how\'. void sv_magic(SV *const sv, SV *const obj, const int how, const char *const name, const I32 namlen)','name' => 'sv_magic'},'sv_utf8_upgrade_flags' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes are invariant in UTF-8. If C has C bit set, will C on C if appropriate, else not. Returns the number of bytes in the converted string C and C are implemented in terms of this function. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade_flags(SV *const sv, const I32 flags)','name' => 'sv_utf8_upgrade_flags'},'do_open9' => {'text' => '','name' => 'do_open9'},'magic_dump' => {'text' => '','name' => 'magic_dump'},'sv_catpvs_mg' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_catpvs_mg(SV* sv, const char* s)','name' => 'sv_catpvs_mg'},'sv_setpvs_mg' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_setpvs_mg(SV* sv, const char* s)','name' => 'sv_setpvs_mg'},'gv_fetchfile_flags' => {'text' => '','name' => 'gv_fetchfile_flags'},'SvREFCNT_inc_void' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value. The macro doesn\'t need to return a meaningful value. void SvREFCNT_inc_void(SV* sv)','name' => 'SvREFCNT_inc_void'},'leave_scope' => {'text' => '','name' => 'leave_scope'},'newSTATEOP' => {'text' => 'Constructs a state op (COP). The state op is normally a C op, but will be a C op if debugging is enabled for currently-compiled code. The state op is populated from L (or L). If I. GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'SvGROW' => {'text' => '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)','name' => 'SvGROW'},'dMULTICALL' => {'text' => 'Declare local variables for a multicall. See L. dMULTICALL;','name' => 'dMULTICALL'},'sv_catpv' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpv(SV *const sv, const char* ptr)','name' => 'sv_catpv'},'fprintf_nocontext' => {'text' => '','name' => 'fprintf_nocontext'},'sv_len' => {'text' => 'Returns the length of the string in the SV. Handles magic and type coercion. See also C, which gives raw access to the xpv_cur slot. STRLEN sv_len(SV *const sv)','name' => 'sv_len'},'PerlIO_stderr' => {'text' => '','name' => 'PerlIO_stderr'},'sv_pvutf8' => {'text' => 'Use the C macro instead char* sv_pvutf8(SV *sv)','name' => 'sv_pvutf8'},'SvPVbyte_nolen' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_nolen(SV* sv)','name' => 'SvPVbyte_nolen'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L. LEAVE;','name' => 'LEAVE'},'mess' => {'text' => 'Take a sprintf-style format pattern and argument list. These are used to generate a string message. If the message does not end with a newline, then it will be extended with some indication of the current location in the code, as described for L. Normally, the resulting message is returned in a new mortal SV. During global destruction a single SV may be shared between uses of this function. SV * mess(const char *pat, ...)','name' => 'mess'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See C.','name' => 'SVt_PVAV'},'hv_delete_ent' => {'text' => 'Deletes a key/value pair in the hash. The value SV is removed from the hash, made mortal, and returned to the caller. The C value will normally be zero; if set to G_DISCARD then NULL will be returned. NULL will also be returned if the key is not found. C can be a valid precomputed hash value, or 0 to ask for it to be computed. SV* hv_delete_ent(HV *hv, SV *keysv, I32 flags, U32 hash)','name' => 'hv_delete_ent'},'PL_keyword_plugin' => {'text' => 'Function pointer, pointing at a function used to handle extended keywords. The function should be declared as int keyword_plugin_function(pTHX_ char *keyword_ptr, STRLEN keyword_len, OP **op_ptr) The function is called from the tokeniser, whenever a possible keyword is seen. C points at the word in the parser\'s input buffer, and C gives its length; it is not null-terminated. The function is expected to examine the word, and possibly other state such as L<%^H|perlvar/%^H>, to decide whether it wants to handle it as an extended keyword. If it does not, the function should return C, and the normal parser process will continue. If the function wants to handle the keyword, it first must parse anything following the keyword that is part of the syntax introduced by the keyword. See L for details. When a keyword is being handled, the plugin function must build a tree of C structures, representing the code that was parsed. The root of the tree must be stored in C<*op_ptr>. The function then returns a constant indicating the syntactic role of the construct that it has parsed: C if it is a complete statement, or C if it is an expression. Note that a statement construct cannot be used inside an expression (except via C and similar), and an expression is not a complete statement (it requires at least a terminating semicolon). When a keyword is handled, the plugin function may also have (compile-time) side effects. It may modify C<%^H>, define functions, and so on. Typically, if side effects are the main purpose of a handler, it does not wish to generate any ops to be included in the normal compilation. In this case it is still required to supply an op tree, but it suffices to generate a single null op. That\'s how the C<*PL_keyword_plugin> function needs to behave overall. Conventionally, however, one does not completely replace the existing handler function. Instead, take a copy of C before assigning your own function pointer to it. Your handler function should look for keywords that it is interested in and handle those. Where it is not interested, it should call the saved plugin function, passing on the arguments it received. Thus C actually points at a chain of handler functions, all of which have an opportunity to handle keywords, and only the last function in the chain (built into the Perl core) will normally return C. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_keyword_plugin'},'LINKLIST' => {'text' => 'Given the root of an optree, link the tree in execution order using the C pointers and return the first op executed. If this has already been done, it will not be redone, and C<< o->op_next >> will be returned. If C<< o->op_next >> is not already set, I should be at least an C. OP* LINKLIST(OP *o)','name' => 'LINKLIST'},'utf8_to_uvuni_buf' => {'text' => 'Returns the Unicode code point of the first character in the string C which is assumed to be in UTF-8 encoding; C points to 1 beyond the end of C. C will be set to the length, in bytes, of that character. This function should only be used when the returned UV is considered an index into the Unicode semantic tables (e.g. swashes). If C does not point to a well-formed UTF-8 character and UTF8 warnings are enabled, zero is returned and C<*retlen> is set (if C isn\'t NULL) to -1. If those warnings are off, the computed value if well-defined (or the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen> is set (if C isn\'t NULL) so that (S + C<*retlen>>) is the next possible position in C that could begin a non-malformed character. See L for details on when the REPLACEMENT CHARACTER is returned. UV utf8_to_uvuni_buf(const U8 *s, const U8 *send, STRLEN *retlen)','name' => 'utf8_to_uvuni_buf'},'cast_iv' => {'text' => '','name' => 'cast_iv'},'savesvpv' => {'text' => 'A version of C/C which gets the string to duplicate from the passed in SV using C char* savesvpv(SV* sv)','name' => 'savesvpv'},'CLASS' => {'text' => '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','name' => 'CLASS'},'newAVREF' => {'text' => '','name' => 'newAVREF'},'foldEQ_latin1' => {'text' => '','name' => 'foldEQ_latin1'},'HeKLEN' => {'text' => '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)','name' => 'HeKLEN'},'sv_pvn_force_flags' => {'text' => 'Get a sensible string out of the SV somehow. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You normally want to use the various wrapper macros instead: see C and C char* sv_pvn_force_flags(SV *const sv, STRLEN *const lp, const I32 flags)','name' => 'sv_pvn_force_flags'},'sv_setpvf_mg_nocontext' => {'text' => '','name' => 'sv_setpvf_mg_nocontext'},'parse_termexpr' => {'text' => 'Parse a Perl term expression. This may contain operators of precedence down to the assignment operators. The expression must be followed (and thus terminated) either by a comma or lower-precedence operator or by something that would normally terminate an expression such as semicolon. If I includes C then the expression is optional, otherwise it is mandatory. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed and the lexical context for the expression. The op tree representing the expression is returned. If an optional expression is absent, a null pointer is returned, otherwise the pointer will be non-null. If an error occurs in parsing or compilation, in most cases a valid op tree is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. Some compilation errors, however, will throw an exception immediately. NOTE: this function is experimental and may change or be removed without notice. OP * parse_termexpr(U32 flags)','name' => 'parse_termexpr'},'mPUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void mPUSHi(IV iv)','name' => 'mPUSHi'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHn(NV nv)','name' => 'PUSHn'},'to_utf8_title' => {'text' => 'Convert the UTF-8 encoded character at C

to its titlecase version and store that in UTF-8 in C and its length in bytes in C. Note that the C needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the titlecase version may be longer than the original character. The first character of the titlecased version is returned (but note, as explained above, that there may be more.) The character at C

is assumed by this routine to be well-formed. UV to_utf8_title(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_title'},'PerlIO_unread' => {'text' => '','name' => 'PerlIO_unread'},'gv_fullname' => {'text' => '','name' => 'gv_fullname'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. SV PL_sv_yes','name' => 'PL_sv_yes'},'pregfree' => {'text' => '','name' => 'pregfree'},'sv_nosharing' => {'text' => 'Dummy routine which "shares" an SV when there is no sharing module present. Or "locks" it. Or "unlocks" it. In other words, ignores its single SV argument. 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 *sv)','name' => 'sv_nosharing'},'ck_entersub_args_list' => {'text' => 'Performs the default fixup of the arguments part of an C op tree. This consists of applying list context to each of the argument ops. This is the standard treatment used on a call marked with C<&>, or a method call, or a call through a subroutine reference, or any other call where the callee can\'t be identified at compile time, or a call where the callee has no prototype. OP * ck_entersub_args_list(OP *entersubop)','name' => 'ck_entersub_args_list'},'ck_warner' => {'text' => '','name' => 'ck_warner'},'is_ascii_string' => {'text' => 'Returns true if the first C bytes of the string C are the same whether or not the string is encoded in UTF-8 (or UTF-EBCDIC on EBCDIC machines). That is, if they are invariant. On ASCII-ish machines, only ASCII characters fit this definition, hence the function\'s name. If C is 0, it will be calculated using C. See also L(), L(), and L(). bool is_ascii_string(const U8 *s, STRLEN len)','name' => 'is_ascii_string'},'SvUTF8_off' => {'text' => 'Unsets the UTF-8 status of an SV (the data is not changed, just the flag). Do not use frivolously. void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'sv_dec_nomg' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion if necessary. Handles operator overloading. Skips handling \'get\' magic. void sv_dec_nomg(SV *const sv)','name' => 'sv_dec_nomg'},'looks_like_number' => {'text' => 'Test if the content of an SV looks like a number (or is a number). C and C are treated as numbers (so will not issue a non-numeric warning), even if your atof() doesn\'t grok them. Get-magic is ignored. I32 looks_like_number(SV *const sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpv_mg(SV *const sv, const char *const ptr)','name' => 'sv_catpv_mg'},'save_vptr' => {'text' => '','name' => 'save_vptr'},'OP_NAME' => {'text' => 'Return the name of the provided OP. For core ops this looks up the name from the op_type; for custom ops from the op_ppaddr. const char * OP_NAME(OP *o)','name' => 'OP_NAME'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'mro_get_private_data' => {'text' => '','name' => 'mro_get_private_data'},'XS_APIVERSION_BOOTCHECK' => {'text' => 'Macro to verify that the perl api version an XS module has been compiled against matches the api version of the perl interpreter it\'s being loaded into. XS_APIVERSION_BOOTCHECK;','name' => 'XS_APIVERSION_BOOTCHECK'},'hv_delayfree_ent' => {'text' => '','name' => 'hv_delayfree_ent'},'sv_setpvf' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Does not handle \'set\' magic. See C. void sv_setpvf(SV *const sv, const char *const pat, ...)','name' => 'sv_setpvf'},'custom_op_register' => {'text' => 'Register a custom op. See L. NOTE: this function must be explicitly called as Perl_custom_op_register with an aTHX_ parameter. void Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop)','name' => 'custom_op_register'},'scan_num' => {'text' => '','name' => 'scan_num'},'save_int' => {'text' => '','name' => 'save_int'},'call_sv' => {'text' => '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, VOL I32 flags)','name' => 'call_sv'},'SVt_PV' => {'text' => 'Pointer type flag for scalars. See C.','name' => 'SVt_PV'},'strGT' => {'text' => '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)','name' => 'strGT'},'is_uni_alnum' => {'text' => '','name' => 'is_uni_alnum'},'mXPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary and mortalizes the SV. Does not use C. See also C and C. void mXPUSHs(SV* sv)','name' => 'mXPUSHs'},'POPl' => {'text' => 'Pops a long off the stack. long POPl','name' => 'POPl'},'init_i18nl14n' => {'text' => '','name' => 'init_i18nl14n'},'scan_version' => {'text' => 'Returns a pointer to the next character after the parsed version string, as well as upgrading the passed in SV to an RV. Function must be called with an already existing SV like sv = newSV(0); s = scan_version(s, SV *sv, bool qv); Performs some preprocessing to the string to ensure that it has the correct characteristics of a version. Flags the object if it contains an underscore (which denotes this is an alpha version). The boolean qv denotes that the version should be interpreted as if it had multiple decimals, even if it doesn\'t. const char* scan_version(const char *s, SV *rv, bool qv)','name' => 'scan_version'},'hv_common_key_len' => {'text' => '','name' => 'hv_common_key_len'},'get_cv' => {'text' => 'Uses C to get the length of C, then calls C. NOTE: the perl_ form of this function is deprecated. CV* get_cv(const char* name, I32 flags)','name' => 'get_cv'},'vnumify' => {'text' => 'Accepts a version object and returns the normalized floating point representation. Call like: sv = vnumify(rv); NOTE: you can pass either the object directly or the SV contained within the RV. The SV returned has a refcount of 1. SV* vnumify(SV *vs)','name' => 'vnumify'},'SvIOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains an integer. Checks the B setting. Use C instead. U32 SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the stack. void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'ptr_table_free' => {'text' => '','name' => 'ptr_table_free'},'SvUNLOCK' => {'text' => 'Releases a mutual exclusion lock on sv if a suitable module has been loaded. void SvUNLOCK(SV* sv)','name' => 'SvUNLOCK'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C. int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV (using C). The new SV is marked as mortal. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_mortalcopy(SV *const oldsv)','name' => 'sv_mortalcopy'},'is_utf8_space' => {'text' => '','name' => 'is_utf8_space'},'cophh_fetch_sv' => {'text' => 'Like L, but takes a Perl scalar instead of a string/length pair. NOTE: this function is experimental and may change or be removed without notice. SV * cophh_fetch_sv(const COPHH *cophh, SV *key, U32 hash, U32 flags)','name' => 'cophh_fetch_sv'},'sv_catpvn_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_catpvn_nomg(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn_nomg'},'newHVhv' => {'text' => '','name' => 'newHVhv'},'newSVpvs_flags' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV* newSVpvs_flags(const char* s, U32 flags)','name' => 'newSVpvs_flags'},'savepvn' => {'text' => 'Perl\'s version of what C would be if it existed. Returns a pointer to a newly allocated string which is a duplicate of the first C bytes from C, plus a trailing NUL byte. The memory allocated for the new string can be freed with the C function. char* savepvn(const char* pv, I32 len)','name' => 'savepvn'},'pad_findmy_sv' => {'text' => 'Exactly like L, but takes the name string in the form of an SV instead of a string/length pair. PADOFFSET pad_findmy_sv(SV *name, U32 flags)','name' => 'pad_findmy_sv'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized. This relies on the fact that uninitialized array elements are set to C<&PL_sv_undef>. Perl equivalent: C. bool av_exists(AV *av, I32 key)','name' => 'av_exists'},'cophh_delete_sv' => {'text' => 'Like L, but takes a Perl scalar instead of a string/length pair. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_delete_sv(const COPHH *cophh, SV *key, U32 hash, U32 flags)','name' => 'cophh_delete_sv'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C. STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'sv_2nv_flags' => {'text' => 'Return the num value of an SV, doing any necessary string or integer conversion. If flags includes SV_GMAGIC, does an mg_get() first. Normally used via the C and C macros. NV sv_2nv_flags(SV *const sv, const I32 flags)','name' => 'sv_2nv_flags'},'gv_init' => {'text' => 'The old form of gv_init_pvn(). It does not work with UTF8 strings, as it has no flags parameter. If the C parameter is set, the GV_ADDMULTI flag will be passed to gv_init_pvn(). void gv_init(GV* gv, HV* stash, const char* name, STRLEN len, int multi)','name' => 'gv_init'},'sv_bless' => {'text' => '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 *const sv, HV *const stash)','name' => 'sv_bless'},'cv_set_call_checker' => {'text' => 'Sets the function that will be used to fix up a call to I. Specifically, the function is applied to an C op tree for a subroutine call, not marked with C<&>, where the callee can be identified at compile time as I. The C-level function pointer is supplied in I, and an SV argument for it is supplied in I. The function is intended to be called in this manner: entersubop = ckfun(aTHX_ entersubop, namegv, ckobj); In this call, I is a pointer to the C op, which may be replaced by the check function, and I is a GV supplying the name that should be used by the check function to refer to the callee of the C op if it needs to emit any diagnostics. It is permitted to apply the check function in non-standard situations, such as to a call to a different subroutine or to a method call. The current setting for a particular CV can be retrieved by L. void cv_set_call_checker(CV *cv, Perl_call_checker ckfun, SV *ckobj)','name' => 'cv_set_call_checker'},'save_ary' => {'text' => '','name' => 'save_ary'},'sv_2io' => {'text' => 'Using various gambits, try to get an IO from an SV: the IO slot if its a GV; or the recursive result if we\'re an RV; or the IO slot of the symbol named after the PV if we\'re a string. \'Get\' magic is ignored on the sv passed in, but will be called on C if sv is an RV. IO* sv_2io(SV *const sv)','name' => 'sv_2io'},'SvMAGIC_set' => {'text' => 'Set the value of the MAGIC pointer in sv to val. See C. void SvMAGIC_set(SV* sv, MAGIC* val)','name' => 'SvMAGIC_set'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the specified character is an alphabetic character in the platform\'s native character set. See the L for an explanation of variants C and C. bool isALPHA(char ch)','name' => 'isALPHA'},'newSVhek' => {'text' => 'Creates a new SV from the hash key structure. It will generate scalars that point to the shared string table where possible. Returns a new (undefined) SV if the hek is NULL. SV* newSVhek(const HEK *const hek)','name' => 'newSVhek'},'taint_env' => {'text' => '','name' => 'taint_env'},'Nullhv' => {'text' => 'Null HV pointer. (deprecated - use C<(HV *)NULL> instead)','name' => 'Nullhv'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV. All of the following SvREFCNT_inc* macros are optimized versions of SvREFCNT_inc, and can be replaced with SvREFCNT_inc. SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'newGVgen_flags' => {'text' => '','name' => 'newGVgen_flags'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C. svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'block_gimme' => {'text' => '','name' => 'block_gimme'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'XPUSHmortal' => {'text' => 'Push a new mortal SV onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void XPUSHmortal()','name' => 'XPUSHmortal'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'SvVOK' => {'text' => 'Returns a boolean indicating whether the SV contains a v-string. bool SvVOK(SV* sv)','name' => 'SvVOK'},'whichsig_pvn' => {'text' => '','name' => 'whichsig_pvn'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvf_mg(SV *const sv, const char *const pat, ...)','name' => 'sv_setpvf_mg'},'my_chsize' => {'text' => '','name' => 'my_chsize'},'newLISTOP' => {'text' => 'Constructs, checks, and returns an op of any list type. I is the opcode. I gives the eight bits of C, except that C will be set automatically if required. I and I supply up to two ops to be direct children of the list op; they are consumed by this function and become part of the constructed op tree. OP * newLISTOP(I32 type, I32 flags, OP *first, OP *last)','name' => 'newLISTOP'},'sv_setref_pv' => {'text' => '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 have a reference count of 1, and the RV will be returned. 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 *const rv, const char *const classname, void *const pv)','name' => 'sv_setref_pv'},'fbm_compile' => {'text' => '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)','name' => 'fbm_compile'},'SvNIOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a number, integer or double. Checks the B setting. Use C instead. U32 SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'PERL_SYS_TERM' => {'text' => 'Provides system-specific clean up of the C runtime environment after running Perl interpreters. This should be called only once, after freeing any remaining Perl interpreters. void PERL_SYS_TERM()','name' => 'PERL_SYS_TERM'},'is_uni_alnum_lc' => {'text' => '','name' => 'is_uni_alnum_lc'},'mro_register' => {'text' => 'Registers a custom mro plugin. See L for details. void mro_register(const struct mro_alg *mro)','name' => 'mro_register'},'vnewSVpvf' => {'text' => '','name' => 'vnewSVpvf'},'rv2cv_op_cv' => {'text' => 'Examines an op, which is expected to identify a subroutine at runtime, and attempts to determine at compile time which subroutine it identifies. This is normally used during Perl compilation to determine whether a prototype can be applied to a function call. I is the op being considered, normally an C op. A pointer to the identified subroutine is returned, if it could be determined statically, and a null pointer is returned if it was not possible to determine statically. Currently, the subroutine can be identified statically if the RV that the C is to operate on is provided by a suitable C or C op. A C op is suitable if the GV\'s CV slot is populated. A C op is suitable if the constant value must be an RV pointing to a CV. Details of this process may change in future versions of Perl. If the C op has the C flag set then no attempt is made to identify the subroutine statically: this flag is used to suppress compile-time magic on a subroutine call, forcing it to use default runtime behaviour. If I has the bit C set, then the handling of a GV reference is modified. If a GV was examined and its CV slot was found to be empty, then the C op has the C flag set. If the op is not optimised away, and the CV slot is later populated with a subroutine having a prototype, that flag eventually triggers the warning "called too early to check prototype". If I has the bit C set, then instead of returning a pointer to the subroutine it returns a pointer to the GV giving the most appropriate name for the subroutine in this context. Normally this is just the C of the subroutine, but for an anonymous (C) subroutine that is referenced through a GV it will be the referencing GV. The resulting C is cast to C to be returned. A null pointer is returned as usual if there is no statically-determinable subroutine. CV * rv2cv_op_cv(OP *cvop, U32 flags)','name' => 'rv2cv_op_cv'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide UTF-8 bytes as a single character. Handles magic and type coercion. STRLEN sv_len_utf8(SV *const sv)','name' => 'sv_len_utf8'},'PerlIO_set_cnt' => {'text' => '','name' => 'PerlIO_set_cnt'},'SvREFCNT_inc_simple_void' => {'text' => 'Same as SvREFCNT_inc_simple, but can only be used if you don\'t need the return value. The macro doesn\'t need to return a meaningful value. void SvREFCNT_inc_simple_void(SV* sv)','name' => 'SvREFCNT_inc_simple_void'},'cx_dup' => {'text' => '','name' => 'cx_dup'},'hv_clear_placeholders' => {'text' => '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 *hv)','name' => 'hv_clear_placeholders'},'dAX' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dAX;','name' => 'dAX'},'SvRV_set' => {'text' => 'Set the value of the RV pointer in sv to val. See C. void SvRV_set(SV* sv, SV* val)','name' => 'SvRV_set'},'grok_number' => {'text' => '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)','name' => 'grok_number'},'csighandler' => {'text' => '','name' => 'csighandler'},'SvIVx' => {'text' => 'Coerces the given SV to an integer and returns it. Guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. IV SvIVx(SV* sv)','name' => 'SvIVx'},'grok_numeric_radix' => {'text' => 'Scan and skip for a numeric decimal separator (radix). bool grok_numeric_radix(const char **sp, const char *send)','name' => 'grok_numeric_radix'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the stack. void XST_mNO(int pos)','name' => 'XST_mNO'},'gp_dup' => {'text' => '','name' => 'gp_dup'},'sv_derived_from_pv' => {'text' => 'Exactly like L, but takes a nul-terminated string instead of a string/length pair. bool sv_derived_from_pv(SV* sv, const char *const name, U32 flags)','name' => 'sv_derived_from_pv'},'savepvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. char* savepvs(const char* s)','name' => 'savepvs'},'SvSTASH_set' => {'text' => 'Set the value of the STASH pointer in sv to val. See C. void SvSTASH_set(SV* sv, HV* val)','name' => 'SvSTASH_set'},'sv_catpv_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_catpv_nomg(SV* sv, const char* ptr)','name' => 'sv_catpv_nomg'},'ZeroD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * ZeroD(void* dest, int nitems, type)','name' => 'ZeroD'},'sv_collxfrm' => {'text' => 'This calls C with the SV_GMAGIC flag. See C. char* sv_collxfrm(SV *const sv, STRLEN *const nxp)','name' => 'sv_collxfrm'},'swash_fetch' => {'text' => '','name' => 'swash_fetch'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'op_lvalue' => {'text' => 'Propagate lvalue ("modifiable") context to an op and its children. I represents the context type, roughly based on the type of op that would do the modifying, although C is represented by OP_NULL, because it has no op type of its own (it is signalled by a flag on the lvalue op). This function detects things that can\'t be modified, such as C<$x+1>, and generates errors for them. For example, C<$x+1 = 2> would cause it to be called with an op of type OP_ADD and a C argument of OP_SASSIGN. It also flags things that need to behave specially in an lvalue context, such as C<$$x = 5> which might have to vivify a reference in C<$x>. NOTE: this function is experimental and may change or be removed without notice. OP * op_lvalue(OP *o, I32 type)','name' => 'op_lvalue'},'dirp_dup' => {'text' => '','name' => 'dirp_dup'},'is_uni_upper' => {'text' => '','name' => 'is_uni_upper'},'gv_stashpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. HV* gv_stashpvs(const char* name, I32 create)','name' => 'gv_stashpvs'},'Zero' => {'text' => '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)','name' => 'Zero'},'vcmp' => {'text' => 'Version object aware cmp. Both operands must already have been converted into version objects. int vcmp(SV *lhv, SV *rhv)','name' => 'vcmp'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_iv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. IV sv_iv(SV* sv)','name' => 'sv_iv'},'PL_parser-Ebufend' => {'text' => 'Direct pointer to the end of the chunk of text currently being lexed, the end of the lexer buffer. This is equal to Clinestr) + SvCUR(PL_parser-Elinestr)>. A NUL character (zero octet) is always located at the end of the buffer, and does not count as part of the buffer\'s contents. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_parser-Ebufend'},'PerlIO_error' => {'text' => '','name' => 'PerlIO_error'},'is_utf8_graph' => {'text' => '','name' => 'is_utf8_graph'},'pv_escape' => {'text' => 'Escapes at most the first "count" chars of pv and puts the results into dsv such that the size of the escaped string will not exceed "max" chars and will not contain any incomplete escape sequences. If flags contains PERL_PV_ESCAPE_QUOTE then any double quotes in the string will also be escaped. Normally the SV will be cleared before the escaped string is prepared, but when PERL_PV_ESCAPE_NOCLEAR is set this will not occur. If PERL_PV_ESCAPE_UNI is set then the input string is treated as Unicode, if PERL_PV_ESCAPE_UNI_DETECT is set then the input string is scanned using C to determine if it is Unicode. If PERL_PV_ESCAPE_ALL is set then all input chars will be output using C<\\x01F1> style escapes, otherwise if PERL_PV_ESCAPE_NONASCII is set, only chars above 127 will be escaped using this style; otherwise, only chars above 255 will be so escaped; other non printable chars will use octal or common escaped patterns like C<\\n>. Otherwise, if PERL_PV_ESCAPE_NOBACKSLASH then all chars below 255 will be treated as printable and will be output as literals. If PERL_PV_ESCAPE_FIRSTCHAR is set then only the first char of the string will be escaped, regardless of max. If the output is to be in hex, then it will be returned as a plain hex sequence. Thus the output will either be a single char, an octal escape sequence, a special escape like C<\\n> or a hex value. If PERL_PV_ESCAPE_RE is set then the escape char used will be a \'%\' and not a \'\\\\\'. This is because regexes very often contain backslashed sequences, whereas \'%\' is not a particularly common character in patterns. Returns a pointer to the escaped text as held by dsv. char* pv_escape(SV *dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags)','name' => 'pv_escape'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'my_exit' => {'text' => '','name' => 'my_exit'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C.','name' => 'SVt_PVCV'},'ss_dup' => {'text' => '','name' => 'ss_dup'},'gv_handler' => {'text' => '','name' => 'gv_handler'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpviv_mg(SV *const sv, const IV iv)','name' => 'sv_setpviv_mg'},'debstack' => {'text' => '','name' => 'debstack'},'sv_2bool' => {'text' => 'This macro is only used by sv_true() or its macro equivalent, and only if the latter\'s argument is neither SvPOK, SvIOK nor SvNOK. It calls sv_2bool_flags with the SV_GMAGIC flag. bool sv_2bool(SV *const sv)','name' => 'sv_2bool'},'lex_grow_linestr' => {'text' => 'Reallocates the lexer buffer (Llinestr>) to accommodate at least I octets (including terminating NUL). Returns a pointer to the reallocated buffer. This is necessary before making any direct modification of the buffer that would increase its length. L provides a more convenient way to insert text into the buffer. Do not use C or C directly on Clinestr>; this function updates all of the lexer\'s variables that point directly into the buffer. NOTE: this function is experimental and may change or be removed without notice. char * lex_grow_linestr(STRLEN len)','name' => 'lex_grow_linestr'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'sv_inc_nomg' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion if necessary. Handles operator overloading. Skips handling \'get\' magic. void sv_inc_nomg(SV *const sv)','name' => 'sv_inc_nomg'},'sv_newmortal' => {'text' => 'Creates a new null SV which is mortal. The reference count of the SV is set to 1. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_newmortal()','name' => 'sv_newmortal'},'is_utf8_cntrl' => {'text' => '','name' => 'is_utf8_cntrl'},'SvOOK' => {'text' => 'Returns a U32 indicating whether the pointer to the string buffer is offset. 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 actually C bytes before SvPVX. This offset used to be stored in SvIVX, but is now stored within the spare part of the buffer. U32 SvOOK(SV* sv)','name' => 'SvOOK'},'SvPV_set' => {'text' => 'Set the value of the PV pointer in sv to val. See C. void SvPV_set(SV* sv, char* val)','name' => 'SvPV_set'},'mess_sv' => {'text' => 'Expands a message, intended for the user, to include an indication of the current location in the code, if the message does not already appear to be complete. C is the initial message or object. If it is a reference, it will be used as-is and will be the result of this function. Otherwise it is used as a string, and if it already ends with a newline, it is taken to be complete, and the result of this function will be the same string. If the message does not end with a newline, then a segment such as C will be appended, and possibly other clauses indicating the current state of execution. The resulting message will end with a dot and a newline. Normally, the resulting message is returned in a new mortal SV. During global destruction a single SV may be shared between uses of this function. If C is true, then the function is permitted (but not required) to modify and return C instead of allocating a new SV. SV * mess_sv(SV *basemsg, bool consume)','name' => 'mess_sv'},'is_utf8_xidcont' => {'text' => '','name' => 'is_utf8_xidcont'},'hv_clear' => {'text' => 'Frees the all the elements of a hash, leaving it empty. The XS equivalent of C<%hash = ()>. See also L. If any destructors are triggered as a result, the hv itself may be freed. void hv_clear(HV *hv)','name' => 'hv_clear'},'get_hv' => {'text' => 'Returns the HV of the specified Perl hash. C are passed to C. If C is set and the Perl variable does not exist then it will be created. If C is zero 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 flags)','name' => 'get_hv'},'safesysrealloc' => {'text' => '','name' => 'safesysrealloc'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES;','name' => 'XSRETURN_YES'},'PoisonNew' => {'text' => 'PoisonWith(0xAB) for catching access to allocated but uninitialized memory. void PoisonNew(void* dest, int nitems, type)','name' => 'PoisonNew'},'op_scope' => {'text' => 'Wraps up an op tree with some additional ops so that at runtime a dynamic scope will be created. The original ops run in the new dynamic scope, and then, provided that they exit normally, the scope will be unwound. The additional ops used to create and unwind the dynamic scope will normally be an C/C pair, but a C op may be used instead if the ops are simple enough to not need the full dynamic scope structure. NOTE: this function is experimental and may change or be removed without notice. OP * op_scope(OP *o)','name' => 'op_scope'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'sv_nv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. NV sv_nv(SV* sv)','name' => 'sv_nv'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHu(UV uv)','name' => 'PUSHu'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. (Uses C.) SV* newSVsv(SV *const old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C. void hv_magic(HV *hv, GV *gv, int how)','name' => 'hv_magic'},'deb_nocontext' => {'text' => '','name' => 'deb_nocontext'},'new_stackinfo' => {'text' => '','name' => 'new_stackinfo'},'save_aelem' => {'text' => '','name' => 'save_aelem'},'PerlIO_clearerr' => {'text' => '','name' => 'PerlIO_clearerr'},'cx_dump' => {'text' => '','name' => 'cx_dump'},'hv_placeholders_p' => {'text' => '','name' => 'hv_placeholders_p'},'XCPT_TRY_END' => {'text' => 'Ends a try block. See L.','name' => 'XCPT_TRY_END'},'HeKEY' => {'text' => '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)','name' => 'HeKEY'},'SvEND' => {'text' => 'Returns a pointer to the spot just after the last character in the string which is in the SV, where there is usually a trailing null (even though Perl scalars do not strictly require it). See C. Access the character as *(SvEND(sv)). Warning: If C is equal to C, then C points to unallocated memory. char* SvEND(SV* sv)','name' => 'SvEND'},'save_delete' => {'text' => '','name' => 'save_delete'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C, C or C for void, scalar or list context, respectively. See L for a usage example. U32 GIMME_V','name' => 'GIMME_V'},'re_compile' => {'text' => '','name' => 're_compile'},'sv_setsv_flags' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. If the C parameter has the C bit set, will C on C if appropriate, else not. If the C parameter has the C bit set then the buffers of temps will not be stolen. and C are implemented in terms of this function. You probably want to use one of the assortment of wrappers, such as C, C, C and C. This is the primary function for copying scalars, and most other copy-ish functions and macros use this underneath. void sv_setsv_flags(SV *dstr, SV *sstr, const I32 flags)','name' => 'sv_setsv_flags'},'gv_init_pvn' => {'text' => 'Converts a scalar into a typeglob. This is an incoercible typeglob; assigning a reference to it will assign to one of its slots, instead of overwriting it as happens with typeglobs created by SvSetSV. Converting any scalar that is SvOK() may produce unpredictable results and is reserved for perl\'s internal use. C is the scalar to be converted. C is the parent stash/package, if any. C and C give the name. The name must be unqualified; that is, it must not include the package name. If C is a stash element, it is the caller\'s responsibility to ensure that the name passed to this function matches the name of the element. If it does not match, perl\'s internal bookkeeping will get out of sync. C can be set to SVf_UTF8 if C is a UTF8 string, or the return value of SvUTF8(sv). It can also take the GV_ADDMULTI flag, which means to pretend that the GV has been seen before (i.e., suppress "Used once" warnings). void gv_init_pvn(GV* gv, HV* stash, const char* name, STRLEN len, U32 flags)','name' => 'gv_init_pvn'},'newATTRSUB' => {'text' => '','name' => 'newATTRSUB'},'gv_fetchmeth_sv' => {'text' => 'Exactly like L, but takes the name string in the form of an SV instead of a string/length pair. GV* gv_fetchmeth_sv(HV* stash, SV* namesv, I32 level, U32 flags)','name' => 'gv_fetchmeth_sv'},'Copy' => {'text' => '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)','name' => 'Copy'},'newSVpv_share' => {'text' => 'Like C, but takes a nul-terminated string instead of a string/length pair. SV* newSVpv_share(const char* s, U32 hash)','name' => 'newSVpv_share'},'sv_taint' => {'text' => 'Taint an SV. Use C instead. void sv_taint(SV* sv)','name' => 'sv_taint'},'utf16_to_utf8' => {'text' => '','name' => 'utf16_to_utf8'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains a signed integer. bool SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'deb' => {'text' => '','name' => 'deb'},'PL_parser-Elinestart' => {'text' => 'Points to the start of the current line inside the lexer buffer. This is useful for indicating at which column an error occurred, and not much else. This must be updated by any lexing code that consumes a newline; the function L handles this detail. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_parser-Elinestart'},'pad_add_name_pvn' => {'text' => 'Allocates a place in the currently-compiling pad for a named lexical variable. Stores the name and other metadata in the name part of the pad, and makes preparations to manage the variable\'s lexical scoping. Returns the offset of the allocated pad slot. I/I specify the variable\'s name, including leading sigil. If I is non-null, the name is for a typed lexical, and this identifies the type. If I is non-null, it\'s a lexical reference to a package variable, and this identifies the package. The following flags can be OR\'ed together: padadd_OUR redundantly specifies if it\'s a package var padadd_STATE variable will retain value persistently padadd_NO_DUP_CHECK skip check for lexical shadowing PADOFFSET pad_add_name_pvn(const char *namepv, STRLEN namelen, U32 flags, HV *typestash, HV *ourstash)','name' => 'pad_add_name_pvn'},'he_dup' => {'text' => '','name' => 'he_dup'},'gv_fullname3' => {'text' => '','name' => 'gv_fullname3'},'mPUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void mPUSHu(UV uv)','name' => 'mPUSHu'},'gv_fetchmeth_pvn' => {'text' => '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. Currently, the only significant value for C is SVf_UTF8. 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_pvn(HV* stash, const char* name, STRLEN len, I32 level, U32 flags)','name' => 'gv_fetchmeth_pvn'},'cophh_new_empty' => {'text' => 'Generate and return a fresh cop hints hash containing no entries. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_new_empty()','name' => 'cophh_new_empty'},'sv_derived_from_pvn' => {'text' => 'Returns a boolean indicating whether the SV is derived from the specified class I. To check derivation at the Perl level, call C as a normal Perl method. Currently, the only significant value for C is SVf_UTF8. bool sv_derived_from_pvn(SV* sv, const char *const name, const STRLEN len, U32 flags)','name' => 'sv_derived_from_pvn'},'op_append_list' => {'text' => 'Concatenate the lists of ops contained directly within two list-type ops, returning the combined list. I and I are the list-type ops to concatenate. I specifies the intended opcode for the list. If either I or I is not already a list of the right type, it will be upgraded into one. If either I or I is null, the other is returned unchanged. OP * op_append_list(I32 optype, OP *first, OP *last)','name' => 'op_append_list'},'repeatcpy' => {'text' => '','name' => 'repeatcpy'},'do_spawn_nowait' => {'text' => '','name' => 'do_spawn_nowait'},'sv_setsv_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_setsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_setsv_nomg'},'load_module_nocontext' => {'text' => '','name' => 'load_module_nocontext'},'re_intuit_string' => {'text' => '','name' => 're_intuit_string'},'do_magic_dump' => {'text' => '','name' => 'do_magic_dump'},'HvNAMELEN' => {'text' => 'Returns the length of the stash\'s name. STRLEN HvNAMELEN(HV *stash)','name' => 'HvNAMELEN'},'XPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHp(char* str, STRLEN len)','name' => 'XPUSHp'},'av_create_and_push' => {'text' => 'Push an SV onto the end of the array, creating the array if necessary. A small internal helper function to remove a commonly duplicated idiom. NOTE: this function is experimental and may change or be removed without notice. void av_create_and_push(AV **const avp, SV *const val)','name' => 'av_create_and_push'},'sv_utf8_encode' => {'text' => 'Converts the PV of an SV to UTF-8, but then turns the C flag off so that it looks like octets again. void sv_utf8_encode(SV *const sv)','name' => 'sv_utf8_encode'},'SvUTF8_on' => {'text' => 'Turn on the UTF-8 status of an SV (the data is not changed, just the flag). Do not use frivolously. void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_does_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of an SV. bool sv_does_pv(SV* sv, const char *const name, U32 flags)','name' => 'sv_does_pv'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvn_mg(SV *const sv, const char *const ptr, const STRLEN len)','name' => 'sv_setpvn_mg'},'toLOWER' => {'text' => 'Converts the specified character to lowercase in the platform\'s native character set, if possible; otherwise returns the input character itself. char toLOWER(char ch)','name' => 'toLOWER'},'av_iter_p' => {'text' => '','name' => 'av_iter_p'},'prescan_version' => {'text' => 'Validate that a given string can be parsed as a version object, but doesn\'t actually perform the parsing. Can use either strict or lax validation rules. Can optionally set a number of hint variables to save the parsing code some time when tokenizing. const char* prescan_version(const char *s, bool strict, const char** errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha)','name' => 'prescan_version'},'PerlIO_write' => {'text' => '','name' => 'PerlIO_write'},'hv_ksplit' => {'text' => '','name' => 'hv_ksplit'},'new_version' => {'text' => 'Returns a new version object based on the passed in SV: SV *sv = new_version(SV *ver); Does not alter the passed in ver SV. See "upg_version" if you want to upgrade the SV. SV* new_version(SV *ver)','name' => 'new_version'},'PerlIO_seek' => {'text' => '','name' => 'PerlIO_seek'},'free_tmps' => {'text' => '','name' => 'free_tmps'},'parse_arithexpr' => {'text' => 'Parse a Perl arithmetic expression. This may contain operators of precedence down to the bit shift operators. The expression must be followed (and thus terminated) either by a comparison or lower-precedence operator or by something that would normally terminate an expression such as semicolon. If I includes C then the expression is optional, otherwise it is mandatory. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed and the lexical context for the expression. The op tree representing the expression is returned. If an optional expression is absent, a null pointer is returned, otherwise the pointer will be non-null. If an error occurs in parsing or compilation, in most cases a valid op tree is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. Some compilation errors, however, will throw an exception immediately. NOTE: this function is experimental and may change or be removed without notice. OP * parse_arithexpr(U32 flags)','name' => 'parse_arithexpr'},'Nullav' => {'text' => 'Null AV pointer. (deprecated - use C<(AV *)NULL> instead)','name' => 'Nullav'},'sv_pvbyten' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten(SV *sv, STRLEN *lp)','name' => 'sv_pvbyten'},'isOCTAL' => {'text' => 'Returns a boolean indicating whether the specified character is an octal digit, [0-7] in the platform\'s native character set. Variants C and C are identical to C. bool isOCTAL(char ch)','name' => 'isOCTAL'},'sv_copypv' => {'text' => 'Copies a stringified representation of the source SV into the destination SV. Automatically performs any necessary mg_get and coercion of numeric values into strings. Guaranteed to preserve UTF8 flag even from overloaded objects. Similar in nature to sv_2pv[_flags] but operates directly on an SV instead of just the string. Mostly uses sv_2pv_flags to do its work, except when that would lose the UTF-8\'ness of the PV. void sv_copypv(SV *const dsv, SV *const ssv)','name' => 'sv_copypv'},'rsignal' => {'text' => '','name' => 'rsignal'},'sv_pv' => {'text' => 'Use the C macro instead char* sv_pv(SV *sv)','name' => 'sv_pv'},'is_uni_xdigit' => {'text' => '','name' => 'is_uni_xdigit'},'perl_alloc_using' => {'text' => '','name' => 'perl_alloc_using'},'pv_pretty' => {'text' => 'Converts a string into something presentable, handling escaping via pv_escape() and supporting quoting and ellipses. If the PERL_PV_PRETTY_QUOTE flag is set then the result will be double quoted with any double quotes in the string escaped. Otherwise if the PERL_PV_PRETTY_LTGT flag is set then the result be wrapped in angle brackets. If the PERL_PV_PRETTY_ELLIPSES flag is set and not all characters in string were output then an ellipsis C<...> will be appended to the string. Note that this happens AFTER it has been quoted. If start_color is non-null then it will be inserted after the opening quote (if there is one) but before the escaped text. If end_color is non-null then it will be inserted after the escaped text but before any quotes or ellipses. Returns a pointer to the prettified text as held by dsv. char* pv_pretty(SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags)','name' => 'pv_pretty'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setnv_mg(SV *const sv, const NV num)','name' => 'sv_setnv_mg'},'utf8_to_bytes' => {'text' => 'Converts a string C of length C from UTF-8 into native byte encoding. Unlike L, this over-writes the original string, and updates C to contain the new length. Returns zero on failure, setting C to -1. If you need a copy of the string, see L. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_setref_pvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV * sv_setref_pvs(const char* s)','name' => 'sv_setref_pvs'},'re_dup_guts' => {'text' => '','name' => 're_dup_guts'},'si_dup' => {'text' => '','name' => 'si_dup'},'uvuni_to_utf8_flags' => {'text' => 'Adds the UTF-8 representation of the code point C to the end of the string C; C should have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvuni_to_utf8_flags(d, uv, flags); or, in most cases, d = uvuni_to_utf8(d, uv); (which is equivalent to) d = uvuni_to_utf8_flags(d, uv, 0); This is the recommended Unicode-aware way of saying *(d++) = uv; This function will convert to UTF-8 (and not warn) even code points that aren\'t legal Unicode or are problematic, unless C contains one or more of the following flags: If C is a Unicode surrogate code point and UNICODE_WARN_SURROGATE is set, the function will raise a warning, provided UTF8 warnings are enabled. If instead UNICODE_DISALLOW_SURROGATE is set, the function will fail and return NULL. If both flags are set, the function will both warn and return NULL. The UNICODE_WARN_NONCHAR and UNICODE_DISALLOW_NONCHAR flags correspondingly affect how the function handles a Unicode non-character. And, likewise for the UNICODE_WARN_SUPER and UNICODE_DISALLOW_SUPER flags, and code points that are above the Unicode maximum of 0x10FFFF. Code points above 0x7FFF_FFFF (which are even less portable) can be warned and/or disallowed even if other above-Unicode code points are accepted by the UNICODE_WARN_FE_FF and UNICODE_DISALLOW_FE_FF flags. And finally, the flag UNICODE_WARN_ILLEGAL_INTERCHANGE selects all four of the above WARN flags; and UNICODE_DISALLOW_ILLEGAL_INTERCHANGE selects all four DISALLOW flags. U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)','name' => 'uvuni_to_utf8_flags'},'PL_rpeepp' => {'text' => 'Pointer to the recursive peephole optimiser. This is a function that gets called at the end of compilation of a Perl subroutine (or equivalently independent piece of Perl code) to perform fixups of some ops and to perform small-scale optimisations. The function is called once for each chain of ops linked through their C fields; it is recursively called to handle each side chain. It is passed, as sole parameter, a pointer to the op that is at the head of the chain. It modifies the op tree in place. The peephole optimiser should never be completely replaced. Rather, add code to it by wrapping the existing optimiser. The basic way to do this can be seen in L. If the new code wishes to operate only on ops at a subroutine\'s top level, rather than throughout the structure, it is likely to be more convenient to wrap the L hook. peep_t PL_rpeepp','name' => 'PL_rpeepp'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See L.','name' => 'G_DISCARD'},'newGVREF' => {'text' => '','name' => 'newGVREF'},'XST_mNV' => {'text' => '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)','name' => 'XST_mNV'},'UNDERBAR' => {'text' => 'The SV* corresponding to the $_ variable. Works even if there is a lexical $_ in scope.','name' => 'UNDERBAR'},'newSVOP' => {'text' => 'Constructs, checks, and returns an op of any type that involves an embedded SV. I is the opcode. I gives the eight bits of C. I gives the SV to embed in the op; this function takes ownership of one reference to it. OP * newSVOP(I32 type, I32 flags, SV *sv)','name' => 'newSVOP'},'cophh_fetch_pvn' => {'text' => 'Look up the entry in the cop hints hash I with the key specified by I and I. If I has the C bit set, the key octets are interpreted as UTF-8, otherwise they are interpreted as Latin-1. I is a precomputed hash of the key string, or zero if it has not been precomputed. Returns a mortal scalar copy of the value associated with the key, or C<&PL_sv_placeholder> if there is no value associated with the key. NOTE: this function is experimental and may change or be removed without notice. SV * cophh_fetch_pvn(const COPHH *cophh, const char *keypv, STRLEN keylen, U32 hash, U32 flags)','name' => 'cophh_fetch_pvn'},'pad_sv' => {'text' => 'Get the value at offset I in the current (compiling or executing) pad. Use macro PAD_SV instead of calling this function directly. SV * pad_sv(PADOFFSET po)','name' => 'pad_sv'},'amagic_call' => {'text' => '','name' => 'amagic_call'},'op_free' => {'text' => '','name' => 'op_free'},'SvPVutf8_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_force(SV* sv, STRLEN len)','name' => 'SvPVutf8_force'},'gv_AVadd' => {'text' => '','name' => 'gv_AVadd'},'pop_scope' => {'text' => '','name' => 'pop_scope'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C.','name' => 'SVt_NV'},'my_popen_list' => {'text' => '','name' => 'my_popen_list'},'sv_2uv' => {'text' => '','name' => 'sv_2uv'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and L. void PUSHMARK(SP)','name' => 'PUSHMARK'},'taint_proper' => {'text' => '','name' => 'taint_proper'},'save_generic_pvref' => {'text' => '','name' => 'save_generic_pvref'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. SV* ST(int ix)','name' => 'ST'},'call_pv' => {'text' => '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)','name' => 'call_pv'},'gv_fetchmeth_autoload' => {'text' => 'This is the old form of L, which has no flags parameter. GV* gv_fetchmeth_autoload(HV* stash, const char* name, STRLEN len, I32 level)','name' => 'gv_fetchmeth_autoload'},'save_mortalizesv' => {'text' => '','name' => 'save_mortalizesv'},'sv_pos_b2u' => {'text' => 'Converts the value pointed to by offsetp from a count of bytes from the start of the string, to a count of the equivalent number of UTF-8 chars. Handles magic and type coercion. void sv_pos_b2u(SV *const sv, I32 *const offsetp)','name' => 'sv_pos_b2u'},'sv_utf8_upgrade_flags_grow' => {'text' => '','name' => 'sv_utf8_upgrade_flags_grow'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C.','name' => 'SVt_IV'},'SvIsCOW' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write (either shared hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for COW). bool SvIsCOW(SV* sv)','name' => 'SvIsCOW'},'reentrant_size' => {'text' => '','name' => 'reentrant_size'},'printf_nocontext' => {'text' => '','name' => 'printf_nocontext'},'save_freesv' => {'text' => '','name' => 'save_freesv'},'sv_catsv' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catsv(SV *dstr, SV *sstr)','name' => 'sv_catsv'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'ax' => {'text' => 'Variable which is setup by C to indicate the stack base offset, used by the C, C and C macros. The C macro must be called prior to setup the C variable. I32 ax','name' => 'ax'},'regexec_flags' => {'text' => '','name' => 'regexec_flags'},'pad_add_name_sv' => {'text' => 'Exactly like L, but takes the name string in the form of an SV instead of a string/length pair. PADOFFSET pad_add_name_sv(SV *name, U32 flags, HV *typestash, HV *ourstash)','name' => 'pad_add_name_sv'},'to_utf8_upper' => {'text' => 'Convert the UTF-8 encoded character at C

to its uppercase version and store that in UTF-8 in C and its length in bytes in C. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the uppercase version may be longer than the original character. The first character of the uppercased version is returned (but note, as explained above, that there may be more.) The character at C

is assumed by this routine to be well-formed. UV to_utf8_upper(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_upper'},'SvPVutf8x_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x_force(SV* sv, STRLEN len)','name' => 'SvPVutf8x_force'},'warner_nocontext' => {'text' => '','name' => 'warner_nocontext'},'sv_eq_flags' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. Is UTF-8 and \'use bytes\' aware and coerces its args to strings if necessary. If the flags include SV_GMAGIC, it handles get-magic, too. I32 sv_eq_flags(SV* sv1, SV* sv2, const U32 flags)','name' => 'sv_eq_flags'},'my_htonl' => {'text' => '','name' => 'my_htonl'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHi(IV iv)','name' => 'PUSHi'},'is_uni_digit' => {'text' => '','name' => 'is_uni_digit'},'SvLEN_set' => {'text' => 'Set the actual length of the string which is in the SV. See C. void SvLEN_set(SV* sv, STRLEN len)','name' => 'SvLEN_set'},'new_numeric' => {'text' => '','name' => 'new_numeric'},'to_utf8_lower' => {'text' => 'Convert the UTF-8 encoded character at C

to its lowercase version and store that in UTF-8 in ustrp and its length in bytes in C. Note that the C needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the lowercase version may be longer than the original character. The first character of the lowercased version is returned (but note, as explained above, that there may be more.) The character at C

is assumed by this routine to be well-formed. UV to_utf8_lower(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_lower'},'gv_init_pv' => {'text' => 'Same as gv_init_pvn(), but takes a nul-terminated string for the name instead of separate char * and length parameters. void gv_init_pv(GV* gv, HV* stash, const char* name, U32 flags)','name' => 'gv_init_pv'},'newSVpvf' => {'text' => 'Creates a new SV and initializes it with the string formatted like C. SV* newSVpvf(const char *const pat, ...)','name' => 'newSVpvf'},'doing_taint' => {'text' => '','name' => 'doing_taint'},'save_I8' => {'text' => '','name' => 'save_I8'},'Newxc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. See also C. void Newxc(void* ptr, int nitems, type, cast)','name' => 'Newxc'},'SvIVX' => {'text' => 'Returns the raw value in the SV\'s IV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. IV SvIVX(SV* sv)','name' => 'SvIVX'},'lex_stuff_pvs' => {'text' => 'Like L, but takes a literal string instead of a string/length pair. NOTE: this function is experimental and may change or be removed without notice. void lex_stuff_pvs(const char *pv, U32 flags)','name' => 'lex_stuff_pvs'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L. int perl_destruct(PerlInterpreter *my_perl)','name' => 'perl_destruct'},'is_utf8_idfirst' => {'text' => '','name' => 'is_utf8_idfirst'},'custom_op_name' => {'text' => 'Return the name for a given custom op. This was once used by the OP_NAME macro, but is no longer: it has only been kept for compatibility, and should not be used. const char * custom_op_name(const OP *o)','name' => 'custom_op_name'},'sv_vsetpvf' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Does not handle \'set\' magic. See C. Usually used via its frontend C. void sv_vsetpvf(SV *const sv, const char *const pat, va_list *const args)','name' => 'sv_vsetpvf'},'any_dup' => {'text' => '','name' => 'any_dup'},'XCPT_CATCH' => {'text' => 'Introduces a catch block. See L.','name' => 'XCPT_CATCH'},'regclass_swash' => {'text' => '','name' => 'regclass_swash'},'my_dirfd' => {'text' => '','name' => 'my_dirfd'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the stack. void XST_mYES(int pos)','name' => 'XST_mYES'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. You probably want to use one of the assortment of wrappers, such as C, C, C and C. void sv_setsv(SV *dstr, SV *sstr)','name' => 'sv_setsv'},'PerlIO_stdin' => {'text' => '','name' => 'PerlIO_stdin'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an XSUB\'s aliases was used to invoke it. See L. I32 ix','name' => 'ix'},'XSRETURN_UV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_UV(IV uv)','name' => 'XSRETURN_UV'},'SvREFCNT_inc_simple' => {'text' => 'Same as SvREFCNT_inc, but can only be used with expressions without side effects. Since we don\'t have to store a temporary value, it\'s faster. SV* SvREFCNT_inc_simple(SV* sv)','name' => 'SvREFCNT_inc_simple'},'my_lstat' => {'text' => '','name' => 'my_lstat'},'my_atof' => {'text' => '','name' => 'my_atof'},'savestack_grow_cnt' => {'text' => '','name' => 'savestack_grow_cnt'},'PL_comppad_name' => {'text' => 'During compilation, this points to the array containing the names part of the pad for the currently-compiling code. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_comppad_name'},'SvTRUE_nomg' => {'text' => 'Returns a boolean indicating whether Perl would evaluate the SV as true or false. See SvOK() for a defined/undefined test. Does not handle \'get\' magic. bool SvTRUE_nomg(SV* sv)','name' => 'SvTRUE_nomg'},'vverify' => {'text' => 'Validates that the SV contains valid internal structure for a version object. It may be passed either the version object (RV) or the hash itself (HV). If the structure is valid, it returns the HV. If the structure is invalid, it returns NULL. SV *hv = vverify(sv); Note that it only confirms the bare minimum structure (so as not to get confused by derived classes which may contain additional hash entries): SV* vverify(SV *vs)','name' => 'vverify'},'dXSI32' => {'text' => 'Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. dXSI32;','name' => 'dXSI32'},'dXCPT' => {'text' => 'Set up necessary local variables for exception handling. See L. dXCPT;','name' => 'dXCPT'},'sv_tainted' => {'text' => 'Test an SV for taintedness. Use C instead. bool sv_tainted(SV *const sv)','name' => 'sv_tainted'},'mro_set_private_data' => {'text' => '','name' => 'mro_set_private_data'},'do_gv_dump' => {'text' => '','name' => 'do_gv_dump'},'reg_named_buff_nextkey' => {'text' => '','name' => 'reg_named_buff_nextkey'},'hv_fill' => {'text' => 'Returns the number of hash buckets that happen to be in use. This function is wrapped by the macro C. Previously this value was stored in the HV structure, rather than being calculated on demand. STRLEN hv_fill(HV const *const hv)','name' => 'hv_fill'},'cv_const_sv' => {'text' => 'If C is a constant sub eligible for inlining. returns the constant value returned by the sub. Otherwise, returns NULL. Constant subs can be created with C or as described in L. SV* cv_const_sv(const CV *const cv)','name' => 'cv_const_sv'},'pad_add_name_pvs' => {'text' => 'Exactly like L, but takes a literal string instead of a string/length pair. PADOFFSET pad_add_name_pvs(const char *name, U32 flags, HV *typestash, HV *ourstash)','name' => 'pad_add_name_pvs'},'newSVnv' => {'text' => 'Creates a new SV and copies a floating point value into it. The reference count for the SV is set to 1. SV* newSVnv(const NV n)','name' => 'newSVnv'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry. SV* HeVAL(HE* he)','name' => 'HeVAL'},'HePV' => {'text' => '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. See also C. If you are using C to get values to pass to C to create a new SV, you should consider using C as it is more efficient. char* HePV(HE* he, STRLEN len)','name' => 'HePV'},'hv_free_ent' => {'text' => '','name' => 'hv_free_ent'},'SvGETMAGIC' => {'text' => 'Invokes C on an SV if it has \'get\' magic. This macro evaluates its argument more than once. void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'PL_parser' => {'text' => 'Pointer to a structure encapsulating the state of the parsing operation currently in progress. The pointer can be locally changed to perform a nested parse without interfering with the state of an outer parse. Individual members of C have their own documentation.','name' => 'PL_parser'},'pv_uni_display' => {'text' => 'Build to the scalar C a displayable version of the string C, length C, the displayable version being at most C bytes long (if longer, the rest is truncated and "..." will be appended). The C argument can have UNI_DISPLAY_ISPRINT set to display isPRINT()able characters as themselves, UNI_DISPLAY_BACKSLASH to display the \\\\[nrfta\\\\] as the backslashed versions (like \'\\n\') (UNI_DISPLAY_BACKSLASH is preferred over UNI_DISPLAY_ISPRINT for \\\\). UNI_DISPLAY_QQ (and its alias UNI_DISPLAY_REGEX) have both UNI_DISPLAY_BACKSLASH and UNI_DISPLAY_ISPRINT turned on. The pointer to the PV of the C is returned. char* pv_uni_display(SV *dsv, const U8 *spv, STRLEN len, STRLEN pvlim, UV flags)','name' => 'pv_uni_display'},'init_stacks' => {'text' => '','name' => 'init_stacks'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic and operator overloading. void sv_inc(SV *const sv)','name' => 'sv_inc'},'SvPVbytex_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex_force(SV* sv, STRLEN len)','name' => 'SvPVbytex_force'},'op_prepend_elem' => {'text' => 'Prepend an item to the list of ops contained directly within a list-type op, returning the lengthened list. I is the op to prepend to the list, and I is the list-type op. I specifies the intended opcode for the list. If I is not already a list of the right type, it will be upgraded into one. If either I or I is null, the other is returned unchanged. OP * op_prepend_elem(I32 optype, OP *first, OP *last)','name' => 'op_prepend_elem'},'hv_delete' => {'text' => 'Deletes a key/value pair in the hash. The value\'s SV is removed from the hash, made mortal, and returned to the caller. The absolute value of C is the length of the key. If C is negative the key is assumed to be in UTF-8-encoded Unicode. The C value will normally be zero; if set to G_DISCARD then NULL will be returned. NULL will also be returned if the key is not found. SV* hv_delete(HV *hv, const char *key, I32 klen, I32 flags)','name' => 'hv_delete'},'pad_add_name_pv' => {'text' => 'Exactly like L, but takes a nul-terminated string instead of a string/length pair. PADOFFSET pad_add_name_pv(const char *name, U32 flags, HV *typestash, HV *ourstash)','name' => 'pad_add_name_pv'},'POP_MULTICALL' => {'text' => 'Closing bracket for a lightweight callback. See L. POP_MULTICALL;','name' => 'POP_MULTICALL'},'sv_cat_decode' => {'text' => 'The encoding is assumed to be an Encode object, the PV of the ssv is assumed to be octets in that encoding and decoding the input starts from the position which (PV + *offset) pointed to. The dsv will be concatenated the decoded UTF-8 string from ssv. Decoding will terminate when the string tstr appears in decoding output or the input ends on the PV of the ssv. The value which the offset points will be modified to the last input position on the ssv. Returns TRUE if the terminator was found, else returns FALSE. bool sv_cat_decode(SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen)','name' => 'sv_cat_decode'},'SvIV_set' => {'text' => 'Set the value of the IV pointer in sv to val. It is possible to perform the same function of this macro with an lvalue assignment to C. With future Perls, however, it will be more efficient to use C instead of the lvalue assignment to C. void SvIV_set(SV* sv, IV val)','name' => 'SvIV_set'},'sv_setiv' => {'text' => 'Copies an integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setiv(SV *const sv, const IV num)','name' => 'sv_setiv'},'gv_efullname' => {'text' => '','name' => 'gv_efullname'},'sv_report_used' => {'text' => 'Dump the contents of all SVs not yet freed (debugging aid). void sv_report_used()','name' => 'sv_report_used'},'save_sptr' => {'text' => '','name' => 'save_sptr'},'SvNVX' => {'text' => 'Returns the raw value in the SV\'s NV slot, without checks or conversions. Only use when you are sure SvNOK is true. See also C. NV SvNVX(SV* sv)','name' => 'SvNVX'},'do_open' => {'text' => '','name' => 'do_open'},'regnext' => {'text' => '','name' => 'regnext'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. U32 HeHASH(HE* he)','name' => 'HeHASH'},'SvIOK' => {'text' => 'Returns a U32 value indicating whether the SV contains an integer. U32 SvIOK(SV* sv)','name' => 'SvIOK'},'newANONHASH' => {'text' => '','name' => 'newANONHASH'},'is_utf8_char_buf' => {'text' => 'Returns the number of bytes that comprise the first UTF-8 encoded character in buffer C. C should point to one position beyond the end of the buffer. 0 is returned if C does not point to a complete, valid UTF-8 encoded character. Note that an INVARIANT character (i.e. ASCII on non-EBCDIC machines) is a valid UTF-8 character. STRLEN is_utf8_char_buf(const U8 *buf, const U8 *buf_end)','name' => 'is_utf8_char_buf'},'SvPV_force' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'HeUTF8' => {'text' => 'Returns whether the C value returned by C is encoded in UTF-8, doing any necessary dereferencing of possibly C keys. The value returned will be 0 or non-0, not necessarily 1 (or even a value with any low bits set), so B blindly assign this to a C variable, as C may be a typedef for C. char* HeUTF8(HE* he)','name' => 'HeUTF8'},'newRANGE' => {'text' => 'Constructs and returns a C op, with subordinate C and C ops. I gives the eight bits of C for the C op and, shifted up eight bits, the eight bits of C for both the C and C ops, except that the bit with value 1 is automatically set. I and I supply the expressions controlling the endpoints of the range; they are consumed by this function and become part of the constructed op tree. OP * newRANGE(I32 flags, OP *left, OP *right)','name' => 'newRANGE'},'cophh_delete_pvn' => {'text' => 'Delete a key and its associated value from the cop hints hash I, and returns the modified hash. The returned hash pointer is in general not the same as the hash pointer that was passed in. The input hash is consumed by the function, and the pointer to it must not be subsequently used. Use L if you need both hashes. The key is specified by I and I. If I has the C bit set, the key octets are interpreted as UTF-8, otherwise they are interpreted as Latin-1. I is a precomputed hash of the key string, or zero if it has not been precomputed. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_delete_pvn(COPHH *cophh, const char *keypv, STRLEN keylen, U32 hash, U32 flags)','name' => 'cophh_delete_pvn'},'grok_hex' => {'text' => 'converts a string representing a hex number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0x" or "x" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the hex number may use \'_\' characters to separate digits. UV grok_hex(const char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_hex'},'newRV' => {'text' => '','name' => 'newRV'},'SvLOCK' => {'text' => 'Arranges for a mutual exclusion lock to be obtained on sv if a suitable module has been loaded. void SvLOCK(SV* sv)','name' => 'SvLOCK'},'gv_fetchfile' => {'text' => '','name' => 'gv_fetchfile'},'sv_vsetpvfn' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Usually used via one of its frontends C and C. void sv_vsetpvfn(SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted)','name' => 'sv_vsetpvfn'},'PerlIO_get_cnt' => {'text' => '','name' => 'PerlIO_get_cnt'},'PerlIO_setlinebuf' => {'text' => '','name' => 'PerlIO_setlinebuf'},'utf16_to_utf8_reversed' => {'text' => '','name' => 'utf16_to_utf8_reversed'},'cast_ulong' => {'text' => '','name' => 'cast_ulong'},'to_utf8_case' => {'text' => 'The C

contains the pointer to the UTF-8 string encoding the character that is being converted. This routine assumes that the character at C

is well-formed. The C is a pointer to the character buffer to put the conversion result to. The C is a pointer to the length of the result. The C is a pointer to the swash to use. Both the special and normal mappings are stored in F, and loaded by SWASHNEW, using F. The C (usually, but not always, a multicharacter mapping), is tried first. The C is a string like "utf8::ToSpecLower", which means the hash %utf8::ToSpecLower. The access to the hash is through Perl_to_utf8_case(). The C is a string like "ToLower" which means the swash %utf8::ToLower. UV to_utf8_case(const U8 *p, U8* ustrp, STRLEN *lenp, SV **swashp, const char *normal, const char *special)','name' => 'to_utf8_case'},'set_numeric_local' => {'text' => '','name' => 'set_numeric_local'},'is_utf8_print' => {'text' => '','name' => 'is_utf8_print'},'calloc' => {'text' => '','name' => 'calloc'},'POPpbytex' => {'text' => 'Pops a string off the stack which must consist of bytes i.e. characters < 256. char* POPpbytex','name' => 'POPpbytex'},'cophh_store_sv' => {'text' => 'Like L, but takes a Perl scalar instead of a string/length pair. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_store_sv(const COPHH *cophh, SV *key, U32 hash, SV *value, U32 flags)','name' => 'cophh_store_sv'},'newPMOP' => {'text' => 'Constructs, checks, and returns an op of any pattern matching type. I is the opcode. I gives the eight bits of C and, shifted up eight bits, the eight bits of C. OP * newPMOP(I32 type, I32 flags)','name' => 'newPMOP'},'PL_peepp' => {'text' => 'Pointer to the per-subroutine peephole optimiser. This is a function that gets called at the end of compilation of a Perl subroutine (or equivalently independent piece of Perl code) to perform fixups of some ops and to perform small-scale optimisations. The function is called once for each subroutine that is compiled, and is passed, as sole parameter, a pointer to the op that is the entry point to the subroutine. It modifies the op tree in place. The peephole optimiser should never be completely replaced. Rather, add code to it by wrapping the existing optimiser. The basic way to do this can be seen in L. If the new code wishes to operate on ops throughout the subroutine\'s structure, rather than just at the top level, it is likely to be more convenient to wrap the L hook. peep_t PL_peepp','name' => 'PL_peepp'},'SvSetMagicSV' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV(SV* dsb, SV* ssv)','name' => 'SvSetMagicSV'},'Move' => {'text' => '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)','name' => 'Move'},'set_context' => {'text' => '','name' => 'set_context'},'sv_catpvn_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. If C has the C bit set, will C on C afterwards if appropriate. C and C are implemented in terms of this function. void sv_catpvn_flags(SV *const dstr, const char *sstr, const STRLEN len, const I32 flags)','name' => 'sv_catpvn_flags'},'PerlIO_flush' => {'text' => '','name' => 'PerlIO_flush'},'sv_2iv_flags' => {'text' => 'Return the integer value of an SV, doing any necessary string conversion. If flags includes SV_GMAGIC, does an mg_get() first. Normally used via the C and C macros. IV sv_2iv_flags(SV *const sv, const I32 flags)','name' => 'sv_2iv_flags'},'runops_standard' => {'text' => '','name' => 'runops_standard'},'gv_efullname3' => {'text' => '','name' => 'gv_efullname3'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs. I needs to be static storage, as it is used directly as CvFILE(), without a copy being made.','name' => 'newXS'},'XCPT_RETHROW' => {'text' => 'Rethrows a previously caught exception. See L. XCPT_RETHROW;','name' => 'XCPT_RETHROW'},'mg_dup' => {'text' => '','name' => 'mg_dup'},'cop_hints_fetch_pvs' => {'text' => 'Like L, but takes a literal string instead of a string/length pair, and no precomputed hash. SV * cop_hints_fetch_pvs(const COP *cop, const char *key, U32 flags)','name' => 'cop_hints_fetch_pvs'},'cop_store_label' => {'text' => 'Save a label into a C. You need to set flags to C for a utf-8 label. NOTE: this function is experimental and may change or be removed without notice. void cop_store_label(COP *const cop, const char *label, STRLEN len, U32 flags)','name' => 'cop_store_label'},'PUSHmortal' => {'text' => 'Push a new mortal SV onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void PUSHmortal()','name' => 'PUSHmortal'},'XS_EXTERNAL' => {'text' => 'Macro to declare an XSUB and its C parameter list explicitly exporting the symbols.','name' => 'XS_EXTERNAL'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'sv_dump' => {'text' => '','name' => 'sv_dump'},'pad_tidy' => {'text' => 'Tidy up a pad at the end of compilation of the code to which it belongs. Jobs performed here are: remove most stuff from the pads of anonsub prototypes; give it a @_; mark temporaries as such. I indicates the kind of subroutine: padtidy_SUB ordinary subroutine padtidy_SUBCLONE prototype for lexical closure padtidy_FORMAT format NOTE: this function is experimental and may change or be removed without notice. void pad_tidy(padtidy_type type)','name' => 'pad_tidy'},'OP_DESC' => {'text' => 'Return a short description of the provided OP. const char * OP_DESC(OP *o)','name' => 'OP_DESC'},'strLE' => {'text' => '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)','name' => 'strLE'},'newSVpvn_flags' => {'text' => '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. If the C argument is NULL the new SV will be undefined. Currently the only flag bits accepted are C and C. If C is set, then C is called on the result before returning. If C is set, C is considered to be in UTF-8 and the C flag will be set on the new SV. C is a convenience wrapper for this function, defined as #define newSVpvn_utf8(s, len, u) \\ newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0) SV* newSVpvn_flags(const char *const s, const STRLEN len, const U32 flags)','name' => 'newSVpvn_flags'},'XopFLAGS' => {'text' => 'Return the XOP\'s flags. U32 XopFLAGS(XOP *xop)','name' => 'XopFLAGS'},'sv_compile_2op' => {'text' => '','name' => 'sv_compile_2op'},'SvOK' => {'text' => 'Returns a U32 value indicating whether the value is defined. This is only meaningful for scalars. U32 SvOK(SV* sv)','name' => 'SvOK'},'sv_setref_nv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_nv(SV *const rv, const char *const classname, const NV nv)','name' => 'sv_setref_nv'},'eval_pv' => {'text' => '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)','name' => 'eval_pv'},'lex_stuff_pvn' => {'text' => 'Insert characters into the lexer buffer (Llinestr>), immediately after the current lexing point (Lbufptr>), reallocating the buffer if necessary. This means that lexing code that runs later will see the characters as if they had appeared in the input. It is not recommended to do this as part of normal parsing, and most uses of this facility run the risk of the inserted characters being interpreted in an unintended manner. The string to be inserted is represented by I octets starting at I. These octets are interpreted as either UTF-8 or Latin-1, according to whether the C flag is set in I. The characters are recoded for the lexer buffer, according to how the buffer is currently being interpreted (L). If a string to be inserted is available as a Perl scalar, the L function is more convenient. NOTE: this function is experimental and may change or be removed without notice. void lex_stuff_pvn(const char *pv, STRLEN len, U32 flags)','name' => 'lex_stuff_pvn'},'sv_usepvn_flags' => {'text' => '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. It must be the start of a mallocked block of memory, and not a pointer to the middle of it. The string length, C, must be supplied. By default this function will realloc (i.e. move) the memory pointed to by C, so that pointer should not be freed or used by the programmer after giving it to sv_usepvn, and neither should any pointers from "behind" that pointer (e.g. ptr + 1) be used. If C & SV_SMAGIC is true, will call SvSETMAGIC. If C & SV_HAS_TRAILING_NUL is true, then C must be NUL, and the realloc will be skipped (i.e. the buffer is actually at least 1 byte longer than C, and already meets the requirements for storing in C). void sv_usepvn_flags(SV *const sv, char* ptr, const STRLEN len, const U32 flags)','name' => 'sv_usepvn_flags'},'hv_assert' => {'text' => 'Check that a hash is in an internally consistent state. void hv_assert(HV *hv)','name' => 'hv_assert'},'my_vsnprintf' => {'text' => 'The C library C if available and standards-compliant. However, if if the C is not available, will unfortunately use the unsafe C which can overrun the buffer (there is an overrun check, but that may be too late). Consider using C instead, or getting C. int my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap)','name' => 'my_vsnprintf'},'sv_free' => {'text' => 'Decrement an SV\'s reference count, and if it drops to zero, call C to invoke destructors and free up any memory used by the body; finally, deallocate the SV\'s head itself. Normally called via a wrapper macro C. void sv_free(SV *const sv)','name' => 'sv_free'},'die_nocontext' => {'text' => '','name' => 'die_nocontext'},'hv_eiter_p' => {'text' => '','name' => 'hv_eiter_p'},'SvPVbyte_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_force(SV* sv, STRLEN len)','name' => 'SvPVbyte_force'},'is_utf8_ascii' => {'text' => '','name' => 'is_utf8_ascii'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array is empty. Perl equivalent: C SV* av_pop(AV *av)','name' => 'av_pop'},'reg_named_buff_exists' => {'text' => '','name' => 'reg_named_buff_exists'},'save_bool' => {'text' => '','name' => 'save_bool'},'ckwarn_d' => {'text' => '','name' => 'ckwarn_d'},'croak' => {'text' => 'This is an XS interface to Perl\'s C function. Take a sprintf-style format pattern and argument list. These are used to generate a string message. If the message does not end with a newline, then it will be extended with some indication of the current location in the code, as described for L. The error message will be used as an exception, by default returning control to the nearest enclosing C, but subject to modification by a C<$SIG{__DIE__}> handler. In any case, the C function never returns normally. For historical reasons, if C is null then the contents of C (C<$@>) will be used as an error message or object instead of building an error message from arguments. If you want to throw a non-string object, or build an error message in an SV yourself, it is preferable to use the L function, which does not involve clobbering C. void croak(const char *pat, ...)','name' => 'croak'},'save_freepv' => {'text' => '','name' => 'save_freepv'},'THIS' => {'text' => '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','name' => 'THIS'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually handled by C. void XSRETURN(int nitems)','name' => 'XSRETURN'},'dump_indent' => {'text' => '','name' => 'dump_indent'},'screaminstr' => {'text' => '','name' => 'screaminstr'},'op_append_elem' => {'text' => 'Append an item to the list of ops contained directly within a list-type op, returning the lengthened list. I is the list-type op, and I is the op to append to the list. I specifies the intended opcode for the list. If I is not already a list of the right type, it will be upgraded into one. If either I or I is null, the other is returned unchanged. OP * op_append_elem(I32 optype, OP *first, OP *last)','name' => 'op_append_elem'},'lex_read_unichar' => {'text' => 'Reads the next (Unicode) character in the text currently being lexed. Returns the codepoint (unsigned integer value) of the character read, and moves Lbufptr> past the character, or returns -1 if lexing has reached the end of the input text. To non-destructively examine the next character, use L instead. If the next character is in (or extends into) the next chunk of input text, the next chunk will be read in. Normally the current chunk will be discarded at the same time, but if I includes C then the current chunk will not be discarded. If the input is being interpreted as UTF-8 and a UTF-8 encoding error is encountered, an exception is generated. NOTE: this function is experimental and may change or be removed without notice. I32 lex_read_unichar(U32 flags)','name' => 'lex_read_unichar'},'reginitcolors' => {'text' => '','name' => 'reginitcolors'},'sv_2pv_nolen' => {'text' => 'Like C, but doesn\'t return the length too. You should usually use the macro wrapper C instead. char* sv_2pv_nolen(SV* sv)','name' => 'sv_2pv_nolen'},'get_av' => {'text' => 'Returns the AV of the specified Perl global or package array with the given name (so it won\'t work on lexical variables). C are passed to C. If C is set and the Perl variable does not exist then it will be created. If C is zero and the variable does not exist then NULL is returned. Perl equivalent: C<@{"$name"}>. NOTE: the perl_ form of this function is deprecated. AV* get_av(const char *name, I32 flags)','name' => 'get_av'},'op_contextualize' => {'text' => 'Applies a syntactic context to an op tree representing an expression. I is the op tree, and I must be C, C, or C to specify the context to apply. The modified op tree is returned. OP * op_contextualize(OP *o, I32 context)','name' => 'op_contextualize'},'PoisonFree' => {'text' => 'PoisonWith(0xEF) for catching access to freed memory. void PoisonFree(void* dest, int nitems, type)','name' => 'PoisonFree'},'gv_SVadd' => {'text' => '','name' => 'gv_SVadd'},'hv_common' => {'text' => '','name' => 'hv_common'},'XopENTRY' => {'text' => 'Return a member of the XOP structure. I is a cpp token indicating which entry to return. If the member is not set this will return a default value. The return type depends on I. XopENTRY(XOP *xop, which)','name' => 'XopENTRY'},'newSVREF' => {'text' => '','name' => 'newSVREF'},'toUPPER' => {'text' => 'Converts the specified character to uppercase in the platform\'s native character set, if possible; otherwise returns the input character itself. char toUPPER(char ch)','name' => 'toUPPER'},'sv_catpvs_flags' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_catpvs_flags(SV* sv, const char* s, I32 flags)','name' => 'sv_catpvs_flags'},'is_lvalue_sub' => {'text' => '','name' => 'is_lvalue_sub'},'is_utf8_string_loc' => {'text' => 'Like L but stores the location of the failure (in the case of "utf8ness failure") or the location C+C (in the case of "utf8ness success") in the C. See also L() and L(). bool is_utf8_string_loc(const U8 *s, STRLEN len, const U8 **p)','name' => 'is_utf8_string_loc'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally appending to the currently-stored string. char* sv_gets(SV *const sv, PerlIO *const fp, I32 append)','name' => 'sv_gets'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'pad_add_anon' => {'text' => 'Allocates a place in the currently-compiling pad (via L) for an anonymous function that is lexically scoped inside the currently-compiling function. The function I is linked into the pad, and its C link to the outer scope is weakened to avoid a reference loop. I should be an opcode indicating the type of operation that the pad entry is to support. This doesn\'t affect operational semantics, but is used for debugging. PADOFFSET pad_add_anon(CV *func, I32 optype)','name' => 'pad_add_anon'},'dUNDERBAR' => {'text' => 'Sets up any variable needed by the C macro. It used to define C, but it is currently a noop. However, it is strongly advised to still use it for ensuring past and future compatibility. dUNDERBAR;','name' => 'dUNDERBAR'},'sv_uv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. UV sv_uv(SV* sv)','name' => 'sv_uv'},'ptr_table_split' => {'text' => '','name' => 'ptr_table_split'},'foldEQ_utf8' => {'text' => 'Returns true if the leading portions of the strings C and C (either or both of which may be in UTF-8) are the same case-insensitively; false otherwise. How far into the strings to compare is determined by other input parameters. If C is true, the string C is assumed to be in UTF-8-encoded Unicode; otherwise it is assumed to be in native 8-bit encoding. Correspondingly for C with respect to C. If the byte length C is non-zero, it says how far into C to check for fold equality. In other words, C+C will be used as a goal to reach. The scan will not be considered to be a match unless the goal is reached, and scanning won\'t continue past that goal. Correspondingly for C with respect to C. If C is non-NULL and the pointer it points to is not NULL, that pointer is considered an end pointer beyond which scanning of C will not continue under any circumstances. This means that if both C and C are specified, and C is less than C+C, the match will never be successful because it can never get as far as its goal (and in fact is asserted against). Correspondingly for C with respect to C. At least one of C and C must have a goal (at least one of C and C must be non-zero), and if both do, both have to be reached for a successful match. Also, if the fold of a character is multiple characters, all of them must be matched (see tr21 reference below for \'folding\'). Upon a successful match, if C is non-NULL, it will be set to point to the beginning of the I character of C beyond what was matched. Correspondingly for C and C. For case-insensitiveness, the "casefolding" of Unicode is used instead of upper/lowercasing both the characters, see L (Case Mappings). I32 foldEQ_utf8(const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2)','name' => 'foldEQ_utf8'},'Nullch' => {'text' => 'Null character pointer. (No longer available when C is defined.)','name' => 'Nullch'},'get_context' => {'text' => '','name' => 'get_context'},'vcroak' => {'text' => 'This is an XS interface to Perl\'s C function. C and C are a sprintf-style format pattern and encapsulated argument list. These are used to generate a string message. If the message does not end with a newline, then it will be extended with some indication of the current location in the code, as described for L. The error message will be used as an exception, by default returning control to the nearest enclosing C, but subject to modification by a C<$SIG{__DIE__}> handler. In any case, the C function never returns normally. For historical reasons, if C is null then the contents of C (C<$@>) will be used as an error message or object instead of building an error message from arguments. If you want to throw a non-string object, or build an error message in an SV yourself, it is preferable to use the L function, which does not involve clobbering C. void vcroak(const char *pat, va_list *args)','name' => 'vcroak'},'parse_fullexpr' => {'text' => 'Parse a single complete Perl expression. This allows the full expression grammar, including the lowest-precedence operators such as C. The expression must be followed (and thus terminated) by a token that an expression would normally be terminated by: end-of-file, closing bracketing punctuation, semicolon, or one of the keywords that signals a postfix expression-statement modifier. If I includes C then the expression is optional, otherwise it is mandatory. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed and the lexical context for the expression. The op tree representing the expression is returned. If an optional expression is absent, a null pointer is returned, otherwise the pointer will be non-null. If an error occurs in parsing or compilation, in most cases a valid op tree is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. Some compilation errors, however, will throw an exception immediately. NOTE: this function is experimental and may change or be removed without notice. OP * parse_fullexpr(U32 flags)','name' => 'parse_fullexpr'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the supplied vtable and returns a pointer to the magic added. Note that C will allow things that C will not. In particular, you can add magic to SvREADONLY SVs, and add more than one instance of the same \'how\'. If C is greater than zero then a C I of C is stored, if C is zero then C is stored as-is and - as another special case - if C<(name && namlen == HEf_SVKEY)> then C is assumed to contain an C and is stored as-is with its REFCNT incremented. (This is now used as a subroutine by C.) MAGIC * sv_magicext(SV *const sv, SV *const obj, const int how, const MGVTBL *const vtbl, const char *const name, const I32 namlen)','name' => 'sv_magicext'},'to_uni_title' => {'text' => '','name' => 'to_uni_title'},'gv_fullname4' => {'text' => '','name' => 'gv_fullname4'},'is_uni_idfirst' => {'text' => '','name' => 'is_uni_idfirst'},'av_push' => {'text' => 'Pushes an SV onto the end of the array. The array will grow automatically to accommodate the addition. This takes ownership of one reference count. Perl equivalent: C. void av_push(AV *av, SV *val)','name' => 'av_push'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV *const sv)','name' => 'newRV_noinc'},'unsharepvn' => {'text' => '','name' => 'unsharepvn'},'my_memcmp' => {'text' => '','name' => 'my_memcmp'},'newSLICEOP' => {'text' => 'Constructs, checks, and returns an C (list slice) op. I gives the eight bits of C, except that C will be set automatically, and, shifted up eight bits, the eight bits of C, except that the bit with value 1 or 2 is automatically set as required. I and I supply the parameters of the slice; they are consumed by this function and become part of the constructed op tree. OP * newSLICEOP(I32 flags, OP *subscript, OP *listval)','name' => 'newSLICEOP'},'mfree' => {'text' => '','name' => 'mfree'},'save_re_context' => {'text' => '','name' => 'save_re_context'},'hv_iterinit' => {'text' => '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 *hv)','name' => 'hv_iterinit'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.016000', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_014_003.pm0000644000175000017500000000040712043460725020754 0ustar tseetseepackage Perl::APIReference::V5_014_003; use strict; use warnings; use parent 'Perl::APIReference::V5_014_000'; sub new { my $class = shift; my $obj = $class->SUPER::new(@_); $obj->{perl_version} = '5.014003'; bless $obj => $class; return $obj; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_018_001.pm0000644000175000017500000000040612207032365020752 0ustar tseetseepackage Perl::APIReference::V5_018_001; use strict; use warnings; use parent 'Perl::APIReference::V5_018_000'; sub new { my $class = shift; my $obj = $class->SUPER::new(@_); $obj->{perl_version} = '5.018001'; bless $obj => $class; return $obj; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_008_003.pm0000644000175000017500000034731011653441731020770 0ustar tseetseepackage Perl::APIReference::V5_008_003; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'SvOOK' => {'text' => '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)','name' => 'SvOOK'},'hv_store_ent' => {'text' => '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. Effectively a successful hv_store_ent takes ownership of one reference to C. 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 C; unlike C it does not take ownership of it, so maintaining the correct reference count on C 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 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)','name' => 'hv_store_ent'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package, which must be a valid UTF-8 string. See C. HV* gv_stashsv(SV* sv, I32 create)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'strGE' => {'text' => '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)','name' => 'strGE'},'form' => {'text' => '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, ...)','name' => 'form'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified version becoming C. Handles \'get\' magic. See also C for a version which guarantees to evaluate sv only once. char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'is_utf8_string' => {'text' => 'Returns true if first C bytes of the given string form a valid UTF-8 string, false otherwise. Note that \'a valid UTF-8 string\' does not mean \'a string that contains code points above 0x7F encoded in UTF-8\' because a valid ASCII string is a valid UTF-8 string. bool is_utf8_string(U8 *s, STRLEN len)','name' => 'is_utf8_string'},'svtype' => {'text' => '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.','name' => 'svtype'},'hv_clear' => {'text' => 'Clears a hash, making it empty. void hv_clear(HV* tb)','name' => 'hv_clear'},'get_hv' => {'text' => '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)','name' => 'get_hv'},'load_module' => {'text' => '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 C. The optional trailing SV* arguments can be used to specify arguments to the module\'s import() method, similar to C. void load_module(U32 flags, SV* name, SV* ver, ...)','name' => 'load_module'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES;','name' => 'XSRETURN_YES'},'sv_nv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. NV sv_nv(SV* sv)','name' => 'sv_nv'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'Poison' => {'text' => '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)','name' => 'Poison'},'sv_insert' => {'text' => '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)','name' => 'sv_insert'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_catpvf_mg'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'SvPOK' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. bool SvPOK(SV* sv)','name' => 'SvPOK'},'get_sv' => {'text' => '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)','name' => 'get_sv'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. See C. void PUSHu(UV uv)','name' => 'PUSHu'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. (Uses C). SV* newSVsv(SV* old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C. void hv_magic(HV* hv, GV* gv, int how)','name' => 'hv_magic'},'SvPVutf8' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *sv, const char *ptr)','name' => 'sv_setpv_mg'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C.','name' => 'XS'},'scan_oct' => {'text' => 'For backwards compatibility. Use C instead. NV scan_oct(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_oct'},'sv_setpvn' => {'text' => '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)','name' => 'sv_setpvn'},'sv_2mortal' => {'text' => 'Marks an existing SV as mortal. The SV will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_2mortal(SV* sv)','name' => 'sv_2mortal'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'newSVrv' => {'text' => '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)','name' => 'newSVrv'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself. void av_undef(AV* ar)','name' => 'av_undef'},'HeKEY' => {'text' => '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)','name' => 'HeKEY'},'pack_cat' => {'text' => '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)','name' => 'pack_cat'},'utf8n_to_uvuni' => {'text' => 'Bottom level UTF-8 decode routine. Returns the unicode code point value of the first character in the string C which is assumed to be in UTF-8 encoding and no longer than C; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, the behaviour is dependent on the value of C: if it contains UTF8_CHECK_ONLY, it is assumed that the caller will raise a warning, and this function will silently just set C to C<-1> and return zero. If the C does not contain UTF8_CHECK_ONLY, warnings about malformations will be given, C will be set to the expected length of the UTF-8 character in bytes, and zero will be returned. The C can also contain various flags to allow deviations from the strict UTF-8 encoding (see F). Most code should use utf8_to_uvchr() rather than call this directly. UV utf8n_to_uvuni(U8 *s, STRLEN curlen, STRLEN* retlen, U32 flags)','name' => 'utf8n_to_uvuni'},'sv_cmp' => {'text' => '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. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp(SV* sv1, SV* sv2)','name' => 'sv_cmp'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'SvEND' => {'text' => '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)','name' => 'SvEND'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C to type C if necessary, then adds a new magic item of type C to the head of the magic list. void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen)','name' => 'sv_magic'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C, C or C for void, scalar or list context, respectively. U32 GIMME_V','name' => 'GIMME_V'},'sv_force_normal_flags' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. The C parameter gets passed to C when unrefing. C calls this function with flags set to 0. void sv_force_normal_flags(SV *sv, U32 flags)','name' => 'sv_force_normal_flags'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'sv_setsv_flags' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. If the C parameter has the C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You probably want to use one of the assortment of wrappers, such as C, C, C and C. This is the primary function for copying scalars, and most other copy-ish functions and macros use this underneath. void sv_setsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_setsv_flags'},'sv_utf8_upgrade_flags' => {'text' => 'Convert the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade_flags(SV *sv, I32 flags)','name' => 'sv_utf8_upgrade_flags'},'New' => {'text' => 'The XSUB-writer\'s interface to the C C function. void New(int id, void* ptr, int nitems, type)','name' => 'New'},'is_utf8_char' => {'text' => 'Tests if some arbitrary number of bytes begins in a valid UTF-8 character. Note that an INVARIANT (i.e. ASCII) character is a valid UTF-8 character. The actual number of bytes in the UTF-8 character will be returned if it is valid, otherwise 0. STRLEN is_utf8_char(U8 *p)','name' => 'is_utf8_char'},'Copy' => {'text' => '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)','name' => 'Copy'},'ibcmp_utf8' => {'text' => 'Return true if the strings s1 and s2 differ case-insensitively, false if not (if they are equal case-insensitively). If u1 is true, the string s1 is assumed to be in UTF-8-encoded Unicode. If u2 is true, the string s2 is assumed to be in UTF-8-encoded Unicode. If u1 or u2 are false, the respective string is assumed to be in native 8-bit encoding. If the pe1 and pe2 are non-NULL, the scanning pointers will be copied in there (they will point at the beginning of the I character). If the pointers behind pe1 or pe2 are non-NULL, they are the end pointers beyond which scanning will not continue under any circustances. If the byte lengths l1 and l2 are non-zero, s1+l1 and s2+l2 will be used as goal end pointers that will also stop the scan, and which qualify towards defining a successful match: all the scans that define an explicit length must reach their goal pointers for a match to succeed). For case-insensitiveness, the "casefolding" of Unicode is used instead of upper/lowercasing both the characters, see http://www.unicode.org/unicode/reports/tr21/ (Case Mappings). I32 ibcmp_utf8(const char* a, char **pe1, UV l1, bool u1, const char* b, char **pe2, UV l2, bool u2)','name' => 'ibcmp_utf8'},'CvSTASH' => {'text' => 'Returns the stash of the CV. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'sv_taint' => {'text' => 'Taint an SV. Use C instead. void sv_taint(SV* sv)','name' => 'sv_taint'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. The target SV physically takes over ownership of the body of the source SV and inherits its flags; however, the target keeps any magic it owns, and any magic in the source is discarded. Note that this is a rather specialist SV copying operation; most of the time you\'ll want to use C or one of its many macro front-ends. void sv_replace(SV* sv, SV* nsv)','name' => 'sv_replace'},'utf8n_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. Allows length and flags to be passed to low level routine. UV utf8n_to_uvchr(U8 *s, STRLEN curlen, STRLEN* retlen, U32 flags)','name' => 'utf8n_to_uvchr'},'sv_utf8_upgrade' => {'text' => 'Convert the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains a signed integer. void SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and L.','name' => 'G_ARRAY'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. Sets up the C and C variables by calling C and C. This is usually handled automatically by C. dXSARGS;','name' => 'dXSARGS'},'sv_2iv' => {'text' => 'Return the integer value of an SV, doing any necessary string conversion, magic etc. Normally used via the C and C macros. IV sv_2iv(SV* sv)','name' => 'sv_2iv'},'savesharedpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* ptr)','name' => 'Safefree'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the C C is whitespace. bool isSPACE(char ch)','name' => 'isSPACE'},'SvROK' => {'text' => 'Tests if the SV is an RV. bool SvROK(SV* sv)','name' => 'SvROK'},'sv_unref' => {'text' => '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. This is C with the C being zero. See C. void sv_unref(SV* sv)','name' => 'sv_unref'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dstr, SV *sstr)','name' => 'sv_catsv_mg'},'call_argv' => {'text' => '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)','name' => 'call_argv'},'SvPV_nolen' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified form becoming C. Handles \'get\' magic. char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'perl_clone' => {'text' => '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 C, 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)','name' => 'perl_clone'},'sv_setnv' => {'text' => 'Copies a double into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setnv(SV* sv, NV num)','name' => 'sv_setnv'},'sv_2nv' => {'text' => 'Return the num value of an SV, doing any necessary string or integer conversion, magic etc. Normally used via the C and C macros. NV sv_2nv(SV* sv)','name' => 'sv_2nv'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'XPUSHp' => {'text' => '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)','name' => 'XPUSHp'},'sv_utf8_encode' => {'text' => 'Convert the PV of an SV to UTF-8-encoded, but then turn off the C flag so that it looks like octets again. Used as a building block for encode_utf8 in Encode.xs void sv_utf8_encode(SV *sv)','name' => 'sv_utf8_encode'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1. HV* newHV()','name' => 'newHV'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or false. bool strNE(char* s1, char* s2)','name' => 'strNE'},'SvUTF8_on' => {'text' => 'Turn on the UTF-8 status of an SV (the data is not changed, just the flag). Do not use frivolously. void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_setpvn_mg'},'sv_pvutf8n_force' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n_force(SV* sv, STRLEN* lp)','name' => 'sv_pvutf8n_force'},'savepv' => {'text' => 'Perl\'s version of C. Returns a pointer to a newly allocated string which is a duplicate of C. The size of the string is determined by C. The memory allocated for the new string can be freed with the C function. char* savepv(const char* pv)','name' => 'savepv'},'toLOWER' => {'text' => 'Converts the specified character to lowercase. char toLOWER(char ch)','name' => 'toLOWER'},'bytes_from_utf8' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike but like C, returns a pointer to the newly-created string, and updates C to contain the new length. Returns the original string if no conversion occurs, C is unchanged. Do nothing if C points to 0. Sets C to 0 if C is converted or contains all 7bit characters. NOTE: this function is experimental and may change or be removed without notice. U8* bytes_from_utf8(U8 *s, STRLEN *len, bool *is_utf8)','name' => 'bytes_from_utf8'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1. AV* newAV()','name' => 'newAV'},'POPp' => {'text' => 'Pops a string off the stack. Deprecated. New code should provide a STRLEN n_a and use POPpx. char* POPp','name' => 'POPp'},'HvNAME' => {'text' => 'Returns the package name of a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV of the sv is assumed to be octets in that encoding, and the sv will be converted into Unicode (and UTF-8). If the sv already is UTF-8 (or if it is not POK), or if the encoding is not a reference, nothing is done to the sv. If the encoding is not an C Encoding object, bad things will happen. (See F and L). The PV of the sv is returned. char* sv_recode_to_utf8(SV* sv, SV *encoding)','name' => 'sv_recode_to_utf8'},'av_make' => {'text' => '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)','name' => 'av_make'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. See C for a version which guarantees to evaluate sv only once. UV SvUV(SV* sv)','name' => 'SvUV'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L. int perl_run(PerlInterpreter* interp)','name' => 'perl_run'},'sv_pvbyten' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten(SV *sv, STRLEN *len)','name' => 'sv_pvbyten'},'sv_catsv_flags' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. If C has C bit set, will C on the SVs if appropriate, else not. C and C are implemented in terms of this function. void sv_catsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_catsv_flags'},'Nullav' => {'text' => 'Null AV pointer.','name' => 'Nullav'},'sv_copypv' => {'text' => 'Copies a stringified representation of the source SV into the destination SV. Automatically performs any necessary mg_get and coercion of numeric values into strings. Guaranteed to preserve UTF-8 flag even from overloaded objects. Similar in nature to sv_2pv[_flags] but operates directly on an SV instead of just the string. Mostly uses sv_2pv_flags to do its work, except when that would lose the UTF-8\'ness of the PV. void sv_copypv(SV* dsv, SV* ssv)','name' => 'sv_copypv'},'sv_pv' => {'text' => 'Use the C macro instead char* sv_pv(SV *sv)','name' => 'sv_pv'},'SvPVutf8_nolen' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_nolen(SV* sv)','name' => 'SvPVutf8_nolen'},'sv_setpviv' => {'text' => '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)','name' => 'sv_setpviv'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setnv_mg(SV *sv, NV num)','name' => 'sv_setnv_mg'},'sv_true' => {'text' => 'Returns true if the SV has a true value by Perl\'s rules. Use the C macro instead, which may call C or may instead use an in-line version. I32 sv_true(SV *sv)','name' => 'sv_true'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV* hv, char** key, I32* retlen)','name' => 'hv_iternextsv'},'utf8_to_bytes' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike C, this over-writes the original string, and updates len to contain the new length. Returns zero on failure, setting C to -1. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_pvbyten_force' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten_force(SV* sv, STRLEN* lp)','name' => 'sv_pvbyten_force'},'sv_derived_from' => {'text' => '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)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. See also C. I32 sv_cmp_locale(SV* sv1, SV* sv2)','name' => 'sv_cmp_locale'},'uvuni_to_utf8_flags' => {'text' => 'Adds the UTF-8 representation of the Unicode codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvuni_to_utf8_flags(d, uv, flags); or, in most cases, d = uvuni_to_utf8(d, uv); (which is equivalent to) d = uvuni_to_utf8_flags(d, uv, 0); is the recommended Unicode-aware way of saying *(d++) = uv; U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)','name' => 'uvuni_to_utf8_flags'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'hv_exists' => {'text' => '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, I32 klen)','name' => 'hv_exists'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See L.','name' => 'G_DISCARD'},'Nullsv' => {'text' => 'Null SV pointer.','name' => 'Nullsv'},'mg_length' => {'text' => 'Report on the SV\'s length. See C. U32 mg_length(SV* sv)','name' => 'mg_length'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'SvPVX' => {'text' => 'Returns a pointer to the physical string in the SV. The SV must contain a string. char* SvPVX(SV* sv)','name' => 'SvPVX'},'XST_mNV' => {'text' => '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)','name' => 'XST_mNV'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. See C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'HEf_SVKEY' => {'text' => 'This flag, used in the length slot of hash entries and magic structures, specifies the structure contains an C pointer where a C pointer is to be expected. (For information only--not to be used).','name' => 'HEf_SVKEY'},'pad_sv' => {'text' => '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)','name' => 'pad_sv'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C in characters. Stops at C (inclusive). If C s> or if the scan would end up past C, croaks. STRLEN utf8_length(U8* s, U8 *e)','name' => 'utf8_length'},'SvPVutf8_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_force(SV* sv, STRLEN len)','name' => 'SvPVutf8_force'},'sv_2pvutf8_nolen' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8_nolen(SV* sv)','name' => 'sv_2pvutf8_nolen'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted if tainting is enabled. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'SvIOK_only_UV' => {'text' => 'Tells and SV that it is an unsigned integer and disables all other OK bits. void SvIOK_only_UV(SV* sv)','name' => 'SvIOK_only_UV'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C.','name' => 'SVt_NV'},'sv_nolocking' => {'text' => '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 *)','name' => 'sv_nolocking'},'sv_vcatpvfn' => {'text' => '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). Usually used via one of its frontends C and C. void sv_vcatpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vcatpvfn'},'SvPVbytex' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex(SV* sv, STRLEN len)','name' => 'SvPVbytex'},'av_store' => {'text' => '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)','name' => 'av_store'},'sv_2uv' => {'text' => 'Return the unsigned integer value of an SV, doing any necessary string conversion, magic etc. Normally used via the C and C macros. UV sv_2uv(SV* sv)','name' => 'sv_2uv'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and L. PUSHMARK;','name' => 'PUSHMARK'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. SV* ST(int ix)','name' => 'ST'},'strLT' => {'text' => '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)','name' => 'strLT'},'sv_pvutf8n' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n(SV *sv, STRLEN *len)','name' => 'sv_pvutf8n'},'call_pv' => {'text' => '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)','name' => 'call_pv'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. SV* av_shift(AV* ar)','name' => 'av_shift'},'newSV' => {'text' => 'Create a new null SV, or if len > 0, create a new empty SVt_PV type SV with an initial PV allocation of len+1. Normally accessed via the C macro. SV* newSV(STRLEN len)','name' => 'newSV'},'av_fetch' => {'text' => '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)','name' => 'av_fetch'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'gv_fetchmeth_autoload' => {'text' => '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 C. 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)','name' => 'gv_fetchmeth_autoload'},'sv_2pvutf8' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV, and set *lp to its length. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8(SV* sv, STRLEN* lp)','name' => 'sv_2pvutf8'},'sv_nounlocking' => {'text' => '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 *)','name' => 'sv_nounlocking'},'dITEMS' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dITEMS;','name' => 'dITEMS'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV* tb, HE* entry)','name' => 'hv_iterval'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. char* sv_reftype(SV* sv, int ob)','name' => 'sv_reftype'},'sv_pos_b2u' => {'text' => 'Converts the value pointed to by offsetp from a count of bytes from the start of the string, to a count of the equivalent number of UTF-8 chars. Handles magic and type coercion. void sv_pos_b2u(SV* sv, I32* offsetp)','name' => 'sv_pos_b2u'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C.','name' => 'SVt_IV'},'av_len' => {'text' => 'Returns the highest index in the array. Returns -1 if the array is empty. I32 av_len(AV* ar)','name' => 'av_len'},'SvIsCOW' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write. (either shared hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for COW) bool SvIsCOW(SV* sv)','name' => 'SvIsCOW'},'sv_unmagic' => {'text' => 'Removes all magic of type C from an SV. int sv_unmagic(SV* sv, int type)','name' => 'sv_unmagic'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *sv, IV i)','name' => 'sv_setiv_mg'},'sv_catsv' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catsv(SV* dsv, SV* ssv)','name' => 'sv_catsv'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled. void SvTAINT(SV* sv)','name' => 'SvTAINT'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C. See C and L for other uses. PUTBACK;','name' => 'PUTBACK'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'ax' => {'text' => 'Variable which is setup by C to indicate the stack base offset, used by the C, C and C macros. The C macro must be called prior to setup the C variable. I32 ax','name' => 'ax'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'SvCUR_set' => {'text' => 'Set the length of the string which is in the SV. See C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'to_utf8_fold' => {'text' => 'Convert the UTF-8 encoded character at p to its foldcase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_FOLD+1 bytes since the foldcase version may be longer than the original character (up to three characters). The first character of the foldcased version is returned (but note, as explained above, that there may be more.) UV to_utf8_fold(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_fold'},'to_utf8_upper' => {'text' => 'Convert the UTF-8 encoded character at p to its uppercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the uppercase version may be longer than the original character (up to two characters). The first character of the uppercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_upper(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_upper'},'SvNOK' => {'text' => 'Returns a boolean indicating whether the SV contains a double. bool SvNOK(SV* sv)','name' => 'SvNOK'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. C should be a valid UTF-8 string. 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)','name' => 'gv_stashpv'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C, C, and L.','name' => 'G_SCALAR'},'SvPVutf8x_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x_force(SV* sv, STRLEN len)','name' => 'SvPVutf8x_force'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. See C. void PUSHi(IV iv)','name' => 'PUSHi'},'sv_reset' => {'text' => 'Underlying implementation for the C Perl function. Note that the perl-level function is vaguely deprecated. void sv_reset(char* s, HV* stash)','name' => 'sv_reset'},'hv_exists_ent' => {'text' => '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)','name' => 'hv_exists_ent'},'to_utf8_lower' => {'text' => 'Convert the UTF-8 encoded character at p to its lowercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the lowercase version may be longer than the original character (up to two characters). The first character of the lowercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_lower(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_lower'},'SvNIOK' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. bool SvNIOK(SV* sv)','name' => 'SvNIOK'},'sv_2pv_flags' => {'text' => 'Returns a pointer to the string value of an SV, and sets *lp to its length. If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string if necessary. Normally invoked via the C macro. C and C usually end up here too. char* sv_2pv_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_2pv_flags'},'SvTAINTED_off' => {'text' => '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)','name' => 'SvTAINTED_off'},'SvNVx' => {'text' => 'Coerces the given SV to a double and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. NV SvNVx(SV* sv)','name' => 'SvNVx'},'unpack_str' => {'text' => '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)','name' => 'unpack_str'},'newSVpvf' => {'text' => 'Creates a new SV and initializes it with the string formatted like C. SV* newSVpvf(const char* pat, ...)','name' => 'newSVpvf'},'require_pv' => {'text' => 'Tells Perl to C the file named by the string argument. It is analogous to the Perl code C. 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)','name' => 'require_pv'},'sv_upgrade' => {'text' => 'Upgrade an SV to a more complex form. Generally adds a new body type to the SV, then copies across as much information as possible from the old body. You generally want to use the C macro wrapper. See also C. bool sv_upgrade(SV* sv, U32 mt)','name' => 'sv_upgrade'},'strEQ' => {'text' => 'Test two strings to see if they are equal. Returns true or false. bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C wrapper instead. SV* sv_newref(SV* sv)','name' => 'sv_newref'},'hv_store' => {'text' => '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. Effectively a successful hv_store takes ownership of one reference to C. 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 L 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)','name' => 'hv_store'},'SvIVX' => {'text' => 'Returns the raw value in the SV\'s IV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. IV SvIVX(SV* sv)','name' => 'SvIVX'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L. int perl_destruct(PerlInterpreter* interp)','name' => 'perl_destruct'},'sv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the scalar sv, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument is as in pv_uni_display(). The pointer to the PV of the dsv is returned. char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim, UV flags)','name' => 'sv_uni_display'},'isUPPER' => {'text' => 'Returns a boolean indicating whether the C C is an uppercase character. bool isUPPER(char ch)','name' => 'isUPPER'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. You probably want to use one of the assortment of wrappers, such as C, C, C and C. void sv_setsv(SV* dsv, SV* ssv)','name' => 'sv_setsv'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the stack. void XST_mYES(int pos)','name' => 'XST_mYES'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C for a version which guarantees to evaluate sv only once. NV SvNV(SV* sv)','name' => 'SvNV'},'packlist' => {'text' => 'The engine implementing pack() Perl function. void packlist(SV *cat, char *pat, char *patend, SV **beglist, SV **endlist)','name' => 'packlist'},'SvUTF8' => {'text' => 'Returns a boolean indicating whether the SV contains UTF-8 encoded data. void SvUTF8(SV* sv)','name' => 'SvUTF8'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'sv_setsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setsv_mg(SV *dstr, SV *sstr)','name' => 'sv_setsv_mg'},'hv_fetch_ent' => {'text' => '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)','name' => 'hv_fetch_ent'},'isLOWER' => {'text' => 'Returns a boolean indicating whether the C C is a lowercase character. bool isLOWER(char ch)','name' => 'isLOWER'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See C. char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an XSUB\'s aliases was used to invoke it. See L. I32 ix','name' => 'ix'},'SvNOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a double. Checks the B setting. Use C. bool SvNOKp(SV* sv)','name' => 'SvNOKp'},'XSRETURN_UV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_UV(IV uv)','name' => 'XSRETURN_UV'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'cv_undef' => {'text' => 'Clear out all the active components of a CV. This can happen either by an explicit C, 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)','name' => 'cv_undef'},'PUSHs' => {'text' => '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)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setuv(SV* sv, UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'utf8_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvchr(U8 *s, STRLEN* retlen)','name' => 'utf8_to_uvchr'},'nothreadhook' => {'text' => 'Stub that provides thread hook for perl_destruct when there are no threads. int nothreadhook()','name' => 'nothreadhook'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'bytes_to_utf8' => {'text' => 'Converts a string C of length C from ASCII into UTF-8 encoding. Returns a pointer to the newly-created string, and sets C to reflect the new length. If you want to convert to UTF-8 from other encodings than ASCII, see sv_recode_to_utf8(). NOTE: this function is experimental and may change or be removed without notice. U8* bytes_to_utf8(U8 *s, STRLEN *len)','name' => 'bytes_to_utf8'},'sv_pvn' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn(SV *sv, STRLEN *len)','name' => 'sv_pvn'},'SvIsCOW_shared_hash' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write shared hash key scalar. bool SvIsCOW_shared_hash(SV* sv)','name' => 'SvIsCOW_shared_hash'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'dXSI32' => {'text' => 'Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. dXSI32;','name' => 'dXSI32'},'sv_setref_iv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_iv(SV* rv, const char* classname, IV iv)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => '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. Uses the "OOK hack". Beware: after this function returns, C and SvPVX(sv) may no longer refer to the same chunk of data. void sv_chop(SV* sv, char* ptr)','name' => 'sv_chop'},'SvPVx' => {'text' => 'A version of C which guarantees to evaluate sv only once. char* SvPVx(SV* sv, STRLEN len)','name' => 'SvPVx'},'sv_backoff' => {'text' => 'Remove any string offset. You should normally use the C macro wrapper instead. int sv_backoff(SV* sv)','name' => 'sv_backoff'},'sv_tainted' => {'text' => 'Test an SV for taintedness. Use C instead. bool sv_tainted(SV* sv)','name' => 'sv_tainted'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. If necessary, uses C and upgrades the SV to C. Returns a pointer to the character buffer. Use the C wrapper instead. char* sv_grow(SV* sv, STRLEN newlen)','name' => 'sv_grow'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. See C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setuv_mg(SV *sv, UV u)','name' => 'sv_setuv_mg'},'cv_const_sv' => {'text' => 'If C is a constant sub eligible for inlining. returns the constant value returned by the sub. Otherwise, returns NULL. Constant subs can be created with C or as described in L. SV* cv_const_sv(CV* cv)','name' => 'cv_const_sv'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually handled automatically by C. See C.','name' => 'XS_VERSION'},'newSVnv' => {'text' => '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)','name' => 'newSVnv'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. See C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry. SV* HeVAL(HE* he)','name' => 'HeVAL'},'PL_na' => {'text' => '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','name' => 'PL_na'},'HePV' => {'text' => '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)','name' => 'HePV'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the SV is set to 1. SV* newSViv(IV i)','name' => 'newSViv'},'sv_untaint' => {'text' => 'Untaint an SV. Use C instead. void sv_untaint(SV* sv)','name' => 'sv_untaint'},'sv_setpv' => {'text' => '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)','name' => 'sv_setpv'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See C.','name' => 'SVt_PVHV'},'pv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the string spv, length len, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument can have UNI_DISPLAY_ISPRINT set to display isPRINT()able characters as themselves, UNI_DISPLAY_BACKSLASH to display the \\\\[nrfta\\\\] as the backslashed versions (like \'\\n\') (UNI_DISPLAY_BACKSLASH is preferred over UNI_DISPLAY_ISPRINT for \\\\). UNI_DISPLAY_QQ (and its alias UNI_DISPLAY_REGEX) have both UNI_DISPLAY_BACKSLASH and UNI_DISPLAY_ISPRINT turned on. The pointer to the PV of the dsv is returned. char* pv_uni_display(SV *dsv, U8 *spv, STRLEN len, STRLEN pvlim, UV flags)','name' => 'pv_uni_display'},'gv_fetchmethod' => {'text' => 'See L. GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'SvGETMAGIC' => {'text' => 'Invokes C on an SV if it has \'get\' magic. This macro evaluates its argument more than once. void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'SvGROW' => {'text' => '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)','name' => 'SvGROW'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_inc(SV* sv)','name' => 'sv_inc'},'sv_usepvn' => {'text' => '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)','name' => 'sv_usepvn'},'SvPVbytex_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex_force(SV* sv, STRLEN len)','name' => 'SvPVbytex_force'},'sv_catpv' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpv(SV* sv, const char* ptr)','name' => 'sv_catpv'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'sv_len' => {'text' => 'Returns the length of the string in the SV. Handles magic and type coercion. See also C, which gives raw access to the xpv_cur slot. STRLEN sv_len(SV* sv)','name' => 'sv_len'},'warn' => {'text' => '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, ...)','name' => 'warn'},'sv_pvutf8' => {'text' => 'Use the C macro instead char* sv_pvutf8(SV *sv)','name' => 'sv_pvutf8'},'SvPVbyte_nolen' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_nolen(SV* sv)','name' => 'SvPVbyte_nolen'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L. LEAVE;','name' => 'LEAVE'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See C.','name' => 'SVt_PVAV'},'hv_delete' => {'text' => '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, I32 klen, I32 flags)','name' => 'hv_delete'},'hv_undef' => {'text' => 'Undefines the hash. void hv_undef(HV* tb)','name' => 'hv_undef'},'SvSetMagicSV_nosteal' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetMagicSV_nosteal'},'hv_delete_ent' => {'text' => '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)','name' => 'hv_delete_ent'},'CLASS' => {'text' => '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','name' => 'CLASS'},'sv_isobject' => {'text' => '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)','name' => 'sv_isobject'},'Newc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Newc(int id, void* ptr, int nitems, type, cast)','name' => 'Newc'},'sv_pvn_force_flags' => {'text' => 'Get a sensible string out of the SV somehow. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You normally want to use the various wrapper macros instead: see C and C char* sv_pvn_force_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_pvn_force_flags'},'HeKLEN' => {'text' => '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)','name' => 'HeKLEN'},'to_utf8_title' => {'text' => 'Convert the UTF-8 encoded character at p to its titlecase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the titlecase version may be longer than the original character (up to two characters). The first character of the titlecased version is returned (but note, as explained above, that there may be more.) UV to_utf8_title(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_title'},'sv_cat_decode' => {'text' => 'The encoding is assumed to be an Encode object, the PV of the ssv is assumed to be octets in that encoding and decoding the input starts from the position which (PV + *offset) pointed to. The dsv will be concatenated the decoded UTF-8 string from ssv. Decoding will terminate when the string tstr appears in decoding output or the input ends on the PV of the ssv. The value which the offset points will be modified to the last input position on the ssv. Returns TRUE if the terminator was found, else returns FALSE. bool sv_cat_decode(SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen)','name' => 'sv_cat_decode'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. See C. void PUSHn(NV nv)','name' => 'PUSHn'},'sv_setiv' => {'text' => 'Copies an integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setiv(SV* sv, IV num)','name' => 'sv_setiv'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it. See C for a version which guarantees to evaluate sv only once. IV SvIV(SV* sv)','name' => 'SvIV'},'sv_report_used' => {'text' => 'Dump the contents of all SVs not yet freed. (Debugging aid). void sv_report_used()','name' => 'sv_report_used'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. void EXTEND(SP, int nitems)','name' => 'EXTEND'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. SV PL_sv_yes','name' => 'PL_sv_yes'},'SvNVX' => {'text' => 'Returns the raw value in the SV\'s NV slot, without checks or conversions. Only use when you are sure SvNOK is true. See also C. NV SvNVX(SV* sv)','name' => 'SvNVX'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(UV u)','name' => 'newSVuv'},'gv_fetchmeth' => {'text' => '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)','name' => 'gv_fetchmeth'},'sv_nosharing' => {'text' => '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 *)','name' => 'sv_nosharing'},'SvUTF8_off' => {'text' => 'Unsets the UTF-8 status of an SV. void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'looks_like_number' => {'text' => 'Test if the content of an SV looks like a number (or is a number). C and C are treated as numbers (so will not issue a non-numeric warning), even if your atof() doesn\'t grok them. I32 looks_like_number(SV* sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpv_mg(SV *sv, const char *ptr)','name' => 'sv_catpv_mg'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. U32 HeHASH(HE* he)','name' => 'HeHASH'},'sv_setref_uv' => {'text' => 'Copies an unsigned 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 have a reference count of 1, and the RV will be returned. SV* sv_setref_uv(SV* rv, const char* classname, UV uv)','name' => 'sv_setref_uv'},'SvIOK' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. bool SvIOK(SV* sv)','name' => 'SvIOK'},'getcwd_sv' => {'text' => 'Fill the sv with current working directory int getcwd_sv(SV* sv)','name' => 'getcwd_sv'},'newSVpv' => {'text' => '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)','name' => 'newSVpv'},'sv_2pvbyte' => {'text' => 'Return a pointer to the byte-encoded representation of the SV, and set *lp to its length. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte(SV* sv, STRLEN* lp)','name' => 'sv_2pvbyte'},'fbm_instr' => {'text' => '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)','name' => 'fbm_instr'},'sv_setpvf' => {'text' => '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, ...)','name' => 'sv_setpvf'},'SvPV_force' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. See C. void XPUSHn(NV nv)','name' => 'XPUSHn'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part attributable to C. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'call_sv' => {'text' => '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)','name' => 'call_sv'},'SVt_PV' => {'text' => 'Pointer type flag for scalars. See C.','name' => 'SVt_PV'},'strGT' => {'text' => '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)','name' => 'strGT'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a string and disables all other OK bits, and leaves the UTF-8 status as it was. void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic after a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'},'sv_pos_u2b' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from the start of the string, to a count of the equivalent number of bytes; if lenp is non-zero, it does the same to lenp, but this time starting from the offset, rather than from the start of the string. Handles magic and type coercion. void sv_pos_u2b(SV* sv, I32* offsetp, I32* lenp)','name' => 'sv_pos_u2b'},'SvTRUE' => {'text' => '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)','name' => 'SvTRUE'},'HeSVKEY_set' => {'text' => '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)','name' => 'HeSVKEY_set'},'POPl' => {'text' => 'Pops a long off the stack. long POPl','name' => 'POPl'},'hv_iternext_flags' => {'text' => 'Returns entries from a hash iterator. See C and C. The C 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 C<&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)','name' => 'hv_iternext_flags'},'grok_hex' => {'text' => 'converts a string representing a hex number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first non-hex-digit character. On return I<*len> is set to the length scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0x" or "x" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the hex number may use \'_\' characters to separate digits. UV grok_hex(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_hex'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L. SPAGAIN;','name' => 'SPAGAIN'},'call_method' => {'text' => '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)','name' => 'call_method'},'SvLOCK' => {'text' => 'Arranges for a mutual exclusion lock to be obtained on sv if a suitable module has been loaded. void SvLOCK(SV* sv)','name' => 'SvLOCK'},'sv_vsetpvfn' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Usually used via one of its frontends C and C. void sv_vsetpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vsetpvfn'},'get_cv' => {'text' => '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)','name' => 'get_cv'},'SvIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. Checks the B setting. Use C. bool SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the stack. void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'perl_parse' => {'text' => '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)','name' => 'perl_parse'},'to_utf8_case' => {'text' => 'The "p" contains the pointer to the UTF-8 string encoding the character that is being converted. The "ustrp" is a pointer to the character buffer to put the conversion result to. The "lenp" is a pointer to the length of the result. The "swashp" is a pointer to the swash to use. Both the special and normal mappings are stored lib/unicore/To/Foo.pl, and loaded by SWASHGET, using lib/utf8_heavy.pl. The special (usually, but not always, a multicharacter mapping), is tried first. The "special" is a string like "utf8::ToSpecLower", which means the hash %utf8::ToSpecLower. The access to the hash is through Perl_to_utf8_case(). The "normal" is a string like "ToLower" which means the swash %utf8::ToLower. UV to_utf8_case(U8 *p, U8* ustrp, STRLEN *lenp, SV **swash, char *normal, char *special)','name' => 'to_utf8_case'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory used by the array itself. void av_clear(AV* ar)','name' => 'av_clear'},'sv_force_normal' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. See also C. void sv_force_normal(SV *sv)','name' => 'sv_force_normal'},'av_unshift' => {'text' => '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)','name' => 'av_unshift'},'SvUNLOCK' => {'text' => 'Releases a mutual exclusion lock on sv if a suitable module has been loaded. void SvUNLOCK(SV* sv)','name' => 'SvUNLOCK'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C. int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV (using C). The new SV is marked as mortal. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_mortalcopy(SV* oldsv)','name' => 'sv_mortalcopy'},'POPpbytex' => {'text' => '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','name' => 'POPpbytex'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. UV SvUVX(SV* sv)','name' => 'SvUVX'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See L.','name' => 'G_NOARGS'},'SvSetMagicSV' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV(SV* dsb, SV* ssv)','name' => 'SvSetMagicSV'},'sv_utf8_decode' => {'text' => 'Convert the octets in the PV from UTF-8 to chars. Scan for validity and then turn off SvUTF8 if needed so that we see characters. Used as a building block for decode_utf8 in Encode.xs NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_decode(SV *sv)','name' => 'sv_utf8_decode'},'Newz' => {'text' => '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)','name' => 'Newz'},'savepvn' => {'text' => 'Perl\'s version of what C would be if it existed. Returns a pointer to a newly allocated string which is a duplicate of the first C bytes from C. The memory allocated for the new string can be freed with the C function. char* savepvn(const char* pv, I32 len)','name' => 'savepvn'},'eval_sv' => {'text' => '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)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized. This relies on the fact that uninitialized array elements are set to C<&PL_sv_undef>. bool av_exists(AV* ar, I32 key)','name' => 'av_exists'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C. STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'Move' => {'text' => '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)','name' => 'Move'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'sv_catpvn_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. void sv_catpvn_flags(SV* sv, const char* ptr, STRLEN len, I32 flags)','name' => 'sv_catpvn_flags'},'GIMME' => {'text' => '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','name' => 'GIMME'},'sv_bless' => {'text' => '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)','name' => 'sv_bless'},'NEWSV' => {'text' => '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)','name' => 'NEWSV'},'sv_isa' => {'text' => '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)','name' => 'sv_isa'},'isALNUM' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphanumeric character (including underscore) or digit. bool isALNUM(char ch)','name' => 'isALNUM'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs.','name' => 'newXS'},'sv_catpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. If the appended data contains "wide" characters (including, but not limited to, SVs with a UTF-8 PV formatted with %s, and characters >255 formatted with %c), the original SV might get upgraded to UTF-8. 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, ...)','name' => 'sv_catpvf'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. void SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C. void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'utf8_to_uvuni' => {'text' => 'Returns the Unicode code point of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. This function should only be used when returned UV is considered an index into the Unicode semantic tables (e.g. swashes). If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvuni(U8 *s, STRLEN* retlen)','name' => 'utf8_to_uvuni'},'sv_2io' => {'text' => 'Using various gambits, try to get an IO from an SV: the IO slot if its a GV; or the recursive result if we\'re an RV; or the IO slot of the symbol named after the PV if we\'re a string. IO* sv_2io(SV* sv)','name' => 'sv_2io'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphabetic character. bool isALPHA(char ch)','name' => 'isALPHA'},'Nullhv' => {'text' => 'Null HV pointer.','name' => 'Nullhv'},'av_fill' => {'text' => 'Ensure than an array has a given number of elements, equivalent to Perl\'s C<$#array = $fill;>. void av_fill(AV* ar, I32 fill)','name' => 'av_fill'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV. SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C. svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter* interp)','name' => 'perl_construct'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. void SvUOK(SV* sv)','name' => 'SvUOK'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_dec(SV* sv)','name' => 'sv_dec'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'strLE' => {'text' => '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)','name' => 'strLE'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'grok_bin' => {'text' => 'converts a string representing a binary number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. On return I<*len> is set to the length scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0b" or "b" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the binary number may use \'_\' characters to separate digits. UV grok_bin(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_bin'},'sv_2pvbyte_nolen' => {'text' => 'Return a pointer to the byte-encoded representation of the SV. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'SvOK' => {'text' => 'Returns a boolean indicating whether the value is an SV. bool SvOK(SV* sv)','name' => 'SvOK'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L. void perl_free(PerlInterpreter* interp)','name' => 'perl_free'},'sv_setref_nv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_nv(SV* rv, const char* classname, NV nv)','name' => 'sv_setref_nv'},'uvchr_to_utf8' => {'text' => 'Adds the UTF-8 representation of the Native codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvchr_to_utf8(d, uv); is the recommended wide native character-aware way of saying *(d++) = uv; U8* uvchr_to_utf8(U8 *d, UV uv)','name' => 'uvchr_to_utf8'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C. MAGIC* mg_find(SV* sv, int type)','name' => 'mg_find'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII digit. bool isDIGIT(char ch)','name' => 'isDIGIT'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'eval_pv' => {'text' => '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)','name' => 'eval_pv'},'newSVpvn_share' => {'text' => 'Creates a new SV with its SvPVX pointing to a shared string in the string table. If the string does not already exist in the table, it is created first. Turns on READONLY and FAKE. The string\'s hash is stored in the UV slot of the SV; if the C parameter is non-zero, that value is used; otherwise the hash is computed. The idea here is that as the string table is used for shared hash keys these strings will have SvPVX == HeKEY and hash lookup will avoid string compare. SV* newSVpvn_share(const char* s, I32 len, U32 hash)','name' => 'newSVpvn_share'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_setpvf_mg'},'SvPOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. Checks the B setting. Use C. bool SvPOKp(SV* sv)','name' => 'SvPOKp'},'sv_free' => {'text' => 'Decrement an SV\'s reference count, and if it drops to zero, call C to invoke destructors and free up any memory used by the body; finally, deallocate the SV\'s head itself. Normally called via a wrapper macro C. void sv_free(SV* sv)','name' => 'sv_free'},'sv_catpvn' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn'},'SvPVbyte_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_force(SV* sv, STRLEN len)','name' => 'SvPVbyte_force'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. CV* newCONSTSUB(HV* stash, char* name, SV* sv)','name' => 'newCONSTSUB'},'sv_setref_pv' => {'text' => '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 have a reference count of 1, and the RV will be returned. 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)','name' => 'sv_setref_pv'},'SvSHARE' => {'text' => 'Arranges for sv to be shared between threads if a suitable module has been loaded. void SvSHARE(SV* sv)','name' => 'SvSHARE'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_pop(AV* ar)','name' => 'av_pop'},'fbm_compile' => {'text' => '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)','name' => 'fbm_compile'},'sv_utf8_downgrade' => {'text' => 'Attempt to convert the PV of an SV from UTF-8-encoded to byte encoding. This may not be possible if the PV contains non-byte encoding characters; if this is the case, either returns false or, if C is not true, croaks. This is not as a general purpose Unicode to byte encoding interface: use the Encode extension for that. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_downgrade(SV *sv, bool fail_ok)','name' => 'sv_utf8_downgrade'},'SvNIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. Checks the B setting. Use C. bool SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'croak' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Normally use this function the same way you use the C C function. See C. If you want to throw an exception object, assign the object to C<$@> and then pass C to croak(): errsv = get_sv("@", TRUE); sv_setsv(errsv, exception_object); croak(Nullch); void croak(const char* pat, ...)','name' => 'croak'},'sortsv' => {'text' => '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)','name' => 'sortsv'},'THIS' => {'text' => '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','name' => 'THIS'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either forward or backward. WARNING: do not use the following unless you *know* C is within the UTF-8 data pointed to by C *and* that on entry C is aligned on the first byte of character or just after the last byte of a character. U8* utf8_hop(U8 *s, I32 off)','name' => 'utf8_hop'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide UTF-8 bytes as a single character. Handles magic and type coercion. STRLEN sv_len_utf8(SV* sv)','name' => 'sv_len_utf8'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually handled by C. void XSRETURN(int nitems)','name' => 'XSRETURN'},'sv_setref_pvn' => {'text' => '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 have a reference count of 1, and the RV will be returned. Note that C copies the pointer while this copies the string. SV* sv_setref_pvn(SV* rv, const char* classname, char* pv, STRLEN n)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for blessed scalars. See C.','name' => 'SVt_PVMG'},'PUSHp' => {'text' => '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)','name' => 'PUSHp'},'scan_bin' => {'text' => 'For backwards compatibility. Use C instead. NV scan_bin(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_bin'},'Nullcv' => {'text' => 'Null CV pointer.','name' => 'Nullcv'},'hv_clear_placeholders' => {'text' => '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 reaasigned 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)','name' => 'hv_clear_placeholders'},'dAX' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dAX;','name' => 'dAX'},'sv_2pv_nolen' => {'text' => 'Like C, but doesn\'t return the length too. You should usually use the macro wrapper C instead. char* sv_2pv_nolen(SV* sv)','name' => 'sv_2pv_nolen'},'get_av' => {'text' => '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)','name' => 'get_av'},'PL_sv_undef' => {'text' => 'This is the C SV. Always refer to this as C<&PL_sv_undef>. SV PL_sv_undef','name' => 'PL_sv_undef'},'SvPVbyte' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'hv_iterkeysv' => {'text' => '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)','name' => 'hv_iterkeysv'},'grok_number' => {'text' => '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)','name' => 'grok_number'},'SvIVx' => {'text' => 'Coerces the given SV to an integer and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. IV SvIVx(SV* sv)','name' => 'SvIVx'},'grok_numeric_radix' => {'text' => 'Scan and skip for a numeric decimal separator (radix). bool grok_numeric_radix(const char **sp, const char *send)','name' => 'grok_numeric_radix'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the stack. void XST_mNO(int pos)','name' => 'XST_mNO'},'toUPPER' => {'text' => 'Converts the specified character to uppercase. char toUPPER(char ch)','name' => 'toUPPER'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array. Returns the deleted element. C is currently ignored. SV* av_delete(AV* ar, I32 key, I32 flags)','name' => 'av_delete'},'is_utf8_string_loc' => {'text' => 'Like is_ut8_string but store the location of the failure in the last argument. bool is_utf8_string_loc(U8 *s, STRLEN len, U8 **p)','name' => 'is_utf8_string_loc'},'utf8_distance' => {'text' => 'Returns the number of UTF-8 characters between the UTF-8 pointers C and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. IV utf8_distance(U8 *a, U8 *b)','name' => 'utf8_distance'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally appending to the currently-stored string. char* sv_gets(SV* sv, PerlIO* fp, I32 append)','name' => 'sv_gets'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'SvPVutf8x' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'sv_collxfrm' => {'text' => 'Add Collate Transform magic to an SV if it doesn\'t already have it. Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the scalar data of the variable, but transformed to such a format that a normal memory comparison can be used to compare the data according to the locale settings. char* sv_collxfrm(SV* sv, STRLEN* nxp)','name' => 'sv_collxfrm'},'sv_2cv' => {'text' => 'Using various gambits, try to get a CV from an SV; in addition, try if possible to set C<*st> and C<*gvp> to the stash and GV associated with it. CV* sv_2cv(SV* sv, HV** st, GV** gvp, I32 lref)','name' => 'sv_2cv'},'SvPV_force_nomg' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. Doesn\'t process magic. char* SvPV_force_nomg(SV* sv, STRLEN len)','name' => 'SvPV_force_nomg'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. Will also turn off the UTF-8 status. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'POPpx' => {'text' => 'Pops a string off the stack. Requires a variable STRLEN n_a in scope. char* POPpx','name' => 'POPpx'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'sv_uv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. UV sv_uv(SV* sv)','name' => 'sv_uv'},'sv_pvbyte' => {'text' => 'Use C instead. char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'hv_fetch' => {'text' => '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 an C. See L for more information on how to use this function on tied hashes. SV** hv_fetch(HV* tb, const char* key, I32 klen, I32 lval)','name' => 'hv_fetch'},'Zero' => {'text' => '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)','name' => 'Zero'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_unref_flags' => {'text' => '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. The C argument can contain C to force the reference count to be decremented (otherwise the decrementing is conditional on the reference count being different from one or the reference being a readonly SV). See C. void sv_unref_flags(SV* sv, U32 flags)','name' => 'sv_unref_flags'},'sv_iv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. IV sv_iv(SV* sv)','name' => 'sv_iv'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'hv_scalar' => {'text' => 'Evaluates the hash in scalar context and returns the result. Handles magic when the hash is tied. SV* hv_scalar(HV* hv)','name' => 'hv_scalar'},'Nullch' => {'text' => 'Null character pointer.','name' => 'Nullch'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)','name' => 'mg_copy'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C flag on this RV; give the referred-to SV C magic if it hasn\'t already; and push a back-reference to this RV onto the array of backreferences associated with that magic. SV* sv_rvweaken(SV *sv)','name' => 'sv_rvweaken'},'grok_oct' => {'text' => 'UV grok_oct(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_oct'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'scan_hex' => {'text' => 'For backwards compatibility. Use C instead. NV scan_hex(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_hex'},'newSVpvn' => {'text' => '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)','name' => 'newSVpvn'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the supplied vtable and returns pointer to the magic added. Note that sv_magicext will allow things that sv_magic will not. In particular you can add magic to SvREADONLY SVs and and more than one instance of the same \'how\' I C is greater then zero then a savepvn() I of C is stored, if C is zero then C is stored as-is and - as another special case - if C<(name && namelen == HEf_SVKEY)> then C is assumed to contain an C and has its REFCNT incremented (This is now used as a subroutine by sv_magic.) MAGIC * sv_magicext(SV* sv, SV* obj, int how, MGVTBL *vtbl, const char* name, I32 namlen )','name' => 'sv_magicext'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C.','name' => 'SVt_PVCV'},'av_push' => {'text' => '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)','name' => 'av_push'},'unpackstring' => {'text' => 'The engine implementing unpack() Perl function. C puts the extracted list items on the stack and returns the number of elements. Issue C before and C after the call to this function. I32 unpackstring(char *pat, char *patend, char *s, char *strend, U32 flags)','name' => 'unpackstring'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV* ar, I32 key)','name' => 'av_extend'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV *sv)','name' => 'newRV_noinc'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpviv_mg(SV *sv, IV iv)','name' => 'sv_setpviv_mg'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'sv_2bool' => {'text' => 'This function is only called on magical items, and is only used by sv_true() or its macro equivalent. bool sv_2bool(SV* sv)','name' => 'sv_2bool'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. You may call C or C 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 C, so you must not discard your iterator immediately else the entry will leak - call C to trigger the resource deallocation. HE* hv_iternext(HV* tb)','name' => 'hv_iternext'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'sv_newmortal' => {'text' => 'Creates a new null SV which is mortal. The reference count of the SV is set to 1. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_newmortal()','name' => 'sv_newmortal'},'sv_clear' => {'text' => 'Clear an SV: call any destructors, free up any memory used by the body, and free the body itself. The SV\'s head is I freed, although its type is set to all 1\'s so that it won\'t inadvertently be assumed to be live during global destruction etc. This function should only be called when REFCNT is zero. Most of the time you\'ll want to call C (or its macro wrapper C) instead. void sv_clear(SV* sv)','name' => 'sv_clear'},'hv_iterinit' => {'text' => '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)','name' => 'hv_iterinit'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.008003', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_012_003.pm0000644000175000017500000000040711653441731020754 0ustar tseetseepackage Perl::APIReference::V5_012_003; use strict; use warnings; use parent 'Perl::APIReference::V5_012_000'; sub new { my $class = shift; my $obj = $class->SUPER::new(@_); $obj->{perl_version} = '5.012003'; bless $obj => $class; return $obj; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_008_008.pm0000644000175000017500000037615411653441731021005 0ustar tseetseepackage Perl::APIReference::V5_008_008; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'SvPV_set' => {'text' => 'Set the value of the PV pointer in sv to val. See C. void SvPV_set(SV* sv, char* val)','name' => 'SvPV_set'},'SvOOK' => {'text' => '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)','name' => 'SvOOK'},'hv_store_ent' => {'text' => '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. Effectively a successful hv_store_ent takes ownership of one reference to C. 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 C; unlike C it does not take ownership of it, so maintaining the correct reference count on C 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 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)','name' => 'hv_store_ent'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package, which must be a valid UTF-8 string. See C. HV* gv_stashsv(SV* sv, I32 create)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'strGE' => {'text' => '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)','name' => 'strGE'},'form' => {'text' => '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, ...)','name' => 'form'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified version becoming C. Handles \'get\' magic. See also C for a version which guarantees to evaluate sv only once. char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'is_utf8_string' => {'text' => 'Returns true if first C bytes of the given string form a valid UTF-8 string, false otherwise. Note that \'a valid UTF-8 string\' does not mean \'a string that contains code points above 0x7F encoded in UTF-8\' because a valid ASCII string is a valid UTF-8 string. See also is_utf8_string_loclen() and is_utf8_string_loc(). bool is_utf8_string(U8 *s, STRLEN len)','name' => 'is_utf8_string'},'svtype' => {'text' => '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.','name' => 'svtype'},'hv_clear' => {'text' => 'Clears a hash, making it empty. void hv_clear(HV* tb)','name' => 'hv_clear'},'get_hv' => {'text' => '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)','name' => 'get_hv'},'load_module' => {'text' => '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 C. The optional trailing SV* arguments can be used to specify arguments to the module\'s import() method, similar to C. void load_module(U32 flags, SV* name, SV* ver, ...)','name' => 'load_module'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES;','name' => 'XSRETURN_YES'},'sv_nv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. NV sv_nv(SV* sv)','name' => 'sv_nv'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'Poison' => {'text' => '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)','name' => 'Poison'},'sv_insert' => {'text' => '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)','name' => 'sv_insert'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_catpvf_mg'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'SvPOK' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. bool SvPOK(SV* sv)','name' => 'SvPOK'},'get_sv' => {'text' => '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)','name' => 'get_sv'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHu(UV uv)','name' => 'PUSHu'},'sv_vsetpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vsetpvf_mg(SV* sv, const char* pat, va_list* args)','name' => 'sv_vsetpvf_mg'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. (Uses C). SV* newSVsv(SV* old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C. void hv_magic(HV* hv, GV* gv, int how)','name' => 'hv_magic'},'SvPVutf8' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *sv, const char *ptr)','name' => 'sv_setpv_mg'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C.','name' => 'XS'},'scan_oct' => {'text' => 'For backwards compatibility. Use C instead. NV scan_oct(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_oct'},'sv_setpvn' => {'text' => 'Copies a string into an SV. The C parameter indicates the number of bytes to be copied. If the C argument is NULL the SV will become undefined. Does not handle \'set\' magic. See C. void sv_setpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_setpvn'},'sv_2mortal' => {'text' => 'Marks an existing SV as mortal. The SV will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. SvTEMP() is turned on which means that the SV\'s string buffer can be "stolen" if this SV is copied. See also C and C. SV* sv_2mortal(SV* sv)','name' => 'sv_2mortal'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'newSVrv' => {'text' => '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)','name' => 'newSVrv'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself. void av_undef(AV* ar)','name' => 'av_undef'},'HeKEY' => {'text' => '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)','name' => 'HeKEY'},'pack_cat' => {'text' => '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)','name' => 'pack_cat'},'utf8n_to_uvuni' => {'text' => 'Bottom level UTF-8 decode routine. Returns the unicode code point value of the first character in the string C which is assumed to be in UTF-8 encoding and no longer than C; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, the behaviour is dependent on the value of C: if it contains UTF8_CHECK_ONLY, it is assumed that the caller will raise a warning, and this function will silently just set C to C<-1> and return zero. If the C does not contain UTF8_CHECK_ONLY, warnings about malformations will be given, C will be set to the expected length of the UTF-8 character in bytes, and zero will be returned. The C can also contain various flags to allow deviations from the strict UTF-8 encoding (see F). Most code should use utf8_to_uvchr() rather than call this directly. UV utf8n_to_uvuni(U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvuni'},'sv_cmp' => {'text' => '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. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp(SV* sv1, SV* sv2)','name' => 'sv_cmp'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'SvEND' => {'text' => '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)','name' => 'SvEND'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C to type C if necessary, then adds a new magic item of type C to the head of the magic list. See C (which C now calls) for a description of the handling of the C and C arguments. You need to use C to add magic to SvREADONLY SVs and also to add more than one instance of the same \'how\'. void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen)','name' => 'sv_magic'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C, C or C for void, scalar or list context, respectively. U32 GIMME_V','name' => 'GIMME_V'},'sv_force_normal_flags' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. The C parameter gets passed to C when unrefing. C calls this function with flags set to 0. void sv_force_normal_flags(SV *sv, U32 flags)','name' => 'sv_force_normal_flags'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'sv_setsv_flags' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. If the C parameter has the C bit set, will C on C if appropriate, else not. If the C parameter has the C bit set then the buffers of temps will not be stolen. and C are implemented in terms of this function. You probably want to use one of the assortment of wrappers, such as C, C, C and C. This is the primary function for copying scalars, and most other copy-ish functions and macros use this underneath. void sv_setsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_setsv_flags'},'sv_utf8_upgrade_flags' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade_flags(SV *sv, I32 flags)','name' => 'sv_utf8_upgrade_flags'},'is_utf8_char' => {'text' => 'Tests if some arbitrary number of bytes begins in a valid UTF-8 character. Note that an INVARIANT (i.e. ASCII) character is a valid UTF-8 character. The actual number of bytes in the UTF-8 character will be returned if it is valid, otherwise 0. STRLEN is_utf8_char(U8 *p)','name' => 'is_utf8_char'},'Copy' => {'text' => '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)','name' => 'Copy'},'ibcmp_utf8' => {'text' => 'Return true if the strings s1 and s2 differ case-insensitively, false if not (if they are equal case-insensitively). If u1 is true, the string s1 is assumed to be in UTF-8-encoded Unicode. If u2 is true, the string s2 is assumed to be in UTF-8-encoded Unicode. If u1 or u2 are false, the respective string is assumed to be in native 8-bit encoding. If the pe1 and pe2 are non-NULL, the scanning pointers will be copied in there (they will point at the beginning of the I character). If the pointers behind pe1 or pe2 are non-NULL, they are the end pointers beyond which scanning will not continue under any circumstances. If the byte lengths l1 and l2 are non-zero, s1+l1 and s2+l2 will be used as goal end pointers that will also stop the scan, and which qualify towards defining a successful match: all the scans that define an explicit length must reach their goal pointers for a match to succeed). For case-insensitiveness, the "casefolding" of Unicode is used instead of upper/lowercasing both the characters, see http://www.unicode.org/unicode/reports/tr21/ (Case Mappings). I32 ibcmp_utf8(const char* a, char **pe1, UV l1, bool u1, const char* b, char **pe2, UV l2, bool u2)','name' => 'ibcmp_utf8'},'mXPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Handles \'set\' magic. Does not use C. See also C, C and C. void mXPUSHp(char* str, STRLEN len)','name' => 'mXPUSHp'},'CvSTASH' => {'text' => 'Returns the stash of the CV. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'sv_taint' => {'text' => 'Taint an SV. Use C instead. void sv_taint(SV* sv)','name' => 'sv_taint'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. The target SV physically takes over ownership of the body of the source SV and inherits its flags; however, the target keeps any magic it owns, and any magic in the source is discarded. Note that this is a rather specialist SV copying operation; most of the time you\'ll want to use C or one of its many macro front-ends. void sv_replace(SV* sv, SV* nsv)','name' => 'sv_replace'},'utf8n_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. Allows length and flags to be passed to low level routine. UV utf8n_to_uvchr(U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvchr'},'sv_utf8_upgrade' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains a signed integer. bool SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and L.','name' => 'G_ARRAY'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. Sets up the C and C variables by calling C and C. This is usually handled automatically by C. dXSARGS;','name' => 'dXSARGS'},'sv_2iv' => {'text' => 'Return the integer value of an SV, doing any necessary string conversion, magic etc. Normally used via the C and C macros. IV sv_2iv(SV* sv)','name' => 'sv_2iv'},'savesharedpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* ptr)','name' => 'Safefree'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the C C is whitespace. bool isSPACE(char ch)','name' => 'isSPACE'},'SvROK' => {'text' => 'Tests if the SV is an RV. bool SvROK(SV* sv)','name' => 'SvROK'},'mXPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. Does not use C. See also C, C and C. void mXPUSHn(NV nv)','name' => 'mXPUSHn'},'sv_unref' => {'text' => '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. This is C with the C being zero. See C. void sv_unref(SV* sv)','name' => 'sv_unref'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dstr, SV *sstr)','name' => 'sv_catsv_mg'},'mPUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Does not use C. See also C, C and C. void mPUSHu(UV uv)','name' => 'mPUSHu'},'gv_stashpvn' => {'text' => 'Returns a pointer to the stash for a specified package. C should be a valid UTF-8 string. The C parameter indicates the length of the C, in bytes. 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_stashpvn(const char* name, U32 namelen, I32 create)','name' => 'gv_stashpvn'},'call_argv' => {'text' => '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)','name' => 'call_argv'},'SvPV_nolen' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified form becoming C. Handles \'get\' magic. char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'perl_clone' => {'text' => '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 C, 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)','name' => 'perl_clone'},'sv_setnv' => {'text' => 'Copies a double into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setnv(SV* sv, NV num)','name' => 'sv_setnv'},'sv_2nv' => {'text' => 'Return the num value of an SV, doing any necessary string or integer conversion, magic etc. Normally used via the C and C macros. NV sv_2nv(SV* sv)','name' => 'sv_2nv'},'sv_setsv_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_setsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_setsv_nomg'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'XPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHp(char* str, STRLEN len)','name' => 'XPUSHp'},'sv_utf8_encode' => {'text' => 'Converts the PV of an SV to UTF-8, but then turns the C flag off so that it looks like octets again. void sv_utf8_encode(SV *sv)','name' => 'sv_utf8_encode'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1. HV* newHV()','name' => 'newHV'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or false. bool strNE(char* s1, char* s2)','name' => 'strNE'},'SvUTF8_on' => {'text' => 'Turn on the UTF-8 status of an SV (the data is not changed, just the flag). Do not use frivolously. void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_setpvn_mg'},'sv_pvutf8n_force' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n_force(SV* sv, STRLEN* lp)','name' => 'sv_pvutf8n_force'},'savepv' => {'text' => 'Perl\'s version of C. Returns a pointer to a newly allocated string which is a duplicate of C. The size of the string is determined by C. The memory allocated for the new string can be freed with the C function. char* savepv(const char* pv)','name' => 'savepv'},'toLOWER' => {'text' => 'Converts the specified character to lowercase. char toLOWER(char ch)','name' => 'toLOWER'},'SvNV_set' => {'text' => 'Set the value of the NV pointer in sv to val. See C. void SvNV_set(SV* sv, NV val)','name' => 'SvNV_set'},'bytes_from_utf8' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike C but like C, returns a pointer to the newly-created string, and updates C to contain the new length. Returns the original string if no conversion occurs, C is unchanged. Do nothing if C points to 0. Sets C to 0 if C is converted or contains all 7bit characters. NOTE: this function is experimental and may change or be removed without notice. U8* bytes_from_utf8(U8 *s, STRLEN *len, bool *is_utf8)','name' => 'bytes_from_utf8'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1. AV* newAV()','name' => 'newAV'},'POPp' => {'text' => 'Pops a string off the stack. Deprecated. New code should use POPpx. char* POPp','name' => 'POPp'},'HvNAME' => {'text' => 'Returns the package name of a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV of the sv is assumed to be octets in that encoding, and the sv will be converted into Unicode (and UTF-8). If the sv already is UTF-8 (or if it is not POK), or if the encoding is not a reference, nothing is done to the sv. If the encoding is not an C Encoding object, bad things will happen. (See F and L). The PV of the sv is returned. char* sv_recode_to_utf8(SV* sv, SV *encoding)','name' => 'sv_recode_to_utf8'},'av_make' => {'text' => '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)','name' => 'av_make'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. See C for a version which guarantees to evaluate sv only once. UV SvUV(SV* sv)','name' => 'SvUV'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L. int perl_run(PerlInterpreter* interp)','name' => 'perl_run'},'sv_pvbyten' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten(SV *sv, STRLEN *len)','name' => 'sv_pvbyten'},'sv_catsv_flags' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. If C has C bit set, will C on the SVs if appropriate, else not. C and C are implemented in terms of this function. void sv_catsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_catsv_flags'},'Nullav' => {'text' => 'Null AV pointer.','name' => 'Nullav'},'sv_copypv' => {'text' => 'Copies a stringified representation of the source SV into the destination SV. Automatically performs any necessary mg_get and coercion of numeric values into strings. Guaranteed to preserve UTF-8 flag even from overloaded objects. Similar in nature to sv_2pv[_flags] but operates directly on an SV instead of just the string. Mostly uses sv_2pv_flags to do its work, except when that would lose the UTF-8\'ness of the PV. void sv_copypv(SV* dsv, SV* ssv)','name' => 'sv_copypv'},'sv_pv' => {'text' => 'Use the C macro instead char* sv_pv(SV *sv)','name' => 'sv_pv'},'SvPVutf8_nolen' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_nolen(SV* sv)','name' => 'SvPVutf8_nolen'},'sv_setpviv' => {'text' => '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)','name' => 'sv_setpviv'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setnv_mg(SV *sv, NV num)','name' => 'sv_setnv_mg'},'sv_true' => {'text' => 'Returns true if the SV has a true value by Perl\'s rules. Use the C macro instead, which may call C or may instead use an in-line version. I32 sv_true(SV *sv)','name' => 'sv_true'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV* hv, char** key, I32* retlen)','name' => 'hv_iternextsv'},'utf8_to_bytes' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike C, this over-writes the original string, and updates len to contain the new length. Returns zero on failure, setting C to -1. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_pvbyten_force' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten_force(SV* sv, STRLEN* lp)','name' => 'sv_pvbyten_force'},'sv_derived_from' => {'text' => '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)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. See also C. I32 sv_cmp_locale(SV* sv1, SV* sv2)','name' => 'sv_cmp_locale'},'uvuni_to_utf8_flags' => {'text' => 'Adds the UTF-8 representation of the Unicode codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvuni_to_utf8_flags(d, uv, flags); or, in most cases, d = uvuni_to_utf8(d, uv); (which is equivalent to) d = uvuni_to_utf8_flags(d, uv, 0); is the recommended Unicode-aware way of saying *(d++) = uv; U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)','name' => 'uvuni_to_utf8_flags'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'hv_exists' => {'text' => '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, I32 klen)','name' => 'hv_exists'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See L.','name' => 'G_DISCARD'},'Nullsv' => {'text' => 'Null SV pointer.','name' => 'Nullsv'},'mg_length' => {'text' => 'Report on the SV\'s length. See C. U32 mg_length(SV* sv)','name' => 'mg_length'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'SvPVX' => {'text' => 'Returns a pointer to the physical string in the SV. The SV must contain a string. char* SvPVX(SV* sv)','name' => 'SvPVX'},'XST_mNV' => {'text' => '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)','name' => 'XST_mNV'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'HEf_SVKEY' => {'text' => 'This flag, used in the length slot of hash entries and magic structures, specifies the structure contains an C pointer where a C pointer is to be expected. (For information only--not to be used).','name' => 'HEf_SVKEY'},'pad_sv' => {'text' => '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)','name' => 'pad_sv'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C in characters. Stops at C (inclusive). If C s> or if the scan would end up past C, croaks. STRLEN utf8_length(U8* s, U8 *e)','name' => 'utf8_length'},'SvPVutf8_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_force(SV* sv, STRLEN len)','name' => 'SvPVutf8_force'},'sv_2pvutf8_nolen' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8_nolen(SV* sv)','name' => 'sv_2pvutf8_nolen'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted if tainting is enabled. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'SvIOK_only_UV' => {'text' => 'Tells and SV that it is an unsigned integer and disables all other OK bits. void SvIOK_only_UV(SV* sv)','name' => 'SvIOK_only_UV'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C.','name' => 'SVt_NV'},'sv_nolocking' => {'text' => '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 *)','name' => 'sv_nolocking'},'sv_vcatpvfn' => {'text' => '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). XXX Except that it maybe_tainted is never assigned to. Usually used via one of its frontends C and C. void sv_vcatpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vcatpvfn'},'SvPVbytex' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex(SV* sv, STRLEN len)','name' => 'SvPVbytex'},'av_store' => {'text' => '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)','name' => 'av_store'},'sv_2uv' => {'text' => 'Return the unsigned integer value of an SV, doing any necessary string conversion, magic etc. Normally used via the C and C macros. UV sv_2uv(SV* sv)','name' => 'sv_2uv'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and L. void PUSHMARK(SP)','name' => 'PUSHMARK'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. SV* ST(int ix)','name' => 'ST'},'strLT' => {'text' => '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)','name' => 'strLT'},'sv_pvutf8n' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n(SV *sv, STRLEN *len)','name' => 'sv_pvutf8n'},'call_pv' => {'text' => '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)','name' => 'call_pv'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. SV* av_shift(AV* ar)','name' => 'av_shift'},'newSV' => {'text' => 'Create a new null SV, or if len > 0, create a new empty SVt_PV type SV with an initial PV allocation of len+1. Normally accessed via the C macro. SV* newSV(STRLEN len)','name' => 'newSV'},'av_fetch' => {'text' => '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)','name' => 'av_fetch'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'gv_fetchmeth_autoload' => {'text' => '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 C. 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)','name' => 'gv_fetchmeth_autoload'},'sv_2pvutf8' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV, and set *lp to its length. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8(SV* sv, STRLEN* lp)','name' => 'sv_2pvutf8'},'sv_nounlocking' => {'text' => '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 *)','name' => 'sv_nounlocking'},'dITEMS' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dITEMS;','name' => 'dITEMS'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV* tb, HE* entry)','name' => 'hv_iterval'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. char* sv_reftype(SV* sv, int ob)','name' => 'sv_reftype'},'SvUV_set' => {'text' => 'Set the value of the UV pointer in sv to val. See C. void SvUV_set(SV* sv, UV val)','name' => 'SvUV_set'},'sv_pos_b2u' => {'text' => 'Converts the value pointed to by offsetp from a count of bytes from the start of the string, to a count of the equivalent number of UTF-8 chars. Handles magic and type coercion. void sv_pos_b2u(SV* sv, I32* offsetp)','name' => 'sv_pos_b2u'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C.','name' => 'SVt_IV'},'av_len' => {'text' => 'Returns the highest index in the array. Returns -1 if the array is empty. I32 av_len(AV* ar)','name' => 'av_len'},'SvIsCOW' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write. (either shared hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for COW) bool SvIsCOW(SV* sv)','name' => 'SvIsCOW'},'CopyD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * CopyD(void* src, void* dest, int nitems, type)','name' => 'CopyD'},'sv_unmagic' => {'text' => 'Removes all magic of type C from an SV. int sv_unmagic(SV* sv, int type)','name' => 'sv_unmagic'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *sv, IV i)','name' => 'sv_setiv_mg'},'sv_catsv' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catsv(SV* dsv, SV* ssv)','name' => 'sv_catsv'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled. void SvTAINT(SV* sv)','name' => 'SvTAINT'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C. See C and L for other uses. PUTBACK;','name' => 'PUTBACK'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'ax' => {'text' => 'Variable which is setup by C to indicate the stack base offset, used by the C, C and C macros. The C macro must be called prior to setup the C variable. I32 ax','name' => 'ax'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'dAXMARK' => {'text' => 'Sets up the C variable and stack marker variable C. This is usually handled automatically by C by calling C. dAXMARK;','name' => 'dAXMARK'},'SvCUR_set' => {'text' => 'Set the current length of the string which is in the SV. See C and C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'to_utf8_fold' => {'text' => 'Convert the UTF-8 encoded character at p to its foldcase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the foldcase version may be longer than the original character (up to three characters). The first character of the foldcased version is returned (but note, as explained above, that there may be more.) UV to_utf8_fold(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_fold'},'to_utf8_upper' => {'text' => 'Convert the UTF-8 encoded character at p to its uppercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the uppercase version may be longer than the original character. The first character of the uppercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_upper(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_upper'},'SvNOK' => {'text' => 'Returns a boolean indicating whether the SV contains a double. bool SvNOK(SV* sv)','name' => 'SvNOK'},'mPUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. Does not use C. See also C, C and C. void mPUSHn(NV nv)','name' => 'mPUSHn'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. C should be a valid UTF-8 string and must be null-terminated. 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)','name' => 'gv_stashpv'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C, C, and L.','name' => 'G_SCALAR'},'sv_vcatpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vcatpvf_mg(SV* sv, const char* pat, va_list* args)','name' => 'sv_vcatpvf_mg'},'SvPVutf8x_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x_force(SV* sv, STRLEN len)','name' => 'SvPVutf8x_force'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHi(IV iv)','name' => 'PUSHi'},'sv_reset' => {'text' => 'Underlying implementation for the C Perl function. Note that the perl-level function is vaguely deprecated. void sv_reset(char* s, HV* stash)','name' => 'sv_reset'},'mXPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Does not use C. See also C, C and C. void mXPUSHu(UV uv)','name' => 'mXPUSHu'},'hv_exists_ent' => {'text' => '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)','name' => 'hv_exists_ent'},'SvLEN_set' => {'text' => 'Set the actual length of the string which is in the SV. See C. void SvLEN_set(SV* sv, STRLEN len)','name' => 'SvLEN_set'},'to_utf8_lower' => {'text' => 'Convert the UTF-8 encoded character at p to its lowercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the lowercase version may be longer than the original character. The first character of the lowercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_lower(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_lower'},'SvNIOK' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. bool SvNIOK(SV* sv)','name' => 'SvNIOK'},'sv_2pv_flags' => {'text' => 'Returns a pointer to the string value of an SV, and sets *lp to its length. If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string if necessary. Normally invoked via the C macro. C and C usually end up here too. char* sv_2pv_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_2pv_flags'},'SvTAINTED_off' => {'text' => '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)','name' => 'SvTAINTED_off'},'SvNVx' => {'text' => 'Coerces the given SV to a double and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. NV SvNVx(SV* sv)','name' => 'SvNVx'},'unpack_str' => {'text' => '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)','name' => 'unpack_str'},'newSVpvf' => {'text' => 'Creates a new SV and initializes it with the string formatted like C. SV* newSVpvf(const char* pat, ...)','name' => 'newSVpvf'},'require_pv' => {'text' => 'Tells Perl to C the file named by the string argument. It is analogous to the Perl code C. 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)','name' => 'require_pv'},'sv_upgrade' => {'text' => 'Upgrade an SV to a more complex form. Generally adds a new body type to the SV, then copies across as much information as possible from the old body. You generally want to use the C macro wrapper. See also C. bool sv_upgrade(SV* sv, U32 mt)','name' => 'sv_upgrade'},'strEQ' => {'text' => 'Test two strings to see if they are equal. Returns true or false. bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C wrapper instead. SV* sv_newref(SV* sv)','name' => 'sv_newref'},'Newxc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Newxc(void* ptr, int nitems, type, cast)','name' => 'Newxc'},'hv_store' => {'text' => '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. Effectively a successful hv_store takes ownership of one reference to C. 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 L 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)','name' => 'hv_store'},'SvIVX' => {'text' => 'Returns the raw value in the SV\'s IV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. IV SvIVX(SV* sv)','name' => 'SvIVX'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L. int perl_destruct(PerlInterpreter* interp)','name' => 'perl_destruct'},'sv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the scalar sv, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument is as in pv_uni_display(). The pointer to the PV of the dsv is returned. char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim, UV flags)','name' => 'sv_uni_display'},'sv_vsetpvf' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Does not handle \'set\' magic. See C. Usually used via its frontend C. void sv_vsetpvf(SV* sv, const char* pat, va_list* args)','name' => 'sv_vsetpvf'},'isUPPER' => {'text' => 'Returns a boolean indicating whether the C C is an uppercase character. bool isUPPER(char ch)','name' => 'isUPPER'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. You probably want to use one of the assortment of wrappers, such as C, C, C and C. void sv_setsv(SV* dsv, SV* ssv)','name' => 'sv_setsv'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the stack. void XST_mYES(int pos)','name' => 'XST_mYES'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C for a version which guarantees to evaluate sv only once. NV SvNV(SV* sv)','name' => 'SvNV'},'packlist' => {'text' => 'The engine implementing pack() Perl function. void packlist(SV *cat, char *pat, char *patend, SV **beglist, SV **endlist)','name' => 'packlist'},'SvUTF8' => {'text' => 'Returns a boolean indicating whether the SV contains UTF-8 encoded data. bool SvUTF8(SV* sv)','name' => 'SvUTF8'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'sv_setsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setsv_mg(SV *dstr, SV *sstr)','name' => 'sv_setsv_mg'},'hv_fetch_ent' => {'text' => '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)','name' => 'hv_fetch_ent'},'isLOWER' => {'text' => 'Returns a boolean indicating whether the C C is a lowercase character. bool isLOWER(char ch)','name' => 'isLOWER'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See C. char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an XSUB\'s aliases was used to invoke it. See L. I32 ix','name' => 'ix'},'SvNOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a double. Checks the B setting. Use C. bool SvNOKp(SV* sv)','name' => 'SvNOKp'},'Newx' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Newx(void* ptr, int nitems, type)','name' => 'Newx'},'XSRETURN_UV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_UV(IV uv)','name' => 'XSRETURN_UV'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'cv_undef' => {'text' => 'Clear out all the active components of a CV. This can happen either by an explicit C, 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)','name' => 'cv_undef'},'PUSHs' => {'text' => 'Push an SV onto the stack. The stack must have room for this element. Does not handle \'set\' magic. Does not use C. See also C, C and C. void PUSHs(SV* sv)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setuv(SV* sv, UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'utf8_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvchr(U8 *s, STRLEN *retlen)','name' => 'utf8_to_uvchr'},'nothreadhook' => {'text' => 'Stub that provides thread hook for perl_destruct when there are no threads. int nothreadhook()','name' => 'nothreadhook'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'bytes_to_utf8' => {'text' => 'Converts a string C of length C from ASCII into UTF-8 encoding. Returns a pointer to the newly-created string, and sets C to reflect the new length. If you want to convert to UTF-8 from other encodings than ASCII, see sv_recode_to_utf8(). NOTE: this function is experimental and may change or be removed without notice. U8* bytes_to_utf8(U8 *s, STRLEN *len)','name' => 'bytes_to_utf8'},'sv_pvn' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn(SV *sv, STRLEN *len)','name' => 'sv_pvn'},'SvIsCOW_shared_hash' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write shared hash key scalar. bool SvIsCOW_shared_hash(SV* sv)','name' => 'SvIsCOW_shared_hash'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'dXSI32' => {'text' => 'Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. dXSI32;','name' => 'dXSI32'},'sv_setref_iv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_iv(SV* rv, const char* classname, IV iv)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => '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. Uses the "OOK hack". Beware: after this function returns, C and SvPVX_const(sv) may no longer refer to the same chunk of data. void sv_chop(SV* sv, char* ptr)','name' => 'sv_chop'},'SvPVx' => {'text' => 'A version of C which guarantees to evaluate sv only once. char* SvPVx(SV* sv, STRLEN len)','name' => 'SvPVx'},'sv_backoff' => {'text' => 'Remove any string offset. You should normally use the C macro wrapper instead. int sv_backoff(SV* sv)','name' => 'sv_backoff'},'sv_tainted' => {'text' => 'Test an SV for taintedness. Use C instead. bool sv_tainted(SV* sv)','name' => 'sv_tainted'},'sv_catsv_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_catsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_catsv_nomg'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. If necessary, uses C and upgrades the SV to C. Returns a pointer to the character buffer. Use the C wrapper instead. char* sv_grow(SV* sv, STRLEN newlen)','name' => 'sv_grow'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setuv_mg(SV *sv, UV u)','name' => 'sv_setuv_mg'},'cv_const_sv' => {'text' => 'If C is a constant sub eligible for inlining. returns the constant value returned by the sub. Otherwise, returns NULL. Constant subs can be created with C or as described in L. SV* cv_const_sv(CV* cv)','name' => 'cv_const_sv'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually handled automatically by C. See C.','name' => 'XS_VERSION'},'newSVnv' => {'text' => '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)','name' => 'newSVnv'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. Does not use C. See also C, C and C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry. SV* HeVAL(HE* he)','name' => 'HeVAL'},'PL_na' => {'text' => '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','name' => 'PL_na'},'HePV' => {'text' => '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)','name' => 'HePV'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the SV is set to 1. SV* newSViv(IV i)','name' => 'newSViv'},'sv_untaint' => {'text' => 'Untaint an SV. Use C instead. void sv_untaint(SV* sv)','name' => 'sv_untaint'},'sv_setpv' => {'text' => '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)','name' => 'sv_setpv'},'Newxz' => {'text' => 'The XSUB-writer\'s interface to the C C function. The allocated memory is zeroed with C. In 5.9.3, we removed the 1st parameter, a debug aid, from the api. It was used to uniquely identify each usage of these allocation functions, but was deemed unnecessary with the availability of better memory tracking tools, valgrind for example. void Newxz(void* ptr, int nitems, type)','name' => 'Newxz'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See C.','name' => 'SVt_PVHV'},'pv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the string spv, length len, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument can have UNI_DISPLAY_ISPRINT set to display isPRINT()able characters as themselves, UNI_DISPLAY_BACKSLASH to display the \\\\[nrfta\\\\] as the backslashed versions (like \'\\n\') (UNI_DISPLAY_BACKSLASH is preferred over UNI_DISPLAY_ISPRINT for \\\\). UNI_DISPLAY_QQ (and its alias UNI_DISPLAY_REGEX) have both UNI_DISPLAY_BACKSLASH and UNI_DISPLAY_ISPRINT turned on. The pointer to the PV of the dsv is returned. char* pv_uni_display(SV *dsv, U8 *spv, STRLEN len, STRLEN pvlim, UV flags)','name' => 'pv_uni_display'},'gv_fetchmethod' => {'text' => 'See L. GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'SvGETMAGIC' => {'text' => 'Invokes C on an SV if it has \'get\' magic. This macro evaluates its argument more than once. void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'SvGROW' => {'text' => '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)','name' => 'SvGROW'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_inc(SV* sv)','name' => 'sv_inc'},'sv_usepvn' => {'text' => '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)','name' => 'sv_usepvn'},'SvPVbytex_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex_force(SV* sv, STRLEN len)','name' => 'SvPVbytex_force'},'sv_catpv' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpv(SV* sv, const char* ptr)','name' => 'sv_catpv'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'sv_len' => {'text' => 'Returns the length of the string in the SV. Handles magic and type coercion. See also C, which gives raw access to the xpv_cur slot. STRLEN sv_len(SV* sv)','name' => 'sv_len'},'warn' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Call this function the same way you call the C C function. See C. void warn(const char* pat, ...)','name' => 'warn'},'sv_pvutf8' => {'text' => 'Use the C macro instead char* sv_pvutf8(SV *sv)','name' => 'sv_pvutf8'},'SvPVbyte_nolen' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_nolen(SV* sv)','name' => 'SvPVbyte_nolen'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L. LEAVE;','name' => 'LEAVE'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See C.','name' => 'SVt_PVAV'},'hv_delete' => {'text' => '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, I32 klen, I32 flags)','name' => 'hv_delete'},'hv_undef' => {'text' => 'Undefines the hash. void hv_undef(HV* tb)','name' => 'hv_undef'},'SvSetMagicSV_nosteal' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetMagicSV_nosteal'},'hv_delete_ent' => {'text' => '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)','name' => 'hv_delete_ent'},'CLASS' => {'text' => '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','name' => 'CLASS'},'savesvpv' => {'text' => 'A version of C/C which gets the string to duplicate from the passed in SV using C char* savesvpv(SV* sv)','name' => 'savesvpv'},'sv_isobject' => {'text' => '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)','name' => 'sv_isobject'},'sv_pvn_force_flags' => {'text' => 'Get a sensible string out of the SV somehow. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You normally want to use the various wrapper macros instead: see C and C char* sv_pvn_force_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_pvn_force_flags'},'HeKLEN' => {'text' => '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)','name' => 'HeKLEN'},'to_utf8_title' => {'text' => 'Convert the UTF-8 encoded character at p to its titlecase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the titlecase version may be longer than the original character. The first character of the titlecased version is returned (but note, as explained above, that there may be more.) UV to_utf8_title(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_title'},'sv_cat_decode' => {'text' => 'The encoding is assumed to be an Encode object, the PV of the ssv is assumed to be octets in that encoding and decoding the input starts from the position which (PV + *offset) pointed to. The dsv will be concatenated the decoded UTF-8 string from ssv. Decoding will terminate when the string tstr appears in decoding output or the input ends on the PV of the ssv. The value which the offset points will be modified to the last input position on the ssv. Returns TRUE if the terminator was found, else returns FALSE. bool sv_cat_decode(SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen)','name' => 'sv_cat_decode'},'mPUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Does not use C. See also C, C and C. void mPUSHi(IV iv)','name' => 'mPUSHi'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHn(NV nv)','name' => 'PUSHn'},'sv_setiv' => {'text' => 'Copies an integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setiv(SV* sv, IV num)','name' => 'sv_setiv'},'SvIV_set' => {'text' => 'Set the value of the IV pointer in sv to val. It is possible to perform the same function of this macro with an lvalue assignment to C. With future Perls, however, it will be more efficient to use C instead of the lvalue assignment to C. void SvIV_set(SV* sv, IV val)','name' => 'SvIV_set'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it. See C for a version which guarantees to evaluate sv only once. IV SvIV(SV* sv)','name' => 'SvIV'},'sv_report_used' => {'text' => 'Dump the contents of all SVs not yet freed. (Debugging aid). void sv_report_used()','name' => 'sv_report_used'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. void EXTEND(SP, int nitems)','name' => 'EXTEND'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. SV PL_sv_yes','name' => 'PL_sv_yes'},'SvNVX' => {'text' => 'Returns the raw value in the SV\'s NV slot, without checks or conversions. Only use when you are sure SvNOK is true. See also C. NV SvNVX(SV* sv)','name' => 'SvNVX'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(UV u)','name' => 'newSVuv'},'gv_fetchmeth' => {'text' => '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)','name' => 'gv_fetchmeth'},'sv_nosharing' => {'text' => '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 *)','name' => 'sv_nosharing'},'SvUTF8_off' => {'text' => 'Unsets the UTF-8 status of an SV. void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'looks_like_number' => {'text' => 'Test if the content of an SV looks like a number (or is a number). C and C are treated as numbers (so will not issue a non-numeric warning), even if your atof() doesn\'t grok them. I32 looks_like_number(SV* sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpv_mg(SV *sv, const char *ptr)','name' => 'sv_catpv_mg'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. U32 HeHASH(HE* he)','name' => 'HeHASH'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'sv_setref_uv' => {'text' => 'Copies an unsigned 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 have a reference count of 1, and the RV will be returned. SV* sv_setref_uv(SV* rv, const char* classname, UV uv)','name' => 'sv_setref_uv'},'SvIOK' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. bool SvIOK(SV* sv)','name' => 'SvIOK'},'getcwd_sv' => {'text' => 'Fill the sv with current working directory int getcwd_sv(SV* sv)','name' => 'getcwd_sv'},'newSVpv' => {'text' => '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)','name' => 'newSVpv'},'sv_2pvbyte' => {'text' => 'Return a pointer to the byte-encoded representation of the SV, and set *lp to its length. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte(SV* sv, STRLEN* lp)','name' => 'sv_2pvbyte'},'fbm_instr' => {'text' => '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)','name' => 'fbm_instr'},'sv_setpvf' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Does not handle \'set\' magic. See C. void sv_setpvf(SV* sv, const char* pat, ...)','name' => 'sv_setpvf'},'SvPV_force' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHn(NV nv)','name' => 'XPUSHn'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part attributable to C. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'call_sv' => {'text' => '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)','name' => 'call_sv'},'SVt_PV' => {'text' => 'Pointer type flag for scalars. See C.','name' => 'SVt_PV'},'strGT' => {'text' => '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)','name' => 'strGT'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a string and disables all other OK bits, and leaves the UTF-8 status as it was. void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic after a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'},'sv_vcatpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. Does not handle \'set\' magic. See C. Usually used via its frontend C. void sv_vcatpvf(SV* sv, const char* pat, va_list* args)','name' => 'sv_vcatpvf'},'sv_pos_u2b' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from the start of the string, to a count of the equivalent number of bytes; if lenp is non-zero, it does the same to lenp, but this time starting from the offset, rather than from the start of the string. Handles magic and type coercion. void sv_pos_u2b(SV* sv, I32* offsetp, I32* lenp)','name' => 'sv_pos_u2b'},'SvTRUE' => {'text' => '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)','name' => 'SvTRUE'},'HeSVKEY_set' => {'text' => '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)','name' => 'HeSVKEY_set'},'POPl' => {'text' => 'Pops a long off the stack. long POPl','name' => 'POPl'},'hv_iternext_flags' => {'text' => 'Returns entries from a hash iterator. See C and C. The C 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 C<&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)','name' => 'hv_iternext_flags'},'grok_hex' => {'text' => 'converts a string representing a hex number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0x" or "x" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the hex number may use \'_\' characters to separate digits. UV grok_hex(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_hex'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L. SPAGAIN;','name' => 'SPAGAIN'},'is_utf8_string_loclen' => {'text' => 'Like is_utf8_string() but stores the location of the failure (in the case of "utf8ness failure") or the location s+len (in the case of "utf8ness success") in the C, and the number of UTF-8 encoded characters in the C. See also is_utf8_string_loc() and is_utf8_string(). bool is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el)','name' => 'is_utf8_string_loclen'},'call_method' => {'text' => '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)','name' => 'call_method'},'SvLOCK' => {'text' => 'Arranges for a mutual exclusion lock to be obtained on sv if a suitable module has been loaded. void SvLOCK(SV* sv)','name' => 'SvLOCK'},'sv_vsetpvfn' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Usually used via one of its frontends C and C. void sv_vsetpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vsetpvfn'},'get_cv' => {'text' => '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)','name' => 'get_cv'},'SvIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. Checks the B setting. Use C. bool SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the stack. void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'perl_parse' => {'text' => '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)','name' => 'perl_parse'},'to_utf8_case' => {'text' => 'The "p" contains the pointer to the UTF-8 string encoding the character that is being converted. The "ustrp" is a pointer to the character buffer to put the conversion result to. The "lenp" is a pointer to the length of the result. The "swashp" is a pointer to the swash to use. Both the special and normal mappings are stored lib/unicore/To/Foo.pl, and loaded by SWASHGET, using lib/utf8_heavy.pl. The special (usually, but not always, a multicharacter mapping), is tried first. The "special" is a string like "utf8::ToSpecLower", which means the hash %utf8::ToSpecLower. The access to the hash is through Perl_to_utf8_case(). The "normal" is a string like "ToLower" which means the swash %utf8::ToLower. UV to_utf8_case(U8 *p, U8* ustrp, STRLEN *lenp, SV **swashp, char *normal, char *special)','name' => 'to_utf8_case'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory used by the array itself. void av_clear(AV* ar)','name' => 'av_clear'},'sv_force_normal' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. See also C. void sv_force_normal(SV *sv)','name' => 'sv_force_normal'},'av_unshift' => {'text' => '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)','name' => 'av_unshift'},'SvUNLOCK' => {'text' => 'Releases a mutual exclusion lock on sv if a suitable module has been loaded. void SvUNLOCK(SV* sv)','name' => 'SvUNLOCK'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C. int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV (using C). The new SV is marked as mortal. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_mortalcopy(SV* oldsv)','name' => 'sv_mortalcopy'},'POPpbytex' => {'text' => 'Pops a string off the stack which must consist of bytes i.e. characters < 256. char* POPpbytex','name' => 'POPpbytex'},'sv_catpvn_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_catpvn_nomg(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn_nomg'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. UV SvUVX(SV* sv)','name' => 'SvUVX'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See L.','name' => 'G_NOARGS'},'SvSetMagicSV' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV(SV* dsb, SV* ssv)','name' => 'SvSetMagicSV'},'sv_utf8_decode' => {'text' => 'If the PV of the SV is an octet sequence in UTF-8 and contains a multiple-byte character, the C flag is turned on so that it looks like a character. If the PV contains only single-byte characters, the C flag stays being off. Scans PV for validity and returns false if the PV is invalid UTF-8. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_decode(SV *sv)','name' => 'sv_utf8_decode'},'savepvn' => {'text' => 'Perl\'s version of what C would be if it existed. Returns a pointer to a newly allocated string which is a duplicate of the first C bytes from C. The memory allocated for the new string can be freed with the C function. char* savepvn(const char* pv, I32 len)','name' => 'savepvn'},'eval_sv' => {'text' => '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)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized. This relies on the fact that uninitialized array elements are set to C<&PL_sv_undef>. bool av_exists(AV* ar, I32 key)','name' => 'av_exists'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C. STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'Move' => {'text' => '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)','name' => 'Move'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'sv_catpvn_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. void sv_catpvn_flags(SV* sv, const char* ptr, STRLEN len, I32 flags)','name' => 'sv_catpvn_flags'},'GIMME' => {'text' => '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','name' => 'GIMME'},'sv_bless' => {'text' => '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)','name' => 'sv_bless'},'NEWSV' => {'text' => '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)','name' => 'NEWSV'},'sv_isa' => {'text' => '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)','name' => 'sv_isa'},'isALNUM' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphanumeric character (including underscore) or digit. bool isALNUM(char ch)','name' => 'isALNUM'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs.','name' => 'newXS'},'sv_catpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. If the appended data contains "wide" characters (including, but not limited to, SVs with a UTF-8 PV formatted with %s, and characters >255 formatted with %c), the original SV might get upgraded to UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. If the original SV was UTF-8, the pattern should be valid UTF-8; if the original SV was bytes, the pattern should be too. void sv_catpvf(SV* sv, const char* pat, ...)','name' => 'sv_catpvf'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. bool SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C. void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'utf8_to_uvuni' => {'text' => 'Returns the Unicode code point of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. This function should only be used when returned UV is considered an index into the Unicode semantic tables (e.g. swashes). If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvuni(U8 *s, STRLEN *retlen)','name' => 'utf8_to_uvuni'},'sv_2io' => {'text' => 'Using various gambits, try to get an IO from an SV: the IO slot if its a GV; or the recursive result if we\'re an RV; or the IO slot of the symbol named after the PV if we\'re a string. IO* sv_2io(SV* sv)','name' => 'sv_2io'},'SvMAGIC_set' => {'text' => 'Set the value of the MAGIC pointer in sv to val. See C. void SvMAGIC_set(SV* sv, MAGIC* val)','name' => 'SvMAGIC_set'},'PUSHmortal' => {'text' => 'Push a new mortal SV onto the stack. The stack must have room for this element. Does not handle \'set\' magic. Does not use C. See also C, C and C. void PUSHmortal()','name' => 'PUSHmortal'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphabetic character. bool isALPHA(char ch)','name' => 'isALPHA'},'newSVhek' => {'text' => 'Creates a new SV from the hash key structure. It will generate scalars that point to the shared string table where possible. Returns a new (undefined) SV if the hek is NULL. SV* newSVhek(const HEK *hek)','name' => 'newSVhek'},'Nullhv' => {'text' => 'Null HV pointer.','name' => 'Nullhv'},'av_fill' => {'text' => 'Ensure than an array has a given number of elements, equivalent to Perl\'s C<$#array = $fill;>. void av_fill(AV* ar, I32 fill)','name' => 'av_fill'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV. SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C. svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter* interp)','name' => 'perl_construct'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. void SvUOK(SV* sv)','name' => 'SvUOK'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_dec(SV* sv)','name' => 'sv_dec'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'MoveD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * MoveD(void* src, void* dest, int nitems, type)','name' => 'MoveD'},'strLE' => {'text' => '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)','name' => 'strLE'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'grok_bin' => {'text' => 'converts a string representing a binary number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*flags> gives output flags. If the value is <= C it is returned as a UV, the output flags are clear, and nothing is written to I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The binary number may optionally be prefixed with "0b" or "b" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the binary number may use \'_\' characters to separate digits. UV grok_bin(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_bin'},'sv_2pvbyte_nolen' => {'text' => 'Return a pointer to the byte-encoded representation of the SV. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'SvOK' => {'text' => 'Returns a boolean indicating whether the value is an SV. It also tells whether the value is defined or not. bool SvOK(SV* sv)','name' => 'SvOK'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L. void perl_free(PerlInterpreter* interp)','name' => 'perl_free'},'sv_setref_nv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_nv(SV* rv, const char* classname, NV nv)','name' => 'sv_setref_nv'},'uvchr_to_utf8' => {'text' => 'Adds the UTF-8 representation of the Native codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvchr_to_utf8(d, uv); is the recommended wide native character-aware way of saying *(d++) = uv; U8* uvchr_to_utf8(U8 *d, UV uv)','name' => 'uvchr_to_utf8'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C. MAGIC* mg_find(SV* sv, int type)','name' => 'mg_find'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII digit. bool isDIGIT(char ch)','name' => 'isDIGIT'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'XPUSHmortal' => {'text' => 'Push a new mortal SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. Does not use C. See also C, C and C. void XPUSHmortal()','name' => 'XPUSHmortal'},'eval_pv' => {'text' => '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)','name' => 'eval_pv'},'newSVpvn_share' => {'text' => 'Creates a new SV with its SvPVX_const pointing to a shared string in the string table. If the string does not already exist in the table, it is created first. Turns on READONLY and FAKE. The string\'s hash is stored in the UV slot of the SV; if the C parameter is non-zero, that value is used; otherwise the hash is computed. The idea here is that as the string table is used for shared hash keys these strings will have SvPVX_const == HeKEY and hash lookup will avoid string compare. SV* newSVpvn_share(const char* s, I32 len, U32 hash)','name' => 'newSVpvn_share'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_setpvf_mg'},'SvPOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. Checks the B setting. Use C. bool SvPOKp(SV* sv)','name' => 'SvPOKp'},'sv_free' => {'text' => 'Decrement an SV\'s reference count, and if it drops to zero, call C to invoke destructors and free up any memory used by the body; finally, deallocate the SV\'s head itself. Normally called via a wrapper macro C. void sv_free(SV* sv)','name' => 'sv_free'},'sv_catpvn' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn'},'SvPVbyte_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_force(SV* sv, STRLEN len)','name' => 'SvPVbyte_force'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. CV* newCONSTSUB(HV* stash, char* name, SV* sv)','name' => 'newCONSTSUB'},'sv_setref_pv' => {'text' => '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 have a reference count of 1, and the RV will be returned. 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)','name' => 'sv_setref_pv'},'SvSHARE' => {'text' => 'Arranges for sv to be shared between threads if a suitable module has been loaded. void SvSHARE(SV* sv)','name' => 'SvSHARE'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_pop(AV* ar)','name' => 'av_pop'},'fbm_compile' => {'text' => '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)','name' => 'fbm_compile'},'sv_utf8_downgrade' => {'text' => 'Attempts to convert the PV of an SV from characters to bytes. If the PV contains a character beyond byte, this conversion will fail; in this case, either returns false or, if C is not true, croaks. This is not as a general purpose Unicode to byte encoding interface: use the Encode extension for that. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_downgrade(SV *sv, bool fail_ok)','name' => 'sv_utf8_downgrade'},'SvNIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. Checks the B setting. Use C. bool SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'croak' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Normally call this function the same way you call the C C function. Calling C returns control directly to Perl, sidestepping the normal C order of execution. See C. If you want to throw an exception object, assign the object to C<$@> and then pass C to croak(): errsv = get_sv("@", TRUE); sv_setsv(errsv, exception_object); croak(Nullch); void croak(const char* pat, ...)','name' => 'croak'},'sortsv' => {'text' => '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)','name' => 'sortsv'},'THIS' => {'text' => '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','name' => 'THIS'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either forward or backward. WARNING: do not use the following unless you *know* C is within the UTF-8 data pointed to by C *and* that on entry C is aligned on the first byte of character or just after the last byte of a character. U8* utf8_hop(U8 *s, I32 off)','name' => 'utf8_hop'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide UTF-8 bytes as a single character. Handles magic and type coercion. STRLEN sv_len_utf8(SV* sv)','name' => 'sv_len_utf8'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually handled by C. void XSRETURN(int nitems)','name' => 'XSRETURN'},'sv_setref_pvn' => {'text' => '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 have a reference count of 1, and the RV will be returned. Note that C copies the pointer while this copies the string. SV* sv_setref_pvn(SV* rv, const char* classname, char* pv, STRLEN n)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for blessed scalars. See C.','name' => 'SVt_PVMG'},'PUSHp' => {'text' => '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. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHp(char* str, STRLEN len)','name' => 'PUSHp'},'scan_bin' => {'text' => 'For backwards compatibility. Use C instead. NV scan_bin(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_bin'},'Nullcv' => {'text' => 'Null CV pointer.','name' => 'Nullcv'},'hv_clear_placeholders' => {'text' => '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)','name' => 'hv_clear_placeholders'},'mXPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Does not use C. See also C, C and C. void mXPUSHi(IV iv)','name' => 'mXPUSHi'},'dAX' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dAX;','name' => 'dAX'},'sv_2pv_nolen' => {'text' => 'Like C, but doesn\'t return the length too. You should usually use the macro wrapper C instead. char* sv_2pv_nolen(SV* sv)','name' => 'sv_2pv_nolen'},'get_av' => {'text' => '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)','name' => 'get_av'},'PL_sv_undef' => {'text' => 'This is the C SV. Always refer to this as C<&PL_sv_undef>. SV PL_sv_undef','name' => 'PL_sv_undef'},'SvRV_set' => {'text' => 'Set the value of the RV pointer in sv to val. See C. void SvRV_set(SV* sv, SV* val)','name' => 'SvRV_set'},'SvPVbyte' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'hv_iterkeysv' => {'text' => '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)','name' => 'hv_iterkeysv'},'grok_number' => {'text' => '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)','name' => 'grok_number'},'SvIVx' => {'text' => 'Coerces the given SV to an integer and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. IV SvIVx(SV* sv)','name' => 'SvIVx'},'grok_numeric_radix' => {'text' => 'Scan and skip for a numeric decimal separator (radix). bool grok_numeric_radix(const char **sp, const char *send)','name' => 'grok_numeric_radix'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the stack. void XST_mNO(int pos)','name' => 'XST_mNO'},'toUPPER' => {'text' => 'Converts the specified character to uppercase. char toUPPER(char ch)','name' => 'toUPPER'},'mPUSHp' => {'text' => '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. Does not use C. See also C, C and C. void mPUSHp(char* str, STRLEN len)','name' => 'mPUSHp'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array. Returns the deleted element. If C equals C, the element is freed and null is returned. SV* av_delete(AV* ar, I32 key, I32 flags)','name' => 'av_delete'},'is_utf8_string_loc' => {'text' => 'Like is_utf8_string() but stores the location of the failure (in the case of "utf8ness failure") or the location s+len (in the case of "utf8ness success") in the C. See also is_utf8_string_loclen() and is_utf8_string(). bool is_utf8_string_loc(U8 *s, STRLEN len, U8 **p)','name' => 'is_utf8_string_loc'},'utf8_distance' => {'text' => 'Returns the number of UTF-8 characters between the UTF-8 pointers C and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. IV utf8_distance(U8 *a, U8 *b)','name' => 'utf8_distance'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally appending to the currently-stored string. char* sv_gets(SV* sv, PerlIO* fp, I32 append)','name' => 'sv_gets'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'SvSTASH_set' => {'text' => 'Set the value of the STASH pointer in sv to val. See C. void SvSTASH_set(SV* sv, STASH* val)','name' => 'SvSTASH_set'},'SvPVutf8x' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'sv_collxfrm' => {'text' => 'Add Collate Transform magic to an SV if it doesn\'t already have it. Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the scalar data of the variable, but transformed to such a format that a normal memory comparison can be used to compare the data according to the locale settings. char* sv_collxfrm(SV* sv, STRLEN* nxp)','name' => 'sv_collxfrm'},'sv_2cv' => {'text' => 'Using various gambits, try to get a CV from an SV; in addition, try if possible to set C<*st> and C<*gvp> to the stash and GV associated with it. CV* sv_2cv(SV* sv, HV** st, GV** gvp, I32 lref)','name' => 'sv_2cv'},'ZeroD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * ZeroD(void* dest, int nitems, type)','name' => 'ZeroD'},'SvPV_force_nomg' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. Doesn\'t process magic. char* SvPV_force_nomg(SV* sv, STRLEN len)','name' => 'SvPV_force_nomg'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. Will also turn off the UTF-8 status. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'POPpx' => {'text' => 'Pops a string off the stack. char* POPpx','name' => 'POPpx'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'sv_uv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. UV sv_uv(SV* sv)','name' => 'sv_uv'},'sv_pvbyte' => {'text' => 'Use C instead. char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'hv_fetch' => {'text' => '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 an C. See L for more information on how to use this function on tied hashes. SV** hv_fetch(HV* tb, const char* key, I32 klen, I32 lval)','name' => 'hv_fetch'},'Zero' => {'text' => '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)','name' => 'Zero'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_unref_flags' => {'text' => '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. The C argument can contain C to force the reference count to be decremented (otherwise the decrementing is conditional on the reference count being different from one or the reference being a readonly SV). See C. void sv_unref_flags(SV* sv, U32 flags)','name' => 'sv_unref_flags'},'sv_iv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. IV sv_iv(SV* sv)','name' => 'sv_iv'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'hv_scalar' => {'text' => 'Evaluates the hash in scalar context and returns the result. Handles magic when the hash is tied. SV* hv_scalar(HV* hv)','name' => 'hv_scalar'},'Nullch' => {'text' => 'Null character pointer.','name' => 'Nullch'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)','name' => 'mg_copy'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C flag on this RV; give the referred-to SV C magic if it hasn\'t already; and push a back-reference to this RV onto the array of backreferences associated with that magic. SV* sv_rvweaken(SV *sv)','name' => 'sv_rvweaken'},'grok_oct' => {'text' => 'converts a string representing an octal number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). If C is set in I<*flags> then the octal number may use \'_\' characters to separate digits. UV grok_oct(char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_oct'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'scan_hex' => {'text' => 'For backwards compatibility. Use C instead. NV scan_hex(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_hex'},'newSVpvn' => {'text' => '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. If the C argument is NULL the new SV will be undefined. SV* newSVpvn(const char* s, STRLEN len)','name' => 'newSVpvn'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the supplied vtable and returns a pointer to the magic added. Note that C will allow things that C will not. In particular, you can add magic to SvREADONLY SVs, and add more than one instance of the same \'how\'. If C is greater than zero then a C I of C is stored, if C is zero then C is stored as-is and - as another special case - if C<(name && namlen == HEf_SVKEY)> then C is assumed to contain an C and is stored as-is with its REFCNT incremented. (This is now used as a subroutine by C.) MAGIC * sv_magicext(SV* sv, SV* obj, int how, MGVTBL *vtbl, const char* name, I32 namlen)','name' => 'sv_magicext'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C.','name' => 'SVt_PVCV'},'av_push' => {'text' => '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)','name' => 'av_push'},'unpackstring' => {'text' => 'The engine implementing unpack() Perl function. C puts the extracted list items on the stack and returns the number of elements. Issue C before and C after the call to this function. I32 unpackstring(char *pat, char *patend, char *s, char *strend, U32 flags)','name' => 'unpackstring'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV* ar, I32 key)','name' => 'av_extend'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV *sv)','name' => 'newRV_noinc'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpviv_mg(SV *sv, IV iv)','name' => 'sv_setpviv_mg'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'sv_2bool' => {'text' => 'This function is only called on magical items, and is only used by sv_true() or its macro equivalent. bool sv_2bool(SV* sv)','name' => 'sv_2bool'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. You may call C or C 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 C, so you must not discard your iterator immediately else the entry will leak - call C to trigger the resource deallocation. HE* hv_iternext(HV* tb)','name' => 'hv_iternext'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'sv_newmortal' => {'text' => 'Creates a new null SV which is mortal. The reference count of the SV is set to 1. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_newmortal()','name' => 'sv_newmortal'},'sv_clear' => {'text' => 'Clear an SV: call any destructors, free up any memory used by the body, and free the body itself. The SV\'s head is I freed, although its type is set to all 1\'s so that it won\'t inadvertently be assumed to be live during global destruction etc. This function should only be called when REFCNT is zero. Most of the time you\'ll want to call C (or its macro wrapper C) instead. void sv_clear(SV* sv)','name' => 'sv_clear'},'hv_iterinit' => {'text' => '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)','name' => 'hv_iterinit'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.008008', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_012_002.pm0000644000175000017500000000040711653441731020753 0ustar tseetseepackage Perl::APIReference::V5_012_002; use strict; use warnings; use parent 'Perl::APIReference::V5_012_000'; sub new { my $class = shift; my $obj = $class->SUPER::new(@_); $obj->{perl_version} = '5.012002'; bless $obj => $class; return $obj; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_016_003.pm0000644000175000017500000000040612131461354020752 0ustar tseetseepackage Perl::APIReference::V5_016_003; use strict; use warnings; use parent 'Perl::APIReference::V5_016_002'; sub new { my $class = shift; my $obj = $class->SUPER::new(@_); $obj->{perl_version} = '5.016003'; bless $obj => $class; return $obj; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_008_009.pm0000644000175000017500000044134311653441731020777 0ustar tseetseepackage Perl::APIReference::V5_008_009; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'hv_store_ent' => {'text' => '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. Effectively a successful hv_store_ent takes ownership of one reference to C. 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 C; unlike C it does not take ownership of it, so maintaining the correct reference count on C 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 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)','name' => 'hv_store_ent'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package. See C. HV* gv_stashsv(SV* sv, I32 flags)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'strGE' => {'text' => '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)','name' => 'strGE'},'form' => {'text' => '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, ...)','name' => 'form'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified version becoming C. Handles \'get\' magic. See also C for a version which guarantees to evaluate sv only once. char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'is_utf8_string' => {'text' => 'Returns true if first C bytes of the given string form a valid UTF-8 string, false otherwise. Note that \'a valid UTF-8 string\' does not mean \'a string that contains code points above 0x7F encoded in UTF-8\' because a valid ASCII string is a valid UTF-8 string. See also is_utf8_string_loclen() and is_utf8_string_loc(). bool is_utf8_string(U8 *s, STRLEN len)','name' => 'is_utf8_string'},'sv_insert' => {'text' => '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)','name' => 'sv_insert'},'SvPOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a character string. U32 SvPOK(SV* sv)','name' => 'SvPOK'},'sv_vsetpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vsetpvf_mg(SV* sv, const char* pat, va_list* args)','name' => 'sv_vsetpvf_mg'},'sv_destroyable' => {'text' => 'Dummy routine which reports that object can be destroyed when there is no sharing module present. It ignores its single SV argument, and returns \'true\'. Exists to avoid test for a NULL function pointer and because it could potentially warn under some level of strict-ness. bool sv_destroyable(SV *sv)','name' => 'sv_destroyable'},'SvPVutf8' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C.','name' => 'XS'},'scan_oct' => {'text' => 'For backwards compatibility. Use C instead. NV scan_oct(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_oct'},'sv_setpvn' => {'text' => 'Copies a string into an SV. The C parameter indicates the number of bytes to be copied. If the C argument is NULL the SV will become undefined. Does not handle \'set\' magic. See C. void sv_setpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_setpvn'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'newSVrv' => {'text' => '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)','name' => 'newSVrv'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'find_runcv' => {'text' => 'Locate the CV corresponding to the currently executing sub or eval. If db_seqp is non_null, skip CVs that are in the DB package and populate *db_seqp with the cop sequence number at the point that the DB:: code was entered. (allows debuggers to eval in the scope of the breakpoint rather than in the scope of the debugger itself). CV* find_runcv(U32 *db_seqp)','name' => 'find_runcv'},'PoisonWith' => {'text' => 'Fill up memory with a byte pattern (a byte repeated over and over again) that hopefully catches attempts to access uninitialized memory. void PoisonWith(void* dest, int nitems, type, U8 byte)','name' => 'PoisonWith'},'utf8n_to_uvuni' => {'text' => 'Bottom level UTF-8 decode routine. Returns the Unicode code point value of the first character in the string C which is assumed to be in UTF-8 encoding and no longer than C; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, the behaviour is dependent on the value of C: if it contains UTF8_CHECK_ONLY, it is assumed that the caller will raise a warning, and this function will silently just set C to C<-1> and return zero. If the C does not contain UTF8_CHECK_ONLY, warnings about malformations will be given, C will be set to the expected length of the UTF-8 character in bytes, and zero will be returned. The C can also contain various flags to allow deviations from the strict UTF-8 encoding (see F). Most code should use utf8_to_uvchr() rather than call this directly. UV utf8n_to_uvuni(U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvuni'},'av_create_and_unshift_one' => {'text' => 'Unshifts an SV onto the beginning of the array, creating the array if necessary. A small internal helper function to remove a commonly duplicated idiom. NOTE: this function is experimental and may change or be removed without notice. SV** av_create_and_unshift_one(AV **const avp, SV *const val)','name' => 'av_create_and_unshift_one'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'newSVpvn_utf8' => {'text' => 'Creates a new SV and copies a string into it. If utf8 is true, calls C on the new SV. Implemented as a wrapper around C. SV* newSVpvn_utf8(NULLOK const char* s, STRLEN len, U32 utf8)','name' => 'newSVpvn_utf8'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C to type C if necessary, then adds a new magic item of type C to the head of the magic list. See C (which C now calls) for a description of the handling of the C and C arguments. You need to use C to add magic to SvREADONLY SVs and also to add more than one instance of the same \'how\'. void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen)','name' => 'sv_magic'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'sv_utf8_upgrade_flags' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade_flags(SV *sv, I32 flags)','name' => 'sv_utf8_upgrade_flags'},'ibcmp_utf8' => {'text' => 'Return true if the strings s1 and s2 differ case-insensitively, false if not (if they are equal case-insensitively). If u1 is true, the string s1 is assumed to be in UTF-8-encoded Unicode. If u2 is true, the string s2 is assumed to be in UTF-8-encoded Unicode. If u1 or u2 are false, the respective string is assumed to be in native 8-bit encoding. If the pe1 and pe2 are non-NULL, the scanning pointers will be copied in there (they will point at the beginning of the I character). If the pointers behind pe1 or pe2 are non-NULL, they are the end pointers beyond which scanning will not continue under any circumstances. If the byte lengths l1 and l2 are non-zero, s1+l1 and s2+l2 will be used as goal end pointers that will also stop the scan, and which qualify towards defining a successful match: all the scans that define an explicit length must reach their goal pointers for a match to succeed). For case-insensitiveness, the "casefolding" of Unicode is used instead of upper/lowercasing both the characters, see http://www.unicode.org/unicode/reports/tr21/ (Case Mappings). I32 ibcmp_utf8(const char* a, char **pe1, UV l1, bool u1, const char* b, char **pe2, UV l2, bool u2)','name' => 'ibcmp_utf8'},'SvREFCNT_inc_void' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value. The macro doesn\'t need to return a meaningful value. void SvREFCNT_inc_void(SV* sv)','name' => 'SvREFCNT_inc_void'},'mXPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Does not use C. See also C, C and C. void mXPUSHp(char* str, STRLEN len)','name' => 'mXPUSHp'},'CvSTASH' => {'text' => 'Returns the stash of the CV. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'gv_const_sv' => {'text' => 'If C is a typeglob whose subroutine entry is a constant sub eligible for inlining, or C is a placeholder reference that would be promoted to such a typeglob, then returns the value returned by the sub. Otherwise, returns NULL. SV* gv_const_sv(GV* gv)','name' => 'gv_const_sv'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. The target SV physically takes over ownership of the body of the source SV and inherits its flags; however, the target keeps any magic it owns, and any magic in the source is discarded. Note that this is a rather specialist SV copying operation; most of the time you\'ll want to use C or one of its many macro front-ends. void sv_replace(SV* sv, SV* nsv)','name' => 'sv_replace'},'utf8n_to_uvchr' => {'text' => 'flags Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. Allows length and flags to be passed to low level routine. UV utf8n_to_uvchr(U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvchr'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and L.','name' => 'G_ARRAY'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'SvROK' => {'text' => 'Tests if the SV is an RV. U32 SvROK(SV* sv)','name' => 'SvROK'},'mXPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void mXPUSHn(NV nv)','name' => 'mXPUSHn'},'sv_unref' => {'text' => '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. This is C with the C being zero. See C. void sv_unref(SV* sv)','name' => 'sv_unref'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dstr, SV *sstr)','name' => 'sv_catsv_mg'},'call_argv' => {'text' => '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)','name' => 'call_argv'},'SvPV_nolen' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified form becoming C. Handles \'get\' magic. char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'perl_clone' => {'text' => '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->create 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 C, 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)','name' => 'perl_clone'},'sv_setnv' => {'text' => 'Copies a double into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setnv(SV* sv, NV num)','name' => 'sv_setnv'},'sv_2nv' => {'text' => 'Return the num value of an SV, doing any necessary string or integer conversion, magic etc. Normally used via the C and C macros. NV sv_2nv(SV* sv)','name' => 'sv_2nv'},'SvREFCNT_inc_simple_NN' => {'text' => 'Same as SvREFCNT_inc_simple, but can only be used if you know I is not NULL. Since we don\'t have to check the NULLness, it\'s faster and smaller. SV* SvREFCNT_inc_simple_NN(SV* sv)','name' => 'SvREFCNT_inc_simple_NN'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'hv_fetchs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV** hv_fetchs(HV* tb, const char* key, I32 lval)','name' => 'hv_fetchs'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1. HV* newHV()','name' => 'newHV'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or false. bool strNE(char* s1, char* s2)','name' => 'strNE'},'sv_pvutf8n_force' => {'text' => 'The backend for the C macro. Always use the macro instead. char* sv_pvutf8n_force(SV* sv, STRLEN* lp)','name' => 'sv_pvutf8n_force'},'savepv' => {'text' => 'Perl\'s version of C. Returns a pointer to a newly allocated string which is a duplicate of C. The size of the string is determined by C. The memory allocated for the new string can be freed with the C function. char* savepv(const char* pv)','name' => 'savepv'},'SvNV_set' => {'text' => 'Set the value of the NV pointer in sv to val. See C. void SvNV_set(SV* sv, NV val)','name' => 'SvNV_set'},'bytes_from_utf8' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike C but like C, returns a pointer to the newly-created string, and updates C to contain the new length. Returns the original string if no conversion occurs, C is unchanged. Do nothing if C points to 0. Sets C to 0 if C is converted or contains all 7bit characters. NOTE: this function is experimental and may change or be removed without notice. U8* bytes_from_utf8(U8 *s, STRLEN *len, bool *is_utf8)','name' => 'bytes_from_utf8'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1. AV* newAV()','name' => 'newAV'},'HvNAME' => {'text' => 'Returns the package name of a stash, or NULL if C isn\'t a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV of the sv is assumed to be octets in that encoding, and the sv will be converted into Unicode (and UTF-8). If the sv already is UTF-8 (or if it is not POK), or if the encoding is not a reference, nothing is done to the sv. If the encoding is not an C Encoding object, bad things will happen. (See F and L). The PV of the sv is returned. char* sv_recode_to_utf8(SV* sv, SV *encoding)','name' => 'sv_recode_to_utf8'},'av_make' => {'text' => '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)','name' => 'av_make'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. See C for a version which guarantees to evaluate sv only once. UV SvUV(SV* sv)','name' => 'SvUV'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L. int perl_run(PerlInterpreter* interp)','name' => 'perl_run'},'sv_catsv_flags' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. If C has C bit set, will C on the SVs if appropriate, else not. C and C are implemented in terms of this function. void sv_catsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_catsv_flags'},'SvPVutf8_nolen' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_nolen(SV* sv)','name' => 'SvPVutf8_nolen'},'sv_setpviv' => {'text' => '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)','name' => 'sv_setpviv'},'sv_true' => {'text' => 'Returns true if the SV has a true value by Perl\'s rules. Use the C macro instead, which may call C or may instead use an in-line version. I32 sv_true(SV *sv)','name' => 'sv_true'},'sv_derived_from' => {'text' => 'Returns a boolean indicating whether the SV is derived from the specified class I. To check derivation at the Perl level, call C as a normal Perl method. bool sv_derived_from(SV* sv, const char* name)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp_locale(SV* sv1, SV* sv2)','name' => 'sv_cmp_locale'},'sv_catpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_catpvs(SV* sv, const char* s)','name' => 'sv_catpvs'},'hv_exists' => {'text' => '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, I32 klen)','name' => 'hv_exists'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'Nullsv' => {'text' => 'Null SV pointer.','name' => 'Nullsv'},'mg_length' => {'text' => 'Report on the SV\'s length. See C. U32 mg_length(SV* sv)','name' => 'mg_length'},'SvPVX' => {'text' => 'Returns a pointer to the physical string in the SV. The SV must contain a string. char* SvPVX(SV* sv)','name' => 'SvPVX'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'HEf_SVKEY' => {'text' => 'This flag, used in the length slot of hash entries and magic structures, specifies the structure contains an C pointer where a C pointer is to be expected. (For information only--not to be used).','name' => 'HEf_SVKEY'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C in characters. Stops at C (inclusive). If C s> or if the scan would end up past C, croaks. STRLEN utf8_length(U8* s, U8 *e)','name' => 'utf8_length'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted if tainting is enabled. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'SvIOK_only_UV' => {'text' => 'Tells and SV that it is an unsigned integer and disables all other OK bits. void SvIOK_only_UV(SV* sv)','name' => 'SvIOK_only_UV'},'sv_nolocking' => {'text' => '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. "Superseded" by sv_nosharing(). void sv_nolocking(SV *sv)','name' => 'sv_nolocking'},'sv_vcatpvfn' => {'text' => '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). XXX Except that it maybe_tainted is never assigned to. Usually used via one of its frontends C and C. void sv_vcatpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vcatpvfn'},'strLT' => {'text' => '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)','name' => 'strLT'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_shift(AV* ar)','name' => 'av_shift'},'sv_pvutf8n' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n(SV *sv, STRLEN *len)','name' => 'sv_pvutf8n'},'newSV' => {'text' => '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 trailing 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. In 5.9.3, newSV() replaces the older NEWSV() API, and drops the first parameter, I, a debug aid which allowed callers to identify themselves. This aid has been superseded by a new build option, PERL_MEM_LOG (see L). The older API is still there for use in XS modules supporting older perls. SV* newSV(STRLEN len)','name' => 'newSV'},'sv_2pvutf8' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV, and set *lp to its length. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8(SV* sv, STRLEN* lp)','name' => 'sv_2pvutf8'},'sv_nounlocking' => {'text' => '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. "Superseded" by sv_nosharing(). void sv_nounlocking(SV *sv)','name' => 'sv_nounlocking'},'dITEMS' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dITEMS;','name' => 'dITEMS'},'SvUV_set' => {'text' => 'Set the value of the UV pointer in sv to val. See C. void SvUV_set(SV* sv, UV val)','name' => 'SvUV_set'},'CopyD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * CopyD(void* src, void* dest, int nitems, type)','name' => 'CopyD'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *sv, IV i)','name' => 'sv_setiv_mg'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C. See C and L for other uses. PUTBACK;','name' => 'PUTBACK'},'savesharedpvn' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. (With the specific difference that a NULL pointer is not acceptable) char* savesharedpvn(const char *const pv, const STRLEN len)','name' => 'savesharedpvn'},'dAXMARK' => {'text' => 'Sets up the C variable and stack marker variable C. This is usually handled automatically by C by calling C. dAXMARK;','name' => 'dAXMARK'},'SvCUR_set' => {'text' => 'Set the current length of the string which is in the SV. See C and C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'sv_2uv_flags' => {'text' => 'Return the unsigned integer value of an SV, doing any necessary string conversion. If flags includes SV_GMAGIC, does an mg_get() first. Normally used via the C and C macros. UV sv_2uv_flags(SV* sv, I32 flags)','name' => 'sv_2uv_flags'},'SvNOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a double. U32 SvNOK(SV* sv)','name' => 'SvNOK'},'mPUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void mPUSHn(NV nv)','name' => 'mPUSHn'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C, C, and L.','name' => 'G_SCALAR'},'sv_reset' => {'text' => 'Underlying implementation for the C Perl function. Note that the perl-level function is vaguely deprecated. void sv_reset(char* s, HV* stash)','name' => 'sv_reset'},'sv_2pv_flags' => {'text' => 'Returns a pointer to the string value of an SV, and sets *lp to its length. If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string if necessary. Normally invoked via the C macro. C and C usually end up here too. char* sv_2pv_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_2pv_flags'},'SvTAINTED_off' => {'text' => '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)','name' => 'SvTAINTED_off'},'SvNVx' => {'text' => 'Coerces the given SV to a double and returns it. Guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. NV SvNVx(SV* sv)','name' => 'SvNVx'},'require_pv' => {'text' => 'Tells Perl to C the file named by the string argument. It is analogous to the Perl code C. 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)','name' => 'require_pv'},'sv_upgrade' => {'text' => 'Upgrade an SV to a more complex form. Generally adds a new body type to the SV, then copies across as much information as possible from the old body. You generally want to use the C macro wrapper. See also C. bool sv_upgrade(SV* sv, U32 mt)','name' => 'sv_upgrade'},'strEQ' => {'text' => 'Test two strings to see if they are equal. Returns true or false. bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'hv_store' => {'text' => '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. Effectively a successful hv_store takes ownership of one reference to C. 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 L 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)','name' => 'hv_store'},'isUPPER' => {'text' => 'Returns a boolean indicating whether the C C is an uppercase character. bool isUPPER(char ch)','name' => 'isUPPER'},'sv_setsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setsv_mg(SV *dstr, SV *sstr)','name' => 'sv_setsv_mg'},'hv_fetch_ent' => {'text' => '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)','name' => 'hv_fetch_ent'},'isLOWER' => {'text' => 'Returns a boolean indicating whether the C C is a lowercase character. bool isLOWER(char ch)','name' => 'isLOWER'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See C. char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'SvNOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a double. Checks the B setting. Use C. U32 SvNOKp(SV* sv)','name' => 'SvNOKp'},'Newx' => {'text' => 'The XSUB-writer\'s interface to the C C function. In 5.9.3, Newx() and friends replace the older New() API, and drops the first parameter, I, a debug aid which allowed callers to identify themselves. This aid has been superseded by a new build option, PERL_MEM_LOG (see L). The older API is still there for use in XS modules supporting older perls. void Newx(void* ptr, int nitems, type)','name' => 'Newx'},'PUSHs' => {'text' => 'Push an SV onto the stack. The stack must have room for this element. Does not handle \'set\' magic. Does not use C. See also C, C and C. void PUSHs(SV* sv)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setuv(SV* sv, UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'utf8_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvchr(U8 *s, STRLEN *retlen)','name' => 'utf8_to_uvchr'},'nothreadhook' => {'text' => 'Stub that provides thread hook for perl_destruct when there are no threads. int nothreadhook()','name' => 'nothreadhook'},'bytes_to_utf8' => {'text' => 'Converts a string C of length C from ASCII into UTF-8 encoding. Returns a pointer to the newly-created string, and sets C to reflect the new length. If you want to convert to UTF-8 from other encodings than ASCII, see sv_recode_to_utf8(). NOTE: this function is experimental and may change or be removed without notice. U8* bytes_to_utf8(U8 *s, STRLEN *len)','name' => 'bytes_to_utf8'},'SvIsCOW_shared_hash' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write shared hash key scalar. bool SvIsCOW_shared_hash(SV* sv)','name' => 'SvIsCOW_shared_hash'},'sv_pvn' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn(SV *sv, STRLEN *len)','name' => 'sv_pvn'},'sv_setref_iv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_iv(SV* rv, const char* classname, IV iv)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => '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. Uses the "OOK hack". Beware: after this function returns, C and SvPVX_const(sv) may no longer refer to the same chunk of data. void sv_chop(SV* sv, char* ptr)','name' => 'sv_chop'},'sv_backoff' => {'text' => 'Remove any string offset. You should normally use the C macro wrapper instead. int sv_backoff(SV* sv)','name' => 'sv_backoff'},'sv_catsv_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_catsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_catsv_nomg'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setuv_mg(SV *sv, UV u)','name' => 'sv_setuv_mg'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually handled automatically by C. See C.','name' => 'XS_VERSION'},'PL_na' => {'text' => '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','name' => 'PL_na'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the SV is set to 1. SV* newSViv(IV i)','name' => 'newSViv'},'sv_untaint' => {'text' => 'Untaint an SV. Use C instead. void sv_untaint(SV* sv)','name' => 'sv_untaint'},'sv_setpv' => {'text' => '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)','name' => 'sv_setpv'},'Newxz' => {'text' => 'The XSUB-writer\'s interface to the C C function. The allocated memory is zeroed with C. See also C. void Newxz(void* ptr, int nitems, type)','name' => 'Newxz'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See C.','name' => 'SVt_PVHV'},'SvGROW' => {'text' => '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)','name' => 'SvGROW'},'gv_fetchmethod' => {'text' => 'See L. GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'dMULTICALL' => {'text' => 'Declare local variables for a multicall. See L. dMULTICALL;','name' => 'dMULTICALL'},'sv_catpv' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpv(SV* sv, const char* ptr)','name' => 'sv_catpv'},'sv_len' => {'text' => 'Returns the length of the string in the SV. Handles magic and type coercion. See also C, which gives raw access to the xpv_cur slot. STRLEN sv_len(SV* sv)','name' => 'sv_len'},'SvPVbyte_nolen' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_nolen(SV* sv)','name' => 'SvPVbyte_nolen'},'sv_pvutf8' => {'text' => 'Use the C macro instead char* sv_pvutf8(SV *sv)','name' => 'sv_pvutf8'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See C.','name' => 'SVt_PVAV'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L. LEAVE;','name' => 'LEAVE'},'hv_undef' => {'text' => 'Undefines the hash. void hv_undef(HV* tb)','name' => 'hv_undef'},'SvSetMagicSV_nosteal' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetMagicSV_nosteal'},'hv_delete_ent' => {'text' => '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)','name' => 'hv_delete_ent'},'CLASS' => {'text' => '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','name' => 'CLASS'},'savesvpv' => {'text' => 'A version of C/C which gets the string to duplicate from the passed in SV using C char* savesvpv(SV* sv)','name' => 'savesvpv'},'sv_isobject' => {'text' => '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)','name' => 'sv_isobject'},'sv_pvn_force_flags' => {'text' => 'Get a sensible string out of the SV somehow. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You normally want to use the various wrapper macros instead: see C and C char* sv_pvn_force_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_pvn_force_flags'},'HeKLEN' => {'text' => '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)','name' => 'HeKLEN'},'to_utf8_title' => {'text' => 'Convert the UTF-8 encoded character at p to its titlecase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the titlecase version may be longer than the original character. The first character of the titlecased version is returned (but note, as explained above, that there may be more.) UV to_utf8_title(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_title'},'mPUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void mPUSHi(IV iv)','name' => 'mPUSHi'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHn(NV nv)','name' => 'PUSHn'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it. See C for a version which guarantees to evaluate sv only once. IV SvIV(SV* sv)','name' => 'SvIV'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. SV PL_sv_yes','name' => 'PL_sv_yes'},'sv_nosharing' => {'text' => 'Dummy routine which "shares" an SV when there is no sharing module present. Or "locks" it. Or "unlocks" it. In other words, ignores its single SV argument. 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 *sv)','name' => 'sv_nosharing'},'SvUTF8_off' => {'text' => 'Unsets the UTF-8 status of an SV. void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'looks_like_number' => {'text' => 'Test if the content of an SV looks like a number (or is a number). C and C are treated as numbers (so will not issue a non-numeric warning), even if your atof() doesn\'t grok them. I32 looks_like_number(SV* sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpv_mg(SV *sv, const char *ptr)','name' => 'sv_catpv_mg'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'sv_setref_uv' => {'text' => 'Copies an unsigned 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 have a reference count of 1, and the RV will be returned. SV* sv_setref_uv(SV* rv, const char* classname, UV uv)','name' => 'sv_setref_uv'},'getcwd_sv' => {'text' => 'Fill the sv with current working directory int getcwd_sv(SV* sv)','name' => 'getcwd_sv'},'newSVpvs_share' => {'text' => 'Like C, but takes a literal string instead of a string/length pair and omits the hash parameter. SV* newSVpvs_share(const char* s)','name' => 'newSVpvs_share'},'newSVpv' => {'text' => '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)','name' => 'newSVpv'},'sv_2pvbyte' => {'text' => 'Return a pointer to the byte-encoded representation of the SV, and set *lp to its length. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte(SV* sv, STRLEN* lp)','name' => 'sv_2pvbyte'},'fbm_instr' => {'text' => '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)','name' => 'fbm_instr'},'sv_setpvf' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Does not handle \'set\' magic. See C. void sv_setpvf(SV* sv, const char* pat, ...)','name' => 'sv_setpvf'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHn(NV nv)','name' => 'XPUSHn'},'SVt_PV' => {'text' => 'Pointer type flag for scalars. See C.','name' => 'SVt_PV'},'call_sv' => {'text' => '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, VOL I32 flags)','name' => 'call_sv'},'strGT' => {'text' => '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)','name' => 'strGT'},'mXPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary and mortalizes the SV. Does not use C. See also C and C. void mXPUSHs(SV* sv)','name' => 'mXPUSHs'},'sv_vcatpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. Does not handle \'set\' magic. See C. Usually used via its frontend C. void sv_vcatpvf(SV* sv, const char* pat, va_list* args)','name' => 'sv_vcatpvf'},'sv_pos_u2b' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from the start of the string, to a count of the equivalent number of bytes; if lenp is non-zero, it does the same to lenp, but this time starting from the offset, rather than from the start of the string. Handles magic and type coercion. void sv_pos_u2b(SV* sv, I32* offsetp, I32* lenp)','name' => 'sv_pos_u2b'},'HeSVKEY_set' => {'text' => '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)','name' => 'HeSVKEY_set'},'POPl' => {'text' => 'Pops a long off the stack. long POPl','name' => 'POPl'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L. SPAGAIN;','name' => 'SPAGAIN'},'SvIOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains an integer. Checks the B setting. Use C. U32 SvIOKp(SV* sv)','name' => 'SvIOKp'},'get_cv' => {'text' => 'Uses C to get the length of C, then calls C. NOTE: the perl_ form of this function is deprecated. CV* get_cv(const char* name, I32 flags)','name' => 'get_cv'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the stack. void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'SvUNLOCK' => {'text' => 'Releases a mutual exclusion lock on sv if a suitable module has been loaded. void SvUNLOCK(SV* sv)','name' => 'SvUNLOCK'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C. int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV (using C). The new SV is marked as mortal. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_mortalcopy(SV* oldsv)','name' => 'sv_mortalcopy'},'sv_catpvn_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_catpvn_nomg(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn_nomg'},'newSVpvs_flags' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV* newSVpvs_flags(const char* s, U32 flags)','name' => 'newSVpvs_flags'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See L.','name' => 'G_NOARGS'},'savepvn' => {'text' => 'Perl\'s version of what C would be if it existed. Returns a pointer to a newly allocated string which is a duplicate of the first C bytes from C, plus a trailing NUL byte. The memory allocated for the new string can be freed with the C function. char* savepvn(const char* pv, I32 len)','name' => 'savepvn'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized. This relies on the fact that uninitialized array elements are set to C<&PL_sv_undef>. bool av_exists(AV* ar, I32 key)','name' => 'av_exists'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C. STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'sv_bless' => {'text' => '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)','name' => 'sv_bless'},'sv_isa' => {'text' => '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)','name' => 'sv_isa'},'sv_catpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. If the appended data contains "wide" characters (including, but not limited to, SVs with a UTF-8 PV formatted with %s, and characters >255 formatted with %c), the original SV might get upgraded to UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. If the original SV was UTF-8, the pattern should be valid UTF-8; if the original SV was bytes, the pattern should be too. void sv_catpvf(SV* sv, const char* pat, ...)','name' => 'sv_catpvf'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C. void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'utf8_to_uvuni' => {'text' => 'Returns the Unicode code point of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. This function should only be used when returned UV is considered an index into the Unicode semantic tables (e.g. swashes). If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvuni(U8 *s, STRLEN *retlen)','name' => 'utf8_to_uvuni'},'sv_2io' => {'text' => 'Using various gambits, try to get an IO from an SV: the IO slot if its a GV; or the recursive result if we\'re an RV; or the IO slot of the symbol named after the PV if we\'re a string. IO* sv_2io(SV* sv)','name' => 'sv_2io'},'SvMAGIC_set' => {'text' => 'Set the value of the MAGIC pointer in sv to val. See C. void SvMAGIC_set(SV* sv, MAGIC* val)','name' => 'SvMAGIC_set'},'newSVhek' => {'text' => 'Creates a new SV from the hash key structure. It will generate scalars that point to the shared string table where possible. Returns a new (undefined) SV if the hek is NULL. SV* newSVhek(const HEK *hek)','name' => 'newSVhek'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphabetic character. bool isALPHA(char ch)','name' => 'isALPHA'},'Nullhv' => {'text' => 'Null HV pointer.','name' => 'Nullhv'},'av_fill' => {'text' => 'Set the highest index in the array to the given number, equivalent to Perl\'s C<$#array = $fill;>. The number of elements in the an array will be C after av_fill() returns. If the array was previously shorter then the additional elements appended are set to C. If the array was longer, then the excess elements are freed. C is the same as C. void av_fill(AV* ar, I32 fill)','name' => 'av_fill'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV. All of the following SvREFCNT_inc* macros are optimized versions of SvREFCNT_inc, and can be replaced with SvREFCNT_inc. SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C. svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'MoveD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * MoveD(void* src, void* dest, int nitems, type)','name' => 'MoveD'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'grok_bin' => {'text' => 'converts a string representing a binary number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*flags> gives output flags. If the value is <= C it is returned as a UV, the output flags are clear, and nothing is written to I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The binary number may optionally be prefixed with "0b" or "b" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the binary number may use \'_\' characters to separate digits. UV grok_bin(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_bin'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L. void perl_free(PerlInterpreter* interp)','name' => 'perl_free'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C. MAGIC* mg_find(SV* sv, int type)','name' => 'mg_find'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'XPUSHmortal' => {'text' => 'Push a new mortal SV onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void XPUSHmortal()','name' => 'XPUSHmortal'},'newSVpvn_share' => {'text' => 'Creates a new SV with its SvPVX_const pointing to a shared string in the string table. If the string does not already exist in the table, it is created first. Turns on READONLY and FAKE. If the C parameter is non-zero, that value is used; otherwise the hash is computed. The string\'s hash can be later be retrieved from the SV with the C macro. The idea here is that as the string table is used for shared hash keys these strings will have SvPVX_const == HeKEY and hash lookup will avoid string compare. SV* newSVpvn_share(const char* s, I32 len, U32 hash)','name' => 'newSVpvn_share'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_setpvf_mg'},'SvPOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a character string. Checks the B setting. Use C. U32 SvPOKp(SV* sv)','name' => 'SvPOKp'},'sv_catpvn' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn'},'sv_setref_pv' => {'text' => '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 have a reference count of 1, and the RV will be returned. 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)','name' => 'sv_setref_pv'},'fbm_compile' => {'text' => '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)','name' => 'fbm_compile'},'sv_utf8_downgrade' => {'text' => 'Attempts to convert the PV of an SV from characters to bytes. If the PV contains a character beyond byte, this conversion will fail; in this case, either returns false or, if C is not true, croaks. This is not as a general purpose Unicode to byte encoding interface: use the Encode extension for that. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_downgrade(SV *sv, bool fail_ok)','name' => 'sv_utf8_downgrade'},'SvNIOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a number, integer or double. Checks the B setting. Use C. U32 SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either forward or backward. WARNING: do not use the following unless you *know* C is within the UTF-8 data pointed to by C *and* that on entry C is aligned on the first byte of character or just after the last byte of a character. U8* utf8_hop(U8 *s, I32 off)','name' => 'utf8_hop'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide UTF-8 bytes as a single character. Handles magic and type coercion. STRLEN sv_len_utf8(SV* sv)','name' => 'sv_len_utf8'},'sv_setref_pvn' => {'text' => '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 have a reference count of 1, and the RV will be returned. Note that C copies the pointer while this copies the string. SV* sv_setref_pvn(SV* rv, const char* classname, char* pv, STRLEN n)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for blessed scalars. See C.','name' => 'SVt_PVMG'},'PUSHp' => {'text' => '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. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHp(char* str, STRLEN len)','name' => 'PUSHp'},'SvREFCNT_inc_simple_void' => {'text' => 'Same as SvREFCNT_inc_simple, but can only be used if you don\'t need the return value. The macro doesn\'t need to return a meaningful value. void SvREFCNT_inc_simple_void(SV* sv)','name' => 'SvREFCNT_inc_simple_void'},'hv_clear_placeholders' => {'text' => '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)','name' => 'hv_clear_placeholders'},'mXPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void mXPUSHi(IV iv)','name' => 'mXPUSHi'},'dAX' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dAX;','name' => 'dAX'},'PL_sv_undef' => {'text' => 'This is the C SV. Always refer to this as C<&PL_sv_undef>. SV PL_sv_undef','name' => 'PL_sv_undef'},'SvRV_set' => {'text' => 'Set the value of the RV pointer in sv to val. See C. void SvRV_set(SV* sv, SV* val)','name' => 'SvRV_set'},'hv_iterkeysv' => {'text' => '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)','name' => 'hv_iterkeysv'},'grok_number' => {'text' => '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)','name' => 'grok_number'},'SvIVx' => {'text' => 'Coerces the given SV to an integer and returns it. Guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. IV SvIVx(SV* sv)','name' => 'SvIVx'},'grok_numeric_radix' => {'text' => 'Scan and skip for a numeric decimal separator (radix). bool grok_numeric_radix(const char **sp, const char *send)','name' => 'grok_numeric_radix'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the stack. void XST_mNO(int pos)','name' => 'XST_mNO'},'mPUSHp' => {'text' => 'Push a string onto the stack. The stack must have room for this element. The C indicates the length of the string. Does not use C. See also C, C and C. void mPUSHp(char* str, STRLEN len)','name' => 'mPUSHp'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array. Returns the deleted element. If C equals C, the element is freed and null is returned. SV* av_delete(AV* ar, I32 key, I32 flags)','name' => 'av_delete'},'utf8_distance' => {'text' => 'Returns the number of UTF-8 characters between the UTF-8 pointers C and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. IV utf8_distance(U8 *a, U8 *b)','name' => 'utf8_distance'},'SvPV_nomg' => {'text' => 'Like C but doesn\'t process magic. char* SvPV_nomg(SV* sv, STRLEN len)','name' => 'SvPV_nomg'},'savepvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. char* savepvs(const char* s)','name' => 'savepvs'},'SvSTASH_set' => {'text' => 'Set the value of the STASH pointer in sv to val. See C. void SvSTASH_set(SV* sv, HV* val)','name' => 'SvSTASH_set'},'sv_collxfrm' => {'text' => 'Add Collate Transform magic to an SV if it doesn\'t already have it. Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the scalar data of the variable, but transformed to such a format that a normal memory comparison can be used to compare the data according to the locale settings. char* sv_collxfrm(SV* sv, STRLEN* nxp)','name' => 'sv_collxfrm'},'ZeroD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * ZeroD(void* dest, int nitems, type)','name' => 'ZeroD'},'SvUV_nomg' => {'text' => 'Like C but doesn\'t process magic. UV SvUV_nomg(SV* sv)','name' => 'SvUV_nomg'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'POPpx' => {'text' => 'Pops a string off the stack. char* POPpx','name' => 'POPpx'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'gv_stashpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. HV* gv_stashpvs(const char* name, I32 create)','name' => 'gv_stashpvs'},'Zero' => {'text' => '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)','name' => 'Zero'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'sv_setpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_setpvs(SV* sv, const char* s)','name' => 'sv_setpvs'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_iv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. IV sv_iv(SV* sv)','name' => 'sv_iv'},'pv_escape' => {'text' => 'Escapes at most the first "count" chars of pv and puts the results into dsv such that the size of the escaped string will not exceed "max" chars and will not contain any incomplete escape sequences. If flags contains PERL_PV_ESCAPE_QUOTE then any double quotes in the string will also be escaped. Normally the SV will be cleared before the escaped string is prepared, but when PERL_PV_ESCAPE_NOCLEAR is set this will not occur. If PERL_PV_ESCAPE_UNI is set then the input string is treated as Unicode, if PERL_PV_ESCAPE_UNI_DETECT is set then the input string is scanned using C to determine if it is Unicode. If PERL_PV_ESCAPE_ALL is set then all input chars will be output using C<\\x01F1> style escapes, otherwise only chars above 255 will be escaped using this style, other non printable chars will use octal or common escaped patterns like C<\\n>. If PERL_PV_ESCAPE_NOBACKSLASH then all chars below 255 will be treated as printable and will be output as literals. If PERL_PV_ESCAPE_FIRSTCHAR is set then only the first char of the string will be escaped, regardles of max. If the string is utf8 and the chars value is >255 then it will be returned as a plain hex sequence. Thus the output will either be a single char, an octal escape sequence, a special escape like C<\\n> or a 3 or more digit hex value. Returns a pointer to the escaped text as held by dsv. char* pv_escape(SV *dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags)','name' => 'pv_escape'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C.','name' => 'SVt_PVCV'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpviv_mg(SV *sv, IV iv)','name' => 'sv_setpviv_mg'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. Guarantees to C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'sv_2bool' => {'text' => 'This function is only called on magical items, and is only used by sv_true() or its macro equivalent. bool sv_2bool(SV* sv)','name' => 'sv_2bool'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'sv_newmortal' => {'text' => 'Creates a new null SV which is mortal. The reference count of the SV is set to 1. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_newmortal()','name' => 'sv_newmortal'},'sv_clear' => {'text' => 'Clear an SV: call any destructors, free up any memory used by the body, and free the body itself. The SV\'s head is I freed, although its type is set to all 1\'s so that it won\'t inadvertently be assumed to be live during global destruction etc. This function should only be called when REFCNT is zero. Most of the time you\'ll want to call C (or its macro wrapper C) instead. void sv_clear(SV* sv)','name' => 'sv_clear'},'SvOOK' => {'text' => 'Returns a U32 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). U32 SvOOK(SV* sv)','name' => 'SvOOK'},'SvPV_set' => {'text' => 'Set the value of the PV pointer in sv to val. See C. void SvPV_set(SV* sv, char* val)','name' => 'SvPV_set'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'svtype' => {'text' => '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.','name' => 'svtype'},'load_module' => {'text' => '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 C. The optional trailing SV* arguments can be used to specify arguments to the module\'s import() method, similar to C. void load_module(U32 flags, SV* name, SV* ver, ...)','name' => 'load_module'},'get_hv' => {'text' => '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)','name' => 'get_hv'},'hv_clear' => {'text' => 'Clears a hash, making it empty. void hv_clear(HV* tb)','name' => 'hv_clear'},'PoisonNew' => {'text' => 'PoisonWith(0xAB) for catching access to allocated but uninitialized memory. void PoisonNew(void* dest, int nitems, type)','name' => 'PoisonNew'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES;','name' => 'XSRETURN_YES'},'sv_nv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. NV sv_nv(SV* sv)','name' => 'sv_nv'},'Poison' => {'text' => 'PoisonWith(0xEF) for catching access to freed memory. void Poison(void* dest, int nitems, type)','name' => 'Poison'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_catpvf_mg'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHu(UV uv)','name' => 'PUSHu'},'get_sv' => {'text' => '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)','name' => 'get_sv'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. (Uses C). SV* newSVsv(SV* old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C. void hv_magic(HV* hv, GV* gv, int how)','name' => 'hv_magic'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *sv, const char *ptr)','name' => 'sv_setpv_mg'},'sv_2mortal' => {'text' => 'Marks an existing SV as mortal. The SV will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. SvTEMP() is turned on which means that the SV\'s string buffer can be "stolen" if this SV is copied. See also C and C. SV* sv_2mortal(SV* sv)','name' => 'sv_2mortal'},'XCPT_TRY_END' => {'text' => 'Ends a try block. See L.','name' => 'XCPT_TRY_END'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself. void av_undef(AV* ar)','name' => 'av_undef'},'HeKEY' => {'text' => '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)','name' => 'HeKEY'},'pack_cat' => {'text' => '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)','name' => 'pack_cat'},'sv_cmp' => {'text' => '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. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp(SV* sv1, SV* sv2)','name' => 'sv_cmp'},'SvEND' => {'text' => '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)','name' => 'SvEND'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C, C or C for void, scalar or list context, respectively. U32 GIMME_V','name' => 'GIMME_V'},'sv_force_normal_flags' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. The C parameter gets passed to C when unrefing. C calls this function with flags set to 0. void sv_force_normal_flags(SV *sv, U32 flags)','name' => 'sv_force_normal_flags'},'sv_setsv_flags' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. If the C parameter has the C bit set, will C on C if appropriate, else not. If the C parameter has the C bit set then the buffers of temps will not be stolen. and C are implemented in terms of this function. You probably want to use one of the assortment of wrappers, such as C, C, C and C. This is the primary function for copying scalars, and most other copy-ish functions and macros use this underneath. void sv_setsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_setsv_flags'},'is_utf8_char' => {'text' => 'Tests if some arbitrary number of bytes begins in a valid UTF-8 character. Note that an INVARIANT (i.e. ASCII) character is a valid UTF-8 character. The actual number of bytes in the UTF-8 character will be returned if it is valid, otherwise 0. STRLEN is_utf8_char(U8 *p)','name' => 'is_utf8_char'},'Copy' => {'text' => '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)','name' => 'Copy'},'sv_taint' => {'text' => 'Taint an SV. Use C instead. void sv_taint(SV* sv)','name' => 'sv_taint'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'sv_utf8_upgrade' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains a signed integer. bool SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. Sets up the C and C variables by calling C and C. This is usually handled automatically by C. dXSARGS;','name' => 'dXSARGS'},'savesharedpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the C C is whitespace. bool isSPACE(char ch)','name' => 'isSPACE'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* ptr)','name' => 'Safefree'},'gv_stashpvn' => {'text' => 'Returns a pointer to the stash for a specified package. The C parameter indicates the length of the C, in bytes. C is passed to C, so if set to C then the package will be created if it does not already exist. If the package does not exist and C is 0 (or any other setting that does not create packages) then NULL is returned. HV* gv_stashpvn(const char* name, U32 namelen, I32 flags)','name' => 'gv_stashpvn'},'mPUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void mPUSHu(UV uv)','name' => 'mPUSHu'},'newSV_type' => {'text' => 'Creates a new SV, of the type specified. The reference count for the new SV is set to 1. SV* newSV_type(svtype type)','name' => 'newSV_type'},'sv_setsv_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_setsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_setsv_nomg'},'SvREFCNT_inc_void_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value, and you know that I is not NULL. The macro doesn\'t need to return a meaningful value, or check for NULLness, so it\'s smaller and faster. void SvREFCNT_inc_void_NN(SV* sv)','name' => 'SvREFCNT_inc_void_NN'},'Perl_signbit' => {'text' => 'Return a non-zero integer if the sign bit on an NV is set, and 0 if it is not. If Configure detects this system has a signbit() that will work with our NVs, then we just use it via the #define in perl.h. Otherwise, fall back on this implementation. As a first pass, this gets everything right except -0.0. Alas, catching -0.0 is the main use for this function, so this is not too helpful yet. Still, at least we have the scaffolding in place to support other systems, should that prove useful. Configure notes: This function is called \'Perl_signbit\' instead of a plain \'signbit\' because it is easy to imagine a system having a signbit() function or macro that doesn\'t happen to work with our particular choice of NVs. We shouldn\'t just re-#define signbit as Perl_signbit and expect the standard system headers to be happy. Also, this is a no-context function (no pTHX_) because Perl_signbit() is usually re-#defined in perl.h as a simple macro call to the system\'s signbit(). Users should just always call Perl_signbit(). NOTE: this function is experimental and may change or be removed without notice. int Perl_signbit(NV f)','name' => 'Perl_signbit'},'av_create_and_push' => {'text' => 'Push an SV onto the end of the array, creating the array if necessary. A small internal helper function to remove a commonly duplicated idiom. NOTE: this function is experimental and may change or be removed without notice. void av_create_and_push(AV **const avp, SV *const val)','name' => 'av_create_and_push'},'PUSH_MULTICALL' => {'text' => 'Opening bracket for a lightweight callback. See L. PUSH_MULTICALL;','name' => 'PUSH_MULTICALL'},'XPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHp(char* str, STRLEN len)','name' => 'XPUSHp'},'sv_utf8_encode' => {'text' => 'Converts the PV of an SV to UTF-8, but then turns the C flag off so that it looks like octets again. void sv_utf8_encode(SV *sv)','name' => 'sv_utf8_encode'},'SvUTF8_on' => {'text' => 'Turn on the UTF-8 status of an SV (the data is not changed, just the flag). Do not use frivolously. void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_setpvn_mg'},'toLOWER' => {'text' => 'Converts the specified character to lowercase. char toLOWER(char ch)','name' => 'toLOWER'},'POPp' => {'text' => 'Pops a string off the stack. Deprecated. New code should use POPpx. char* POPp','name' => 'POPp'},'SvIV_nomg' => {'text' => 'Like C but doesn\'t process magic. IV SvIV_nomg(SV* sv)','name' => 'SvIV_nomg'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'sv_pvbyten' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten(SV *sv, STRLEN *len)','name' => 'sv_pvbyten'},'Nullav' => {'text' => 'Null AV pointer.','name' => 'Nullav'},'sv_copypv' => {'text' => 'Copies a stringified representation of the source SV into the destination SV. Automatically performs any necessary mg_get and coercion of numeric values into strings. Guaranteed to preserve UTF8 flag even from overloaded objects. Similar in nature to sv_2pv[_flags] but operates directly on an SV instead of just the string. Mostly uses sv_2pv_flags to do its work, except when that would lose the UTF-8\'ness of the PV. void sv_copypv(SV* dsv, SV* ssv)','name' => 'sv_copypv'},'sv_pv' => {'text' => 'Use the C macro instead char* sv_pv(SV *sv)','name' => 'sv_pv'},'pv_pretty' => {'text' => 'Converts a string into something presentable, handling escaping via pv_escape() and supporting quoting and elipses. If the PERL_PV_PRETTY_QUOTE flag is set then the result will be double quoted with any double quotes in the string escaped. Otherwise if the PERL_PV_PRETTY_LTGT flag is set then the result be wrapped in angle brackets. If the PERL_PV_PRETTY_ELIPSES flag is set and not all characters in string were output then an elipses C<...> will be appended to the string. Note that this happens AFTER it has been quoted. If start_color is non-null then it will be inserted after the opening quote (if there is one) but before the escaped text. If end_color is non-null then it will be inserted after the escaped text but before any quotes or elipses. Returns a pointer to the prettified text as held by dsv. char* pv_pretty(SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags)','name' => 'pv_pretty'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setnv_mg(SV *sv, NV num)','name' => 'sv_setnv_mg'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV* hv, char** key, I32* retlen)','name' => 'hv_iternextsv'},'utf8_to_bytes' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike C, this over-writes the original string, and updates len to contain the new length. Returns zero on failure, setting C to -1. If you need a copy of the string, see C. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_pvbyten_force' => {'text' => 'The backend for the C macro. Always use the macro instead. char* sv_pvbyten_force(SV* sv, STRLEN* lp)','name' => 'sv_pvbyten_force'},'uvuni_to_utf8_flags' => {'text' => 'Adds the UTF-8 representation of the Unicode codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvuni_to_utf8_flags(d, uv, flags); or, in most cases, d = uvuni_to_utf8(d, uv); (which is equivalent to) d = uvuni_to_utf8_flags(d, uv, 0); is the recommended Unicode-aware way of saying *(d++) = uv; U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)','name' => 'uvuni_to_utf8_flags'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'mPUSHs' => {'text' => 'Push an SV onto the stack and mortalizes the SV. The stack must have room for this element. Does not use C. See also C and C. void mPUSHs(SV* sv)','name' => 'mPUSHs'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See L.','name' => 'G_DISCARD'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'XST_mNV' => {'text' => '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)','name' => 'XST_mNV'},'UNDERBAR' => {'text' => 'The SV* corresponding to the $_ variable. Works even if there is a lexical $_ in scope. (Lexical $_ is available in perl 5.9.2 and later)','name' => 'UNDERBAR'},'pad_sv' => {'text' => '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)','name' => 'pad_sv'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'SvPVutf8_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_force(SV* sv, STRLEN len)','name' => 'SvPVutf8_force'},'sv_2pvutf8_nolen' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8_nolen(SV* sv)','name' => 'sv_2pvutf8_nolen'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C.','name' => 'SVt_NV'},'av_store' => {'text' => '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)','name' => 'av_store'},'SvPVbytex' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex(SV* sv, STRLEN len)','name' => 'SvPVbytex'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and L. void PUSHMARK(SP)','name' => 'PUSHMARK'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. SV* ST(int ix)','name' => 'ST'},'call_pv' => {'text' => '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)','name' => 'call_pv'},'av_fetch' => {'text' => '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)','name' => 'av_fetch'},'gv_fetchmeth_autoload' => {'text' => '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 C. 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)','name' => 'gv_fetchmeth_autoload'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV* tb, HE* entry)','name' => 'hv_iterval'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. char* sv_reftype(SV* sv, int ob)','name' => 'sv_reftype'},'sv_pos_b2u' => {'text' => 'Converts the value pointed to by offsetp from a count of bytes from the start of the string, to a count of the equivalent number of UTF-8 chars. Handles magic and type coercion. void sv_pos_b2u(SV* sv, I32* offsetp)','name' => 'sv_pos_b2u'},'SvREFCNT_inc_simple_void_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value, and you know that I is not NULL. The macro doesn\'t need to return a meaningful value, or check for NULLness, so it\'s smaller and faster. void SvREFCNT_inc_simple_void_NN(SV* sv)','name' => 'SvREFCNT_inc_simple_void_NN'},'av_len' => {'text' => 'Returns the highest index in the array. The number of elements in the array is C. Returns -1 if the array is empty. I32 av_len(AV* ar)','name' => 'av_len'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C.','name' => 'SVt_IV'},'SvIsCOW' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write. (either shared hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for COW) bool SvIsCOW(SV* sv)','name' => 'SvIsCOW'},'sv_unmagic' => {'text' => 'Removes all magic of type C from an SV. int sv_unmagic(SV* sv, int type)','name' => 'sv_unmagic'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled. void SvTAINT(SV* sv)','name' => 'SvTAINT'},'sv_catsv' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catsv(SV* dsv, SV* ssv)','name' => 'sv_catsv'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'ax' => {'text' => 'Variable which is setup by C to indicate the stack base offset, used by the C, C and C macros. The C macro must be called prior to setup the C variable. I32 ax','name' => 'ax'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'my_sprintf' => {'text' => 'The C library C, wrapped if necessary, to ensure that it will return the length of the string written to the buffer. Only rare pre-ANSI systems need the wrapper function - usually this is a direct call to C. int my_sprintf(char *buffer, const char *pat, ...)','name' => 'my_sprintf'},'to_utf8_fold' => {'text' => 'Convert the UTF-8 encoded character at p to its foldcase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the foldcase version may be longer than the original character (up to three characters). The first character of the foldcased version is returned (but note, as explained above, that there may be more.) UV to_utf8_fold(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_fold'},'to_utf8_upper' => {'text' => 'Convert the UTF-8 encoded character at p to its uppercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the uppercase version may be longer than the original character. The first character of the uppercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_upper(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_upper'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. Uses C to determine the length of C, then calls C. HV* gv_stashpv(const char* name, I32 flags)','name' => 'gv_stashpv'},'SvPVutf8x_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x_force(SV* sv, STRLEN len)','name' => 'SvPVutf8x_force'},'sv_vcatpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vcatpvf_mg(SV* sv, const char* pat, va_list* args)','name' => 'sv_vcatpvf_mg'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHi(IV iv)','name' => 'PUSHi'},'mXPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void mXPUSHu(UV uv)','name' => 'mXPUSHu'},'hv_exists_ent' => {'text' => '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)','name' => 'hv_exists_ent'},'SvLEN_set' => {'text' => 'Set the actual length of the string which is in the SV. See C. void SvLEN_set(SV* sv, STRLEN len)','name' => 'SvLEN_set'},'to_utf8_lower' => {'text' => 'Convert the UTF-8 encoded character at p to its lowercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the lowercase version may be longer than the original character. The first character of the lowercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_lower(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_lower'},'SvNIOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a number, integer or double. U32 SvNIOK(SV* sv)','name' => 'SvNIOK'},'unpack_str' => {'text' => '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)','name' => 'unpack_str'},'newSVpvf' => {'text' => 'Creates a new SV and initializes it with the string formatted like C. SV* newSVpvf(const char* pat, ...)','name' => 'newSVpvf'},'Newxc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. See also C. void Newxc(void* ptr, int nitems, type, cast)','name' => 'Newxc'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C wrapper instead. SV* sv_newref(SV* sv)','name' => 'sv_newref'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L. int perl_destruct(PerlInterpreter* interp)','name' => 'perl_destruct'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'SvIVX' => {'text' => 'Returns the raw value in the SV\'s IV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. IV SvIVX(SV* sv)','name' => 'SvIVX'},'sv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the scalar sv, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument is as in pv_uni_display(). The pointer to the PV of the dsv is returned. char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim, UV flags)','name' => 'sv_uni_display'},'newSVpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV* newSVpvs(const char* s)','name' => 'newSVpvs'},'sv_vsetpvf' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Does not handle \'set\' magic. See C. Usually used via its frontend C. void sv_vsetpvf(SV* sv, const char* pat, va_list* args)','name' => 'sv_vsetpvf'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'XCPT_CATCH' => {'text' => 'Introduces a catch block. See L.','name' => 'XCPT_CATCH'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the stack. void XST_mYES(int pos)','name' => 'XST_mYES'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. You probably want to use one of the assortment of wrappers, such as C, C, C and C. void sv_setsv(SV* dsv, SV* ssv)','name' => 'sv_setsv'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'packlist' => {'text' => 'The engine implementing pack() Perl function. void packlist(SV *cat, char *pat, char *patend, SV **beglist, SV **endlist)','name' => 'packlist'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C for a version which guarantees to evaluate sv only once. NV SvNV(SV* sv)','name' => 'SvNV'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'SvUTF8' => {'text' => 'Returns a U32 value indicating whether the SV contains UTF-8 encoded data. Call this after SvPV() in case any call to string overloading updates the internal flag. U32 SvUTF8(SV* sv)','name' => 'SvUTF8'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an XSUB\'s aliases was used to invoke it. See L. I32 ix','name' => 'ix'},'cv_undef' => {'text' => 'Clear out all the active components of a CV. This can happen either by an explicit C, 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)','name' => 'cv_undef'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'XSRETURN_UV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_UV(IV uv)','name' => 'XSRETURN_UV'},'SvREFCNT_inc_simple' => {'text' => 'Same as SvREFCNT_inc, but can only be used with expressions without side effects. Since we don\'t have to store a temporary value, it\'s faster. SV* SvREFCNT_inc_simple(SV* sv)','name' => 'SvREFCNT_inc_simple'},'get_cvn_flags' => {'text' => 'Returns the CV of the specified Perl subroutine. C are passed to C. 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_cvn_flags(const char* name, STRLEN len, I32 flags)','name' => 'get_cvn_flags'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'dXSI32' => {'text' => 'Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. dXSI32;','name' => 'dXSI32'},'SvPVx' => {'text' => 'A version of C which guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. char* SvPVx(SV* sv, STRLEN len)','name' => 'SvPVx'},'dXCPT' => {'text' => 'Set up necessary local variables for exception handling. See L. dXCPT;','name' => 'dXCPT'},'sv_tainted' => {'text' => 'Test an SV for taintedness. Use C instead. bool sv_tainted(SV* sv)','name' => 'sv_tainted'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. If necessary, uses C and upgrades the SV to C. Returns a pointer to the character buffer. Use the C wrapper instead. char* sv_grow(SV* sv, STRLEN newlen)','name' => 'sv_grow'},'cv_const_sv' => {'text' => 'If C is a constant sub eligible for inlining. returns the constant value returned by the sub. Otherwise, returns NULL. Constant subs can be created with C or as described in L. SV* cv_const_sv(CV* cv)','name' => 'cv_const_sv'},'newSVnv' => {'text' => '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)','name' => 'newSVnv'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. Does not use C. See also C, C and C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry. SV* HeVAL(HE* he)','name' => 'HeVAL'},'HePV' => {'text' => '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. See also C. If you are using C to get values to pass to C to create a new SV, you should consider using C as it is more efficient. char* HePV(HE* he, STRLEN len)','name' => 'HePV'},'SvGETMAGIC' => {'text' => 'Invokes C on an SV if it has \'get\' magic. This macro evaluates its argument more than once. void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'pv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the string spv, length len, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument can have UNI_DISPLAY_ISPRINT set to display isPRINT()able characters as themselves, UNI_DISPLAY_BACKSLASH to display the \\\\[nrfta\\\\] as the backslashed versions (like \'\\n\') (UNI_DISPLAY_BACKSLASH is preferred over UNI_DISPLAY_ISPRINT for \\\\). UNI_DISPLAY_QQ (and its alias UNI_DISPLAY_REGEX) have both UNI_DISPLAY_BACKSLASH and UNI_DISPLAY_ISPRINT turned on. The pointer to the PV of the dsv is returned. char* pv_uni_display(SV *dsv, U8 *spv, STRLEN len, STRLEN pvlim, UV flags)','name' => 'pv_uni_display'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_inc(SV* sv)','name' => 'sv_inc'},'sv_usepvn' => {'text' => 'Tells an SV to use C to find its string value. Implemented by calling C with C of 0, hence does not handle \'set\' magic. See C. void sv_usepvn(SV* sv, char* ptr, STRLEN len)','name' => 'sv_usepvn'},'SvPVbytex_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex_force(SV* sv, STRLEN len)','name' => 'SvPVbytex_force'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'warn' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Call this function the same way you call the C C function. See C. void warn(const char* pat, ...)','name' => 'warn'},'hv_delete' => {'text' => '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, I32 klen, I32 flags)','name' => 'hv_delete'},'POP_MULTICALL' => {'text' => 'Closing bracket for a lightweight callback. See L. POP_MULTICALL;','name' => 'POP_MULTICALL'},'sv_cat_decode' => {'text' => 'The encoding is assumed to be an Encode object, the PV of the ssv is assumed to be octets in that encoding and decoding the input starts from the position which (PV + *offset) pointed to. The dsv will be concatenated the decoded UTF-8 string from ssv. Decoding will terminate when the string tstr appears in decoding output or the input ends on the PV of the ssv. The value which the offset points will be modified to the last input position on the ssv. Returns TRUE if the terminator was found, else returns FALSE. bool sv_cat_decode(SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen)','name' => 'sv_cat_decode'},'SvIV_set' => {'text' => 'Set the value of the IV pointer in sv to val. It is possible to perform the same function of this macro with an lvalue assignment to C. With future Perls, however, it will be more efficient to use C instead of the lvalue assignment to C. void SvIV_set(SV* sv, IV val)','name' => 'SvIV_set'},'sv_setiv' => {'text' => 'Copies an integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setiv(SV* sv, IV num)','name' => 'sv_setiv'},'sv_report_used' => {'text' => 'Dump the contents of all SVs not yet freed. (Debugging aid). void sv_report_used()','name' => 'sv_report_used'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. void EXTEND(SP, int nitems)','name' => 'EXTEND'},'SvNVX' => {'text' => 'Returns the raw value in the SV\'s NV slot, without checks or conversions. Only use when you are sure SvNOK is true. See also C. NV SvNVX(SV* sv)','name' => 'SvNVX'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(UV u)','name' => 'newSVuv'},'gv_fetchmeth' => {'text' => '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)','name' => 'gv_fetchmeth'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. U32 HeHASH(HE* he)','name' => 'HeHASH'},'SvIOK' => {'text' => 'Returns a U32 value indicating whether the SV contains an integer. U32 SvIOK(SV* sv)','name' => 'SvIOK'},'SvPV_force' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'HeUTF8' => {'text' => 'Returns whether the C value returned by C is encoded in UTF-8, doing any necessary dereferencing of possibly C keys. The value returned will be 0 or non-0, not necessarily 1 (or even a value with any low bits set), so B blindly assign this to a C variable, as C may be a typedef for C. char* HeUTF8(HE* he, STRLEN len)','name' => 'HeUTF8'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part attributable to C. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a string and disables all other OK bits, and leaves the UTF-8 status as it was. void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic after a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'},'SvTRUE' => {'text' => '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)','name' => 'SvTRUE'},'grok_hex' => {'text' => 'converts a string representing a hex number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0x" or "x" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the hex number may use \'_\' characters to separate digits. UV grok_hex(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_hex'},'hv_iternext_flags' => {'text' => 'Returns entries from a hash iterator. See C and C. The C 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 C<&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)','name' => 'hv_iternext_flags'},'is_utf8_string_loclen' => {'text' => 'Like is_utf8_string() but stores the location of the failure (in the case of "utf8ness failure") or the location s+len (in the case of "utf8ness success") in the C, and the number of UTF-8 encoded characters in the C. See also is_utf8_string_loc() and is_utf8_string(). bool is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el)','name' => 'is_utf8_string_loclen'},'call_method' => {'text' => '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)','name' => 'call_method'},'SvLOCK' => {'text' => 'Arranges for a mutual exclusion lock to be obtained on sv if a suitable module has been loaded. void SvLOCK(SV* sv)','name' => 'SvLOCK'},'sv_vsetpvfn' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Usually used via one of its frontends C and C. void sv_vsetpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vsetpvfn'},'perl_parse' => {'text' => '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)','name' => 'perl_parse'},'to_utf8_case' => {'text' => 'The "p" contains the pointer to the UTF-8 string encoding the character that is being converted. The "ustrp" is a pointer to the character buffer to put the conversion result to. The "lenp" is a pointer to the length of the result. The "swashp" is a pointer to the swash to use. Both the special and normal mappings are stored lib/unicore/To/Foo.pl, and loaded by SWASHNEW, using lib/utf8_heavy.pl. The special (usually, but not always, a multicharacter mapping), is tried first. The "special" is a string like "utf8::ToSpecLower", which means the hash %utf8::ToSpecLower. The access to the hash is through Perl_to_utf8_case(). The "normal" is a string like "ToLower" which means the swash %utf8::ToLower. UV to_utf8_case(U8 *p, U8* ustrp, STRLEN *lenp, SV **swashp, char *normal, char *special)','name' => 'to_utf8_case'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory used by the array itself. void av_clear(AV* ar)','name' => 'av_clear'},'sv_force_normal' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. See also C. void sv_force_normal(SV *sv)','name' => 'sv_force_normal'},'av_unshift' => {'text' => '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)','name' => 'av_unshift'},'SvREFCNT_inc_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you know I is not NULL. Since we don\'t have to check the NULLness, it\'s faster and smaller. SV* SvREFCNT_inc_NN(SV* sv)','name' => 'SvREFCNT_inc_NN'},'POPpbytex' => {'text' => 'Pops a string off the stack which must consist of bytes i.e. characters < 256. char* POPpbytex','name' => 'POPpbytex'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. UV SvUVX(SV* sv)','name' => 'SvUVX'},'SvSetMagicSV' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV(SV* dsb, SV* ssv)','name' => 'SvSetMagicSV'},'sv_utf8_decode' => {'text' => 'If the PV of the SV is an octet sequence in UTF-8 and contains a multiple-byte character, the C flag is turned on so that it looks like a character. If the PV contains only single-byte characters, the C flag stays being off. Scans PV for validity and returns false if the PV is invalid UTF-8. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_decode(SV *sv)','name' => 'sv_utf8_decode'},'hv_stores' => {'text' => 'Like C, but takes a literal string instead of a string/length pair and omits the hash parameter. SV** hv_stores(HV* tb, const char* key, NULLOK SV* val)','name' => 'hv_stores'},'eval_sv' => {'text' => '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)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'Move' => {'text' => '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)','name' => 'Move'},'sv_catpvn_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. void sv_catpvn_flags(SV* sv, const char* ptr, STRLEN len, I32 flags)','name' => 'sv_catpvn_flags'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'GIMME' => {'text' => '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','name' => 'GIMME'},'sv_2iv_flags' => {'text' => 'Return the integer value of an SV, doing any necessary string conversion. If flags includes SV_GMAGIC, does an mg_get() first. Normally used via the C and C macros. IV sv_2iv_flags(SV* sv, I32 flags)','name' => 'sv_2iv_flags'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs. I needs to be static storage, as it is used directly as CvFILE(), without a copy being made.','name' => 'newXS'},'isALNUM' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphanumeric character (including underscore) or digit. bool isALNUM(char ch)','name' => 'isALNUM'},'XCPT_RETHROW' => {'text' => 'Rethrows a previously caught exception. See L. XCPT_RETHROW;','name' => 'XCPT_RETHROW'},'my_snprintf' => {'text' => 'The C library C functionality, if available and standards-compliant (uses C, actually). However, if the C is not available, will unfortunately use the unsafe C which can overrun the buffer (there is an overrun check, but that may be too late). Consider using C instead, or getting C. int my_snprintf(char *buffer, const Size_t len, const char *format, ...)','name' => 'my_snprintf'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. bool SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'PUSHmortal' => {'text' => 'Push a new mortal SV onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void PUSHmortal()','name' => 'PUSHmortal'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter* interp)','name' => 'perl_construct'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. bool SvUOK(SV* sv)','name' => 'SvUOK'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_dec(SV* sv)','name' => 'sv_dec'},'strLE' => {'text' => '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)','name' => 'strLE'},'pv_display' => {'text' => 'Similar to pv_escape(dsv,pv,cur,pvlim,PERL_PV_ESCAPE_QUOTE); except that an additional "\\0" will be appended to the string when len > cur and pv[cur] is "\\0". Note that the final string may be up to 7 chars longer than pvlim. char* pv_display(SV *dsv, char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)','name' => 'pv_display'},'newSVpvn_flags' => {'text' => '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. If the C argument is NULL the new SV will be undefined. Currently the only flag bits accepted are C and C. If C is set, then C is called on the result before returning. If C is set, then it will be set on the new SV. C is a convenience wrapper for this function, defined as #define newSVpvn_utf8(s, len, u) \\ newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0) SV* newSVpvn_flags(const char* s, STRLEN len, U32 flags)','name' => 'newSVpvn_flags'},'sv_2pvbyte_nolen' => {'text' => 'Return a pointer to the byte-encoded representation of the SV. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'SvOK' => {'text' => 'Returns a U32 value indicating whether the value is an SV. It also tells whether the value is defined or not. U32 SvOK(SV* sv)','name' => 'SvOK'},'sv_setref_nv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_nv(SV* rv, const char* classname, NV nv)','name' => 'sv_setref_nv'},'uvchr_to_utf8' => {'text' => 'Adds the UTF-8 representation of the Native codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvchr_to_utf8(d, uv); is the recommended wide native character-aware way of saying *(d++) = uv; U8* uvchr_to_utf8(U8 *d, UV uv)','name' => 'uvchr_to_utf8'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII digit. bool isDIGIT(char ch)','name' => 'isDIGIT'},'eval_pv' => {'text' => '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)','name' => 'eval_pv'},'sv_usepvn_flags' => {'text' => '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. By default this function will realloc (i.e. move) the memory pointed to by C, so that pointer should not be freed or used by the programmer after giving it to sv_usepvn, and neither should any pointers from "behind" that pointer (e.g. ptr + 1) be used. If C & SV_SMAGIC is true, will call SvSETMAGIC. If C & SV_HAS_TRAILING_NUL is true, then C must be NUL, and the realloc will be skipped. (i.e. the buffer is actually at least 1 byte longer than C, and already meets the requirements for storing in C) void sv_usepvn_flags(SV* sv, char* ptr, STRLEN len, U32 flags)','name' => 'sv_usepvn_flags'},'hv_assert' => {'text' => 'Check that a hash is in an internally consistent state. void hv_assert(HV* tb)','name' => 'hv_assert'},'my_vsnprintf' => {'text' => 'The C library C if available and standards-compliant. However, if if the C is not available, will unfortunately use the unsafe C which can overrun the buffer (there is an overrun check, but that may be too late). Consider using C instead, or getting C. int my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap)','name' => 'my_vsnprintf'},'sv_free' => {'text' => 'Decrement an SV\'s reference count, and if it drops to zero, call C to invoke destructors and free up any memory used by the body; finally, deallocate the SV\'s head itself. Normally called via a wrapper macro C. void sv_free(SV* sv)','name' => 'sv_free'},'SvPVbyte_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_force(SV* sv, STRLEN len)','name' => 'SvPVbyte_force'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. CV* newCONSTSUB(HV* stash, char* name, SV* sv)','name' => 'newCONSTSUB'},'SvSHARE' => {'text' => 'Arranges for sv to be shared between threads if a suitable module has been loaded. void SvSHARE(SV* sv)','name' => 'SvSHARE'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_pop(AV* ar)','name' => 'av_pop'},'croak' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Normally call this function the same way you call the C C function. Calling C returns control directly to Perl, sidestepping the normal C order of execution. See C. If you want to throw an exception object, assign the object to C<$@> and then pass C to croak(): errsv = get_sv("@", TRUE); sv_setsv(errsv, exception_object); croak(NULL); void croak(const char* pat, ...)','name' => 'croak'},'sortsv' => {'text' => '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)','name' => 'sortsv'},'THIS' => {'text' => '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','name' => 'THIS'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually handled by C. void XSRETURN(int nitems)','name' => 'XSRETURN'},'scan_bin' => {'text' => 'For backwards compatibility. Use C instead. NV scan_bin(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_bin'},'Nullcv' => {'text' => 'Null CV pointer.','name' => 'Nullcv'},'sv_2pv_nolen' => {'text' => 'Like C, but doesn\'t return the length too. You should usually use the macro wrapper C instead. char* sv_2pv_nolen(SV* sv)','name' => 'sv_2pv_nolen'},'get_av' => {'text' => '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)','name' => 'get_av'},'MULTICALL' => {'text' => 'Make a lightweight callback. See L. MULTICALL;','name' => 'MULTICALL'},'SvPVbyte' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'PoisonFree' => {'text' => 'PoisonWith(0xEF) for catching access to freed memory. void PoisonFree(void* dest, int nitems, type)','name' => 'PoisonFree'},'toUPPER' => {'text' => 'Converts the specified character to uppercase. char toUPPER(char ch)','name' => 'toUPPER'},'is_utf8_string_loc' => {'text' => 'Like is_utf8_string() but stores the location of the failure (in the case of "utf8ness failure") or the location s+len (in the case of "utf8ness success") in the C. See also is_utf8_string_loclen() and is_utf8_string(). bool is_utf8_string_loc(U8 *s, STRLEN len, U8 **p)','name' => 'is_utf8_string_loc'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally appending to the currently-stored string. char* sv_gets(SV* sv, PerlIO* fp, I32 append)','name' => 'sv_gets'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'SvPVutf8x' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'sv_2cv' => {'text' => 'Using various gambits, try to get a CV from an SV; in addition, try if possible to set C<*st> and C<*gvp> to the stash and GV associated with it. The flags in C are passed to sv_fetchsv. CV* sv_2cv(SV* sv, HV** st, GV** gvp, I32 lref)','name' => 'sv_2cv'},'SvPV_force_nomg' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. Doesn\'t process magic. char* SvPV_force_nomg(SV* sv, STRLEN len)','name' => 'SvPV_force_nomg'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. Will also turn off the UTF-8 status. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'dUNDERBAR' => {'text' => 'Sets up the C variable for an XSUB that wishes to use C. dUNDERBAR;','name' => 'dUNDERBAR'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'XCPT_TRY_START' => {'text' => 'Starts a try block. See L.','name' => 'XCPT_TRY_START'},'sv_pvbyte' => {'text' => 'Use C instead. char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'sv_uv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. UV sv_uv(SV* sv)','name' => 'sv_uv'},'hv_fetch' => {'text' => '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 an C. See L for more information on how to use this function on tied hashes. SV** hv_fetch(HV* tb, const char* key, I32 klen, I32 lval)','name' => 'hv_fetch'},'sv_unref_flags' => {'text' => '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. The C argument can contain C to force the reference count to be decremented (otherwise the decrementing is conditional on the reference count being different from one or the reference being a readonly SV). See C. void sv_unref_flags(SV* sv, U32 flags)','name' => 'sv_unref_flags'},'hv_scalar' => {'text' => 'Evaluates the hash in scalar context and returns the result. Handles magic when the hash is tied. SV* hv_scalar(HV* hv)','name' => 'hv_scalar'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'Nullch' => {'text' => 'Null character pointer.','name' => 'Nullch'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)','name' => 'mg_copy'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'grok_oct' => {'text' => 'converts a string representing an octal number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). If C is set in I<*flags> then the octal number may use \'_\' characters to separate digits. UV grok_oct(char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_oct'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C flag on this RV; give the referred-to SV C magic if it hasn\'t already; and push a back-reference to this RV onto the array of backreferences associated with that magic. SV* sv_rvweaken(SV *sv)','name' => 'sv_rvweaken'},'scan_hex' => {'text' => 'For backwards compatibility. Use C instead. NV scan_hex(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_hex'},'newSVpvn' => {'text' => '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. If the C argument is NULL the new SV will be undefined. SV* newSVpvn(const char* s, STRLEN len)','name' => 'newSVpvn'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the supplied vtable and returns a pointer to the magic added. Note that C will allow things that C will not. In particular, you can add magic to SvREADONLY SVs, and add more than one instance of the same \'how\'. If C is greater than zero then a C I of C is stored, if C is zero then C is stored as-is and - as another special case - if C<(name && namlen == HEf_SVKEY)> then C is assumed to contain an C and is stored as-is with its REFCNT incremented. (This is now used as a subroutine by C.) MAGIC * sv_magicext(SV* sv, SV* obj, int how, MGVTBL *vtbl, const char* name, I32 namlen)','name' => 'sv_magicext'},'av_push' => {'text' => '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)','name' => 'av_push'},'unpackstring' => {'text' => 'The engine implementing unpack() Perl function. C puts the extracted list items on the stack and returns the number of elements. Issue C before and C after the call to this function. I32 unpackstring(char *pat, char *patend, char *s, char *strend, U32 flags)','name' => 'unpackstring'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV* ar, I32 key)','name' => 'av_extend'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV* sv)','name' => 'newRV_noinc'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. You may call C or C 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 C, so you must not discard your iterator immediately else the entry will leak - call C to trigger the resource deallocation. HE* hv_iternext(HV* tb)','name' => 'hv_iternext'},'hv_iterinit' => {'text' => '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)','name' => 'hv_iterinit'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.008009', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_018_002.pm0000644000175000017500000000040612264521575020764 0ustar tseetseepackage Perl::APIReference::V5_018_002; use strict; use warnings; use parent 'Perl::APIReference::V5_018_000'; sub new { my $class = shift; my $obj = $class->SUPER::new(@_); $obj->{perl_version} = '5.018002'; bless $obj => $class; return $obj; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_008_007.pm0000644000175000017500000037067611653441731021007 0ustar tseetseepackage Perl::APIReference::V5_008_007; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'SvOOK' => {'text' => '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)','name' => 'SvOOK'},'hv_store_ent' => {'text' => '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. Effectively a successful hv_store_ent takes ownership of one reference to C. 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 C; unlike C it does not take ownership of it, so maintaining the correct reference count on C 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 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)','name' => 'hv_store_ent'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package, which must be a valid UTF-8 string. See C. HV* gv_stashsv(SV* sv, I32 create)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'strGE' => {'text' => '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)','name' => 'strGE'},'form' => {'text' => '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, ...)','name' => 'form'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified version becoming C. Handles \'get\' magic. See also C for a version which guarantees to evaluate sv only once. char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'is_utf8_string' => {'text' => 'Returns true if first C bytes of the given string form a valid UTF-8 string, false otherwise. Note that \'a valid UTF-8 string\' does not mean \'a string that contains code points above 0x7F encoded in UTF-8\' because a valid ASCII string is a valid UTF-8 string. bool is_utf8_string(U8 *s, STRLEN len)','name' => 'is_utf8_string'},'svtype' => {'text' => '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.','name' => 'svtype'},'hv_clear' => {'text' => 'Clears a hash, making it empty. void hv_clear(HV* tb)','name' => 'hv_clear'},'get_hv' => {'text' => '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)','name' => 'get_hv'},'load_module' => {'text' => '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 C. The optional trailing SV* arguments can be used to specify arguments to the module\'s import() method, similar to C. void load_module(U32 flags, SV* name, SV* ver, ...)','name' => 'load_module'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES;','name' => 'XSRETURN_YES'},'sv_nv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. NV sv_nv(SV* sv)','name' => 'sv_nv'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'Poison' => {'text' => '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)','name' => 'Poison'},'sv_insert' => {'text' => '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)','name' => 'sv_insert'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_catpvf_mg'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'SvPOK' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. bool SvPOK(SV* sv)','name' => 'SvPOK'},'get_sv' => {'text' => '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)','name' => 'get_sv'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHu(UV uv)','name' => 'PUSHu'},'sv_vsetpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vsetpvf_mg(SV* sv, const char* pat, va_list* args)','name' => 'sv_vsetpvf_mg'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. (Uses C). SV* newSVsv(SV* old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C. void hv_magic(HV* hv, GV* gv, int how)','name' => 'hv_magic'},'SvPVutf8' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *sv, const char *ptr)','name' => 'sv_setpv_mg'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C.','name' => 'XS'},'scan_oct' => {'text' => 'For backwards compatibility. Use C instead. NV scan_oct(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_oct'},'sv_setpvn' => {'text' => 'Copies a string into an SV. The C parameter indicates the number of bytes to be copied. If the C argument is NULL the SV will become undefined. Does not handle \'set\' magic. See C. void sv_setpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_setpvn'},'sv_2mortal' => {'text' => 'Marks an existing SV as mortal. The SV will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. SvTEMP() is turned on which means that the SV\'s string buffer can be "stolen" if this SV is copied. See also C and C. SV* sv_2mortal(SV* sv)','name' => 'sv_2mortal'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'newSVrv' => {'text' => '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)','name' => 'newSVrv'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself. void av_undef(AV* ar)','name' => 'av_undef'},'HeKEY' => {'text' => '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)','name' => 'HeKEY'},'pack_cat' => {'text' => '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)','name' => 'pack_cat'},'utf8n_to_uvuni' => {'text' => 'Bottom level UTF-8 decode routine. Returns the unicode code point value of the first character in the string C which is assumed to be in UTF-8 encoding and no longer than C; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, the behaviour is dependent on the value of C: if it contains UTF8_CHECK_ONLY, it is assumed that the caller will raise a warning, and this function will silently just set C to C<-1> and return zero. If the C does not contain UTF8_CHECK_ONLY, warnings about malformations will be given, C will be set to the expected length of the UTF-8 character in bytes, and zero will be returned. The C can also contain various flags to allow deviations from the strict UTF-8 encoding (see F). Most code should use utf8_to_uvchr() rather than call this directly. UV utf8n_to_uvuni(U8 *s, STRLEN curlen, STRLEN* retlen, U32 flags)','name' => 'utf8n_to_uvuni'},'sv_cmp' => {'text' => '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. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp(SV* sv1, SV* sv2)','name' => 'sv_cmp'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'SvEND' => {'text' => '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)','name' => 'SvEND'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C to type C if necessary, then adds a new magic item of type C to the head of the magic list. See C (which C now calls) for a description of the handling of the C and C arguments. You need to use C to add magic to SvREADONLY SVs and also to add more than one instance of the same \'how\'. void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen)','name' => 'sv_magic'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C, C or C for void, scalar or list context, respectively. U32 GIMME_V','name' => 'GIMME_V'},'sv_force_normal_flags' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. The C parameter gets passed to C when unrefing. C calls this function with flags set to 0. void sv_force_normal_flags(SV *sv, U32 flags)','name' => 'sv_force_normal_flags'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'sv_setsv_flags' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. If the C parameter has the C bit set, will C on C if appropriate, else not. If the C parameter has the C bit set then the buffers of temps will not be stolen. and C are implemented in terms of this function. You probably want to use one of the assortment of wrappers, such as C, C, C and C. This is the primary function for copying scalars, and most other copy-ish functions and macros use this underneath. void sv_setsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_setsv_flags'},'sv_utf8_upgrade_flags' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade_flags(SV *sv, I32 flags)','name' => 'sv_utf8_upgrade_flags'},'New' => {'text' => 'The XSUB-writer\'s interface to the C C function. void New(int id, void* ptr, int nitems, type)','name' => 'New'},'is_utf8_char' => {'text' => 'Tests if some arbitrary number of bytes begins in a valid UTF-8 character. Note that an INVARIANT (i.e. ASCII) character is a valid UTF-8 character. The actual number of bytes in the UTF-8 character will be returned if it is valid, otherwise 0. STRLEN is_utf8_char(U8 *p)','name' => 'is_utf8_char'},'Copy' => {'text' => '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)','name' => 'Copy'},'ibcmp_utf8' => {'text' => 'Return true if the strings s1 and s2 differ case-insensitively, false if not (if they are equal case-insensitively). If u1 is true, the string s1 is assumed to be in UTF-8-encoded Unicode. If u2 is true, the string s2 is assumed to be in UTF-8-encoded Unicode. If u1 or u2 are false, the respective string is assumed to be in native 8-bit encoding. If the pe1 and pe2 are non-NULL, the scanning pointers will be copied in there (they will point at the beginning of the I character). If the pointers behind pe1 or pe2 are non-NULL, they are the end pointers beyond which scanning will not continue under any circumstances. If the byte lengths l1 and l2 are non-zero, s1+l1 and s2+l2 will be used as goal end pointers that will also stop the scan, and which qualify towards defining a successful match: all the scans that define an explicit length must reach their goal pointers for a match to succeed). For case-insensitiveness, the "casefolding" of Unicode is used instead of upper/lowercasing both the characters, see http://www.unicode.org/unicode/reports/tr21/ (Case Mappings). I32 ibcmp_utf8(const char* a, char **pe1, UV l1, bool u1, const char* b, char **pe2, UV l2, bool u2)','name' => 'ibcmp_utf8'},'mXPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Handles \'set\' magic. Does not use C. See also C, C and C. void mXPUSHp(char* str, STRLEN len)','name' => 'mXPUSHp'},'CvSTASH' => {'text' => 'Returns the stash of the CV. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'sv_taint' => {'text' => 'Taint an SV. Use C instead. void sv_taint(SV* sv)','name' => 'sv_taint'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. The target SV physically takes over ownership of the body of the source SV and inherits its flags; however, the target keeps any magic it owns, and any magic in the source is discarded. Note that this is a rather specialist SV copying operation; most of the time you\'ll want to use C or one of its many macro front-ends. void sv_replace(SV* sv, SV* nsv)','name' => 'sv_replace'},'utf8n_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. Allows length and flags to be passed to low level routine. UV utf8n_to_uvchr(U8 *s, STRLEN curlen, STRLEN* retlen, U32 flags)','name' => 'utf8n_to_uvchr'},'sv_utf8_upgrade' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains a signed integer. bool SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and L.','name' => 'G_ARRAY'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. Sets up the C and C variables by calling C and C. This is usually handled automatically by C. dXSARGS;','name' => 'dXSARGS'},'sv_2iv' => {'text' => 'Return the integer value of an SV, doing any necessary string conversion, magic etc. Normally used via the C and C macros. IV sv_2iv(SV* sv)','name' => 'sv_2iv'},'savesharedpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* ptr)','name' => 'Safefree'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the C C is whitespace. bool isSPACE(char ch)','name' => 'isSPACE'},'SvROK' => {'text' => 'Tests if the SV is an RV. bool SvROK(SV* sv)','name' => 'SvROK'},'mXPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. Does not use C. See also C, C and C. void mXPUSHn(NV nv)','name' => 'mXPUSHn'},'sv_unref' => {'text' => '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. This is C with the C being zero. See C. void sv_unref(SV* sv)','name' => 'sv_unref'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dstr, SV *sstr)','name' => 'sv_catsv_mg'},'mPUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Does not use C. See also C, C and C. void mPUSHu(UV uv)','name' => 'mPUSHu'},'gv_stashpvn' => {'text' => 'Returns a pointer to the stash for a specified package. C should be a valid UTF-8 string. The C parameter indicates the length of the C, in bytes. 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_stashpvn(const char* name, U32 namelen, I32 create)','name' => 'gv_stashpvn'},'call_argv' => {'text' => '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)','name' => 'call_argv'},'SvPV_nolen' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified form becoming C. Handles \'get\' magic. char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'perl_clone' => {'text' => '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 C, 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)','name' => 'perl_clone'},'sv_setnv' => {'text' => 'Copies a double into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setnv(SV* sv, NV num)','name' => 'sv_setnv'},'sv_2nv' => {'text' => 'Return the num value of an SV, doing any necessary string or integer conversion, magic etc. Normally used via the C and C macros. NV sv_2nv(SV* sv)','name' => 'sv_2nv'},'sv_setsv_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_setsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_setsv_nomg'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'XPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHp(char* str, STRLEN len)','name' => 'XPUSHp'},'sv_utf8_encode' => {'text' => 'Converts the PV of an SV to UTF-8, but then turns the C flag off so that it looks like octets again. void sv_utf8_encode(SV *sv)','name' => 'sv_utf8_encode'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1. HV* newHV()','name' => 'newHV'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or false. bool strNE(char* s1, char* s2)','name' => 'strNE'},'SvUTF8_on' => {'text' => 'Turn on the UTF-8 status of an SV (the data is not changed, just the flag). Do not use frivolously. void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_setpvn_mg'},'sv_pvutf8n_force' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n_force(SV* sv, STRLEN* lp)','name' => 'sv_pvutf8n_force'},'savepv' => {'text' => 'Perl\'s version of C. Returns a pointer to a newly allocated string which is a duplicate of C. The size of the string is determined by C. The memory allocated for the new string can be freed with the C function. char* savepv(const char* pv)','name' => 'savepv'},'toLOWER' => {'text' => 'Converts the specified character to lowercase. char toLOWER(char ch)','name' => 'toLOWER'},'bytes_from_utf8' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike but like C, returns a pointer to the newly-created string, and updates C to contain the new length. Returns the original string if no conversion occurs, C is unchanged. Do nothing if C points to 0. Sets C to 0 if C is converted or contains all 7bit characters. NOTE: this function is experimental and may change or be removed without notice. U8* bytes_from_utf8(U8 *s, STRLEN *len, bool *is_utf8)','name' => 'bytes_from_utf8'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1. AV* newAV()','name' => 'newAV'},'POPp' => {'text' => 'Pops a string off the stack. Deprecated. New code should provide a STRLEN n_a and use POPpx. char* POPp','name' => 'POPp'},'HvNAME' => {'text' => 'Returns the package name of a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV of the sv is assumed to be octets in that encoding, and the sv will be converted into Unicode (and UTF-8). If the sv already is UTF-8 (or if it is not POK), or if the encoding is not a reference, nothing is done to the sv. If the encoding is not an C Encoding object, bad things will happen. (See F and L). The PV of the sv is returned. char* sv_recode_to_utf8(SV* sv, SV *encoding)','name' => 'sv_recode_to_utf8'},'av_make' => {'text' => '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)','name' => 'av_make'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. See C for a version which guarantees to evaluate sv only once. UV SvUV(SV* sv)','name' => 'SvUV'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L. int perl_run(PerlInterpreter* interp)','name' => 'perl_run'},'sv_pvbyten' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten(SV *sv, STRLEN *len)','name' => 'sv_pvbyten'},'sv_catsv_flags' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. If C has C bit set, will C on the SVs if appropriate, else not. C and C are implemented in terms of this function. void sv_catsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_catsv_flags'},'Nullav' => {'text' => 'Null AV pointer.','name' => 'Nullav'},'sv_copypv' => {'text' => 'Copies a stringified representation of the source SV into the destination SV. Automatically performs any necessary mg_get and coercion of numeric values into strings. Guaranteed to preserve UTF-8 flag even from overloaded objects. Similar in nature to sv_2pv[_flags] but operates directly on an SV instead of just the string. Mostly uses sv_2pv_flags to do its work, except when that would lose the UTF-8\'ness of the PV. void sv_copypv(SV* dsv, SV* ssv)','name' => 'sv_copypv'},'sv_pv' => {'text' => 'Use the C macro instead char* sv_pv(SV *sv)','name' => 'sv_pv'},'SvPVutf8_nolen' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_nolen(SV* sv)','name' => 'SvPVutf8_nolen'},'sv_setpviv' => {'text' => '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)','name' => 'sv_setpviv'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setnv_mg(SV *sv, NV num)','name' => 'sv_setnv_mg'},'sv_true' => {'text' => 'Returns true if the SV has a true value by Perl\'s rules. Use the C macro instead, which may call C or may instead use an in-line version. I32 sv_true(SV *sv)','name' => 'sv_true'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV* hv, char** key, I32* retlen)','name' => 'hv_iternextsv'},'utf8_to_bytes' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike C, this over-writes the original string, and updates len to contain the new length. Returns zero on failure, setting C to -1. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_pvbyten_force' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten_force(SV* sv, STRLEN* lp)','name' => 'sv_pvbyten_force'},'sv_derived_from' => {'text' => '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)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. See also C. I32 sv_cmp_locale(SV* sv1, SV* sv2)','name' => 'sv_cmp_locale'},'uvuni_to_utf8_flags' => {'text' => 'Adds the UTF-8 representation of the Unicode codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvuni_to_utf8_flags(d, uv, flags); or, in most cases, d = uvuni_to_utf8(d, uv); (which is equivalent to) d = uvuni_to_utf8_flags(d, uv, 0); is the recommended Unicode-aware way of saying *(d++) = uv; U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)','name' => 'uvuni_to_utf8_flags'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'hv_exists' => {'text' => '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, I32 klen)','name' => 'hv_exists'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See L.','name' => 'G_DISCARD'},'Nullsv' => {'text' => 'Null SV pointer.','name' => 'Nullsv'},'mg_length' => {'text' => 'Report on the SV\'s length. See C. U32 mg_length(SV* sv)','name' => 'mg_length'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'SvPVX' => {'text' => 'Returns a pointer to the physical string in the SV. The SV must contain a string. char* SvPVX(SV* sv)','name' => 'SvPVX'},'XST_mNV' => {'text' => '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)','name' => 'XST_mNV'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'HEf_SVKEY' => {'text' => 'This flag, used in the length slot of hash entries and magic structures, specifies the structure contains an C pointer where a C pointer is to be expected. (For information only--not to be used).','name' => 'HEf_SVKEY'},'pad_sv' => {'text' => '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)','name' => 'pad_sv'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C in characters. Stops at C (inclusive). If C s> or if the scan would end up past C, croaks. STRLEN utf8_length(U8* s, U8 *e)','name' => 'utf8_length'},'SvPVutf8_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_force(SV* sv, STRLEN len)','name' => 'SvPVutf8_force'},'sv_2pvutf8_nolen' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8_nolen(SV* sv)','name' => 'sv_2pvutf8_nolen'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted if tainting is enabled. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'SvIOK_only_UV' => {'text' => 'Tells and SV that it is an unsigned integer and disables all other OK bits. void SvIOK_only_UV(SV* sv)','name' => 'SvIOK_only_UV'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C.','name' => 'SVt_NV'},'sv_nolocking' => {'text' => '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 *)','name' => 'sv_nolocking'},'sv_vcatpvfn' => {'text' => '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). Usually used via one of its frontends C and C. void sv_vcatpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vcatpvfn'},'SvPVbytex' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex(SV* sv, STRLEN len)','name' => 'SvPVbytex'},'av_store' => {'text' => '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)','name' => 'av_store'},'sv_2uv' => {'text' => 'Return the unsigned integer value of an SV, doing any necessary string conversion, magic etc. Normally used via the C and C macros. UV sv_2uv(SV* sv)','name' => 'sv_2uv'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and L. void PUSHMARK(SP)','name' => 'PUSHMARK'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. SV* ST(int ix)','name' => 'ST'},'strLT' => {'text' => '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)','name' => 'strLT'},'sv_pvutf8n' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n(SV *sv, STRLEN *len)','name' => 'sv_pvutf8n'},'call_pv' => {'text' => '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)','name' => 'call_pv'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. SV* av_shift(AV* ar)','name' => 'av_shift'},'newSV' => {'text' => 'Create a new null SV, or if len > 0, create a new empty SVt_PV type SV with an initial PV allocation of len+1. Normally accessed via the C macro. SV* newSV(STRLEN len)','name' => 'newSV'},'av_fetch' => {'text' => '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)','name' => 'av_fetch'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'gv_fetchmeth_autoload' => {'text' => '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 C. 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)','name' => 'gv_fetchmeth_autoload'},'sv_2pvutf8' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV, and set *lp to its length. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8(SV* sv, STRLEN* lp)','name' => 'sv_2pvutf8'},'sv_nounlocking' => {'text' => '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 *)','name' => 'sv_nounlocking'},'dITEMS' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dITEMS;','name' => 'dITEMS'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV* tb, HE* entry)','name' => 'hv_iterval'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. char* sv_reftype(SV* sv, int ob)','name' => 'sv_reftype'},'sv_pos_b2u' => {'text' => 'Converts the value pointed to by offsetp from a count of bytes from the start of the string, to a count of the equivalent number of UTF-8 chars. Handles magic and type coercion. void sv_pos_b2u(SV* sv, I32* offsetp)','name' => 'sv_pos_b2u'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C.','name' => 'SVt_IV'},'av_len' => {'text' => 'Returns the highest index in the array. Returns -1 if the array is empty. I32 av_len(AV* ar)','name' => 'av_len'},'SvIsCOW' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write. (either shared hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for COW) bool SvIsCOW(SV* sv)','name' => 'SvIsCOW'},'CopyD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * CopyD(void* src, void* dest, int nitems, type)','name' => 'CopyD'},'sv_unmagic' => {'text' => 'Removes all magic of type C from an SV. int sv_unmagic(SV* sv, int type)','name' => 'sv_unmagic'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *sv, IV i)','name' => 'sv_setiv_mg'},'sv_catsv' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catsv(SV* dsv, SV* ssv)','name' => 'sv_catsv'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled. void SvTAINT(SV* sv)','name' => 'SvTAINT'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C. See C and L for other uses. PUTBACK;','name' => 'PUTBACK'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'ax' => {'text' => 'Variable which is setup by C to indicate the stack base offset, used by the C, C and C macros. The C macro must be called prior to setup the C variable. I32 ax','name' => 'ax'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'SvCUR_set' => {'text' => 'Set the length of the string which is in the SV. See C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'to_utf8_fold' => {'text' => 'Convert the UTF-8 encoded character at p to its foldcase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the foldcase version may be longer than the original character (up to three characters). The first character of the foldcased version is returned (but note, as explained above, that there may be more.) UV to_utf8_fold(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_fold'},'to_utf8_upper' => {'text' => 'Convert the UTF-8 encoded character at p to its uppercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the uppercase version may be longer than the original character. The first character of the uppercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_upper(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_upper'},'SvNOK' => {'text' => 'Returns a boolean indicating whether the SV contains a double. bool SvNOK(SV* sv)','name' => 'SvNOK'},'mPUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. Does not use C. See also C, C and C. void mPUSHn(NV nv)','name' => 'mPUSHn'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. C should be a valid UTF-8 string and must be null-terminated. 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)','name' => 'gv_stashpv'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C, C, and L.','name' => 'G_SCALAR'},'sv_vcatpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vcatpvf_mg(SV* sv, const char* pat, va_list* args)','name' => 'sv_vcatpvf_mg'},'SvPVutf8x_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x_force(SV* sv, STRLEN len)','name' => 'SvPVutf8x_force'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHi(IV iv)','name' => 'PUSHi'},'sv_reset' => {'text' => 'Underlying implementation for the C Perl function. Note that the perl-level function is vaguely deprecated. void sv_reset(char* s, HV* stash)','name' => 'sv_reset'},'mXPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Does not use C. See also C, C and C. void mXPUSHu(UV uv)','name' => 'mXPUSHu'},'hv_exists_ent' => {'text' => '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)','name' => 'hv_exists_ent'},'to_utf8_lower' => {'text' => 'Convert the UTF-8 encoded character at p to its lowercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the lowercase version may be longer than the original character. The first character of the lowercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_lower(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_lower'},'SvNIOK' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. bool SvNIOK(SV* sv)','name' => 'SvNIOK'},'sv_2pv_flags' => {'text' => 'Returns a pointer to the string value of an SV, and sets *lp to its length. If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string if necessary. Normally invoked via the C macro. C and C usually end up here too. char* sv_2pv_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_2pv_flags'},'SvTAINTED_off' => {'text' => '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)','name' => 'SvTAINTED_off'},'SvNVx' => {'text' => 'Coerces the given SV to a double and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. NV SvNVx(SV* sv)','name' => 'SvNVx'},'unpack_str' => {'text' => '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)','name' => 'unpack_str'},'newSVpvf' => {'text' => 'Creates a new SV and initializes it with the string formatted like C. SV* newSVpvf(const char* pat, ...)','name' => 'newSVpvf'},'require_pv' => {'text' => 'Tells Perl to C the file named by the string argument. It is analogous to the Perl code C. 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)','name' => 'require_pv'},'sv_upgrade' => {'text' => 'Upgrade an SV to a more complex form. Generally adds a new body type to the SV, then copies across as much information as possible from the old body. You generally want to use the C macro wrapper. See also C. bool sv_upgrade(SV* sv, U32 mt)','name' => 'sv_upgrade'},'strEQ' => {'text' => 'Test two strings to see if they are equal. Returns true or false. bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C wrapper instead. SV* sv_newref(SV* sv)','name' => 'sv_newref'},'hv_store' => {'text' => '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. Effectively a successful hv_store takes ownership of one reference to C. 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 L 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)','name' => 'hv_store'},'SvIVX' => {'text' => 'Returns the raw value in the SV\'s IV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. IV SvIVX(SV* sv)','name' => 'SvIVX'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L. int perl_destruct(PerlInterpreter* interp)','name' => 'perl_destruct'},'sv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the scalar sv, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument is as in pv_uni_display(). The pointer to the PV of the dsv is returned. char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim, UV flags)','name' => 'sv_uni_display'},'sv_vsetpvf' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Does not handle \'set\' magic. See C. Usually used via its frontend C. void sv_vsetpvf(SV* sv, const char* pat, va_list* args)','name' => 'sv_vsetpvf'},'isUPPER' => {'text' => 'Returns a boolean indicating whether the C C is an uppercase character. bool isUPPER(char ch)','name' => 'isUPPER'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. You probably want to use one of the assortment of wrappers, such as C, C, C and C. void sv_setsv(SV* dsv, SV* ssv)','name' => 'sv_setsv'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the stack. void XST_mYES(int pos)','name' => 'XST_mYES'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C for a version which guarantees to evaluate sv only once. NV SvNV(SV* sv)','name' => 'SvNV'},'packlist' => {'text' => 'The engine implementing pack() Perl function. void packlist(SV *cat, char *pat, char *patend, SV **beglist, SV **endlist)','name' => 'packlist'},'SvUTF8' => {'text' => 'Returns a boolean indicating whether the SV contains UTF-8 encoded data. bool SvUTF8(SV* sv)','name' => 'SvUTF8'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'sv_setsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setsv_mg(SV *dstr, SV *sstr)','name' => 'sv_setsv_mg'},'hv_fetch_ent' => {'text' => '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)','name' => 'hv_fetch_ent'},'isLOWER' => {'text' => 'Returns a boolean indicating whether the C C is a lowercase character. bool isLOWER(char ch)','name' => 'isLOWER'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See C. char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an XSUB\'s aliases was used to invoke it. See L. I32 ix','name' => 'ix'},'SvNOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a double. Checks the B setting. Use C. bool SvNOKp(SV* sv)','name' => 'SvNOKp'},'XSRETURN_UV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_UV(IV uv)','name' => 'XSRETURN_UV'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'cv_undef' => {'text' => 'Clear out all the active components of a CV. This can happen either by an explicit C, 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)','name' => 'cv_undef'},'PUSHs' => {'text' => 'Push an SV onto the stack. The stack must have room for this element. Does not handle \'set\' magic. Does not use C. See also C, C and C. void PUSHs(SV* sv)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setuv(SV* sv, UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'utf8_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvchr(U8 *s, STRLEN* retlen)','name' => 'utf8_to_uvchr'},'nothreadhook' => {'text' => 'Stub that provides thread hook for perl_destruct when there are no threads. int nothreadhook()','name' => 'nothreadhook'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'bytes_to_utf8' => {'text' => 'Converts a string C of length C from ASCII into UTF-8 encoding. Returns a pointer to the newly-created string, and sets C to reflect the new length. If you want to convert to UTF-8 from other encodings than ASCII, see sv_recode_to_utf8(). NOTE: this function is experimental and may change or be removed without notice. U8* bytes_to_utf8(U8 *s, STRLEN *len)','name' => 'bytes_to_utf8'},'sv_pvn' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn(SV *sv, STRLEN *len)','name' => 'sv_pvn'},'SvIsCOW_shared_hash' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write shared hash key scalar. bool SvIsCOW_shared_hash(SV* sv)','name' => 'SvIsCOW_shared_hash'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'dXSI32' => {'text' => 'Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. dXSI32;','name' => 'dXSI32'},'sv_setref_iv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_iv(SV* rv, const char* classname, IV iv)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => '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. Uses the "OOK hack". Beware: after this function returns, C and SvPVX(sv) may no longer refer to the same chunk of data. void sv_chop(SV* sv, char* ptr)','name' => 'sv_chop'},'SvPVx' => {'text' => 'A version of C which guarantees to evaluate sv only once. char* SvPVx(SV* sv, STRLEN len)','name' => 'SvPVx'},'sv_backoff' => {'text' => 'Remove any string offset. You should normally use the C macro wrapper instead. int sv_backoff(SV* sv)','name' => 'sv_backoff'},'sv_tainted' => {'text' => 'Test an SV for taintedness. Use C instead. bool sv_tainted(SV* sv)','name' => 'sv_tainted'},'sv_catsv_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_catsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_catsv_nomg'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. If necessary, uses C and upgrades the SV to C. Returns a pointer to the character buffer. Use the C wrapper instead. char* sv_grow(SV* sv, STRLEN newlen)','name' => 'sv_grow'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setuv_mg(SV *sv, UV u)','name' => 'sv_setuv_mg'},'cv_const_sv' => {'text' => 'If C is a constant sub eligible for inlining. returns the constant value returned by the sub. Otherwise, returns NULL. Constant subs can be created with C or as described in L. SV* cv_const_sv(CV* cv)','name' => 'cv_const_sv'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually handled automatically by C. See C.','name' => 'XS_VERSION'},'newSVnv' => {'text' => '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)','name' => 'newSVnv'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. Does not use C. See also C, C and C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry. SV* HeVAL(HE* he)','name' => 'HeVAL'},'PL_na' => {'text' => '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','name' => 'PL_na'},'HePV' => {'text' => '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)','name' => 'HePV'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the SV is set to 1. SV* newSViv(IV i)','name' => 'newSViv'},'sv_untaint' => {'text' => 'Untaint an SV. Use C instead. void sv_untaint(SV* sv)','name' => 'sv_untaint'},'sv_setpv' => {'text' => '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)','name' => 'sv_setpv'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See C.','name' => 'SVt_PVHV'},'pv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the string spv, length len, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument can have UNI_DISPLAY_ISPRINT set to display isPRINT()able characters as themselves, UNI_DISPLAY_BACKSLASH to display the \\\\[nrfta\\\\] as the backslashed versions (like \'\\n\') (UNI_DISPLAY_BACKSLASH is preferred over UNI_DISPLAY_ISPRINT for \\\\). UNI_DISPLAY_QQ (and its alias UNI_DISPLAY_REGEX) have both UNI_DISPLAY_BACKSLASH and UNI_DISPLAY_ISPRINT turned on. The pointer to the PV of the dsv is returned. char* pv_uni_display(SV *dsv, U8 *spv, STRLEN len, STRLEN pvlim, UV flags)','name' => 'pv_uni_display'},'gv_fetchmethod' => {'text' => 'See L. GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'SvGETMAGIC' => {'text' => 'Invokes C on an SV if it has \'get\' magic. This macro evaluates its argument more than once. void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'SvGROW' => {'text' => '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)','name' => 'SvGROW'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_inc(SV* sv)','name' => 'sv_inc'},'sv_usepvn' => {'text' => '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)','name' => 'sv_usepvn'},'SvPVbytex_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex_force(SV* sv, STRLEN len)','name' => 'SvPVbytex_force'},'sv_catpv' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpv(SV* sv, const char* ptr)','name' => 'sv_catpv'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'sv_len' => {'text' => 'Returns the length of the string in the SV. Handles magic and type coercion. See also C, which gives raw access to the xpv_cur slot. STRLEN sv_len(SV* sv)','name' => 'sv_len'},'warn' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Call this function the same way you call the C C function. See C. void warn(const char* pat, ...)','name' => 'warn'},'sv_pvutf8' => {'text' => 'Use the C macro instead char* sv_pvutf8(SV *sv)','name' => 'sv_pvutf8'},'SvPVbyte_nolen' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_nolen(SV* sv)','name' => 'SvPVbyte_nolen'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L. LEAVE;','name' => 'LEAVE'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See C.','name' => 'SVt_PVAV'},'hv_delete' => {'text' => '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, I32 klen, I32 flags)','name' => 'hv_delete'},'hv_undef' => {'text' => 'Undefines the hash. void hv_undef(HV* tb)','name' => 'hv_undef'},'SvSetMagicSV_nosteal' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetMagicSV_nosteal'},'hv_delete_ent' => {'text' => '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)','name' => 'hv_delete_ent'},'CLASS' => {'text' => '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','name' => 'CLASS'},'savesvpv' => {'text' => 'A version of C/C which gets the string to duplicate from the passed in SV using C char* savesvpv(SV* sv)','name' => 'savesvpv'},'sv_isobject' => {'text' => '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)','name' => 'sv_isobject'},'Newc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Newc(int id, void* ptr, int nitems, type, cast)','name' => 'Newc'},'sv_pvn_force_flags' => {'text' => 'Get a sensible string out of the SV somehow. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You normally want to use the various wrapper macros instead: see C and C char* sv_pvn_force_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_pvn_force_flags'},'HeKLEN' => {'text' => '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)','name' => 'HeKLEN'},'to_utf8_title' => {'text' => 'Convert the UTF-8 encoded character at p to its titlecase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the titlecase version may be longer than the original character. The first character of the titlecased version is returned (but note, as explained above, that there may be more.) UV to_utf8_title(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_title'},'sv_cat_decode' => {'text' => 'The encoding is assumed to be an Encode object, the PV of the ssv is assumed to be octets in that encoding and decoding the input starts from the position which (PV + *offset) pointed to. The dsv will be concatenated the decoded UTF-8 string from ssv. Decoding will terminate when the string tstr appears in decoding output or the input ends on the PV of the ssv. The value which the offset points will be modified to the last input position on the ssv. Returns TRUE if the terminator was found, else returns FALSE. bool sv_cat_decode(SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen)','name' => 'sv_cat_decode'},'mPUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Does not use C. See also C, C and C. void mPUSHi(IV iv)','name' => 'mPUSHi'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHn(NV nv)','name' => 'PUSHn'},'sv_setiv' => {'text' => 'Copies an integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setiv(SV* sv, IV num)','name' => 'sv_setiv'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it. See C for a version which guarantees to evaluate sv only once. IV SvIV(SV* sv)','name' => 'SvIV'},'sv_report_used' => {'text' => 'Dump the contents of all SVs not yet freed. (Debugging aid). void sv_report_used()','name' => 'sv_report_used'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. void EXTEND(SP, int nitems)','name' => 'EXTEND'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. SV PL_sv_yes','name' => 'PL_sv_yes'},'SvNVX' => {'text' => 'Returns the raw value in the SV\'s NV slot, without checks or conversions. Only use when you are sure SvNOK is true. See also C. NV SvNVX(SV* sv)','name' => 'SvNVX'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(UV u)','name' => 'newSVuv'},'gv_fetchmeth' => {'text' => '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)','name' => 'gv_fetchmeth'},'sv_nosharing' => {'text' => '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 *)','name' => 'sv_nosharing'},'SvUTF8_off' => {'text' => 'Unsets the UTF-8 status of an SV. void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'looks_like_number' => {'text' => 'Test if the content of an SV looks like a number (or is a number). C and C are treated as numbers (so will not issue a non-numeric warning), even if your atof() doesn\'t grok them. I32 looks_like_number(SV* sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpv_mg(SV *sv, const char *ptr)','name' => 'sv_catpv_mg'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. U32 HeHASH(HE* he)','name' => 'HeHASH'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'sv_setref_uv' => {'text' => 'Copies an unsigned 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 have a reference count of 1, and the RV will be returned. SV* sv_setref_uv(SV* rv, const char* classname, UV uv)','name' => 'sv_setref_uv'},'SvIOK' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. bool SvIOK(SV* sv)','name' => 'SvIOK'},'getcwd_sv' => {'text' => 'Fill the sv with current working directory int getcwd_sv(SV* sv)','name' => 'getcwd_sv'},'newSVpv' => {'text' => '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)','name' => 'newSVpv'},'sv_2pvbyte' => {'text' => 'Return a pointer to the byte-encoded representation of the SV, and set *lp to its length. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte(SV* sv, STRLEN* lp)','name' => 'sv_2pvbyte'},'fbm_instr' => {'text' => '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)','name' => 'fbm_instr'},'sv_setpvf' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Does not handle \'set\' magic. See C. void sv_setpvf(SV* sv, const char* pat, ...)','name' => 'sv_setpvf'},'SvPV_force' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHn(NV nv)','name' => 'XPUSHn'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part attributable to C. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'call_sv' => {'text' => '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)','name' => 'call_sv'},'SVt_PV' => {'text' => 'Pointer type flag for scalars. See C.','name' => 'SVt_PV'},'strGT' => {'text' => '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)','name' => 'strGT'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a string and disables all other OK bits, and leaves the UTF-8 status as it was. void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic after a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'},'sv_vcatpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. Does not handle \'set\' magic. See C. Usually used via its frontend C. void sv_vcatpvf(SV* sv, const char* pat, va_list* args)','name' => 'sv_vcatpvf'},'sv_pos_u2b' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from the start of the string, to a count of the equivalent number of bytes; if lenp is non-zero, it does the same to lenp, but this time starting from the offset, rather than from the start of the string. Handles magic and type coercion. void sv_pos_u2b(SV* sv, I32* offsetp, I32* lenp)','name' => 'sv_pos_u2b'},'SvTRUE' => {'text' => '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)','name' => 'SvTRUE'},'HeSVKEY_set' => {'text' => '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)','name' => 'HeSVKEY_set'},'POPl' => {'text' => 'Pops a long off the stack. long POPl','name' => 'POPl'},'hv_iternext_flags' => {'text' => 'Returns entries from a hash iterator. See C and C. The C 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 C<&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)','name' => 'hv_iternext_flags'},'grok_hex' => {'text' => 'converts a string representing a hex number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0x" or "x" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the hex number may use \'_\' characters to separate digits. UV grok_hex(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_hex'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L. SPAGAIN;','name' => 'SPAGAIN'},'call_method' => {'text' => '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)','name' => 'call_method'},'SvLOCK' => {'text' => 'Arranges for a mutual exclusion lock to be obtained on sv if a suitable module has been loaded. void SvLOCK(SV* sv)','name' => 'SvLOCK'},'sv_vsetpvfn' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Usually used via one of its frontends C and C. void sv_vsetpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vsetpvfn'},'get_cv' => {'text' => '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)','name' => 'get_cv'},'SvIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. Checks the B setting. Use C. bool SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the stack. void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'perl_parse' => {'text' => '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)','name' => 'perl_parse'},'to_utf8_case' => {'text' => 'The "p" contains the pointer to the UTF-8 string encoding the character that is being converted. The "ustrp" is a pointer to the character buffer to put the conversion result to. The "lenp" is a pointer to the length of the result. The "swashp" is a pointer to the swash to use. Both the special and normal mappings are stored lib/unicore/To/Foo.pl, and loaded by SWASHGET, using lib/utf8_heavy.pl. The special (usually, but not always, a multicharacter mapping), is tried first. The "special" is a string like "utf8::ToSpecLower", which means the hash %utf8::ToSpecLower. The access to the hash is through Perl_to_utf8_case(). The "normal" is a string like "ToLower" which means the swash %utf8::ToLower. UV to_utf8_case(U8 *p, U8* ustrp, STRLEN *lenp, SV **swash, char *normal, char *special)','name' => 'to_utf8_case'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory used by the array itself. void av_clear(AV* ar)','name' => 'av_clear'},'sv_force_normal' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. See also C. void sv_force_normal(SV *sv)','name' => 'sv_force_normal'},'av_unshift' => {'text' => '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)','name' => 'av_unshift'},'SvUNLOCK' => {'text' => 'Releases a mutual exclusion lock on sv if a suitable module has been loaded. void SvUNLOCK(SV* sv)','name' => 'SvUNLOCK'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C. int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV (using C). The new SV is marked as mortal. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_mortalcopy(SV* oldsv)','name' => 'sv_mortalcopy'},'POPpbytex' => {'text' => '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','name' => 'POPpbytex'},'sv_catpvn_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_catpvn_nomg(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn_nomg'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. UV SvUVX(SV* sv)','name' => 'SvUVX'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See L.','name' => 'G_NOARGS'},'SvSetMagicSV' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV(SV* dsb, SV* ssv)','name' => 'SvSetMagicSV'},'sv_utf8_decode' => {'text' => 'If the PV of the SV is an octet sequence in UTF-8 and contains a multiple-byte character, the C flag is turned on so that it looks like a character. If the PV contains only single-byte characters, the C flag stays being off. Scans PV for validity and returns false if the PV is invalid UTF-8. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_decode(SV *sv)','name' => 'sv_utf8_decode'},'Newz' => {'text' => '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)','name' => 'Newz'},'savepvn' => {'text' => 'Perl\'s version of what C would be if it existed. Returns a pointer to a newly allocated string which is a duplicate of the first C bytes from C. The memory allocated for the new string can be freed with the C function. char* savepvn(const char* pv, I32 len)','name' => 'savepvn'},'eval_sv' => {'text' => '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)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized. This relies on the fact that uninitialized array elements are set to C<&PL_sv_undef>. bool av_exists(AV* ar, I32 key)','name' => 'av_exists'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C. STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'Move' => {'text' => '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)','name' => 'Move'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'sv_catpvn_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. void sv_catpvn_flags(SV* sv, const char* ptr, STRLEN len, I32 flags)','name' => 'sv_catpvn_flags'},'GIMME' => {'text' => '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','name' => 'GIMME'},'sv_bless' => {'text' => '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)','name' => 'sv_bless'},'NEWSV' => {'text' => '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)','name' => 'NEWSV'},'sv_isa' => {'text' => '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)','name' => 'sv_isa'},'isALNUM' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphanumeric character (including underscore) or digit. bool isALNUM(char ch)','name' => 'isALNUM'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs.','name' => 'newXS'},'sv_catpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. If the appended data contains "wide" characters (including, but not limited to, SVs with a UTF-8 PV formatted with %s, and characters >255 formatted with %c), the original SV might get upgraded to UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. If the original SV was UTF-8, the pattern should be valid UTF-8; if the original SV was bytes, the pattern should be too. void sv_catpvf(SV* sv, const char* pat, ...)','name' => 'sv_catpvf'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. bool SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C. void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'utf8_to_uvuni' => {'text' => 'Returns the Unicode code point of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. This function should only be used when returned UV is considered an index into the Unicode semantic tables (e.g. swashes). If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvuni(U8 *s, STRLEN* retlen)','name' => 'utf8_to_uvuni'},'sv_2io' => {'text' => 'Using various gambits, try to get an IO from an SV: the IO slot if its a GV; or the recursive result if we\'re an RV; or the IO slot of the symbol named after the PV if we\'re a string. IO* sv_2io(SV* sv)','name' => 'sv_2io'},'PUSHmortal' => {'text' => 'Push a new mortal SV onto the stack. The stack must have room for this element. Does not handle \'set\' magic. Does not use C. See also C, C and C. void PUSHmortal()','name' => 'PUSHmortal'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphabetic character. bool isALPHA(char ch)','name' => 'isALPHA'},'Nullhv' => {'text' => 'Null HV pointer.','name' => 'Nullhv'},'av_fill' => {'text' => 'Ensure than an array has a given number of elements, equivalent to Perl\'s C<$#array = $fill;>. void av_fill(AV* ar, I32 fill)','name' => 'av_fill'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV. SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C. svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter* interp)','name' => 'perl_construct'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. void SvUOK(SV* sv)','name' => 'SvUOK'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_dec(SV* sv)','name' => 'sv_dec'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'MoveD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * MoveD(void* src, void* dest, int nitems, type)','name' => 'MoveD'},'strLE' => {'text' => '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)','name' => 'strLE'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'grok_bin' => {'text' => 'converts a string representing a binary number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The binary number may optionally be prefixed with "0b" or "b" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the binary number may use \'_\' characters to separate digits. UV grok_bin(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_bin'},'sv_2pvbyte_nolen' => {'text' => 'Return a pointer to the byte-encoded representation of the SV. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'SvOK' => {'text' => 'Returns a boolean indicating whether the value is an SV. It also tells whether the value is defined or not. bool SvOK(SV* sv)','name' => 'SvOK'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L. void perl_free(PerlInterpreter* interp)','name' => 'perl_free'},'sv_setref_nv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_nv(SV* rv, const char* classname, NV nv)','name' => 'sv_setref_nv'},'uvchr_to_utf8' => {'text' => 'Adds the UTF-8 representation of the Native codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvchr_to_utf8(d, uv); is the recommended wide native character-aware way of saying *(d++) = uv; U8* uvchr_to_utf8(U8 *d, UV uv)','name' => 'uvchr_to_utf8'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C. MAGIC* mg_find(SV* sv, int type)','name' => 'mg_find'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII digit. bool isDIGIT(char ch)','name' => 'isDIGIT'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'XPUSHmortal' => {'text' => 'Push a new mortal SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. Does not use C. See also C, C and C. void XPUSHmortal()','name' => 'XPUSHmortal'},'eval_pv' => {'text' => '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)','name' => 'eval_pv'},'newSVpvn_share' => {'text' => 'Creates a new SV with its SvPVX pointing to a shared string in the string table. If the string does not already exist in the table, it is created first. Turns on READONLY and FAKE. The string\'s hash is stored in the UV slot of the SV; if the C parameter is non-zero, that value is used; otherwise the hash is computed. The idea here is that as the string table is used for shared hash keys these strings will have SvPVX == HeKEY and hash lookup will avoid string compare. SV* newSVpvn_share(const char* s, I32 len, U32 hash)','name' => 'newSVpvn_share'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_setpvf_mg'},'SvPOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. Checks the B setting. Use C. bool SvPOKp(SV* sv)','name' => 'SvPOKp'},'sv_free' => {'text' => 'Decrement an SV\'s reference count, and if it drops to zero, call C to invoke destructors and free up any memory used by the body; finally, deallocate the SV\'s head itself. Normally called via a wrapper macro C. void sv_free(SV* sv)','name' => 'sv_free'},'sv_catpvn' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn'},'SvPVbyte_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_force(SV* sv, STRLEN len)','name' => 'SvPVbyte_force'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. CV* newCONSTSUB(HV* stash, char* name, SV* sv)','name' => 'newCONSTSUB'},'sv_setref_pv' => {'text' => '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 have a reference count of 1, and the RV will be returned. 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)','name' => 'sv_setref_pv'},'SvSHARE' => {'text' => 'Arranges for sv to be shared between threads if a suitable module has been loaded. void SvSHARE(SV* sv)','name' => 'SvSHARE'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_pop(AV* ar)','name' => 'av_pop'},'fbm_compile' => {'text' => '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)','name' => 'fbm_compile'},'sv_utf8_downgrade' => {'text' => 'Attempts to convert the PV of an SV from characters to bytes. If the PV contains a character beyond byte, this conversion will fail; in this case, either returns false or, if C is not true, croaks. This is not as a general purpose Unicode to byte encoding interface: use the Encode extension for that. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_downgrade(SV *sv, bool fail_ok)','name' => 'sv_utf8_downgrade'},'SvNIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. Checks the B setting. Use C. bool SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'croak' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Normally call this function the same way you call the C C function. Calling C returns control directly to Perl, sidestepping the normal C order of execution. See C. If you want to throw an exception object, assign the object to C<$@> and then pass C to croak(): errsv = get_sv("@", TRUE); sv_setsv(errsv, exception_object); croak(Nullch); void croak(const char* pat, ...)','name' => 'croak'},'sortsv' => {'text' => '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)','name' => 'sortsv'},'THIS' => {'text' => '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','name' => 'THIS'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either forward or backward. WARNING: do not use the following unless you *know* C is within the UTF-8 data pointed to by C *and* that on entry C is aligned on the first byte of character or just after the last byte of a character. U8* utf8_hop(U8 *s, I32 off)','name' => 'utf8_hop'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide UTF-8 bytes as a single character. Handles magic and type coercion. STRLEN sv_len_utf8(SV* sv)','name' => 'sv_len_utf8'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually handled by C. void XSRETURN(int nitems)','name' => 'XSRETURN'},'sv_setref_pvn' => {'text' => '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 have a reference count of 1, and the RV will be returned. Note that C copies the pointer while this copies the string. SV* sv_setref_pvn(SV* rv, const char* classname, char* pv, STRLEN n)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for blessed scalars. See C.','name' => 'SVt_PVMG'},'PUSHp' => {'text' => '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. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHp(char* str, STRLEN len)','name' => 'PUSHp'},'scan_bin' => {'text' => 'For backwards compatibility. Use C instead. NV scan_bin(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_bin'},'Nullcv' => {'text' => 'Null CV pointer.','name' => 'Nullcv'},'hv_clear_placeholders' => {'text' => '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)','name' => 'hv_clear_placeholders'},'mXPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Does not use C. See also C, C and C. void mXPUSHi(IV iv)','name' => 'mXPUSHi'},'dAX' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dAX;','name' => 'dAX'},'sv_2pv_nolen' => {'text' => 'Like C, but doesn\'t return the length too. You should usually use the macro wrapper C instead. char* sv_2pv_nolen(SV* sv)','name' => 'sv_2pv_nolen'},'get_av' => {'text' => '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)','name' => 'get_av'},'PL_sv_undef' => {'text' => 'This is the C SV. Always refer to this as C<&PL_sv_undef>. SV PL_sv_undef','name' => 'PL_sv_undef'},'SvPVbyte' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'hv_iterkeysv' => {'text' => '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)','name' => 'hv_iterkeysv'},'grok_number' => {'text' => '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)','name' => 'grok_number'},'SvIVx' => {'text' => 'Coerces the given SV to an integer and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. IV SvIVx(SV* sv)','name' => 'SvIVx'},'grok_numeric_radix' => {'text' => 'Scan and skip for a numeric decimal separator (radix). bool grok_numeric_radix(const char **sp, const char *send)','name' => 'grok_numeric_radix'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the stack. void XST_mNO(int pos)','name' => 'XST_mNO'},'toUPPER' => {'text' => 'Converts the specified character to uppercase. char toUPPER(char ch)','name' => 'toUPPER'},'mPUSHp' => {'text' => '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. Does not use C. See also C, C and C. void mPUSHp(char* str, STRLEN len)','name' => 'mPUSHp'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array. Returns the deleted element. If C equals C, the element is freed and null is returned. SV* av_delete(AV* ar, I32 key, I32 flags)','name' => 'av_delete'},'is_utf8_string_loc' => {'text' => 'Like is_ut8_string but store the location of the failure in the last argument. bool is_utf8_string_loc(U8 *s, STRLEN len, U8 **p)','name' => 'is_utf8_string_loc'},'utf8_distance' => {'text' => 'Returns the number of UTF-8 characters between the UTF-8 pointers C and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. IV utf8_distance(U8 *a, U8 *b)','name' => 'utf8_distance'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally appending to the currently-stored string. char* sv_gets(SV* sv, PerlIO* fp, I32 append)','name' => 'sv_gets'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'SvPVutf8x' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'sv_collxfrm' => {'text' => 'Add Collate Transform magic to an SV if it doesn\'t already have it. Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the scalar data of the variable, but transformed to such a format that a normal memory comparison can be used to compare the data according to the locale settings. char* sv_collxfrm(SV* sv, STRLEN* nxp)','name' => 'sv_collxfrm'},'sv_2cv' => {'text' => 'Using various gambits, try to get a CV from an SV; in addition, try if possible to set C<*st> and C<*gvp> to the stash and GV associated with it. CV* sv_2cv(SV* sv, HV** st, GV** gvp, I32 lref)','name' => 'sv_2cv'},'ZeroD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * ZeroD(void* dest, int nitems, type)','name' => 'ZeroD'},'SvPV_force_nomg' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. Doesn\'t process magic. char* SvPV_force_nomg(SV* sv, STRLEN len)','name' => 'SvPV_force_nomg'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. Will also turn off the UTF-8 status. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'POPpx' => {'text' => 'Pops a string off the stack. Requires a variable STRLEN n_a in scope. char* POPpx','name' => 'POPpx'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'sv_uv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. UV sv_uv(SV* sv)','name' => 'sv_uv'},'sv_pvbyte' => {'text' => 'Use C instead. char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'hv_fetch' => {'text' => '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 an C. See L for more information on how to use this function on tied hashes. SV** hv_fetch(HV* tb, const char* key, I32 klen, I32 lval)','name' => 'hv_fetch'},'Zero' => {'text' => '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)','name' => 'Zero'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_unref_flags' => {'text' => '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. The C argument can contain C to force the reference count to be decremented (otherwise the decrementing is conditional on the reference count being different from one or the reference being a readonly SV). See C. void sv_unref_flags(SV* sv, U32 flags)','name' => 'sv_unref_flags'},'sv_iv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. IV sv_iv(SV* sv)','name' => 'sv_iv'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'hv_scalar' => {'text' => 'Evaluates the hash in scalar context and returns the result. Handles magic when the hash is tied. SV* hv_scalar(HV* hv)','name' => 'hv_scalar'},'Nullch' => {'text' => 'Null character pointer.','name' => 'Nullch'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)','name' => 'mg_copy'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C flag on this RV; give the referred-to SV C magic if it hasn\'t already; and push a back-reference to this RV onto the array of backreferences associated with that magic. SV* sv_rvweaken(SV *sv)','name' => 'sv_rvweaken'},'grok_oct' => {'text' => 'converts a string representing an octal number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). If C is set in I<*flags> then the octal number may use \'_\' characters to separate digits. UV grok_oct(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_oct'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'scan_hex' => {'text' => 'For backwards compatibility. Use C instead. NV scan_hex(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_hex'},'newSVpvn' => {'text' => '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. If the C argument is NULL the new SV will be undefined. SV* newSVpvn(const char* s, STRLEN len)','name' => 'newSVpvn'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the supplied vtable and returns a pointer to the magic added. Note that C will allow things that C will not. In particular, you can add magic to SvREADONLY SVs, and add more than one instance of the same \'how\'. If C is greater than zero then a C I of C is stored, if C is zero then C is stored as-is and - as another special case - if C<(name && namlen == HEf_SVKEY)> then C is assumed to contain an C and is stored as-is with its REFCNT incremented. (This is now used as a subroutine by C.) MAGIC * sv_magicext(SV* sv, SV* obj, int how, MGVTBL *vtbl, const char* name, I32 namlen)','name' => 'sv_magicext'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C.','name' => 'SVt_PVCV'},'av_push' => {'text' => '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)','name' => 'av_push'},'unpackstring' => {'text' => 'The engine implementing unpack() Perl function. C puts the extracted list items on the stack and returns the number of elements. Issue C before and C after the call to this function. I32 unpackstring(char *pat, char *patend, char *s, char *strend, U32 flags)','name' => 'unpackstring'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV* ar, I32 key)','name' => 'av_extend'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV *sv)','name' => 'newRV_noinc'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpviv_mg(SV *sv, IV iv)','name' => 'sv_setpviv_mg'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'sv_2bool' => {'text' => 'This function is only called on magical items, and is only used by sv_true() or its macro equivalent. bool sv_2bool(SV* sv)','name' => 'sv_2bool'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. You may call C or C 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 C, so you must not discard your iterator immediately else the entry will leak - call C to trigger the resource deallocation. HE* hv_iternext(HV* tb)','name' => 'hv_iternext'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'sv_newmortal' => {'text' => 'Creates a new null SV which is mortal. The reference count of the SV is set to 1. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_newmortal()','name' => 'sv_newmortal'},'sv_clear' => {'text' => 'Clear an SV: call any destructors, free up any memory used by the body, and free the body itself. The SV\'s head is I freed, although its type is set to all 1\'s so that it won\'t inadvertently be assumed to be live during global destruction etc. This function should only be called when REFCNT is zero. Most of the time you\'ll want to call C (or its macro wrapper C) instead. void sv_clear(SV* sv)','name' => 'sv_clear'},'hv_iterinit' => {'text' => '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)','name' => 'hv_iterinit'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.008007', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_012_000.pm0000644000175000017500000061677311653441731020774 0ustar tseetseepackage Perl::APIReference::V5_012_000; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'newBINOP' => {'text' => '','name' => 'newBINOP'},'strGE' => {'text' => '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)','name' => 'strGE'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified version becoming C. Handles \'get\' magic. See also C for a version which guarantees to evaluate sv only once. char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'sv_vsetpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vsetpvf_mg(SV *const sv, const char *const pat, va_list *const args)','name' => 'sv_vsetpvf_mg'},'SvPVutf8' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'sortsv_flags' => {'text' => 'Sort an array, with various options. void sortsv_flags(SV** array, size_t num_elts, SVCOMPARE_t cmp, U32 flags)','name' => 'sortsv_flags'},'vwarn' => {'text' => '','name' => 'vwarn'},'scan_oct' => {'text' => 'For backwards compatibility. Use C instead. NV scan_oct(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_oct'},'my_strlcat' => {'text' => '','name' => 'my_strlcat'},'av_arylen_p' => {'text' => '','name' => 'av_arylen_p'},'newGVOP' => {'text' => '','name' => 'newGVOP'},'gv_add_by_type' => {'text' => '','name' => 'gv_add_by_type'},'is_uni_ascii' => {'text' => '','name' => 'is_uni_ascii'},'find_runcv' => {'text' => 'Locate the CV corresponding to the currently executing sub or eval. If db_seqp is non_null, skip CVs that are in the DB package and populate *db_seqp with the cop sequence number at the point that the DB:: code was entered. (allows debuggers to eval in the scope of the breakpoint rather than in the scope of the debugger itself). CV* find_runcv(U32 *db_seqp)','name' => 'find_runcv'},'utf8n_to_uvuni' => {'text' => 'Bottom level UTF-8 decode routine. Returns the Unicode code point value of the first character in the string C which is assumed to be in UTF-8 encoding and no longer than C; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, the behaviour is dependent on the value of C: if it contains UTF8_CHECK_ONLY, it is assumed that the caller will raise a warning, and this function will silently just set C to C<-1> and return zero. If the C does not contain UTF8_CHECK_ONLY, warnings about malformations will be given, C will be set to the expected length of the UTF-8 character in bytes, and zero will be returned. The C can also contain various flags to allow deviations from the strict UTF-8 encoding (see F). Most code should use utf8_to_uvchr() rather than call this directly. UV utf8n_to_uvuni(const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvuni'},'newSVpvn_utf8' => {'text' => 'Creates a new SV and copies a string into it. If utf8 is true, calls C on the new SV. Implemented as a wrapper around C. SV* newSVpvn_utf8(NULLOK const char* s, STRLEN len, U32 utf8)','name' => 'newSVpvn_utf8'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'pregcomp' => {'text' => '','name' => 'pregcomp'},'my_cxt_index' => {'text' => '','name' => 'my_cxt_index'},'lex_discard_to' => {'text' => 'Discards the first part of the Llinestr> buffer, up to I. The remaining content of the buffer will be moved, and all pointers into the buffer updated appropriately. I must not be later in the buffer than the position of Lbufptr>: it is not permitted to discard text that has yet to be lexed. Normally it is not necessarily to do this directly, because it suffices to use the implicit discarding behaviour of L and things based on it. However, if a token stretches across multiple lines, and the lexing code has kept multiple lines of text in the buffer fof that purpose, then after completion of the token it would be wise to explicitly discard the now-unneeded earlier lines, to avoid future multi-line tokens growing the buffer without bound. NOTE: this function is experimental and may change or be removed without notice. void lex_discard_to(char *ptr)','name' => 'lex_discard_to'},'markstack_grow' => {'text' => '','name' => 'markstack_grow'},'ibcmp_utf8' => {'text' => 'Return true if the strings s1 and s2 differ case-insensitively, false if not (if they are equal case-insensitively). If u1 is true, the string s1 is assumed to be in UTF-8-encoded Unicode. If u2 is true, the string s2 is assumed to be in UTF-8-encoded Unicode. If u1 or u2 are false, the respective string is assumed to be in native 8-bit encoding. If the pe1 and pe2 are non-NULL, the scanning pointers will be copied in there (they will point at the beginning of the I character). If the pointers behind pe1 or pe2 are non-NULL, they are the end pointers beyond which scanning will not continue under any circumstances. If the byte lengths l1 and l2 are non-zero, s1+l1 and s2+l2 will be used as goal end pointers that will also stop the scan, and which qualify towards defining a successful match: all the scans that define an explicit length must reach their goal pointers for a match to succeed). For case-insensitiveness, the "casefolding" of Unicode is used instead of upper/lowercasing both the characters, see http://www.unicode.org/unicode/reports/tr21/ (Case Mappings). I32 ibcmp_utf8(const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2)','name' => 'ibcmp_utf8'},'mXPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Does not use C. See also C, C and C. void mXPUSHp(char* str, STRLEN len)','name' => 'mXPUSHp'},'lex_stuff_sv' => {'text' => 'Insert characters into the lexer buffer (Llinestr>), immediately after the current lexing point (Lbufptr>), reallocating the buffer if necessary. This means that lexing code that runs later will see the characters as if they had appeared in the input. It is not recommended to do this as part of normal parsing, and most uses of this facility run the risk of the inserted characters being interpreted in an unintended manner. The string to be inserted is the string value of I. The characters are recoded for the lexer buffer, according to how the buffer is currently being interpreted (L). If a string to be interpreted is not already a Perl scalar, the L function avoids the need to construct a scalar. NOTE: this function is experimental and may change or be removed without notice. void lex_stuff_sv(SV *sv, U32 flags)','name' => 'lex_stuff_sv'},'CvSTASH' => {'text' => 'Returns the stash of the CV. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'gv_const_sv' => {'text' => 'If C is a typeglob whose subroutine entry is a constant sub eligible for inlining, or C is a placeholder reference that would be promoted to such a typeglob, then returns the value returned by the sub. Otherwise, returns NULL. SV* gv_const_sv(GV* gv)','name' => 'gv_const_sv'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. The target SV physically takes over ownership of the body of the source SV and inherits its flags; however, the target keeps any magic it owns, and any magic in the source is discarded. Note that this is a rather specialist SV copying operation; most of the time you\'ll want to use C or one of its many macro front-ends. void sv_replace(SV *const sv, SV *const nsv)','name' => 'sv_replace'},'utf8n_to_uvchr' => {'text' => 'flags Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. Allows length and flags to be passed to low level routine. UV utf8n_to_uvchr(const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvchr'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and L.','name' => 'G_ARRAY'},'sv_2iv' => {'text' => '','name' => 'sv_2iv'},'ck_warner_d' => {'text' => '','name' => 'ck_warner_d'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'mXPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void mXPUSHn(NV nv)','name' => 'mXPUSHn'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'is_utf8_punct' => {'text' => '','name' => 'is_utf8_punct'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dsv, SV *ssv)','name' => 'sv_catsv_mg'},'call_argv' => {'text' => '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)','name' => 'call_argv'},'SvPV_nolen' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified form becoming C. Handles \'get\' magic. char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'perl_clone' => {'text' => '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->create 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 C, 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 *proto_perl, UV flags)','name' => 'perl_clone'},'sv_2nv' => {'text' => 'Return the num value of an SV, doing any necessary string or integer conversion, magic etc. Normally used via the C and C macros. NV sv_2nv(SV *const sv)','name' => 'sv_2nv'},'save_alloc' => {'text' => '','name' => 'save_alloc'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'rninstr' => {'text' => '','name' => 'rninstr'},'hv_fetchs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV** hv_fetchs(HV* tb, const char* key, I32 lval)','name' => 'hv_fetchs'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'savepv' => {'text' => 'Perl\'s version of C. Returns a pointer to a newly allocated string which is a duplicate of C. The size of the string is determined by C. The memory allocated for the new string can be freed with the C function. char* savepv(const char* pv)','name' => 'savepv'},'save_iv' => {'text' => '','name' => 'save_iv'},'HvNAME' => {'text' => 'Returns the package name of a stash, or NULL if C isn\'t a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV of the sv is assumed to be octets in that encoding, and the sv will be converted into Unicode (and UTF-8). If the sv already is UTF-8 (or if it is not POK), or if the encoding is not a reference, nothing is done to the sv. If the encoding is not an C Encoding object, bad things will happen. (See F and L). The PV of the sv is returned. char* sv_recode_to_utf8(SV* sv, SV *encoding)','name' => 'sv_recode_to_utf8'},'save_hptr' => {'text' => '','name' => 'save_hptr'},'runops_debug' => {'text' => '','name' => 'runops_debug'},'do_gvgv_dump' => {'text' => '','name' => 'do_gvgv_dump'},'PERL_SYS_INIT' => {'text' => 'Provides system-specific tune up of the C runtime environment necessary to run Perl interpreters. This should be called only once, before creating any Perl interpreters. void PERL_SYS_INIT(int argc, char** argv)','name' => 'PERL_SYS_INIT'},'vstringify' => {'text' => 'In order to maintain maximum compatibility with earlier versions of Perl, this function will return either the floating point notation or the multiple dotted notation, depending on whether the original version contained 1 or more dots, respectively SV* vstringify(SV *vs)','name' => 'vstringify'},'sv_catsv_flags' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. If C has C bit set, will C on the SVs if appropriate, else not. C and C are implemented in terms of this function. void sv_catsv_flags(SV *const dsv, SV *const ssv, const I32 flags)','name' => 'sv_catsv_flags'},'is_uni_alpha' => {'text' => '','name' => 'is_uni_alpha'},'str_to_version' => {'text' => '','name' => 'str_to_version'},'sv_derived_from' => {'text' => 'Returns a boolean indicating whether the SV is derived from the specified class I. To check derivation at the Perl level, call C as a normal Perl method. bool sv_derived_from(SV* sv, const char *const name)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp_locale(SV *const sv1, SV *const sv2)','name' => 'sv_cmp_locale'},'sv_catpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_catpvs(SV* sv, const char* s)','name' => 'sv_catpvs'},'set_numeric_standard' => {'text' => '','name' => 'set_numeric_standard'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'Nullsv' => {'text' => 'Null SV pointer. (No longer available when C is defined.)','name' => 'Nullsv'},'scan_vstring' => {'text' => '','name' => 'scan_vstring'},'ptr_table_new' => {'text' => '','name' => 'ptr_table_new'},'do_op_dump' => {'text' => '','name' => 'do_op_dump'},'PerlIO_get_base' => {'text' => '','name' => 'PerlIO_get_base'},'SvPVX' => {'text' => 'Returns a pointer to the physical string in the SV. The SV must contain a string. char* SvPVX(SV* sv)','name' => 'SvPVX'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'is_utf8_perl_word' => {'text' => '','name' => 'is_utf8_perl_word'},'debop' => {'text' => '','name' => 'debop'},'ref' => {'text' => '','name' => 'ref'},'is_uni_print_lc' => {'text' => '','name' => 'is_uni_print_lc'},'SvOOK_offset' => {'text' => 'Reads into I the offset from SvPVX back to the true start of the allocated buffer, which will be non-zero if C has been used to efficiently remove characters from start of the buffer. Implemented as a macro, which takes the address of I, which must be of type C. Evaluates I more than once. Sets I to 0 if C is false. void SvOOK_offset(NN SV*sv, STRLEN len)','name' => 'SvOOK_offset'},'save_list' => {'text' => '','name' => 'save_list'},'is_uni_idfirst_lc' => {'text' => '','name' => 'is_uni_idfirst_lc'},'newGIVENOP' => {'text' => '','name' => 'newGIVENOP'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted if tainting is enabled. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'sv_nolocking' => {'text' => '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. "Superseded" by sv_nosharing(). void sv_nolocking(SV *sv)','name' => 'sv_nolocking'},'ibcmp' => {'text' => '','name' => 'ibcmp'},'Slab_Alloc' => {'text' => '','name' => 'Slab_Alloc'},'strLT' => {'text' => '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)','name' => 'strLT'},'save_pushptr' => {'text' => '','name' => 'save_pushptr'},'save_clearsv' => {'text' => '','name' => 'save_clearsv'},'Slab_Free' => {'text' => '','name' => 'Slab_Free'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_shift(AV *av)','name' => 'av_shift'},'sv_setpvf_nocontext' => {'text' => '','name' => 'sv_setpvf_nocontext'},'sv_nounlocking' => {'text' => '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. "Superseded" by sv_nosharing(). void sv_nounlocking(SV *sv)','name' => 'sv_nounlocking'},'perl_clone_using' => {'text' => '','name' => 'perl_clone_using'},'PerlIO_context_layers' => {'text' => '','name' => 'PerlIO_context_layers'},'lex_unstuff' => {'text' => 'Discards text about to be lexed, from Lbufptr> up to I. Text following I will be moved, and the buffer shortened. This hides the discarded text from any lexing code that runs later, as if the text had never appeared. This is not the normal way to consume lexed text. For that, use L. NOTE: this function is experimental and may change or be removed without notice. void lex_unstuff(char *ptr)','name' => 'lex_unstuff'},'newSVpvf_nocontext' => {'text' => '','name' => 'newSVpvf_nocontext'},'SvUV_set' => {'text' => 'Set the value of the UV pointer in sv to val. See C. void SvUV_set(SV* sv, UV val)','name' => 'SvUV_set'},'rvpv_dup' => {'text' => '','name' => 'rvpv_dup'},'filter_read' => {'text' => '','name' => 'filter_read'},'ckwarn' => {'text' => '','name' => 'ckwarn'},'warner' => {'text' => '','name' => 'warner'},'CopyD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * CopyD(void* src, void* dest, int nitems, type)','name' => 'CopyD'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *const sv, const IV i)','name' => 'sv_setiv_mg'},'newFOROP' => {'text' => '','name' => 'newFOROP'},'save_generic_svref' => {'text' => '','name' => 'save_generic_svref'},'savesharedpvn' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. (With the specific difference that a NULL pointer is not acceptable) char* savesharedpvn(const char *const pv, const STRLEN len)','name' => 'savesharedpvn'},'SvCUR_set' => {'text' => 'Set the current length of the string which is in the SV. See C and C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'sv_2pv' => {'text' => '','name' => 'sv_2pv'},'SvNOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a double. U32 SvNOK(SV* sv)','name' => 'SvNOK'},'mPUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void mPUSHn(NV nv)','name' => 'mPUSHn'},'is_uni_digit_lc' => {'text' => '','name' => 'is_uni_digit_lc'},'sv_reset' => {'text' => 'Underlying implementation for the C Perl function. Note that the perl-level function is vaguely deprecated. void sv_reset(const char* s, HV *const stash)','name' => 'sv_reset'},'sv_2pv_flags' => {'text' => 'Returns a pointer to the string value of an SV, and sets *lp to its length. If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string if necessary. Normally invoked via the C macro. C and C usually end up here too. char* sv_2pv_flags(SV *const sv, STRLEN *const lp, const I32 flags)','name' => 'sv_2pv_flags'},'push_scope' => {'text' => '','name' => 'push_scope'},'SvNVx' => {'text' => 'Coerces the given SV to a double and returns it. Guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. NV SvNVx(SV* sv)','name' => 'SvNVx'},'setdefout' => {'text' => 'Sets PL_defoutgv, the default file handle for output, to the passed in typeglob. As PL_defoutgv "owns" a reference on its typeglob, the reference count of the passed in typeglob is increased by one, and the reference count of the typeglob that PL_defoutgv points to is decreased by one. void setdefout(GV* gv)','name' => 'setdefout'},'form_nocontext' => {'text' => '','name' => 'form_nocontext'},'hv_store' => {'text' => '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. Effectively a successful hv_store takes ownership of one reference to C. 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 L for more information on how to use this function on tied hashes. SV** hv_store(HV *hv, const char *key, I32 klen, SV *val, U32 hash)','name' => 'hv_store'},'sys_intern_dup' => {'text' => '','name' => 'sys_intern_dup'},'do_binmode' => {'text' => '','name' => 'do_binmode'},'get_op_names' => {'text' => '','name' => 'get_op_names'},'op_null' => {'text' => '','name' => 'op_null'},'hv_fetch_ent' => {'text' => '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 *hv, SV *keysv, I32 lval, U32 hash)','name' => 'hv_fetch_ent'},'gv_fetchpvn_flags' => {'text' => '','name' => 'gv_fetchpvn_flags'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'Newx' => {'text' => 'The XSUB-writer\'s interface to the C C function. In 5.9.3, Newx() and friends replace the older New() API, and drops the first parameter, I, a debug aid which allowed callers to identify themselves. This aid has been superseded by a new build option, PERL_MEM_LOG (see L). The older API is still there for use in XS modules supporting older perls. void Newx(void* ptr, int nitems, type)','name' => 'Newx'},'newFORM' => {'text' => '','name' => 'newFORM'},'PUSHs' => {'text' => 'Push an SV onto the stack. The stack must have room for this element. Does not handle \'set\' magic. Does not use C. See also C, C and C. void PUSHs(SV* sv)','name' => 'PUSHs'},'to_uni_upper_lc' => {'text' => '','name' => 'to_uni_upper_lc'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setuv(SV *const sv, const UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'is_uni_upper_lc' => {'text' => '','name' => 'is_uni_upper_lc'},'do_aspawn' => {'text' => '','name' => 'do_aspawn'},'sv_pvn' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn(SV *sv, STRLEN *lp)','name' => 'sv_pvn'},'do_openn' => {'text' => '','name' => 'do_openn'},'mro_get_from_name' => {'text' => '','name' => 'mro_get_from_name'},'sv_setref_iv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_iv(SV *const rv, const char *const classname, const IV iv)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => '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. Uses the "OOK hack". Beware: after this function returns, C and SvPVX_const(sv) may no longer refer to the same chunk of data. void sv_chop(SV *const sv, const char *const ptr)','name' => 'sv_chop'},'sv_backoff' => {'text' => 'Remove any string offset. You should normally use the C macro wrapper instead. int sv_backoff(SV *const sv)','name' => 'sv_backoff'},'reentrant_retry' => {'text' => '','name' => 'reentrant_retry'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_pvn_nomg' => {'text' => '','name' => 'sv_pvn_nomg'},'is_uni_space_lc' => {'text' => '','name' => 'is_uni_space_lc'},'stack_grow' => {'text' => '','name' => 'stack_grow'},'dump_mstats' => {'text' => '','name' => 'dump_mstats'},'newLOOPEX' => {'text' => '','name' => 'newLOOPEX'},'save_shared_pvref' => {'text' => '','name' => 'save_shared_pvref'},'PL_na' => {'text' => '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','name' => 'PL_na'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the SV is set to 1. SV* newSViv(const IV i)','name' => 'newSViv'},'gv_name_set' => {'text' => '','name' => 'gv_name_set'},'sv_untaint' => {'text' => 'Untaint an SV. Use C instead. void sv_untaint(SV *const sv)','name' => 'sv_untaint'},'Newxz' => {'text' => 'The XSUB-writer\'s interface to the C C function. The allocated memory is zeroed with C. See also C. void Newxz(void* ptr, int nitems, type)','name' => 'Newxz'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See C.','name' => 'SVt_PVHV'},'reentrant_init' => {'text' => '','name' => 'reentrant_init'},'save_gp' => {'text' => '','name' => 'save_gp'},'SvRX' => {'text' => 'Convenience macro to get the REGEXP from a SV. This is approximately equivalent to the following snippet: if (SvMAGICAL(sv)) mg_get(sv); if (SvROK(sv) && (tmpsv = (SV*)SvRV(sv)) && SvTYPE(tmpsv) == SVt_PVMG && (tmpmg = mg_find(tmpsv, PERL_MAGIC_qr))) { return (REGEXP *)tmpmg->mg_obj; } NULL will be returned if a REGEXP* is not found. REGEXP * SvRX(SV *sv)','name' => 'SvRX'},'newASSIGNOP' => {'text' => '','name' => 'newASSIGNOP'},'hv_undef' => {'text' => 'Undefines the hash. void hv_undef(HV *hv)','name' => 'hv_undef'},'SvSetMagicSV_nosteal' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetMagicSV_nosteal'},'sv_isobject' => {'text' => '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)','name' => 'sv_isobject'},'gv_efullname4' => {'text' => '','name' => 'gv_efullname4'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it. See C for a version which guarantees to evaluate sv only once. IV SvIV(SV* sv)','name' => 'SvIV'},'PerlIO_eof' => {'text' => '','name' => 'PerlIO_eof'},'sv_setref_uv' => {'text' => 'Copies an unsigned 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 have a reference count of 1, and the RV will be returned. SV* sv_setref_uv(SV *const rv, const char *const classname, const UV uv)','name' => 'sv_setref_uv'},'get_ppaddr' => {'text' => '','name' => 'get_ppaddr'},'getcwd_sv' => {'text' => 'Fill the sv with current working directory int getcwd_sv(SV* sv)','name' => 'getcwd_sv'},'newSVpvs_share' => {'text' => 'Like C, but takes a literal string instead of a string/length pair and omits the hash parameter. SV* newSVpvs_share(const char* s)','name' => 'newSVpvs_share'},'newSVpv' => {'text' => '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 *const s, const STRLEN len)','name' => 'newSVpv'},'sv_2pvbyte' => {'text' => 'Return a pointer to the byte-encoded representation of the SV, and set *lp to its length. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte(SV *const sv, STRLEN *const lp)','name' => 'sv_2pvbyte'},'fbm_instr' => {'text' => '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* littlestr, U32 flags)','name' => 'fbm_instr'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHn(NV nv)','name' => 'XPUSHn'},'PL_opfreehook' => {'text' => 'When non-C, the function pointed by this variable will be called each time an OP is freed with the corresponding OP as the argument. This allows extensions to free any extra attribute they have locally attached to an OP. It is also assured to first fire for the parent OP and then for its kids. When you replace this variable, it is considered a good practice to store the possibly previously installed hook and that you recall it inside your own. Perl_ophook_t PL_opfreehook','name' => 'PL_opfreehook'},'dump_all' => {'text' => '','name' => 'dump_all'},'ninstr' => {'text' => '','name' => 'ninstr'},'sv_vcatpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. Does not handle \'set\' magic. See C. Usually used via its frontend C. void sv_vcatpvf(SV *const sv, const char *const pat, va_list *const args)','name' => 'sv_vcatpvf'},'sv_pos_u2b' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from the start of the string, to a count of the equivalent number of bytes; if lenp is non-zero, it does the same to lenp, but this time starting from the offset, rather than from the start of the string. Handles magic and type coercion. Use C in preference, which correctly handles strings longer than 2Gb. void sv_pos_u2b(SV *const sv, I32 *const offsetp, I32 *const lenp)','name' => 'sv_pos_u2b'},'is_utf8_xdigit' => {'text' => '','name' => 'is_utf8_xdigit'},'PERL_SYS_INIT3' => {'text' => 'Provides system-specific tune up of the C runtime environment necessary to run Perl interpreters. This should be called only once, before creating any Perl interpreters. void PERL_SYS_INIT3(int argc, char** argv, char** env)','name' => 'PERL_SYS_INIT3'},'upg_version' => {'text' => 'In-place upgrade of the supplied SV to a version object. SV *sv = upg_version(SV *sv, bool qv); Returns a pointer to the upgraded SV. Set the boolean qv if you want to force this SV to be interpreted as an "extended" version. SV* upg_version(SV *ver, bool qv)','name' => 'upg_version'},'HeSVKEY_set' => {'text' => '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)','name' => 'HeSVKEY_set'},'is_utf8_perl_space' => {'text' => '','name' => 'is_utf8_perl_space'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L. SPAGAIN;','name' => 'SPAGAIN'},'newCVREF' => {'text' => '','name' => 'newCVREF'},'my_bcopy' => {'text' => '','name' => 'my_bcopy'},'PL_parser-Ebufptr' => {'text' => 'Points to the current position of lexing inside the lexer buffer. Characters around this point may be freely examined, within the range delimited by Clinestr>)> and Lbufend>. The octets of the buffer may be intended to be interpreted as either UTF-8 or Latin-1, as indicated by L. Lexing code (whether in the Perl core or not) moves this pointer past the characters that it consumes. It is also expected to perform some bookkeeping whenever a newline character is consumed. This movement can be more conveniently performed by the function L, which handles newlines appropriately. Interpretation of the buffer\'s octets can be abstracted out by using the slightly higher-level functions L and L. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_parser-Ebufptr'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See L.','name' => 'G_NOARGS'},'is_uni_ascii_lc' => {'text' => '','name' => 'is_uni_ascii_lc'},'hv_riter_set' => {'text' => '','name' => 'hv_riter_set'},'to_uni_lower' => {'text' => '','name' => 'to_uni_lower'},'dounwind' => {'text' => '','name' => 'dounwind'},'ptr_table_clear' => {'text' => '','name' => 'ptr_table_clear'},'uvchr_to_utf8_flags' => {'text' => '','name' => 'uvchr_to_utf8_flags'},'save_hash' => {'text' => '','name' => 'save_hash'},'sv_isa' => {'text' => '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 *const name)','name' => 'sv_isa'},'sv_catpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. If the appended data contains "wide" characters (including, but not limited to, SVs with a UTF-8 PV formatted with %s, and characters >255 formatted with %c), the original SV might get upgraded to UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. If the original SV was UTF-8, the pattern should be valid UTF-8; if the original SV was bytes, the pattern should be too. void sv_catpvf(SV *const sv, const char *const pat, ...)','name' => 'sv_catpvf'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C. void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'utf8_to_uvuni' => {'text' => 'Returns the Unicode code point of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. This function should only be used when the returned UV is considered an index into the Unicode semantic tables (e.g. swashes). If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvuni(const U8 *s, STRLEN *retlen)','name' => 'utf8_to_uvuni'},'is_utf8_idcont' => {'text' => '','name' => 'is_utf8_idcont'},'av_fill' => {'text' => 'Set the highest index in the array to the given number, equivalent to Perl\'s C<$#array = $fill;>. The number of elements in the an array will be C after av_fill() returns. If the array was previously shorter then the additional elements appended are set to C. If the array was longer, then the excess elements are freed. C is the same as C. void av_fill(AV *av, I32 fill)','name' => 'av_fill'},'warn_nocontext' => {'text' => '','name' => 'warn_nocontext'},'my_swap' => {'text' => '','name' => 'my_swap'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'MoveD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * MoveD(void* src, void* dest, int nitems, type)','name' => 'MoveD'},'gv_IOadd' => {'text' => '','name' => 'gv_IOadd'},'grok_bin' => {'text' => 'converts a string representing a binary number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*flags> gives output flags. If the value is <= C it is returned as a UV, the output flags are clear, and nothing is written to I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The binary number may optionally be prefixed with "0b" or "b" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the binary number may use \'_\' characters to separate digits. UV grok_bin(const char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_bin'},'cast_uv' => {'text' => '','name' => 'cast_uv'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L. void perl_free(PerlInterpreter *my_perl)','name' => 'perl_free'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C. MAGIC* mg_find(const SV* sv, int type)','name' => 'mg_find'},'safesysfree' => {'text' => '','name' => 'safesysfree'},'PL_parser-Elinestr' => {'text' => 'Buffer scalar containing the chunk currently under consideration of the text currently being lexed. This is always a plain string scalar (for which C is true). It is not intended to be used as a scalar by normal scalar means; instead refer to the buffer directly by the pointer variables described below. The lexer maintains various C pointers to things in the Clinestr> buffer. If Clinestr> is ever reallocated, all of these pointers must be updated. Don\'t attempt to do this manually, but rather use L if you need to reallocate the buffer. The content of the text chunk in the buffer is commonly exactly one complete line of input, up to and including a newline terminator, but there are situations where it is otherwise. The octets of the buffer may be intended to be interpreted as either UTF-8 or Latin-1. The function L tells you which. Do not use the C flag on this scalar, which may disagree with it. For direct examination of the buffer, the variable Lbufend> points to the end of the buffer. The current lexing position is pointed to by Lbufptr>. Direct use of these pointers is usually preferable to examination of the scalar through normal scalar means. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_parser-Elinestr'},'hv_riter_p' => {'text' => '','name' => 'hv_riter_p'},'newSVpvn_share' => {'text' => 'Creates a new SV with its SvPVX_const pointing to a shared string in the string table. If the string does not already exist in the table, it is created first. Turns on READONLY and FAKE. If the C parameter is non-zero, that value is used; otherwise the hash is computed. The string\'s hash can be later be retrieved from the SV with the C macro. The idea here is that as the string table is used for shared hash keys these strings will have SvPVX_const == HeKEY and hash lookup will avoid string compare. SV* newSVpvn_share(const char* s, I32 len, U32 hash)','name' => 'newSVpvn_share'},'mro_set_mro' => {'text' => '','name' => 'mro_set_mro'},'SvPOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a character string. Checks the B setting. Use C instead. U32 SvPOKp(SV* sv)','name' => 'SvPOKp'},'pregfree2' => {'text' => '','name' => 'pregfree2'},'sv_catpvn' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpvn(SV *dsv, const char *sstr, STRLEN len)','name' => 'sv_catpvn'},'my_socketpair' => {'text' => '','name' => 'my_socketpair'},'init_global_struct' => {'text' => '','name' => 'init_global_struct'},'sv_utf8_downgrade' => {'text' => 'Attempts to convert the PV of an SV from characters to bytes. If the PV contains a character that cannot fit in a byte, this conversion will fail; in this case, either returns false or, if C is not true, croaks. This is not as a general purpose Unicode to byte encoding interface: use the Encode extension for that. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_downgrade(SV *const sv, const bool fail_ok)','name' => 'sv_utf8_downgrade'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either forward or backward. WARNING: do not use the following unless you *know* C is within the UTF-8 data pointed to by C *and* that on entry C is aligned on the first byte of character or just after the last byte of a character. U8* utf8_hop(const U8 *s, I32 off)','name' => 'utf8_hop'},'newPROG' => {'text' => '','name' => 'newPROG'},'sv_setref_pvn' => {'text' => '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 have a reference count of 1, and the RV will be returned. Note that C copies the pointer while this copies the string. SV* sv_setref_pvn(SV *const rv, const char *const classname, const char *const pv, const STRLEN n)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for blessed scalars. See C.','name' => 'SVt_PVMG'},'gv_fetchsv' => {'text' => '','name' => 'gv_fetchsv'},'PUSHp' => {'text' => '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. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHp(char* str, STRLEN len)','name' => 'PUSHp'},'my_strftime' => {'text' => '','name' => 'my_strftime'},'mXPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void mXPUSHi(IV iv)','name' => 'mXPUSHi'},'PL_sv_undef' => {'text' => 'This is the C SV. Always refer to this as C<&PL_sv_undef>. SV PL_sv_undef','name' => 'PL_sv_undef'},'hv_iterkeysv' => {'text' => '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)','name' => 'hv_iterkeysv'},'mPUSHp' => {'text' => 'Push a string onto the stack. The stack must have room for this element. The C indicates the length of the string. Does not use C. See also C, C and C. void mPUSHp(char* str, STRLEN len)','name' => 'mPUSHp'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array. Returns the deleted element. If C equals C, the element is freed and null is returned. SV* av_delete(AV *av, I32 key, I32 flags)','name' => 'av_delete'},'utf8_distance' => {'text' => 'Returns the number of UTF-8 characters between the UTF-8 pointers C and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. IV utf8_distance(const U8 *a, const U8 *b)','name' => 'utf8_distance'},'SvPV_nomg' => {'text' => 'Like C but doesn\'t process magic. char* SvPV_nomg(SV* sv, STRLEN len)','name' => 'SvPV_nomg'},'parser_dup' => {'text' => '','name' => 'parser_dup'},'do_sprintf' => {'text' => '','name' => 'do_sprintf'},'SvUV_nomg' => {'text' => 'Like C but doesn\'t process magic. UV SvUV_nomg(SV* sv)','name' => 'SvUV_nomg'},'save_I32' => {'text' => '','name' => 'save_I32'},'gv_autoload4' => {'text' => '','name' => 'gv_autoload4'},'POPpx' => {'text' => 'Pops a string off the stack. char* POPpx','name' => 'POPpx'},'newCONDOP' => {'text' => '','name' => 'newCONDOP'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'sv_setpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_setpvs(SV* sv, const char* s)','name' => 'sv_setpvs'},'is_uni_punct_lc' => {'text' => '','name' => 'is_uni_punct_lc'},'cxinc' => {'text' => '','name' => 'cxinc'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. Guarantees to C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'sv_clear' => {'text' => 'Clear an SV: call any destructors, free up any memory used by the body, and free the body itself. The SV\'s head is I freed, although its type is set to all 1\'s so that it won\'t inadvertently be assumed to be live during global destruction etc. This function should only be called when REFCNT is zero. Most of the time you\'ll want to call C (or its macro wrapper C) instead. void sv_clear(SV *const sv)','name' => 'sv_clear'},'lex_read_space' => {'text' => 'Reads optional spaces, in Perl style, in the text currently being lexed. The spaces may include ordinary whitespace characters and Perl-style comments. C<#line> directives are processed if encountered. Lbufptr> is moved past the spaces, so that it points at a non-space character (or the end of the input text). If spaces extend into the next chunk of input text, the next chunk will be read in. Normally the current chunk will be discarded at the same time, but if I includes C then the current chunk will not be discarded. NOTE: this function is experimental and may change or be removed without notice. void lex_read_space(U32 flags)','name' => 'lex_read_space'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'SvGAMAGIC' => {'text' => 'Returns true if the SV has get magic or overloading. If either is true then the scalar is active data, and has the potential to return a new value every time it is accessed. Hence you must be careful to only read it once per user logical operation and work with that returned value. If neither is true then the scalar\'s value cannot change unless written to. U32 SvGAMAGIC(SV* sv)','name' => 'SvGAMAGIC'},'svtype' => {'text' => '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.','name' => 'svtype'},'hv_placeholders_get' => {'text' => '','name' => 'hv_placeholders_get'},'load_module' => {'text' => '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 C. The optional trailing SV* arguments can be used to specify arguments to the module\'s import() method, similar to C. They must be terminated with a final NULL pointer. Note that this list can only be omitted when the PERL_LOADMOD_NOIMPORT flag has been used. Otherwise at least a single NULL pointer to designate the default import list is required. void load_module(U32 flags, SV* name, SV* ver, ...)','name' => 'load_module'},'dump_eval' => {'text' => '','name' => 'dump_eval'},'Poison' => {'text' => 'PoisonWith(0xEF) for catching access to freed memory. void Poison(void* dest, int nitems, type)','name' => 'Poison'},'is_uni_alpha_lc' => {'text' => '','name' => 'is_uni_alpha_lc'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *const sv, const char *const pat, ...)','name' => 'sv_catpvf_mg'},'get_sv' => {'text' => 'Returns the SV of the specified Perl scalar. C are passed to C. If C is set and the Perl variable does not exist then it will be created. If C is zero 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 flags)','name' => 'get_sv'},'GetVars' => {'text' => '','name' => 'GetVars'},'do_hv_dump' => {'text' => '','name' => 'do_hv_dump'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *const sv, const char *const ptr)','name' => 'sv_setpv_mg'},'whichsig' => {'text' => '','name' => 'whichsig'},'lex_next_chunk' => {'text' => 'Reads in the next chunk of text to be lexed, appending it to Llinestr>. This should be called when lexing code has looked to the end of the current chunk and wants to know more. It is usual, but not necessary, for lexing to have consumed the entirety of the current chunk at this time. If Lbufptr> is pointing to the very end of the current chunk (i.e., the current chunk has been entirely consumed), normally the current chunk will be discarded at the same time that the new chunk is read in. If I includes C, the current chunk will not be discarded. If the current chunk has not been entirely consumed, then it will not be discarded regardless of the flag. Returns true if some new text was added to the buffer, or false if the buffer has reached the end of the input text. NOTE: this function is experimental and may change or be removed without notice. bool lex_next_chunk(U32 flags)','name' => 'lex_next_chunk'},'sv_2mortal' => {'text' => 'Marks an existing SV as mortal. The SV will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. SvTEMP() is turned on which means that the SV\'s string buffer can be "stolen" if this SV is copied. See also C and C. SV* sv_2mortal(SV *const sv)','name' => 'sv_2mortal'},'hv_store_flags' => {'text' => '','name' => 'hv_store_flags'},'is_uni_graph' => {'text' => '','name' => 'is_uni_graph'},'malloc' => {'text' => '','name' => 'malloc'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself. void av_undef(AV *av)','name' => 'av_undef'},'pack_cat' => {'text' => '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, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)','name' => 'pack_cat'},'PerlIO_read' => {'text' => '','name' => 'PerlIO_read'},'sv_cmp' => {'text' => '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. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp(SV *const sv1, SV *const sv2)','name' => 'sv_cmp'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'sv_force_normal_flags' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg; if we\'re a copy-on-write scalar, this is the on-write time when we do the copy, and is also used locally. If C is set then a copy-on-write scalar drops its PV buffer (if any) and becomes SvPOK_off rather than making a copy. (Used where this scalar is about to be set to some other value.) In addition, the C parameter gets passed to C when unrefing. C calls this function with flags set to 0. void sv_force_normal_flags(SV *const sv, const U32 flags)','name' => 'sv_force_normal_flags'},'tmps_grow' => {'text' => '','name' => 'tmps_grow'},'is_utf8_char' => {'text' => 'Tests if some arbitrary number of bytes begins in a valid UTF-8 character. Note that an INVARIANT (i.e. ASCII on non-EBCDIC machines) character is a valid UTF-8 character. The actual number of bytes in the UTF-8 character will be returned if it is valid, otherwise 0. STRLEN is_utf8_char(const U8 *s)','name' => 'is_utf8_char'},'get_vtbl' => {'text' => '','name' => 'get_vtbl'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'sv_utf8_upgrade' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Will C on C if appropriate. Always sets the SvUTF8 flag to avoid future validity checks even if the whole string is the same in UTF-8 as not. Returns the number of bytes in the converted string This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. Sets up the C and C variables by calling C and C. This is usually handled automatically by C. dXSARGS;','name' => 'dXSARGS'},'savesharedpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the C C is a US-ASCII (Basic Latin) whitespace. bool isSPACE(char ch)','name' => 'isSPACE'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* ptr)','name' => 'Safefree'},'custom_op_desc' => {'text' => '','name' => 'custom_op_desc'},'regdupe_internal' => {'text' => '','name' => 'regdupe_internal'},'gv_stashpvn' => {'text' => 'Returns a pointer to the stash for a specified package. The C parameter indicates the length of the C, in bytes. C is passed to C, so if set to C then the package will be created if it does not already exist. If the package does not exist and C is 0 (or any other setting that does not create packages) then NULL is returned. HV* gv_stashpvn(const char* name, U32 namelen, I32 flags)','name' => 'gv_stashpvn'},'vmess' => {'text' => '','name' => 'vmess'},'to_uni_fold' => {'text' => '','name' => 'to_uni_fold'},'new_collate' => {'text' => '','name' => 'new_collate'},'my_stat' => {'text' => '','name' => 'my_stat'},'my_setenv' => {'text' => '','name' => 'my_setenv'},'newSV_type' => {'text' => 'Creates a new SV, of the type specified. The reference count for the new SV is set to 1. SV* newSV_type(const svtype type)','name' => 'newSV_type'},'SvREFCNT_inc_void_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value, and you know that I is not NULL. The macro doesn\'t need to return a meaningful value, or check for NULLness, so it\'s smaller and faster. void SvREFCNT_inc_void_NN(SV* sv)','name' => 'SvREFCNT_inc_void_NN'},'Perl_signbit' => {'text' => 'Return a non-zero integer if the sign bit on an NV is set, and 0 if it is not. If Configure detects this system has a signbit() that will work with our NVs, then we just use it via the #define in perl.h. Otherwise, fall back on this implementation. As a first pass, this gets everything right except -0.0. Alas, catching -0.0 is the main use for this function, so this is not too helpful yet. Still, at least we have the scaffolding in place to support other systems, should that prove useful. Configure notes: This function is called \'Perl_signbit\' instead of a plain \'signbit\' because it is easy to imagine a system having a signbit() function or macro that doesn\'t happen to work with our particular choice of NVs. We shouldn\'t just re-#define signbit as Perl_signbit and expect the standard system headers to be happy. Also, this is a no-context function (no pTHX_) because Perl_signbit() is usually re-#defined in perl.h as a simple macro call to the system\'s signbit(). Users should just always call Perl_signbit(). NOTE: this function is experimental and may change or be removed without notice. int Perl_signbit(NV f)','name' => 'Perl_signbit'},'PUSH_MULTICALL' => {'text' => 'Opening bracket for a lightweight callback. See L. PUSH_MULTICALL;','name' => 'PUSH_MULTICALL'},'new_ctype' => {'text' => '','name' => 'new_ctype'},'save_svref' => {'text' => '','name' => 'save_svref'},'to_uni_upper' => {'text' => '','name' => 'to_uni_upper'},'newNULLLIST' => {'text' => '','name' => 'newNULLLIST'},'is_uni_cntrl_lc' => {'text' => '','name' => 'is_uni_cntrl_lc'},'is_utf8_lower' => {'text' => '','name' => 'is_utf8_lower'},'sv_pos_u2b_flags' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from the start of the string, to a count of the equivalent number of bytes; if lenp is non-zero, it does the same to lenp, but this time starting from the offset, rather than from the start of the string. Handles type coercion. I is passed to C, and usually should be C to handle magic. STRLEN sv_pos_u2b_flags(SV *const sv, STRLEN uoffset, STRLEN *const lenp, U32 flags)','name' => 'sv_pos_u2b_flags'},'init_tm' => {'text' => '','name' => 'init_tm'},'newWHILEOP' => {'text' => '','name' => 'newWHILEOP'},'Gv_AMupdate' => {'text' => '','name' => 'Gv_AMupdate'},'filter_del' => {'text' => '','name' => 'filter_del'},'POPp' => {'text' => 'Pops a string off the stack. Deprecated. New code should use POPpx. char* POPp','name' => 'POPp'},'SvIV_nomg' => {'text' => 'Like C but doesn\'t process magic. IV SvIV_nomg(SV* sv)','name' => 'SvIV_nomg'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'newANONLIST' => {'text' => '','name' => 'newANONLIST'},'my_memset' => {'text' => '','name' => 'my_memset'},'my_atof2' => {'text' => '','name' => 'my_atof2'},'PerlIO_get_ptr' => {'text' => '','name' => 'PerlIO_get_ptr'},'save_destructor' => {'text' => '','name' => 'save_destructor'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV *hv, char **key, I32 *retlen)','name' => 'hv_iternextsv'},'lex_read_to' => {'text' => 'Consume text in the lexer buffer, from Lbufptr> up to I. This advances Lbufptr> to match I, performing the correct bookkeeping whenever a newline character is passed. This is the normal way to consume lexed text. Interpretation of the buffer\'s octets can be abstracted out by using the slightly higher-level functions L and L. NOTE: this function is experimental and may change or be removed without notice. void lex_read_to(char *ptr)','name' => 'lex_read_to'},'sv_pvbyten_force' => {'text' => 'The backend for the C macro. Always use the macro instead. char* sv_pvbyten_force(SV *const sv, STRLEN *const lp)','name' => 'sv_pvbyten_force'},'reg_named_buff_fetch' => {'text' => '','name' => 'reg_named_buff_fetch'},'ibcmp_locale' => {'text' => '','name' => 'ibcmp_locale'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'save_pptr' => {'text' => '','name' => 'save_pptr'},'PerlIO_set_ptrcnt' => {'text' => '','name' => 'PerlIO_set_ptrcnt'},'mPUSHs' => {'text' => 'Push an SV onto the stack and mortalizes the SV. The stack must have room for this element. Does not use C. See also C and C. void mPUSHs(SV* sv)','name' => 'mPUSHs'},'dump_packsubs' => {'text' => '','name' => 'dump_packsubs'},'is_utf8_digit' => {'text' => '','name' => 'is_utf8_digit'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'init_i18nl10n' => {'text' => '','name' => 'init_i18nl10n'},'vform' => {'text' => '','name' => 'vform'},'get_op_descs' => {'text' => '','name' => 'get_op_descs'},'safesyscalloc' => {'text' => '','name' => 'safesyscalloc'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'sv_2pvutf8_nolen' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8_nolen(SV* sv)','name' => 'sv_2pvutf8_nolen'},'gv_HVadd' => {'text' => '','name' => 'gv_HVadd'},'mro_get_linear_isa' => {'text' => 'Returns either C or C for the given stash, dependant upon which MRO is in effect for that stash. The return value is a read-only AV*. You are responsible for C on the return value if you plan to store it anywhere semi-permanently (otherwise it might be deleted out from under you the next time the cache is invalidated). AV* mro_get_linear_isa(HV* stash)','name' => 'mro_get_linear_isa'},'av_store' => {'text' => '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 *av, I32 key, SV *val)','name' => 'av_store'},'SvPVbytex' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex(SV* sv, STRLEN len)','name' => 'SvPVbytex'},'reg_named_buff_scalar' => {'text' => '','name' => 'reg_named_buff_scalar'},'unlnk' => {'text' => '','name' => 'unlnk'},'av_fetch' => {'text' => '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 *av, I32 key, I32 lval)','name' => 'av_fetch'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV *hv, HE *entry)','name' => 'hv_iterval'},'is_uni_xdigit_lc' => {'text' => '','name' => 'is_uni_xdigit_lc'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. const char* sv_reftype(const SV *const sv, const int ob)','name' => 'sv_reftype'},'SvREFCNT_inc_simple_void_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value, and you know that I is not NULL. The macro doesn\'t need to return a meaningful value, or check for NULLness, so it\'s smaller and faster. void SvREFCNT_inc_simple_void_NN(SV* sv)','name' => 'SvREFCNT_inc_simple_void_NN'},'rsignal_state' => {'text' => '','name' => 'rsignal_state'},'av_len' => {'text' => 'Returns the highest index in the array. The number of elements in the array is C. Returns -1 if the array is empty. I32 av_len(AV *av)','name' => 'av_len'},'sv_unmagic' => {'text' => 'Removes all magic of type C from an SV. int sv_unmagic(SV *const sv, const int type)','name' => 'sv_unmagic'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled. void SvTAINT(SV* sv)','name' => 'SvTAINT'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'my_sprintf' => {'text' => 'The C library C, wrapped if necessary, to ensure that it will return the length of the string written to the buffer. Only rare pre-ANSI systems need the wrapper function - usually this is a direct call to C. int my_sprintf(char *buffer, const char *pat, ...)','name' => 'my_sprintf'},'to_utf8_fold' => {'text' => 'Convert the UTF-8 encoded character at p to its foldcase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the foldcase version may be longer than the original character (up to three characters). The first character of the foldcased version is returned (but note, as explained above, that there may be more.) UV to_utf8_fold(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_fold'},'regfree_internal' => {'text' => '','name' => 'regfree_internal'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. Uses C to determine the length of C, then calls C. HV* gv_stashpv(const char* name, I32 flags)','name' => 'gv_stashpv'},'sv_vcatpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vcatpvf_mg(SV *const sv, const char *const pat, va_list *const args)','name' => 'sv_vcatpvf_mg'},'mXPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void mXPUSHu(UV uv)','name' => 'mXPUSHu'},'hv_exists_ent' => {'text' => '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 *hv, SV *keysv, U32 hash)','name' => 'hv_exists_ent'},'atfork_unlock' => {'text' => '','name' => 'atfork_unlock'},'SvNIOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a number, integer or double. U32 SvNIOK(SV* sv)','name' => 'SvNIOK'},'save_long' => {'text' => '','name' => 'save_long'},'mro_method_changed_in' => {'text' => 'Invalidates method caching on any child classes of the given stash, so that they might notice the changes in this one. Ideally, all instances of C in perl source outside of C should be replaced by calls to this. Perl automatically handles most of the common ways a method might be redefined. However, there are a few ways you could change a method in a stash without the cache code noticing, in which case you need to call this method afterwards: 1) Directly manipulating the stash HV entries from XS code. 2) Assigning a reference to a readonly scalar constant into a stash entry in order to create a constant subroutine (like constant.pm does). This same method is available from pure perl via, C. void mro_method_changed_in(HV* stash)','name' => 'mro_method_changed_in'},'unpack_str' => {'text' => '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(const char *pat, const char *patend, const char *s, const char *strbeg, const char *strend, char **new_s, I32 ocnt, U32 flags)','name' => 'unpack_str'},'my_fflush_all' => {'text' => '','name' => 'my_fflush_all'},'is_uni_print' => {'text' => '','name' => 'is_uni_print'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C wrapper instead. SV* sv_newref(SV *const sv)','name' => 'sv_newref'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'sv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the scalar sv, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument is as in pv_uni_display(). The pointer to the PV of the dsv is returned. char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim, UV flags)','name' => 'sv_uni_display'},'newSVpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV* newSVpvs(const char* s)','name' => 'newSVpvs'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'realloc' => {'text' => '','name' => 'realloc'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'packlist' => {'text' => 'The engine implementing pack() Perl function. void packlist(SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist)','name' => 'packlist'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C for a version which guarantees to evaluate sv only once. NV SvNV(SV* sv)','name' => 'SvNV'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'SvUTF8' => {'text' => 'Returns a U32 value indicating whether the SV contains UTF-8 encoded data. Call this after SvPV() in case any call to string overloading updates the internal flag. U32 SvUTF8(SV* sv)','name' => 'SvUTF8'},'op_dump' => {'text' => '','name' => 'op_dump'},'get_mstats' => {'text' => '','name' => 'get_mstats'},'savestack_grow' => {'text' => '','name' => 'savestack_grow'},'debstackptrs' => {'text' => '','name' => 'debstackptrs'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'ptr_table_store' => {'text' => '','name' => 'ptr_table_store'},'cv_undef' => {'text' => 'Clear out all the active components of a CV. This can happen either by an explicit C, 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)','name' => 'cv_undef'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'sv_catpvf_nocontext' => {'text' => '','name' => 'sv_catpvf_nocontext'},'save_padsv_and_mortalize' => {'text' => '','name' => 'save_padsv_and_mortalize'},'get_cvn_flags' => {'text' => 'Returns the CV of the specified Perl subroutine. C are passed to C. 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_cvn_flags(const char* name, STRLEN len, I32 flags)','name' => 'get_cvn_flags'},'reentrant_free' => {'text' => '','name' => 'reentrant_free'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'dump_vindent' => {'text' => '','name' => 'dump_vindent'},'SvPVx' => {'text' => 'A version of C which guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. char* SvPVx(SV* sv, STRLEN len)','name' => 'SvPVx'},'dump_form' => {'text' => '','name' => 'dump_form'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. If necessary, uses C and upgrades the SV to C. Returns a pointer to the character buffer. Use the C wrapper instead. char* sv_grow(SV *const sv, STRLEN newlen)','name' => 'sv_grow'},'vnormal' => {'text' => 'Accepts a version object and returns the normalized string representation. Call like: sv = vnormal(rv); NOTE: you can pass either the object directly or the SV contained within the RV. SV* vnormal(SV *vs)','name' => 'vnormal'},'newPVOP' => {'text' => '','name' => 'newPVOP'},'filter_add' => {'text' => '','name' => 'filter_add'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. Does not use C. See also C, C and C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'is_uni_graph_lc' => {'text' => '','name' => 'is_uni_graph_lc'},'is_utf8_alnum' => {'text' => '','name' => 'is_utf8_alnum'},'set_numeric_radix' => {'text' => '','name' => 'set_numeric_radix'},'is_utf8_upper' => {'text' => '','name' => 'is_utf8_upper'},'newIO' => {'text' => '','name' => 'newIO'},'do_join' => {'text' => '','name' => 'do_join'},'save_helem' => {'text' => '','name' => 'save_helem'},'die' => {'text' => '','name' => 'die'},'sv_usepvn' => {'text' => 'Tells an SV to use C to find its string value. Implemented by calling C with C of 0, hence does not handle \'set\' magic. See C. void sv_usepvn(SV* sv, char* ptr, STRLEN len)','name' => 'sv_usepvn'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'swash_init' => {'text' => '','name' => 'swash_init'},'newANONSUB' => {'text' => '','name' => 'newANONSUB'},'warn' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Call this function the same way you call the C C function. See C. void warn(const char* pat, ...)','name' => 'warn'},'PerlIO_get_bufsiz' => {'text' => '','name' => 'PerlIO_get_bufsiz'},'to_uni_title_lc' => {'text' => '','name' => 'to_uni_title_lc'},'fp_dup' => {'text' => '','name' => 'fp_dup'},'hek_dup' => {'text' => '','name' => 'hek_dup'},'pmop_dump' => {'text' => '','name' => 'pmop_dump'},'newANONATTRSUB' => {'text' => '','name' => 'newANONATTRSUB'},'sv_catpvf_mg_nocontext' => {'text' => '','name' => 'sv_catpvf_mg_nocontext'},'reg_named_buff_all' => {'text' => '','name' => 'reg_named_buff_all'},'PerlIO_close' => {'text' => '','name' => 'PerlIO_close'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. void EXTEND(SP, int nitems)','name' => 'EXTEND'},'newOP' => {'text' => '','name' => 'newOP'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(const UV u)','name' => 'newSVuv'},'gv_fetchmeth' => {'text' => '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. 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)','name' => 'gv_fetchmeth'},'op_refcnt_lock' => {'text' => '','name' => 'op_refcnt_lock'},'newGVgen' => {'text' => '','name' => 'newGVgen'},'sv_does' => {'text' => 'Returns a boolean indicating whether the SV performs a specific, named role. The SV can be a Perl object or the name of a Perl class. bool sv_does(SV* sv, const char *const name)','name' => 'sv_does'},'delimcpy' => {'text' => '','name' => 'delimcpy'},'newLOOPOP' => {'text' => '','name' => 'newLOOPOP'},'reg_named_buff_firstkey' => {'text' => '','name' => 'reg_named_buff_firstkey'},'free_global_struct' => {'text' => '','name' => 'free_global_struct'},'uvuni_to_utf8' => {'text' => '','name' => 'uvuni_to_utf8'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part attributable to C. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'PerlIO_tell' => {'text' => '','name' => 'PerlIO_tell'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a string and disables all other OK bits, and leaves the UTF-8 status as it was. void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic after a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'},'SvTRUE' => {'text' => 'Returns a boolean indicating whether Perl would evaluate the SV as true or false. See SvOK() for a defined/undefined test. Does not handle \'get\' magic. bool SvTRUE(SV* sv)','name' => 'SvTRUE'},'regdump' => {'text' => '','name' => 'regdump'},'my_pclose' => {'text' => '','name' => 'my_pclose'},'hv_iternext_flags' => {'text' => 'Returns entries from a hash iterator. See C and C. The C 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 C<&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 *hv, I32 flags)','name' => 'hv_iternext_flags'},'is_utf8_string_loclen' => {'text' => 'Like is_utf8_string() but stores the location of the failure (in the case of "utf8ness failure") or the location s+len (in the case of "utf8ness success") in the C, and the number of UTF-8 encoded characters in the C. See also is_utf8_string_loc() and is_utf8_string(). bool is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el)','name' => 'is_utf8_string_loclen'},'call_method' => {'text' => '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)','name' => 'call_method'},'sys_init' => {'text' => '','name' => 'sys_init'},'perl_parse' => {'text' => 'Tells a Perl interpreter to parse a Perl script. See L. int perl_parse(PerlInterpreter *my_perl, XSINIT_t xsinit, int argc, char** argv, char** env)','name' => 'perl_parse'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory used by the array itself. void av_clear(AV *av)','name' => 'av_clear'},'sv_force_normal' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. See also C. void sv_force_normal(SV *sv)','name' => 'sv_force_normal'},'av_unshift' => {'text' => '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 *av, I32 num)','name' => 'av_unshift'},'save_set_svflags' => {'text' => '','name' => 'save_set_svflags'},'SvREFCNT_inc_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you know I is not NULL. Since we don\'t have to check the NULLness, it\'s faster and smaller. SV* SvREFCNT_inc_NN(SV* sv)','name' => 'SvREFCNT_inc_NN'},'sys_term' => {'text' => '','name' => 'sys_term'},'re_intuit_start' => {'text' => '','name' => 're_intuit_start'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. UV SvUVX(SV* sv)','name' => 'SvUVX'},'do_pmop_dump' => {'text' => '','name' => 'do_pmop_dump'},'sv_utf8_decode' => {'text' => 'If the PV of the SV is an octet sequence in UTF-8 and contains a multiple-byte character, the C flag is turned on so that it looks like a character. If the PV contains only single-byte characters, the C flag stays being off. Scans PV for validity and returns false if the PV is invalid UTF-8. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_decode(SV *const sv)','name' => 'sv_utf8_decode'},'op_refcnt_unlock' => {'text' => '','name' => 'op_refcnt_unlock'},'hv_stores' => {'text' => 'Like C, but takes a literal string instead of a string/length pair and omits the hash parameter. SV** hv_stores(HV* tb, const char* key, NULLOK SV* val)','name' => 'hv_stores'},'eval_sv' => {'text' => '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)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'sv_utf8_upgrade_nomg' => {'text' => 'Like sv_utf8_upgrade, but doesn\'t do magic on C STRLEN sv_utf8_upgrade_nomg(SV *sv)','name' => 'sv_utf8_upgrade_nomg'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'GIMME' => {'text' => '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','name' => 'GIMME'},'newLOGOP' => {'text' => '','name' => 'newLOGOP'},'my_snprintf' => {'text' => 'The C library C functionality, if available and standards-compliant (uses C, actually). However, if the C is not available, will unfortunately use the unsafe C which can overrun the buffer (there is an overrun check, but that may be too late). Consider using C instead, or getting C. int my_snprintf(char *buffer, const Size_t len, const char *format, ...)','name' => 'my_snprintf'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. bool SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'gp_ref' => {'text' => '','name' => 'gp_ref'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter *my_perl)','name' => 'perl_construct'},'newWHENOP' => {'text' => '','name' => 'newWHENOP'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. bool SvUOK(SV* sv)','name' => 'SvUOK'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_dec(SV *const sv)','name' => 'sv_dec'},'pv_display' => {'text' => 'Similar to pv_escape(dsv,pv,cur,pvlim,PERL_PV_ESCAPE_QUOTE); except that an additional "\\0" will be appended to the string when len > cur and pv[cur] is "\\0". Note that the final string may be up to 7 chars longer than pvlim. char* pv_display(SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)','name' => 'pv_display'},'newHVREF' => {'text' => '','name' => 'newHVREF'},'sv_2pvbyte_nolen' => {'text' => 'Return a pointer to the byte-encoded representation of the SV. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'is_uni_space' => {'text' => '','name' => 'is_uni_space'},'PerlIO_fileno' => {'text' => '','name' => 'PerlIO_fileno'},'uvchr_to_utf8' => {'text' => 'Adds the UTF-8 representation of the Native codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvchr_to_utf8(d, uv); is the recommended wide native character-aware way of saying *(d++) = uv; U8* uvchr_to_utf8(U8 *d, UV uv)','name' => 'uvchr_to_utf8'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the C C is a US-ASCII (Basic Latin) digit. bool isDIGIT(char ch)','name' => 'isDIGIT'},'call_atexit' => {'text' => '','name' => 'call_atexit'},'is_utf8_alpha' => {'text' => '','name' => 'is_utf8_alpha'},'my_bzero' => {'text' => '','name' => 'my_bzero'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. Passing NULL for SV creates a constant sub equivalent to C, which won\'t be called if used as a destructor, but will suppress the overhead of a call to C. (This form, however, isn\'t eligible for inlining at compile time.) CV* newCONSTSUB(HV* stash, const char* name, SV* sv)','name' => 'newCONSTSUB'},'SvSHARE' => {'text' => 'Arranges for sv to be shared between threads if a suitable module has been loaded. void SvSHARE(SV* sv)','name' => 'SvSHARE'},'vwarner' => {'text' => '','name' => 'vwarner'},'sortsv' => {'text' => 'Sort an array. Here is an example: sortsv(AvARRAY(av), av_len(av)+1, Perl_sv_cmp_locale); Currently this always uses mergesort. See sortsv_flags for a more flexible routine. void sortsv(SV** array, size_t num_elts, SVCOMPARE_t cmp)','name' => 'sortsv'},'sys_intern_clear' => {'text' => '','name' => 'sys_intern_clear'},'my_ntohl' => {'text' => '','name' => 'my_ntohl'},'doref' => {'text' => '','name' => 'doref'},'scan_bin' => {'text' => 'For backwards compatibility. Use C instead. NV scan_bin(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_bin'},'Nullcv' => {'text' => 'Null CV pointer. (deprecated - use C<(CV *)NULL> instead)','name' => 'Nullcv'},'lex_bufutf8' => {'text' => 'Indicates whether the octets in the lexer buffer (Llinestr>) should be interpreted as the UTF-8 encoding of Unicode characters. If not, they should be interpreted as Latin-1 characters. This is analogous to the C flag for scalars. In UTF-8 mode, it is not guaranteed that the lexer buffer actually contains valid UTF-8. Lexing code must be robust in the face of invalid encoding. The actual C flag of the Llinestr> scalar is significant, but not the whole story regarding the input character encoding. Normally, when a file is being read, the scalar contains octets and its C flag is off, but the octets should be interpreted as UTF-8 if the C pragma is in effect. During a string eval, however, the scalar may have the C flag on, and in this case its octets should be interpreted as UTF-8 unless the C pragma is in effect. This logic may change in the future; use this function instead of implementing the logic yourself. NOTE: this function is experimental and may change or be removed without notice. bool lex_bufutf8()','name' => 'lex_bufutf8'},'MULTICALL' => {'text' => 'Make a lightweight callback. See L. MULTICALL;','name' => 'MULTICALL'},'debprofdump' => {'text' => '','name' => 'debprofdump'},'SvPVbyte' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'is_uni_lower' => {'text' => '','name' => 'is_uni_lower'},'sys_init3' => {'text' => '','name' => 'sys_init3'},'PerlIO_stdout' => {'text' => '','name' => 'PerlIO_stdout'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'SvPVutf8x' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'sv_2cv' => {'text' => 'Using various gambits, try to get a CV from an SV; in addition, try if possible to set C<*st> and C<*gvp> to the stash and GV associated with it. The flags in C are passed to gv_fetchsv. CV* sv_2cv(SV* sv, HV **const st, GV **const gvp, const I32 lref)','name' => 'sv_2cv'},'gp_free' => {'text' => '','name' => 'gp_free'},'SvPV_force_nomg' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. Doesn\'t process magic. char* SvPV_force_nomg(SV* sv, STRLEN len)','name' => 'SvPV_force_nomg'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. Will also turn off the UTF-8 status. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'save_destructor_x' => {'text' => '','name' => 'save_destructor_x'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'sv_pvbyte' => {'text' => 'Use C instead. char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'hv_fetch' => {'text' => '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 an C. See L for more information on how to use this function on tied hashes. SV** hv_fetch(HV *hv, const char *key, I32 klen, I32 lval)','name' => 'hv_fetch'},'XCPT_TRY_START' => {'text' => 'Starts a try block. See L.','name' => 'XCPT_TRY_START'},'sv_unref_flags' => {'text' => '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. The C argument can contain C to force the reference count to be decremented (otherwise the decrementing is conditional on the reference count being different from one or the reference being a readonly SV). See C. void sv_unref_flags(SV *const ref, const U32 flags)','name' => 'sv_unref_flags'},'hv_scalar' => {'text' => 'Evaluates the hash in scalar context and returns the result. Handles magic when the hash is tied. SV* hv_scalar(HV *hv)','name' => 'hv_scalar'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV *sv, SV *nsv, const char *key, I32 klen)','name' => 'mg_copy'},'save_I16' => {'text' => '','name' => 'save_I16'},'grok_oct' => {'text' => 'converts a string representing an octal number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). If C is set in I<*flags> then the octal number may use \'_\' characters to separate digits. UV grok_oct(const char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_oct'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C flag on this RV; give the referred-to SV C magic if it hasn\'t already; and push a back-reference to this RV onto the array of backreferences associated with that magic. If the RV is magical, set magic will be called after the RV is cleared. SV* sv_rvweaken(SV *const sv)','name' => 'sv_rvweaken'},'scan_hex' => {'text' => 'For backwards compatibility. Use C instead. NV scan_hex(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_hex'},'newSVpvn' => {'text' => '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. If the C argument is NULL the new SV will be undefined. SV* newSVpvn(const char *const s, const STRLEN len)','name' => 'newSVpvn'},'unpackstring' => {'text' => 'The engine implementing unpack() Perl function. C puts the extracted list items on the stack and returns the number of elements. Issue C before and C after the call to this function. I32 unpackstring(const char *pat, const char *patend, const char *s, const char *strend, U32 flags)','name' => 'unpackstring'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV *av, I32 key)','name' => 'av_extend'},'sv_peek' => {'text' => '','name' => 'sv_peek'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. You may call C or C 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 C, so you must not discard your iterator immediately else the entry will leak - call C to trigger the resource deallocation. HE* hv_iternext(HV *hv)','name' => 'hv_iternext'},'hv_store_ent' => {'text' => '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. Effectively a successful hv_store_ent takes ownership of one reference to C. 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 C; unlike C it does not take ownership of it, so maintaining the correct reference count on C 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 L for more information on how to use this function on tied hashes. HE* hv_store_ent(HV *hv, SV *key, SV *val, U32 hash)','name' => 'hv_store_ent'},'hv_eiter_set' => {'text' => '','name' => 'hv_eiter_set'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package. See C. HV* gv_stashsv(SV* sv, I32 flags)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'form' => {'text' => '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, ...)','name' => 'form'},'instr' => {'text' => '','name' => 'instr'},'pregexec' => {'text' => '','name' => 'pregexec'},'is_utf8_string' => {'text' => 'Returns true if first C bytes of the given string form a valid UTF-8 string, false otherwise. Note that \'a valid UTF-8 string\' does not mean \'a string that contains code points above 0x7F encoded in UTF-8\' because a valid ASCII string is a valid UTF-8 string. See also is_ascii_string(), is_utf8_string_loclen(), and is_utf8_string_loc(). bool is_utf8_string(const U8 *s, STRLEN len)','name' => 'is_utf8_string'},'croak_xs_usage' => {'text' => 'A specialised variant of C for emitting the usage message for xsubs croak_xs_usage(cv, "eee_yow"); works out the package name and subroutine name from C, and then calls C. Hence if C is C<&ouch::awk>, it would call C as: Perl_croak(aTHX_ "Usage %s::%s(%s)", "ouch" "awk", "eee_yow"); void croak_xs_usage(const CV *const cv, const char *const params)','name' => 'croak_xs_usage'},'sv_insert' => {'text' => 'Inserts a string at the specified offset/length within the SV. Similar to the Perl substr() function. Handles get magic. void sv_insert(SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen)','name' => 'sv_insert'},'SvPOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a character string. U32 SvPOK(SV* sv)','name' => 'SvPOK'},'pad_findmy' => {'text' => 'Given a lexical name, try to find its offset, first in the current pad, or failing that, in the pads of any lexically enclosing subs (including the complications introduced by eval). If the name is found in an outer pad, then a fake entry is added to the current pad. Returns the offset in the current pad, or NOT_IN_PAD on failure. NOTE: this function is experimental and may change or be removed without notice. PADOFFSET pad_findmy(const char* name, STRLEN len, U32 flags)','name' => 'pad_findmy'},'sv_destroyable' => {'text' => 'Dummy routine which reports that object can be destroyed when there is no sharing module present. It ignores its single SV argument, and returns \'true\'. Exists to avoid test for a NULL function pointer and because it could potentially warn under some level of strict-ness. bool sv_destroyable(SV *sv)','name' => 'sv_destroyable'},'save_aelem_flags' => {'text' => '','name' => 'save_aelem_flags'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C.','name' => 'XS'},'gv_check' => {'text' => '','name' => 'gv_check'},'sv_setpvn' => {'text' => 'Copies a string into an SV. The C parameter indicates the number of bytes to be copied. If the C argument is NULL the SV will become undefined. Does not handle \'set\' magic. See C. void sv_setpvn(SV *const sv, const char *const ptr, const STRLEN len)','name' => 'sv_setpvn'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'newSVrv' => {'text' => '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 *const rv, const char *const classname)','name' => 'newSVrv'},'cast_i32' => {'text' => '','name' => 'cast_i32'},'is_utf8_posix_digit' => {'text' => '','name' => 'is_utf8_posix_digit'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'stashpv_hvname_match' => {'text' => '','name' => 'stashpv_hvname_match'},'newMYSUB' => {'text' => '','name' => 'newMYSUB'},'PoisonWith' => {'text' => 'Fill up memory with a byte pattern (a byte repeated over and over again) that hopefully catches attempts to access uninitialized memory. void PoisonWith(void* dest, int nitems, type, U8 byte)','name' => 'PoisonWith'},'av_create_and_unshift_one' => {'text' => 'Unshifts an SV onto the beginning of the array, creating the array if necessary. A small internal helper function to remove a commonly duplicated idiom. NOTE: this function is experimental and may change or be removed without notice. SV** av_create_and_unshift_one(AV **const avp, SV *const val)','name' => 'av_create_and_unshift_one'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'is_uni_lower_lc' => {'text' => '','name' => 'is_uni_lower_lc'},'seed' => {'text' => '','name' => 'seed'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C to type C if necessary, then adds a new magic item of type C to the head of the magic list. See C (which C now calls) for a description of the handling of the C and C arguments. You need to use C to add magic to SvREADONLY SVs and also to add more than one instance of the same \'how\'. void sv_magic(SV *const sv, SV *const obj, const int how, const char *const name, const I32 namlen)','name' => 'sv_magic'},'sv_utf8_upgrade_flags' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes are invariant in UTF-8. If C has C bit set, will C on C if appropriate, else not. Returns the number of bytes in the converted string C and C are implemented in terms of this function. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade_flags(SV *const sv, const I32 flags)','name' => 'sv_utf8_upgrade_flags'},'do_open9' => {'text' => '','name' => 'do_open9'},'magic_dump' => {'text' => '','name' => 'magic_dump'},'gv_fetchfile_flags' => {'text' => '','name' => 'gv_fetchfile_flags'},'SvREFCNT_inc_void' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value. The macro doesn\'t need to return a meaningful value. void SvREFCNT_inc_void(SV* sv)','name' => 'SvREFCNT_inc_void'},'leave_scope' => {'text' => '','name' => 'leave_scope'},'newSTATEOP' => {'text' => '','name' => 'newSTATEOP'},'my_fork' => {'text' => '','name' => 'my_fork'},'SvROK' => {'text' => 'Tests if the SV is an RV. U32 SvROK(SV* sv)','name' => 'SvROK'},'sv_unref' => {'text' => '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. This is C with the C being zero. See C. void sv_unref(SV* sv)','name' => 'sv_unref'},'moreswitches' => {'text' => '','name' => 'moreswitches'},'ptr_table_fetch' => {'text' => '','name' => 'ptr_table_fetch'},'save_nogv' => {'text' => '','name' => 'save_nogv'},'sv_setnv' => {'text' => 'Copies a double into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setnv(SV *const sv, const NV num)','name' => 'sv_setnv'},'is_utf8_mark' => {'text' => '','name' => 'is_utf8_mark'},'SvREFCNT_inc_simple_NN' => {'text' => 'Same as SvREFCNT_inc_simple, but can only be used if you know I is not NULL. Since we don\'t have to check the NULLness, it\'s faster and smaller. SV* SvREFCNT_inc_simple_NN(SV* sv)','name' => 'SvREFCNT_inc_simple_NN'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1. HV* newHV()','name' => 'newHV'},'gv_dump' => {'text' => '','name' => 'gv_dump'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or false. bool strNE(char* s1, char* s2)','name' => 'strNE'},'my_strlcpy' => {'text' => '','name' => 'my_strlcpy'},'PerlIO_fill' => {'text' => '','name' => 'PerlIO_fill'},'my_failure_exit' => {'text' => '','name' => 'my_failure_exit'},'sv_pvutf8n_force' => {'text' => 'The backend for the C macro. Always use the macro instead. char* sv_pvutf8n_force(SV *const sv, STRLEN *const lp)','name' => 'sv_pvutf8n_force'},'do_sv_dump' => {'text' => '','name' => 'do_sv_dump'},'SvNV_set' => {'text' => 'Set the value of the NV pointer in sv to val. See C. void SvNV_set(SV* sv, NV val)','name' => 'SvNV_set'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1. AV* newAV()','name' => 'newAV'},'bytes_from_utf8' => {'text' => 'Converts a string C of length C from UTF-8 into native byte encoding. Unlike C but like C, returns a pointer to the newly-created string, and updates C to contain the new length. Returns the original string if no conversion occurs, C is unchanged. Do nothing if C points to 0. Sets C to 0 if C is converted or consisted entirely of characters that are invariant in utf8 (i.e., US-ASCII on non-EBCDIC machines). NOTE: this function is experimental and may change or be removed without notice. U8* bytes_from_utf8(const U8 *s, STRLEN *len, bool *is_utf8)','name' => 'bytes_from_utf8'},'dump_sub' => {'text' => '','name' => 'dump_sub'},'vload_module' => {'text' => '','name' => 'vload_module'},'save_adelete' => {'text' => '','name' => 'save_adelete'},'av_make' => {'text' => '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 **strp)','name' => 'av_make'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. See C for a version which guarantees to evaluate sv only once. UV SvUV(SV* sv)','name' => 'SvUV'},'hv_name_set' => {'text' => '','name' => 'hv_name_set'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L. int perl_run(PerlInterpreter *my_perl)','name' => 'perl_run'},'mess_nocontext' => {'text' => '','name' => 'mess_nocontext'},'sv_insert_flags' => {'text' => 'Same as C, but the extra C are passed the C that applies to C. void sv_insert_flags(SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen, const U32 flags)','name' => 'sv_insert_flags'},'SvPVutf8_nolen' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_nolen(SV* sv)','name' => 'SvPVutf8_nolen'},'SvRXOK' => {'text' => 'Returns a boolean indicating whether the SV contains qr magic (PERL_MAGIC_qr). If you want to do something with the REGEXP* later use SvRX instead and check for NULL. bool SvRXOK(SV* sv)','name' => 'SvRXOK'},'sv_setpviv' => {'text' => 'Copies an integer into the given SV, also updating its string value. Does not handle \'set\' magic. See C. void sv_setpviv(SV *const sv, const IV num)','name' => 'sv_setpviv'},'sv_dup' => {'text' => '','name' => 'sv_dup'},'sv_true' => {'text' => 'Returns true if the SV has a true value by Perl\'s rules. Use the C macro instead, which may call C or may instead use an in-line version. I32 sv_true(SV *const sv)','name' => 'sv_true'},'save_aptr' => {'text' => '','name' => 'save_aptr'},'hv_exists' => {'text' => 'Returns a boolean indicating whether the specified hash key exists. The C is the length of the key. bool hv_exists(HV *hv, const char *key, I32 klen)','name' => 'hv_exists'},'my_popen' => {'text' => '','name' => 'my_popen'},'mg_length' => {'text' => 'Report on the SV\'s length. See C. U32 mg_length(SV* sv)','name' => 'mg_length'},'vdeb' => {'text' => '','name' => 'vdeb'},'do_close' => {'text' => '','name' => 'do_close'},'newUNOP' => {'text' => '','name' => 'newUNOP'},'mini_mktime' => {'text' => '','name' => 'mini_mktime'},'HEf_SVKEY' => {'text' => 'This flag, used in the length slot of hash entries and magic structures, specifies the structure contains an C pointer where a C pointer is to be expected. (For information only--not to be used).','name' => 'HEf_SVKEY'},'save_helem_flags' => {'text' => '','name' => 'save_helem_flags'},'newPADOP' => {'text' => '','name' => 'newPADOP'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C in characters. Stops at C (inclusive). If C s> or if the scan would end up past C, croaks. STRLEN utf8_length(const U8* s, const U8 *e)','name' => 'utf8_length'},'is_uni_cntrl' => {'text' => '','name' => 'is_uni_cntrl'},'dowantarray' => {'text' => '','name' => 'dowantarray'},'my_cxt_init' => {'text' => '','name' => 'my_cxt_init'},'SvIOK_only_UV' => {'text' => 'Tells and SV that it is an unsigned integer and disables all other OK bits. void SvIOK_only_UV(SV* sv)','name' => 'SvIOK_only_UV'},'dump_fds' => {'text' => '','name' => 'dump_fds'},'sv_vcatpvfn' => {'text' => '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). Usually used via one of its frontends C and C. void sv_vcatpvfn(SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted)','name' => 'sv_vcatpvfn'},'do_spawn' => {'text' => '','name' => 'do_spawn'},'share_hek' => {'text' => '','name' => 'share_hek'},'sv_pvutf8n' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n(SV *sv, STRLEN *lp)','name' => 'sv_pvutf8n'},'gv_fetchpv' => {'text' => '','name' => 'gv_fetchpv'},'newSV' => {'text' => '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 trailing 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. In 5.9.3, newSV() replaces the older NEWSV() API, and drops the first parameter, I, a debug aid which allowed callers to identify themselves. This aid has been superseded by a new build option, PERL_MEM_LOG (see L). The older API is still there for use in XS modules supporting older perls. SV* newSV(const STRLEN len)','name' => 'newSV'},'sv_2pvutf8' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV, and set *lp to its length. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8(SV *const sv, STRLEN *const lp)','name' => 'sv_2pvutf8'},'dITEMS' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dITEMS;','name' => 'dITEMS'},'save_scalar' => {'text' => '','name' => 'save_scalar'},'newSUB' => {'text' => '','name' => 'newSUB'},'despatch_signals' => {'text' => '','name' => 'despatch_signals'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C. See C and L for other uses. PUTBACK;','name' => 'PUTBACK'},'dAXMARK' => {'text' => 'Sets up the C variable and stack marker variable C. This is usually handled automatically by C by calling C. dAXMARK;','name' => 'dAXMARK'},'sv_2uv_flags' => {'text' => 'Return the unsigned integer value of an SV, doing any necessary string conversion. If flags includes SV_GMAGIC, does an mg_get() first. Normally used via the C and C macros. UV sv_2uv_flags(SV *const sv, const I32 flags)','name' => 'sv_2uv_flags'},'is_uni_punct' => {'text' => '','name' => 'is_uni_punct'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C, C, and L.','name' => 'G_SCALAR'},'SvTAINTED_off' => {'text' => '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)','name' => 'SvTAINTED_off'},'require_pv' => {'text' => 'Tells Perl to C the file named by the string argument. It is analogous to the Perl code C. 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)','name' => 'require_pv'},'strEQ' => {'text' => 'Test two strings to see if they are equal. Returns true or false. bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'sv_upgrade' => {'text' => 'Upgrade an SV to a more complex form. Generally adds a new body type to the SV, then copies across as much information as possible from the old body. You generally want to use the C macro wrapper. See also C. void sv_upgrade(SV *const sv, svtype new_type)','name' => 'sv_upgrade'},'save_hdelete' => {'text' => '','name' => 'save_hdelete'},'safesysmalloc' => {'text' => '','name' => 'safesysmalloc'},'isUPPER' => {'text' => 'Returns a boolean indicating whether the C C is a US-ASCII (Basic Latin) uppercase character. bool isUPPER(char ch)','name' => 'isUPPER'},'save_item' => {'text' => '','name' => 'save_item'},'lex_peek_unichar' => {'text' => 'Looks ahead one (Unicode) character in the text currently being lexed. Returns the codepoint (unsigned integer value) of the next character, or -1 if lexing has reached the end of the input text. To consume the peeked character, use L. If the next character is in (or extends into) the next chunk of input text, the next chunk will be read in. Normally the current chunk will be discarded at the same time, but if I includes C then the current chunk will not be discarded. If the input is being interpreted as UTF-8 and a UTF-8 encoding error is encountered, an exception is generated. NOTE: this function is experimental and may change or be removed without notice. I32 lex_peek_unichar(U32 flags)','name' => 'lex_peek_unichar'},'sv_setsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setsv_mg(SV *const dstr, SV *const sstr)','name' => 'sv_setsv_mg'},'call_list' => {'text' => '','name' => 'call_list'},'croak_nocontext' => {'text' => '','name' => 'croak_nocontext'},'isLOWER' => {'text' => 'Returns a boolean indicating whether the C C is a US-ASCII (Basic Latin) lowercase character. bool isLOWER(char ch)','name' => 'isLOWER'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See C. char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'SvNOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a double. Checks the B setting. Use C instead. U32 SvNOKp(SV* sv)','name' => 'SvNOKp'},'nothreadhook' => {'text' => 'Stub that provides thread hook for perl_destruct when there are no threads. int nothreadhook()','name' => 'nothreadhook'},'utf8_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvchr(const U8 *s, STRLEN *retlen)','name' => 'utf8_to_uvchr'},'bytes_to_utf8' => {'text' => 'Converts a string C of length C from the native encoding into UTF-8. Returns a pointer to the newly-created string, and sets C to reflect the new length. A NUL character will be written after the end of the string. If you want to convert to UTF-8 from encodings other than the native (Latin1 or EBCDIC), see sv_recode_to_utf8(). NOTE: this function is experimental and may change or be removed without notice. U8* bytes_to_utf8(const U8 *s, STRLEN *len)','name' => 'bytes_to_utf8'},'SvIsCOW_shared_hash' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write shared hash key scalar. bool SvIsCOW_shared_hash(SV* sv)','name' => 'SvIsCOW_shared_hash'},'start_subparse' => {'text' => '','name' => 'start_subparse'},'mg_size' => {'text' => '','name' => 'mg_size'},'to_uni_lower_lc' => {'text' => '','name' => 'to_uni_lower_lc'},'sv_catsv_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_catsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_catsv_nomg'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setuv_mg(SV *const sv, const UV u)','name' => 'sv_setuv_mg'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually handled automatically by C. See C.','name' => 'XS_VERSION'},'sys_intern_init' => {'text' => '','name' => 'sys_intern_init'},'fetch_cop_label' => {'text' => '','name' => 'fetch_cop_label'},'sv_setpv' => {'text' => 'Copies a string into an SV. The string must be null-terminated. Does not handle \'set\' magic. See C. void sv_setpv(SV *const sv, const char *const ptr)','name' => 'sv_setpv'},'find_rundefsvoffset' => {'text' => '','name' => 'find_rundefsvoffset'},'hv_placeholders_set' => {'text' => '','name' => 'hv_placeholders_set'},'atfork_lock' => {'text' => '','name' => 'atfork_lock'},'gv_fetchmethod' => {'text' => 'See L. GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'SvGROW' => {'text' => '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)','name' => 'SvGROW'},'dMULTICALL' => {'text' => 'Declare local variables for a multicall. See L. dMULTICALL;','name' => 'dMULTICALL'},'sv_catpv' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpv(SV *const sv, const char* ptr)','name' => 'sv_catpv'},'fprintf_nocontext' => {'text' => '','name' => 'fprintf_nocontext'},'sv_len' => {'text' => 'Returns the length of the string in the SV. Handles magic and type coercion. See also C, which gives raw access to the xpv_cur slot. STRLEN sv_len(SV *const sv)','name' => 'sv_len'},'PerlIO_stderr' => {'text' => '','name' => 'PerlIO_stderr'},'sv_pvutf8' => {'text' => 'Use the C macro instead char* sv_pvutf8(SV *sv)','name' => 'sv_pvutf8'},'SvPVbyte_nolen' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_nolen(SV* sv)','name' => 'SvPVbyte_nolen'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L. LEAVE;','name' => 'LEAVE'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See C.','name' => 'SVt_PVAV'},'mess' => {'text' => '','name' => 'mess'},'hv_delete_ent' => {'text' => '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 *hv, SV *keysv, I32 flags, U32 hash)','name' => 'hv_delete_ent'},'PL_keyword_plugin' => {'text' => 'Function pointer, pointing at a function used to handle extended keywords. The function should be declared as int keyword_plugin_function(pTHX_ char *keyword_ptr, STRLEN keyword_len, OP **op_ptr) The function is called from the tokeniser, whenever a possible keyword is seen. C points at the word in the parser\'s input buffer, and C gives its length; it is not null-terminated. The function is expected to examine the word, and possibly other state such as L<%^H|perlvar/%^H>, to decide whether it wants to handle it as an extended keyword. If it does not, the function should return C, and the normal parser process will continue. If the function wants to handle the keyword, it first must parse anything following the keyword that is part of the syntax introduced by the keyword. See L for details. When a keyword is being handled, the plugin function must build a tree of C structures, representing the code that was parsed. The root of the tree must be stored in C<*op_ptr>. The function then returns a contant indicating the syntactic role of the construct that it has parsed: C if it is a complete statement, or C if it is an expression. Note that a statement construct cannot be used inside an expression (except via C and similar), and an expression is not a complete statement (it requires at least a terminating semicolon). When a keyword is handled, the plugin function may also have (compile-time) side effects. It may modify C<%^H>, define functions, and so on. Typically, if side effects are the main purpose of a handler, it does not wish to generate any ops to be included in the normal compilation. In this case it is still required to supply an op tree, but it suffices to generate a single null op. That\'s how the C<*PL_keyword_plugin> function needs to behave overall. Conventionally, however, one does not completely replace the existing handler function. Instead, take a copy of C before assigning your own function pointer to it. Your handler function should look for keywords that it is interested in and handle those. Where it is not interested, it should call the saved plugin function, passing on the arguments it received. Thus C actually points at a chain of handler functions, all of which have an opportunity to handle keywords, and only the last function in the chain (built into the Perl core) will normally return C. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_keyword_plugin'},'cast_iv' => {'text' => '','name' => 'cast_iv'},'savesvpv' => {'text' => 'A version of C/C which gets the string to duplicate from the passed in SV using C char* savesvpv(SV* sv)','name' => 'savesvpv'},'CLASS' => {'text' => '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','name' => 'CLASS'},'newAVREF' => {'text' => '','name' => 'newAVREF'},'HeKLEN' => {'text' => '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)','name' => 'HeKLEN'},'sv_pvn_force_flags' => {'text' => 'Get a sensible string out of the SV somehow. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You normally want to use the various wrapper macros instead: see C and C char* sv_pvn_force_flags(SV *const sv, STRLEN *const lp, const I32 flags)','name' => 'sv_pvn_force_flags'},'sv_setpvf_mg_nocontext' => {'text' => '','name' => 'sv_setpvf_mg_nocontext'},'mPUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void mPUSHi(IV iv)','name' => 'mPUSHi'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHn(NV nv)','name' => 'PUSHn'},'to_utf8_title' => {'text' => 'Convert the UTF-8 encoded character at p to its titlecase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the titlecase version may be longer than the original character. The first character of the titlecased version is returned (but note, as explained above, that there may be more.) UV to_utf8_title(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_title'},'PerlIO_unread' => {'text' => '','name' => 'PerlIO_unread'},'gv_fullname' => {'text' => '','name' => 'gv_fullname'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. SV PL_sv_yes','name' => 'PL_sv_yes'},'pregfree' => {'text' => '','name' => 'pregfree'},'sv_nosharing' => {'text' => 'Dummy routine which "shares" an SV when there is no sharing module present. Or "locks" it. Or "unlocks" it. In other words, ignores its single SV argument. 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 *sv)','name' => 'sv_nosharing'},'ck_warner' => {'text' => '','name' => 'ck_warner'},'is_ascii_string' => {'text' => 'Returns true if first C bytes of the given string are ASCII (i.e. none of them even raise the question of UTF-8-ness). See also is_utf8_string(), is_utf8_string_loclen(), and is_utf8_string_loc(). bool is_ascii_string(const U8 *s, STRLEN len)','name' => 'is_ascii_string'},'SvUTF8_off' => {'text' => 'Unsets the UTF-8 status of an SV. void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'looks_like_number' => {'text' => 'Test if the content of an SV looks like a number (or is a number). C and C are treated as numbers (so will not issue a non-numeric warning), even if your atof() doesn\'t grok them. I32 looks_like_number(SV *const sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpv_mg(SV *const sv, const char *const ptr)','name' => 'sv_catpv_mg'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'save_vptr' => {'text' => '','name' => 'save_vptr'},'mro_get_private_data' => {'text' => '','name' => 'mro_get_private_data'},'hv_delayfree_ent' => {'text' => '','name' => 'hv_delayfree_ent'},'sv_setpvf' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Does not handle \'set\' magic. See C. void sv_setpvf(SV *const sv, const char *const pat, ...)','name' => 'sv_setpvf'},'save_int' => {'text' => '','name' => 'save_int'},'scan_num' => {'text' => '','name' => 'scan_num'},'call_sv' => {'text' => '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, VOL I32 flags)','name' => 'call_sv'},'SVt_PV' => {'text' => 'Pointer type flag for scalars. See C.','name' => 'SVt_PV'},'strGT' => {'text' => '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)','name' => 'strGT'},'is_uni_alnum' => {'text' => '','name' => 'is_uni_alnum'},'mXPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary and mortalizes the SV. Does not use C. See also C and C. void mXPUSHs(SV* sv)','name' => 'mXPUSHs'},'POPl' => {'text' => 'Pops a long off the stack. long POPl','name' => 'POPl'},'init_i18nl14n' => {'text' => '','name' => 'init_i18nl14n'},'scan_version' => {'text' => 'Returns a pointer to the next character after the parsed version string, as well as upgrading the passed in SV to an RV. Function must be called with an already existing SV like sv = newSV(0); s = scan_version(s, SV *sv, bool qv); Performs some preprocessing to the string to ensure that it has the correct characteristics of a version. Flags the object if it contains an underscore (which denotes this is an alpha version). The boolean qv denotes that the version should be interpreted as if it had multiple decimals, even if it doesn\'t. const char* scan_version(const char *s, SV *rv, bool qv)','name' => 'scan_version'},'hv_common_key_len' => {'text' => '','name' => 'hv_common_key_len'},'vnumify' => {'text' => 'Accepts a version object and returns the normalized floating point representation. Call like: sv = vnumify(rv); NOTE: you can pass either the object directly or the SV contained within the RV. SV* vnumify(SV *vs)','name' => 'vnumify'},'get_cv' => {'text' => 'Uses C to get the length of C, then calls C. NOTE: the perl_ form of this function is deprecated. CV* get_cv(const char* name, I32 flags)','name' => 'get_cv'},'SvIOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains an integer. Checks the B setting. Use C instead. U32 SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the stack. void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'ptr_table_free' => {'text' => '','name' => 'ptr_table_free'},'SvUNLOCK' => {'text' => 'Releases a mutual exclusion lock on sv if a suitable module has been loaded. void SvUNLOCK(SV* sv)','name' => 'SvUNLOCK'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C. int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV (using C). The new SV is marked as mortal. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_mortalcopy(SV *const oldsv)','name' => 'sv_mortalcopy'},'is_utf8_space' => {'text' => '','name' => 'is_utf8_space'},'sv_catpvn_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_catpvn_nomg(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn_nomg'},'newSVpvs_flags' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV* newSVpvs_flags(const char* s, U32 flags)','name' => 'newSVpvs_flags'},'newHVhv' => {'text' => '','name' => 'newHVhv'},'savepvn' => {'text' => 'Perl\'s version of what C would be if it existed. Returns a pointer to a newly allocated string which is a duplicate of the first C bytes from C, plus a trailing NUL byte. The memory allocated for the new string can be freed with the C function. char* savepvn(const char* pv, I32 len)','name' => 'savepvn'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized. This relies on the fact that uninitialized array elements are set to C<&PL_sv_undef>. bool av_exists(AV *av, I32 key)','name' => 'av_exists'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C. STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'gv_fetchmethod_flags' => {'text' => '','name' => 'gv_fetchmethod_flags'},'gv_init' => {'text' => '','name' => 'gv_init'},'sv_bless' => {'text' => '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 *const sv, HV *const stash)','name' => 'sv_bless'},'sv_2io' => {'text' => 'Using various gambits, try to get an IO from an SV: the IO slot if its a GV; or the recursive result if we\'re an RV; or the IO slot of the symbol named after the PV if we\'re a string. IO* sv_2io(SV *const sv)','name' => 'sv_2io'},'save_ary' => {'text' => '','name' => 'save_ary'},'newXS_flags' => {'text' => '','name' => 'newXS_flags'},'SvMAGIC_set' => {'text' => 'Set the value of the MAGIC pointer in sv to val. See C. void SvMAGIC_set(SV* sv, MAGIC* val)','name' => 'SvMAGIC_set'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the C C is a US-ASCII (Basic Latin) alphabetic character. bool isALPHA(char ch)','name' => 'isALPHA'},'newSVhek' => {'text' => 'Creates a new SV from the hash key structure. It will generate scalars that point to the shared string table where possible. Returns a new (undefined) SV if the hek is NULL. SV* newSVhek(const HEK *const hek)','name' => 'newSVhek'},'taint_env' => {'text' => '','name' => 'taint_env'},'Nullhv' => {'text' => 'Null HV pointer. (deprecated - use C<(HV *)NULL> instead)','name' => 'Nullhv'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV. All of the following SvREFCNT_inc* macros are optimized versions of SvREFCNT_inc, and can be replaced with SvREFCNT_inc. SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C. svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'block_gimme' => {'text' => '','name' => 'block_gimme'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'XPUSHmortal' => {'text' => 'Push a new mortal SV onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void XPUSHmortal()','name' => 'XPUSHmortal'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'SvVOK' => {'text' => 'Returns a boolean indicating whether the SV contains a v-string. bool SvVOK(SV* sv)','name' => 'SvVOK'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvf_mg(SV *const sv, const char *const pat, ...)','name' => 'sv_setpvf_mg'},'my_chsize' => {'text' => '','name' => 'my_chsize'},'newLISTOP' => {'text' => '','name' => 'newLISTOP'},'sv_setref_pv' => {'text' => '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 have a reference count of 1, and the RV will be returned. 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 *const rv, const char *const classname, void *const pv)','name' => 'sv_setref_pv'},'fbm_compile' => {'text' => '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)','name' => 'fbm_compile'},'SvNIOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a number, integer or double. Checks the B setting. Use C instead. U32 SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'PERL_SYS_TERM' => {'text' => 'Provides system-specific clean up of the C runtime environment after running Perl interpreters. This should be called only once, after freeing any remaining Perl interpreters. void PERL_SYS_TERM()','name' => 'PERL_SYS_TERM'},'is_uni_alnum_lc' => {'text' => '','name' => 'is_uni_alnum_lc'},'mro_register' => {'text' => '','name' => 'mro_register'},'vnewSVpvf' => {'text' => '','name' => 'vnewSVpvf'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide UTF-8 bytes as a single character. Handles magic and type coercion. STRLEN sv_len_utf8(SV *const sv)','name' => 'sv_len_utf8'},'PerlIO_set_cnt' => {'text' => '','name' => 'PerlIO_set_cnt'},'SvREFCNT_inc_simple_void' => {'text' => 'Same as SvREFCNT_inc_simple, but can only be used if you don\'t need the return value. The macro doesn\'t need to return a meaningful value. void SvREFCNT_inc_simple_void(SV* sv)','name' => 'SvREFCNT_inc_simple_void'},'cx_dup' => {'text' => '','name' => 'cx_dup'},'hv_clear_placeholders' => {'text' => '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 *hv)','name' => 'hv_clear_placeholders'},'dAX' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dAX;','name' => 'dAX'},'SvRV_set' => {'text' => 'Set the value of the RV pointer in sv to val. See C. void SvRV_set(SV* sv, SV* val)','name' => 'SvRV_set'},'grok_number' => {'text' => '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)','name' => 'grok_number'},'csighandler' => {'text' => '','name' => 'csighandler'},'SvIVx' => {'text' => 'Coerces the given SV to an integer and returns it. Guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. IV SvIVx(SV* sv)','name' => 'SvIVx'},'grok_numeric_radix' => {'text' => 'Scan and skip for a numeric decimal separator (radix). bool grok_numeric_radix(const char **sp, const char *send)','name' => 'grok_numeric_radix'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the stack. void XST_mNO(int pos)','name' => 'XST_mNO'},'gp_dup' => {'text' => '','name' => 'gp_dup'},'savepvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. char* savepvs(const char* s)','name' => 'savepvs'},'SvSTASH_set' => {'text' => 'Set the value of the STASH pointer in sv to val. See C. void SvSTASH_set(SV* sv, HV* val)','name' => 'SvSTASH_set'},'ZeroD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * ZeroD(void* dest, int nitems, type)','name' => 'ZeroD'},'sv_collxfrm' => {'text' => 'Add Collate Transform magic to an SV if it doesn\'t already have it. Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the scalar data of the variable, but transformed to such a format that a normal memory comparison can be used to compare the data according to the locale settings. char* sv_collxfrm(SV *const sv, STRLEN *const nxp)','name' => 'sv_collxfrm'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'swash_fetch' => {'text' => '','name' => 'swash_fetch'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'dirp_dup' => {'text' => '','name' => 'dirp_dup'},'is_uni_upper' => {'text' => '','name' => 'is_uni_upper'},'vcmp' => {'text' => 'Version object aware cmp. Both operands must already have been converted into version objects. int vcmp(SV *lhv, SV *rhv)','name' => 'vcmp'},'Zero' => {'text' => '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)','name' => 'Zero'},'gv_stashpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. HV* gv_stashpvs(const char* name, I32 create)','name' => 'gv_stashpvs'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_iv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. IV sv_iv(SV* sv)','name' => 'sv_iv'},'PL_parser-Ebufend' => {'text' => 'Direct pointer to the end of the chunk of text currently being lexed, the end of the lexer buffer. This is equal to Clinestr) + SvCUR(PL_parser-Elinestr)>. A NUL character (zero octet) is always located at the end of the buffer, and does not count as part of the buffer\'s contents. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_parser-Ebufend'},'PerlIO_error' => {'text' => '','name' => 'PerlIO_error'},'is_utf8_graph' => {'text' => '','name' => 'is_utf8_graph'},'pv_escape' => {'text' => 'Escapes at most the first "count" chars of pv and puts the results into dsv such that the size of the escaped string will not exceed "max" chars and will not contain any incomplete escape sequences. If flags contains PERL_PV_ESCAPE_QUOTE then any double quotes in the string will also be escaped. Normally the SV will be cleared before the escaped string is prepared, but when PERL_PV_ESCAPE_NOCLEAR is set this will not occur. If PERL_PV_ESCAPE_UNI is set then the input string is treated as Unicode, if PERL_PV_ESCAPE_UNI_DETECT is set then the input string is scanned using C to determine if it is Unicode. If PERL_PV_ESCAPE_ALL is set then all input chars will be output using C<\\x01F1> style escapes, otherwise only chars above 255 will be escaped using this style, other non printable chars will use octal or common escaped patterns like C<\\n>. If PERL_PV_ESCAPE_NOBACKSLASH then all chars below 255 will be treated as printable and will be output as literals. If PERL_PV_ESCAPE_FIRSTCHAR is set then only the first char of the string will be escaped, regardles of max. If the string is utf8 and the chars value is >255 then it will be returned as a plain hex sequence. Thus the output will either be a single char, an octal escape sequence, a special escape like C<\\n> or a 3 or more digit hex value. If PERL_PV_ESCAPE_RE is set then the escape char used will be a \'%\' and not a \'\\\\\'. This is because regexes very often contain backslashed sequences, whereas \'%\' is not a particularly common character in patterns. Returns a pointer to the escaped text as held by dsv. char* pv_escape(SV *dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags)','name' => 'pv_escape'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'my_exit' => {'text' => '','name' => 'my_exit'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C.','name' => 'SVt_PVCV'},'ss_dup' => {'text' => '','name' => 'ss_dup'},'gv_handler' => {'text' => '','name' => 'gv_handler'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpviv_mg(SV *const sv, const IV iv)','name' => 'sv_setpviv_mg'},'debstack' => {'text' => '','name' => 'debstack'},'sv_2bool' => {'text' => 'This function is only called on magical items, and is only used by sv_true() or its macro equivalent. bool sv_2bool(SV *const sv)','name' => 'sv_2bool'},'lex_grow_linestr' => {'text' => 'Reallocates the lexer buffer (Llinestr>) to accommodate at least I octets (including terminating NUL). Returns a pointer to the reallocated buffer. This is necessary before making any direct modification of the buffer that would increase its length. L provides a more convenient way to insert text into the buffer. Do not use C or C directly on Clinestr>; this function updates all of the lexer\'s variables that point directly into the buffer. NOTE: this function is experimental and may change or be removed without notice. char * lex_grow_linestr(STRLEN len)','name' => 'lex_grow_linestr'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'sv_newmortal' => {'text' => 'Creates a new null SV which is mortal. The reference count of the SV is set to 1. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_newmortal()','name' => 'sv_newmortal'},'is_utf8_cntrl' => {'text' => '','name' => 'is_utf8_cntrl'},'SvPV_set' => {'text' => 'Set the value of the PV pointer in sv to val. See C. void SvPV_set(SV* sv, char* val)','name' => 'SvPV_set'},'SvOOK' => {'text' => 'Returns a U32 indicating whether the pointer to the string buffer is offset. 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 actually C bytes before SvPVX. This offset used to be stored in SvIVX, but is now stored within the spare part of the buffer. U32 SvOOK(SV* sv)','name' => 'SvOOK'},'hv_clear' => {'text' => 'Clears a hash, making it empty. void hv_clear(HV *hv)','name' => 'hv_clear'},'get_hv' => {'text' => 'Returns the HV of the specified Perl hash. C are passed to C. If C is set and the Perl variable does not exist then it will be created. If C is zero 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 flags)','name' => 'get_hv'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES;','name' => 'XSRETURN_YES'},'PoisonNew' => {'text' => 'PoisonWith(0xAB) for catching access to allocated but uninitialized memory. void PoisonNew(void* dest, int nitems, type)','name' => 'PoisonNew'},'safesysrealloc' => {'text' => '','name' => 'safesysrealloc'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'sv_nv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. NV sv_nv(SV* sv)','name' => 'sv_nv'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHu(UV uv)','name' => 'PUSHu'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. (Uses C). SV* newSVsv(SV *const old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C. void hv_magic(HV *hv, GV *gv, int how)','name' => 'hv_magic'},'deb_nocontext' => {'text' => '','name' => 'deb_nocontext'},'new_stackinfo' => {'text' => '','name' => 'new_stackinfo'},'save_aelem' => {'text' => '','name' => 'save_aelem'},'PerlIO_clearerr' => {'text' => '','name' => 'PerlIO_clearerr'},'cx_dump' => {'text' => '','name' => 'cx_dump'},'hv_placeholders_p' => {'text' => '','name' => 'hv_placeholders_p'},'XCPT_TRY_END' => {'text' => 'Ends a try block. See L.','name' => 'XCPT_TRY_END'},'HeKEY' => {'text' => '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)','name' => 'HeKEY'},'SvEND' => {'text' => '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)','name' => 'SvEND'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C, C or C for void, scalar or list context, respectively. U32 GIMME_V','name' => 'GIMME_V'},'save_delete' => {'text' => '','name' => 'save_delete'},'re_compile' => {'text' => '','name' => 're_compile'},'sv_setsv_flags' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. If the C parameter has the C bit set, will C on C if appropriate, else not. If the C parameter has the C bit set then the buffers of temps will not be stolen. and C are implemented in terms of this function. You probably want to use one of the assortment of wrappers, such as C, C, C and C. This is the primary function for copying scalars, and most other copy-ish functions and macros use this underneath. void sv_setsv_flags(SV *dstr, SV *sstr, const I32 flags)','name' => 'sv_setsv_flags'},'newATTRSUB' => {'text' => '','name' => 'newATTRSUB'},'Copy' => {'text' => '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)','name' => 'Copy'},'sv_taint' => {'text' => 'Taint an SV. Use C instead. void sv_taint(SV* sv)','name' => 'sv_taint'},'utf16_to_utf8' => {'text' => '','name' => 'utf16_to_utf8'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains a signed integer. bool SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'deb' => {'text' => '','name' => 'deb'},'PL_parser-Elinestart' => {'text' => 'Points to the start of the current line inside the lexer buffer. This is useful for indicating at which column an error occurred, and not much else. This must be updated by any lexing code that consumes a newline; the function L handles this detail. NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_parser-Elinestart'},'he_dup' => {'text' => '','name' => 'he_dup'},'gv_fullname3' => {'text' => '','name' => 'gv_fullname3'},'mPUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void mPUSHu(UV uv)','name' => 'mPUSHu'},'repeatcpy' => {'text' => '','name' => 'repeatcpy'},'do_spawn_nowait' => {'text' => '','name' => 'do_spawn_nowait'},'sv_setsv_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_setsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_setsv_nomg'},'load_module_nocontext' => {'text' => '','name' => 'load_module_nocontext'},'do_magic_dump' => {'text' => '','name' => 'do_magic_dump'},'re_intuit_string' => {'text' => '','name' => 're_intuit_string'},'XPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHp(char* str, STRLEN len)','name' => 'XPUSHp'},'av_create_and_push' => {'text' => 'Push an SV onto the end of the array, creating the array if necessary. A small internal helper function to remove a commonly duplicated idiom. NOTE: this function is experimental and may change or be removed without notice. void av_create_and_push(AV **const avp, SV *const val)','name' => 'av_create_and_push'},'sv_utf8_encode' => {'text' => 'Converts the PV of an SV to UTF-8, but then turns the C flag off so that it looks like octets again. void sv_utf8_encode(SV *const sv)','name' => 'sv_utf8_encode'},'SvUTF8_on' => {'text' => 'Turn on the UTF-8 status of an SV (the data is not changed, just the flag). Do not use frivolously. void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvn_mg(SV *const sv, const char *const ptr, const STRLEN len)','name' => 'sv_setpvn_mg'},'toLOWER' => {'text' => 'Converts the specified character to lowercase. Characters outside the US-ASCII (Basic Latin) range are viewed as not having any case. char toLOWER(char ch)','name' => 'toLOWER'},'av_iter_p' => {'text' => '','name' => 'av_iter_p'},'prescan_version' => {'text' => 'const char* prescan_version(const char *s, bool strict, const char** errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha)','name' => 'prescan_version'},'PerlIO_write' => {'text' => '','name' => 'PerlIO_write'},'hv_ksplit' => {'text' => '','name' => 'hv_ksplit'},'new_version' => {'text' => 'Returns a new version object based on the passed in SV: SV *sv = new_version(SV *ver); Does not alter the passed in ver SV. See "upg_version" if you want to upgrade the SV. SV* new_version(SV *ver)','name' => 'new_version'},'PerlIO_seek' => {'text' => '','name' => 'PerlIO_seek'},'free_tmps' => {'text' => '','name' => 'free_tmps'},'Nullav' => {'text' => 'Null AV pointer. (deprecated - use C<(AV *)NULL> instead)','name' => 'Nullav'},'sv_pvbyten' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten(SV *sv, STRLEN *lp)','name' => 'sv_pvbyten'},'sv_copypv' => {'text' => 'Copies a stringified representation of the source SV into the destination SV. Automatically performs any necessary mg_get and coercion of numeric values into strings. Guaranteed to preserve UTF8 flag even from overloaded objects. Similar in nature to sv_2pv[_flags] but operates directly on an SV instead of just the string. Mostly uses sv_2pv_flags to do its work, except when that would lose the UTF-8\'ness of the PV. void sv_copypv(SV *const dsv, SV *const ssv)','name' => 'sv_copypv'},'sv_pv' => {'text' => 'Use the C macro instead char* sv_pv(SV *sv)','name' => 'sv_pv'},'rsignal' => {'text' => '','name' => 'rsignal'},'is_uni_xdigit' => {'text' => '','name' => 'is_uni_xdigit'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setnv_mg(SV *const sv, const NV num)','name' => 'sv_setnv_mg'},'pv_pretty' => {'text' => 'Converts a string into something presentable, handling escaping via pv_escape() and supporting quoting and ellipses. If the PERL_PV_PRETTY_QUOTE flag is set then the result will be double quoted with any double quotes in the string escaped. Otherwise if the PERL_PV_PRETTY_LTGT flag is set then the result be wrapped in angle brackets. If the PERL_PV_PRETTY_ELLIPSES flag is set and not all characters in string were output then an ellipsis C<...> will be appended to the string. Note that this happens AFTER it has been quoted. If start_color is non-null then it will be inserted after the opening quote (if there is one) but before the escaped text. If end_color is non-null then it will be inserted after the escaped text but before any quotes or ellipses. Returns a pointer to the prettified text as held by dsv. char* pv_pretty(SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags)','name' => 'pv_pretty'},'perl_alloc_using' => {'text' => '','name' => 'perl_alloc_using'},'utf8_to_bytes' => {'text' => 'Converts a string C of length C from UTF-8 into native byte encoding. Unlike C, this over-writes the original string, and updates len to contain the new length. Returns zero on failure, setting C to -1. If you need a copy of the string, see C. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'re_dup_guts' => {'text' => '','name' => 're_dup_guts'},'si_dup' => {'text' => '','name' => 'si_dup'},'uvuni_to_utf8_flags' => {'text' => 'Adds the UTF-8 representation of the Unicode codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvuni_to_utf8_flags(d, uv, flags); or, in most cases, d = uvuni_to_utf8(d, uv); (which is equivalent to) d = uvuni_to_utf8_flags(d, uv, 0); is the recommended Unicode-aware way of saying *(d++) = uv; U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)','name' => 'uvuni_to_utf8_flags'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See L.','name' => 'G_DISCARD'},'newGVREF' => {'text' => '','name' => 'newGVREF'},'XST_mNV' => {'text' => '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)','name' => 'XST_mNV'},'UNDERBAR' => {'text' => 'The SV* corresponding to the $_ variable. Works even if there is a lexical $_ in scope.','name' => 'UNDERBAR'},'newSVOP' => {'text' => '','name' => 'newSVOP'},'pad_sv' => {'text' => '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)','name' => 'pad_sv'},'amagic_call' => {'text' => '','name' => 'amagic_call'},'op_free' => {'text' => '','name' => 'op_free'},'SvPVutf8_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_force(SV* sv, STRLEN len)','name' => 'SvPVutf8_force'},'gv_AVadd' => {'text' => '','name' => 'gv_AVadd'},'pop_scope' => {'text' => '','name' => 'pop_scope'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C.','name' => 'SVt_NV'},'my_popen_list' => {'text' => '','name' => 'my_popen_list'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and L. void PUSHMARK(SP)','name' => 'PUSHMARK'},'sv_2uv' => {'text' => '','name' => 'sv_2uv'},'taint_proper' => {'text' => '','name' => 'taint_proper'},'save_generic_pvref' => {'text' => '','name' => 'save_generic_pvref'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. SV* ST(int ix)','name' => 'ST'},'call_pv' => {'text' => '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)','name' => 'call_pv'},'gv_fetchmeth_autoload' => {'text' => '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 C. 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)','name' => 'gv_fetchmeth_autoload'},'save_mortalizesv' => {'text' => '','name' => 'save_mortalizesv'},'sv_pos_b2u' => {'text' => 'Converts the value pointed to by offsetp from a count of bytes from the start of the string, to a count of the equivalent number of UTF-8 chars. Handles magic and type coercion. void sv_pos_b2u(SV *const sv, I32 *const offsetp)','name' => 'sv_pos_b2u'},'sv_utf8_upgrade_flags_grow' => {'text' => '','name' => 'sv_utf8_upgrade_flags_grow'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C.','name' => 'SVt_IV'},'SvIsCOW' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write. (either shared hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for COW) bool SvIsCOW(SV* sv)','name' => 'SvIsCOW'},'reentrant_size' => {'text' => '','name' => 'reentrant_size'},'apply_attrs_string' => {'text' => '','name' => 'apply_attrs_string'},'printf_nocontext' => {'text' => '','name' => 'printf_nocontext'},'save_freesv' => {'text' => '','name' => 'save_freesv'},'sv_catsv' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catsv(SV *dstr, SV *sstr)','name' => 'sv_catsv'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'ax' => {'text' => 'Variable which is setup by C to indicate the stack base offset, used by the C, C and C macros. The C macro must be called prior to setup the C variable. I32 ax','name' => 'ax'},'regexec_flags' => {'text' => '','name' => 'regexec_flags'},'to_utf8_upper' => {'text' => 'Convert the UTF-8 encoded character at p to its uppercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the uppercase version may be longer than the original character. The first character of the uppercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_upper(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_upper'},'SvPVutf8x_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x_force(SV* sv, STRLEN len)','name' => 'SvPVutf8x_force'},'warner_nocontext' => {'text' => '','name' => 'warner_nocontext'},'my_htonl' => {'text' => '','name' => 'my_htonl'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHi(IV iv)','name' => 'PUSHi'},'is_uni_digit' => {'text' => '','name' => 'is_uni_digit'},'SvLEN_set' => {'text' => 'Set the actual length of the string which is in the SV. See C. void SvLEN_set(SV* sv, STRLEN len)','name' => 'SvLEN_set'},'to_utf8_lower' => {'text' => 'Convert the UTF-8 encoded character at p to its lowercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the lowercase version may be longer than the original character. The first character of the lowercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_lower(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_lower'},'new_numeric' => {'text' => '','name' => 'new_numeric'},'newSVpvf' => {'text' => 'Creates a new SV and initializes it with the string formatted like C. SV* newSVpvf(const char *const pat, ...)','name' => 'newSVpvf'},'doing_taint' => {'text' => '','name' => 'doing_taint'},'save_I8' => {'text' => '','name' => 'save_I8'},'Newxc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. See also C. void Newxc(void* ptr, int nitems, type, cast)','name' => 'Newxc'},'SvIVX' => {'text' => 'Returns the raw value in the SV\'s IV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. IV SvIVX(SV* sv)','name' => 'SvIVX'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L. int perl_destruct(PerlInterpreter *my_perl)','name' => 'perl_destruct'},'is_utf8_idfirst' => {'text' => '','name' => 'is_utf8_idfirst'},'sv_vsetpvf' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Does not handle \'set\' magic. See C. Usually used via its frontend C. void sv_vsetpvf(SV *const sv, const char *const pat, va_list *const args)','name' => 'sv_vsetpvf'},'custom_op_name' => {'text' => '','name' => 'custom_op_name'},'any_dup' => {'text' => '','name' => 'any_dup'},'XCPT_CATCH' => {'text' => 'Introduces a catch block. See L.','name' => 'XCPT_CATCH'},'my_dirfd' => {'text' => '','name' => 'my_dirfd'},'regclass_swash' => {'text' => '','name' => 'regclass_swash'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the stack. void XST_mYES(int pos)','name' => 'XST_mYES'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. You probably want to use one of the assortment of wrappers, such as C, C, C and C. void sv_setsv(SV *dstr, SV *sstr)','name' => 'sv_setsv'},'PerlIO_stdin' => {'text' => '','name' => 'PerlIO_stdin'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an XSUB\'s aliases was used to invoke it. See L. I32 ix','name' => 'ix'},'XSRETURN_UV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_UV(IV uv)','name' => 'XSRETURN_UV'},'SvREFCNT_inc_simple' => {'text' => 'Same as SvREFCNT_inc, but can only be used with expressions without side effects. Since we don\'t have to store a temporary value, it\'s faster. SV* SvREFCNT_inc_simple(SV* sv)','name' => 'SvREFCNT_inc_simple'},'my_lstat' => {'text' => '','name' => 'my_lstat'},'my_atof' => {'text' => '','name' => 'my_atof'},'savestack_grow_cnt' => {'text' => '','name' => 'savestack_grow_cnt'},'vverify' => {'text' => 'Validates that the SV contains a valid version object. bool vverify(SV *vobj); Note that it only confirms the bare minimum structure (so as not to get confused by derived classes which may contain additional hash entries): bool vverify(SV *vs)','name' => 'vverify'},'dXSI32' => {'text' => 'Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. dXSI32;','name' => 'dXSI32'},'dXCPT' => {'text' => 'Set up necessary local variables for exception handling. See L. dXCPT;','name' => 'dXCPT'},'sv_tainted' => {'text' => 'Test an SV for taintedness. Use C instead. bool sv_tainted(SV *const sv)','name' => 'sv_tainted'},'mro_set_private_data' => {'text' => '','name' => 'mro_set_private_data'},'do_gv_dump' => {'text' => '','name' => 'do_gv_dump'},'reg_named_buff_nextkey' => {'text' => '','name' => 'reg_named_buff_nextkey'},'cv_const_sv' => {'text' => 'If C is a constant sub eligible for inlining. returns the constant value returned by the sub. Otherwise, returns NULL. Constant subs can be created with C or as described in L. SV* cv_const_sv(const CV *const cv)','name' => 'cv_const_sv'},'newSVnv' => {'text' => 'Creates a new SV and copies a floating point value into it. The reference count for the SV is set to 1. SV* newSVnv(const NV n)','name' => 'newSVnv'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry. SV* HeVAL(HE* he)','name' => 'HeVAL'},'HePV' => {'text' => '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. See also C. If you are using C to get values to pass to C to create a new SV, you should consider using C as it is more efficient. char* HePV(HE* he, STRLEN len)','name' => 'HePV'},'hv_free_ent' => {'text' => '','name' => 'hv_free_ent'},'PL_parser' => {'text' => 'Pointer to a structure encapsulating the state of the parsing operation currently in progress. The pointer can be locally changed to perform a nested parse without interfering with the state of an outer parse. Individual members of C have their own documentation.','name' => 'PL_parser'},'SvGETMAGIC' => {'text' => 'Invokes C on an SV if it has \'get\' magic. This macro evaluates its argument more than once. void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'pv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the string spv, length len, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument can have UNI_DISPLAY_ISPRINT set to display isPRINT()able characters as themselves, UNI_DISPLAY_BACKSLASH to display the \\\\[nrfta\\\\] as the backslashed versions (like \'\\n\') (UNI_DISPLAY_BACKSLASH is preferred over UNI_DISPLAY_ISPRINT for \\\\). UNI_DISPLAY_QQ (and its alias UNI_DISPLAY_REGEX) have both UNI_DISPLAY_BACKSLASH and UNI_DISPLAY_ISPRINT turned on. The pointer to the PV of the dsv is returned. char* pv_uni_display(SV *dsv, const U8 *spv, STRLEN len, STRLEN pvlim, UV flags)','name' => 'pv_uni_display'},'init_stacks' => {'text' => '','name' => 'init_stacks'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_inc(SV *const sv)','name' => 'sv_inc'},'SvPVbytex_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex_force(SV* sv, STRLEN len)','name' => 'SvPVbytex_force'},'hv_delete' => {'text' => '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 *hv, const char *key, I32 klen, I32 flags)','name' => 'hv_delete'},'POP_MULTICALL' => {'text' => 'Closing bracket for a lightweight callback. See L. POP_MULTICALL;','name' => 'POP_MULTICALL'},'sv_cat_decode' => {'text' => 'The encoding is assumed to be an Encode object, the PV of the ssv is assumed to be octets in that encoding and decoding the input starts from the position which (PV + *offset) pointed to. The dsv will be concatenated the decoded UTF-8 string from ssv. Decoding will terminate when the string tstr appears in decoding output or the input ends on the PV of the ssv. The value which the offset points will be modified to the last input position on the ssv. Returns TRUE if the terminator was found, else returns FALSE. bool sv_cat_decode(SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen)','name' => 'sv_cat_decode'},'sv_setiv' => {'text' => 'Copies an integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setiv(SV *const sv, const IV num)','name' => 'sv_setiv'},'SvIV_set' => {'text' => 'Set the value of the IV pointer in sv to val. It is possible to perform the same function of this macro with an lvalue assignment to C. With future Perls, however, it will be more efficient to use C instead of the lvalue assignment to C. void SvIV_set(SV* sv, IV val)','name' => 'SvIV_set'},'gv_efullname' => {'text' => '','name' => 'gv_efullname'},'sv_report_used' => {'text' => 'Dump the contents of all SVs not yet freed. (Debugging aid). void sv_report_used()','name' => 'sv_report_used'},'save_sptr' => {'text' => '','name' => 'save_sptr'},'SvNVX' => {'text' => 'Returns the raw value in the SV\'s NV slot, without checks or conversions. Only use when you are sure SvNOK is true. See also C. NV SvNVX(SV* sv)','name' => 'SvNVX'},'do_open' => {'text' => '','name' => 'do_open'},'regnext' => {'text' => '','name' => 'regnext'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. U32 HeHASH(HE* he)','name' => 'HeHASH'},'SvIOK' => {'text' => 'Returns a U32 value indicating whether the SV contains an integer. U32 SvIOK(SV* sv)','name' => 'SvIOK'},'newANONHASH' => {'text' => '','name' => 'newANONHASH'},'SvPV_force' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'HeUTF8' => {'text' => 'Returns whether the C value returned by C is encoded in UTF-8, doing any necessary dereferencing of possibly C keys. The value returned will be 0 or non-0, not necessarily 1 (or even a value with any low bits set), so B blindly assign this to a C variable, as C may be a typedef for C. char* HeUTF8(HE* he)','name' => 'HeUTF8'},'newRANGE' => {'text' => '','name' => 'newRANGE'},'grok_hex' => {'text' => 'converts a string representing a hex number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0x" or "x" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the hex number may use \'_\' characters to separate digits. UV grok_hex(const char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_hex'},'newRV' => {'text' => '','name' => 'newRV'},'SvLOCK' => {'text' => 'Arranges for a mutual exclusion lock to be obtained on sv if a suitable module has been loaded. void SvLOCK(SV* sv)','name' => 'SvLOCK'},'gv_fetchfile' => {'text' => '','name' => 'gv_fetchfile'},'sv_vsetpvfn' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Usually used via one of its frontends C and C. void sv_vsetpvfn(SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted)','name' => 'sv_vsetpvfn'},'PerlIO_get_cnt' => {'text' => '','name' => 'PerlIO_get_cnt'},'PerlIO_setlinebuf' => {'text' => '','name' => 'PerlIO_setlinebuf'},'utf16_to_utf8_reversed' => {'text' => '','name' => 'utf16_to_utf8_reversed'},'cast_ulong' => {'text' => '','name' => 'cast_ulong'},'to_utf8_case' => {'text' => 'The "p" contains the pointer to the UTF-8 string encoding the character that is being converted. The "ustrp" is a pointer to the character buffer to put the conversion result to. The "lenp" is a pointer to the length of the result. The "swashp" is a pointer to the swash to use. Both the special and normal mappings are stored lib/unicore/To/Foo.pl, and loaded by SWASHNEW, using lib/utf8_heavy.pl. The special (usually, but not always, a multicharacter mapping), is tried first. The "special" is a string like "utf8::ToSpecLower", which means the hash %utf8::ToSpecLower. The access to the hash is through Perl_to_utf8_case(). The "normal" is a string like "ToLower" which means the swash %utf8::ToLower. UV to_utf8_case(const U8 *p, U8* ustrp, STRLEN *lenp, SV **swashp, const char *normal, const char *special)','name' => 'to_utf8_case'},'set_numeric_local' => {'text' => '','name' => 'set_numeric_local'},'is_utf8_print' => {'text' => '','name' => 'is_utf8_print'},'calloc' => {'text' => '','name' => 'calloc'},'POPpbytex' => {'text' => 'Pops a string off the stack which must consist of bytes i.e. characters < 256. char* POPpbytex','name' => 'POPpbytex'},'newPMOP' => {'text' => '','name' => 'newPMOP'},'SvSetMagicSV' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV(SV* dsb, SV* ssv)','name' => 'SvSetMagicSV'},'Move' => {'text' => '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)','name' => 'Move'},'sv_catpvn_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. void sv_catpvn_flags(SV *const dstr, const char *sstr, const STRLEN len, const I32 flags)','name' => 'sv_catpvn_flags'},'set_context' => {'text' => '','name' => 'set_context'},'PerlIO_flush' => {'text' => '','name' => 'PerlIO_flush'},'sv_2iv_flags' => {'text' => 'Return the integer value of an SV, doing any necessary string conversion. If flags includes SV_GMAGIC, does an mg_get() first. Normally used via the C and C macros. IV sv_2iv_flags(SV *const sv, const I32 flags)','name' => 'sv_2iv_flags'},'gv_efullname3' => {'text' => '','name' => 'gv_efullname3'},'runops_standard' => {'text' => '','name' => 'runops_standard'},'isALNUM' => {'text' => 'Returns a boolean indicating whether the C C is a US-ASCII (Basic Latin) alphanumeric character (including underscore) or digit. bool isALNUM(char ch)','name' => 'isALNUM'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs. I needs to be static storage, as it is used directly as CvFILE(), without a copy being made.','name' => 'newXS'},'XCPT_RETHROW' => {'text' => 'Rethrows a previously caught exception. See L. XCPT_RETHROW;','name' => 'XCPT_RETHROW'},'mg_dup' => {'text' => '','name' => 'mg_dup'},'PUSHmortal' => {'text' => 'Push a new mortal SV onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void PUSHmortal()','name' => 'PUSHmortal'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'sv_dump' => {'text' => '','name' => 'sv_dump'},'newSVpvn_flags' => {'text' => '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. If the C argument is NULL the new SV will be undefined. Currently the only flag bits accepted are C and C. If C is set, then C is called on the result before returning. If C is set, C is considered to be in UTF-8 and the C flag will be set on the new SV. C is a convenience wrapper for this function, defined as #define newSVpvn_utf8(s, len, u) \\ newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0) SV* newSVpvn_flags(const char *const s, const STRLEN len, const U32 flags)','name' => 'newSVpvn_flags'},'strLE' => {'text' => '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)','name' => 'strLE'},'SvOK' => {'text' => 'Returns a U32 value indicating whether the value is defined. This is only meaningful for scalars. U32 SvOK(SV* sv)','name' => 'SvOK'},'sv_compile_2op' => {'text' => '','name' => 'sv_compile_2op'},'sv_setref_nv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_nv(SV *const rv, const char *const classname, const NV nv)','name' => 'sv_setref_nv'},'eval_pv' => {'text' => '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)','name' => 'eval_pv'},'lex_stuff_pvn' => {'text' => 'Insert characters into the lexer buffer (Llinestr>), immediately after the current lexing point (Lbufptr>), reallocating the buffer if necessary. This means that lexing code that runs later will see the characters as if they had appeared in the input. It is not recommended to do this as part of normal parsing, and most uses of this facility run the risk of the inserted characters being interpreted in an unintended manner. The string to be inserted is represented by I octets starting at I. These octets are interpreted as either UTF-8 or Latin-1, according to whether the C flag is set in I. The characters are recoded for the lexer buffer, according to how the buffer is currently being interpreted (L). If a string to be interpreted is available as a Perl scalar, the L function is more convenient. NOTE: this function is experimental and may change or be removed without notice. void lex_stuff_pvn(char *pv, STRLEN len, U32 flags)','name' => 'lex_stuff_pvn'},'sv_usepvn_flags' => {'text' => '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. By default this function will realloc (i.e. move) the memory pointed to by C, so that pointer should not be freed or used by the programmer after giving it to sv_usepvn, and neither should any pointers from "behind" that pointer (e.g. ptr + 1) be used. If C & SV_SMAGIC is true, will call SvSETMAGIC. If C & SV_HAS_TRAILING_NUL is true, then C must be NUL, and the realloc will be skipped. (i.e. the buffer is actually at least 1 byte longer than C, and already meets the requirements for storing in C) void sv_usepvn_flags(SV *const sv, char* ptr, const STRLEN len, const U32 flags)','name' => 'sv_usepvn_flags'},'hv_assert' => {'text' => 'Check that a hash is in an internally consistent state. void hv_assert(HV *hv)','name' => 'hv_assert'},'my_vsnprintf' => {'text' => 'The C library C if available and standards-compliant. However, if if the C is not available, will unfortunately use the unsafe C which can overrun the buffer (there is an overrun check, but that may be too late). Consider using C instead, or getting C. int my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap)','name' => 'my_vsnprintf'},'sv_free' => {'text' => 'Decrement an SV\'s reference count, and if it drops to zero, call C to invoke destructors and free up any memory used by the body; finally, deallocate the SV\'s head itself. Normally called via a wrapper macro C. void sv_free(SV *const sv)','name' => 'sv_free'},'die_nocontext' => {'text' => '','name' => 'die_nocontext'},'hv_eiter_p' => {'text' => '','name' => 'hv_eiter_p'},'SvPVbyte_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_force(SV* sv, STRLEN len)','name' => 'SvPVbyte_force'},'is_utf8_ascii' => {'text' => '','name' => 'is_utf8_ascii'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_pop(AV *av)','name' => 'av_pop'},'reg_named_buff_exists' => {'text' => '','name' => 'reg_named_buff_exists'},'ckwarn_d' => {'text' => '','name' => 'ckwarn_d'},'save_bool' => {'text' => '','name' => 'save_bool'},'croak' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Normally call this function the same way you call the C C function. Calling C returns control directly to Perl, sidestepping the normal C order of execution. See C. If you want to throw an exception object, assign the object to C<$@> and then pass C to croak(): errsv = get_sv("@", GV_ADD); sv_setsv(errsv, exception_object); croak(NULL); void croak(const char* pat, ...)','name' => 'croak'},'save_freepv' => {'text' => '','name' => 'save_freepv'},'THIS' => {'text' => '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','name' => 'THIS'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually handled by C. void XSRETURN(int nitems)','name' => 'XSRETURN'},'dump_indent' => {'text' => '','name' => 'dump_indent'},'screaminstr' => {'text' => '','name' => 'screaminstr'},'lex_read_unichar' => {'text' => 'Reads the next (Unicode) character in the text currently being lexed. Returns the codepoint (unsigned integer value) of the character read, and moves Lbufptr> past the character, or returns -1 if lexing has reached the end of the input text. To non-destructively examine the next character, use L instead. If the next character is in (or extends into) the next chunk of input text, the next chunk will be read in. Normally the current chunk will be discarded at the same time, but if I includes C then the current chunk will not be discarded. If the input is being interpreted as UTF-8 and a UTF-8 encoding error is encountered, an exception is generated. NOTE: this function is experimental and may change or be removed without notice. I32 lex_read_unichar(U32 flags)','name' => 'lex_read_unichar'},'sv_2pv_nolen' => {'text' => 'Like C, but doesn\'t return the length too. You should usually use the macro wrapper C instead. char* sv_2pv_nolen(SV* sv)','name' => 'sv_2pv_nolen'},'get_av' => {'text' => 'Returns the AV of the specified Perl array. C are passed to C. If C is set and the Perl variable does not exist then it will be created. If C is zero 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 flags)','name' => 'get_av'},'reginitcolors' => {'text' => '','name' => 'reginitcolors'},'PoisonFree' => {'text' => 'PoisonWith(0xEF) for catching access to freed memory. void PoisonFree(void* dest, int nitems, type)','name' => 'PoisonFree'},'gv_SVadd' => {'text' => '','name' => 'gv_SVadd'},'hv_common' => {'text' => '','name' => 'hv_common'},'newSVREF' => {'text' => '','name' => 'newSVREF'},'toUPPER' => {'text' => 'Converts the specified character to uppercase. Characters outside the US-ASCII (Basic Latin) range are viewed as not having any case. char toUPPER(char ch)','name' => 'toUPPER'},'is_lvalue_sub' => {'text' => '','name' => 'is_lvalue_sub'},'is_utf8_string_loc' => {'text' => 'Like is_utf8_string() but stores the location of the failure (in the case of "utf8ness failure") or the location s+len (in the case of "utf8ness success") in the C. See also is_utf8_string_loclen() and is_utf8_string(). bool is_utf8_string_loc(const U8 *s, STRLEN len, const U8 **p)','name' => 'is_utf8_string_loc'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally appending to the currently-stored string. char* sv_gets(SV *const sv, PerlIO *const fp, I32 append)','name' => 'sv_gets'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'dUNDERBAR' => {'text' => 'Sets up the C variable for an XSUB that wishes to use C. dUNDERBAR;','name' => 'dUNDERBAR'},'sv_uv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. UV sv_uv(SV* sv)','name' => 'sv_uv'},'ptr_table_split' => {'text' => '','name' => 'ptr_table_split'},'Nullch' => {'text' => 'Null character pointer. (No longer available when C is defined.)','name' => 'Nullch'},'get_context' => {'text' => '','name' => 'get_context'},'vcroak' => {'text' => '','name' => 'vcroak'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the supplied vtable and returns a pointer to the magic added. Note that C will allow things that C will not. In particular, you can add magic to SvREADONLY SVs, and add more than one instance of the same \'how\'. If C is greater than zero then a C I of C is stored, if C is zero then C is stored as-is and - as another special case - if C<(name && namlen == HEf_SVKEY)> then C is assumed to contain an C and is stored as-is with its REFCNT incremented. (This is now used as a subroutine by C.) MAGIC * sv_magicext(SV *const sv, SV *const obj, const int how, const MGVTBL *const vtbl, const char *const name, const I32 namlen)','name' => 'sv_magicext'},'to_uni_title' => {'text' => '','name' => 'to_uni_title'},'gv_fullname4' => {'text' => '','name' => 'gv_fullname4'},'is_uni_idfirst' => {'text' => '','name' => 'is_uni_idfirst'},'av_push' => {'text' => 'Pushes an SV onto the end of the array. The array will grow automatically to accommodate the addition. Like C, this takes ownership of one reference count. void av_push(AV *av, SV *val)','name' => 'av_push'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV *const sv)','name' => 'newRV_noinc'},'unsharepvn' => {'text' => '','name' => 'unsharepvn'},'my_memcmp' => {'text' => '','name' => 'my_memcmp'},'mfree' => {'text' => '','name' => 'mfree'},'newSLICEOP' => {'text' => '','name' => 'newSLICEOP'},'save_re_context' => {'text' => '','name' => 'save_re_context'},'hv_iterinit' => {'text' => '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 *hv)','name' => 'hv_iterinit'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.012000', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference.pm0000644000175000017500000001325712264521643017525 0ustar tseetseepackage Perl::APIReference; use 5.006; use strict; use warnings; use Carp qw/croak/; use version; our $VERSION = '0.16'; use Class::XSAccessor getters => { 'index' => 'index', 'perl_version' => 'perl_version', }; sub _par_loader_hint { require Perl::APIReference::Generator; require Perl::APIReference::V5_018_002; } our %Perls = ( 5.018002 => 'V5_018_002', 5.018001 => 'V5_018_001', 5.018000 => 'V5_018_000', 5.016003 => 'V5_016_003', 5.016002 => 'V5_016_002', 5.016001 => 'V5_016_001', 5.016 => 'V5_016_000', 5.014004 => 'V5_014_004', 5.014003 => 'V5_014_003', 5.014002 => 'V5_014_002', 5.014001 => 'V5_014_001', 5.014 => 'V5_014_000', 5.012004 => 'V5_012_004', 5.012003 => 'V5_012_003', 5.012002 => 'V5_012_002', 5.012001 => 'V5_012_001', 5.012 => 'V5_012_000', 5.01 => 'V5_010_000', 5.010001 => 'V5_010_001', 5.008009 => 'V5_008_009', 5.008008 => 'V5_008_008', 5.008007 => 'V5_008_007', 5.008006 => 'V5_008_006', 5.008005 => 'V5_008_005', 5.008004 => 'V5_008_004', 5.008003 => 'V5_008_003', 5.008002 => 'V5_008_002', 5.008001 => 'V5_008_001', 5.008 => 'V5_008_000', 5.006002 => 'V5_006_002', 5.006001 => 'V5_006_001', 5.006 => 'V5_006_000', ); our $NewestAPI = '5.018002'; our $NewestStableAPI = '5.018002'; $Perls{'5.018000'} = $Perls{5.018}; $Perls{'5.016000'} = $Perls{5.016}; $Perls{'5.014000'} = $Perls{5.014}; $Perls{'5.012000'} = $Perls{5.012}; $Perls{'5.010000'} = $Perls{5.01}; $Perls{'5.010'} = $Perls{5.01}; $Perls{'5.008000'} = $Perls{5.008}; $Perls{'5.008000'} = $Perls{5.006}; #$Perls{'5.000'} = $Perls{5}; sub _get_class_name { my $class_or_self = shift; my $version = shift; return exists $Perls{$version} ? "Perl::APIReference::" . $Perls{$version} : undef; } sub new { my $class = shift; my %args = @_; my $perl_version = $args{perl_version}; croak("Need perl_version") if not defined $perl_version; $perl_version = $NewestStableAPI if lc($perl_version) eq "newest"; $perl_version = $NewestAPI if lc($perl_version) eq "newest_devel"; $perl_version = version->new($perl_version)->numify(); croak("Bad perl version '$perl_version'") if not exists $Perls{$perl_version}; my $classname = __PACKAGE__->_get_class_name($perl_version); eval "require $classname;"; croak("Bad perl version ($@)") if $@; return $classname->new(perl_version => $perl_version); } sub as_yaml_calltips { my $self = shift; my $index = $self->index(); my %toyaml; foreach my $entry (keys %$index) { my $yentry = { cmd => '', 'exp' => $index->{$entry}{text}, }; $toyaml{$entry} = $yentry; } require YAML::Tiny; return YAML::Tiny::Dump(\%toyaml); } # only for ::Generator sub _new_from_parse { my $class = shift; return bless {@_} => $class; } # only for ::Generator sub _dump_as_class { my $self = shift; my $version = $self->perl_version; my $classname = $self->_get_class_name($version); if (not defined $classname) { die "Can't determine class name for Perl version '$version'." . " Do you need to add it to the list of supported versions first?"; } my $file_name = $classname; $file_name =~ s/^.*::([^:]+)$/$1.pm/; require Data::Dumper; local $Data::Dumper::Indent = 0; my $dumper = Data::Dumper->new([$self->{'index'}]); my $dump = $dumper->Dump(); open my $fh, '>', $file_name or die $!; print $fh < \$VAR1, perl_version => '$version', } => \$class); return \$self; } 1; HERE } 1; __END__ =head1 NAME Perl::APIReference - Programmatically query the perlapi =head1 SYNOPSIS use Perl::APIReference; my $api = Perl::APIReference->new(perl_version => '5.18.2'); my $api_index_hash = $api->index; =head1 DESCRIPTION This module allows accessing the perlapi documentation for multiple releases of perl as an index (a hash). Currently, the stable releases perl 5.18.0-2, 5.16.0-3, 5.14.0-3, 5.12.0-4, 5.10.0-1, 5.8.0-9, and 5.6.0-2 are supported. To add support for another release, simply send me the release's F via email or via an RT ticket and I'll add it in the next release. API docs for development releases may be dropped from the distribution at any time. The general policy on this is to try and ship the APIs for the newest development release. =head1 METHODS =head2 new Constructor. Takes the C argument which specifies the version of the perlapi that you want to use. The version has to be in the form C<5.008009> to indicate perl 5.8.9. For the initial releases in a new family (5.10.0, etc), the shortened forms C<5.010> and C<5.01> can be used. Special C settings are C and C which correspond to the newest available stable and experimental perl API versions. =head2 index Returns the index of perlapi entries and their documentation as a hash reference. =head2 perl_version Returns the API object's perl version. Possibly normalized to the floating point form (Cnew($version)-Enumify()>). =head2 as_yaml_calltips Dumps the index as a YAML file in the format used by the Padre calltips. Requires L. =head1 SEE ALSO L L L =head1 AUTHOR Steffen Mueller, Esmueller@cpan.orgE =head1 COPYRIGHT AND LICENSE Copyright (C) 2009, 2010, 2011, 2012, 2013, 2014 by Steffen Mueller This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself, either Perl version 5.6.0 or, at your option, any later version of Perl 5 you may have available. =cut Perl-APIReference-0.16/MANIFEST0000644000175000017500000000402712264521751014413 0ustar tseetsee.gitignore author_scripts/generate.pl Changes data/perlapi.5.10.0.pod.xz data/perlapi.5.10.1.pod.xz data/perlapi.5.12.0.pod.xz data/perlapi.5.14.0.pod.xz data/perlapi.5.16.0.pod.xz data/perlapi.5.16.2.pod.xz data/perlapi.5.18.0.pod.xz data/perlapi.5.6.0.pod.xz data/perlapi.5.6.1.pod.xz data/perlapi.5.6.2.pod.xz data/perlapi.5.8.0.pod.xz data/perlapi.5.8.1.pod.xz data/perlapi.5.8.2.pod.xz data/perlapi.5.8.3.pod.xz data/perlapi.5.8.4.pod.xz data/perlapi.5.8.5.pod.xz data/perlapi.5.8.6.pod.xz data/perlapi.5.8.7.pod.xz data/perlapi.5.8.8.pod.xz data/perlapi.5.8.9.pod.xz lib/Perl/APIReference.pm lib/Perl/APIReference/Generator.pm lib/Perl/APIReference/V5_006_000.pm lib/Perl/APIReference/V5_006_001.pm lib/Perl/APIReference/V5_006_002.pm lib/Perl/APIReference/V5_008_000.pm lib/Perl/APIReference/V5_008_001.pm lib/Perl/APIReference/V5_008_002.pm lib/Perl/APIReference/V5_008_003.pm lib/Perl/APIReference/V5_008_004.pm lib/Perl/APIReference/V5_008_005.pm lib/Perl/APIReference/V5_008_006.pm lib/Perl/APIReference/V5_008_007.pm lib/Perl/APIReference/V5_008_008.pm lib/Perl/APIReference/V5_008_009.pm lib/Perl/APIReference/V5_010_000.pm lib/Perl/APIReference/V5_010_001.pm lib/Perl/APIReference/V5_012_000.pm lib/Perl/APIReference/V5_012_001.pm lib/Perl/APIReference/V5_012_002.pm lib/Perl/APIReference/V5_012_003.pm lib/Perl/APIReference/V5_012_004.pm lib/Perl/APIReference/V5_012_005.pm lib/Perl/APIReference/V5_014_000.pm lib/Perl/APIReference/V5_014_001.pm lib/Perl/APIReference/V5_014_002.pm lib/Perl/APIReference/V5_014_003.pm lib/Perl/APIReference/V5_014_004.pm lib/Perl/APIReference/V5_016_000.pm lib/Perl/APIReference/V5_016_001.pm lib/Perl/APIReference/V5_016_002.pm lib/Perl/APIReference/V5_016_003.pm lib/Perl/APIReference/V5_018_000.pm lib/Perl/APIReference/V5_018_001.pm lib/Perl/APIReference/V5_018_002.pm Makefile.PL MANIFEST This list of files MANIFEST.SKIP t/01load.t t/02versions.t META.yml Module YAML meta-data (added by MakeMaker) META.json Module JSON meta-data (added by MakeMaker) Perl-APIReference-0.16/data/0000755000175000017500000000000012264521751014170 5ustar tseetseePerl-APIReference-0.16/data/perlapi.5.8.2.pod.xz0000644000175000017500000006155411653441731017454 0ustar tseetsee7zXZִF!t/9xtU_&Wi-͟ϽbW`?|M4~۱Wh%̴vHyc[$Gj{9lXko1A>=0ma0 vj%⿌qA`&nHqԢ8Pȃp#FVHf+8TU@堵ˎUv wzmE:L .:s* HCWvTan,5őُI%2WZY qz?)^4G";ot!hcy8@#]5wVMz.S[Z]8oBI3:*t$(&J"Ji%%N~}-y Pn7^< 23byKοqbM */͎:M;H*:4ӊ8͜˨¬@)H/z`$lUgX-֎A2KE೭f0/^ dxbq%hM',f W U!ZlouEMg5X h5&ؼ^sm/S>C#s8^p3$ED ?P+bXa+104K;Wݭ4rc5QiVMp z6(aV>ϓgfϷՁn5,ߴ[?K0 ȗ,Ɏf1ϬdmkʝDފ_P[9X~sda0"X{0׈]OD@*",r DIĭe+ !%9Y:O*M?;o5-II[Xk=uun.4c6UoizWBm SRI>=B$X`؃X?Ƕ,<$ɴHsY .)22@Mž/m 7dT\I*b$r'.rXG])n +3Id5i'.m]ĨSJϲmƲqM{1„oBqi_r|= C tѯwF (5)o-[' [Xj3_z߾"Z֏O-ҝ(a^hbHm`"<]WO!)d7;Cg!BKȌVxZ֢@\TL #$_/c-Fl|!BTS@4Ggx#Vpڛ49UjWzdXkEFxzi&F,0ze.{i;N=n{]2RN}h@sk=MowCߪrð9 M# =,̤Kpc0]^Xk|<E_^Ee l)(olcZ ꦏ&b3x+c(.50jYߝnL|4\+84~/&OtߛS O$7 ]T3%WY Q:IT}RM6- 9Qٸ?;Hiʂ"N$T $ ̞iX"6mAi\o/ǽe}0Kñx kHz2=6pC[?7X&w,WR%X+=~W&ߩ}`|jo%8: cqbRRwe5Ȧ*<8ĝF\`^IDsYǴ527%xZ?^%}ou2߶ 6L\ Xq]YoM6_Iۨ FQ/ 8Y$ pez$kFgE"^3#J ̷LXyA]{co5&a$7z37vUi#Q?> Hq,7oN@ Mv5d5<,'# _בR%ojݦ.E?N\&z+(hOV ܷvH \ۋD 1%mA>jGh;l|w!QKV>j"Sp$ǿI5:6n?ڤH`^.0DXֆj>r3 b@b.\*0DsY1 c\FnyfMĞw밚g4E }oz9-1ٙؓIX`gsOҰR<&3I&v/YU=N}5c1x\zIu L՞q+(8CXe^z|6 >ȼ1IlDgkCay][|O:1Cn6eYޯk)%T"u:>޾cnf:|6 >ԃ7ӿka*9J ʗhPHc9Xx#.HGD91} G8c&E#n% !Zh|AIja7[6 E 6>-pG&(BŀQ:R}wLjdt՞(F+:;-mPs PBĸ}&5tw ]rfMBfjAt"Jⱟ[A¤ CrE`xamiRE9*.A_cZuwWl*CP1>$ðCBOe|Ʌ&3P>T־;v  kTmpFN0=ܽ^u &h3bpgi VC":[*^fWߣ4b i7ָ70 JT" kd_6e4) H^o+A-wYP4T B<nϕ^4{,xQYpFx =RrhP{Z4r'`{bB|Zx U٦RCh3.lW/W˜*jc"𺁱i-fێ= 9CKQŭpئW/?j%Z84+`eF`ITϖWI+S4:~Jn>y_? Ru1vlu;{nc|3Ed% V2jǷz}\/c#K5<" EKf1煢(9N&ulvntVc ƺ ʃ^v`Qs(&þ4u }R{ ⏞4*p.qJʗuxkH> Yp҃w.gz1k:V$ _nEj9/5Jj*fO2Ȫݾأx$V q vZ$`R} s[Ů?O (n@SŦ LhSGmJP"w܅ N(؁){Mpߺܙ5@P / j+I|` ^lco>1~nTgBV1|Z󪁯B,y©tFeA|rBN۰E_pZn;Ґ;E#|U,b!yQ騜;UtZBhѰxtl҄$u!t d?f/ES6J.Uv g5QҼmb^jG+nEez)U@KiT@<^:V\L+;Qh0shB&bݎK}'9\Duv Oӽ WEFY\{&6fd Oz̪ҥ<1+V+'5`hJLSf9,G)ΓX!a@x5A2DbQU%r d|G0(5w5JMu ӫdk’ByHW`e!a6.?qjT l(k&}khnR7gpg#9#&r߀+zd`fC)un(l\SGԋ)}\l%\,Mg ȘFZ`Τc8P5BYa|Y B<%s*ʶ6S@Q:Iw^.iH5fGUM} B뵚\ + BwDGfw^@y$|<%󃁌qЙ@yǍZg<Ф--z倳36F|}g#)yS-%M̕D$<5ش"u].&&AQ1Ά ORh9Y3 m덨wmD|  +vv¬>,Km\۴N 8d\!(i*ppʕ-$*LBHW 0Hhڇ!Rwr&4/`s<þ=BW@%\Z$ڱԖ .]M -'BayO?lʩ(,q" x#L GfTQMxziC_ _|6d.ƤV_+1vDʍg?r|j R5L{*MKNp2[ @aZTBkPVZy@TF\BUHйbSbJBR&uғ4:fL)M f?A"JA-2aNl '<" Lfn-vO- Y4_>nZ}Ma! mcBQń8"xаͭ գ뫇~bB :As5JE<L]#Ɖy]ƌ;BMWҩڍEWnNM@~ dL qשWaDhK>".ҙA@|rbw/7mjRoAX#A')j,X `H*, 5ʮ'`5yͲ7v }Rs VǠퟂ{hlH'>K_ۛH ҇&OQK錾H`5g%[ (=BAp$Gl|XSU<쑷=eww8I%zJPtoEKNrN)(H(ŋ}Y O؊iW2Tng-鑤4lҒN͡]]&mV^*7@ƐnYOZivqĹPe8Giu'@rԙ>n>+X z,'nR2+B=Ĥp@ܷgTutP˚_qse7ᤘвlD`2|+ʼnX{sE+X}snl`˞Cc`D'W/"*M@mElkRCu. NaOw&^j_gJΞ1ilRs[!ERֱ܁{ N132\[U80|ߣEƞDɉLIrwV8cl1q$|t* $չfk˯j$lj]7_^sf[%-H΁"l$; ]RU/Nd"bR]v#\9KӅ Y`zS(d=DkNʩG눩s3cc,MKUV8;j^@`W1˲pXE*UsMCw I8 adD a*9bo֏ωOnэ%l 2|%" e:QܵESLrG|Ȭz!v]*H{788:B2Ͼ?Z/ ,UM2k^Ш172g7iAGտWYOTMg A>X,kNNcH^'اgKV)bkpO2ԗ2.ɮl[京S{J˿p2$(xyBryOtyX|D`r RIw|o{xS&ڸ؂Od]wzAxM !f>"7mcl?j]3I!& ?b@g:] 1K_Ç[ (l*޵l\]\ >5LG{Pڕ8H=GQ@&8ۖ6[SnFz=t~km*Ɍ#Xo6OzjrcESdK=y"Nh@lN %#@O`<36EQfM)=Йe9>mk nQub]C{Rwml<;%pa`6XCl:E3z߾'[#hjly* A٨{61 *NVs({0iZ9dcHں/؅IY`ȡW.agYc̳+9 P'9UdHS{JbZ*1kŊ:y(_>,K2*X {ك]A$YN@G>'&O\hu'B,7={ 1LRfL@z bJD@t!e-W90mo`=KT+-1',Z+HQJ[kI3ףp%R*CE-oxi2j. OҵHq7?h0Mfv-jsjڈ;\UU>CvR]<ߦRL`5.4*s͖6 >mlyNi#E£TH[rLP9t=摤QZ\QY4f1px7|O?+]nlo<Ӊ*繡QR~I-*Ž,K9kE`MO[3b͈ܕ &p{ iCQ>҂˕Uq4qB0xٻ rp eX&@m̔l&"2`U5gg3>NbF]$zQ%RHPaT/Tׯ> N /|1,'OXC<s5Ds~)"rIv:azj0d9]UP~%P[pܟNuke@/#8؁DE7G~".HR [?ij19Z$!??~݋l ۰:E@ڋ 9p$y@+G5v-w3Ӝ}Ɖmnn1MY+{$_>mw'÷з|$Z梬4Ȱt;g:#k!,EPT?hCļ\|vj/]73vĵRַ-z|.x yu6av$ Ǣ?: ؓYV*+ҷ>ټcg˸֚;IsL+{"t:'rwjAs<1"V_@$e~xNizOt#HXBCB5x5D/i_ԟ{z&W& sAO+k vL7fɰ]%#B;>N _M@l6)к_s/o hgTiGTG('Mէ@kE*Е'8Uy):̗|$Of2+WZklMd@_:V:{6[]t2NPۭ f;ie[Qb4MbZ5c|b4diN#tbk!o>e:K]/JxJ#\DF6F zNl0j|'qCj.܇x"pN;g@?e'ATo;Cm]!8Ǵ rJYcz$3^ft. ^--ύEI=Zfr@ Qtd,lc38o2gHхjMCc(@AQX#R2W-గ'Mp66DMMA< NƲnm yjC/"D195L*EZ)-W=Xۇ-:,QpMνrSS|E_GY] \1OOÝ|%Mgi!OUGWv3Ta[ֆbA!?,Kz ASLua8 @܋A&찟ͤ_S^lSO384RcuFM's. c2Iҏ\-0$ pFz|$liy L(eŞw%جjI 5|:UPJݲ3)Xӹ -[T6=ig)g(4 _RzZ}F@FgCRi`o Ysk3äH"g^;Ϻh`'$Ft3Ql `|yn6{d_^4Isýd`m!{oDSY^!7&-98Ny/2>~=Gl}̀)X!՗. 6ߌ>u'*? [5=ĺB;'!^I7Q?nsEك+v?+=+(0RdֈF@U* Vw> !xyZַ Asm ۉ)j+zM-İ-dw q'^Vue<FҠbQMșy :l^G/b@x)0ke+M<Ĕ$C9q!s8].&{3Ysak9=TefQ8Y8C/:mOX=pQ@`>Z$j-.NhT=])ƪ|9bvHXR&/ #:LEW\:+ϭaĨ+AUL @H`oY@_nuݷ幈aF=1ZV냌+hHǝ0):tY d!FG~&){WS\qw#)P0|{.ٸ\0 | z4l;8/xj IGǚE^$ L`d܄W )4z @p\[|믏{$? ?QYXIjNTe}S\~,j9㧃icAhTIhG1sLãِ>vV&c4+=\KɑqWY-(?zLLb4 s߁ױN->G?[3sj9>if4W6)1@nf7Q^#@ޝrf˳$}$ | 6#>7'^)YLUpc90;C5"b'{1|H|r|\Ů+H "hcx Ex0{/՞e4KY̯jY1[QjdQW&B]`PDEF 2 kpsWlH;'m@Xo qO*RH- @TkMNmGr2 I4TS#z?5sBx!Jp^7'`-ΈH5pћk1Sqmjh꺿k7OY*B/?Ye i LIxTa ?B_*R!~} $a@0-KTFD 3Os U_|; ̥[;7=CSz˞ ISo=E™_r19ycV?H>3 )ڤfW3=6>~H ̼ ;'ߔzgCprLJoGW*P؍\bS˚I)fS|=ڜk( a2b6!N}P%\ h+KD@>$#ZЕZ{TOXRrR#O#;JУu'ȉl$87[:S**FAU&3u4]_M9LбQBu$&/]DYίCmE9v{URTt-|};_ ˏa~XQ GDv-TfWY`>X+Kb07Ճ] ]6Hmy1 & 1 L.aV3/sFȟmi/$_Π:xUD-}i{L [^Kf4mU fP0w2Y ""!/Q`e!/ü2YDbتPӱ-gM~[_>58۝+~KZM!K[?u@yM"K*FVy ߽k&>CPXY+e["H';Q=J;§?=9d?8W7lqUAږP{*)*X}<)Cԧ%^֒X>DLu"5VWcfnI0xv?JRJA-Sm:bN |J?ĥ<{޲nV.MF$RsB0iU/wo'~SxBWXoS/5frq/ęF=(;ѭD@H$8y\sV~Su+G@q<gOGw.TҕJ%& c2ڇCo7}?ڿ}L?XO% ,fBS`] .`6R2*.7c遈"y䳄wh+xX ]]-[;9-Mm_il܄/r6 [Ewykp7%ErAJP@a'HٶZ2εRbK@ )i͞k":eqnh9nO3;dO-6Whne.f :b=*'I Ux,M^}$>|c]XĽ#O!G +LҲd4zo"|Y!mar HZӀ ʃ̧{Bgݵ+~|i7 5Qu ?Cc?F_u~v3CC_\B]Td>-<\ޛД=BtV ˉ!6gY&tBʋ$(WO6P~Y;" [Ej*gYgz',U@Y]-#*bo+%)*$8*+l.dJbQNɲ9ׯ:pHr o"PWw'TmP-y}階|"J-5 >,,-%0ixtePnNw( ƒ*Q>5^^0R~#¬e?bG(WFX i߀>TV`i^f^6\jY}Kܷ=Y"&wX+ ZFD~{qыq%XŭdCwGqW+@J"F.#ɔGQ@Y8cF5 005i1m'̬v2+=~˿,f S%rjVG&Eˇ 5/,rqڨ{lS)jCc.M>} 1cfuUGZ3<4}AS߮@U, М^i5Vr^0X^ȷ2z? XVLAv*;lw'k4S,u/JNJK` O{v;†V{N2v;u"g+8J*2]9CR"kkUr-K &(!`pI1չ*wWjRl/735o ۹Y ֕2HIf9IA/[=M x_z~&čV~rc`!U_uoyߟPmoijCƭisxGzCBAJV{vcf]},v^(ypMt,56:ŰX\y_*eDg!ȏ]TXƪU܏@Z̃R("҄|4_=\6 AhvU﹈ g 98֖ܽOKss7F oei#weE2, :XtTi۹'w U;!θo~`Gka7Julk 믦j_AWJ8ߪ8L~ZFQG|PM"vb#և)GJg wNm@C6ue~yRaZ/9O}-RJY5@*W3E8,O?;ZllէlQ$Q#%X|7)Sb;)Ae@)} 7g0!}Ye=r]%?^{`@0[_Zs(LY`hYoye^cv目:^$\tIGE0R;- VI}Iʯ| ܥYT+ }N㎽KLތPWnD>#'y}ɋ;,D'nij̩.W8 ~&yP/ll6 G% ) [Ԅ8 k]pL(SWC&ޯJ)ܮFcy=1.I~o1KLce{XqaT_y63\z}ß&Zm$XD<2_nd86jAX>Az켚]r?c0l]Ig@m9hxoL t(1u;| w9dl. Mj H<e}7t;'E!ccݐii!]zDUlM'K-FhnFf?1Gaa7x2~4N3S6QIws6L]k&hAzƆt=v³~iI;,4;@/Apl&ٛ(ő uRlK cE0WQ2EXĻ]QhT>6AjЎDHl?Dzo%&S5od϶_tl`Rh\), tFM});d-y Nex2塝DƇ>5,Mh+{L57 4^oG  jQR∮ VhfP_ur>/?m?J4^-k:Q۶ٍ]]KVxa*P> [-l8Akߙ5O%O-DI4ςcdVX,)>65gۑ.y֧@. ZӋ;K,6*(Ub 7zZm,nb'9 mtËsD T5MPC^T>V0FvĸbW9B]cLQ{+α<{@$U.'(ю}C”ʊxCVY-\p]TDo'ŴEV:hC"= -W](חq9 av"eq$˵\Apfkld?˙= cyԜG UJ2 E&t8h\]̺I&(Xa&amXݿ#t`v[ "g~_}UGXclx.V:SFiD{$ú s/IL6u^WAzkwJD8`QX5zzMƛmV[\g[Z`.sP0閕C)g !wOaE{/$'@ql n<#qL1&n/ǤNlj%ߎ!hzqtLl\Bb@VNxЮbK^6PdNe8W*QIYCa+& s$$5JKkV5/ȶ!Uk~{ڶ DKճuDk1 2!veA;s0.p_Pp)b>aQRLke5BӮaj? ] ]gW.bkEj 8riM-O\FHVFebC(.{$YMf,C\ABۓ0#Ic̉w^#H%wGΟ63'N:@>x2ȼ2 V]ֈv ,R@!)e#odQ^˚ )K-R:"=&7}DOND_h{c!TZHwxʘ2G#msa-ZA.ě>Rs©Scn$oU~Ih*Aa,/z2ŸqqAi=Ku?@#wS v|XfZ6?^n,C"l=~#[?]R;Ff)iKő[*^OEAudz'&ZdRG:QwQ}' t@)D)l݄c֥r/XIQCJoO 36X=/Gq')!biÓWa "ClJ=,ţ]p2~tTjDU]R$M6-h4[ AMmre+,$D;*}c 3qA3ǀsvqe k]rמy{ξ]]'A[&D:i" =y?ل{-^-3t Ĥ EX\魃2cLFNI4{k[KR4χd o (ٶA&; c'T/LNoAa.o9Nr7z93h0Y6._X>^qۨPEpq_#gj> dIԀq7R.I nڐaQJ̤#{2w7iL`z<',RV#^n8a$rͻT[:d1T4 `"^]UW~whdȼ|SwYPңN@vumIêco?h@H PjnO9g2E518BBӯ :LĐ.ןs~#= ^YVb?xܮ#vn+WлSWgɤR1Љ@WA2B ;#K΍Ƚz}gw_ꞌYȰ m?\ i P:&d82\L\XG,]+'Q0h<<ƒ I8Uٌw-\f"m+!ݓQ<%.߀nlaޓ.=0ƆVFA/ۮ{ B̎M<>UkPA6ֿ?89(XT&pH[Px4doRHDwв5/sJS L?Yz8fiO qM:B0 35/1 y҂@AsNV &f '%˓xDH14/+[!E$ٿ+%mPI:i]@ C%/V/ܙ{fn<̙+;|X&'kT%鳄V#Ft~v=,z׋%+Vj˽;mUS|s&B|&-jܥw]@}rps .,-@',&mc{i>Df9ZZ +Nnm <)B+$~ JI4A7q~SقS%t1a[H1,͊Zi#0ws~c &|$i9'E)"!8c>W  Ԙ°1Mk{jʾJ2jq}.<ܜPo(~Iy⚒RYy>9"=ÎMZdO 6y"Jʁn+2Law.ϹjAǦ*ijA**Y`sZ\cg;1BzkTueBhkLT\/VHϵP rŗYa &k0kW ?\19f>w4{~~| kC  U"bv ?=55*va;#e=NZ2S5΃M/!àr8Sr"{, I+Yn{#\w"~mDÀe {}D:(^h&؄ $M-{bPMRӉQ?k+}Eu*U?".oZfø藍=1>"aQ4b:KT d{ßu24GAX ".&6(| m:e :#umaKm=QS)&Su»Zb'/56농7RG٩v]^ 0b>\t͌Aq$ >&`xp Q_0iRFve1:dUڗ|HE <$'*DDuU:*,!2߭Q:!X[gXE(ɿa Dphɔ}l=x )%ܤUd`8W򤨽Ǎ(B,X2M#9o i/VՈLGVg>k"rL[~R '\4#6MV k&ln'f]"1" ǹZj&01iucRI5 #OKEEJKs$Gl!*w"\d3v#}EbȕB6]Ry| y+͜"4vU3A,Bfy6%k d# (>z[YKob\4[k?P<Ϲf#;g=m6J&GB)FA[+ MP12@}d3$wZ}ݸKT 8:Sq#}|I6~ M Jee!cxN9-.q/ U$V[z34tNG~h}v4+t\!Y)IV;ʈ7 -+f4vJgT:7B6`Q mJ~8G^h4Yq"t1[u1 =]bi+jXi65!|Ɯ98Ŷbny90ޟճeWzzk@q]{%JYH1+Z'tx$>0_Jd2`To5D; :~Twzӕ`UCDXgGkJBםP[fb%5='YGq"!g6+j%߂1l(ASSTA扱zQ,An 8zDh$Wt}$; 2 7d1nIk ZU {YtAes]IRڬ:9*S_/wvӲ E*t [y($Do%<@EEZH[xΓ?|#zI舆⣅֤Lϙ wdd: :)^y(k4pn܋h{6SCm7LoAf "& ,8% @vb 0Ըy"6[.$Gt:[N ;IӅ!ꉠ2{7if?Řc4c>< ]CN F_7vMؤG@^`urtr'#oۯm)G@6f`ȣ@˒ "{qU{a_g6aR%bQd0g,U~X}:OO#QF!?1s2Ҹ(lwp ] B !pYໟRjp3b2p4Hs#r5wuYZ9>T_h[=y~CE0?2n @IkrnE}ZnOh3Խ̞( 33h-`ǻM"CR*D6Tn+=VEUyq T=*1 " ^'^Q7Ɍg I0'z]JayG[gYZPerl-APIReference-0.16/data/perlapi.5.8.9.pod.xz0000644000175000017500000007760411653441731017466 0ustar tseetsee7zXZִF!t/juB]c?V Or;6ǎ#x=j-CTx+'jj'UрP%p 'PQ\Yl]*({3#D` QYnA֌3)m(O0lgȾV>Ix2QŏnǾ8YioaRԽwC+9!74lH(ܖXvC#"D}%l9jSԸGXjog;~3̝Ħ7&ݺMT"0M7V:s_:ĸ*5.Jn۟F:gfqis >>o+7/#Y32TUSt<^$&̱(4wgAUiͮ栚{} '؝sA`~jh~.][éLD,XjNLVZ-OsR3,jۗw5r"ԞV<q彜8i)'IHb|b +|!=% {C _N|(ݖr9.d餒-fgf-&S2n].,sUg2~Awd퍧HQR3{c~w~~~u>1иHϫAVGJ El˹K]=}HQSn.&-*1D\64C%"2ZM9LiB'OC~y_d웞{*Ãj7υl!P9]!PIM&dI/8`==qg]ʱo gFtwbgy&PɱgO])v2ȮG@*nXg]/Ӥ6"]\N<݃nVPyoB^ڏ*Z摟ZPdWLg>5]%6 c`=t8Awn$z,;D{4Pc&h6PsEP=$\o,:Ws~>r<%ͷX^jt1^o5_{p) B*%E-& o}7m3Z&\w }Tsu'_^z./R8ړΉ}=ip4;[P^!c~DBjRM)_1 5Ӷ s%qܡgt63j .LOrT!1H  Z'|م Aʮ %=iV{c^W| X %KOjYO?G9Q(Ep0LlTĠ&HSDj-l' Ű- {+Ao `K3ڳ%~AX 8R`))*(,ǃiC?XNt t2n۵[ZMnt,n#R- J21'N?fq=a+my8K/R f!.- v*L;NJ"q|QFt7,ZAibFQ ! e%E  s ^41NԧZ7/€h6Tx'8X83XA" &oQ`8+fA Lea|:ZTȆQ=Zsg] C=khCn =nX1Ee~prkFKtj#yD1 _%/Z u)HU *,cĩ4m/z.mZp(2maj5JY9R//^ Q}:\:F&WA{ġ? ƏݫÝvŐϠr9/o10ƟU1ؾ[-%fs|nu=U=>upmڌX 3 ҏ^,zcgtNuڄq]blG9& f!G bxaiZz\1>:_h0Y-eEԖBfd˙h- @Fʧ% !B*Zo1𠰼ՓSV> _WnwU+ ʼJ+[*FkÂzˢ j< jOLsȶRhȧI|7"y<s%OfC)f(s'ivtM%E24&dEdAпnٌY atä-Nj &%lGy,T582.2' MԬ2pQ ecІ"]czF-AO SGqϲD`kV6Z_ u֘3qPݹ^/T#D|"He khq*#Qs7 E듘V[/^& ױ:W shF_hm3vs閙HZ!4YXu+5l*6륾Bg,2uR)ga_bW ܣROK}i[}n~=m= ʻ?E ddFM#7v2OE~S_?G~;{f>օrciS-"? vv^ðoN:Ǐhc;q:xX /Dܤ-`Dqy<~;>4Iy݋G>:Pg "$-5"aCI hb0ШO];Oʡ]]e^d)`iE{x]CtISA8(D )ޣɦ@2'g2_ y)kN_^k'AqDg8( :OQ[<-<j!-{HJluYPMηJK^sKdߟ8`[ ˔Itirr 4ڹ{Chn4Y:9Q} ÷un%AI$/ /`e وjC_V8[3?}GF67! ,I#1Mv[Vz;PňO 3~H-=⊛)]9bdxpTwrx"k`47%n5BljE!%j`SSSgnRRnչiX̒ÌAcOQ^cfҲU'QRs/\U(R|)g|6'x+S5O%gBL*U$g:Q{3?aNs$"{rbWW!os>z62.z`mzTsM35n1k⼥NJ[ћXǯߊ!;  ~DŽJWUhnk yt:@y*~nW>T@J:hu.l4,0_A;3E".d焰3I=q^NȀ54;sʨ +v\?31:25M^C=wΆ8c(rop { =}S_csP\B f*XfNֺim]mF*~0߯d2@vRۊoRqU{ {䁘gV@;>]lnІIk:v@q\P*=\3JgRMXc\z>E-loO N@f){6|3܁^)hi+>e A"`vqE >T=) - ?4(*ѮZ>|.|I.xCcHj yEJmBY}-k5QڎE_MaHz>'=WQF{]j k :mY TRb!_+jr@< ^„`ՍVk|:ܹ)d!故rݗ @G;J{E$s)noxY5^wv#<4yo\+bW3tQpW8_ 5mtZ |VY~1e >HDvӲΦܩfDTQuh+N/aamұDZ!?J#5XɒV5tvk;_VDJ Jc¢v$Տ`؇dOYGf+d@J6[^!smdTtR}vM7:n17sd 0ZkP=tWӚU15^(/9e(꧅=Ȥ[[EJXC@=cܠv!`0b tBùBvi{f *O p 0!=T)Fo .CPQ{iw,Z5SBҚIjRqK4PvhtLm#l/RV񡲓[zS鉓QpEL2"E˿A>iȼaqÜ\ЙFΓ/6r>UQ{_Ƹ4`b Xqgvahy}/hޓӼqF\n'\ Ơ=h|ѐ[u@ο,'<X%%g*j5m+Ma7ERR٨"Ƽ r}!QɌϪ m9gN@/ᨔ^u6L~?+"XCc)iq -@2o[gu#Ʈ18hNCi Ӥb' HRKy4ܔ6ݘ]n|kPt؂+YwgGOVKR׶y0s椯\=> ܺ8Sņ z_ۊ!bWƑԁNO k9\jb.KAʓ(ƣ<ܭEM~=r"`b+ćjk{:Rz7`aV u b@Ȕd :d|4h}.wtj@T4de#_ i`Y"b*YVצ=a `XbbQA+!O8wrSmk"dƇ@ 40ch+28fe h*q]g%H&=nE CNpoS8%n9'"/Gg%Ykc;utDY,\_W|3GgDmf2a3)FZcs`N⍩;0ÿ+.ioEM{^Mk{Aɿ{ R=x'BHD@_fu(6އeUx'dv]Jh3ʢT!X9M4B"'W(>Ғ;k?(!_]Q!ɂؗOdecm1erp72fnR.VIj3g+H}*s;7_y/귈D危>L9TlHr'7M*Ѵi7˥d=[p3FVZI/Srm߆m–VR׸GջO1D*:0 w_.ڐZSwu~F8 |+cG>H/(XB0ICΗl^*UUPx1cpWRLƁ2_d)1TK\s7̩`D*׷BBvN,xmf vZ#BG?#zjA{%*IMA3?G  ;BktHU@2Vd/4|og{1fdCq1|B|H, wY~>Ite#"̚(%ΦK,&"d.p8+CyR_nGa%=șѿv U2[kzQϮ8tXZ Ol8 WC7H ٍTx;];dDRS\:DS~q A#FLW4wڳ4yEdL # J7ZEﴴ>NL^:T똻fDBRE=д~3fb5Su@.zTAeM8C`3ɻr09 ?8T{`ĺi"$=L\Ӭs囙nkXKI$QN>謯;JmR!8(uUUyJgrE>J̃O(ulȞzJ{~1k"gy}E r4=pH߶y]+#ƒ $p5<&ATn)d%72w.MerW 5ݰ s)|> l 4_&>b]YΡ:QPOcmo9p9ev!Mhw%wۡdÌ ?p,jL>y_:1-g\*h^u| P{Q֭%rUp=z Iۑeu;Ԛ  "s܏Sʭ,`s? '?Ν eSNmOMevg):rA-he|""/5,`ʷ4iBi 5xVReyV ,;FQfJ.ْӸSU izmKYyirenHj'Ln OL,Z+guLj|iߛ@~ZC JJ*m{ Z]-.fIyHbhHQd6ۉ+:5yQ$Ins|A[EЯKƧxl dZ2' WZ8庽OUF6 42K *xj)0Ϥ4:w̷3~V5r|L"mq%hm!n=%t=QVVXk [fϒc=:"N>7av6>U mK;6ALf/uf|4VT`S"h^CK\~R*OJ!M9Vp!c|9 %/'vKɸӃwn>f輥JUQB/{]E ]ό?~y_i4X=kiN[ ~hB[T$Z9o=sv`^O0V ܵ$.BnMAϨ,A /f܋qNT9oRj;O= 'cWA V83؈B0sN(_,#v6xM\yY *KLdScNhJX"Wj=F u&yXLޅ,-FFOH]4?DY1&#QrJg TЌ_ޮɣيfs".ÓXBj-uxA(65Nm=0ZMgi"$H SkN 8Ep4vb%Qm؀173bEhlxhh~x7m5%#{UsmCZ) 4PmrqJ@+|mT @E/)9,ϐ^_4tͩ[)km謟] naXܪ*w= Jh$Lo:YA>')@Al<ێ&-c3{`]q))&! zA;P1Uq֓92΀뫯z-eXY0oXvR9GI?xѯ*k}ROfPw2#X= Z:%\ihsW~x,0dҵD S95pvX:k2Kwٛσ{|-}vc_o:9MxHȂ2rY%͌0ܐ+Cz8m`פK 5*5ХOiJʬ%"Qt66Y>V.kXG{v1~ͷbhS2G云*cZWN6)[prF&J{"]@p3<k%.zd'gκtNP¶bzJTAN?V(CzT UzX2.U8bե:M9!q~KDw1NkL,oٓfPD +)@R0ؑ&q)x:?`IĔP g,]!*rϽlf3ۊdW}'Vn;'_%TEMi0rO7цb3ܺJ Դt5Ag#ĐI<`};F{ $Ʉl2vp+⒒`fHju ,ɏ;Y7Wg5@2دL_jf=tnmq{V`L֟ +_w4}:$Z&ۦ*>qo-gH9Wi |3beuo \~L42-<+AœV\0[BdPWŜth<& +ι]!Lh^iM! y Lу/|(j'\%{{M{5ҁB%ɫea6؃hrb6SqWXZo9t8 3gDV9qwD!z?齫r9,%7̽P8](ffg`OMH5*6qVTkBBo%!e޻9Nk3 ȦUtڞ-6v4U_/= /O(s*!Ŏ"읞=0되K5Q(=! y xI ]7nPԛFOj!{(u<6Hoɶ8܏!LJ!)FdѪmfr[mjVA7j?!/ vs;%P^Sxl]-Spj޷leQ轍;2n? ަ%ˎ M9ա'yf|P >"TPk Qt{طExND3iwp\o6N%̞򱹊b3bP?L%1iz #(љpg2 D~^HpK}o (F,mռM>^{%u7ep}:1YB-ḭI~[Hufn+'oN+\̡W0`H 79P8.FyK*lq#k[}tuSؾoͶ<ʌ}9/g[G~׭ J>`ox Cʢd{YᔇaJB` Loi'_0NBp $f"BbN?mS,^p}~齥83 @5Iއ0S  !_'%"2w^k[0+]rp2vNpjy^"nZÉy8؞Cax^{z&.Qԧl ::ڣ#muǓ4h`Vo7lEc2>B(ή(,w`ZD>}!wA:1.J˨*E)J_QL}]|6qM6l$b5!tU˭j[L Wx([glwD6 "%,ۨ|mQ*Z&,8-of;" x; XCl=0=+ﺉ 2uaVPWXgv홽yٿ%ֵ;'jd(RZG˔ｶ7wD7O.|՝ý-)$)> ۤ@wѝV9auq\GO /i~%iu, mrI߾Us5.f0@SL7"0r|O=CIrcaKZendIl2s"F$=\-ƄmYmg;/ 74jr4-~QP`OEiP hݩz ?$C*40*-B]ZES1Aь,{o}HJH=uqG]V Ϫ 2 sVrc(, vyZ4[BlCTv1,-D۰ѵn%N.`nqqn'C-0ʘ#㭢ܶFY$09/3`H8krq.+#؜w~LWsѱeӍ\ݧJvyX+N-Z.b鼞JJ ?E(_{- }94_k#@Y8~;a !ИhՈ8bF ZJtk-ٷqOsmU[[ 3RY4GID9:LHc;<7riI9 hC;7AK,u"pU湜XK=QBіټ`ZA6Hp t٥ 4 glx? o@{vTEIaP"d$Gi߮pjp/ *&k eQqZ)K_#du714HLCOҧIcCNQnS:v ֙Umc,EƲ?ڋy}E:.a6'c#j2o&`p]-_.O FWӜYsQ*"_O/4k.,ľH1$i鱖qvzk'e- f@EQ#.da>dy҃ ՖQ?ʓ-}0%s_8s< y1#͹aeeZ\ޜeNhB"." ! aGI%COBP A q[Mm31bhR|ة_ޭ]| QG "Q8;e/MțN@kH6\sRFE-^Z7׹#R;O,_a wC8",eP 3R)_{/rpTt:M;eD.w'pzm Vd+t s4RO/2t 2SSJfmQ&JmiZ+ʚ˭) ) -\FP$swK.`܃c+)rǛqsd0{ ^`]=o`1řDaVXЪXx&ykTbL PwlJEL"" ߇]vy]V=uxӘ;<4S.s9/*|XC醜}^Ur3_8!lIw%#:T`%އ? MĶ 7\c86Q%#5hxLY[t$B39@rcLw$|oNXM}c+0>an1vyNw??MzChqXsvN9WQdy fJ#ӑu仐k =ւ26(CjoYX-k3ŤM*7(_g&NGvNj񫂥 .SQ` h/ݼT怵`  'MIoѶuˬ,1o9EHrS;Ѥ|RpʉP/7:bW9 VKgz_^ɘUκP&ߩtN^L&:7 .1No]"b6diMsMTH{l;)ܾ8XTttHȀV+@PBXWmR$nV|'Jl}MIkX!$@,AXvbH *iL;Aq? ۊ!Wpr;6ǁ^򇎺+5LJt`<_.x'?˴WMOֲEڐirOؑ|LE?S3Tcd@0ZyoZҮom tcoܤc߀F(`ڂ5i2{L8@V4s>ttri;3MBC`h %(`hQL/- TǖĽı&F'~`lhNrM-* JzU[ߙm2S Ts[ƉxQW\C_Xrwi܉79t7Ytz>[+WJTQ47]g88 (r%;Uy65lTDܣ`* 13T?G}\~{r8u*?C~X(yJ71zUKWPK ;$%+ ZFʋu7B+{ݝwQe򂐺(wӅ TUe 8(l_N7MP7yj5604W. xܡJ&R g3Wk=YݍP MS}AjI(ѣdn\Bx pK.Ekђ1dT}ҋMҋ$e}1 yï/꣡X%*.b❌Ɣ"x4SefTR`rS"|v>un,ϭ,̗ۮ7Xwl`er05i,ǗuFIwK# <70yZODfSkBŶ ,XN{\@R[E#kSsQPuhEoM%\ 0 ۿ16.%~v pzΜ+NE=}uN)nVkEHe*eNa{kE,#~ӁΧ<8Xuߍ,f#ej BbvC2 Չe@cvu*pR<`Ml*9Zw\BP +Ԗb2S#7?R/>Kf8J*P]}I58 PV+y`+S> _'(`\buS:pA"qY˴$] Cݚ')1= fX>d[r]SwrC p{7&??at熃 &|l#ze'}V(mlE+uuގ,ghF:L_R츣;!zdY^&,L«w*ʚ*G%M&n7HRH Nar l#ca5,pϩF_mEJ~ u;MvzOޝ\v.&@A6RY%a#M/VEVoLwe}W__1-,NŦ6{u06LI@@*x@X!tF4ƌ h}x/ zjQ?=t$.kͽFrmʅY8?* W4=8r) r X h0FDݱ-9%DU$wJ}s@{6PR$I8k TI, Y^, ߋyу_4q2Wck:#bo{9 VBo "'(t!u {1.A 7F_#=^/?0w=V̒E9cJ[=.}h, h1<5$r+UM{d[,Bźy'CؔcU/E_hƸa˩(ϟ y70l_{"֟ h|W˕*96,/!t+?`Ae!1{lQ[u"8DOEA1byihmD9q`-tog.E#$$9 O:k^-ӐhBdlB%.-J[j!:^Q#ѵqF$'`k0aavRfY~֎4as%+J !BGMv,$ϧ FIpnhWоx]Y#x{^6OX7ِ4Q"8̗"~DP$Kߺȗ؊R\*-ux 冁,eOM;|ʋfR'K\(sGF (t%B;>0~C|<=⠘2ax2jHsBvSn'UǙ o鬽;m ūlhT,?DK--Y請nơ{v$Q, #$>YL2uOف?Z3:-ݿkٽA1U?Nof3L. rG.׬@Ǖ=pREúvZd{8oqBG6vc]bD"UKӠ'M>@h(OuR'ޠ h @Jڡ__A3p D.$\fy0u' i41I]X{U1kOQqS>e.ge(*cA+"C9sM3w.I$~TջnQ(#D֝{jK)éJ+^JQl)9lwDAշ:9g0;h| (iWa}z5(ǘEL,U(5U98-24u7_>].Ş,-m1kjPsk =F@E,/@Աzio7XPy0"(QVUs"Cu(_Uݘo%z/?Df*)w(5 ϗt E29jJyatf9_zF; ⒠1߁^qUPAԸd2u2Zߌ9j*S num;bh7YMUߜ+Z"P A}1 y_|P3ezJm*kqa~^ =#o3 -7u]/FXJ\Mbs>nd]v%nWqAm Ox R5b vJ Ob ,2Z',e4)˼b6aPKzg¶&[o,};@[n1nFf< `pT/ffnc0$)$*C|#G@S xLEr~ZɃ,vbC:+9a]瞔,Mnuw7jSyz'ѴK \0 .&U'鴮(uD0*_@ tGDag hwfȎM~E)y1$TX%v/fX L/ A6!ϷcKxT|c8bPQi[ }Ăza!UV zXz%N4vQ,l[707\E$ڃ ^4*.["wh/2tfLb5;8Nv?ؕ,=օ" C{,uEk4fs~%ZZfeC^*zq}L8+1"FbXJ>J{vfd'•?<;"fl{G-(Ԓtf dͳjUa~hʪ-mDRI5Z{g҂VҎq UV:)UYj%tHy N~fЈQوW4#b"C)9}3wct)aАCV̲ q2qnDu2\KG%aWaTξ%QĽy˻*F-u\ ΍CKp# RGK+SAd$Yb b^Dߟ: J4$&vB2,)8;鍉U!chrT:9*`W);e9 \lG' jI "._&o:jӃ=+8F򲲖\gxf$OT4uϨoO::a"]t)~㲢L@եE7 RpIn},H?〶$Kk*vsQXϻ;1#8Ȯ4$,R5!~z)!/bUT>' %7>t~T@,+# g^}ĝ[ M778N:@)v?-T}ͅ5Ws r(Vd9'գۦ[ ]oW=uʄsV{ѓ]>)倌}a3 "Z6Ia|iZ,n~1Lʩ9Ύۭɦ8ϝiסSv2͟B+Z,I5x^^@$?˜ 䥞 bҊJ 9dK@mTB3%fa^/h׺\ϒd OPYp@ԏvɍ~ʈ-@jú:L;=ܕ=[VlY(lY(:&ƿCJ?hu >)A((7);L4H_;I Lj~M<)@T*[TVma;aA]["Xn =S.I/(%kE~'}cN ON;,t* f&=E7"bA-ᴒS Ut-A; xC.6-AvIJJ1$PR{z<9Mr\EUp:6WSeNx*SL].M[#*W/h69G$'~l5;J*yf|‚ώu ]ʵ(x!}7gp=v_ޤ9c7]%ơ˻kikoBFSc0 ۔@ȢrN`|J>+OSd67εMExQ 5ٓyIe&oOH̐k nB"6iv[v܁2їQRZ18m;S3~v { 83)zT_-\)X+"P&q`Vr[0%sU:Vr(NG 5 yTac.jT 6ոcʅ׍j7hf9atPY ? R=)Re񥸿yEuy8:JSm(Dݼt;){v+I)>ƻ؎sp~eJ9T*/q\1dsU;5MKeEigpo藄nLoFpx`ADklwI#4E!ľR(lr = ݌do1Ktz߬_8æH/2&iөRT)-ϾLqO!=V׿Kajץ|M[(fE3ᐈȒGu37V#qpx^eeuZvy6'cn޾+M>.M"Gϛ'J}eǫ{ԩU޼r!8A>Q3@?x_mP@c;@$nG-=x$9'M"0,G9v4Rō5mY3OtV*Mk;,>~?%EXCx lٔUəe70M)LoEѓ0#߽Җ_-SdQNҤth*}3Vis|5v}#qc|EeuM!' "8Z]L $9 )X(nȢ+YZhXٹ c l{?VIpu 1"&w/_ 'AEd&^u & ؽi^})|OwmC09Oj )3“\Uf]M*ߐbr} r=dҜuT6t:#*(2oZSRi,bz|B{>C(^EڀseAE=_cKV}+ 2вM={* !)xn:-WQ*BC۹fpKpW9Z~ݔEbuhrR pCX;5h BM] pE!UxR~6VkhS" pM"m@~}|Yԑf> !jlɮ}[u: 5yb&PiRU(94~<3[L+GVlOWtj $LU|ǔBؗ\]=X*, jQ ( HrLS480Kn)&ùV)Ŷ2eF1 lh+_2 0,̴wî>^mAO[}Q<iyN y~*}$ԑNa d{+,Vb.9cx7DH%=={т E;.C@ S.y"*Jnqi|NwJL|3ClԲ"aC*|'aEv/+S*Ld`UtI$:\p"i.?=T.g LW4x]NqNX`8K@W))47XWZE8Y.4@"tpf&[jU4ka+0f~F4DvH #w JK͟n:oB'z]p6 3ny8Lh$8,s )NWxqD.uK#&QƭF,m`F `P+JfT (ݧmAX]ͼ&Uvfķ;lSƸE"׻U8U4Z?$Fwn N攦^tQzIh$tEݛwN&]U՟JPŦT`jw18RрTA,Zi@e4 u)J8 my:X"W>aV /,0*a.Ykxﱟ\#:)a Ds-vh̗cflJ6v7/O`FK ?udccWrp^Sezn~tTPp5@S%#ۀkҡbg@ȩ%h9ٳdJ K㽛~r!LSq!%c4<@۫1qHT[mJ 3cϨhG9>QX ^ 58Py@iݠ霨*FY`¥~WnUʷD=l֫uMq/bdJ< vHV(܄\+ r-@oGS\61c5ߒxyc #J1cU1iL 9r#-׵o1N[3Jv~~Ñ߸ͫTN Qt6 ̵^QYKO;@ΐiqb!KL\fAZ#=兰UUwmf5\p~4wj^6RVz:QuH)z]0'񧿰UF+?Z6^VCB L'!+F',ZfnTD=dw(^.|*ҍ>u_S~vp+HEgSBw螆Ko JGTDCU|~ҬJd$8ĉKƮ/>f>D@Jz 1eNÅZ - Y?f5ޢ4n#o#:^{!ZkVSi}ֽV?"e{sMh>Ln[5.G<_q9X4#&9@f XWL?W>5qB[p̦T`A4ף04>?9gx.ءů͊}C@-@\7Ӂ}a.́'^Z1f ?a+Ģ_O+1NH1+nخ{jQP[;l0 %[}^dǜMP6_ϴfMW nQݹtw1uCLJ|w]nݭfV,HjgA[W G ޤcQD5ċ{H@BgBq7١`!o7iBB,Py*RYPyABMZ#U}k;'`r(avJ3 ErֈiM-ż֘q"d4NP%8ΦG#:Ayeܒ˳ġM-34 m>εoeSv.m'Th2a.?D&z,o I\Ei0^ f p+ӝiA!lsRh>aj\*S-qNS:{+$5zn 71:u|OL<nVR#dyË=Jed;TԂ)sx!+`xjXїY5#@Gݓkٜ.2\^nTP=zx/ !gn **\͊zPNaJ60g2~;Eܥ64E]hj\&=?ӁشxK˓,ñ^A}}(jn\h~˭?X*IvT*x- iE]0ha#S C*$Lr 47ઈl@pڱLaJVp,ak<챬,8珨O m)ѓ=  b0+$|9BuMxQP!upT Cz/fag(>M%~@֪Y~kl78g7@؞#nԫrerBgILRԕ4jFf bI% 4, `Pb̈0F˧ut^A'`+edP.v}X18A,zB 6 ӊP*d>ڌ!Z3Monh<^؂z&mqGdTˎ>(G΍2F }-I^zdFQIһv;ޏ 9du#ٞ AM-}}Ŗ4|YA% T}s&;= 毤y;e>~F{2pyIsNoR8a KdC哢Ԏ}c؀u/7LF0PR>}q PE7Tu7耮,A}PDu*<10RF5w׈ꯜ^,6eiC;F bX9Qi9YlDBS3AdQ/>B#Ա? ܰ'UO(CyPycI f(7V({SAwЭ)rQfѣ x=\;SG"B˰ Aa57|),4CƔz;n3Q eyywobqD^ŶV3d\'XMM->NݩD);%O.gI4l37 vˆߍ#WTw4@C3X1c5*/.UI s 聨}RzT F[EpإJ,xV_/ "ڋH]D>Enힻ%\S[v+%ޡZM>&*o/.O U dFjt^ج(rT!楗Ni@VFͶm*֏̘c,OH^ѾJe?w("!;_@]zk*Ō]DVAoCM229ɐm QH9- %\Qe x]ǹZ}9}TĿc@j._EW^Cbxo/lWqf^!)]ׄr]TSvrP}ZېSqk8ri}J{KV&k&ר:N-9,$~aaM}! v \<-!9eo1xF-wD>Bado\s}qLRu;\0TqƵ AjL`>nI'_O9Yy/wD)jτGf%D/4%]iyyP>o Gw $_B*Hj齉xHZf'Nj>PFX:'(4*.yhHAw/bd9FpfSa~>ȷ' R3{N.E}k2Զ` >+sG:OFXir$-2t݀e#`je6=yM4q霍(Ѥ4Gdsn>R3& +F `Mpo Wү4=fsݏ_gڵT A fghW~$])+QE|F*쀹V;ɴnvwL+?|kK "^[އ1Y/$@9^2@BUcq-Uf]#w5²~2hN= LT9xBL5s?qG5λiӢW*ERxQ5<5:Rn}1GэW0(NG{4X@.Ttmǹ@AG߷"BcӇ7jeb$gO^ɗdnsQnVh?q,,:wAl

~:r}1ΏEDu^*(qwNrTy9&IOq;Qw8%gfwDkی8SDc{J]$0ixǹV+c`q +@ž܆fxH|; saÑJڦmtl/:עv|/W/$SRpX6A74j#⣣VG/Agipz0bZaq3˅x2~pFnQUP/8] 5@bO8h`(_n>-#UA/ig G% 9U :'Ȝ~ȦSGVpḇ7Iirp2L RqM.ubjDv~*z䁾OBʋ"b48K}0Fb8kKZH]:uj2sE99eus IgF wrH).pizOoZ- E){uRZP:'#qC8ݒʟVS[Sn_m?=5]jGx:Nͫ>\w9xtU_&Wi-͟ϽbW`?|M4~۱Wh%̴vHyc[$Gj{9lXko1A>=0ma0 vj%⿌qA`&nHqԢ8Pȃp#FVHf+8TU@堵ˎUv wzmE:L .:s* HCWvTan,5őُI%2WZY qz?)^4G";ot!hcy8@#]5wVMz.S[Z]8oBI3:*t$(&J"Ji%%N~}-y Pn7^< 23byKοqbM */͎:M;H*:4ӊ8͜˨¬@)H/z`$lUgX-֎A2KE೭f0/^ dxbq%hM',f W U!ZlouEMg5X h5&ؼ^sm/S>C#s8^p3$ED ?P+bXa+104K;Wݭ4rc5QiVMp z6(aV>ϓgfϷՁn5,ߴ[?K0 ȗ,Ɏf1ϬdmkʝDފ_P[9X~sda0"X{0׈]OD@*",r DIĭe+ !%9Y:O*M?;o5-II[Xk=uun.4c6UoizWBm SRI>=B$X`؃X?Ƕ,<$ɴHsY .)22@Mž/m 7dT\I*b$r'.rXG])n +3Id5i'.m]ĨSJϲmƲqM{1„oBqi_r|= C tѯwF (5)o-[' [Xj3_z߾"Z֏O-ҝ(a^hbHm`"<]WO!)d7;Cg!BKcU hJQ^x4yGϡzl GG/:=e6%A7bK$HٙJreFFvaL9* PY#Fd؀t("p\.Sލb);zU>"UU>}n:Akh&({e11ނvߺQswZ7jq譝O,AŨ6˦cRڀDG_eHoD=A*)ؖFfPmt=q93B:D,5$gJ.ԥHC̩Ęz:k}ވ,/ GE`^5(WSXodZ0Ng3ﲶJiنJ?HO/]˅:/LKvi(2q/o1Pnk3D]>)@%<+M hkݗeeũfA_vbAP50AQJҪ3=Ի`H ^ zq 0Pb TVcYK͉KM7_l@-T&eB8p\F[ed?/갔C@IOd3xi_tJ5"APp-M !kJm= P0ߤalP؈l,[p tZ#ERpTC;՛/֭ΤOuܔTBcx5q#h̒nEP !pnB5qm_[AoSP7SF.>Տ qw9)${1΂`?a~0qM'5_1uiZ"HO R*\Nz'}v':`4Ϳ=.D Bzjw!@L#H(SMikݝ4.{Z߲nVh="7yilQ3[*UBx[0t]  ey.3G+C# @4,.hZE PdдMCe0&panLLb5}zz}qlx˹;'$37~ {kt2;=$"!%pCJ28WډC ZBIWcçi t0W^9yM:\¬[T k' ]mƺB[O^+(6?7ckbf bNQ|,;,{Q*g)Qy |ỵbAMV0%Q]i3`3 |zgޠ玸tͪ9u1j,e:~=;9J]45_ՋG:ODkqGW8 9 ̄Q #Ҽn'#>tpzjQSFV3CZ n˦K$WKlk_PDJ?ɦf߮ڗ̿ 0Ky 4AZD4qʘ,>\Q<.C)򄌏BL&d)38uQ82ͣ6K\(NVs9z!WҖ H$ջ;A<317E\Kߕ!~*^{{|( qA?#)aCNfdwmNHY&~ĕ9ӑv?+uܯ.gA} ,P;K6q!]-ɀ!$>IHq@Th9xtGhf"rS䴴7'+:Ip/ZcSa4XU=z&t*oVo{kO@{OM{q+::Hf=OcڻN 6']``J!`׭"_ Ox[W}IlZqUy2c.,i =ӝO 쮣\d4wt#3OJMH{kȡR@1 f?d˺ߝyH@_ZCG'8v+2j,-FCMvsλp*zay&8B ׻z7&)#Gki)K =;̼K\420eIiYͩBjˠC,cלpBn\,2aSIk,5|/bC $7c T | gٖڪo͢Dj -[Xa KFĂJ{F{!7> Cl4MxGGA'&W0߭aqOhTw|lF"L(֙:B{]ɭl9K V kγ 3ɧci.7:)lMȈ4P2j|0&+{TI1zU^yu]T UBzbl2Lx(C/7,vYގ+GDR$̂mUߘrD|8wGzxP) ̞dÉ=ọ,^ QFDNZ6w( 5QJ v0MAP7Z C,4Vc[Of(ˏ~,ر+9UNqO(DtXl(oqv˧W.5UR,ZM4w>H1GWx>SB/(Q ( e~x n U2"bO4eMě+{S:SfiqTH0zZSyMLf HOC%{=G- zOgzsFJ쩟b/3l|*7 jmT9>ES4O&.zfg.{{>N1 c/lF r'R;E FVa=(Nސ>< !fز^%t$YhwMsO'0]usL[Jj3K(X78Ĺ) ={/΢yOmU ˗1acqb ;&_hC֯ošGDZXStыR ?!M3v màb?4͔l|P棪!dOx .#e:H6BJjK#D677hdQ%q5>h#Ym5mQESLR8H}HڹZlyL'+Cōc[a0WՒH+ HucŹ]}75Go%HM5I^e,~sI-P;ãY{[c K'VP,zL#RPM]3`gMr>v42iR֜)MPް+Q/Yq(!!}d~Na81~u3(@Fs:_̠KЁg"qIp:z);E,6$I>xF&.>32ҟc-֒o(*E&ag(E.AP-uosiL3~ܘ8S&S޻Oz 헔h!4*;'&1Ӥ4|STE3|.b榜1fc8U]-.Q59 EC=?&#F!4 [e;,Y uAI^Jз˯^1] 2]H!xRQ"ßtĢ;'-_쭁5 ` z $5єjM$KneMB^pTNmk%yO-]J͉@h >@ Ym0Y̎n]%8UHo}h`RܔsD/deZr3rc{dBJndd(qV|UJNMa eqQ]++Ny5Z)[ e\OtB_xz q,rH!=`TPoNjX_X11?1@m|KqGЦͿ˗nV$"iv? 9,Gpb7 hx)Q"nOB@Legu2?D = 3폽!O֏|$ƇޘGwZ9RPZe%v3m\ְ_Uou-l8Z7ȴ.IK\9XZ>\ɚ" sdǮ-8F)+E.]R$s:vx0!w[EfT\0gp'3Lhq | ݢAkaZ9#RH,;h2_0;0XL_G͇՞){*qL4򑭅 eB. %0՛Xnʯ4GiށjmMv_W]t-smj1_=I}j 6yt44,zga;%bXto^2GLU vYf<3Ck`( q8^yOfB8WnVoxtZi"_-ѴԋCt|IiN|ZVV/CkN*Q +T{/Bbu<܀..&+ RA-dN:c4ߐ$? GC' 䑀"eūL3S]w@n}k)(L7ex?S0s"4 P}u\#7FmDׯiM&{ @tH:$%E$WM}! �˙TV~Fkť'58f :PYuۭ06}9S?v4b=%Q;Zj:\@8F3&;a䐄\kqw]҄XiΤe85vGpjRW [-w#[Ѭ8ry"!V P7 \:FG\ gx4O:HvLn?{O9rULaH;kKpy>O1rq e J__UfE֯0ӳСoL<,vz/A))/ /[ /u[>J9|va@Nt16_N-m ]7xv:M_{kCւ6 rR" "!u'7wWW}0]YZ` ;BWSoL+,goj 'ٍ <̝eWO2@k U%ͷx\YGjBbpk6X0IG7G|tu;X*{:Nkxyk['"g+5ޙ ) ڑ)*'Hʆq~ߣ}|t@iPseI6J@A FQUX,Mi =<P9r~s4``Vsf8N.#_L3 GNqK:)H2_πhcuo r#łS)B ñ֩2Kvkfw]C Tڌi8Q$5k}xGXCh0$8_T2ʓAV<7mnX4$&NCWQ@8@ 4/AA'~-ӘTf 2Q5%粃"9 Yս%ʂe1_^EQF#vfIϘ)I-IHa췫%nIcCp̖l`ջ vV~S6=28I~lIXn,aǟ 4c}@X/-+y_L*~0$=,1Uec|a HSG.bY:U>݃{)q݁ST,k=d1}h(@eWi<5+%Y]]vi iwNks]]] XNwh5RwpSͤl_\n譾$J#w݈V`bs0 ,fi} {.W!gH,yxh4̔2 vUr{&A z׭/q%«QF.WyXዟH Y5$JO?Jsg9d6ptAT5ti~Rw +?:qpZioE#wuKuDT)y+xRcZ?7X9z]61'9z fnj;vFMʜ2qJܾޣPdvG|,:S:^b#<:rW hPnS}rYfBgQ\|'~ *ʘS㼁v%՜S|s(p5hT:awv@`*QőЇkĚ {_/t1g۾W=)֕ [rv|5F Dߚ^4>\qqgsJ|i&0Ê;d-}=iwMōt|!+ٝJӟ`,fF_bٱVDH6mӇ F(e1Aȵt6_9ɞ}6Y!rzDiWxm9AB[zbޡR@c«t@>,q#Qi3%~>S@&5XITY1'F5!bd3,?>v¦AcPPh̭/%\mh*ڈRx@Bm{YvR8S8)cG}sݱd cTLsB"Tl{)LsO:C"-^C|K@~`KCr@6y ئ{趹}šWs( c`،ewf'=$z@3 +0|9[jK"ȹf_RGzLne+r(+Fv9pFs, 3qK?Ԙ?K[~Ը{Nχ{8wNDdSGIADPj A#yA6 K[\S_˝FMgdF|][KϨEN(Dt6AP;*UEրk|-`f_VPptIUAF^bYa*RD̉Ds]`+4s;FqABXN_D@c'%[MR06. 2ʿ[pLm&@sUn~ x$` e,ᅝ."UI5A XT_]mDka 4wNd#hp8JH%#1c`UZ7#):(R~?u>,YX"(-X3e怃'D-1JSz{WK*aٛҾ")6^\Y\OB uV%ΎG8LFo{ =ķ5?}wTE'ĢoJ ؝)9ܼl"}T/AR{of]i9ˤw/g%bT̞Or/ik[r03Ʈi`RSw;"[25$ y#k)]tu;CwV9vGV;qZcqk%N?mw\cq̆= %d.MB3=%AY[~ئ`˺ E/*լ%x_SeFlӵp̓P) >miIu0] #Ѵb%JG r.dMǁTŏ j, AjϟPr [:f75eP_҅q%=CU +yZш. xǐ`ơN͉-4YX-VsP}fWBXʺ$<fig!T@+"LoY0o~ԡa?ؔr]! IdgzQAނ)c=>s[گq,uOw1TbF෽@/qq-qjp$? mhQmY-Œ>fBoB_}I" 9+3:VX-l5Z]Bfp@r6ob᚞[J d{>ʹ9sg&;8Q̇;X1Lۤ#lnG²o$` +G8e}BT'M:oɍE&V{=7<0vG(Lb%ЌRxVX^"ϫ/'23D-hUjtyjNuKIYp^>ɲ:ۍZЭ|p/lݕ]-NM @1Mζr11?n9-|))gzl` ߱N䦲 2yL3.gwysΙx7MN„/'[2jh`1=½b0a 3ݽ󀡼Y[.Qt.ڂ֎: r+\ ⫢L 03P( G^m䩟 Dny"^+91u12uH*Lvϡ# {r::Qm[HYE3llr6@{GL~¯nw۹NmE2 W;qWdk)Plftڑ5* w 4,n '8kw1tG vR+!%CudL2j $*p?Yߍ{SUޒw̭SYQӇd\NX k \{]+-#eE$:fvh<#u0Xǹ`8tlqӉxdyraM=AaL7՞}ʺ-Q,c[+υ1-guT]q 5!1gTkb_wn|[^s$;&`riWF]9*c$!Db"1JEnHM*41C0${{z= >dE\y5n =^4prCO2ոsg ":o4oۢGySЎ-9yF,)UydEONlҝgnmiCҷ)2VTvʹ韗``햮ﻭ]0CZD,%J˾y!ݜ&5l&E6urd3+$ ּBijph$^/w/pdiiSǛ9L9 \J_ri׋f4y494-@{)6* G[UoXJCʸtv@(BON XEr=*㟼'6u^āD`xu؟Q.">㋮g#[7'+cC&$rb#Zd]9*w=7`|1BW^5~lB 8_M"j;b髉N3p|! Ʌuo~j4Si) *P2= ˘Lq^d,_ "}x/Ӝ'LnvZvc߭f/x1\+١9Xba9lx>deq?:uIJӟ_,$\bjRqQ%dz@'~@e]2vhƛ]k @P.|c IXhYD?~dl<_u;1.lj8A2哈,%~iLdz*ؔw/Nd5DrFquBDnfjv?> hIT|ey8\b P}Gȃb_+n)+:}|8x,}W8쐧Q.W7CmP P}M<lSt j-Ǿ6S9MU*n YP~z;1 '&',ṅZp920y@o :6=ǧ!#4h:h$)x̶EXY|n9Y&=v1s@22Ұe.RF^h:4g4X^7B~ɑ4ˍ:i퍮3s9T~='!&'+1ZuN`pB-2WWik4yP_^"+J Bo N{Qӫ5l{2Q\5PBq'Xs0y] W(r§fJ8L~hj[.} gնmwRp.q|6" Ds=S~% ߰ l:},I3.*  0gD$vb&qhhhZTVp,Kl4-Яb(AQ PN۲1,3@c%}=ޓnX$^@C%n>=ԀΆYK/^bvd|MP`sBH|ס;j2{ {XqԣnRN63J&C(߹Owae #'+$pMG>9uJ+>H*w|_,b}1e vhC"IXrߥHؿ̮(U4/Q1tझ@O'zg`W>In"aSR%i1͙ىʟRAAν2^@wXRn~7zY~Sr1E776hp"N'X&&~e`1K=3U%T咩S~^*Q3P0 "1zvZY瓨nHU'GK,(kT)m@)=A788ȳI0@L字IO;n֔C3_fjڿ.|/`H1oy4҇Ӳi>ԐU5} )9@/3\4tI '44Fzt>-5ҙQM!NWvuj Qj*ks@ &d~q2u=u8hGetL#ﻱJ<}`S]6C%_TF"C-CZX ?Kͥ0˱N B o̦VPxI-\|#Pl\LMR#F}7TBg7CBuS 5gѨ`Fc g7,SR\ވRL6SdW}.xjI)1޻{YSbO*)cH5 `8N!nt+^~ /&- 0MA=iȃ/MLToRO͈LєAXDXp*K=#FTW>jRy靣YG"[͋A·d&H ;vYHA=?κp+?h?sdi+'A쮰(frۓt>o>gEo*;E*HEU8|7mU`<5|'W{KHjk!'%0޲FzsֹmN !zC]]E.QsNf0'8>d: e[&Q@x<3'H'^aO=;%$WRW0~LE{$5ƥޏ.d?>T>vB;zb75pxuk\!6ܘRMUgL=B \l3uLsϾެ!ƪ~7UhE&{ChΌ-2]ס(^3nV$sm!j<%+Cw?2/_ց?ecK7 /-}=3؂:*f_$E7,A|>Uc%z)h6 d:h@{ɠjuo#q]}m̈́1aqpUj$0Xr**6Gy=S⥧0܏$/]KŸ7hP~t9y mB c|4f) >+GK!ipnb2!|+ ZBK~ˆԧo>nGZP*Szsy0}fU 7=M{(/Lj5f?VY$7(~ӝ 銱Z+{~ o!zܿ؆6&WÆqI`PDz8hXLP\Y9NEi(.IIյXO'nF=`W49h>ﰤ"R{ +{&!8)<;v%LXox4y6 d}v! jZ&:gJ 1i{ T 뿐;KI:ٓgsw7}^IyBxtp] VOf3^䑉MA'$)>p|gkoa'&r!=DT-1G)f%gD֮M\4zǛ _t"rnf8*_{,; #{_SǽjvbxnrOΎX/F4 ^U#*l+X"B Zۊ f4aE*Д7 Gdjx ) ^Mm)"UHvVa u+o;s'([G߫ w5!p@_B^+ t|] )dw8d(V"WBk&ޠ;e5عe7D{P2 $.adۣ!PKU;3ů1 ;1`{$Km1})hD9 ƳlC=RCF=w-MP[[ մn=2AIr) X,o5py'ƭ߾/Ls'ZC?Rr#;X/kW3F˿DhN k3]w_Qi5Q㬄&*4{[iI``R}H2? _!й %d]/4l/p8Y_$kы# /3i野kuʃd%ފFnd_qh37/?&&3 W++2J^Z=77-I'E 0L()C#-^%9#,}5@s6G[1cx|L^~"~0#UpĮ^v-A pWD#VxA6=4-&4.jyb{uYp|4|0O?6YQ{U&EbuqeˋSG" ^Kt6KUdqgM?. VU~1{Xvt}^ՎGIDX'Oly"#r񿨎4BVlsMt1 `G|Nҡ*.ᩑzBO\׵R[g}d #V +M_ )uKC؛|M_9GT ojθǴ,K *ZgF7C6Zx:]Y\K:O)fⶴrk_TN7F[c5@'3:iJDD#3v3a mR` b>=o/OHE9!OBbQCJOSK_k@vuL5ko-l sß5͖`k~,>+ȺF"ʜx wg_kӂazέ(*;W ;"7289)eC$z;G:; p]!>kLtl0enK'AfkBȲ5Sc`Dvwq?:Z5Vo![(Sh\&zl!6XgzkӎaҶhA1G yb2x ؓY폲M;ffA:6w&=ƈ@^RbnN-òǮ59^mrR8Z!"PJ}tp1xBݮ,%4a_='W%&/Nq~r$"_S]FTXq cK DJ)2yYHÖOv9.^Mn_lO6>NrB nqftl:FX 1 } e S9G..$Y*T1W|F Ixk:'~2Ti%j吓/L?R3_NG}EnG癵)&%h9U4}vpu`tX0ӕeH5~/pgYӼ6aXu#Aض`b^ɔI=(*W͙e@`@dI(F[WFY1B5q nFO+I-yLk o\yp)x DS*֗,HNLK}jl2eg v:4Щр&X)ocgCX38\LGYS|MF-M9Zꮋ2rZ'mEW_ RhZo"AseuU{yQьW s,L,,.Q.8#27UY,ȹA^7sH!D!3HD>̌F)[<4umA?+%`J,+j KZm+%F 4Vd_{(W,ń!tV- âξD|`FP d|e~z,-1CA VfK˚g0)\5R#k-SgkJʄtCԙm:=x!K'FF|ynצ#ؒV['Z1lQ>Ҥ!8iIleSF~B>ݫ⓺1 hP`,hb#T E5< F1;/Df0&Bg-Ж.SDüǃw'4bCȡ4y? Tlk>+ C,tbh&<*{aN.>ޥv~1OukM7qgmq4_Ux?ft>դ7ja_?+8C˩L`LLP1 ϩ%99:pT^̼14͒sǨ.[򅑉T rgŠeWYD{-IϮ!Uag4a?mpZFk*IIۡlBZ0@g ST]; *s"'IaŃf򘒔Ќ`c47|¦4Qe[zrI͋BMH=b_LwLEŎ ]g*|wIse;X/ ryd'ܦ|;T]Ljvw~x]zˏ)?`Y,g"//Ȟ$ ztޙ*_LCLj-S4KHG븽LZص<ޛTZzpWչ ~u8{XOsse^<n P ;׌ᐏs:hK|Kû" M %I ("q&]YبLL8J˜><6J#V~WDf9Pܕd}F'ś3oF:hgp*K~/"^R/.oۿd_.YjEpՊuyX+jcwXUڷehJ*$\ɂqKKNա==/YUwIۻػZQzLS?KWE!>qh XMqbLJ[ !gYZPerl-APIReference-0.16/data/perlapi.5.8.4.pod.xz0000644000175000017500000006214411653441731017452 0ustar tseetsee7zXZִF!t/d#]$P cǷ=[o^ɲh%*Q}Ԋ Y.Ʈ{P]jq>9xtU_&Wi-͟ϽbW`?|M4~۱Wh%̴vHyc[$Gj{9lXko1A>=0ma0 vj%⿌qA`&nHqԢ8Pȃp#FVHf+8TU@堵ˎUv wzmE:L .:s* HCWvTan,5őُI%2WZY qz?)^4G";ot!hcy8@#]5wVMz.S[Z]8oBI3:*t$(&J"Ji%%N~}-y Pn7^< 23byKοqbM */͎:M;H*:4ӊ8͜˨¬@)H/z`$lUgX-֎A2KE೭f0/^ dxbq%hM',f W U!ZlouEMg5X h5&ؼ^sm/S>C#s8^p3$ED ?P+bXa+104K;Wݭ4rc5QiVMp z6(aV>ϓgfϷՁn5,ߴ[?K0 ȗ,Ɏf1ϬdmkʝDފ_P[9X~sda0"X{0׈]OD@*",r DIĭe+ !%9Y:O*M?;o5-II[Xk=uun.4c6UoizWBm SRI>=B$X`؃X?Ƕ,<$ɴHsY .)22@Mž/m 7dT\I*b$r'.rXG])n +3Id5i'.m]ĨSJϲmƲqM{1„oBqi_r|= C tѯwF (5)o-[' [Xj3_z߾"Z֏O-ҝ(a^hbHm`"<]WO!)d7;Cg!BKȌVxZ֢@\TL #$_/c-Fl|!BTS@4Ggx#Vpڛ49UjWzdXkEFxzi&F,0ze.{i;N=n{]2RN}h@sk=MowCߪrð9 M# =,̤Kpc0]^Xk|<E_^Ee l)(olcZ ꦏ&b3x+c(.50jYߝnL|4\+84~/&OtߛS O$7 ]T3%WY Q:IT}RM6- 9Qٸ?;Hiʂ"N$T $ ̞iX"6mAi\o/ǽe}0Kñx kHz2=6pC[?7X&w,WR%X+=~W&ߩ}`|jo%8: cqbRRwe5Ȧ*<8ĝF\`^IDsYǴ527%xZ?^%}ou2߶ 6L\ Xq]YoM6_Iۨ FQ/ 8Y$ pez$kFgE"^3#J ̷LXyA]{co5&a$7z37vUi#Q?> Hq,7oN@ Mv5d5<,'# _בR%ojݦ.E?N\&z+(hOV ܷvH \ۋD 1%mA>jGh;l|w!QKV>j"Sp$ǿI5:6n?ڤH`^.0DXֆj>r3 b@b.\*0DsY1 c\FnyfMĞw밚g4E }oz9-1ٙؓIX`gsOҰR<&3I&v/YU=N}5c1x\zIu L՞q+(8CXe^z|6 >ȼ1IlDgkCay][|O:1Cn6eYޯk)%T"u:>޾cnf:|6 >ԃ7ӿka*9J ʗhPHc9Xx#.HGD91} G8c&E#n% !Zh|AIja7[6 E 6>-pG&(BŀQ:R}wLjdt՞(F+:;-mPs PBĸ}&5tw ]rfMBfjAt"Jⱟ[A¤ CrE`xamiRE9*.A_cZuwWl*CP1>$ðCBOe|Ʌ&3P>T־;v  kTmpFN0=ܽ^u &h3bpgi VC":[*^fWߣ4b i7ָ70 JT" kd_6e4) H^o+A-wYP4T B<nϕ^4{,xQYpFx =RrhP{Z4r'`{bB|Zx U٦RCh3.lW/W˜*jc"𺁱i-fێ= 9CKQŭpئW/?j%Z84+`eF`ITϖWI+S4:~Jn>y_? Ru1vlu;{nc|3Ed% V2jǷz}\/c#K5<" EKf1煢(9N&ulvntVc ƺ ʃ^v`Qs(&þ4u }R{ ⏞4*p.qJʗuxkH> Yp҃w.gz1k:V$ _nEj9/5Jj*fO2Ȫݾأx$V q vZ$`R} s[Ů?O (n@SŦ LhSGmJP"w܅ N(؁){Mpߺܙ5@P / j+I|` ^lco>1~nTgBV1|Z󪁯B,y©tFeA|rBN۰E_pZn;Ґ;E#|U,b!yQ騜;UtZBhѰxtl҄$u!t d?f/ES6J.Uv g5QҼmb^jG+nEez)U@KiT@<^:V\L+;Qh0shB&bݎK}'9\Duv Oӽ WEFY\{&6fd Oz̪ҥ<1+V+'5`hJLSf9,G)ΓX!a@x5A2DbQU%r d|G0(5w5JMu ӫdk’ByHW`e!a6.?qjT l(k&}khnR7gpg#9#&r߀+zd`fC)un(l\SGԋ)}\l%\,Mg ȘFZ`Τc8P5BYa|Y B<%s*ʶ6S@Q:Iw^.iH5fGUM} B뵚\ + BwDGfw^@y$|<%󃁌qЙ@yǍZg<Ф--z倳36F|}g#)yS-%M̕D$<5ش"u].&&AQ1Ά ORh9Y3 m덨wmD|  +vv¬>,Km\۴N 8d\!(i*ppʕ-$*LBHW 0Hhڇ!Rwr&4/`s<þ=BW@%\Z$ڱԖ .]M -'BayO?lʩ(,q" x#L GfTQMxziC_ _|6d.ƤV_+1vDʍg?r|j R5L{*MKNp2[ @aZTBkPVZy@TF\BUHйbSbJBR&uғ4:fL)M f?A"JA-2aNl '<" Lfn-vO- Y4_>nZ}Ma! mcBQń8"xаͭ գ뫇~bB :As5JE<L]#Ɖy]ƌ;BMWҩڍEWnNM@~ dL qשWaDhK>".ҙA@|rbw/7mjRoAX#A')j,X `H*, 5ʮ'`5^J pNYXǐOܺ>9ߟ?U6r’=Ley}&(pHI;J nq3re:Ҝ'b1iI]1ɆrX2$` ]Ku󻄁&e8粛쯿u o4Sin܏»Ys1(IY^[GRbyaOܶ.{AԻqT: G#Ȇ ֒!m9*e5VLq뤻F76Xgb,/\b0z1YtwٴjH[e(Ϸ]& K]7SLGCV;x¾8%V7^ܖ\B].; })*ע<8(srsD>\Pgui kyC햭Ph  Ţ[YN(49VD(8V} ck3qiݱԅ,_#i"&/~LD;wƫLc똏; Xw|_o2$9Z47i)7H(hQj39h7}d@rQB0Tgt(£f;tm=Cz-S¼ëb6QWRriMRX[n$"uz,IrmhvOBMAqE9kFL*N?=9*;LpWdu9|,n"!:*G?4Q!P7H7Nq!Kt|Az*6;mD )E.Yaj3 T1WrD{a952%u+=]F8oExmZ@޴u$;)R'뒾*ԫ{]"K -О30M93gT-q.0-ٮeY ~f1.&~Rvdz ts7Ã-)N GIOPȝA3 ς$og|u|14@RނG+Έތ8=NakW+Qb)vNUy򒏧׸% *xxqag rLT8! MU׹TM=q`(E"& piCl/hEB89FhsA (97yLJ>0*%[ 9ƴ d bYin 29pډ)Lk.jSH հim{gn|gC&BetJާyׅyr#!b:-ݖnc=0#ZQ_ߡ nѿa&^z6FK†qwҁ$<2=)ݻUK;iBAj\(>dӬ/lG4[:Fh:nHu iG Lm2PӂOB6Vgq~jI),qL7\,mgkD[FԚ{ ?J{f 4=29k3&XLVh7ޟV,aQgI|+gS[;rC>8`JGcf[ٍٺST($=?_ as% b{~߄30[޸[w^m^ p(ovBNXPʵՓOEzwۗaҫ<[+`rs-B 6xZOLNQ땽q,f+"άx!﷒v=u/ɸeo0+ttY#Xա"+q.hPׂka^;Ch^FYGb_։ =9 =m~ 9Cd4Rm$`ĝmɁs+@-k (mͺ k&My5yطh G6EܶIN~ʢ溄tϚGUЬj;­/M8z] 7,-G5lj3Q//7("`"$]5PW -zkqͥ |ҟ7k E1b_$ݿ4L B88#" A(xo7P]+G066u>~g3ILMF9m>O?@ 9h3g$u(i:`S:7BC`[f c60)ak}%~i:t8GBa9a>X|8) imfa21B[]F-%xf(2r/T k䠪.KaDm톒+Yk$I%"}ES SYNR@J^ Ztw t2cɳ;4 sDPH{N84f Mn5.`LJFU?|Sh'+ʗ;Xo9 H[lb|bsܬhJzm< TXN&}偺spɖM\܏'Tepn(SPxdiՋ!jn@TRk1$q,~u8gҐh8`Qޒ%e1d9/K;}-S(@Ahtm]YgX*d|-0- \RC7uc33K|+$OPhT_$MDѱ 'b~c.MsCs(s(-]CZ$UT@i{VrCsU\K m6acJ69J=@xq}KȺ9b&Gj:S93*G24 q(Ul-Ĵ0a)6$ȈSbf(!ʺD 9kUDI>w< (8l: a=fOvːTĻsܐX`$βCSiq,Ig~#F~Gq6IX7WiNvwCaRXd|'=Q W4%oڷ Yˌflr_^wCAyVС($ӯ#cV 9HاM)%!ywdJ\ΧJ4LCe2Emp&i/*7c çuWCfȖPocp,+zְtሆ<(25-/86Е/ė?,u<#o櫊G=U[n,C}Ņ2zL4J0S׹'q trIdXօu*rIg< Q<2\.7GP9Ԙ2"EvO~0Y(cml~G:h7vue ]yg\>N+ť&!2cbN(T+)Ir}2%l>>ʰO#"ˣ#NUvNsҜe"Oz#;藍—W,)qs ?a-l},|.D7P- !Z/8)_>i: PLMf[h(ZB: Lp #}7m,[W7WNlRTڕֱԾ=`gY"?-I e"iLߦKD?sugzEjReR䶥Vݞj[B@,Қd`JV hdDJ29at21F`. 3)~3 S`h^ǻ&1H~O)fٶ\ QknԛjL2lk̪Fg1*lX#݁hVP K+s7&BZ~f sƢQUiC9}OJ~=/'FBVDQǪ!ToG2LH^)Oӧ6W+w|iǸzAFFc%= ¥8GE mOu WϋlV)TC'Ko<[nqG1F[N$:1$y#^ uS/@<ػtVe$$3nU9 ~Y^8v!s߽ZHl#mBԻcy?K%D=3U7b,*P{&FCd93N `3(KP!R迣e>Eo͒rXɘ.LX Jc Vy:y#7ِsY%D品*3wpo֑A 0f}5;S LC14c r2%4F ݆Pi734SB\si D[OrS-+d>z빾j{Mibo[Q,tuԜp'M-T]V,% !+UmK1 %׊ FAL쬨'; >u} |{IMwLT$$qqU5[P|IJu\7#y`Bl,:$>v'inEuJgĘ/Z#qɆ-1B%6sZ5+DŽ[IaI!YXPzFS?~95Eoǡ*hNY ~8^Odv6C>GN=e.ιJ)[ne ~; W@VV<ʗ¢SA\f5RqMLDžh U fTGW^h2<Sn{Aq1EΦ@/o OGQ8B*N䁓-{AC,ڲdB!݈r^FyZ|4CLkhљ7 L|% Ɇ0F\]8oXhg* 2U2\_BB bxD P M2# p)@+G;oTuQe" π#Y7\,/.}NZV6-i0kgAAh~88t\ sA؆+fJRm{m*-49rpP:FsԽ[_Yo>!6j6-Q@rTfgo^kI |+Eؠ`Zl 3zoڊJ ʭh%熞Vs9Q6BɊ9%ӑRN6cNÿ˗ ^]t( ѩu\BQ8?X6)\5ځ/ {,yguk?G'\4QT6e>Q9wNpa, 7{o!>$?y-sg9!U Wg!<Յ汇ǥ6uwQB [~Wʴ$͟#:00 dQGtjځm@R\C!h2^J;^eDF,!jA_e57 @_l]@1 P?br?q.e;1%uռ4bʚ: |ҴkATM^V&]ldU`WVHI@nM_[-0X90 $r&ym*sTMpm> 5k'Tv|1^t[Bd"9gawJ8"0JMv gv!B荊zHJj~z4BcF)x~/Z(U f7r*Rf,IȻyI"%4DT8fTa©gD@J[ҳOlL&Jx5enJ$tk6Յ6"c0YR@+=ʦ9MHKEap]!JW8[&ڹNs<v"^Yy@Yﯽ0r1nJw$0oW! d[! ?}b9a!%*];>>5@tKx* jFV |sTndeA֍8&C2;oMZjאf~wфfUΜAb}Ϩ~Y%fԶj^tz<.Iqj#;2ne*DAF:gG`kO2yPj@31"'"V%sH7y3*{[[OPOmg}@(O6`$kV(H[Qnw2?= ̉\+&qX]HZ"3dkSϿg &+mo,~"]n@t%QF 6.U|u +RɟrGv+٣jm۷`Nlp:QTvzD$H,O0@d~+~ג1JЦmrRDbq, 2g yo-Om],5p 1<{5OKn3B%!CЁx@|SjkLqy V'}1<$QHoe"}֒Mk:-EoY HI$%}PQN#!bb4wQ/ϠdGa38tnzv v:tY7@&/Hߓ!^n ppR2K7şˋѓQeF\(aPNe#8UX<W'l0*lp8ICtZ>qGRz(5Pd;  MnEɂw%k$ȵQM˪Ȥ8$@SޱN \BW 5eDn-8p5aak77 Y6ak ׆ObIdeo*q| F ܫ2axr6h[Rލx  $j[~c׏g?kz &js KT{ڰX0yb{bYy1,<9G"|Ɍx{^m5$~ʒ7^ [ V\1d1kP61ȌYbp'Dkz][0]W +bZ%#R{dj`"".F^â{,bջ̠n{nLߤBlMcIv`hܱ )sܠ}9hc%n6Mȵ7\N.!Jޮ7ETiG~ @\ %(xHwo mtIaP&\yX?8X:xb#p0 \ǹ"$-ᗘ*y+̮W 9.KVq}hȹ$siYxcXN$dLbPXZ_:kwؾiPSC;A hlۓ_D ]{ taCapy$+ Iz)!af5yVk({ҽ1q%FsdPv8`cV3eC$㏾xZkh1 q:jvFaw(4" nxO۩ӄK-0x5r3ܻvI9՞<Z^xV!HHb`U(-3w! [uNE&Yy&}Tl/147)|@Q8+|\1}V_LK pq;2;_3f&fknSt2\{y'D1U=2y=Xb>ZY/mB5? ݦ\prS}f9ۈjvS{=ڷ,j=?aC5h2)ً|mn/vz-ՄÃ۱yt93> iZa"5ydq;]E٬Ɂ pXUtw>PetM-0f0ƴ"I<6f%dh7fE]ƒ,a9rJYf8}mxbddÜ&dݪ#:xuW#ysrR0/nP*'5CH0@'F?0Yt* Ee.ą+KuȬ Dz+,ڕJLgٟ W 6Ngc[aiƳ<~i`xBpx- u%O Ear1cpIr"ˉi&lm =1TxDJԓB!'a2?s+vYcwinBK}z eߕNgA@־5Sv!y_%ݐ2:Kq)[ib2A`#[+J1]Q/sz!;_W'lO?qS-7UA@+"yP6~6C/oǕG=_iVŷ37EUSOF7&uK掎iwG_ 3v+J<ְSDn7Mvk5Ѧ>͙U?^FkxN۔,Lw5$8EWXn =k x!Æ$ ]fMQ~i^%MC&xqtͻ:2f9#x9*4eȹ }yab$ cHA04{gz$s44;m{: Kyò|˓h}8KەO[ZCHl쒼$Dn삋uBoҠaԯ9F CoW|x GәJ~L|εf-Ts>4rܥ1,CWdH-qK6RTm9 gǔmT!̞%jHgOeEk19صD49chY0XZaPNKҚk»9EZ<n:Usyڜv]:wo bNꤒMZecA,s7 ys;g5G9IiW`LJcHy)^V]+FSvߦ /|x[eJDLvxku:Ȓޖ®Kz`lhۓIyhX#D)u]K v]=A^ 0a|::ڳcIU8VepwmQuXې?iZ G"9|cVC$@x]mֵɇ["|7$bd4`FWQd5m  z UcT&YեD QF~ԈG x;tI˹\FcGL9]i=ԗH+@56@ ,`{p3k /3q:9.UXO&k\똖 AyF`TYFC3JgʞJR?0w晴r൉_\H5so4>)5,%~~mv0ztvMx,|3F I֊ذ3:7aqniHᎴ CAlTl_29g rM- p'b,+Bm >f˹TCZ_>W 7N+Scmb净ăz&\=ܩJݶ61g/TpXRlb uY fL(1ʺ4T&OcZ\}^9z究mNf.(5֛Y!~UZWznssC},:S۸/ڜo]c9"ɖv)|HJp. %+pynGc&Vj3S-t,I!FHzThh6n*ᕋ1;!Ӓ 7q !5}~rD 7P-TYbP^m%;$bp{P'0n7_ \N&FSk}쿇:NˈEMD2Ӡ~(w+߸{r_tsc x:gD^;hN<6%Ҋ|t"dχdmfDmkw>3,>Hpϐ#ooD3nT8Z-D-iwoס6SoȇLM۽ ѮEܨ7qY :^2k 7JaÛ •[{|jk'`hv-<\{'9 3 {ӎ/t.h@&bk&uy5Xנ:<[*緅pw eL9PT޶t_2ќLtOFCCGFZJv]{́2h YW D'!w,լV-~37_Kn[`6`ȩz7瓭32hSP%qmkΞ0"s{LNU}7}ӏ5Ӧ,O=)TӍkҁibL+#qٖ2%/.EM?Z8{P pQŗ}G_PX訔8cVK_ڶai-;;q;(cN%zS6x EX`Rֲ=kZnIr0&E_>J9k )|$=JT֬F]ej>L{{>ID& Ί*-w22w身 I|} 19TEqu2yGæ.4`{Y"P,닉e2^L6p2=zdc N?  cTREnvX օ]pC; `BR@ 7\weijYaJ4V N@$`aiB[LL3p֡78دΠ !`Db&C֟OD»-`750#cN6e]Zg1F;=A'DxATO]Z ]mI)$|# -f!)`8Y2Rhlj/k=D`"LG]*&Gf@ D94}z+2yg({#3$4͂s6uy~~iY͊zZUC)aN-v1x5E.|<>35,2ivy"NZgjLmfK pWnXI;V㣪w;6~&l44-j?Su.BtiB0G;P5 i*Az5c(&Z-0xϪFŅ7,'? e"ަ(vNFtW[GXUXf 7̻*yrHxs;֞zu~9~7Vs+k֧? j)%BS~ZB9Be#b;TO/  =ʍSikx{lL88qƃܰPø rq0mO$Venb0qA5H{N2@z&:8@_/01|Ts%bKfN0QGRzoYEc@n/ ,NJt`J:`-K̻^(򂍛nޑ#ʋafxs6ڛF)%Q+gZ'Rp)LנS 29N1BT9ee@ΦV@N=J{B w7]65HsB^]F+3]`31oy%dc/v|2R~h{ @^We+>3Lx3:PYu'P\,hr6n(^I94*R!ؕ)3m"] +r.a"1*&`ʢw#7v0w mc Gњ8k pNo[dt N4x[g:#I:pt.Z@8wFg2)@] @RCKm +q9?y&륊*-۠w!7Db~17g?ܙ*1>JGI@IyMZ$rGr=Κ4.v /GǺgYZPerl-APIReference-0.16/data/perlapi.5.8.8.pod.xz0000644000175000017500000006733011653441731017460 0ustar tseetsee7zXZִF!t/n]$P cǷ=[o^ɲh%*Q}Ԋ Y.Ʈ{P]jq>9xtU_&Wi-͟ے"*=DtE0L!&~ؕJ"W˖?*X[ً.-Z9agEMEcJc-j(e콾`)q5\(:hbi7DNX;aw: iŠsƓ?"G1XǸG|)3>/أWsrC2{Y [R1#M7N\c< #V^gÉ{zT/ZeH*\ΣϰlV5g!N{X6CU}vjMމ!%)ˆ_2B3V x!OQG6{qamɆ$fff wlSLL_-T6f1- 7a!MN7gSxi38w\̓a\<:&zr^&wZt)H+uwC \ VN4z03∧f2W0UЀƾ -DB߁?DQ=Kbj쟧= SX˘9}9a1@fG`fo 3}rV14jn#4gDնF]6d1t7I! R1ոL P"KJlaahveYwwfNAS*'HVXk1#{z/w:q"?"auEqtzkIt&9jԜX`*xQH&M '?닂*Ue㒨rh]=Za k?*fVm6.t|xYOiG4GB jEҔdr?jdm"!g1"b^N)pJHB(Edeķq*=竓ZiJi%9Kf^hԦ6b\ /.m?'HR _&{1thDqռcHE a+ZUIМGj-YIyQJ<(';zc9 ÓxY XШ0RahSKp(mJ *`pZs U4@^T-_<.ŞZSA)yGՔ_R[lGmy{9F"'7+^ fU\Ά&q! ό53.+shG 2}l AAbu6.LJ``⃴$ΨƨJ!F5 Y/}]:Qr'#橼:]zYtd%єbbLpyzM5x^j=ږ9+vh qD4#h6m1w(݌ xmvnvԤGqHeO\w'pMT p[y.۵$.):1UtӼA7HuRs1\m莟bD ]=^3Y_#,}=ʂcݑ*OͺIn'PjADYqG-U\8US@#iB=vm^Ƥ|緶J*{9""!^R<.׼C\GGߦkDYRZN DȃU>$C MPz&iJ\I沜b@.Wkm͚±r#_I@)GŦM(tD/!u.iq[rRHꆸP %̇}O֜+t~fďj,6< [@/{T@U]y8OeL3ǿ=+Э`YNLӛg479")޲4D[4nSWw^gП;Fi"#{<+(5;K 2_''Ji->mټUZ 6{ !p "+*}p5ϰC (,KX˅B>DAEۛ>So~ 9 ~g@l?jrq˪ H:J%k| o =Q |7m:L aUYꇗ|g7I+Te={'J .x@?'A=ۊ+ѷښ:=h07(]/Ev)ܜYdF??&.->z-,k)_b²ka79T}I>2 |Ibn_'~8]-}EO"j}6! Qj>l=Q?X,'ɶjS+ps=گ qa:BER_6UeuE85gZhsWsXƒ ]V`hEhhuRͻ~ı҃}ʔZ',]3y2L z>{&ļv=M1:"~is1j5R?0I&csW 4imz@TêcN?\i1 7S41ɼ߱zPXc"^}{ ^Ie7^#/NdWP[X` E`Twnu Tr_ΊX*1(vH˜i|9*J a͊ :yu0>"` Q_Uzwz%tIk&Pi~!av-[˴:\D+hщ/뒇]8H]ҁ#wׇ^*Q.BʮD>כ i(I(V~x>jd>ߠ}#:c䓭 ES tE}RX` 6$ pꂠF.n@4LSh:tMn1LWFdԯuizE# CqN #ۏZq6h6%סּ~K%9 &Xsp.yCӔV̰>ނY;vY+x.wd \ @H/v,HN8,+r 6'`K=xO"rDx?q$;)}ܘQ&E!zƬ&ؽ}޼DҨ{}NE` 1Lj]Q@yZݷwKR]87L쏿i`&QL99Z{CUWؙmU< 5 (x q3jE)mJ؆*AboK`$m~L'~1EUS6WDx6:d{\`He&++x8S#Z^r;8o9lFߎ|p Oعl[&1;Gb"Yh)z 8-#NwT]T6Pςl,IE#Ŋ4Q)a1ZQ(YSnu _49˫V>}J niSE–/ϗB7uir׏gNuaF{nh| Mk?GXz{ά*FχƳm|/C_2= L{'kS+&l^.+칆Y 8y'1k%pq=`2P-r;%i4(vjQ~ea0!=r[<LK}Fި;հ4LCɤCu吱z~HM&?cI‡eF@lS#H'Ny"jJ#U›BWJYȮ@ Z>{qaB(YSNE Y5-?K8vF[ xF5ЦWa&pjݛa?85O'2z}p}XW‹]rV41y8'&T]`L!_ƕ $*L^4GY` =qꪰ078KCH u!Lۮ"zhHo59ߋn~n˚jVBLr 0 r$ޝY`%p D֤S_{7xЯe#f)t x#et5}u2}\_kaSOCfGݘLӈ>Aն>ZO:?bTN h-;ƛL3c$N=]Vu(td<lׅt0a@:uZjwҊ0em z;xPuv7! ah3c6D#F|i W2+-R/b!l@˩,{Ɇu*vBIE5͙t3X~K1\2˪5D_)TMyL}'}r}REU %Ǽ7,n!j/}y$j~v[80pQ^{aG5e`WHD7S!E {>iˈhaq53E b,v.nCxg:39Tu3O?28:L9μ`Y*ii}fj󻯻4)"ҶVU%} OH{s膘êf3~3af=)j;Z@?"eUs̾Іg&2Y-srkAE5l>,sϯ|Ag+N!.#P6ݨc!.a@ TQB$fˍCba“ j(L!~|P*3Y]>sd(NH`]}_Qsqrn.CzH͸-L4nC18I`bY=XLUF8 y U p>}4X1Gm3aaF8% lщc2,нnu[˲;ML? ,VQIJ|8qѢ'Y8-=L oq05Jz1 J'JW^Xh 帵:Z#!̞a6q )'~{?Z)|ZR= $p4x+ 2o]-&EjU:9h؀(nzz֫ <3c]G9UfWD nTԑGzKN87Js jb#{$VLȲa fHŽoeP<=Nw;,I`4J }1CC ZuvMq.*-:M<_6ꧠ?m֎Qw'Ş!u{)ȖS%%ecˬp 08ao]&aE->FģW?Af^,J_V,V W5<әp݌fY+EY5VÓk& _WM8捓}qc=`M 7Uw~ϲ LKcEJ#.M ħa6D،FZ:mLAj7S^蕬e%TXrWMH4ڻiF$7~I+:hZyR gD5Oǧ5Ҿl?ٍ>޳.a îdmz qMBhaJZtGSӏc]#z%h')z;^$SR4XNkYVUwkθxEFPiպ۶~UGQFEP-MC'[9yvE(pC;@&>qFmK2.6+A6%;43 w/1ivkn'".C~`Ul/rRhZ>R񩧱L7kR[NqjYXU|xf?jbL(9}kƽtHSPͶ{FGv|BDU Y7 >(kū`ueߎ"dD߃^%&3xp\ uB 1 ;iJbg}!^OjLv2 JG@ZS^Sq9Yq[cTdQg h!@!J2q mˁ$Mld8g_ێSIFUKZv/@=˵H mw1y8WiFD6+luI/d٢OybIo`p&G%>و*0 $3k\~#F5fH)X]mR|Xyr51Uqe4;z&/0B #wHg6Ƚ9i50S>0kTsss"NdY9e'ծݡ旄7ͩf VUr:UM0~]ͩ~lZQEm=m%[HsAut5DDhW+3H1gLaZ.KƎ(|;&Io%QLba?=8ϢHMvkz"$1dd|7X|୔a띛ZqUbE]bU]sr)U2Sfk.# b:Ke Q#niٌL!!mJ)l[{^x'7?g=IGJK"Zu %L -H݉ w 3J>4DtX Ů_a|Cܛ>Oo#H`~Y#.bӃvb#h'^FxG"`L0ΣXk]逋.'>'ZHU(6Kkǁ$d]$+IV2ձ#`!50 d:85#@<ԅ呃;ׁLJs}9*|fʎl Ú'ij7:vt> 2gz*_5uȂYs:0߲%p͔v )[d'0#}T)! 5)Iz8~V'hKID2_%%[ D@U{y{;AJV*%ٚ('a2 OPRt$,Qr#l#|`<$zprCR_SITclbdao Q+<QَHmC]_4\7OI*~ݢgimc%O+6[e3P&Ĵ D 'ό1.30i4~h( s*0v;'}g ZD?Ϙ@)  P2 )1S.oHq4;:;|S*ppY gQ!NI{EN&1Ӣ PQy;B:.}j*(9&e$%2{h9l͌鵻^ʳP-›8;qeT`enmH&kxvXۋ./r\ISQVW՞.r' @2hUфo0oiDJ{6e~ѥ`f҉ن*soq lLN|H9 }f[E)Bho :+>(LO+ _ bAtgmݩ=/qSYؒϟ>Hbf qy8N~A,G}qASp1u$v[lc-|[o8&,=A"YA 60WuQbj޽݋k zPV*g1i~7`gj`6{4DV!\prU`tJN=!?88!|/wX i/,bɡ5KJH{@╬tt:Ή/qCp^Ǭ0绤E*)HP.Rp iЛx%դ}5{HDlz/ pum$DZr%1 "}VVoQNLa"&bk묪?@GH]x%Sf 0DƠ{>_]E"Dz'\ۋ5BR3>㠻pzp Aߒ/DRx0ZmW78kEV<$]RiQ"v7gprU>^ fR4up J('j/@2`M'Srpyoɀ;*G8z` =4/EͨtQ C/0`# n-L똘*m vUn=HF*p}Q?f'ya>Heӂd=N!W\-O W~ph{V>Ħ氖jٕ9TS(Mt[&0z0s:Y9Ð6V rEy2:hVKGJ!uj |),|[<ܨ?BY{ j#xf` 9NGfNa.v~2[aXIgWv_NJjI"qEm9.\4=yt̔?Pe.T9"A6>Vu죶/(6q&".W @֍wSwP/Ts1Ź.pR C@ ~Q(FREyQ8Ϫa)p2RAQ]#*[F0S$k&/~+aUː5L6 1.qp?W!:Ԃ#/?0QP F.zr0-oqvuY7s=2ZdCEϨ={'ޟ烡tTl^jabD/\(O=C|n6 ZxkjФQmȰ6MUK8x)tTЍ-ok`SMסyxrǺ$|?U;m!Z@-8|ܼt+!9 ?MvŠn BN%R ɡKj<<V=AUF^$g0`G#IPr `LRQO~ Eu-2nzHFn})Z ^.%t @( ~tZׅd :=NH9ccUr6|.x׶kgBPE& ~_AKk B]h"y8~)jb/I6w2)m)'Jeם/7XJc:ݹ?QϺ|.*>oټqWϾQXUY咮S?7Vi2gJ~ݪJDEHԏ6-iNcPݮ 0c/"Ҡ<"6kčE%~ $U:gRn PRyei 5Ӆ$ f^RPl3vg22+QV6! A%0#\R׏(hipFWh5*L OG53G lτQc;0ZH¥iؕ\ Knƍ+VY`$D_J@yF/ Lv7̺Q{= |Nh -5RH(Xf 4.b'[ rx:YS kHM: 7ȊNٹ; ^~v{*_4^Edqjn?i"֣'\ B{(WJ=%-7W8_òh1=DvMls@ݨٚ{ C~2zC_G5'oVPIU3 %DBi/$% gԡGV DЎ/iʿ|&hV#"f B3UEPٶȶ'ub+9SzM׼VT|Tz|[ BR48q!iO  >nۦ^'HBe.E"`@#/v 捖GP^hTk< 1;V5K dSdV9"#͒`Q,bX޽>y,kj~r5rt c+[:.LozWo,hK<0d &p+纣e!;5BMzʟy1lCzv|0paXkbZ|qO0ׂ6Z5+GړY{G >o=4%»'Km=̺x-(1 ‡3/!d&QW>Ob2:_℆`C]Hy_/BUC>Etĝu)t^- m ]AlS 9V5 _t{2ifbd0ԃbi4>)f[n&YPۺ֗|wⅷx~z 2;hcNjVBBa*Nj="Jc2 v/ziw0$Vo.Wo&|0.8]G&jt#>Zg0Dk @XY3hABI#y #mu6v?-DEOG)Ml=fgRTWvߎvAx!ɕHd5-#/e8j>UzaˤTU,LU(|đ";kǯ F:>-TURۧ\7O( .&HɎ!{ysjH?<|lT囓cB&!$\T"sG2b-i>pRy^!D#|o1ANKEA|n@'v4KA%wb? pTո d +_ \ze+CK{ 1Qɂ{`Y^}GI[zTlY7ʁ2D&Moz|7lF 6rP=[Ab bp~ <k ^ (Wk}f[d$J?Y ͮ~oMZٓ8g?߼JH,x `N3:u.Nn@/ξ6֛ȿÁN'חsC,_SC KB 'r;@nl _^^+lxve1 fGgL!^(~LoˤۊmV퍾 ՘*dAXT5{:ˢY5;l]kۣ~UA\;b}+G&ґIA!CEZ!dE9m#m1!8!?ݕ et/[Yhoۏ@r>&("d룼r 31At:>i1Y6q3fmLzM snFeǤz8 [k[C5,d=6Qf=7bJa/) ..ahoCnqlc7ya9"vK;=O*1<ģ3⽷}X*U۸ \0ʶLl"O߳O_˓qD^KSvTU.Fw?4/ ds0Ay%Geb~ón+H::.) K#!ˆ@ 20?@@(zjƁhX'r8c.<7@̴F=!X"DIjs!w#8ꝉGFM<+lR;^ Q'Yj]0mOq2pQ0I`t$UKe{pbFo7eIh*Z{F0#/X@awW7z:"49/ͯx{XaIB)=>$?0qeZJE'`Ɨ6~^C:cC'+[`Jb](Mc݄Q)> ̦#!o"6U?^ӑ9:yl.eC+qrpr0Qԗ \N5h(JUܗ^aUvѳSZT[Ri{g&JJ S4f0a^ŭ8.v_ӃqG§f WDd(אY8?]xٲiq/Aju9*H6Xnͻ?[bQȣOY8XEɳNP4}YŞ0Sሠ;B,FZ*+h6NPʵHNGiWmweݍ]mV-KΣP y3CMS) 'iDBbrS@ @ 񄾫SFR^mZƇ49zTGTCeTig 0 ^bBSV4A02^ -r>x7aْk 1l2g#=⬓\d3<*uӗW%-E).Wl$=> trǻKF'Y_"pF6%6 \Rx5gUI7Թ#vGWT@b ;:1@ZW7WтOdI}L>ҡV34=zt=90+nTvʪ%%]kZ`[m޶{׼[}OvE&D"jqu]44> [IvbЊ N(\g<5Fn3;/@C6`v\cQwh!"; eC:|.9 t^0 üA~ҟj7/dES9bݴcZ{sW'7_hy[c eWDu;q;S_0)С{}0q5BYKquێCoK1MI$Aǒ3aBiȂ V!]D)tN;g-e3n.찰ہ;{A?CvBdzDAs?:H*,)ǡÞP7= 6];pw/ui߮Fxd@Q][QFʧtRA4v9`,更Tm ݬG. /׫`Vgi㉙w(}g͂u"JQ~ 1ȤSˉ< 71_x5X!&:2-[59L kE7lMK\\?-}\BLvFw-JGʷ#n|@@O3ty3Z {FJ#V-P򾲣hh `5ʴЇY?wO{'#JN mQԤ-Tj#_ue҃1OIw"yEՂs7huj~ _#*| "*֔F}bEe0@X\:闄]*@%$fak<'m.9 EQ CpZInͳB!oN Aaܰsqz:< \n$7rn /ɮH v| V٩>t  YD"MK$FNpGMd<{w'CQ5yt@O!B {Pq) eC )i'PjS0br+.f?FE.I%v-@jt̗6tNj]VKdVmowhHW;|'DfL.M\ݸ>s/zhhHֲM*GZF,`f\N&*;FGx&'sL7zQ3ق>/~)l7NÞG4˔l}/'(+_9f g6EYqFosw 8d/"ziuGA=2J!􃵿' d5^!hH}͋@X|XZ~b`¼()Eu/@ez䫝NN, Z_SF˸c96 @ dYDFɹ >FdS黳_Ng|b&4f3b%*Ȅ I{l}U~ՑTR[_wXDjWٕ+)iTD¥x)(A?([|8,G(&ZO:P="l9EvΓ_yg0Rh[/4dmDHD!McZ%LSwn3̗0,  b%}MFm l_X2Qf JJgr"f#YN~qGw&ׁ@l^rKyaF6}nnoa›R83RE3I (.66Y+sݚ͡GEE<^#2U*"2=wY8ôN;놫Wۙu瞚&LϝRk T[t$[~qnX:1*4rj; 96iIQf ?[巶`7h|]2 _Lǫg5 2p?iݮ-y~w۬dQȬmaym˖юcկq Q]^Cn&48A֯Dd+oq ]&(3ذs4gNMb+9,O5U{2C;b%ߌ:@Ԇ><8/K} lRŕA!0^9f:^AeMSaLD=%U$ S:֣ymV_m?fM T]f}FgQS~}mS7m]Ns&廱ݟ I@d8cI GHuE%-j$2zΩBG*i;09@W̹J.A4I\P^~X^aeG:ދO\e͆iw"<(ѽ%)3֯u9=ݾu܀ NZW" ޯsv`%geXkbn(DqR1pDn©R igdP`? C ҍ!%xa[&i  N>"\f+ 4/mK ẉZ D1ݟ; 4~ԃD& ̽,!{>R1BQ9EͯF/rWVpu[]Ӟw)h/0f\_ׄi4 9.?b;a8%vTU٪c䝛H!c-G\_+'Bhaο:Y˹&#90q;Ku75_)ul] 0_?/*x#>9 .Uȑp>O8ހ4~~A.6ϝ]aZ~e) ?7_eAٻGSb|3,y-P | OB # sGSpK$8 53oK >ÌW@ CLSȲQ1\Sr*,RG^__@{uouz5U\xCԗgYWmbzl)¿tLU֭s>s%4>qŮ58h~¥I#h U/3fkЍL.eDvy\,cL 5N Tꕫq3I@7Sq:8=.ȪW9_?zר 7DE:`#_*IBd"ˇ͗A8ݹ9= o.w!5ύ殰!V~UEեB@oUhМۼbilR^?lgrg&l*Z`Ϻ,] :L,|DBq]1 zsD7=+R<  ;i?A~J  -|GrlZ(l;7'w(Eq"LX5\M9vT"iH ʏX&cgTa8Jf Gd) uK™Gƒeqnhl"px^R5tDaóR(a?R^`# ys*fmq#IyIRk8U1Ycq&y:_9kyb-V$ FUl(!y}B>IM[*Bd}FQѫ`/2kF[CҮZc'Chkb˘S9'z O!q3%V!T7>*~ .#5@L2.R #J㚀z% \X,D~Zbma? 6=]6e&/d!u_"K`@VCalXfCu&Yb<>dWB1m>z3C!`NJ.+%n?ֱutѩ#SSCG*y $!˃*[dfk[#zy۷}>ȋdiGx}}7􃀘@~:-fk5<-.TWL3564Us HIM*>O !]H47~=N0 ^0D{`Ԇ>sl6RrRՆeGzZ(#xOD *JDP]#ر6јnK<\>`"벑w*' =|gq&EYd B"dX:=4ÿ%::o*sl-&&M=EGъB24aNuMiݖk :QZtb^/af 7#@mf: <,'Jfc&>Jވߩ6;1EEdѷO+i+Fs]>9ZCydo&RU]ߣvqdq/vs}Xi~0j]v.Qnwm ںxbXlד7c9KVҗ6`5Wѝ(?t3'wn؝Rh{ENٮlRh0w]~j[e[i[%2MqL>Ϝ\Hw'${ M]r fEr;xv?,»2v jx寶Ȑc,+@if%{?T^,+#vSNX ;K@B_av Y 4. ]m8SO0-S38F_z;C5(ҋ = M?HtV u LM^ܒ%yu?IY]'n0e۳=c3DžjYPʣ~L+U]0"6]in@xx<4/rG2AAPN&[F=XV:aFnb/ Aj1a2I|+LVWS $leɤٯuCymYVyF= =D `7_ d"_PPF=&\cb#LEu܌sfe/g] Cdz.~@cȳO@8Ԃ *!>?Gµn󥋣xjΰ Y0#-zRZZA`eKr}2ldHlhou|NrI-8-!.C4d̯WM.`EmyCaW|كmalC58p_!AKyrwhdu?Gd;bi # cؕ(0+&\a5qR7 jgЧ^lAMB{[摨N7YYǍ/YK[ܟ(`Wsd7m놰S߽Ac!ktigSPHT R4_pex#s4A<<`MR-Ictǯl 8Ԍ+Gj07lw.'=,r& {&ݐjqkє!= _يM%`VPcyOb"5Z?HZti'7X9n<;q JR.Jg;"Xk%)~Xn2ߋUv_֚ymzk$]Pe ~kur,V_sN鋧>jU}*§* 6K$Oːd:x{pH"ii $eNA-cUG]QB?\y'%:seT|joh€ g)1QB\a,֔HW09 Z ʯI@kN(AkSTy$wFK5R&Bn_r:Ǽy4-B j m Vj7>dQH#o<`=Yt%D&Ƿqr2]Π5CA? qv/ pɻf0Q;F 4n7uxKi-b0Ъ(u$Wig[ D%ãs6iTF1wN9 0 6?LByi׳/ l4}m,Qj3=xxuFft(nUYؐPW`/ E,+)5bS N7=4wjUw^\:iQJB2[(ڭkW!; /ܷs rcx5`A .n!CYZQx ѓO8آ<%$weq ~-)g !4{?=7o3eVV{ܨO4Ȑ .ԪSZ40-]]!{(ptM)}oU&nJIޟ:ԯK]xz5d wA|`{۱̝[h #̯y M@ebe @py5b|FGPQ^Iqꯞ=-:# uauԝˆs gYZPerl-APIReference-0.16/data/perlapi.5.6.1.pod.xz0000644000175000017500000003567011653441731017451 0ustar tseetsee7zXZִF!t/;w]$P cǷ=[o^ɲh%*Q}Ԋ Y.Ʈ{P]jq>9xtU_&Wi-͟ϽbW`?|M4~۱Wh%̴vVaozfpyP+ŸI.r q>lW",ΆC-OLJGS*kIFX c̲uZ R =0}g>_ FЙs9= U7YL>!r.FNJO@4f*SNanHbn 9q%Xb@E&}o"˨8D>{p& YB!98/%pbiZ ,rN^p3(Hxe8,= owsv8uaRa+%>k&8!ѴAI?\oJmT }zf8qfFV'- "_Z5QRj >7M?1/OuR) y䣇fU35/za[ =bSq N_gdwFFͨPTkbdPͱP:>P&a~gvZreFt #u,u(P lcB[KN;YE2A#\|G/q|2v[j :IFSH&>9=?5M_j|_NJLJe aX(P(oF>&[5Vw~'Ry 1S慧4%&E)| LCg|4PfJbBFwDVHh;bw\aŏǠD&tjO֙\.xPLĠ]!րE0d}LO?F*ZeZ.?̑6ua]D*>LJ)„_&7SRjxb;4G iY( hknŷF^ ){"kQ؝V(mټ(gG8ռOydH3"ȺNM[y[ZI/>J72ee]OC >ܯ{R*N IǞSq!+Ce,v Ex(uF\@qk\ӽ\P8/54NOꪰfW2Z7'GW-;܂ug 9Z6q[ 8aɅ`SƣT{ŵ[xKBs6wzO#!Gf] ^LǕRuה''5gl/j25Q J>ʏ V`ׅ7,lT§썈v]:h>,<_%|$ވ`|~p=iXEd74VNPCMu68Ɵ>,hN[e,y#W3[6Tkq N;NF]}ZRJv̬2_8 XPI.cHv٧YW^P(gy@ E uG7 8ryϪt=Ezq!eBf`{n15Փ#KhSyÒ twga-`'|qkA+qZ@%Iv[} ]dXJБb B~['oCcwm/Mt:P +Hf&8f ¡BKM(%=zg`Y$@XfvqGZ$Vjt0M*Bbk.Hj!~NɕYǒ%U$0Jܶ g~C K`w (x/O6ږi&.~ m$jRerz}+_;"[(Բʗ,ކwE҂f!MaZXi)vvAۃ/Bl% sʀ!gM)>[y;|H-9;7CZmxpe`GG:`|mkWn[&PQ /B%3}t1 ?g'8Ƙp*)Y1s>A?P.pV('-^ 5MS{8 6a:D [XsqK[7?Mk `QA Zlϟ '%w 9N!D{OIzkF#vE9U?dd)lz@h=@aUb*@zTyq.Qc+?X5 oُtqo[ n'Brk7:` jDQK쿒Ҿ#J2Qn70t wG+3RRpGZqj"l#(A}/1qpY)hu>FzN/[GX.~l5%=N6;#S=) /Nb ^yo6^Q"LYMcn?%f]8ZvyU kdV_֬[桕[Ry7Ԡ | fb#Qf6dd pabJfÌq+/̎Hw1%?CIbbJՆrN{ex?`no=LTQ}\IAmEPz*D#uJ؛y3ۊ{>"ILZ0 bDC^˧/1<onXV CJup-;Ȭ$t`CVǍH58KJu E+Cf`NNݧ@R m*1x#f}MV(d%众qF"#ѽvk B9~CVFF4 {<^T3LX=YA13Oϻ0&iX\G`#wzyptI%\ 5P጗1qyx-\*O)}6޿a/TWQgf1؋ϔd|#;Ҵv?ٹ$hbgyǜfYyOXҘy !Y>2$tP9rs[hu#If10Ȱr!`("f|Ջ-,[p)!@[8$O(Ţ`K~ƮHh'3XCi F:,)ڬcnsQt;Xc,kr On83ɲa̧^] {RM^J@I QjSEpvO 7ʓIq4wmϢ2miT'NsRpW 9A}$IO{/En&Ҟߧ!N3_ڞ%󲲦=PD2SnKw2smdť?1Y! pjRK\ʾ2K.dgj| TGQ7) ܠ3d2xu% : 1+ʈica@n1BVjdW7d(dSUkJmUm]֙ش"FGXlZme18ĩ?2N*_k QPB>ӽ.9->.7Pt23-3k& #E)TaY.ւ8Y ɔ&iҤbtI%Mr`ZfzB34{QHPL7-LFVl߰qP51AqtGrpCru qv BOF'wS8q3ޛaHR*ߌp&Rad$yKda{WjY)3FJQ1"[eB uݩi_\WPL@%|}\ P0v#F$XV-0NcFxo+-| $t뛙 PB\ޛ4muaRZ4 5| r{R~$c~Rpx\eӺ"^J!Wނ(b\e_ mú^"iRljYDTKgk8X?:7ՅMfuXNK~!3kX>ed]TD%IQJEٖjLē :z5 *kݗw7mEkooytfHȋ'}>8W:; ZQ*q%krA G*8nPDCq$V5rE6]m 3FNumML-lzܳU}>?=Yty@g/0 "Jx MM_1?R\0W60~s 6nbG`a^4dO}mvtA8 YX '8W%U :T?EnD?>ni&v.WA.;k{* $Qv@-ݚMj6}o vu mt#2g iΠ(E,bĦNM&M}Vj HP8k @ɣe7SMU(K8+<[`7G z&B[rf DT?(>uٱ79Kq) # Ȁ8ș$H>|(ǢBaGJ)bn)Z;cEjCư{pP]%PEhsL#B\W 3ظס'ڻ+ٻ/Aà>Z@m@paa*2;\{ѡ Fh\pjs ZL?" DY6O/ZE+#'lz%">q96!`-<7}z鿠X%G9tUsY(|f<H B|*jF ݄H2P>JxNiAHړ"h;`jmt[d0HPW;E\^*ID$deM(*jKxj>s;W5``2']:`/僦mqԲvgW?S Xm _H|]uf4BpBWJv?8 4L;6l Kw 7"bō 7تE90 ^\o('{xgdJN 7s#N%뿞pbU|6<%ҁX[0>d:صx@!ьd-o+?8"bL65p7.O1vCL,XRVQڛa9M!̖m!&nal%\YLl![-#++Ig3g"u+@! ,w;A ͨb:BJia]b9٪((S-5uKWﱎVu^C6[ [سMsx9yL4S)7حüfY5.::c 4HQڠTp-46V5k>f͗o"Juŋ?8_o Xm:NIxȲ/ yY !)3=с.ȩe㞼 7q4fmI܆y|φF3^z TrJp]7j΢x<[:CGbn!Fo#ͻhދۢZ?p ߯,'0< $q͞L92.PvZoÅX MEF%iR^B9H4; bN&N\0y( lktStX Q17;Ӛ*4t'܈$`e\Il%9JPt5kxϨm v j.oC{绂{č^Ɏshihuk'jA,"s'=[gTMWF4NdT(Go*VV TfCU+4;ZqgB &~8E|l>^4M tv29⯝P-(ǝ@9\E$a~E^rx>wY.ۛӅ6o:c+hHFt`9P莱 Z:"FAR 4wm>3soSהր>,L;'~ .z ,E4\x`ȑQϏ>E6{/2.*H&{"gHgWB c k@Ly͖HPxPbiA\wʶZv>lfQ |bVAmnyh{^S rVBtV -rI^Iz4iʼBu.סw'W~6)ܡ{)P}mz} rݸ>?4L9>b >s^e(y {WSŒEg=ʲי_d^gF~dq*ƎD :qW7:4EQv!~  oFQ+B|iK)/VI6Z8@蕻px"͝Q! LN+_ۍ|u\۟wV]cMVD|e,SNYڸlC 5^$[Q(fR|*`:8~2[ p; sx10Kf"&?q;x /'"rHvёʏ lZ}=vq⑻Q8n?h wRo;R͆Kh갼Bp%ntYld1Ǎ\UYٶ,kL.)'m}{jy#.=X^8Y40\:7Z r 8a;Gi#!Zk'5_k($‹ϙeٙ'"a>2U=V\Xޏb~) dgA+Н(Ige0(,[wQ ]Q':%G+ 3c/6 d|+(óOgˠ:_%Ā/qS +l`'dS`ýdb=ದtE (7PP0!e$.GlXUwc ٍ@ BP\/^r-p+d6UawPY:1("O’=p3œ6C9]1@\TS%gĶ 6Nyb;Tq}CV^()9)y'||^v4U$"=I)SJЙ;-hL wv?zFhIU(;%T6j7ܝ*cbw$aS~+ZW_#R\<{V =X, iwe12V<DAz1n~:_z˹.[INaF- Hzhٶy#ҙq-8S֧u~udap*58\ `sV=@M/xIu(\hHSNg7$n\ a vA;LZ┆sy4tQ>2|M| v( س8ˋ\CcxL;za9t֏._?k8~n¤Edd{YĆOQwZ 5~lKJ2#vim^xErMƌhwY!+F}8'pZ>$ .gZnFz(Щ̓ !JT3ZJ6%Xx::t (&Ǭ"9v0Hj@J ޡBgfE8lbsЏ֒QQlibdž= U(~f8ٲd&I'qv49{_L!p>]oRLg~ꠚ*a:&g(M|mjR*ひLK5¬#Ks~Vbnn?Aǎ|>j̀q6^l0@s,/'Տ:yM([ONd#wKnekj\myD3 Z9p"_Fei';N"6'(U*څO JpE`*FǰcslǗtS{VsOp4nil\*Zr5Sj'u:r7(H{0Ћ\e`JC эJIsAO L-_7c{H퀡nq)9QQO)Utx\ -ܳLp^UObt6ɘ܂dJ/rMˀŀg4|zVuC&ړܪ 6 .ePU-g +klt5ufrJƻ׮S; f;L_kϲ!>H +sEPȥZdf2!3W54*^eOm{>6jE-FU(<يꉆkGh[}橦9ra$5- .j5n<91f'!9xtU_&Wi-͟ϽbW`?|M4~۱Wh%̴vVaozfpyP+ŸI.r q>lW",ΆC-OLJGS*kIFX c̲uZ R =0}g>_ FЙs9= U7YL>!r.FNJO@4f*SNanHbn 9q%Xb@E&}o"˨8D>{p& YB!98/%pbiZ ,rN^p3(Hxe8,= owsv8uaRa+%>k&8!ѴAI?\oJmT }zf8qfFV'- "_Z5QRj >7M?1/OuR) y䣇fU35/za[ =bSq N_gdwFFͨPTkbdPͱP:>P&a~gvZreFt #u,u(P lcB[KN;YE2A#\|G/q|2v[j :IFSH&>9=?5M_j|_NJLJe aX(P(oF>&[5Vw~'Ry 1S慧4%&E)| LCg|4PfJbBFwDVHh;bw\aŏǠD&tjO֙\.xPLĠ]!րE0d}LO?F*ZeZ.?̑6ua]D*>LJ)„_&7SRjxb;4G iY( hknŷF^ ){"kQ؝V(mټ(gG8ռOydH3"ȺNM[y[ZI/>J72ee]OC >ܯ{R*N IǞSq!+Ce,v Ex(uF\@qk\ӽ\P8/54NOꪰfW2Z7'GW-;܂ug 9Z6q[ 8aɅ`SƣT{ŵ[xKBs6wzO#!Gf] ^LǕRuה''5gl/j25Q J>ʏ V`ׅ7,lT§썈v]:h>,<_%|$ވ`|~p=iXEd74VNPCMu68Ɵ>,hN[e,y#W3[6Tkq N;NF]}ZRJv̬2_8 XPI.cHv٧YW^P(gy@ E uG7 8ryϪt=Ezq!eBf`{n15Փ#KhSyÒ twga-`'|qkA+qZ@%Iv[} ]dXJБb B~['oCcwm/Mt:P +Hf&8f ¡BKM(%=zg`Y$@XfvqGZ$Vjt0M*Bbk.Hj!~NɕYǒ%U$0Jܶ g~C K`w (x/O6ږi&.~ m$jRerz}+_;"[(Բʗ,ކwE҂f!MaZXi)vvAۃ/Bl% sʀ!gM)>[y;|H-9;7CZmxpe`GG:`|mkWn[&PQ /B%3}t1 ?g'8Ƙp*)Y1s>A?P.pV('-^ 5MS{8 6a:D [XsqK[7?Mk `QA Zlϟ '%w 9N!D{OIzkF#vE9U?dd)lz@h=@aUb*@zTyq.Qc+?X5 oُtqo[ n'Brk7:` jDQK쿒Ҿ#J2Qn70t wG+3RRpGZqj"l#(A}/1qpY)hu>FzN/[GX.~l5%=N6;#S=) /Nb ^yo6^Q"LYMcn?%f]8ZvyU kdV_֬[桕[Ry7Ԡ | fb#Qf6dd pabJfÌq+/̎Hw1%?CIbbJՆrN{ex?`no=LTQ}\IAmEPz*D#uJ؛y3ۊ{>"ILZ0 bDC^˧/1<onXV CJup-;Ȭ$t`CVǍH58KJu E+Cf`NNݧ@R m*1x#f}MV(d%众qF"#ѽvk B9~CVFF4 {<^T3LX=YA13Oϻ0&iX\G`#wzyptI%\ 5P጗1qyx-\*O)}6޿a/TWQgf1؋ϔd|#;Ҵv?ٹ$hbgyǜfYyOXҘy !Y>2$tP9rs[hu#If10Ȱr!`("f|Ջ-,[p)!@[8$O(Ţ`K~ƮHh'3XCi F:,)ڬcnsQt;Xc,kr On83ɲa̧^] {RM^J@I QjSEpvO 7ʓIq4wmϢ2miT'NsRpW 9A}$IO{/En&Ҟߧ!N3_ڞ%󲲦=PD2SnKw2smdť?1Y! pjRK\ʾ2K.dgj| TGQ7) ܠ3d2xu% : 1+ʈica@n1BVjdW7d(dSUkJmUm]֙ش"FGXlZme18ĩ?2N*_k QPB>ӽ.9->.7Pt23-3k& #E)TaY.ւ8Y ɔ&iҤbtI%Mr`ZfzB34{QHPL7-LFVl߰qP51AqtGrpCru qv BOF'wS8q3ޛaHR*ߌp&Rad$yKda{WjY)3FJQ1"[eB uݩi_\WPL@%|}\ P0v#F$XV-0NcFxo+-| $t뛙 PB\ޛ4muaRZ4 5| r{R~$c~Rpx\eӺ"^J!Wނ(b\e_ mú^"iRljYDTKgk8X?:7ՅMfuXNK~!3kX>ed]TD%IQJEٖjLē :z5 *kݗw7mEkooytfHȋ'}>8W:; ZQ*q%krA G*8nPDCq$V5rE6]m 3FNumML-lzܳU}>?=Yty@g/0 "Jx MM_1?R\0W60~s 6nbG`a^4dO}mvtA8 YX '8W%U :T?EnD?>ni&v.WA.;k{* $Qv@-ݚMj6}o vu mt#2g iΠ(E,bĦNM&M}Vj HP8k @ɣe7SMU(K8+<[`7G z&B[rf DT?(>uٱ79Kq) # Ȁ8ș$H>|(ǢBaGJ)bn)Z;cEjCư{pP]%PEhsL#B\W 3ظס'ڻ+ٻ/Aà>Z@m@paa*2;\{ѡ Fh\pjs ZL?" DY6O/ZE+#'lz%">q96!`-<7}z鿠X%G9tUsY(|f<H B|*jF ݄H2P>JxNiAHړ"h;`jmt[d0HPW;E\^*ID$deM(*jKxj>s;W5``2']:`/僦mqԲvgW?S Xm _H|]uf4BpBWJv?8 4L;6l Kw 7"bō 7تE90 ^\o('{xgdJN 7s#N%뿞pbU|6<%ҁX[0>d:صx@!ьd-o+?8"bL65p7.O1vCL,XRVQڛa9M!̖m!&nal%\YLl![-#++Ig3g"u+@! ,w;A ͨb:BJia]b9٪((S-5uKWﱎVu^C6[ [سMsx9yL4S)7حüfY5.::c 4HQڠTp-46V5k>f͗o"Juŋ?8_o Xm:NIxȲ/ yY !)3=с.ȩe㞼 7q4fmI܆y|φF3^z TrJp]7j΢x<[:CGbn!Fo#ͻhދۢZ?p ߯,'0< $q͞L92.PvZoÅX MEF%iR^B9H4; bN&N\0y( lktStX Q17;Ӛ*4t'܈$`e\Il%9JPt5kxϨm v j.oC{绂{č^Ɏshihuk'jA,"s'=[gTMWF4NdT(Go*VV TfCU+4;ZqgB &~8E|l>^4M tv29⯝P-(ǝ@9\E$a~E^rx>wY.ۛӅ6o:c+hHFt`9P莱 Z:"FAR 4wm>3soSהր>,L;'~ .z ,E4\x`ȑQϏ>E6{/2.*H&{"gHgWB c k@Ly͖HPxPbiA\wʶZv>lfQ |bVAmnyh{^S rVBtV -rI^Iz4iʼBu.סw'W~6)ܡ{)P}mz} rݸ>?4L9>b >s^e(y {WSŒEg=ʲי_d^gF~dq*ƎD :qW7:4EQv!~  oFQ+B|iK)/VI6Z8@蕻px"͝Q! LN+_ۍ|u\۟wV]cMVD|e,SNYڸlC 5^$[Q(fR|*`:8~2[ p; sx10Kf"&?q;x /'"rHvёʏ lZ}=vq⑻Q8n?h wRo;R͆Kh갼Bp%ntYld1Ǎ\UYٶ,kL.)'m}{jy#.=X^8Y40\:7Z r 8a;Gi#!Zk'5_k($‹ϙeٙ'"a>2U=V\Xޏb~) dgA+Н(Ige0(,[wQ ]Q':%G+ 3c/6 d|+(óOgˠ:_%Ā/qS +l`'dS`ýdb=ದtE (7PP0!e$.GlXUwc ٍ@ BP\/^r-p+d6UawPY:1("O’=p3œ6C9]1@\TS%gĶ 6Nyb;Tq}CV^()9)y'||^v4U$"=I)SJЙ;-hL wv?zFhIU(;%T6j7ܝ*cbw$aS~+ZW_#R\<{V =X, iwe12V<DAz1n~:_z˹.[INaF- Hzhٶy#ҙq-8S֧u~udap*58\ `sV=@M/xIu(\hHSNg7$n\ a vA;LZ┆sy4tQ>2|M| v( س8ˋ\CcxL;za9t֏._?k8~n¤Edd{YĆOQwZ 5~lKJ2#vim^xErMƌhwY!+F}8'pZ>$ .gZnFz(Щ̓ !JT3ZJ6%Xx::t (&Ǭ"9v0Hj@J ޡBgfE8lbsЏ֒QQlibdž= U(~f8ٲd&I'qv49{_L!p>]oRLg~ꠚ*a:&g(M|mjR*ひLK5¬#Ks~Vbnn?Aǎ|>j̀q6^l0@s,/'Տ:yM([ONd#wKnekj\myD3 Z9p"_Fei';N"6'(U*څO JpE`*FǰcslǗtS{VsOp4nil\*Zr5Sj'u:r7(H{0Ћ\e`JC эJIsAO L-_7c{H퀡nq)9QQO)Utx\ -ܳLp^UObt6ɘ܂dJ/rMˀŀg4|zVuC&ړܪ 6 .ePU-g +klt5ufrJƻ׮S; f;L_kϲ!>H +sEPȥZdf2!3W54*^eOm{>6jE-FU(<يꉆkGh[}橦9ra$5- .j5n<91f'!9xtU_&Wi-͟ϽbW`?|M4~۱Wh%̴vHyc[$Gj{9lXko1A>=0ma0 vj%⿌qA`&nHqԢ8Pȃp#FVHf+8TU@堵ˎUv wzmE:L .:s* HCWvTan,5őُI%2WZY qz?)^4G";ot!hcy8@#]5wVMz.S[Z]8oBI3:*t$(&J"Ji%%N~}-y Pn7^< 23byKοqbM */͎:M;H*:4ӊ8͜˨¬@)H/z`$lUgX-֎A2KE೭f0/^ dxbq%hM',f W U!ZlouEMg5X h5&ؼ^sm/S>C#s8^p3$ED ?P+bXa+104K;Wݭ4rc5QiVMp z6(aV>ϓgfϷՁn5,ߴ[?K0 ȗ,Ɏf1ϬdmkʝDފ_P[9X~sda0"X{0׈]OD@*",r DIĭe+ !%9Y:O*M?;o5-II[Xk=uun.4c6UoizWBm SRI>=B$X`؃X?Ƕ,<$ɴHsY .)22@Mž/m 7dT\I*b$r'.rXG])n +3Id5i'.m]ĨSJϲmƲqM{1„oBqi_r|= C tѯwF (5)o-[' [Xj3_z߾"Z֏O-ҝ(a^hbHm`"<]WO!)d7;Cg!BKȌVxZ֢@\TL #$_/c-Fl|!BTS@4Ggx#Vpڛ49UjWzdXkEFxzi&F,0ze.{i;N=n{]2RN}h@sk=MowCߪrð9 M# =,̤Kpc0]^Xk|<E_^Ee l)(olcZ ꦏ&b3x+c(.50jYߝnL|4\+84~/&OtߛS O$7 ]T3%WY Q:IT}RM6- 9Qٸ?;Hiʂ"N$T $ ̞iX"6mAi\o/ǽe}0Kñx kHz2=6pC[?7X&w,WR%X+=~W&ߩ}`|jo%8: cqbRRwe5Ȧ*<8ĝF\`^IDsYǴ527%xZ?^%}ou2߶ 6L\ Xq]YoM6_Iۨ FQ/ 8Y$ pez$kFgE"^3#J ̷LXyA]{co5&a$7z37vUi#Q?> Hq,7oN@ Mv5d5<,'# _בR%ojݦ.E?N\&z+(hOV ܷvH \ۋD 1%mA>jGh;l|w!QKV>j"Sp$ǿI5:6n?ڤH`^.0DXֆj>r3 b@b.\*0DsY1 c\FnyfMĞw밚g4E }oz9-1ٙؓIX`gsOҰR<&3I&v/YU=N}5c1x\zIu L՞q+(8CXe^z|6 >ȼ1IlDgkCay][|O:1Cn6eYޯk)%T"u:>޾cnf:|6 >ԃ7ӿka*9J ʗhPHc9Xx#.HGD91} G8c&E#n% !Zh|AIja7[6 E 6>-pG&(BŀQ:R}wLjdt՞(F+:;-mPs PBĸ}&5tw ]rfMBfjAt"Jⱟ[A¤ CrE`xamiRE9*.A_cZuwWl*CP1>$ðCBOe|Ʌ&3P>T־;v  kTmpFN0=ܽ^u &h3bpgi VC":[*^fWߣ4b i7ָ70 JT" kd_6e4) H^o+A-wYP4T B<nϕ^4{,xQYpFx =RrhP{Z4r'`{bB|Zx U٦RCh3.lW/W˜*jc"𺁱i-fێ= 9CKQŭpئW/?j%Z84+`eF`ITϖWI+S4:~Jn>y_? Ru1vlu;{nc|3Ed% V2jǷz}\/c#K5<" EKf1煢(9N&ulvntVc ƺ ʃ^v`Qs(&þ4u }R{ ⏞4*p.qJʗuxkH> Yp҃w.gz1k:V$ _nEj9/5Jj*fO2Ȫݾأx$V q vZ$`R} s[ŮЧlyx357RȗJ.8t1[s]P9ktz׆q l D⼊!iI^˖-3Lȹc!>j] Jf20(t$j(96֦gpk/2t5q@2;U~_E㞪V¡: Z/>파%kY'kej}`),Heqdjcv:'׈+ES=F`_T59Eǟuo&G/T~w-R=0!G{E[)Mʘ9%F&iNޱYw" {p^2i|:+r7:[XAzDB)'" 8*ģ?A8|Ʀel_-Lf%Sh|Az'7I&]le=lVi$"j_c+9L~n k^šwVĉBoW}% +VX1.. 3ӗhWb3X.Oiz*~!zgUPdֲѻ`m1tqe# ۽K xQdpP֬+6!^muN f"Zujc/hH0b[ϊ3k?˦ɇ+ ⒒0QEijaɼ "Q[#[YS)Xࡂ*V(#3$\qV<upND._dj:VmQ >]9]EDϔ_0ȶ9 0r3ё8ρ8\ӚEDu[ȔoMg>3~f+~)0gXWcjFG@3p$\v,:!xE-bVj~`Y,T#ADNcYpaJr 7߭̕呏kn :4"M)7no(unQ]rLոkNI: xaxXT|ʘ9Wop5}lmb8)詰ah?~^Wg &DD0^k2oh-579^6^琩SϚoWXo|3 j*,>(r'+}4a@Ƣ 7*z vv{CҨ$\>INgطQ0!P* B鯑'GDU\,a{VK!]v2_%>{Up&i#?yGR'ѓ<̟:yVVf[k0{Qٱ$.G:?]>)5' T<⸲+2|(H]hkί#Ul@:0S,Wew;{mŅ03?0H!NIr2W4fn…WpC,mrU)'VMiGH[i֓6TH?1ev|¯iMl(圛9݈b,eάX#"%ʵ-ͅ2 WYX0B DD)FܼʪJ,ְjk"-~hdeJ.{BKNpti,f|lݟ^qWV&?t(A%5wxw-⌹rS\,18Q);{i], (`U 4ޓ"t4%Q< i_gs^"4 圣So3;kۉg5L#lc݇9A}?X9Ϧ=fJcwq:DXiRfid1Ob2: A(4w&o7mQ<.^* rwPxϟ<΁̠O *Uo"j%9HTU(舒Yzs[B"|=H~nQ)=j&מ7  P׏^zGCe[sQ0[\7&o.PdžTMz| J2#,f0 WD`i;W(kg_X; ;DC*}2t7rR+PqrqJ*P8`En1Ws:2Գ2 _RhH'Xi?,PƓݮВEJزl =b/l(m R5 ٖ2y?qsZE|=#d@g;'  xjg͎0^HƲP]<&=!@y o,chWjgq~ H+fm̄'.88ŕ=:IBo +9Y% 䚶kSiS*14oYbUf08&FmET<]hϐAAr?_/Ru$,&/>NvϨ7uM6; sC &0 ]6V߀$""! ۃ`(JXXwvTupBqHKjb!ɟOF"UW"^`Rƨղ8_E7,>Ro)#QGmqz.4$^h۫k_4$MZ#_}Sm6r:j}vxj,E3T|I&ETZKe%I2Q Bq2[WbJNW¬?Ųc᭦rևxՓleH)w$4/tiP^~cǒh!{S6L[0rBY4Q.Euh_@u:ⲥwcascU% _lwH.~O;(kDW\ &ԪpXX$4@a}?ĉ0z=ćWߡԒyc]ƮZӇ?(Dau:y*!^l%K?^ⶫ=pp:cTB)hO1*{РF@~Ɗ4r98%pi ) h)Nh2[E"o=|l/p q =* i;H.օ %~ ? } rzǚm n j_bW|Yz}4ghvԖ  AD5|ROJAG%͍p̰'⺆g,X q$,jk[辻Hs4w脕* {^l`B06Fby85Bg2~\V$#[[ l320JdzMȭR9Rt BT{#]6sS;9` ȕOi^LiPF 3M鼵)CCNEi W4 MpO5"czJւd_R'#4$u-E B[4YII3"#r|GX'E`ARg)fW t qlqLLJnDqEM?!$x *chhQ/,VؑAFrYND* _!0dq%&B$Q/Mö4/OB< ǩ׎e= HXq15 1ຣ?#FSbHw½;P JأtU@{<}\&nm*>I.@rBPS.PY^OH/Q!EFr38W{/kf.~Ó*d ғ!a Zq87#01ۼ92nj)hji4AT|ʎ#S* {IRң.ba~ LYJP#2LWt낎l}U +t]f\Aaɴ\f4-8yUin 9ǩŮC?]ZZ- .DG$=0|Iw4$D/ U&c5䠞"(v[$oR+B7*kF#'^ ^ :.WXDc3cmL߅)iFs c 버9ePSs%bŭC=S@@'xRދ@ J Ԕ< 40`cx3o4SosDۧeRJŤbsg%MFآpH'%r%Ԭ}<'sk4瘬Zoh 9iC"DTeѦ Dact)oG\“3vA5 $ť:Ӌbԧa 9v+ԛa:|h?b2nCjS5$},RWX,|]̵ZJ%̨a寴JChCsB\#Q*Q<|"+m1heCgN+82+mMWYT/aO8]h>7]TAVᄕ\*$ŕvYI`-8#W|gB5k|{8,K;`!u|EuCk4k$O`E#Hm'V '$1 |Ͷcy 3W($[-fr&(% r' -9\`ښNQ5qZ~7,=gԇEpg\3;C3bbj@8jh*\D-dMi1 |28 u$4{g*GԹ'"qFxT%'9T48"g@JY&'uiVMp0I ǻAppw i@W0<"x vߒ;'W'?}ӜeHCǶ[dubqVN #›2څ8*@D LѼ z{&뫺S>)E@OqyA5F\ zǁ9.\ t"U#qt@OGDսbD h5Pi3[-*-.큮+WZW 9˭ [rΣdVE1|Ye9Z/B MkD˺ӈj./(Q 5 e!+a>PXǹSw݋KNT1Q}l1SǼp22{Уי aÒEY3 V&Q-Bg|9Rqrs}bI _1+;u\X$(S*n+M0e2$Hi~p鱹8G9@۬j[ӹ_A[ZMdG7ᙃeᓱ8xmޯN|)|5Q.NCܖe'Fհ>5F }U&3`]pε>V9G pee"7uiv?ID -cy&6H}넽\*}׋oI}p0^nF|4%G(jmx;C]p g$*x9l+d=9uG_$y=f†R&%3Hp$AmW6Wj Q'sb_ DϲB\/ 5,,z1 ?xuO;0jE`>%y >O`6Yj0rn 1e%̇pҐ^[:pvziO8%n 3RGr\-2bſUa !@]]>ϝ5~tt'` )$† R`ГSG4-dcV!:ŋz+XmkTvp&Lr᪷EUew˕V֝0C+uӍiA2Eߝ6CBWr<5PP\íaE (i X+vEbי|"3ߌT}9O`!ZsT252z,. }qT]F.NHd7s,ΖPXyOsF'#cxYW]DHc8?k\hJ$$ҟXnEez\n EPBe=7u-vymc3 r;q%P>ut~Rlm?ए.գFLѣji$eUXhST(aVWa;ڃw ]h8#n# NpD]^ާ-:I,$R잱wqbPӐ-a m~KN RFBҚ~v9]G[by dkaљJ쬫h:D?xGXsFo`Bv.*BSZO{ ɩiN3n(nwaRϮasػP⏹7uS0cE'u'6  N*ʑo#Ĥ{E3PSyRhL[.ʦNZvQr@:V^zrwIcUH_*- Tr2e 3g|; -.Qv٢#ᥝ/9]P V04?/f &s7}S( @jzr(' Jngir[K&]sCàBct>5c>8Xs&'5v`:* f?t0INeXYM!0LicMZE D׮P;Ӎp ҬCƄgRjmG0᧋o6ھ:__Y B[3˪6Y}IE^):?=fMmw B."y'Vqn8ͺY V3Q#!o?s=`څ 7K05b?CF"㶅[/(#b ,=hSCLTTǚs)l5݁ZBl+8NIԼk\ZgMHΥ{n=['8O!T`T`][DoFzo9*- M vC0kL"QI%FyS} "yEKg*d0L`9@ =L}Ukm),A3{Hi}E4ޥN@wXWGgli׽Z;mG@w|Q;3e~nuM5[6)ۆq(7 ]8 I&ٖ%ފQP> Sme/ϸX:x “=‚hX5 `2ԩ+׍0jPU)V 4M8O %0uf<8d`5AG}\0DN\HwWl3=""070ZekZtv4J;xC~[^8NOЖҸM7z#֌B֘a?N숓8sGǜ 쯧߳H5M=.u35Ghy1Xb28kU&s9^(TKPjIxz,,%wS*؍%3HH~",(wg|vϋE)ͨ^nCp3X>Cz;cK܎20V{2$8/KHBSUEӱPCQm 'Kky.F /F;OXքXER&F@mQ*8x2/~ܾ) n|.ǚcVoOא,]49r%Rnx䉭,} #Ǻ_".V.4n8WْܭƞhJxvK)E9JUYLT5[;A ^ez@0χF߶kKpKh=on[\$ҹ܈G$ɵ9 +4I;f_pSQ60:n(`31F[w33qd"Ud~g}q&-]m)uVmIM\ARyLr)sk4i1ּ`_%ּ#{#Nی=& i4Tf'Ö}&u/h%i%Y(+yqN^TyyIX~e2O,J(Ob"wpqfɭr@[CYIa@R=HrlI5VyNoIf:0c&%ɗGH!Rv}JX X§4O9 AƕMkV8aHw NjNE0Gzi ͷp0+ +Z&[݉#5q{.s(y^'"*z~jkDѨ潒~pِ(ܟ`O'軎7:\bbnGe]tm䞧_cmY6}MD5(\k+Wֻi}Q6(Mp L<|6)X D~ F-*4xnEN6U]bp'}:XW -PI=#\Z=M?sJz `E@ll?O&+tŀ]BPQ*M/ &K[Vje왒dm8cz ^k0s{JJJDLb?x%I=?+.lķ9 j̤p=0)x)f9pddsZ=e:Z&pGGL}8 92Y3SiK'{͒zœS?_}DISegjs4!;InErJ#M=H&|u8+qZw:t8N~8Fz>81VILji:֚6Ho,?\ř|FT/A]hآoX)3m6s> 4=X2tx\_%v^GYpK>Ez#yu/-Dx]FEy+M@ M;˔ݶ>+Xwo ٚ6K.7fE5^m zD`xi%cSƇ勗%2EՌV/'ònj8l~;" p2b'ͲT,%J뎌=Ia8UM6hk#e5y羫}ہ_F8V~TvYwA{^i'[YD}(MGjR.x cfmIk}K@I{sMYtU Bs kB<UDnՙj1`A HB1A7K-bYp-G= $.Odx1]۸S|$=';+v0\lPa/p}'S҅寊u`B2Z͊dMTmT[> 7\p-I] rI!cB26+_#)LLNe4aBOh.>9wX)8b C3a}e(T#e?=veXf7ۡ5qKo{4OɿY=O-&7BM( <}}c4+_nՍ)7K쑳ZIs[b" ͗ʍwY~^f&5l,*6"}ͩƦG Ι֍ 2R,|U1l&hw: `s8&,Hi M-d6#*^^D+Yeď#n1"GmD#?68eb*&7s6dwJ!MBYd%31 l0qE1dnÆ>v)]Ֆb*3aG%i%#hW5i{by7Y%耼,9&*򈹵5[ K_9~TxA Y6M6din`j}OiSsGDj`l3vd/Ȩ oF[6*c"ܨ lO M~b[RWNR\O_HL l_Uh"^33zT]ݤVL*i >M_|?tn"^[ޣH%t8SqFP`7sO_[LOrv'PidXì7Uݨ*ki $MQi;WҪ/cKqFKvV=iTC@e]ٹGBR)$ k/= UË))"3nGx$N)ό" QۣH֦a5i]&΀B r˯flb6H @8D&ȴ}<R~aΧ56JB_|C<8vc,Q!pnx$9эޫbphrE JUnmE3_ڔx/(emJBEd9Z sʚ LA`PKDvD G+Xujyq*IE11ro&ы]JaR}]0ڧxn+|7MXkre1x{ y/ĩ P-B:n-!oRmՅmEZ)fT/V @^%I:vU;L1ZJyq<@oʒYs~ck,YƀabFPR YjR4./Y{M'MGoxtT>_a!:|>N ONzz]sW@ח i^oLp tNvu[";9^l4HaR^d-,gUm"#Òr0w7Jv0ȊYBC"? ]↷[gF,X-I > - Qj#O"V:+5`gV5B҄QK]~-XAXjxަzD_Tu2D,-6 $3-o0/*mhE4_FN\}T8۩e W:#xϒ,`HQQ B$Aϭ,4a8UX/*myG<9nWXKb{t4,W+",T?oпbѹX%X?$N۬n~{$v="@sC5@"!#ʌ?&1[5)|0Y{{Q bg5 +H'K(U9ٳ"$6<ߊFIնeQZB҅Zww*(zEG`\➻ n8Zt0+nӛ--m E SO|pM9QO]3w`;T 2J&%v#u=yiL"oNb+!st+E:o6s16;lhq[*+֣1'YngЎ""  /QDfal}uZsXOG~*a}OJ'5)"?[ws%\ 9#:% ɘ6JH3@*͘Cl!V aI>yn@~6F VSXI([| vtԔ>Q{|PH_3ʃl&Z톫#FWt+_YePX]2H7D+;=vj!)!sOw+i 7QG4 VCWe_e'᳅P]x7/x=ԃ/N8oCv#R%}XϒFg*jUh<>Xݲ1#6* XܷIKo8UEp2u^$?ei1BS_yݲv<CNU V(]T2BiBV=틇VyUUOm[T=?k*z$۬UIB&fG'rOR[^gRRZ{< LK!7 bg&:{ƙHɢcMsC9,-(p5lڧq5>9:(C^<򠚨[FNPVx d^3EZ.z@n$t(QC Bj0Kn""K}PY&Zg,2.ҍR`_p [74T lV=uu!=b!0 瞸i)MA `@,> ! SՈFȮ#  @F0h2xnzKJ( T {UN}-6 ڋyo.J_¬mg\Z.F78ih9dQVYr^@M=(8~'%] #kG kt[>c $ۧ(ʄL6)mOCFF 旗aI>ʼU4juplDBF\m]$-)=@oFJ kdo:}"s{n7J?6]L 79]iH^~[@PF3倘ҕr("#Ĵ^ܴ]TBJxwp]̊Ȑp8=Ϥ@Փf n Wr+~7TFY9JC|G rFd>&A{5"ҷE/@ch+MY#˖SsV!IPCkoOgA ӏ$-341>D')hJ1M=Fܑ|])ӥʹ5L %]\uV:Vy "B/ӊ!bL̺  ›ض:`ILV1X͞ǾQq$ 9vM"QE5k xUt 夡܉{*nhH+8^&XǸ%ELZW~th >}N E[޾|fԚeV%C)"9@A.1Q$g7s7{)ɽOBFe@څ@ 1 2Z=3qNaIbX#UuM/3[7LF k18k˕#bX1k"=@A8m \a&6Ƃl&Q,aI?QqO11zy=ṱ?nnM ;jr,}JTQ[%>"Z|G.!Fm/|{,B};XY Z1`FZ1TLp1%S#OqO%?e~fe:xŧǀš1- d#PQ' B󭶞9苡0.nH`"8`37KC hm*l)fAa-Ul&]U5^r RR;ej/il TP?!f| R5&7"H%䨍y\N 76z=x;ǴDsgb 6=j}stWZi`JZME ::yjVa!s)>nvi<4D%&ܵ5rva$ b5GҶ}ECz%gb:! j ,#t-,q{g%NF_8xgY?GB2*F<&| !8Ѡ&䋍ΐ$/KC_/Kؙ1+J.$_8X(dNu^෣Ge$W0ؠ>MJ[X-j ɓCt @B(XL!$;]A; <הCF>WQvLuUKRgTGbrMR~=`rPG ?PVp h-L%|ƻYΖ;B-aL$7Gx6;R}UGtvy1poKb$+V1tdxL >G9R}4 Qѱ1rOכӕr5Bn:y5!HjbAz [TZa&^nLcO~+|q&:7'Hٓio]97XA[!\| JAqZC63,ozSPWګR(Y3Ƨ#I:b`/en4[ =°;5rVm)à b},E՗ҝMzWȏF]tRC3ȇKQϾڱ;gqF{! =)X[1;ǂ V 2 ?-zgX"v3H,W:-L>k{ ~G@tofHW902_` ~v)D'&p%!k>Lz^B?V%cj }1$>L:}s4o~\ÛX7<0rLM65K|bѩeo}I2ħBF6;O&ʙkV웺W^!?j$K׭~_E[]2f ~Q H)r7gf}ﶫ]"6'.Lϼr~VW[slq4eqZ:j"@p$7Q!}q=/&Pud|69{%5P ~̾t'0|lZ6h2&E:ױgYZPerl-APIReference-0.16/data/perlapi.5.16.0.pod.xz0000644000175000017500000017547412043467326017542 0ustar tseetsee7zXZִF!t/p]c?V Or;6ǎ#x=j-CTx+'jj'UрP%p 'PQ\Yl]*({3#D` QYnA֌3)m(O0lgȾV>Ix2QŏnǾ8YioaRԽwC+9!74lH(*3q\.gfDfc&WdaU4-|CmnTsRFhɯ(}E Px)\[8ZAՅ?=4&k}!N.D]|MLB8Z)3l+Ni v U?CBbֺ qtzG.PPk'*A!érVqYdv|g=nҥ0PǬRC / p1ehs6fLظ_ M'V\jf31 uڧ =#4TMXrﮇ>&݇&[_z/x PϊxEj G~NGywu( `t -@V1vv^]vΫF@쾉.l.p'oٌ')_h}s򹴲3v#k88-)f~[l[9E2.ncDnZܙ9P?TIB{ypTxĵ\dlK=/ Uŀd tH()œ;=dm"4?KeG~Z}0QDXl +ozd o@9vvHr; 둧K,<)lGJ)،:;ZFĈ1}Bk` !sg,Q֊ 2:_NA1 $t+ 67Ap -3w+%Ƀ|㡃Av'JҲ>K<ՠS}yշ :vT&m8uoª |o.QC[&{ 9A |u޷b6N%܉GkBi Z ;;| TҁS Y^&`Z3[>sBtQr[ɿߵzmZ,EĔX+NbhAc%D>~)LzJrg:{:IP}p&)I 7/ɋ^k1C3i*˽HoB(1;F"Ϧ-,$\@ӄU֤xARq@v2-#dF|(o v!J*7gHV{ZMaAֽ|H}0##1h;f.:"QQn+< (*\؇84$HΌ!|+U|D؍ɠr<.hyxvh G&iM/qa,P.ǘLX#3ϊjDX|zG+̛kB4UrfͲ$]|h%4q3zۭkN%x ]G8{xM->:Q>dl;n'GMN̟~􎙽9@a6뒛baln۬jnw8p3gv^{ &U4#YEOn)-\l$友0_ i8z-Ö[1`?nQŢv#[:>o1}> Nrb8-e_yfx^ufWYEF>HGn-5Fp{%xk!K0]Z,/?*|)7ѭ# ݹJFnwIDh}XpSPgF\};Vݶ-3[cG{klѮlm9Q0rTX3A v¡?> 0 $ d^ي2Rb߫1cOa欤?V%t;]}\KeV~VA7lJ^lo(im K,)I-$[ CRgн_z&Jcɾb 8矛qB FTD.}7,h6 ZttII65-(shѴu*v_P@}Ә9dݚ=e|m $&K3>=|_.xa*#Offw0bўp r8ШwеBQ +uyKSh*Pf=ٯE{I׻uh;+rFoGjz<jՏ,5tmrKEtԝ (t6t]N7RJif~Z"<%gbTx]%Ȼ8$NP)>lN%Ȯa^m*I(k' UrBpA@ԞhM)oYn-qي@v? RǶe806,;ŅIIl:FN*ؖ4qzSdSFhZ!>=Sōa1zKç*7Ѿ`F!KVR`PF4-6h^iijcrh]=W6jR@r)yC'yVj.(TOy=!2z0pBu,-\Y3FNn?Q;Ev\kT*}9j[*<r*b]ftnK#*RFMI_Jw t&Jvn"&Rz؝4E{<~$M{̰P/[q|ְz/P<5_DA,WV]Ũ_' 4ta`H_H$`WIVv0lE`y9d|?lrqO\-Է)e R &߰[3/heQSt%]qWP\Eu7](.(FT1poWÔ6Ŧg_ }oR1)tk<.]/&ϦYb 90R/ ImjXwxxhSmxJ*bOp-/Y]țr>j="Nɒ0*_ZI9ra0|^ǭX‡gx+!Su\)kKΟK^½N!) U cj;wQMS_!o4↵ūR =PUȸe]e;Fj(x|" oΛH VNB\qgۗ%>-ɐ1OɇrON Bjǒ1LV3/K^8-kڈMAjh@|Pw@ݾ6Jzh{ò&JmWW.[?b,|^b%A; xr.n;G_%[DGH=GXyV0~!5?ʎ(/WfqR61X޽|;0%A֢>:, qh \%R\ǛF-4WXn\|_3܈m/G+_DK)I`ao 'lW cg=[ , 18W5^tm'hS)rr¹KdVKGvAkGRbk옌c6HgmB?av<&/>+܇[(QLdUx)Mx1,,dҖ]GQ5SbS b67h;ɗژa>5!A!+覙Al6qS ZS{郓gЇ+@ u0(̙=Q&WJ2B+AL(GV ơ.٘ &GEh0kO"@tBNL¢1 S`5"v (_.PBipcrb0*Scoc;;vR!Լ+Ҿ\Dp7n rc8DbJVdĝmKkP SQ4j6m9vm#Ve/%S]d[ߏ+Gۃu4AO8&87{~ä(؀ TN_TBcݍuRGj7ܭەis(eD$E&Z|aꡊQ{` c++ LjݤZ[4X$vЧZ.@t62鏃Ltck\?j\ ߲%(\j2 ؓJrI}(Wvƀ:ANGlVXI၇L5N_5U^Y(.1sF@=Y\4O  /iܩ1{]gaqџU"%y gclUZT]-1ݢ4zm:fqNRő2B,K;$uiPϩ_6P48UKp{؄Ogk=sB l~+cpsE\h"͌#o*x@JtB|[=NMˠ#׷º:mں_j9mU0 } f;&հ2y9{[3U^rAAM5ԡ$kgu?6̐iRh|B]RjIaP G&Iʲ7$;g$:zw!VN.p\Gj=>fid>+&~t#tӎCJmQ"b{S>-*^,{{Ve4UFlEܷm}G ZpR qF@6lR)zR2L;]t fFOfr庩`:gI+!ܦԾRZAp$`xH"I4gSCXnׅ}T%"|uxi3"hRѪ%JTh #N{|ɳٿ!Y+kb oZL;c;fC c~t\ MϘ0׌a}CxwH\2`*&-͛~7_,&($iR^@Ϭڟ{R.UA-3HZ &HQ2Vj>֛]BӔ\HːCҗ E*jMfi }*j4#sS%8Q[AgMQ+A Oc}uU[kՏ`e@6Oe;W{)Tn%ScP>"e|c1ܻez=::!XwRF؁HmhDd "?WT d.Q %c"|4Y5I? ;y2<'m$Y!8T[F2J&*AVh {K'8wjV@]R`>BBʹ}6ϹοJwB"#0p ZcB!+ nq[m GL?)F{AԂ]t=Q]X$n~T?%=YcqҤrjo_T>lq}v _p[&s[dS b Ɓ 9ɜ=Zns>VQm `P0|$Nj[N_k }##)= tfj] :tTe"#ɴGHTSh@1 ${THFȸo{ 1k*,`3F7,?$ @چ@?Wq5]!. <$ ?LhT($糖* +5BѢ ͌={{h`|7_F<︻Okdb,q.0†H cvE& 4橜위5w^KрrAqoQ={LQcW* 2)۹T@CUҊ,銞&<ҌR,IKHcR=puYйI1 ı7p^cZ[ev3!;w2 bY+2囄|;E?1a8mj$C>c6uj1'kL%#y6a@:Lx{Ȇ5&qls:cjμY"9XNWB{oW JSR:HMt=Nܓ} }; N:a%?.oQ0QbV-$CriKܘE1ۢd=jI;Kbz_hK<ÔwOfϿ*EpZPU^3yCSEHL'JG=y!g]>W0Wa(Bv { N{'чЌ^ (9iX9#LwIKկj,|8rslmhs`-Ljxk>/#{H)1MdxjL< "J  o9}!Cf]qqa=fDtd{_4Bd Mo$9wmcimycPTʆsHbؙr['9`uܮViM"b}ŔYXf$}Q쥤PHGWUğr=a (Q02 %>wꅾL!{?oN;Zp AHTڕSqOޖ8-8D|= $BBWz1X%[j׸J z n[,HM%Ehj %4Wm b0_!yuDODm~ 3 %}jG, S Ot>'|Cnۃ +|aꌕwb+_('%T7& =CW1 `phKǫcrB['-{e,p,GV2em4//اZEo"Fhwl_T63DNd=P ~ڽ+ +PKBz8Z|A%jA W.FT/~Jja\lԧ YmRHI"m\&]-[!^%]7UØvS*qm.'_k1j N-bȺ(:glu]hXx ÿA6G~dw8 PKY/c_5XM56'fFܧtŻE=!nė'| hUHᑵ4>z+Ao1 p9* ookqeTar:3x"faAz1ր#: m@&|,[fR+ZXav}s(v؛b"n)!`#wrl-$ v4R(zV]OGbjQEcQRyEmo(*Zva#ާ6w@#Jir;= G&  $bQ=ŗ#m1=/pVA:rJIK8tN\CۻKQ:vؽӣBoc}7smJˠ[BQ\;nbAG蕿4X43X~ed7g(M^d AP?D@"u^afsi!'3sz.")WE7Kg3 N8v"z`UmW^Ȋ~ -J~! OapHV:ӕnO:o4ڧz;=1~ѣ*&hgf*]5Xe6gw/+@0=KafUeaTECx&E҉} 61P`sŠ.& 0o{$-TBv'R!,F ) ;C__ā/NګdjciXf 3;z.>&6٥(~Z}bRGD8󙝤 W!̪Igb#񩝌ݔ׆-1AhY%QmDRdԜ6ybܺ 4vNKUp/zBX̴"vsݘnK.zuCIpR/ |G->׆B#7o$ar]F!kJPҝqkCwښ%5=\hjUmo-_QJ%2%i(ꊹIvRo㊖=LY>Js y2!p)_{(ۃyĕ@|ָ@}m:eǚI k)9DZ/5-Vگr8ϽBe޾{t~teߣoс_υv5tfI >("G~n&@N*ʳu \qкx!'temۺvsf@r Aa a˛dӘ[[%1qۭɢg fà9MRI7xاĺ@@@?r6KtB6@E񌫑êsd |.>X0B YY:Ι;;T0 b`Z._eJ=U>l*+#aDf9Uf?jp~n]z2 y+NcKɂGOPw,6b? 9|22m^/HQN'f9Fcߐ/Caa$)ndS4xhB*ql|_ hng"ˡm+k];?ED˕)fr tyH8ulH3+\ztӑD(|h7:p0*Fdjj[Rh,]yƻFz4tp)ϿBQuɃ<}dڨ*kY]!ΎDHIolNts0-Bb.&q/SR/@I:qՌw;>5pZP9HFryQ*(&hN*]w.{QL.R˘erؠtkiF W0&Iv[`PAX}KGz|-H`  hJ)%DV ,Mwji65&Fّ&\6}iͻ:mսc:\/2BcynyC9b.א=K,=01?Oo)l$3POš|m]< 2nTN5sjW ? ֫a-/`gx- N} x\6"_+^nU>nJߗ~c[nEI)v`B:@rLNu!sj8=" 'g6J8L Oԍ{*<)[Ust*ԏ(b'C>+z0oM}m= l Ո|omȮŃ &Ҭb;=քtnݝۘn U׳[::5Ɋ\ [:~#n_gL#k#yKU E1J:O׈…"dvk]}E-3Yp~ºULړ.q:(@fVLF{Gd(m+H2mc_.p1`ѰyݺHY󂵯(JxJ7)Ze@N0όxl!6 (Wiʓ}'ea{cz tb$#[X]eRMŮU^;e*]*"Y9E5YCbۡ4ip3sCP]T(_lgN (u%kO$= F%"sa 2ITزެi﬙Br0*RQP 52ۃJGϊuCB$c&!y7Rׯ._Ltmt5?J&6( #ru/}]"l~QSܝ{>YaI B0Ѱ5/Yw&H3] `~ɉH^+.!敉l_!U)4qE#HL:ى*} T۬3Ome%ݚ7S.t :>C&kt&s\s/,榵`[AUؘ=&p )Ek'؍C=6﮸2z/nR]M&Ga^A.1ʜS:?KBǹ9aMi Omx6iLʍ7p 2=6_8>>)ʸ2͑a(eAVd@,SBh\s 3[eAgyT:`V$>ףNQg:G8vNAN.H5 ؽipv`=06mLmsj7&[̏/5BekJO]xti\1Bj+7?F!*NH\\~ǹoNd<}2pb>WHlޫ5d'9_3p*%S!7g,WT9x!C|t #3)^sXIwj"zw0O>/qyB afuX3Z<%̂RE!/$}fMVxDeqM@k_,R~?O4j!;"HfOn?'K RsܓW*X2̲*d :(GbI\UBH 4.QV}_ίTe,%tJw=XD7q(]m'eFgDdaYoikOnFgƢ!v!e.rĮ E<ʲ.jW 5l]M Q`lhYk8Bi-;&L:717r`Van{sɪOϭid mfO ߡn1tLmZ5ha?Trs| / 6gY&Hp+Q;s{ژ9`)< c{>IS_:ځ(I6 Q,Gq ]9Ɇ#{Epb8_=mWok@¸ɯ=OWM<9ߟ*p[NXt^bōRu`jsàU&ֹ{2C@* rQ1+(0^7ݚvcw,qIJL[| ѹǶ;0@TV}E:>ͯۖ !PET@H.^F6; 5dY$X<_b(;5%sJ* z%w;dd4ʄz!Aь 3'>=*N/h1۠#Г\m9(E[ϕKNyc'aIcUJO#`0F$_S^LuR"O7DU^<3IR`T2o]M(s<ߑ*W{kr_.Y2Mo4d dgTN9AȏÏYw#fY{U/)Yj$BQ3Eڅ Ǫ݆ܯ%Je/@[S <{ه%xIl,=[1ʣ̰=jK<}a{'sq&E%? ')aeRFA,ķ8"Bq^so$ɌK.l^,m0k\r^@tt,REؖo5-Z)![cx99 籈zO6]'muX Hwf=%m>a,xĚTTӱoIQdykO.a$TF鳆 M)8fAw}k-X2}VhUd&*'ᑹ#t(h9;|WiYv>k ")r+b[zP.F m%RҢH?"Y P2Boj=Э35`yfDSr?% ŚyR+|/hXuz.)>1?=P8sABS\x{5qiX? ng|H/25dp7Q5*A* c6[d뮳hk)L(g6o g^7sA_֩<Po1'@~3nyQJ}q)?-޺ʘSA+">PZ;QuɳU(CP FzG(WG3v9 -1|jHɟTNƗTV+ݩ걃1UJЋ dif?Ol=p`PIs@;ͳ9$A5T"׫< 3/k{-ԷMGM&[P藕zX]֘ lrQ ~ucϘܵ^򿙰$;ЯQ{| {Ge1*-p~]c[e]nIośZ+sW8K[H6FPFәvQt;]zW:jhgˎ=)C`rhm6r`E-l%Yd&f؆ n8JM TfLk~*p~M`( 1,LE  7zasEF!_RYc+n_y-?8nQNRr/|JJVm$j8N8젓wKI_B[ye[HOSI &ͪr0px#:jdW >Jula-e5\7Kf sJxǢ.˧T8S<3 Q44Xt\mΏW̗GinN3XTQgi0yd^}8ZEwUs1k@ r *Uetﭮ?ұBA4hMbEړ`w$' Œ dg԰ "s]'~ @׹1BL-cutC4]U,0rxXL0c*>LJ_;!e)O,cdS_70,C%˱՝A{ul|: b6K#s<5X4nFQsi'т) z3CqF'56WFfxe->SqMtc+Eܣ`P#<8e;Ʊt>:7? AC>ni[ c]Şt;o EnFz`~PŢegwi8ÿEQXu\rົ%M llJqa[֩&WW0\s sJMO,y'{ Muo f gnC~:C#=3p6.u`a?8Y5Ѵl:HZ5AnRFvm.XC!Hae iL!9Cȋb}P1w)s{,uZH4ro;֪RNᮢkh`xʛ ιGz rikAu~~;~}!⛙mrI-L1'1Bc'i"P N8>6cC^Jѝ\7a`#Rzx#\@~'|IKupoMw㐫"9#,bh)h8ϵp3zN9`M.1:z2oQ:O~PG%iǑPK4%Cy*?;-l1HOEk/K6]ܦ!٧&GYؔܵ AHlz˶]v^;~35rS^HX:ԑ~&tO \NS>يiܫ`'-8"f3+2n+Y1`g+r(¾"&Ӿ|3{>kˈvvUOv)e"##55\ _mQoeg4!,r' W p8ҫ$c l/[I.J?4*!0){f#67M`}l ĩv{SH3# $S&GqJpr!>yn3$&̠U=;ke+hbǔ5f}B呚{2,9p ,F.Ӝ 4̮V qםr*ܰ;2m5>$tt&D̹F/7SWkt0JY><1aK5!{?8*gw(Bic0?9x){edQF0op#D-.*F [b2hP}W>ؠ8$ƨ }lb6Vg=(gDgm1ij$Lzzt^{FdW}Gi(]9R'<]J-LhWwy#d +#6id4"ˍhQL5X)&hrÃ+Ēm-E:BZfҔ9W7N (E'Ud(SUhN:%k7M)d1Lj [SNs!#a&!*y!0.$9Zd)7OԪ.=c<'m>Q8ʲAVo;{aqƕ*),R1A4xElwiP^6V`Ym*1Vŗ0026%L 8@UObm;}/u~_4po+3]ڑm˫)X6S'V44hOx.%5cmya]X DIm3gOq 49-gNM؏ؿd4ǯIQ[R#]{/5,Mtkωԋl^%t8-ꐄXU#J9zؗL=BǕGZ X(WC%Lǂe^5xg4{cPwnl1C Og)˽& Œ[Q;ÝBހqTyʒZ6s+l}y% 0hc H%~u]"kSn }ݳb;,yW8bfuz#Wi^ ֛mM4g -ia!c΀!&dS1L{0WWH.hWށRW p}|dQv7IZ'f PjdJp#Ϗ- Cx(E~ A٧DNZ0:+TYbO, 8 0?u"oϋr B_&tŠ4P]3@#-. V$,nq*N.yjHU*'tǤs֮Μ߯Z[ɴ}ܥfn|Q9%D5N]P4S{사&?%1Gd}B5 4 y,I}pSbD_!ZDnc Nmy7~ [i<4dv/U5aV6 bcP]F,a]Q°@~N+ߕPla w%iiWǿH0$yu zW?鰲xXQF'(3~ I u aN B݈Aaà"F?thp9iDZC[)*Z[HSB'-ľw\.qtӧy\#I ]2* |VMlv#FUI/V7DbU*0 2K2dOH=kh pōA㜓գM-yh|`P!xpk?xh2ۘ^'uՅ}P@q%b,$3`!*en-sO+e:y-5}Iw)_0b_ۖA K;_K㡷@nY s/}%?H61i4OЭp,e^ޣR)ׯව'~gg!Wbde>IKCU ɦù­xn澧[IK^=Xi텲geFK f_/V]$:RKX<%^h)19"GK\ecaV4o!Tn=iIdW}\ -a{` 5tsUR WN<1fciZfv\<Kd `4=TEELəNuoT]XЪRdj.e3 i7 xI9Y4/}gf`( ^dGSVU {jKGL.%.G0ݚͲU&O.{3SZemC"8T/-G髬1l1V[L`p,j.gʭO`1EC3u맶J`g2풴8&zjK'GL^LP6޳8nF20;C\ .e/VY:`x4PS] {@M4k޸NdR?=:mpAJ>F`Rcu%*h'8{2_tW &ڬ#+`<ƀỉVR%07$aDbvy0kf"SНԴ]P\*$rS3f۝v[EKXk/:q҉VTCv"%MhE@v:6$%Pig0'z<- Y<0׀I9p<Յ ?Iț&\L1/X-eb1#z'ٛu* W-3X/^|nL7Y\pxyUE+)/o*0&s-ptZ[{vou_se@ٙ;#?`ǯ2swAD:2}i2~/9S5斵n5Ҷ-[ɤIS-8r=]\YeݞAB:|Ux3RG:p~7]65gOʼnW pY$:Ɓ٨ҖwҢޔǒ0@,_.Q(H zbCa]`HE)j@MhYݿOYB7DxHCH cqJL> (!"jP{t]\UNK(@E`Ue$_[ KR/\dJe5ˆ VڥWr"wDt?HM|i͉P=&_爷WfƦ\gӲ,5mM㸱Ӏ٠G I,iy9eVgTcW_nz(p*"_}Qs0me<<8׆$˥ %rGlf%y{ɸK_rw6˥q%T|J]v(TڻwZt\MO2Ϸ :2IFpx3߳CHQB,ܮٞ O-W9%$0yaI*NǷEr3IvG71"|! _rXO9 [SmAdyUwAx6'@X[WEz,=ϖMpP\xwRfmY3UL[F-OH?G5b@y2'yL[z;{걜j@d>=r\~ w.Б(!@Y ] 2e@C].0dwK+sݪȇ\煪rar@{%lPQ͟BHm$&yH75{,&t^lab!1t 3;e G ব$ǰ@/jfe݀ t n8N%pV(SY͒Vht{abEp[0R}(*,N=o>2c;93?1LqjhB$DA##uD%)K2GӞY_ªP)p~!1 A St)8=obz.ẁڨnUgAmt'&z]/Nq=|u*-(wxd0^xҤueHą2:fzQ2!8Ӻ(MGNFMǓ"@DX0;au(A"hE2[rz1OE̿`@pYpB"Rz-Fj `*(Y> i">BUG##w@RN X^Ĩ'5 }3ڒ%b0sœY\V0BuyLlŚHXsn'$Ӵ(7i70وPG^^uZtyΚF Kcr\5̮h9C"T%zܱw]ًtU\Y p{XRZ|pFd!ioARi!JZdIN\N?:fXL9| (pp?DVe =1z9Z-kOJJL*ív4 T;7&WAd*%UNhrgA㑁aĄΖ(z!kBIf!a^H 3Ouj8 9*IRf=L>9YEGu(RsΊvH~ ІKjP)7lUSf vOBH~FG>ھJs<=<7?/-x!/-yX3fǺV>.d߰hlή |99LI+7|ƌH9Qu׆dZgY'rW?B}Ĝ;VЇ۠돚O? k@җhpuS Y'I{&5嚏\GHZ5f>drJcqҝQ,+ Éj]BQT2ޞܯb4OJN=!4,{0+kGB7nЇ]tÖw2?XwII _yuFl $I^:v1Eu.}wWd6Q3,)ZH$,7=<ۜDX@{ih8IĽpB9DJv˪!F[~uKs1s$jA΄XF5\fω/0XMرl L&",lg+R*WϾs36c˙ (E^L :ϧc^|Gȏ_K˧S˔ٓ?e2>=8~uY4ZC!GY!a2@J-U*N"q7ÊvdCL<^|AisbvFkD`>C&c\8w2=OP*|3?XH2^ӥ5Hĵ4֥{:PS^#z[e!_) `j)N>("(j7EΕyv ׏榲B[ewGd i'Ăru䟿Sk \M--C!i _\מA<"㟂#J:S{k:cFF4 n= B@NULpbȍy\@I` +;sFp ]eܧ}Ύ|\oߘ MKj@>:,ٜ7V-LSw;`yt ~Ϛz0lݛlH~2>M#{Á=gq%clȽKA5.qӤD"|RFʐ wڐoCuwJq}Zc oV!?w֢=#2_U1̖H ouS4N|d}L) ߊ}өg5^Yp2\]Y^۴k"s9,}ڳxp68C ʠCd@-7uiϲJEhȋ;XYu T/oW)cmGM/<ٽ/5~nC= +SI|2ba4l_RpR_" }`6(RA$KM^ykq]eIU-Eu|M@:y>|@}2ď/"(_]TΩkCVIQ'xcH+Cxb)cB;~F|(ə@6:AVj*[pmBMP]ΏA4rx(#Jggd^G<hZ iOlEeZÜ.S6ھ+(Δ WyVg\ъ*a?kg|.j/=a$]{mAL`=tɇB89/c\}yhoA ߷9s]WTYn׃IߵCQP7÷0W2i?'U .^F)f(蝔!l}R+d =a ;$1q :}ha9Ɂ _k%c;K"fM5H^[ }ꈖ-{l ǀxC}E3L ۛ I>3?luSڶ&%愾d™{wj xOD-.LP;3 L\Hi9ҍ{ص]:y-P{ް9]!ol'~U^5&n ٩˾ѹL[2K&"Oҫ"|y0v|JF"mUfUt;`Y6qeICUkΕi`}'s1}T1 fM`9V-3?+ jH). ըCiD^n^1Žrk6 5ٗUz^Oɀͬ&LuU22Dh:E.=<ͳEhɵY4A3d-߼"9{782 ~^0H{ڒtM\N\Ga?>Go@u_sg+`0^(* l1@lcj5[dLÀa%w xZZӲv@!Q4'#B=WB[:Z:\3&6[V=< 'DI 9 s=FfsZ6ygG5V2@u0)="E[jQlB3F r^љK >‖%WQ p7d+[w[LgU YdFvEHonH>^PȄS:p=Q,A rg94T2΍ӗjxz*qw9U7PW9!t FˑG֯Q2JKJV?T#1I{j%FFA·淟rؙRkRk]ƺOUn+Ÿ= M0pR9ۏTQ~C!*S#@tH+Hl_VGU~DoߠKݩ.̌vp0viu6v za>."Xdt!6ʛg0e!|Ifj/f<:w^Ge>nՔ&Q–_fb+H,JsEZK U]ebYuo^V˗rƋ+A=)΀9F!&HI_eOg+[i@vHԂMo#7 &_S‰̫IqӐ8LLV>QD:9Ώz#v)>w?LC~<|AeQomQhc\|)zA3llWT_ڢ|jD^'45oH9i9?SUwe]&^x=J LQ;.9]%%J-Y2 qxy\l0qO׋<@ :$tch|X&w0+&73<(CxLM{^{n2(~RxlWN[*_Bwʵo3kQ~g C/zSXig!.$i"470. -p{: Z4̲RH9Lagw>f>XϪ%F(.tB2/8VbzqS+ѕ}lاW2GJU3b/]_ӕpϑc0̕D#Ը?RQ+ꛚ[28*q\0A=֥Ũ k#x =*9 ϵhyf#C?AOR/t6]̘n̮b_DvS{$[qt+mULV)pir;/ʽB6["*TGtB>. %%g <wu*Nߌ쭓~<3ӶNH~ Z3u>$NZzU!qXNбJ<ƀI ' PUk0%@ 'c0̅J CN3 0?V;bwb4W,;ġ+Yȋo\oΓ0q7wqFP='E0c3Cz^DE`/; zLQFb5Tϧ@@+my>KO{X))3Fjx[SjLLȪ9rII}B)@"|yrv dΗJB'Lp\硊RYC\2NyP6㜣LrJeRϽNlCutEǩ!!?_O^U_sβ(TRBaviC=~7=˓ +`+|tmUэgt }n_Sj1i-6* mI+|bàvSLt8pJbRDK![a {Iϛ{{xr 7WWT6u|탒$XH~0U]lZ4'\9SAŤ0x%eyR]T(`y$I|¨ː!5, E̢Z$%NV$\YAXpW_lu,,T2ʞXgmg۽=Ӏ5 J[ޝ[Fq-uq! >B%Ttܮ F^3`U2 uX;V;i̻N_ *"*su*4QE!gׄM1ۆ¨cq\x$Ԭ "dҭAMsmYneg͜'vV6{^\ZQrc˾7%=kdo>(cA_p]Tۣ,QFo]4SҦ+U./-H49h|[mv p ]UOV-eI2jֽg=A:Xʝ#n(.S 7yꅙ2:ddie ثhV+jbkMVMٸLNIԒ8_>]Y5HoV"-[VL?ȈwS-[J69ـߡBC&-^v2/XDž-СP ٔ{@Y#̀޳.Aua9:/ MɐҲ<ęo@*}_ >Z#峇}$^<\#G '=OFL= ][OE5~>܈8u]Gn]Uսbc| o"MBpgo ĔI^p 2bu/K7af~.%2jq1q}uoLQIEs4KpӂdVzlZV~s +R eJw2amɍo= y4B{RrF> ܆T:rL(fLnoLC5VO.rJPl뾽OY3#l\~t6`Q3\u_:Gm[c" >g9% YR{e&S4+sLT00Mb16}fLPBfF IoTĂIVÙšP!,2dG|a3 $$\ΔB)82H6M 8&0حW$TdlGdPhc22d;,Q:(pc9z'L[@bUʑ |},S+VmvѬ27ujA%#$/ jMVbvCR_mܬ~?4:BmfsUj-U1o!q&ˑZ|vM4p".!lX?d0԰p8Aq QF畳6.twΪ#2Q VAGȦa}|AGaAJZw@be `e*Y8$ĄI 5썅id Vt2 ?o HC_|U>tH$.ݏUѠ`ײ)nA86MϏ^RX욒i2㻨JUr=\]4tj! >E m]8 Ud(Vx n # LzX_Jv?9ntHqkdg_m|N3ۮ Nno?F@?댔:EhRs^(rtTK8`oB'~%#>md;zbsSq'Sh3A*ӆ LK\ӓ,|TpVvƱ3.^ksMY\?pwcD]V>t2Mxjh;",WI oBtI:4E> ezh幠ʥ5:y 'Ò%1<ǁ K+AF^Rͥ'^lP[~JcIQ$*z0!egA\z~K,GCw亪eQu~羴K)]E4L1ޠdC,7y,U늭'\4Q3ey䣼x]i;L~8&Oտ0a0ě85<%%n 1<"MxHfoԒ?Eׇ [IHr[!6w]=$ X8ܧRm鯽,S(NT)"eK:\ڴBAIW29"M]KK '9059}>$nh' K䙧ֽHUh F#83~Aa&E"jl[XNL.(:'ByۓDzL&r= e1JNcKg.1c䠾GAN[Y6q# !nC<,e qj_'8>v/}d/]Z;?;/Q v7Wf̐{L2M֠naNX/m#ls7~lܟ:U5I;y|dK?c>ͨe#&cȤ]N`g"Fiܠ԰JPRpT  /Đ.z#+UY@+~HgoOҔ0IPZ!. cZғ&X&ޘRQK єS/ڤ|-4JfI]5N^^ };/y]q!GZ[e;s/b!igXUnRCGrjNr7H+GWηK%n{h9 1 l1 ;R)N#BL93S棄Ӑ%W ̩ӆ-#{c7ţ 7!U3[lmJszʤ:mL"uHo^M~[ďK=Dz^=K?c 5EN!5A7jACqR>m1iّg;mIE !UŞ!~ʇecxC#V`Zuy>^ sb=CB)! CYl+drKX;i0!b @Fi$<{5&~dU1QBZJGj6A6w_63.{bAO|.@XEFRluE{ }bAv;|@zB}Xw:J*?7[Qm9'2U#A;OD W\T04^(![7G l)n)h`:&]?DݍbˏFw6aҟ&sxG̪Kٗw[.<8F3".V{(:{o0?+AnD#;a AU@s\COqb©qȪS{ibM̧e({pډJ7)z*HpS5O]FEE͍Bt&Д7wimB.9*Y2afZ"dwpZBvcNX tak$H4iM @;ʨT V۪}Ҟ*'s?$/ G t#J [ |kp T(Hі9#ΞrS"om"WX{<WGJ,FRmbVh7-.b?Tow4`x\voiHIU#(%RkJq<βJ~pb B{L}_KZLSDPBP?!4 :ypm;Ieð3.)k 7h = b a^!yiq˨U|,3N_{Ͻxꂂwu(u1|r0 = :Wv!mg)t|c5^{r.Q!2Bt'_՚ܠkC]%`[rЬStB7o[="3#SL>^U HtQ䉎|`G,խ|} cĘ2e_a{BMOCctnLfM!ЂI4 mWA۫AU{DA2|袋13KNum:vu8kx1Bx5՚ɯh|Ӯy빓@ t]X7Ade|;}u.Kk)VآU8ʯo8r1bp°C Z3k.Bc*z|i,R{Mv؛;B[G5e"pmi5E'< ܔ9/aWHqfNXT하(k6wI4Ć_STAM $P4v'G7sAy+ ,T91}!z;id&XT%VkufVp\蜝p@Ru7M.5ȬV *6 =[mK+؊utgqeN׆L#\ K}eۀKBƳs{tǽSRP L>eWo hUim5r@MJ:qIH}{!%gfk>aV $mumA؞EUp$abALJ9-BOp4F&܀ za>luKڤe){.CYO;3<&{مa>}^-E2i"ڙj㣱"PKwaϯ p;i+Fj@OUB*^ӬboQ):sWqD0gWu b2QhaIqQ~K]d#8A_,'r{rll ̣. .b_b_Xr7B wyӑ$+ fm͹@> բOI[J>!)g }33[KCeE~v sfP}Q 4U.9>Dfv=gd$ώG2:XVgD5nXLﾖ>FSYX\Af`]?,E3kKfC5k@,@Sl$tI}3bGsR&ΤnJȝ br`[_DT- 3ױ_55YOy#49ĤdhS, 3k 'Nm(zD7bp2d|.0Ϳ _e 䆅<@"Ȗ^RU|bbkgϰPi5?k) 8w2UĹt%xXh΃q #4*f?VV^iGנ q %x0Dd:0:JWqcIl\Gd;{'_ DS"+Vsߟ.m#*؇XQk'ԙw( -LNՐAU,<UMf;mZ5̖gŁ>:>IhM_=䤱@Pz '%m|i.IkJЪ_y ,)c9SƿT6`oqDw*᯶ bB*ߑf4ߧ(ʶ<~s4B`pGm%z,Slxqk+;^u?S.2u]@l~ɾxTbh ;ک06Dk2kH^!li/cI0|ӥ|w4.+qy϶idPEV~rl\my/~mWC8%_uKW$\?Iz92Xvp![^%4Hm/q-ibGBo Q?T.~wGDUy_fvc\hBziJ_|9ZoOb':.|?"7s2c'j`^;a6c`Q|Eub#2g *lʿQ܍GکmFFd@xJѐAX 9WҒ2% qa`9ҷΜ'*ܯ4 .vTWpKm39&P=HmuDq?/pFOsi ^Š+`5EY&ɂ ،;67ױeq^3kV^"=Db'udz]KKg1 .\.%PIr=P Kש_Î:& x*.!e"udޜ 7%,ƚs_2/[&>Um{?%!Q_v Vy`t|5Bik!^zi ;2B?A+w+1~MPOWӵ$_5>R=L7lQ t+GҒ]nFf-Jpetz&|\aaKoާ-~rik+U}{# 5-,{< &j[l##ʖx?IecBR=-e!8Sә7~'?{\|2rs IZk]$q+]XcJ8Nܸfe)4=9,5H)e II!WN^' oEKk dl' rrΠ*r-ٸQl8t+%"C @cKmree $VQeuol{FR&54P< ,M# U]7 iG{s8KPwd`ݾ#'iW N:ލV`(SR%̔/1#04^/@4x^roVGA)ht z/NoőOr[ [!L.hLbk{hUccVNXo>6 Ъ8j>?'#D2>#HУH^K[| >%J.h@mÖih%gѼ?7'$Bf4_r 1bH{s]+h<*/֪M蠀#$(Ee;eθ4P*}?QzrGrY9Ev2('!Z b]0g Y !Y`mOoF'9.(URfV_U.C.@7j wil#A8 y)ў)K'6zG\QkwN3oZdթu36eXr3E pN9䁔dUUpK-)2u'b/0< kK*|P2G -9L4+NO[6\)xN{S_kd9V?Ohj Y"+ *b(, ``upF%ix3z3U1.]nNc88+=kܿ,^'*\TPԜ )8ϚUCfaڕ^Ū#Ɏ]_K#-a<:>s0.쒡C̀k |iǭW4i,ذi{f3MlHu ̞ X2o_yOaI<}78Tf@;}-[ "K3_wtm2?CoQ ^tMF.k!Fz?oT14:dGHzf[PMzߪT4gva&{%ZG?bMCI?ql:2+InظgU3w1[j_އe$XZ0pוb_Ҽ "Jy W@{(jynm^@a[8wRFqXWTF b}5)nl1 9)Swu;|h!V?衭 G}^u*9)U aZ|1y=vPb7 #>FR"RQeS܍]@X|Q}z?J#5$>Ne,Z- u[UWԑ3!dA2,1l1](;Ъ##tԢ=JԓQz8޼>Yyޓ  tEàdxX4|6VWC˴0p0V*pYIJ]ۯ9[vKMS;<E3C')M5RcTRpڻ>l&zvlUK[+gNp`cI4cY >=25.#V7|Ӧ*X`m2DvĖ5Mc6s*%=n6J>pGdaߍ (=: }3[u~.scJ#GبaE*8*d!H)$z ў_)$hݣaeKKbZppS($jL52xL*Dhaph/؝3AaRJ2f۬Ck''%Vno˷@9LVUnd, l-I^P$ԝSg_L{6{_Iܬu}wFx^s$'Z] LrB< ϩ)AZE3 yJl,sz TNoPp_^TS{sk5N@B{zbQoJt6~+![k3,SKFS"nN6O:!q:/ LKϣ4vtlrZaU]K(%7{ ڳ$[饛1KQm/\x[U!cGz9,?PbE` mߢg1fKa!:O.UV@Q4!j$ A8O.1rW {D<:[+%5GFZ ۚ}҂>ƟZ~y lSz{:^@qN JVJGs(jF7m01MY`m;GWdp"2|:tidiKḧ́&~K:i~S}fMzbRSb^cr Jj |~>;!FjRSR~9[d CN*SEnvC?NpmTTjQCmvag"1J iגo2gӊ}4Y±N~5AփNЖ/lL=r`Ǽ>o?81e؈k2tjyJ=K^aBa7}NgDz^UϫL=%>w 2~;F4J8<fIptR* ي0w{[2GH7!bϑ_#hʯ1""<b p,6xs! ^؎%5$>0BnyER$3]'}4PGIR~nX>č=2ǶҎ f&/gz鍑IGlp:?\7ǜ&$IGNv̅c%(n+ g SEnlJ<;҇^6x4Vts£R݃AT߹U}(&ݿvƙ(}<#glDa&Kp>57;}$gը̓b\8~"JiIS NÁ Y쨞] WǕ h5NY}"̀=];R ̶Oȣ>P^ԧ„w YSM8ݓm i dSO@^/";OZJPagnbYg~#rWfe?_ QM`,K`["D]هٻ8P^89F..iDA-)6Q1fPJ # m/QXi4kY9Kd,gjP L*&Ԝ+$n\ aP@n"Qݴ6p[PNVOtwzE̴ {7@DxKRy897;4b ;i'K Cp<[[~<˺º?^;Fȼ@:;yi5CrMc2_Eۃ&2|489P9Żm٣UyhAq6P6!=V:~쟝 D~\3 ȥ7n'0CMatū 0}Ur+MP|; Ia6n͹eFr[)7VE.^d-{41pհoϷ oz| ..B ]e/ oEL w.OotF4Õodj#}N l\C9/) y9 e4vC\c[7JR m[_\ngK9DkibKH,oZ[4|\\zI ԑg,)^+DCD6v=*D }1b%qeQjg)C _:v`Xda4v*D0oUNתQ+ހ@i1̯ۙjOfyފz̠ k*柲Aeş0PC)j.N<n,6Zmٞ39B}k#B ;@Q{6 "Ǣ莚io7hS8nm$`l]%wrb%(j$Í82/\9! $k ɳV&?a"_8:nmxb" H;F&P@ZztUC;bm܏W ZqO!ӧo[z 6 c=t lyZl~MclD # uPH0vs84;ؑVu}RS*4KSF굷e1)WcG;s@ <l98v Z*9c WD7` /obe24+zt"h͡ۅ팜@9[Z?A:mE%ML 3m5f~޴ @q(Nyqx=3%M~iFMfV ` C{UdSWQ)kC%w{3OɨP2/jT'իi~TDst|1f܎Ix_W&T͜s_y$fAmHt978!Pt%R>mQ6(x3%y4xRjəSFd0Tl#UVtOg(̓\JS5&-I^R4'&o2zxޓ⺟"tg`MMd}25FWvYWb&!]E4~PS?1ZGi5-Q JVdbL QQ"!DF1DՎ"j =J@fLTkݡ Yy͙9';$94(6{ֿ+ ېsVX$}ӿLZXC~Wǎ]<+<|Lʉf}Õh(ޔAj1 T{e鵨&X.d3ϐ@9M19;4eBK'蓴t Kʨ^w?OX:zѵZ <_GZ 0mq$ٱB(|O*$6̳jՎCd`\d1޽ Gon|M\%2:=a7X÷i x--'ߝ:XE%3:}|0](qI_EDkNN 20e+jMR=xA0".sW#?ɺ3BYmrǼ9ZtĶ BD$R7^pm-s÷h5K,+[^r$oʳ"Wjyg~ 9Eo,ޓ!:4 _e!򽏁+HzM+L^+ODG(}0;®Q:9>xTp,U=;H:f?5^t&]ԏoٝL Nt/?uub=N w`h~z93yѰb8qHh`NB@\Itأ#$~ze bE28Fzul7{(d_ Cw1vU|e6K+] H5 K]x2瘃.l-}EQ-EikE6ӯOM+NGM>p R O#݌mȥ]c$v&;̢tdƒ_YlTo"hŝ/T* "!0gǨ0|JgO2$cV/4ՑszG$%><̰׶9LaU,aa2TdٹS&lꎦ ]xm$&f?z)vu gXbXy\7xR)_)pz|h[?!̍_2d.J~? ) `zN -]=޽4?$r:'c=&B.$'Àj^QN9x5^d.ؓ{hbhjB52YRd%{tCKtx}Fq/PEv_/@ٿ vGW8b[6f>.>k Onl 0 uN@@„vDQԣf&Q+љHTTG15eR~Pd_\- ,bK*oKoMa#PB fYI~JXow8v347w $Un{T6&b6^cdA!A%q6^ .UpHqϔb@C)QB'x(Ҏt=+$ $qDRט* mL-g"d/ پq(ǎA٭{ :>K 5YnKg\Ly, ]m޷ᤢM?j[lG_L}pݵEp|mf$j3/[Pd[@#SYBI3 83u텬@q   j$߶n$bR7- CW(jn+_GM7 Qɳ7f]88dcG&9y R(#6[w&rHt >ӵ01?b8,T_vp0?X TAHnɵ N ^| n 7h^0ڟATS'B!`V ɯ18aÃs<8w1C%d6Qqm] ;YuTS~fT ^'9sS6_}k@WU3o|l ~ *BwH; <ғ$hvi /y RV AxPg(HS])td7no 4)\NE I':S~+&eE&ИT#:tB%{.W8@N1x|S`L߂ᾀaXlCmTg> wtݓ(N/ W*cUlk#Q39IN“F:#XQg3YF]&CO1lSOAqaC2u>Ok d4+gv#+tOQ$"#@nd6]~y=Z3lSi(,} UUIyZ~eb8pcDLO4b)kR3[L03pEvprĞ{cS/hQjw>B M0empݓq}vQ'~o#-DeOh+.y S < ˮ+|UtPSqB*oHxEGn'|=A/jj D_2}­Ժp7.șkS8[¬XT^ IG95Z8N*r~Cx2?,%轞<&M0*@$,"q_m ;NC$S㔌7<^W!m`.P'BMA:aCPbHqFF2m bAd}("y|>(pci.2ҤSk1f&{H t[]6>=y"G8kF;k1++˘{BG 9ge>"Ϣ}B6;6vFIIrpۻCYN9#|}jԅSNI-{t ;f~!3S4PHf(֋rc^JZSVyR71՝E lp1I`̺4Y\ 5e:JSNj[nn9xװj=&8p`3#QF{' ' mgf<քD04""L2? sOeAn7}M YePV>UЦR4+F}*۩#ѐ9++c э+˔(_6~ Y:Vrп0kUJ:dxo6>,/`[$qvJ/?#F\)Upp )6tqZ߮ի$bC;qgDRy\3k_%:%Ϫ &D ;&{M tZBR~R9꩓lFH,u!EFSZV%NK1]0>eu)P1#yMJi޶*3B!Yu%-#jrI"s\:DSLd@$h"-+(fOHV(W#A znm(%H+D >ulR'l%#W[]~ӮQ-wETJd 2G,LݗȚR?1߫>xw+n6P:\; tif _ ' k.'v2'STȯ,<5y@p1}[a ! YZZwu)"w=5Cw ;b=E&V\ !/)'pŞiwK3A(]*"{B>%R_Չ8Zwb@boh[1=dU#o_zzx* Όlg4}lrL/edJ[Sq (\xkHSY,BV/6<ԋpce(DMmI^oZRl )a ; @D!aT@'Y%ڿgC]{U"g^K_J4<#FP8$wqAf`j*cTl h%`C_ K,VЄ8f JKTð0:CT$VwW3*E}Ch>D^>7c-U416`uo~.!?7(Nzl3_.7$P02o98G{4''Za:`ݾˡmym}zZeQhc 6<ֶC~5N'[s,&xݗ e񍫙| j< ?)vumwR* l?rEG7C});i6jk\z:՞ BI9;YZg2ä4`׸d6 q0..DvFIz|/K?jTn<`y ?Krw]+U[Ņzg`3HB]Uٰ<U0s<mO~IRV$romQP Qmufdfp]:RvRLjpV^ڔK-ÆabCKw~ "˭#.GbvɵŃ:`*8W%Fh#*|ntֿDձ$+%H TV}C~P͒E0'q2^F5 ?{') !2M6OTeꏘfw(;16 <jKYpa0ly/XxBXcg6$\n!I#Ur] ?RA0( ZlyH^)R=uih&R/BuTfN^#s HJoio0àJF~H4vf|]hޒet2 `(F/U2ݑ4f}ފ.#֘N!+A]!^f$V57)xSwuMN0`C*)Il?oɚPܯٙ!K=&_MqO̘$n7W?+X r'޷sL$C/Å]cZ԰]tB`2rђ*N?39ds4~5%xA:aĘK3N2a#8 ſEl;PI"6Q_Ej9V"`_e7~;z Ȃ Lݞݿ!*EQ]2@GvشY %e:qjZ[u|4~So .!?ȿv$ u(#^vE<Ԣ]g]gźB=jJBvzY) j 9k#3yyw|R\BΈ?H ' ~LD,“o+|.Fj [[A:e`۠a} t!؄i^O_;gR"鑱?MмO'jJrjb$TA &-&ܔEbl(ZOCrq[ )za~s˰̀JiDXĢq,2E;b̙n'o&lWEƧG;=ᴥZ]2܈ 仓 1,]V|Po +D+TbQsq.ms |Zw34 f@1c%kQ5 uף #V]K?}pU[ٷVm~:"'B$,u91x5eq'bܢp-3Z}yyPf V!b%Pd6m)}ou#t$ʓIXe儓 (+qv6na`9`ǴgpzRnn_r! G.Pn8HYΞn9p>KAv0ɩnQ|CzO[`x&q۶;m"G/'2k PJP',nIaHrtHտ+yϼb6A?Jɇk -y aBxX}X@ndp䤔@Tb~˕EkMwa_x '$OsQ oC}IMf+ݞn(r1R1^J{.&N+oELf ʟdm=r SWMdz!珽&OfC@;\E~#sk-?bEgLw)=Z`Yέ=Fut21B&rYiÏrqV.xz7i A$DK6 TD2O4x|U؝kmf):XKY@aby# ,-5#bR~UF!%z&](~a &ԧY Ny` E$snk%9rPdV¨n]h֊6|C;3˨F`s%ŕ/fWAzԲ biw[w&F  ZBlB"E?@u֪/eN4s& zƷnz[~|hd=j@4q1$'Ixrq^WŻ0;D*1y:1SO-ZOW9H]q늂v!b+E92fX(GSmkcCx(c!BlrJps̏w?-aGd$G# GL1-^V*Bl`hA,uR_jvJD9rgPK؋Kj9 ]2-fOFF5hfm^2y|APPK ~W`VXf"QQ#HUsZ^}w4̛5US6 SzfFLmQT>WIS#f5glƬgX:qxA?I:7kloxs3k 6ѷ1(ʨY?u7X(6E82"tItm^yTKuډY;DqMrBچ(akk&^졺?Z*1$_ R߻4l V*87eftSF6Oؐ%#Oӿ+t4\?sي5>A\η8qИ'l&š8 K?S׬'?UF2zZ[:$QK14wDS8B곤zZﴱ=y,[3ܕQ _I9 xԖdV#63&Zj"2oE 1sP/4ԓlvufLֈ\8Sn)5YKh,/@BҒ[QDh:L𥆰ۣJ}9ܧ<(Н~yYcGcvgikak~6YXbP iRfm,`n/?&f8Y#ܜ 6tbݼj ŵLGSlTRV6K]癥,Q} oxk~dDq]NCʊN( )sM捧4P;ydta8`y?W&R:K/!TA{7IV\ʦZR9RKqZE 44;iOx2Z Çrl.Z9 p>ς %Q<מɱ韯A;P'3y { N79~"6)#+h?D))qLG3CKkjf0A> xrvf}xUjL GJî4!"d~Ұ{ PZq6d)NϖX}eabfYPkC{%1 ?q%La"|ԝ}$^6Pî D/TkeR{j oB0qpW= ܢW)T\F /=l,{AQ;tFJd \vZ0@WAwWnۏ¬XbH}#Ʌˍ dǸw5N3v(`LB.>[hEa;q;gYZPerl-APIReference-0.16/data/perlapi.5.16.2.pod.xz0000644000175000017500000017552412044665211017532 0ustar tseetsee7zXZִF!t/%]c?V Or;6ǎ#x=j-CTx+'jj'UрP%p 'PQ\Yl]*({3#D` QYnA֌3)m(O0lgȾV>Ix2QŏnǾ8YioaRԽwC+9!74lH(*3q\.gfDfc&WdaU4-|CmnTsRFhɯ(}E Px)\[8ZAՅ?=4&k}!N.D]|MLB8Z)3l+Ni v U?CBbֺ qtzG.PPk'*A!érVqYdv|g=nҥ0PǬRC / p1ehs6fLظ_ M'V\jf31 uڧ =#4TMXrﮇ>&݇&[_z/x PϊxEj G~NGywu( `t -@V1vv^]vΫF@쾉.l.p'oٌ')_h}s򹴲3v#k88-)f~[l[9E2.ncDnZܙ9P?TIB{ypTxĵ\dlK=/ Uŀd tH()œ;=dm"4?KeG~Z}0QDXl +ozd o@9vvHr; 둧K,<)lGJ)،:;ZFĈ1}Bk` !sg,Q֊ 2:_NA1 $t+ 67Ap -3w+%Ƀ|㡃Av'JҲ>K<ՠS}yշ :vT&m8uoª |o.QC[&{ 9A |u޷b6N%܉GkBi Z ;;| TҁS Y^&`Z3[>sBtQr[ɿߵzmZ,EĔX+NbhAc%D>~)LzJrg:{:IP}p&)I 7/ɋ^k1C3i*˽HoB(1;F"Ϧ-,$\@ӄU֤xARq@v2-#dF|(o v!J*7gHV{ZMaAֽ|H}0##1h;f.:"QQn+< (*\؇84$HΌ!|+U|D؍ɠr<.hyxvh G&iM/qa,P.ǘLX#3ϊjDX|zG+̛kB4UrfͲ$]|h%4q3zۭkN%x ]G8{xM->:Q>dl;n'GMN̟~􎙽9@a6뒛baln۬jnw8p3gv^{ &U4#YEOn)-\l$友0_ i8z-Ö[1`?nQŢv#[:>o1}> Nrb8-e_yfx^ufWYEF>HGn-5Fp{%xk!K0]Z,/?*|)7ѭ# ݹJFnwIDh}XpSPgF\};Vݶ-3[cG{klѮlm9Q0rTX3A v¡?> 0 $ d^ي2Rb߫1cOa欤?V%t;]}\KeV~VA7lJ^lo(im K,)I-$[ CRgн_z&Jcɾb 8矛qB FTD.}7,h6 ZttII65-(shѴu*v_P@}Ә9dݚ=e|m $&K3>=|_.xa*#Offw0bўp r8ШwеBQ +uyKSh*Pf=ٯE{I׻uh;+rFoGjz<jՏ,5tmrKEtԝ (t6t]N7RJif~Z"<%gbTx]%Ȼ8$NP)>lN%Ȯa^m*I(k' UrBpA@ԞhM)oYn-qي@v? RǶe806,;ŅIIl:FN*ؖ4qzSdSFhZ!>=Sōa1zKç*7Ѿ`F!KVR`PF4-6h^iijcrh]=W6jR@r)yC'yVj.(TOy=!2z0pBu,-\Y3FNn?Q;Ev\kT*}9j[*<r*b]ftnK#*RFMI_Jw t&Jvn"&Rz؝4E{<~$M{̰P/[q|ְz/P<5_DA,WV]Ũ_' 4ta`H_H$`WIVv0lE`y9d|?lrqO\-Է)e R &߰[3/heQSt%]qWP\Eu7](.(FT1poWÔ6Ŧg_ }oR1)tk<.]/&ϦYb 90R/ ImjXwxxhSmxJ*bOp-/Y]țr>j="Nɒ0*_ZI9ra0|^ǭX‡gx+!Su\)kKΟK^½N!) U cj;wQMS_!o4↵ūR =PUȸe]e;Fj(x|" oΛH VNB\qgۗ%>-ɐ1OɇrON Bjǒ1LV3/K^8-kڈMAjh@|Pw@ݾ6Jzh{ò&JmWW.[?b,|^b%A; xr.n;G_%[DGH=GXyV0~!5?ʎ(/WfqR61X޽|;0%A֢>:, qh \%R\ǛF-4WXn\|_3܈m/G+_DK)I`ao 'lW cg=[ , 18W5^tm'hS)rr¹KdVKGvAkGRbk옌c6HgmB?av<&/>+܇[(QLdUx)Mx1,,dҖ]GQ5SbS b67h;ɗژa>5!A!+覙Al6qS ZS{郓gЇ+@ u0(̙=Q&WJ2B+AL(GV ơ.٘ &GEh0kO"@tBNL¢1 S`5"v (_.PBipcrb0*Scoc;;vR!Լ+Ҿ\Dp7n rc8DbJVdĝmKkP SQ4j6m9vm#Ve/%S]d[ߏ+Gۃu4AO8&87{~ä(؀ TN_TBcݍuRGj7ܭەis(eD$E&Z|aꡊQ{` c++ LjݤZ[4X$vЧZ.@t62鏃Ltck\?j\ ߲%(\j2 ؓJrI}(Wvƀ:ANGlVXI၇L5N_5U^Y(.1sF@=Y\4O  /iܩ1{]gaqџU"%y gclUZT]-1ݢ4zm:fqNRő2B,K;$uiPϩ_6P48UKp{؄Ogk=sB l~+cpsE\h"͌#o*x@JtB|[=NMˠ#׷º:mں_j9mU0 } f;&հ2y9{[3U^rAAM5ԡ$kgu?6̐iRh|B]RjIaP G&Iʲ7$;g$:zw!VN.p\Gj=>fid>+&~t#tӎCJmQ"b{S>-*^,{{Ve4UFlEܷm}G ZpR qF@6lR)zR2L;]t fFOfr庩`:gI+!ܦԾRZAp$`xH"I4gSCXnׅ}T%"|uxi3"hRѪ%JTh #N{|ɳٿ!Y+kb oZL;c;fC c~t\ MϘ0׌a}CxwH\2`*&-͛~7_,&($iR^@Ϭڟ{R.UA-3HZ &HQ2Vj>֛]BӔ\HːCҗ E*jMfi }*j4#sS%8Q[AgMQ+A Oc}uU[kՏ`e@6Oe;W{)Tn%ScP>"e|c1ܻez=::!XwRF؁HmhDd "?WT d.Q %c"|4Y5I? ;y2<'m$Y!8T[F2J&*AVh {K'8wjV@]R`>BBʹ}6ϹοJwB"#0p ZcB!+ nq[m GL?)F{AԂ]t=Q]X$n~T?%=YcqҤrjo_T>lq}v _p[&s[dS b Ɓ 9ɜ=Zns>VQm `P0|$Nj[N_k }##)= tfj] :tTe"#ɴGHTSh@1 ${THFȸo{ 1k*,`3F7,?$ @چ@?Wq5]!. <$ ?LhT($糖* +5BѢ ͌={{h`|7_F<︻Okdb,q.0†H cvE& 4橜위5w^KрrAqoQ={LQcW* 2)۹T@CUҊ,銞&<ҌR,IKHcR=puYйI1 ı7p^cZ[ev3!;w2 bY+2囄|;E?1a8mj$C>c6uj1'kL%#y6a@:Lx{Ȇ5&qls:cjμY"9XNWB{oW JSR:HMt=Nܓ} }; N:a%?.oQ0QbV-$CriKܘE1ۢd=jI;Kbz_hK<ÔwOfϿ*EpZPU^3yCSEHL'JG=y!g]>W0Wa(Bv { N{'чЌ^ (9iX9#LwIKկj,|8rslmhs`-Ljxk>/#{H)1MdxjL< "J  o9}!Cf]qqa=fDtd{_4Bd Mo$9wmcimycPTʆsHbؙr['9`uܮViM"b}ŔYXf$}Q쥤PHGWUğr=a (Q02 %>wꅾL!{?oN;Zp AHTڕSqOޖ8-8D|= $BBWz1X%[j׸J z n[,HM%Ehj %4Wm b0_!yuDODm~ 3 %}jG, S Ot>'|Cnۃ +|aꌕwb+_('%T7& =CW1 `phKǫcrB['-{e,p,GV2em4//اZEo"Fhwl_T63DNd=P ~ڽ+ +PKBz8Z|A%jA W.FT/~Jja\lԧ YmRHI"m\&]-[!^%]7UØvS*qm.'_k1j N-bȺ(:glu]hXx ÿA6G~dw8 PKY/c_5XM56'fFܧtŻE=!nė'| hUHᑵ4>z+Ao1 p9* ookqeTar:3x"faAz1ր#: m@&|,[fR+ZXav}s(v؛b"n)!`#wrl-$ v4R(zV]OGbjQEcQRyEmo(*Zva#ާ6w@#Jir;= G&  $bQ=ŗ#m1=/pVA:rJIK8tN\CۻKQ:vؽӣBoc}7smJˠ[BQ\;nbAG蕿4X43X~ed7g(M^d AP?D@"u^afsi!'3sz.")WE7Kg3 N8v"z`UmW^Ȋ~ -J~! OapHV:ӕnO:o4ڧz;=1~ѣ*&hgf*]5Xe6gw/+@0=KafUeaTECx&E҉} 61P`sŠ.& 0o{$-TBv'R!,F ) ;C__ā/NګdjciXf 3;z.>&6٥(~Z}bRGD8󙝤 W!̪Igb#񩝌ݔ׆-1AhY%QmDRdԜ6ybܺ 4vNKUp/zBX̴"vsݘnK.zuCIpR/ |G->׆B#7o$ar]F!kJPҝqkCwښ%5=\hjUmo-_QJ%2%i(ꊹIvRo㊖=LY>Js y2!p)_{(ۃyĕ@|ָ@}m:eǚI k)9DZ/5-Vگr8ϽBe޾{t~teߣoс_υv5tfI >("G~n&@N*ʳu \qкx!'temۺvsf@r Aa a˛dӘ[[%1qۭɢg fà9MRI7xاĺ@@@?r6KtB6@E񌫑êsd |.>X0B YY:Ι;;T0 b`Z._eJ=U>l*+#aDf9Uf?jp~n]z2 y+NcKɂGOPw,6b? 9|22m^/HQN'f9Fcߐ/Caa$)ndS4xhB*ql|_ hng"ˡm+k];?ED˕)fr tyH8ulH3+\ztӑD(|h7:p0*Fdjj[Rh,]yƻFz4tp)ϿBQuɃ<}dڨ*kY]!ΎDHIolNts0-Bb.&q/SR/@I:qՌw;>5pZP9HFryQ*(&hN*]w.{QL.R˘erؠtkiF W0&Iv[`PAX}KGz|-H`  hJ)%DV ,Mwji65&Fّ&\6}iͻ:mսc:\/2BcynyC9b.א=K,=01?Oo)l$3POš|m]< 2nTN5sjW ? ֫a-/`gx- N} x\6"_+^nU>nJߗ~c[nEI)v`B:@rLNu!sj8=" 'g6J8L Oԍ{*<)[Ust*ԏ(b'C>+z0oM}m= l Ո|omȮŃ &Ҭb;=քtnݝۘn U׳[::5Ɋ\ [:~#n_gL#k#yKU E1J:O׈…"dvk]}E-3Yp~ºULړ.q:(@fVLF{Gd(m+H2mc_.p1`ѰyݺHY󂵯(JxJ7)Ze@N0όxl!6 (Wiʓ}'ea{cz tb$#[X]eRMŮU^;e*]*"Y9E5YCbۡ4ip3sCP]T(_lgN (u%kO$= F%"sa 2ITزެi﬙Br0*RQP 52ۃJGϊuCB$c&!y7Rׯ._Ltmt5?J&6( #ru/}]"l~QSܝ{>YaI B0Ѱ5/Yw&H3] `~ɉH^+.!敉l_!U)4qE#HL:ى*} T۬3Ome%ݚ7S.t :>C&kt&s\s/,榵`[AUؘ=&p )Ek'؍C=6﮸2z/nR]M&Ga^A.1ʜS:?KBǹ9aMi Omx6iLʍ7p 2=6_8>>)ʸ2͑a(eAVd@,SBh\s 3[eAgyT:`V$>ףNQg:G8vNAN.H5 ؽipv`=06mLmsj7&[̏/5BekJO]xti\1Bj+7?F!*NH\\~ǹoNd<}2pb>WHlޫ5d'9_3p*%S!7g,WT9x!C|t #3)^sXIwj"zw0O>/qyB afuX3Z<%̂RE!/$}fMVxDeqM@k_,R~?O4j!;"HfOn?'K RsܓW*X2̲*d :(GbI\UBH 4.QV}_ίTe,%tJw=XD7q(]m'eFgDdaYoikOnFgƢ!v!e.rĮ E<ʲ.jW 5l]M Q`lhYk8Bi-;&L:717r`Van{sɪOϭid mfO ߡn1tLmZ5ha?Trs| / 6gY&Hp+Q;s{ژ9`)< c{>IS_:ځ(I6 Q,Gq ]9Ɇ#{Epb8_=mWok@¸ɯ=OWM<9ߟ*p[NXt^bōRu`jsàU&ֹ{2C@* rQ1+(0^7ݚvcw,qIJL[| ѹǶ;0@TV}E:>ͯۖ !PET@H.^F6; 5dY$X<_b(;5%sJ* z%w;dd4ʄz!Aь 3'>=*N/h1۠#Г\m9(E[ϕKNyc'aIcUJO#`0F$_S^LuR"O7DU^<3IR`T2o]M(s<ߑ*W{kr_.Y2Mo4d dgTN9AȏÏYw#fY{U/)Yj$BQ3Eڅ Ǫ݆ܯ%Je/@[S <{ه%xIl,=[1ʣ̰=jK<}a{'sq&E%? ')aeRFA,ķ8"Bq^so$ɌK.l^,m0k\r^@tt,REؖo5-Z)![cx99 籈zO6]'muX Hwf=%m>a,xĚTTӱoIQdykO.a$TF鳆 M)8fAw}k-X2}VhUd&*'ᑹ#t(h9;|WiYv>k ")r+b[zP.F m%RҢH?"Y P2Boj=Э35`yfDSr?% ŚyR+|/hXuz.)>1?=P8sABS\x{5qiX? ng|H/25dp7Q5*A* c6[d뮳hk)L(g6o g^7sA_֩<Po1'@~3nyQJ}q)?-޺ʘSA+">PZ;QuɳU(CP FzG(WG3v9 -1|jHɟTNƗTV+ݩ걃1UJЋ dif?Ol=p`PIs@;ͳ9$A5T"׫< 3/k{-ԷMGM&[P藕zX]֘ lrQ ~ucϘܵ^򿙰$;ЯQ{| {Ge1*-p~]c[e]nIośZ+sW8K[H6FPFәvQt;]zW:jhgˎ=)C`rhm6r`E-l%Yd&f؆ n8JM TfLk~*p~M`( 1,LE  7zasEF!_RYc+n_y-?8nQNRr/|JJVm$j8N8젓wKI_B[ye[HOSI &ͪr0px#:jdW >Jula-e5\7Kf sJxǢ.˧T8S<3 Q44Xt\mΏW̗GinN3XTQgi0yd^}8ZEwUs1k@ r *Uetﭮ?ұBA4hMbEړ`w$' Œ dg԰ "s]'~ @׹1BL-cutC4]U,0rxXL0c*>LJ_;!e)O,cdS_70,C%˱՝A{ul|: b6K#s<5X4nFQsi'т) z3CqF'56WFfxe->SqMtc+Eܣ`P#<8e;Ʊt>:7? AC>ni[ c]Şt;o EnFz`~PŢegwi8ÿEQXu\rົ%M llJqa[֩&WW0\s sJMO,y'{ Muo f gnC~:C#=3p6.u`a?8Y5Ѵl:HZ5AnRFvm.XC!Hae iL!9Cȋb}P1w)s{,uZH4ro;֪RNᮢkh`xʛ ιGz rikAu~~;~}!⛙mrI-L1'1Bc'i"P N8>6cC^Jѝ\7a`#Rzx#\@~'|IKupoMw㐫"9#,bh)h8ϵp3zN9`M.1:z2oQ:O~PG%iǑPK4%Cy*?;-l1HOEk/K6]ܦ!٧&GYؔܵ AHlz˶]v^;~35rS^HX:ԑ~&tO \NS>يiܫ`'-8"f3+2n+Y1`g+r(¾"&Ӿ|3{>kˈvvUOv)e"##55\ _mQoeg4!,r' W p8ҫ$c l/[I.J?4*!0){f#67M`}l ĩv{SH3# $S&GqJpr!>yn3$&̠U=;ke+hbǔ5f}B呚{2,9p ,F.Ӝ 4̮V qםr*ܰ;2m5>$tt&D̹F/7SWkt0JY><1aK5!{?8*gw(Bic0?9x){edQF0op#D-.*F [b2hP}W>ؠ8$ƨ }lb6Vg=(gDgm1ij$Lzzt^{FdW}Gi(]9R'<]J-LhWwy#d +#6id4"ˍhQL5X)&hrÃ+Ēm-E:BZfҔ9W7N (E'Ud(SUhN:%k7M)d1Lj [SNs!#a&!*y!0.$9Zd)7OԪ.=c<'m>Q8ʲAVo;{aqƕ*),R1A4xElwiP^6V`Ym*1Vŗ0026%L 8@UObm;}/u~_4po+3]ڑm˫)X6S'V44hOx.%5cmya]X DIm3gOq 49-gNM؏ؿd4ǯIQ[R#]{/5,Mtkωԋl^%t8-ꐄXU#J9zؗL=BǕGZ X(WC%Lǂe^5xg4{cPwnl1C Og)˽& Œ[Q;ÝBހqTyʒZ6s+l}y% 0hc H%~u]"kSn }ݳb;,yW8bfuz#Wi^ ֛mM4g -ia!c΀!&dS1L{0WWH.hWށRW p}|dQv7IZ'f PjdJp#Ϗ- Cx(E~ A٧DNZ0:+TYbO, 8 0?u"oϋr B_&tŠ4P]3@#-. V$,nq*N.yjHU*'tǤs֮Μ߯Z[ɴ}ܥfn|Q9%D5N]P4S{사&?%1Gd}B5 4 y,I}pSbD_!ZDnc Nmy7~ [i<4dv/U5aV6 bcP]F,a]Q°@~N+ߕPla w%iiWǿH0$yu zW?鰲xXQF'(3~ I u aN B݈Aaà"F?thp9iDZC[)*Z[HSB'-ľw\.qtӧy\#I ]2* |VMlv#FUI/V7DbU*0 2K2dOH=kh pōA㜓գM-yh|`P!xpk?xh2ۘ^'uՅ}P@q%b,$3`!*en-sO+e:y-5}Iw)_0b_ۖA K;_K㡷@nY s/}%?H61i4OЭp,e^ޣR)ׯව'~gg!Wbde>IKCU ɦù­xn澧[IK^=Xi텲geFK f_/V]$:RKX<%^h)19"GK\ecaV4o!Tn=iIdW}\ -a{` 5tsUR WN<1fciZfv\<Kd `4=TEELəNuoT]XЪRdj.e3 i7 xI9Y4/}gf`( ^dGSVU {jKGL.%.G0ݚͲU&O.{3SZemC"8T/-G髬1l1V[L`p,j.gʭO`1EC3u맶J`g2풴8&zjK'GL^LP6޳8nF20;C\ .e/VY:`x4PS] {@M4k޸NdR?=:mpAJ>F`Rcu%*h'8{2_tW &ڬ#+`<ƀỉVR%07$aDbvy0kf"SНԴ]P\*$rS3f۝v[EKXk/:q҉VTCv"%MhE@v:6$%Pig0'z<- Y<0׀I9p<Յ ?Iț&\L1/X-eb1#z'ٛu* W-3X/^|nL7Y\pxyUE+)/o*0&s-ptZ[{vou_se@ٙ;#?`ǯ2swAD:2}i2~/9S5斵n5Ҷ-[ɤIS-8r=]\YeݞAB:|Ux3RG:p~7]65gOʼnW pY$:Ɓ٨ҖwҢޔǒ0@,_.Q(H zbCa]`HE)j@MhYݿOYB7DxHCH cqJL> (!"jP{t]\UNK(@E`Ue$_[ KR/\dJe5ˆ VڥWr"wDt?HM|i͉P=&_爷WfƦ\gӲ,5mM㸱Ӏ٠G I,iy9eVgTcW_nz(p*"_}Qs0me<<8׆$˥ %rGlf%y{ɸK_rw6˥q%T|J]v(TڻwZt\MO2Ϸ :2IFpx3߳CHQB,ܮٞ O-W9%$0yaI*NǷEr3IvG71"|! _rXO9 [SmAdyUwAx6'@X[WEz,=ϖMpP\xwRfmY3UL[F-OH?G5b@y2'yL[z;{걜j@d>=r\~ w.Б(!@Y ] 2e@C].0dwK+sݪȇ\煪rar@{%lPQ͟BHm$&yH75{,&t^lab!1t 3;e G ব$ǰ@/jfe݀ t n8N%pV(SY͒Vht{abEp[0R}(*,N=o>2c;93?1LqjhB$DA##uD%)K2GӞY_ªP)p~!1 A St)8=obz.ẁڨnUgAmt'&z]/Nq=|u*-(wxd0^xҤueHą2:fzQ2!8Ӻ(MGNFMǓ"@DX0;au(A"hE2[rz1OE̿`@pYpB"Rz-Fj `*(Y> i">BUG##w@RN X^Ĩ'5 }3ڒ%b0sœY\V0BuyLlŚHXsn'$Ӵ(7i70وPG^^uZtyΚF Kcr\5̮h9C"T%zܱw]ًtU\Y p{XRZ|pFd!ioARi!JZdINU=`z SF(pF]HD='ĶĩI -ǤU%|%/|}L ص $id'(K77h7iÐ>孼cKENLɠCK>*b8;%x$bR}_%|/y%L6D9sM^Ǻ+b߶oy:11wÆ1Oio؎P>_\Ӧ|  Ŗ? 壪#| VtW3 l녌 !^7s V=8~Z"{|@tvYUŞ7q mye+zY/bp(YMVrـb1t(t*2 hv4h j'HL\~( m R߉O(Yso~3;tϟ]ƵF7RYӐ"Q_2P e b˹ Yu  ڹGڋ_AnUh[!ORC8]U< _T^ {qLK=}tYh]{rĻA.yk%5Jtm%#cHʧ|IRιH٪cz1+`l~PP@jx=mQ<]%lQ2'> Km>"Wlfe=l퀫t@o^̝n{X!Ni-Wjj*HΆT.ZHuoQ? luϼ0e(l<_J|< Ft Fm|"7I:Z" p{E;%y[@/H9^አ˿>@-53@e~mHF_W/:c"9xykMT^شLF0j'ɭ#c5ܫ%D$:BNqq2KrKm  دe^eUeiA`m9S.34|5)fVTy6 ̨2])YIltPG{4g Fi7AmF25~m8lgN1q W!NK~ffWDL\dLh]kX݅E=H86ôYm8%@tމW)h $5' ?YZ-.V/KZ!Ĕ9IGY=ٌӣ TT}Ӫˇ|[1Y#j.DbpD9g"(Ev|bp:9GQH;/|` $*֙Qe׷!vFRP3S@Q3]ś6%X"uVki1^挗 2ɥP*$$x/KsMm f,|y ͈-6&EyDU= ~Lu+ ge@ qzgdLjGi+a-[-Y HoKP[Jv2Ɣ d56dE4J洙'3yԁ9x*ڹui^T¥AA͇ew ڏ"qЩ)uwiRr&LaoGtf>f?L':S FY,6`e.TGxE -ǥHIcǭ%f1xHjy+I=02eрJjS Re苚xioڵWQm] ?Xb{rgOmpF>ÓV-& OHVWyaC#CslPR}Y8`tlٴĔ=J 7=PS &v)[D_/-BO DAi>0,`[ jal# 7ҤQ9ii`FUkMC yeە!ށ ̆۝Am'( ˸ %}^,ry)QoL[:&ԗ8 ;%77.$q7"93HsVg$F8Gh︗?m"@gb7a6s .L Q*e<Ǵ&tUdc2r K84s(($!2#ϿKBVs^CMSP\'b K-Zڇj۞-[D?QT _G2aͳ[o>*a]D2!Ӎ <3dưgM*+DEZ:t֧6;nOS$4gJ },=[f!zӼإr ŲȱWKM[2 znONz`q\:ѭ{u4f*ONd PPoB,LCv||BDiF-J$0^DJ־aB-k7pg!8 &[M-r~U{}A/#T@SAJZq0sI;޺B"ʍ9EʪW{}fd lǰjx̔! XQT;g(R_rR"@戬pJ(yz6v6T*mrSG`ʣ.nQTc ֶ_ yeU "g{Ouƒ49YĖQ3꣞]`~qO'7N=KvJkc09.y6hI{D1t heGvTi4QM^K;bi+ Dͅ爐<ʅ-߼' X0=v-ݥIZ1y/ -(Gm+r G?H-@Jhg+{2}P| h-P<؍5 _97*1ټϽ[;bmQ\)٧Uu1' WΤ.Ŕ.oC\s#`J7/=;_PĒU!RM'CR`J>_:g b ]!ܛ: $1{JWGlAczf:A}ƲCwzbe>y ~ {FTݴU0;'H|YJvhTBv[!]g(FUSN,0EZtlkK%y aUF({cL)c-\uRl <9}ѵ3+g0T]c.hi^%T$4}2W¸,K-׍qΈj (8F"Y.pm*j2qtI^5RuR-kWK 5dݬmË\ucBWZoa9ҿ;LXՠHF VLב,Rr-SjT~DF-%~`n!ցCfj7,RJuylv]%/j/XTd#Po}4ShD1*H4@w$^Z>'0==fW1Vo|cRz3_`!˥ ƸAY@z$hCg'߂s6+b O W#I˝Ύ@:6^pB4n'#bv/:;$^LIID ȏĜԳtYY ^@ Bk 7qu-VcLF/AmD@S2L{Ie :_j ?,Nȼ7,0ef  q5Q^@! E+j]MgV{1b~gQ2>T^T6JB`z UnN؅pt0m!Y>RZ6NaF)ع ᝜nyc B|ܪ8iNstCbIӉ^ʓ1!pcHPZ(w^#c;#޿Z(4i_ >E o)QZ{4oRh9]DR]2YfKtא^l0B:B#Rn%uwNvP@n5Gec嫎 F]K'k4V8Kv?upZ$4Q2P!.4 ~JXX&VKoi60x^M5KRm?C%:m^!R.=#^# Za gZ WmK?-e I)3D;>' [Dӄ>ȥH+b;sy 5\ȿ-})}юϖ'4e$gZ@At3Y[d4螼8ڕeH8P6h7ɕK{tS9<q㦆qmmnmymJ;Squ;6*g}"ՙ`6ERF p\J4f +TqЬNEP^ @]\ISp1Pn1\#X4_!HAX=Qs-o$M(o`jDډ5RP֊=F5a&e!ͳWu7ܟBݝZ{r [A@`|)K 5w)`1Y)"WD͗I"\=%߲QfU6n tN f\eÓNVWEO1vu7S5 y"FziU-qc{_u-q$MO-̫q f aw۷H8~&hCBjo@zdCo;ßvy],$(s% hb 0͍0Mcli{HUCqL2|y3E#HKx a=)d$$mb{x3ϰL6rml'$AG&2?Ȼm /1`F[zSbO8[КζaҴ˧[Ѩmɢ/ŊԿΗm̕Itt,$|tkVk"=%vIS`lrCVM,]껵Ds3!s`^b#m17F4mMzk@6!6EVJRSuoڟ𺵳7fvR+89U-IV߆vPң^pHZMp`oVJ]ȰW<ˑOԗ:Wk$e$r2?P]|drJэw}- Ⱈ:td˅T١#vA??d  þͦ#̉͢UJu-~/-^SbfjƤ r O0s D5!op4qt ᕱ6 넓ybLoW~{G= b,>ޣ [ϵ1/Hq QF)4 Lu~p^6Vńr`'R4VKn`ع:~xumTBo (9qXR@?0i3)o* 4 ,o ɥ8h8ȁN8߼ iQ[jR` zʱե\ *>K[FjtF& #"F,ڞ!˸ƓTic^t$OY ȯ8oت~$:ȪrH LԖb --\6f ʛɏ_l& G6t Rafa9Y1XLl8/S`[sկJ'dT)!1f 7ty< #SNHEdmN\Dz!eyw#,_u VB/V)Wq>Nԏp~{s G,Ɲ;ec,x4/3v,BKNˇoω];Fq 2ep; Ixq!pRYntW[p*_jֲRh_UL ;ېS[Rd܅PmSA(Plp.̲A(ց\4Ic:8X|自hE5y#BMh81xJAy>@q4i1-33r,elqz w`AF}PSvx tC}ncnn5˩ojFGk8% M:ڿ_&.8bETbdV x@Px0 @7rݖZ:}?wy,M!D= 6$)#> ]y!3'>3WzᏩr`R2x](ol8ǔ;.W=d_%۝S0o%p A%Zוs?pG95"قi'LXk"}S Ż E3~9b!XyUނKTRl?ip5r%mDO?˻*!Ƹ1 I3$?`Wq Lo*gT q|wYwەـJ}Phq(= zz\ﺌ1xN~&J\čHA4A-߱挶cа1}ż6"o Ǣ;u>[jQ^;DCvCY1QsϏ_G+ \'h'A8$vQ!,?6تZbq/ӄ=W}á'Ɋ]%! i#킏bNUGʢwI]Ώ# XRHJH3DC]8dK#A)/xIdmm[%nB@LifXPJF!JqaiCB]дr!e ;gR)=Gvc1Ҙ% O2!% (]ǩ~PJ쭊c%fPXZݖ1[S_Q,ʛvdJ jZUY&4p&F*ηMbsJaQ_J`gy>Ӷe|v4EdKBԊ5N22}  o>j6Ov.&abT;'x+Ӳ7YH@TZ-A&(G$rg_:j:^NMIa=axNw2YzTt*׫E8DDfY<*gU=ĝzѳimtsl:^nT(ix̦y}rNovrEӏakq1Hڬ5EcZ+].pO6BhUutBN(c+ .12?1#J'lk.kM+P1@vR➮)[1dy-+8p(X1QlץI$Z)kг~⿓[-&/D26Tk(X ;U5 lx;:`R疵*u(Byt#;>g$8 @ƴ+ޙH-6"P֥jβD z/}M EE1u&ô0ƒ-j8,1G!?_øGk6(hc='Bj,&@ }\8Meù#Ro rtO療X-4VdK8kxz(B%;glR녱E9@8 rݟׂO/elt 7k=Ph uBx?28jEb5-W[O np/xM[4c1&刚 0>Af+*@h_;m\_ʩ!ҳ~CU/qv-y Iu{+LevuUZa.)M,J\`; }%G\LC1s_)9kD5b+ P1ZaoBⱔ+7dGF5-Yc)aԍQꏯ}` ,aq;_XV0dMTzD Jq l J4'XHWXL|1P Ԉq⩠H$p'|涙 ` 32Ô6h~nVRy ׈Ae <5ԼKsT"C:TOԚvJ)8DS#=Qn&jugɛΠqCSRhBj7\NYn%^*l59TY*qߤlvi\ bT Y3qPA bU9?j n^&N*]z/ ,y_K]Rw_-՝[EJ"&\̶PQ#NMvOt\}q)nj>lU}1) ]D꜁4ûo;1ә^LHɮ6NpQ|ڏ[od>\ǘݲ2 ^;>MF F/p#  Yd㶁ϫ&!@!qI?5PT] R}bm2}>[jV˭Zה8? ZV xWI]<ŠfOrڃbs*qwASyї?t9)]]Hڐ 6Za=jev,ÌU Nm0I|9N f961^:_CG8:ut6iBzU3$AÙ1v>RS Z%"F=,dM\UP[1+ U”*=סM/+Y&Ba}9!ZgBT-&p6r[iIˆaF@0 b 319RBx宩K1_RtK=~E|dĠz~V[x*VݨżO|hwW2f f7 ?@FBIJm*M#"@uvP `nuv N#7Ԣ 9oO?QtWy d֊ƚ߈QR6D>{Zlx$>/Cлx'2$xTԿ_OԱ\Lb"> 3rN0!\^yGgvPEaֆsmV%} d>њ;PA7Sg,xV8G@`fUs~ +PA bwEu:eU} &䟖^hJ\\7yp k?$Mq+ԛ ٰ~8k+45M:TW}t_pCӎx*ƅ~>) X%dz6pyg"[DL)'wC#=2er{[l-s x.3yotA^fOkT L0Aano'm@جK|EK< *>T(Fc0SɧCGB $S mݸwƿ{4{m˰ ѠNu\ {S n{^YJ-GCx5iv6q[7g^"};ڑݠ ނ ^smC COqΝ;t זj:*j}GcԜWwipJTfE8IKt4X#a~9 -u=ZJ*x'!C {NGiM} H Y ׵ yP>tzČ+𕺒\W#H>~(snP祰0~ݭ !\ڳP{4"LJ+nְRJ"I_) 2^Hvo1P@,}?gLGv$XQ,fP'"e,->T .X5,NӖc6 &yIelD D^& yP^r |+[x~*h `L$\4+Л[PG[PRCXE+E$gbxdBd=wC6 }pǟyc|Чj6+?)U~hxOi@a'F> :̂H_m'=ye ie1yۍHk Oq3A5?u168J&N6mp~Oے%'*}jNdH@D^/|B|Oh+փ(pg4&r8KO~i̗ ?? 'AoyxsI"!(stA=>Xm$,gߣWdhuhZyO&Rz >>#A iDg(Yʧ"cF~w"}^ q U;ym[a!df[E._tt'<Ίp,#)U>-!r$a~h>;7褗QZP8c]=6 (5L|erj[4is+Z}/@燻U`k0kkn(EZ~geA\")큈r]Rrz}NOZhj:#[-DVlNV-W* frnj 3/_ؖJC.ս}iNr !F]/okЕ'ݤ:e_-=W{pᚥ(_t~nFcGӟJ]ڑr,~k} jꯋ(RZPatЯ6bR1$-NhvV0"VoY8tMGpQHH@KjzòX;cx66''nʟ h~;Z[:Ak{zҶ-`2N2ʭI\$nL#drɚ2;yuٱd; ܀봔?eUkwfu*bif.X@prlz@n4܀|="zÓ #tk?vU"/B"yId&fX L`8^`]U]dke9L(|uѹQT ʋ(`o0ЙmZ 5v>uimO$f|QxgRdew(~߱Jo[. :dp 0x^a;@UčJ(|e࿪R_2E\%8rcD|=rպqSuY+>︱w_ +6f7Ii B)hw/ρQg 'Jһ ىtmvFǘ}. s>:-ad (0D^YP_%KqW6ೖkš>HeZ$6T\ ÷:֓RluwȼGv?mu%rLWR06x[廘l>~ KAnik"sN3voxJ( ζtBn[si/5NPd"L!߿%; = fP*Xɢ␗W?^;W-:ҙ8 s6 ԜG'GO&R $iR?KcH)l.F{/vi 2BhCH'x>"[[=O v 4@|״ۡ\-'X{<1E=k6B KOM]MPZ;d~Uk{MLh1Ÿ^U0m&ݑ@0+  ϒir߯tJ'1t>|P9Q穞#@}vKnvC'Нnta @PYb*C Ya)pO=)oY\Hx7%u+r/P29kPwWF@3נ!CJ'?>S\ IhZGSr54 &"5@p)g5ޔ:-&7} |2"x."@?ηㇽQx-=$KCЕ_qWW? Y~X)QJɘCWO X-.`^H߽|7쎄ITKOffeph]ǻuẳA\zڛ @T=ϩ*X-!$3p%O(+woZEGk*OWFaOkH=)5NK$x(wp4fs&e<ēd"&2JLvOYl_^irl)?oI~J[3Ap  aaCqa@PF} x1VFi6X#E?vo;_r[>O)Sϔ]wb*f UzqG~$9yeeuëlVW$>&2 !LM|{fub͕4GOK8WZ?t})F0ɼ2_^A`#ۼwϙT L|$||DEyzl'ؼe%+-T{]P(z"qN|Փy+pMR]3-ח`'NoӼlWO߈ hnHZz -|+̛2g&"Xf̛&"Shn""k[- ;а-oq%F ,AGpV'RRφ5o9j1ZHi@)+Uj s4`$j+ \[Ux^};{=/TD$՚hQ$27YCa>7qv׼ X T9^<^X.NPh7Ǒ!obU}0[SE 5iІP㋝K"x˭ϋJ2[v[Ү , aW 7GT*#HS;PGL]'Ib5)X`('jf.1CC.4BQՒȉLT~6CSra:Ӹ^׷q^(Z]nSr9$8SvyZFDC%X6# `H[v/ZMDJ׹C\PG,/ڊz:7 ywJX4ʽd|ol.{"/ q6A";]ƇrR@\bݘgN) u= ct!n>WrNjၓSQhl@A|w:пԦ52Vj %NS+ 7L'8SѲ-}{?GKi@XN}@GH.vgAQ/05M!y5Nm~X<5M~(UT9PL~U2VSFXQJW~'D ({;m̃o5j8|$敡!W,iVMf/q|ϜRMˣ.Pytjv8o4vioֻBIZU&365S6͇ %H(&j/0urb:"Z^L C68v0t>߶a6ULFOSTRT^0216 _`A*5VM]HM+OUNtjXbGx<}!HS^"IEK9󿆧m%N"Xe?{H L`=२"Cñg Vy]^z գ)beHW^19"POKcY?Ra#o"BbXݯ}r6Ѿ#Ȏ#+g!ժbܓZ)#lN P, P4t]'d:OW=F_ VșgVPXZg YѲb sEF8H 6sm(5C %"٧H99ZRjT5 `=B,e1u?iꥍGW;׾+RseO˻CBWmb%fTTtө&,]rWc4.rh2z$p֬/M>}fdrSs++#,ǨQIKEa&=& f n7D`\B\9wgA~+bGԺ0W(zTnyAr:'(f׍pwDm _؈q/?rP/` V` )Ľ=DuJbTe-v1]2rʈ:rDLńEPc1>XWJ_"!3^k㯥tKYc. [0q+sASCxGqb<XsC`\Z7IqEEΉ])xSEFRknQfz]6Ni3I dg aqvE |Q ̠rjj$pB#E;7. ެ"ԇ:&S0DDRU sH{%"O,*ࡈYDȳ<:cWt8{E*}wIfgFevOXDq$QQONIr.j1|p)+J=Ș_3bZi&7=t߲Mm bbkmtViǎPL2T|s{VNSSAx=~j_%+Q4_iz[\/*gނxShYG-T[SLLML2^4YWMHVpCd˘TLzGy5)F0D9y+uHga-Hx\+1YYgGx6 3t y46|Vړղx%3Cn˻@٣1.ݙmLOqSdۨWEۿjOm  g'V}Vd:vH5 t=%nQ0G8.7|Oу q(WcrY f4̯j82hw/mG4`°Y]PMa=re-Se/1:Ki)x>58 $?z1HƠ;?OD ? 2YC#N֊ث%$QaGml"gd+`VlT]^\^R= 6[Nr]MDV=+^]i03~=lKtUbwJ*:OFsR<0#bJt44|/+ f]3H |ѹ_+|;5QLVTuoI]xr?"Z@Ĉ^!B:ˑ(A$|sFbOrIt4x0/vau0땄N;g`A@GktRfߋB#փE/1?~<٠'#UaE!Naja"H"9eHQ]1+(OcvC-Ð][Gr]UZ J" |G4bӳ.9;9!0ZxvR v%3)es?d~.By9ǠOZ-6籏Va-G=nzgZ|,WRl`&U"3 sqzD]dF%rM1Wdqz &ZwQOQDW %(&+-K]%y5hb)@0nǷs;;c5;p2,]jkkc&9%́$`i,IzD_m1Pq(GgJZ?_hH,NG"{ozW$KӖ!uݢ[ tlQƾDߠh)hOo*NE/L#'}l^<1v f+vk c@bXrO0j^;ouxuz,tQ{S`߀xNa;ϟ;PXw ݕwBX?LZ]BQnxojtn[PО=Ҙ-5#JHק0d5t63IO@ZO$a26?l qrBҕGkr6'6.wO嵣C%JhU$d%ZOF^Vc9!223Ezyj8& 9 3Ǜ"H%<ˤn.=:Ql`ЮKVF:Lċxͯ\Hy IbJV: #o($Ĩ)5; ǶXӫ#V,W7麤 վ`f85y ˓^W {/cogK&\VKA>en'LHDˍp6j*D"2(Uz1hNŸBXX-&><74LpSU^5T69u cUcW 2ݶP+is>oC',4_փ,Ksz'&!s6Uqu$aAgvy+~Ɛ-ԻB\i9cٲ*d/Χa#Bo"t{)6Pne<401w153UrK}5I @twgb'gF`Tiso%ՍLNHWE$cx=:TZ|p(ڱCC_YhbwsLe3q-cq / R&!;sԱFYm*p&?{֓;[oژ(F-rJ;>;Ys=p=7Zݚ S[bU ZIw}Е|6?Yx5&;T[ru+w+>+"kcOCn.,Εt SO 7.m,+0i( 3r倭첨2F c8**dU yMuKVUA~w<{gHlԗiZy$X 2uJ+?^јtL|<0{5][C"!CRUV&4"kX聯%PNk%8vkQ n(bIsG#v6SwjU:b,y@"vs&Cc~c.`˝^E#t ƌWDMuiXV뭎z½7Z幸,Ӭlz#݃nOGX޼K9 Tf% )UHMӇT=< DH s+Eֲ_H`vt^Hk]$ӱBl,IhJ*瞪amWVuN+7ޏΉGP)_ILJi') u|ގj?BDvM0Lқ϶04 [HTQIXc5 23ŒWPdS+9 5Au9A{c8:T{<}#wxfN0n'.!=vA>3h N_U ?O:*(4a v.$0ήbp62M+è޽ s"#' mzdHrzy? Ndžf0R&Rr%WͱC1&&DBn.LL#oK6]H0Lmkn+¡M`&_pW6vM%NXe_MX }w@XgINa19ؐ!|mY"*XXέXqm/ _-Smg+=sIg=C4Kt\`n|O*0"+A6y">RT;]. ,$|t"O] 9a;m.<F x=w`^~FP(6ǿM{K\s`[-͊߃<ԙ[`C OaEkG~8b7{|1걉9\MQZe^Z)IfPKtOn6M{+knT2&ߦM Vi9sY6 4{[k*:) ,ɲyoF_VBBgA$XͰYnLn5v;A=dL.?A9_;BXHh<ۅŏ<=VªX7m顙fP.;c #mWHʐxz'6Nv-!uOq&FJ?} 4@޲j=6Iܻ54Qyv\L-m5.|oU:=\JƠv}d?*e9HvDGNinvĮo"^R&5XXrI=a?shFA0Cn8(|sH z_ nFE5-Chc3L[*,EQwL}jrF l5 "v넨?'T8liI#" #OqY0rWr^~y2LQ2&-XT?tXP*¸'ABAZ2dxX tGѹ~Dba֩B.1r8>,В6.>7" ^To~|1x3pw/pep1Q=/ZM=)16\sxyP j.F XӁamhf>NQU+Y2ژET6)C2q7 $@XZbѰj@_@zdd Reg%C!`Z=i\V@~E(y{kğC@Ƞ02i[5ؒYR~L(5r3Hۊȩ>0I|iu(`cZb=~g&;vӍAfƢx@2m.U~ lD`x4Q$7ܪyկE6Aπx ?ǭě? u|51;h@.淪E+=ڕUYk4jw~/D*5 (ާ# kx8F>0%MZY&;nWpӬ8o& GT׾pj|8ƿ1c#OKn6 ?"T]mLq&@.g3/{yZ̼}toCSl:<'Nc8Pj HkA.2o ȳfhwφ n?E%˿@5vd\,Aڣpf@9yȫ}Hzc̽fwu-W$g |[b+"Έc(3->"1c,o2ɕf0H[ wv]Hn)x[[B",WOXYx;xJ)u^^pfx q%5raÿytPĄ0]ZJH +AkUZ_\h Z>J]75A-b`oZH ݤ]~fVVijHeYwB{+` ~'~M׫ƴG^S ^k :7 JwN.3~v'$k4itRP;|Z@vә|lD/^Uv̽zV2ɠqҏ pHA&+g*~_g$s>voM0ny7k9LeQg}%p̓NglT'{w ܯE8YY38Qg(C:SH.Ѥ4MJ9ioߪN[zku:ć{+fY:ۨF+ۧ{bt0so (zZ^* [, ]7=0F䩜=kV k۔zuTs[~ﾎ{3 Pjscі$/$W߃gXd?|EwQ][Tw&+ͧqZjp#W+_!玽Z?3Ѱes@7Ծ>I- ^Q}-XS݊Ηl*Cb>\Ke>PI<Ϥ.8XS 秋?@Fg6J4]M^=\db$Qj[U3X{[3UkXV.sNrb<~e3,ýu?K}B]H-KqEkĺQbnbru W.wfzbC g d/YcBC _kx$oȿ/Rv &%0^u'E.H- hs.,e8ee,t_EiA0v7.(㚬}/i&dq$|mv>Zw: z;-Hn(/:֙'0jp#l>F9ESA x :=JH&=i՜T.K{l&,u!2xX|\lQ nPYdrR̪/& S\3&p΅#`|Fqӌ_-Riux"%B  7{Ew]u17 ʁRE=3[i|zUgI9ޔ t:t@hy A*e|\o4Q,x>OJ úH4l4n+GqKnhFv(i9L4q^";*Xş=֔ۘ{٩D'cʈLx\U1ndk d޼hO钜Ǜq3G֒dMNߎ.hMۉs;ܕrXLwVB1a.YRrIi"2/+>ru#q\׈62.[A4H\9ck D*mMUڏ١,+-kƳEU{a=(M¨ 9̭']7lGM./J<'6>.q׮2YPvbGB !л7]J8^^Zȝ>rW+>8*7Rqb5?-E ͮg ބcd9L6Ley>fɖՎ cő;n^ؐ,tI-QK}d"Ը]٢ 1\H]B RIbݏĸuް?Ji"Hᦶ\m^'ߝGr/$';}3\Ҳ +5hok8;=CAn <e(bjşs^\(DOJySq҅Ɓu= B}ߞw['wL!jdYX?oWZGtw[1(˄di ”%G&?._! 썩S-| ,8˷M\uJmnCd1|r?3p;"SZ@.k+rO(3TIȑJPް#XV&;!u7Dxž͂{h]@5$ &vl~- 5\n,"܅:]R[s0NB7ۛpR#qbr&lr?ZRRg%9r- LnH SS,Fz{NXuP{`ճfʱ'ZXʛ;kT,Ă}ɧ( Zةе2~M ɽ|([^ރ[I3 ^U>i iiS4/J\n#8<ǽVڇO] No]Ke伝.yTtVC!;|3Xg{W7&Ey[n?cOo$ޮKhӇel. u[>{.)lSb^jU1'inw-S1>ybrMRMNÛ [ /L+C]n 5KleF'JcT)g;ᇞO!z{sfFְ W4C$x6VqZr󃟣*,o Y` XSN_8]|bX[[I{\P:M/tZF,!SN4KS뎾|GbA֩2E i>^|?P@FS E*ςki*kfXQy*]Գ`q/6B=2U3|4 <|h_V^V%}vd+\ʹvMwco_a^z. -we'a~1!tK# ]нeGN<ĄeGq-P},ltM /a0!nɉ ^+!NJq{D~{dfb%AGN1tW ǥ1czCYh̋4ĝ |~T =o; ]M>JFm.'*T)p+ȏ<)WL-(vA̧R=Ӝ:A,jd!l\潃򼟞/NuyiQ| 2F 3ZDͤ]YFN(v7"7X(Xɐ_$(7b ,oG+\."1YPG6&^Xq*! u}!g"瓹UТoϮ/%[ g>sF`e:lˡ( ~S/9:/^+oLZB'fp4w4mp K܆)ܽm{ש+iAZ7:AU>xϢ[u*o@bC"ܥ|_bQtFw*N HW`REOf`doFQgxyDH ?*a q%pQ2bZ5\5@8~#v `Lv<;pƶUoE.eDNh}WKY G c0$mNAZ0k\zА~u^J3#U_"$Ʈ=6s\ "橔RP< x/ Л숌"яu1ꠃlwzh7i|u]4 $pВ2\/Ea0k QpvƠ79>hAʮrֻՍzicg h@)ݮpȵJ+f sǥ?}`ߡ ~LIS#YP!؞,VNKZՒMxKJ^sjK9hp, wۛ4+#D0!Z @@S×9J|nWyv @_6{!U)`Uc 핕fhFz V4q͂_s~iJUTλl$;,~j(Y E?Bp".!=x{Y19RLdL?f6 ґteApA z 芁;E(61"uem際ҋͲՋm|}HqKw"t73VM/"d /gDmHkmG'WSM5Pfuf1Gĝn!3?ҀJ?XׯK?w??5`/HDK">e t |YHGc'UKOC},w@$>B41Q ypBI㞎MѱgYZPerl-APIReference-0.16/data/perlapi.5.10.0.pod.xz0000644000175000017500000010232011653441731017506 0ustar tseetsee7zXZִF!t/~.]c?V Or;6ǎ#x=j-CTx+'jj'UрP%p 'PQ\Yl]*({3#D` QYnA֌3)m(O0lgȾV>Ix2QŏnǾ8YioaRԽwC+9!74lH(ܖXvC#"D}%l9jSԸGXjog;~3̝Ħ7&ݺMT"0M7V:s_:ĸ*5.Jn۟F:gfqis >>o+7/#Y32TUSt<^$&̱(4wgAUiͮ栚{} '؝sA`~jh~.][éLD,XjNLVZ-OsR3,jۗw5r"ԞV<q彜8i)'IHb|b +|!=% {C _N|(ݖr9.d餒-fgf-&S2n].,sUg2~Awd퍧HQR3{c~w~~~u>1иHϫAVGJ El˹K]=}HQSn.&-*1D\64C%"2ZM9LiB'OC~y_d웞{*Ãj7υl!P9]!PIM&dI/8`==qg]ʱo gFtwbgy&PɱgO])v2ȮG@*nXg]/Ӥ6"]\N<݃nVPyoB^ڏ*Z摟ZPdWLg>5]%6 c`=t8Awn$z,;D{4Pc&h6PsEP=$\o,:Ws~>r<%ͷX^jt1^o5_{p) B*%E-& o}7m3Z&\w }Tsu'_^z./R8ړΉ}=ip4;[P^!c~DBjRM)_1 5Ӷ s%qܡgt63j .LOrT!1H  Z'|م Aʮ %=iV{c^W| X %KOjYO?G9Q(Ep0LlTĠ&HSDj-l' Ű- {+Ao `K3ڳ%~AX 8R`))*(,ǃiC?XNt t2n۵[ZMnt,n#R- J21'N?fq=a+my8K/R f!.- v*L;NJ"q|QFt7,ZAibFQ ! e%E  s ^41NԧZ7/€h6Tx'8X83XA" }F@'ԫ5H/=D:n*;}V_5ΖU)$Kͭ+̆$'Z %7$o~m`SeCköRɋ'Zr;g׭ +ђ*Tw 2N:1'w3Т,Sϙq^F99n5hkq i"+POsد.96k>A\Fm$Oh./Mb:d\)0pqWG  , Zg"k+IS+Vyp N[ARqBdH˵Q2aH7=kgP8(QLJ\nH{9^5ФĎ.:-5 ) U] PI(̓@m7ٌBөQ1^2-`EqM;KtJv5~StQ"N^(UiYcQ.ijN٢6ݐ)5MFeWMfXp"ToPw>)10Gݦ%!+˓ ȠM ^= _뇈{,TA7/#`N *sy__RS'(9?œ ^MRRY٧d<N\ DݺFj C?wUHڸ9+ q/q@Fm 3킉}b5y ⸺ٓ9K_@L$ :f]?i/Ƕ̞:/0D"`1JcQO| DzG Fw 7ɚ1RىmNۃhiY *֔UL FВj:l%ᾫ9}ϚE`\:8j]hI"X*EPrQE31߉.}OiƐl Ǔ)Ҕ-s)또HOPsF;&MJ7 LKlͿ X9uXEдy rȑ&CQP %GOokYАU3HdkĻ$KAt^|0:^AHf`ʚ>Yp;4U+gm BsqDi"WjCb ׸DF>T@e@T8jG*WWƫk%aH,0;?ӊOinrA2/u,'wIt,ycyh)BK1&'9&>K $'f)VoR۰ITΨ0uEn_i6(;53ˍ2U}x)87umYf?/DN8/H%^[p9wz|E .nO3~8k> M'1 M%HuC 46 p6ԾM׍`_r$n &KylL!d_uϾ?E_h&Iyӎޢ'Ј/5>_?/"4qCcBE,Kbo[6̀@h]=DʙB ߆=nH_\ĉMYѰ%#)naUMD@KPSEASAcb8(ez1*;CGqps#DmD5-PI}MN:~(v NMH"1δni#Xc& ʘm`)K_M\uT%ڼYRj>˾VnCsk]hɮ@IU]=JIРfE ut,߭1LR@ZH/7kcR1F?}Ӌ jX26c<(0W/36<]0ԃwW:lw)k Q*iV='SvwzשbG`\hCl1^}i7(W~)S7WWDe`gEkFmAKˀ%Uҵ:w)M]K+ "z[Qss1E8oXRlx>C),dhr\%5Yd=>! Îrtw֋Q{=x!jF0Qrce*2NKzvk.ݽ|3ƚY<1kh6}A&kjV6n2CaKPs$uzWs;i-J JMHZHAHd~7lV=A!v,cAE >oP~#J5"yu W?EEXiYa<[,݊Ph>W~ˊŦwv.Z³/*¹E'nEwi wĻS2M#D#v\၏J+r@owRXA{^ȉۭ,L=RU_LL&xȊzUo\_tMٌyR p6hAV]}VqF[-Mg[,Z;P覅1Tqטԇ1c:AMia?<4Uy- `U!қ+H2cFY JIG ԎŒ~tW:ͤ6Ah@2(  2q)OܴOv*.59nnzmF]Adz?O1}tp#fB=XJͅ5B(qEWL6^ťVΖ6[҄9z%n1ad(1< VA!4q$W0Tun7TXϾi,VD$&hNYKq>+g|{T0+<0W)t[LfTNuc@v%E̋ȚLp-t8w2 U߆"9;,.E*Z^h2"N\t`N8OB%s7TA%'N=_/xb:-X }3 V1_4cgiqE#8EA6H!R*¿: U'ѡ}&w)CSjjX=f+|_a-afԍJ޽PWrrX$ 9+Rmd2͑lI_{\9@*ȏgl J5?O =VYJG2[1CŅb8>ZcU-!ung JXX θi6h`eɷ-4`1q 3^xd朸|8qL Wvai|9p+3.HjW ,LR/Rڻ`>ʼq/šY1A׷]S%]@uwO(yT\9k  &IMcZ y|8j:2\Eŧ7L'vxum=ju~Q+34Ćs@~8LmD|c^Bz3W3sE >0O`/D>b@tvEzϑkFhHGwk:١x8lk@DF !`$/.^԰p 踎fDD&~vu -Y8[c K罣 -7g$\ 5|e#T>?|nn3`W}dc .kȡFEP|+L:ϏC|E{%:DG6n Ha/̹tm} ;i/=@ 8wV'2<7)R,lQPTUR R}C`+8cn@ˣCXO3}]KS-9lMR'7Pa)L=uZد ٞ=vO¾Ө)N}姽v $JHb`*JF{6UD$d}ye w|= bXs㻲!`ˉIpaa C uFpdӂG"֓ "i};,R"p`du֠b\7.rTQ a | -EDP7:& 5WޟSִe%کu):ƼȨ}UULZ↪OMШ,, Gk0%w^&}䂾2T^IinJ'ke{(x ÷yorn9JGmVdwLJUШJd6| {]iIۡx3'NRjEݙ[u:_˞30c |Fi(P`ɦYfM뛴Y";I .-吲Aeϝfٜ0=Yww/TPa+(J% \,(#4 2nUYSΘ@G&*p>s ؎!ҿ=ߚ gη-& X^"Orr @8+kZ9]dZ [Y8o/ Aăm 30-*MD9F L^KsLr(CY23V1?8^PRÏ E<+ M N.3ivXkWt41RY;ZIR*Al!$Voa n`ο_U?=V AjGpM׼rLC1XYEeyRt=quc3g!kHlsn3\6kg'ÙYL3h\rr)Ӣ;Q^EK4Xڌ.8k ҈7\d3q plTn\ )w^QzGkpgu)9Jb'[sYE&'dڭHMNGɅ? Ve<3@_t(0ȘVd!^Ψ(]5vpLt?$TbE`LG ;*]VHم3Sbc 4H辴*ctVKCj/` m ջ g(qQ`m%a/˦8R*mآokeOM{J;6p:-2mEV·W RO5s+H Q%bGI l,gKGEVEooם{KP󠽁|U=R$_(ixJӗw6YF ֪Q nPl33oHKuYSje-1G\{Ul,~^&KE.7'HdEow _Usuq v pv,D@*J @. ]M|p@jUd5DI"E;g9XtbcY{^Rtؙh7="נ)ZpkZ䉵!oy`?n*[Uϕ祵/7zDn 7ʉu h 3Sep e gE)ǥw }R^鄖w׈A<S `~w"TH)x# S^:־QW(!m(zmFi<,n?t8dN- }S%`0wJP>E@ߘ^Ue{Y̜>mQ(ð2q_# $+?n0;^:Fx+*m]|ɗEOYx ^EM}.zKqI4/Mִ赊 ·uwj.?I&TJ.΁ k3,ʖ؋k +Fl)nu|FZsGCWpz%"Gb+hύi1ƥ*VD ܬ&0D[+PnG,I(nө/6)C".)UXex͚Qe3ν 0+#ɘBbݍupLR(3FZPw"(h*[i]8clhi|UЂ=%ULyX5+h?\Z CI׭4e=Mz(_ok~30*Dz)7vhy&T 7D]$ yӴ a :}}}!$10z=*u}HZ xK3Ʈގi@)_Gؖ'A̸{8m{걍Cl l-\s8O=c]R;TFϋu=`U:|iߎOh?[?91F'J !I99 Gxڐ6a*+HQ|xFSZ`baOCDV1]CV bŷ3[*!>]'FgF9Jڝ~ 6T^ Phc|ٺUp`xxb'\e/0ɨCZX`á@IXl+ɒGXAx\L]o EgW[vrH#q8{[Y;f{2!GO!|H:^SX0JW1[HxܵZ3k5w<.SaQJL?w4-77Y4z{!h-nr\~_!ҴXGD#qMHp2f2A1 0\'گhCQXIp%2@]ja"sr[DAfq0'+"tʛS%36F;O6,fj/?=->ޖr*+P-`mCLoFk. C90O%F=qS1˩[Kȭ7t_X^aBQi/"33fM@'#%"r3QJI[T\_lhc'}Ǔba]xh9=&q8E"\7_/fжV){>p*AՇ+0w쉺#>^czf.)A, ds"_+I2c$y> k8vȍ6hC"ҋ ygYtQeݠiɚ3.{%2?9%Ov#mjH-Ȫ n6 3}e,':Z֚^|9T3檊Q vÖ\pimD>Mz5'K4qڗT]8-}~Z0_a&lWnLSVuE\6.I\>3QsMq3=-*<;u??ʭzscq\ǓX$8Z&&6QV[#Ϙ`{*+ Ri ^O ƶx3R>tN:u<!: C[mȿnᮨ a)iFmn' k 1"$\aߏאDm3x 2K{m_yU4VrLP[[4j&h"ڸ^T昷zLF.@ PkM.Cl) ÁWcA!TfjBqVtҴGj&po;Z]k45 `ѶӮ7ae#OB$w(Y=Y&}Vu7[v '//~g }Wgkw'y]̺Vc%Cq4XX "V ^a\9_1-vx;^#S_'{RWX})JPq|aIl ۅ=>O# tU~d9=mû&6nz!w_~!̴?3Yݪ#dw`@FS< M^oIcV`A;p%$6Ko[r;/éIpegxҟ\%wZ} )XVYS}M^Mq1M /TnͳsB GcBAk~Z.E$B$`g@-&Y~ J-X{@,2ww E~OdZWU#|2nHx%g½Z5)_%`,9srrVWd U ,)-w&#:Jp_I\_c- *p [{"1LX *b,pdmgC9uQfԷTgo}lF_V%Ma dCmr[a - G%MoDO}MIgm,*-W=̂Ym`BpP%sr+$e)4?m`^YzT ^AQ:?L/@p#S-V&p0C߃ 5l Py exA]O̩_.,W {+5IKV*{l+3cObSO[hrJXGOӷ#04tܭFkUM/`+?p"UWoqs]s.@5iYnTD{D@Տ^HmVF&TRIG䣅l+;1h~ jEDDZItziF7Nu;B0lun7%GQ]7Mƚv7%L#-.10s=k |xL*TT&i=[D o1]?DWVnOxShʈxa .ƚ=skg(9?JL$C$YTLYe\Jf .$+"z kL v #=oy g8̫(7@}*ܚw~¥૔wI$D5hcf VD'v 7^ǖ[)SmeE͞'DM/Ǝh5  *ZV,2u @Ƿt(a3ۓ;1φ ˰"4x_P2A,H41yRץM%9_"~zq|ҽ>QTȧa{xG~~߅^qe^]Sq *˅x UCl+Hʻ);Tߎ(.]W ҽ341',.GT u `G4޹O:|__ۓ!XQpFق]J]藈<ɏ%4My'0NpGߠ |ae'yڦ)y ]Tn wy1RUe:1 (/%5TgIݩ0wbJg˙:ɰ8 MBS@Kt1r40dr1MNU,2M`Wɽ{-{U{Vh@O H<weYL3QJ&WqX]0E@f"`<\A누aOޕL_JW ƍg1m[06`'{1~fQ5*&otau!$1P-Jj[QY80Ƃ=:(=Cȋ;9^]_,| 9/>(JkcUR;?^\2W@|CyL1?O 򩼵iӢG:qlR#` \Ԋ_i6JH:U|T}sax9yf<&@!ʰ<&o^LtwƛF%`{WI`qQnB凇.#ģgjc'tB 0{$b9EWK0&*B@|- GOW?lbAbC.pX2NVAG^;;QU ${aHD]\#'\T籶2*]Ns/6|h7gŪzt%D4JɦGoR)Išzq5hE L$Gvhm=TuC${`U:216]Y8D0ҙJlZT%.W~pe%&˔u6_(35Gb('d>[MMatc[35v4аܯ>,E^%C&ko`AEKi IDfWC P3tN-O;_ &İ0bZD\q fH58Icb)݄Q@teT@}DSC ha bHowD=I54(Ӥ,: uzU.gQRˈ⿜t@F}6w*aY ;1#U&IJ,[]c9;dۻ!BN4w[j 囕*Qwv7E ΣV=o-# x>lPezZ柈 UJK/%V $%p/ڃMȰm 9aWp_0[E$q"L2 w+Q|1 wJe0|"Jn"fE7X@U<@e?H D/AzwPGbJL`+B.с2* ^xb-ѕ*Nal7mDZHif).u.;,τXz-xʆTt"zxMv~G:aMĕa lvc)/جASM5|m=};I3מ*UU)Q[Q*IJרB: 4,az/Hױ}dX {`VH&DXU?6Wr>d !mA/؄f pGd i >ν#tzb|$`4M-hY>er'E|dM]3(9E&#&": rX#͎1` 3(W-ոBݮSA2n"yfw3gG7#%M1:AnHM03#ܗ|W Tr䐙tgYfR56;sP糧REXu/t_TPRj+h`}"ɹ^rE5H@jPKi*jO8+%a-1H.ΓC)+9òe~z;܏rbsgaf7hw:jvy0T҇%"DDP]ם3YsV K2 _yIђO4wʋg/lM=y Vsί~py >2+6RK=ݺa&600Z OAJl ].JW{!#?ZX=??شw`>vgvohWO5zN<# K덛-%#EC=Na $Yr@feuѢhqlL qk= tLf;k{C^hHeGkYJ E6eQfGK}֝xǝ4RoG($.}e|>JskF0~p53Kvn 'ȦP:Ln^DgjpBQbTES?z^#i- .~; \]\zp ; IIf+zVF@CoP"[,Xa ٢p3O}]<ϯ4b"3k~}.m8D1N?E_gn@ܖgQVV" xs9Z+gIG!I~K|]muf} C瑟 V0 {mĚ_%])!^gW6\rtŧQ>qQx J&˖\FUMlUTgj8Pz|5).@!͖''Er\]t+7hGm?P}Ü[cP 勉`N۵4N4LN xO!5ާ5*A%t&`c2'2]6Tٻ[&9 b%SKB:,?"pf8UN1~8gPuH`h ?[dNшz"7#q~š%lȯMHXOf5U?kC v&qbJ'`1ʍ.3}Ɨ?9o!@™* L,]@wڼ6EӯHSԝM"UD $_91^GlB#e9D-Xv6j.DO*(\/ H*bU|]49sUR4^mN`>W#/_PFU[5& ZvhKT:݆r`Tl>[o#]E-u@Ja2g#  %5rW2iME9+*@E'hsFJ;b"Gϟ;:_QpgB<+}DUIkROOu'gX#58۱Nt-s露\36am*!aļ 4t 6hS^M}ME.E7m_GZ o^ouR AWqt6 6j|;L9%=Jt, Khz&w\u#Nܺ:ܞGGMA4kg+}؇lL^b(WΖ:MNރCm26%:nkxpPƒ0XLȡ"B9@Ca  1fTDx}{%oQA^b% G 3Z.a@`~2)LߡݔSH,G?c$T2SSiI?N.dt+{~fJm]9!]{WHr ' ΩK 팜CaXq7o#vk/,Ie$_ 0ه)x{v~G®t.6dlY,IMtr# i[W}ͷ*"eg YZ J/̂[/.[ݥߍG[]u$>1KA?ՕHdkKP07AGyLc3 6REL 3_ArM8*:eajfv5+Ø5,jbMyM,HC%%)?HCǯJzjaC+pd\ e)훪]MLСwzsK;/w\﮾ɖ7C%+(i-{y"IaSdC"._J<ϯNԉp跭(Y&9nvc1z"?jy'6޽p,B_qIN{zwqXw B|Rt]d̃I o8f .mj?[vX[H6&7qyrYRkxJg+WP<\W>"饃tpf M,=wҬr~^.(Es~)!H>=3xcRC Ҳ8L@q;^5bJdX}§6yB"\)32h^pſ{8ƫipuqy]Hn̓F.2>?FidF3/  $4K3qm Y 2s]hs6_V|*a_i EYgDƖtnI&LPPՁKLr+Vy'Dꆁ}G$9̇D<(vTjH EXs-k6mDѸnUl@JmȄĦ[3(lZhR5.|jԋcEdN<^1kxMuƃ%bDh4Zc͔dGO["؃=}bWO˳hqKگoyn[&g}!eap֩펜pTd}̪y" <7f(gzƞܰ`_y?F z1`f4#_^e9Pv57B%mgaX\P9lQ#{#3\xp@3rё|BtS]y#fDۯ)14Yז]yh{ްH4 Y%N:U57?U#n2V\B ei1iNBH :76Aُ*}Di/`2ˬ$ǥjx1L_dQ O9;9 $1#"lu?.^@K=J&vsi],%Zq!T7"硷8Y$q!Z4 jt݁y x %dqQ%a%r2{\Wsa'٦vxk^.=|1K|MTNlWq*^|Av 4Y dT9 [:PVM>ϑkӠ4^4XP.Lޣx+ Iր/9ᡎa-h˱ELI[DZD$)]_;׃&(vm"X9cBJ㪆kalҢ'H!c;?z&}׊G`4 V1GHIN9P=2/DU~"W+XaCJ Mkhx' !Qx>7/o賯WW1.4w~;B-{OK|3ѳ-7"At6kf!S}Q?d8ID|Cd1@^+ްB-d+@O* ה|OE"I̲ I&UkӍt8}1_A4+kf BKc 2g@N9a[ c䍦Nc2KG{VȩJ"ȨL`5K\{cBm;r ?BQ__[!QڰsiG8`8FUGa;evΖJ$ʦG\}Ӓ˶ VO/Og)HD9C4]nEQet 8P<(We Ք;D&א\0M*F x,Q('k)0jO),4t| NO^NE MVl ai:E!QՖ䝘d+aΆq yҼVA)@Cu?ʼnbFGP%fJͰe"4/ex@v̢҉E6o _+]VjOv4nzK;8zPg Y_ބ짯,(%Nʤ݉ J/h(v YKt`az/DΫLG`!Op Ojˆ/Q18Ǫc 7n7cS;a!EG|ovsr@9)5tm;&nXoc Zvt8O;Fj+Υ_'pvKYF~\P~f!8וNtwCJkS5w!˕Ӓ an`+U:aƎOs)㠏t@G}ՖDҢ:\(x& PLG aݸJGvfΨ(nncY$kQ*!XāJWf73a@:1TYxz…_LДVpdFZ^}Fi+VBMWDk"S$MPm[x֠IIPAI9ZU*ՔVoT2ؠ`uf4kM{s[O~Q͎.9" <Ь"p4kqw/^@X9XעMUPZ'UwkBriK܎M?s^.\ޯSBCnC7vl| B=:@xfj {̃+fضZDyK%|U;Ipmƒ8<8;m`:LotP_)ܘR#vp4S!Je8tA6XP(xirewNՙ[v]l=U%Ќ% #ejONu5O#<槮N9-a~sQ4_pMY4=Y'A٢>U/5hP}AZ=d~0YiǺE1H-7^S"I+dmO)۔♶'1m9KP@n243NecxR 0gt24[d"q=]fNRJ-<Ț|M#B2"*2lp:~|+3'VyKù[1`\D$(2q8{/Ƹّh/'+%ql*ܢ7nsHT@BxX|P_5oDyN8J1Ks-܏}O fvBa uvP1vԋٱX32])0:|Ò0y`=\7~h,1 Q^Lo}-+I90\cŋP (j~fXwȈ ,#`{Mdgn$#1B}~]?}tWDkNl;\h/^Ϥ[j+8z*}4XL`IuNm`F#z=mSu܈y!b1@/W{_P=d;kV`txKs&Ʌ,blAribacn 32}iؿub3{7k@f:8z:{J+ruv4j W(֍nloW"fks6,]MGE(W[6^ 騍zDR%*cќ }G3qqz'jFeƯ^!2$Mr]kU?bZo>VP&h[iF dN;zM3?68;V%b"lBp%pD.UN] }v B9kJ.o"15x>\C;$Qz?c=J'#ds$/~6R9nuĄ;hҨG_~EI#W1ZVA1T~ʒ=DG\ Ey$SKZq *َ# 8q]vzdzW0x KDm2 <2 8C>AzZD2Tɣ5i+jM P?o@90D[mxewMΎ}ҙ]D>-i5%\渝a?^* ^{ozOgY"c)oV6Dm,2Ug|ZWhSϢƥA Riӣ\=KC)bJfRHYz};Ӽx~enŚLxd)gFI(i 7$Q]SW[).3e2PWGÌ5Q.sŏuld{IїUk/7 Ҫ(ٵWhD^.N؏k1'ϯ p%9‡T25#0Q`4't6& +jW!fd7 jV^vwrT!e(Bm~Tjv5ڲQH&'!SBX,njHU.㡕< =EBIP*"zBR\88d%L=ϸg}niN/IM 1/PcEVc{Y0 g?0ڝ̝yAnim]0{j#Ok>0Y_bt[R$REcd-sX 4~ͩP)#nU0+g-T&/js3(iX+yK߷r4PR|[6gʚj [cw306_{jJ*s?_ⵊ@qx=Tcu/uQnj5w皸prV1=Od9YB/'K~efIG$"Qб+"| . 5Jĝ8z6Dݣk u$I0ux>]lu );{UAݯez5Kv'hFV W Kd熇gP!VHqXMS3kb%db_ZGh"R 󏻄-`0o⁧.ɰ4yH0鍋4syTē@pu#rM<B$]WqY AȻ2e⁇ldXn?5`!|Ɖ]n^ؗ\Phy҅y3Y`f밶6D]qSȒ\\Ԟ|IW'hP%?IyǼ^wmyܯ مL8IqMb?RiqFCi-ti H; S=.7P ٟHA p7kFɃ!6RjI2ne#(_gZxؽ)9e3v.dyJ)G:6Э=kSAD֓Թ|Z !1MsPUO7SkayY>4ə PH_VH-#(ۥ:`e`CGG-wlԬڸ7@`FnB$_%.5`r27|vl(z;_iy"X[\,p[S1Xo9pCkvrZU=WS9`S'ꨄ/Z?|U,aؗeHXpϫJSi(0\cjFh; xhՒJ7W {Z\Xȏ7zY&*NN8lƑB]Dsj._lV D5ži7Z8QC6G4; (k[xQ9FPy zu{scd^eqO#`au O^evN}۱|Dǝ_#aa+]2\@Ol 6r H렗J90GwYnC=?f{r=3$Up{ S,u(XWHu*r/ҥnSh!Lj@w`IAj=,9sF2Sf&uC"UN܆'LcSeΞ⇰% Q+aX|=#clcӗqd$;,/9-0ΕZW&ޏrc侀SOWbMQ$LNrѷ5I^RE| QI;b9"yه޽@qtU~LעbIӹok{F'b1IiY)+3h!*6X/7*~j%W^":i=Pp=Or7o(LdI\C4΂ک!'fWf ExUb`ӹ NlqH.Ča6?{%_4er"!NX6s:Y{L#MXQ&[D&b x>&ʌ!f5~qm4A| 1(,+P٬򮞽F!Abޡ[t:y'E+pm;OpMV#Pz>m@d1=u.e`^~ 3fys/8x˟?nZ7l+9z;!Y7)fsTH L/%~[h-"H (EzU],"v)F5E#w @C6M 1>;"ًt\xF-g4KUB-qU,-;LW"`+٠Z؎藏< /SQșŭ.8ۂ?N'Z!I-;N)]ހF j.\d 79#9~A[KB]@BB~L9ЙF 1RΤ7h4V%qJIuFt XWK̨d% V! N 57<[eQ{ $^^'x`AS+u>'V}], ¦25hrijBlǀEO,遶5VdC9~1'=3vGmNQ فzN '_Oeq| )"Ԯu_=V4vSƉEGo#'0Q\= tdE+\,\RQU7cFZ<"AN$-1)z۹a{'dZ>!2Dy{+B!: p@.= wijM/3>8G`M#xOҟfk0 w+RKse9j:5>֘(1+b7 x'|vN V쪴ιb+mkl3RD0] &8/mL11Wܞ^hIv4_FexeP=cKAas.iHyb#^ׂfQU,,j_6LblJ1ʿhCX.]XU8͛hsr}`6B$&߀QEJMPWOx|S= s=CbF8k=T+U-LC%-aR[̢^j7dIH5-99:βw(1ާr~8 '@!/u@ @3[SU 0かir\5*ɳ /=mCO>2<1&mdv"҆_3߯ৎ؛Fv~'*$ߚNtƸ h Ґ3 0S:eF_߹{.j:%-kc8{[!*c$DOrG :e](^Î]eᥨ<}g;҃ڞΏ~*ů ` e Bjww$ IbX$$*M)|ھc"_MѺs?.6l})-5DԴuhjzYQ gI B ۈa2p?- a\P n@T[[ /NBʊ+F#-:!rM,ZttrIGl8A*%% v&c(qx^K \[Q?O'ILފ גSN;F„<PJ~\kQ^yx X [AGL`NhGb'bq:9CDʐ.H/Z2b+lrp~8䠠z{SnȺ_sĴvkL-צdgJs}?VTVEСP(!Ruc=MR%H#r%HչC@F>gCu/ ZҜ\f~AjoR;@O\=b榈a(}̡k_Ӻ oʃ`QpSo:w_mF"[,De,&12Ӕ3(jT7(x-B(K$x DEcxRVEPx3t >{'4.sQcU3WI]9.F%Z},a7"[F"t-Qp8?WOskPHoJ1zOVpQGGP6oYك]ٰ1w1\ ԓ3C2?/2''ZRn+ćWP7y짓506ʢ(;lŦsMJK<,YMyl#:m!)HI Ջ4^p/q/8mg O.>O,rp!p]Ɓ.#ЅEPm݈!Ae;&dl%Ph=7ѕwEs]ZjTB/q$ ; yy€)4.ڇzf_hVu**\o:Mnva!Ïϭ܋$p8x/ӂH̼ >-6~q5Ud7 ؈qV]r+ _.2mSiG7AW6|vA0`δ2 GyvBɲK$ A8MѿX(4l22KN"{f]2h{tNV7,^.8h/,kiBmPe:;f]5PxIJcg*A gwƏUpU^4 ~\ܫv<="%ɇ8N>'[S 9 +,Ϥf u"ވ trO}?ҟJЩ9naѥѿJ ۂHgYZPerl-APIReference-0.16/data/perlapi.5.8.0.pod.xz0000644000175000017500000005705011653441731017446 0ustar tseetsee7zXZִF!t/Ῡ]]$P cǷ=[o^ɲh%*Q}Ԋ Y.Ʈ{P]jq>9xtU_&Wi-͟ϽbW`?|M4~۱Wh%̴vHyc[$Gj{9lXko1A>=0ma0 vj%⿌qA`&nHqԢ8Pȃp#FVHf+8TU@堵ˎUv wzmE:L .:s* HCWvTan,5őُI%2WZY qz?)^4G";ot!hcy8@#]5wVMz.S[Z]8oBI3:*t$(&J"Ji%%N~}-y Pn7^< 23byKοqbM */͎:M;H*:4ӊ8͜˨¬@)H/z`$lUgX-֎A2KE೭f0/^ dxbq%hM',f W U!ZlouEMg5X h5&ؼ^sm/S>C#s8^p3$ED ?P+bXa+104K;Wݭ4rc5QiVMp z6(aV>ϓgfϷՁn5,ߴ[?K0 ȗ,Ɏf1ϬdmkʝDފ_P[9X~sda0"X{0׈]OD@*",r DIĭe+ !%9Y:O*M?;o5-II[Xk=uun.4c6UoizWBm SRI>=B$X`؃X?Ƕ,<$ɴHsY .)22@Mž/m 7dT\I*b$r'.rXG])n +3Id5i'.m]ĨSJϲmƲqM{1„oBqi_r|= C tѯwF (5)o-[' [Xj3_z߾"Z֏O-ҝ(a^hbHm`"<]WO!)d7;Cg!BKȌVxZ֢@\TL #$_/c-Fl|!BTS@4Ggx#Vpڛ49UjWzdXkEFxzi&F,0ze.{i;N=n{]2RN}h@sk=MowCߪrð9 M# =,̤Kpc0]^Xk|<E_^Ee l)(olcZ ꦏ&b3x+c(.50jYߝnL|4\+84~/&OtߛS O$7 ]T3%WY Q:IT}RM6- 9Qٸ?;Hiʂ"N$T $ ̞iX"6mAi\o/ǽe}0Kñx kHz2=6pC[?7X&w,WR%X+=~W&ߩ}`|jo%8: cqbRRwe5Ȧ*<8ĝF\`^IDsYǴ527%xZ?^%}ou2߶ 6L\ Xq]YoM6_Iۨ FQ/ 8Y$ pez$kFgE"^3#J ̷LXyApd?[/_Ypj.Y8x c1mnI'w1HZ`iPC0^n7&9aO.482;~I~^z ̶A~ @RX.0/ `*F9@9q DT+!9=!,Nΰq_3m[owZ>N݈;*#tTI< WI<QbmJ &M0 O"lJbYrjYDA,eUȞ!1N!֩puQsjݖőmYԖrx'4S6+I!aX}L$~.U-ڳ/h Ǡ=GEGqq%vqr/C1\ b )U+b\$1`5 {6?pWG-<6e^%48r+>70.0+  JJk3e ]F]̊gnf+ D{!B~qIC|P丞ս⍨ey@`q0Gq\DB5 Jxx'LkX<k+`ja!2|N|6ґ5y3z^n;T:P9 A'rXwh W-_#A-)pŠ !҅{9pD0 k'g:UPg^|w!)x2;sJzj#q?6 HX>82g|SKHQ@EX yz_"\$!^@G& {Xsr ĝ0UI Ӽw1F`b̢؛F%l: QXS]n ^+ZKM,܇;mN*Y%rYu.}sm#{Do3=ug>xL$ICؔnVeԙTSL=SOCwq$1XnLؖ.1=vxK*g NNߓP^xzxh3wցd!UĈۿ(e2*b~ R?\L (UB%W{9 WxXʍ4<0VF<| ob֬U(T3Ud18I<톃PQ%f+~jV8NUhYx=6UsL<(=l0bp\v[o5y87#=t)y TmTSZKSH"PF$,!~I0 wsGcU8SYp| AzL -X&i$lCoLА$7QD&b[ldfHdd&Z&8v&ຝm!\oY4 ZZ4uF26lDn-(@@&һ>eg)[rH'I3d@kY E=*1L}z}kӜu5~ 6#;WtW|LWjciQ Htp0f4nz$W\}kxEf'eot^|7wHc6$S;_C ifR ;Լ:ƀv5Rӂq絓BAA6%M7 5B D~Z xT> ԾB#KY+*;/VslmA!|ѻ pp1tB.L@q=7Qg9u']o <5=\#Y Y?'@^sG9ϒK pEgseo!EP i0 # +u:uJBݭ}Zd;Ⱥ^kzᓣ(h"*-F_\MZ!WTϜCOA|4/^YϺ>ߝ-XuO8 E63b"'a/>!n󢽈ڣdS?Ap#F[;aMa{4lFg`tY79ՔJM@_VcC&gÅxۆS c ذ.T F*9H*?5s>,@k`E$z;zv;f3i߱Z?lnHz| Tm6F[wY҃6̋zϏ!x&7HPV8@Ko\#";֤2{ r2ݨ6rWn':ׄp| Q BIyrs9jF!qGUŘ8+3xHITpۚtd G=zC!r @UcNNEAWv/ M\Sg{fc[XץBɰQ~N(A4+q1i#HU½a53*KӸ !Ό nwcJop ܕ\QĘkdx3;oIj|ə_~n- 4<_U?70f@Eę{bt ϛ>h\MAlsOmrӸMxҗ{/05k2k*Tt+>*\kfd/Q{ NIC[(:cQ_O@h. 2^\5!JQv;ȏe`0?'ii9YGP\}G9t?Jq/%oF\ ]-WW/ĮVD_ ]O`;1/uAz7ϺE?&90i4kE/u᳼q;D7XskNh#KlN\'83jD3>t̎ǧ|(y*/53]XE >ͳxdԾ†8;P'VQC ]sYf٦anq_GLb𚕂Q(>$mn)OW &Olw7k[M?HĠ,8*\9F3VZe߬|"lW6W2%|OOl:vZv$S2:t ~ 46E&-LpB29&h'׮ MPN3\EW"8{@5%UTK}(a6zZ5kCQ-gP"8PФL"+V95 Cn[%1KB#oF+a%^w@ptw=;QG:G?Қk{ ҷ[)kiM K,1$~ܨop ':N)FeCb8Z-:޺@W(U0㬤 C.+-||=I`' "mjAE)zC 4A,QIs հf(p7ݰ~}=CX٪&k7~RɴlS ujccX,egqW)8f5z!ʳȇD3Z& Ҍ)5R%ư9*昞8'Oe:! _36W4+ٗyD31:>X?+%&8H+\56n/Euh+Xv5.^oQ7=ky1PG(.!RXCqb9ua|.Z"N r2\sZzp,y6kDZv`Y/J{Ϻ-:FRj" KQ~lr5_vXLm j.Q#TF'3{5wv&{#JۻN)Jv DXK]SpVT4e:zHMѩ܍J>cvm|R9;DP:g-gBd#DcLL-sSy"ѲvJTfEEXm^R6&+nHfYǓ BZgN8VZLc`d2zokP Y T ZW<xh%M72XGY[( >voؓ7@8NWBd?|t^_[1ӈfhNlHu@Hp{O^m уK_jˋBXl&莑)6¨zf mB⢯1]>m(__%Vrt'~ Ͷ7Lԏތ ̅㑸_Z2WX+}0ފ .\w9\uEtC5O*dҒ֊BS,?;Pij06l+(/x. Q  c.;tn"(DbMtzK54nؐUnֽ3c8RkO~J P1Hۏb9fxǙBL9Lپ X_$m\1htvNLU85&jEny72ٗa0W!!-;:^bZ9W:]̵d~4Ma~)\):m-\,Ȇq"}n2JwPL݊J~l{OY ydӪإ^3ex;y\Q)90G 5AaplQL;z;*RX$;9&&.بzaH>QO{iJ+=)[| jMk Htk!%qTCDidvQvz8C]Gshls써K3{i :3?D,=wY+CwmgsyL 7M&0;͔;ʂP/i/Mk"63,[ WF)-eNk}r8p=I7gm_V1^ٺHOߙ?d8 Fŋ\7j4i{Q*{p}[ぉvga98:1yt6recO HU{ɞsstH ?E VHNtnL+#02jI?q_h.MxO$HHÃ[ǜ<P.t'Wز݄YES*ĩ`8j۔>MlV5 q;&6/%xa< ϑAqYMV>j)| RۏzI2^l:r4j>ӧiw|b+2F$:}l.9)O F0eb^mZE8FQid\[zYHx:@\ٟ*1+R\JF;!To+6t$,:{8%ۭ*Kт; cAn}dyo+~1P<v"@S#]rJּY|M{ 2HTUlNqg\IDP7`(yR\)o-r«͡^pc hkT=+< :g)~|(o]rd͝fmolwcFIF]_E0U1 QQ1̀]r}),N:*bs]umn}NƩ&ȍHmw~6LmiQ'|Âul.!:tYk2"|h 5ANaLs25݋+*"Ԙ37D+`bu8 D&}d,7#pJ V\l탩ʇ$P.6-M{_AǴ M%+t#*H. <pL Y]ZGL4]m%g%ěmgչ}@^E Lxݛa D`k 6=lPQ*QY3\YvCTbAqv0W8һ>] o@_+`S/:uAR_ߒKw̓gzs2)Lj/G#7b/jǍq٪:4>-_mֆV;B HLLB,7}> "s f sF+qتBz3V_ 7 p! |oŊ/)*ϟA&kh_QӍV'H*SYa-+*fE ߞ6!4Y3_~SlIIhA iD\^XSXzL R,.6|p^.J̽5lƶld|{ΤWNeOL$a*tCyf78P~ؽ$tȗ\LVY7M~-EjɎ62! -'YqXl5<mǢ.emg.{ZΨyl*c0oAX@ϕ 92Wgk"3,|'@:/Fn"U_>ʰ[ġA᜼T"RuQ\QUenéC&\ OdJߦRO491KZϙlM^7|%gl17GԅE7rw"vm4}Ϩé5oLYDŽ5Q#鎅^#a!B 9l^8Ι뿳;Jql sB+\PےoI'LP56sK}9UN/`&DV7?GeF^Zf6+R_EYdG#M2q/[ʼnR#!/eB!1 JL"ǣ۾#4,O+w>{(+KւHƊUN` 6gfVo q[C|P 0Co Z˥@9VV{V`WݰHFPwi6k<7`MӍP!=U6[4ǃ,]E n(x߅Fnq,mR?tDʼne},QाZXm3UU6qoRyQ,{8&J;$Gq􁟼UגDβ0\ǍbN#D/`$<喎A'ѧy'Ij 7| Q9rE]ڝ[o6lQ>E %8nZCe[StԊk'R W-e~u _.1pmo6GtmzZ /PoY"V30VS݆SԾ`nf`/??} Kw+.qIӧy΀{Fufٕ6yNn!]!nPOX`pr-['YT=}p3tl }lw7ݟqw箰=#scg]q]F0cBȝg/ǿ|I2 犾A b'SڀzŲtPpMzw`~]+PKgVO?6. g<VɕRY470\73T[zYfq\ X$tUPMnY喭0ŕ !\ϺN ӛs bS~YOR%X㠈S(MñT+;WDl/h i'Ylb=;6 YW3exU<͜ufi1\[ d03*2+pwdZޚ>IOGyqo%ᶿ>qtT٦k AKuA?_}A,v AynGL3YБ<ԤStW0hA蘀ظ?X 4MHT (˖14- }JȜ ֡v3vnn_;R\պ+=e{%sPPy 1[-)*?f@!&NPI6n]0Fl9!f.7މ$bO%-= wJrW3TF[РU_rv繝QM_]j=dl xOz@#N"WY?i4-"^{"C3{0w.l Ks3XWEO2 w obQ ߜ(jyQ&8Tu{Èw$i_.]/bGLeGIT%bFx6}XŐlHҡwܿ&Y{JHG{.gQ ŸZ = >-Z6d/pYI*v*m$DU ܯCr[źC=i[88Z6I`|=؝2JV_H5+Zve^T3Q:Eΐ/8j#2-wEUH(8=oa'PqWgX 4Kp1 ڻ=WKŽ !A/`o> mFR>ⴂklVZ)`w*0ccA|Èu?-Ky Xl!+aY4[`*_`m)\w'(Ƅ<{6eK9rǹ# 'y̥B5`A5)[ْWBq1)-F?3j%MP]}R: NiRlyJgY^7 2VBCBS,[d2pakit[I$#_EK.CP\Mza4PiwLYDW "4NI v)/A~T|fNd5'?ܵH|7uܗWn2w]0琤ͭ`tY9+[CdGץy}_J ^'3ٯg0zm26=Rq]kwBڌ٥MerxywmIB:AH;_q#KZ56r{v:+ =+ǣa&cGE܃Jz$ǺWЇ}3ޯRI"D4Y.r170Ϩ>vPp _ q! D2DWRl0Lr2Er/"ɝȟZ$נ$.<%&rqr¹uT(pl6EV$8阉*<]+~wo4&Axٗ_CE~Sur [[EUZۦ$M^5&Wzu&$AF?F?st S;-fA9@ȗXcʲUU8SĽ2ޤmE;*!G(8yĻgjY ]V6|@<Ie";@TJcTk>/G0D'$BV ˓kybޱ^$[}%"%!os77sfn O;ȯlS`Bҧ̰Mi=(?riGdaĹq1>(nj|u= D"iU=ce\a37j>i0DoI`ܤF|?LW˷#և+apjMU'~B p!8^>aŨR$C`a6(PogO&grB $Jdld>gN/$1 ^|DLU"cj]"~Ơޛj>Wz\A5GpLq˖ }/l=>@) 컗SanlKsd:Pߐ? =u٪)УQߐ%bF"-NND]8W%07nLXWyMa6j2҉ Dxrݕ{6]3z|3{%Nutr 枷[D9v> 2=x%hҴ`])xj}IPw1DLqCl=4tCLJEroW# sٴX|.5it3!ҚM@ͬM"K2_ |.MdIjH /;3 20LJLlVf='EGy(S,Ϳae+丱S?ls؈_53rS &~ӝK2gQf ?̕kjʃQ#ԢD~Bz2~a0:#qkhp 1sW v*`=]:JyJ]i \\iJO'D}ۋ>fQeGP U0<*#`b[zhR([٪^R5)FմWdm[e^KGhѴGýR@CŎc=됮0Vi U&4m5#(ӯvV|Rٚq֔Rt:Nu]H@ZҦ~% %T~AA0_%~qRt~$ge9;EclӦWF?2-k=%JThɫs8e 5[& 9Q{H)JdM)eҝ-n!U;<(vGP*0_qϼkL&,΂l(`j8V}o^9(vIz2g{Y)XBӗXB_Y;t\@HT}3F)hC}U".1qyXMQ4)짨AzemOndp+[[7) 5?Œ_ VG[CwfDqci\b26 Soy e}> v-8,O?A7VӴ{9=d-@ _|>eV,Ə8:gCyi- BRn n:x뢮k~zO~;}|YG!p]CEOx)2fxZ(BǷM%9®J?LGieuliKc w@ yE#*v5zftۢ_aLGtB߈GPE@>PM?l~=t9ֱ<+_d/`Krsg쩎W[$h&PSwzǦlWv`jpTa[-?VVH,.t K`IʮU.cO+{>-<-~*F[T%x}a)Z 2~׫]>>&^xHc\e :=%@K~Oa>neY0<1 eBԨl^Γ==wsD$!uX-F'!.kOfKI2F!j;{$%}矆t7sh_/5DڮE M]D3I#YY'f׾"Vȋ7czYx̕Ȕ2,WS_;)[6;{7ӄ9Ɉs vcU]7%|)R$3]l=oej dES%J>:@RyK7~琯zNqxYnK=UįpP\ *+Jsׂпe|M68¶AFZ0 R3;c>c9z5t!e4/-~|kHU+3CO }VO QwڍƑBњ eaӑ~ #)6Q LYAUr~6[CV.#nXlvLBTصC"\qCT7+:-QO\mR?N V*oܡYM;/|va ?_57qPEP@Tq̤UpʦZ}61 u;QZ ]5:ȀP&OO:`FA qXuC_f`w l_6Q^ZGCN|3'6YѸ0HQLYpyj@1qNM|{#gGl I`M vNp|Y$Ej.Tw,TC{YAv# >#QV?P} .5e7c~a3gk{弋/<aX ?^R-^2,lPvɌnx.f]]jۄOzV)#z3WD֎0b]cO(2eި[aPyKaDTqi}Ӆa:h,+j 43k=n ʋ[rWK ~K0ܺ[Q:kFPJړW]Diɖ1*coRy#$Hhi{ ~8L9%s$\_)tn>cNRi0dr1vB r'ľ )Q#Oeѩj2 S9 4p&BLa aŪQf''tP:f=)?2IWpf8N%TN5'7|׀u_UN͠Mf~i0u¾D )vܟ~mee&@ (B|ˮiYQ?A}l\No9sෛg˷ĮBJXl~<ǡLP>eHIRr1r(gԂRqAx^sƀOL6<֬.|Dv{r?Hf]-&}Ɠ,!Y/^ ?5BYNH3xzg5.H>Z–SF1Bf.T[3" ωK#QjP"B]e:qW0[ ˎ܄T (u xMVu:0݄c zt:|fm-T9O͹L.A~$'gUGyw dHxkq̧ Ϙ=5E1XbgB?v4 յI?Vх[z*ȼdr9 ~VahnJC'H&12LJ^X~f9xtU_&Wi-͟ϽbW`?|M4~۱Wh%̴vHyc[$Gj{9lXko1A>=0ma0 vj%⿌qA`&nHqԢ8Pȃp#FVHf+8TU@堵ˎUv wzmE:L .:s* HCWvTan,5őُI%2WZY qz?)^4G";ot!hcy8@#]5wVMz.S[Z]8oBI3:*t$(&J"Ji%%N~}-y Pn7^< 23byKοqbM */͎:M;H*:4ӊ8͜˨¬@)H/z`$lUgX-֎A2KE೭f0/^ dxbq%hM',f W U!ZlouEMg5X h5&ؼ^sm/S>C#s8^p3$ED ?P+bXa+104K;Wݭ4rc5QiVMp z6(aV>ϓgfϷՁn5,ߴ[?K0 i+%1i9Ki#y8 ;s6W5G3]&aj{F6~:]]|[=ZG˙l&*ɲ K 8!f)kx(,F~᮷TB"3+RGɔ :pI %*07UM]㱔YtBTh+K${Qrډ9UHPkLf? 3^҄g PZj* 9h7IT pd$sϷ-*н{ui|aaWx#l:m13vZjy0xolguoOHgz0F|[ma[6}=v@J{199IRW\Ȋ&t缉XdKmB1A*WvVl$Pib4p]PGx3S>lu"ԸlPt|^ )wܖC}ts/ #/?1 2Sucq0QAd9F jcc."$mf-켙m$L*xNY~=/1|?r&4Y`EK1=VTdOuA`QeNH#{:NV-MoFT^,yUo '(A8jfk%P~MVk ~y~6eE;au |stWC-~ JƪyIRV<23[>E2*]tCY;T ʬ MŷXf7Z)}K8Dԓ40%ik QPZ8t79y[j ; 81{xI8rST42_+;aV،F0sČˉFML(F^SÞ>%:Ljdd5ZTU"i&F͟`]I!sȹ;+8jd݋!K_Qpܯ/' &yra暈 8[٣P8,ʾ>@iޠ:Niy`-(#K?Tsuo`.0>uǴ?3b0o3j Gnu8_GL~ҧ"PGUy&LjcpQ#ۓLD;=fMrjeL%ϯڈ"&g3!b l89?$ Wsa8wNPd-?|B}>f$tNkLR3w O>-~0O;0msĝS?\,QF$g/b݄G ldJAk[F *|;Jۅ GI "qmxÖwueP sj((}ynEupr~!".ܶt\" @¶K_cȧ&grj[zv5xMk3؎Z=r-+,i3NC'fk[xHPUj| J&cb>n=q瘙(,R*H9 r 9e+%飆js97ULWVN%-8y:p-x?M:c5Cy>Ļ؊o$o{;Tkda]A!7 "cw8[ E'2Ek`1jjOj£&Ig3SXgX>3kz%t[}0nBUG8[ΏiTgO#q骛@y&D=`lH1Ed!9ARvmVK׮ Pw`˝܁yT'ִfQ(8/)腍ahƌ\5L%{ضY 1ߣf$:t\Ά#{qt~rH!uL ֨Tw`<1.>+_7п|;ܠmpkD Q]r.q~GF92iakO00.a`.FtS8uYsxy d&Oĭ\V4w Ά/~g:fTFiǷ|'9d@ id<\1b@CPVW%ȱ6bj>xh(9)w.?Jw\bkk"n z66;_񯝋769ؘH#!pUJ_q^#][Sb+ㅋ rqݝ߂oTVU(&(bĤ·G5uYm4Fm(&&CζJY1cGcRG}'bVXl+,ώO/dӨOQ^R qsm37'3⒪nY7k7l!!;_$$8 $_0vVJ9ꪖָ ~ 7c_;fΩ مtc.(z jV\%ZҭL3ʱ-p}\?OₘgYY3yT4+?I8Ev,`ҷB.}0퀷6.MQ-|0Bt7Gܭl >)ZEUڄsk S@'Dwc }8@$CMa)aa^e3%0O['e)ۭ}>qxT;5:;5_mȩГ&F3)?^%~+!1ъ81U1gYdoܾ=nKllLg$&C,lHGYi!3 Zȯ$'c:jwyIϋm9<(޳},#wЈ5uKo]q~DaJ`%E9Zob߃$,5=7i4BSP4>N>ň9P|"Vڃb(1~VjJ#\Qx6'wQ?*zKViLܻ}V}j>=6skJK} #r?0Ή^ W1oJbN(Ҷ/*"$EVo T3Uj{ϒv[`nP lMnȱ$7za3g~51þ ąo5b\zD4vw/zPReIѴpʣ͆w2 m">Vam76a%MVw>"E V?Vy_`ʑv<{&/+{+i뙵o ,"F_Sch`UW!֖bO4 aBiyz`8}ii, 9Ը7E,TcW>/%ƴM$~o9XG{Gé4 }N]Jf(*MoI6/^w#yV3H,uݓI@ɦz P+Spbk¢ *TSs{ZnVz}/ y-1L+L z V$F)F Ox!2WɜLg]G,nEE v;2ugՕֹSа܅Ϭ "MY`ׁW" _IqI(k`Ȫ}5{Vbz!Tb b`^8Y9.\>_^La@*pNRN &ݹ^XID]qMP+2K ڄN:+YKǣ'zsll4W4{̌?r*՘?|z<*%b*隝[$%UHҡ$.]ܓ]5A?[{`vC̉NT_!WgN~~FrXW++#Lw%hb8!Lʆa@JË4rAֹ4*F rp=vÄ9NWPQCÄսt~#' ΙU5ӝ VwV&yhk;B\?ՍaN (2tx@#@#ޡ$!hy3 4 ^o2P/0%ç;W̐ vgݭ}FhQp+goȦ>2TfO}X7/`]T_,`ۮ vN-#Ҩ@_>9@/NR}ڐ'}}$[ Ǎgڙ댏4g5D/xJXD-G)OZ glļ`i$w&(u8J~CMU=$IݾڔaTZz?, 6!V/@SܭLI57Bǜ90MM#Np$$Sb1`S<Madh’[?&mePN69܋p8\_zg+J@ yhp7n!Uf¾4i/#%0f:xpt h qдH?.aSTʣ.Hiprbp zE=~+{X-I!5~Z>PƣRlJ :;kz0b#;` HbJU{,[u%JS.IY?LA!6B ~Bw򦓋á-is_@c 8^Ž D# }TBkBdm ~  ˛ϥ۾n s&3 bm,r&;8-hx_pQ&ե†-fe2u['tק(Wsn3*fɸQU<=!vQE Ʋ& p`:ԋՃ7gfbZp, Ӳu7 w)=/Wb}g4 +g C=fl?CHF,lYw%&{&Vz1<Kv h,̚muCC-BHQ ]-@J 7w^o# ;;P0^3⊚qmE'ҧeCޗ,4td^` [+qqLҚg ;m=#+}y  NFR$iɞDSkhbOtLpۏco#=3z@JV.c:f܃2XD>|!Dza @!䎹%2V'X~=yt1oTLo0 ױS4ɖu#x`- I?8q Ox\;}q4[ I~`Wp( o1-% ܺ3C_ z+^GX`nG8:03bշ/~YTLƇH|5/.9rRV Wp,)<||[.UM'|ah<n][˷09tҎss40Q>Сq3 Ld+m2YK!(:v?"A+/l x Mʂ4˖a+ݨ0n[}7>8?ds*qj ECny<ˎP=9E$TusGx ?'LrN#P9F #@EǓb(cZOWDJ~>7?UHLʍ h'uek(!f%rLZҟi݀'.yq,iWR>|kxZ+n/}^S+Eb vEyfLV}'tQ[ֵ4ǰAQNk fZA.fé-{by76A4Iye|LwT #R|quUFf̓ ը1_ b7UZ:}|YMH:%b" >WU䣡(H ݑ/ǎG7`G#Eֺ1?p4U C2@iC}is]A\À8+"a1z,t4?g_xm=}[T"5MhXxVˋay͜$cuD'x%BH.ZERi-A})oK0*ocjpV_pRz$.{+5P*J&@n:Gڪ8WΣ%XR~A1\om[hJ!C`QHdG |;͔ ,3Ƽn XI {F㓚)m7ky:xm z(U-bc_IҪ)گ1Zc7C|coil%#||\2"E޶%k爟4'xmGi0s$MqMLz8f`[kyY$~ш\ܹ]#u$aIc.O=U(7܍o6S#n 3)OFT95R~sbI,.sE O$Pc>A2W[B0+2bk<=O>u;02g0o} 1cn^zжT :h9F) b[8r U7Zil+ش,dXͰew㨌-!r>`6Pl`לlr`1%~i}bs?8.C7Kk$zA[ԲE0ʑ!+oPia6a#;'R`Qē^Q9+C( WL_/krV#>'K:\@,a~7>Z)e#VGWLA8HT1Qur럣 FN$fÌxI62v_Fzȑ:ԓ.t&YY NSsEiphQ{<{7j5T:[z Ԛn1V8B Boi UQs;)|Mg_5ծ )O&63i\OYR;оɒv￨]P&0 s%esSI,_ݻrBum%gu`<iǬ,SK[nRn @%~f2 ߾bySp򛚊$!-Z[}( TX=2i 5`SgR2Jd\~DX;Gᅶ#=UQ7.eQ0MȂz~=I5;WU}tE TÙ=p[ixqo$h,N5iSs5ۇ4[\kCCOH2y(=i/^d>' %;XNDc?[D3 xAbTHߗ@*-ho[vm"' WzcW5J1 2m5U[6/NÁc+mJ)hX6c0$gg[Z86W#G'!yMZBE(zU ~Uo(ȶ*φqρVNZlB+]iDG_wG\!q1! $FV@@JEs2;UVR63};ZJ87nC8RaH"zsy '"[F?yUI_Kf)mIA@O!4~f=x g]zj-tf.b#yTVt۵Gv9RD}jҿbV= D˒2Υ Sئ4 Q4E-CWځh @!x|Ba). ŋBm, tƀB-:ʴ1&􉛯A;Sx P}MPhYlVm_gbSo {(='>0Q`Uߝ-_Ca2n9$!ʬN :B*7Fɔ'\Ot~ ph[YQՄGHGeE߲,5始i2yKc̮DWk&dJނP3َv m{ﲓ.QD@_#9|[ ^/AGmv IJбſY)bbZ{#/_9N&cN[)=񯴖B~uɆ#ǃgk!`_ 7@$zJ&s)ƀ58nxTՓC߫ͽLϴ\^`a|F[P}_q#tW!$/"{SR6d|Aq˷gmA*zI93~ g/omkJUѮJƏ@@8,o},ܚ5$rܲ]Y*Bn8U}L(Ti᮷>ΘSe-MīygECfTo\[ә͛RW\zb iɫ-Pzˤ9bU qcQ*08դZc^*jFqݓ=]ɉ- ) ljZZU% ΪldDZ6wR⺯Z&eϢ)4u.Cm.gh+ wS|S*KjVG_) drKXj&5WoЯĠ_#Pjnآ*~|6'['e_æh3T噦] h<5ɩFJ'?$>d|s%%\>U~K{_%2!g:a{ (g3]rVl (- ⾿f6bHi jM$`<˅KXvd@HG'BfՖa>efiLD˛bkóiwpЯ9 wߩykp4nΗHcm~| 3Xf6YP. or 8p`_Ř4s"f.,e5d:7P;l^"kS7^Ob欠ӔuJؿ zcY r:L|^:m9s"SrIUnV1|BfnmMN QY~\8?vՂec(ŵ}%t˄[en甓6HBdJۍ . gwad>73J:~}Xyr/N)k'5p|>1!1~q:_;طtL.xIo-[)vVe'S?mQ+{J. N2$!~ڳi2spDS.v7JpRX pZ}\>A0mFt5lά䃩~Yg,>A V46p NlJA8* {0 %GPv r!.ALjr x) PQ:y} n Z$|UU:dD#R}#/P~BoK%q#4%OWo[nL.7u Rܓmx0vdd%3ziM^nuGPݾB;Z-Qbw`+vbPt6ݾ `u VPmcbQZy5!4标\ܢ25qs=OwV Q'm:? T]OIkStDcgW)21*O0b8GVd}Րh/ᠨi1ba [fyhgWG]b+Fgtq-vd=Uu^z^BK##!@'/ `ŔPýs\`Z<#_G(rI,i4*)T6O*+9fjmvltݿ7*;=ڦ+R^{'Yo퓁Zhg >@ =%-^[Kj ֐$#&EQW>[][!4ܼ^֧! >\toTf֣ yuEH|o?q}Y;h!5Pdu)lhh:QFܔ"L|ukېTJgPbpK#H,XiѶ? r. syMϓ\,'fGZ/B ܗ13 ;[\`m-,XBz{D}cRbQgbfI6ioN~X|bUM9[B/ܰ<о`֒ P.צų! ^$Rf?`?!IVjŊ[k^[sȍgvMpJ>SVY6vi!?fվ'/'wqs-Z!E&ۂj=0෦Xde!y%tп@EE`f#HFRޥ 'kIzZ}JA >@>E%J>K-KD (29С @d JU8ԞE^ r{Nigg@Q/mGNߧ c5\׼\lw `q{dz1k@LOgVPVgc@3GZwjjYY*s<" @ނަҳ^ܰ}@*:Ƶg@–.`X/ :iH ;#2`ʖR W2j 6܀OhKPfLT>f rx FO[>Kv<_>;YdClB 42IjR{&U0tzgISmCY'=ӲKobz.tl(wd:H>̹C@7Yx[py67Xds.f o$s|C;vLPgϤcDI׺OHo va!"J;"n^'&vW̅vfyZJ`ũ`:XMλfae:縚%\mz#<(mGUj  (A 5[Y]T*N5cF) {Hu+ud4c >XO32mhR"иVXQ{w ~}LZ,څ(Y2'K 2!"A^S 'Y@^F1OVSClE)86S,"D{}|VqWYfL_J;oĿi ?@$hY~ jź 7+fy3;깟mK06Os!v Z&;.5>30Bt ݵbA})Dl܌1OnTۥSگL VxM5 2=)|_FFtj"]Q-S5.iEYA25\B^2{~N! E]1|`Ns՞ޤ&n)c;*e>tc_q}61xY5f9o'X~ P4{ mߚ`U)ΕǨo&k(的K%O擙/ dcsWJQ2X'>_kNqeg/K.7'Q_dBYfȿE$aտ9Oh:X-pU P<./K7Qd=)νiĶ޲a:Mn}ǥBeEa8/JU+kv (RJ.;K-w@2F>w3t{;H\\)YxjYMTj^(+5X7Ja)qU>Do`h)P;lEd0[0gw*Wl?rcnnAƟ5mN &U44biJ7Q 6Jnz:#CDZP)`޵Ush=AЋ!` 'WtZ,n$<>7٩d}]C1F9NҚu "Tզ  ^< Wb .V KO*tVm\>)~&~w-JܤP&~dw~KJ0Olg<@Q`HC*&g"#Nk];!=2hm dt~R:O%Ɛ&oiv1-nnR0}y#_.4z7{7*պI\ e>X1zkM= »Ȍ[zнsfBIsP5ϕm/ܐ=ɀAVs(8ǻZ_8b>?~DK@sZ:W%Q}! amٵ0VU#Xdru:׵?UWj~N;jpau z]NYe/3= ;Ah %ĥ!}AnF~FL6?;&55@~RXFsw)T3|" gRA32t 7M{y9tw+'/^O 'O`x8Aԩ}K־˰˅=`0Ԡw#oJnE-u6mxkTNL2>B|sK(ꞃd6s?N j:?(H3Yu ߯V$J[KyE\Εev%m| z;8IƗ]CLn5gVT0Ľ[a`{&"BjKr7i%|"Y@x[^ Ŭ ^ >+t͋cݜGjΫhv AuSڂڇoE;gf&7|m J8s;*!8Jç逗 ӄz ( g@:V[Dx@EG"{aQ[^: HQNd;jmDW*-+j3hIa#8_I+rub\pJz&!Iit:< " 6} 0_'r' =o42Ktd *LPp_񇣯DūjR(^5zR5q$Z^+6_'t5 $Kt%7șrCnB&Y3f愼cd>ty;NK&4v,*\| {Q M4y:yDù7O>.c&`]:>K&խA]h[K+wts˘]? B 6jU),yr2!ċ[aY2_e'(Rb[Ō)G:EJdV4n(@viC{tب'@@xb#K`lN^H rޅtJ\xKǠE)rάk=P@~`7K_P:Iu*X8Bx ޗfK)XpΜrl-:6x\:* pb^4\҂ZBmOzK3ab7 U=|Zm(K0x{fB&C2@jc6⫖m=ȭKԿ^@X⮀P BЛn#O)W7"#xI,655!ĩP2@)Dj HYzgwt" M"C灍|LȜx̀A1`ݻ̭fkBݓe׶tǬnʂp2dyrSVer>M`_unnCt_4u?.i8jj}Ji +1.X'N#Tk2q VFFD|vd~t=ѥUVW>~uRh QcmQ]_lxCL;5p0~&u]QQ8U2Y+q +O?#&p펷,6rqbCOѝxdtxk ._!=-Sewu:R ˇ Cj e9rmvn|ZORqo3A\[Y3H0y(ojdt-V8W_%y)6<4xțVrAl\Kp{2M!FQL'hh HL2} q52rPsy_KxHs/j%\)W|8ѶjaS;&SC]T?`E< e #pD+%̋vܞE19_ai04ɼ>wy堮6MxFYc}9@Y 6!m*9I7bfv(vWByk0AX imCv6i *&(0\MeFIz .%[9"^Y!I^&9&F&D*^\Iw~Kڀ^wND*!FXfC [ΊP**?{owڤVYڟ#&=?B2Huwdg^7x#o ~|2|@XƳNijH[:;L:$~ݤ(/"m+(*@lFwQ:Ibu] ]ybv$_ x^@? mbIuO1rp4 GuW& Ou|mDaCSE~HC TW~8-^ƆX;OXۨӻ9g"C8Q MaZ%ik O7AɋCT\OX.׻yLʖeĢQ߀ky1@7r޳(&KhsVQGyySw垝a29 ^.alng:VFʣ(s^懪^vq4cftL;ɽ[շh&L2") }ћnDe6T5{/ʳ'Cg6l4F#_B@i=qr=M ઍLm[X iJp]ŵ{QN3+m~*7NgO<4ЬOy}ˎ03dy,\MbD}CJirp)6/JE~-c5Wߪ7ոtGZQ01fN `Z ˻iꅵ H*31^Go$oj4[]i`M;U!}z!`(m"KnNE tz9zc={v?fn= U { I^<$HkD ^M^\qr#j1;Gf'NdN|KDFy"lVr#R 1N*L Q.:#Q+G1"X;)< 1IY,;jtd"Qcf_m֭ozwϴIgl=$eht|eϭ"aae%cöx+@Y nHxĥPCÐ2fUU9-mҐ$26^b)pL1^64PqRF!BmHk¹rPelfH%6?(^λN[d \Hr5A}N?C^|R*BM|'yR91Off9 ϹGTbEQ)$X]GvLzm=KOY +h?8)zגuFWO%{G7wnE:8JW;@u:^lz }%V a<ϯ\ {zq~ӂ,lGqL/#1-Jaw5JzMrV^G7_QK*"KoMxŀBG\]Rlil/tnn{c(qɪ[m{iUaYϰSf3\R?.!G CW?.m7:l Ŗ |3Ocv6*RG&@P cЅ\z-՝6ӂ$CIނ$>xy#Oaʟ%tѫ]4<[zn6snN8Lp6~T6jC6/ ҺRQ('+32# E񍢧ȯS9l՗E _S:'_5ƯꍄO:b0!?vOWKl$8זNEƑ KiχIG:A5v 06myk] Tk妩z;?&Z{0NwW;  LV( 0cr&6[a +J`DE1Ʋ^&*T2,WD+[xpׯOD-c(د4Wy>87˖ϼ?2 P-I 8*Pe3Z֏ŗZp mL:[ݨ* n~F`E\٧CU.Ȑ)I6.υ#,vziޤX+'mrY"Muz3d*. Gj ϳVj#ҩ[0^XdB)}[u<$f`yWI! ȹ7LTnhQ9tRةt._탢 p_̨o(z'<;Venb\D D+ "i>G7C~ ?bNg{q;)#¶m`aRRxHEkI׬ TV'j8IeZ?k+g㺉&O`;_.g p=WTL uٶ)f$VnPgwDL1kΥgpmdEEUt[]VZ/~mZ Wod128{Fڢ7H,Wk#iyQ0ft%bf[Cs 똞uRiOj>|o˃kHo*T-l=~kz̪xAR%cWIj?]ֹð"N0Z| 6L\M-QǯpD@3we0)L/{#[[Y*TVL8ޮvy G $yyxHb`[oaX%Ŋjy 'OA?%DxbZmw?S+|XϹA>kg6nzXVxĎQRu^3L^2.W dzUEfc WKFV|G)U-K /͑^O>Fo= g6V0b|̒cŴcӟXb{`h럲4o{r*zxrBZ`d+р vb?jgWh]+OeཡW c2qOt]"HiR9̱ ̽dwaA)į kIq*>]W)R2 ' QȗZ0n~SCyP#7 O qJn,G5x9ryEo.RxC O-yD*G QG{U$Il}-9c&20/;1 %VCZhk<|Lє&s>:ܯ]_8/GF? 5-]\Akfzxf%׃Z+1-| A/whH|ր|+XQO X6&RUxy#˒uL˜֘nS @#L|ۊ6Lq#h&t?@$FýmpEIn2`1R%>yVϺ?qgƹk̈(~A࿡z05v\6@Gb@2"|mni0+j8`Q&n!­z ȕrah!'#e1!T=iRJ'X7_P1JIBI; ~zEצ$ǦhD@f1$M{aK_/ Ә ȯكG+>`y"Η Gu)qeIx[z܀D/ 6uET‚zȢ5[8[(N\Cew:C n4($M.)#ԧΝj/\@ទT,SMqgKzAT5 N#CהɆ@dχ_Ll}` w(^ASv@ڷ%>0؈ x 4Ȏ␉4q@ o |*̊%zMVb0nfk:[ӯG爿ϫYJ{W: eq ωiB@SwG4sZ* M f-(fX)dHUc Ki>pij8V h_  )?u҂Hd`HQA]Ѿ|evRȞP1gac 5! _Ω'm]$lHe!Rbq_QMO\Pz>}ZʂpS`v0(x ADXUCB-I"]յn:J~O 5;|x.Z+j5Rc?[F%wS㴖p9s^'*wZ#m$#z SSz8"$BE73F!ؓ0NnJo~!j];Ng#&]_YIJ}+ #RgӰ*=Ķ1{̂gYZPerl-APIReference-0.16/data/perlapi.5.6.0.pod.xz0000644000175000017500000003125011653441731017436 0ustar tseetsee7zXZִF!t/v2f]$P cǷ=[o^ɲh%*Q}Ԋ Y.Ʈ{P]jq>9xtU_&Wi-͟ϽbW`?|M4~۱Wh%̴vVaozfpyP+ŸI.r q>lW",ΆC-OLJGS*kIFX c̲uZ R =0}g>_ FЙs9= U7YL>!r.FNJO@4f*SNanHbn 9q%Xb@E&}o"˨8D>{p& YB!98/%pbiZ ,rN^p3(Hxe8,= owsv8uaRa+%>k&8!ѴAI?\oJmT }zf8qfFV'- "_Z5QRj >7M?1/OuR) y䣇fU3MKХLjƤlč,ʹ1h0-;+VO) b5;w"ܡ ujW|͊f&L;ib b"5pj[?Uq"ZO+lh~Pȡhay-TUW4%U ݯ 2Xy ZkdGOlf\^ѠKO4_:yG,hz~۳r) rJ藺gն+7dBA2wڨD"qxyp. B,ziCV:;X'k 7 О츯v{]o]pliJ/O1FkK4 ecWnxd.i8G:d:!~KY1󍮌b"W褩{Ƹbk ^ [Qu{:#!@D@q|"8B)= 4Ef5ޢu29ۇ?ji FʝRe bU)ُ`|wG=xUC 1D>@|O82^:_m|x8ܠ@st)_E !U^Cs2* O{QQx2/4Z׭6Lx>uA?rlHƵv?'R(<~ ;;77ВB]Er lwmop' ,R :|wUGFy"`9D.hguDC[oi/L=7 q_ p(xR*GA Jw?!(J|0Q`Gbr.ڭ:PMAuT<$vK#:ˣ |Lko"#,NtzNxTJuj\x#rp"N̵G%U:k ]*L3z}IuIrw}h)D78 Mm`ʊ5MbN ؔHK\AQY ِΰ tkvjƽ0X̳uS|n^tJZwYQ%ƘIY ġ1n I4424VHi7Q90F_|u'YRXL{Zig-7vpf_]Ӎ##=[~כOjM=mkK.b{2dP<~>܃HڞE#۔&KJ\ |~ 3"z3~{' C&Sጀ3@vm*fs8$#=N4iUIA+QYA\,D>݀Rn(bmI~H 3BakVAcFj8\`1D[OA0Mt e-_B(J 46.'kg(2vWN+܀m0NSQETy۴<,YoX~9#[ĪUE @QcA9/fgz.UF {:z*B'K@J֒*hfy?|$ĉ[_C4 K@(MȽ(V$=mSBOAd4;OSa.itPzBzNI\ĵ%ʿ)$"RE%ZĿ㴐GhO|qy!=} t2=m!oAbMy;Au;q/. 8W1i 9uݢ$=f ϼe3 KPضC]f;yI "?U1\'?Uޢ4:/aߔ89.d16Ns~]Me:zXׁO3-ƇI.v6Df"wRmτ\dJc!Iٔׄ`RA (B9vA(a׾]ebkWQgfdt,ϱjfp IY勤Qb+eݗ ~,t;GS2Ef:YdC$ǩ9!dhB5V~}($E jGh6el#MF"{%3Kr *G*af3.HUR8+z˕ Fd+O:`6U9Z?b.m8H^N8d/¢߉s @|׆+l'<76ßHl6[+I"G-G*X=+J|ǏtmrCI9')8`3n`\diTevDd:SHcx qChKk`3­qkQ*JtFQ=(ks$|+[93͞q Tݽ>m#q^5Z iewK$wٺċ*.=NG{"=r!` =HyVEa(Tksx4p)gP\*PόTٹ**ج܉ڿ/l3Yخc %yV>~` ^~LI,1$xXSI` @8׀_5{;AskiV{z+#+˔N)kr)}{Eb cV DDHXTک-8f?%rVTTǟѼ8p A7/ 08ނudZiB]xeriGqa^JZ، ~]I\Zv^ut)lW Qgh4ߙut;~6;k˖QuWD:ëIHBNYC/{ k@|ۨ>hT3?6?Vcad뀺۟rdO⥶䗋8jSu2$3G-'i 򼷪@^lʰ^2Pv[闗3!ىIL-ZM!;댆o9l[eSG*o .+` <(A]"[R[maPfOrlf7Fr:.4NRW !i%HΖx`8l~=ÐDW#I9߬*1P. 1[DYwoк#k\Uնd^"r*VHܜߛNV2* gtt 4k2'p#^|=&xo3!}2R*H$=VFK\i!l+dtopzopBq=GĢN&&"ysRI=Bߜl{b<3W|ڻٔmvjdڥCwNi$*-$sB¢v3-ی{mFK[[hםA2V֨KS}jɖFBH@Z ?+ (Q2 ,A'p22QFzÞaGАl<RzSRdCJ<&WnLóUD/qr}{ɄƲaXjJKӭGN?_d$AD#q`3>ߦwD'}EJR]r%_w}E$Qَ7` ^K3j1e-Z~BLOVc"6 ]|`ЈY$K͌|z^n$MO?k9KֻY =V)C){XTt qZ+ SJbHll+{Q (y,=,갻QS>J`=i`F;*l ־V˷"==/Su$!mIk>zr&˦Z!cˀ"mJ(p?&p[-W"ݱ S 4-rF1 ٧P{Ls&A``oP>9ϑ]¤ Ej?c (_qٺq/,Vh z7*%'^z;̚kqCd*~oY41K_ޱ$JzJl_NlgrkN40ޖR6nHau3Vi"f ~%@IAo(el bDR2@fmN `;rr]p+~]g yX̩d-wܩ]BE3ޅか TNvYNcįeۨ6Jal6FGo]$;cé$X>aDK=8V%s1RllةX ëUy+9 ~5y.֖&kl_Ǭ?h/:yzSLJFô,Pw2# 8E+'1#Vo[vT K#+P/SC֚E_, XbnV'lm="C`{VպKQDGY@j%+Ao0ֽHUDPk) JlZju0 A'$v "oh$e` EuN/o(gx}(EQ&5ecwEEՒZoaGIC=j 1\ ,*`a3Zhԭ?SYN8}|d`ܞ|Ldd@fZ%4VIg6JAYEX(viݧʌS l_Goɮ|93$psgY 7TǝzDtސqRHú֒`wʱhKi/@|<?8D!Y|vXq%ʖ=g[eoFDbgZ4 dO"-xfS=Ԙ)BNB D E`l `]ss=gaoY\DJK~a}/.6(h{L ?(,y51U2E&&:ul1yYiIΕH6O]pNFҜ>W!F`E'%d r;Ȑ~tC=*nhj,m@&R+fmfed|)YGLź+Fh+5\YDk/t'b,l /< FaY6ڷXZ-\$tw9 \;?:'y*A v^&~9x{~(sϥUθ_YOVkn@-2: *yt `?kq-}n.MM!řXgTSgR'ԓ$:*`_F/?ejF:? E]`<ZXc?L_t['S(ck zb*XJWP3׋tymiu\^@ |tA&gfs$ [G*\$F;L%kXY }V"f2T:d3[ϖD̮7@'mXyԖlǰj@-eZyT+f)6:NT9]V$-X>V^X, 0?>5;ѯ]!LO}^V1fFӨ]`9^?6eý!A{@'5d(GlF`>U8$.Xx%o<;-t4I>SFIɢVG[Zi\k,pd !B(k HzYDGz `G1N a+cIelR(eO.J.qv'O(T#-؃e4]s)ʞhZb]nvqzcj>Pi 75eW% lɎC]'quխ:qau^,bO~^3_fN & ;>|+bT^B"ăSB̺ћuAmB\|OAղԾt>9~bX'e:amT<}MKdursX%be{Ϊ1ydgѬ=e1YQ퐻L֙8:0^;B꞊>"%YdF[i]L3Ȅ_%}z;r{yYu޻Q[1I1* 7F0] Hih"̦Zr|;vߪdR7x`*PaҺ.#Lz(paѩzo5_Qx(X44m9˃Jq95͸LDgUE5;&S^S}}倠XݴGI6Q!{{WXZF>%yC|{̖0;Z7K+|&,pԉ:Ł؄a|f*렇B{ %B1եzM׾N+k~\ss%22K~54>/S/H@h0n B i6v18juMڧܾD7EV+VƵhEo;,N妋8Q{6Zb*hI/uj//;wufv퉵m~63@N_5>HۻFA%|v2iP_}F-43Ȳ%j D2j9bߢxgH'\h}]x̽m Cm7i$Pf/ϔez%?{S$d&/&a5{*g<z76Hq;}yb=6Ӗr;j~]c!=36H@eTף;^&[~Ԥ;;u띯0L,Rdhf|: ۽>(f_asLPKk׻Vo]œ/Mu_b\'w8(2*g6EA'[@VB n#:ECiu`م_sfh _LVr)oVOBu7wd֣@Qә>gxjϺbj 0.}d 3QC 5یF%ڱc%ŵW Qi-STnj~^jh+ %ڮ>'P:~"٘~y3BsVKbXˠs\=UU/AD H:뿪c Qk]QFx<\1Z:R9oDtSD&@kdicu Nd ld& 73$3f#621 4Q?S03-HM4BW̄bwV3 rዻ-5`.N7RSKsD R!ٱ,~DӒYMa4--QNz#Eb=* WXw@HZ?*[®U#u\8NN\s8NX7Y'|Sɻ(-|Dc:.Xg";6[П\-N ~"\Fve-B º&ߒP@WSpK83h/ 78 \F)i,#d1_)eE$Sv6 *9U;|(JS`o.9,(Xj|t"*a9 u隄BxxsTa4=1ڱmĸOsaώm^)ÈnNM#iYW">ɒ!Ng5s"ԁ>؉:ީ4jhK~RWp#S6 |w28|ɕH<''~ڢ%ϮNbqxTC2 }>4!2fPGµ~N&_Bzjc ;SHxBmֶ ĥúrT5Wq8(C'NѻA$z\KǝKK )-p @u'+&oɢQ ;eVhB\zy=WQnQ9Jj2٢n\ٙ!= eYjJ?- M& ;vaR"GHB?b9HS? 8)Wh"C.E'z orX i)+MS7{Ø[~&(}|+=h]~)5tוYad5'9yj@1(KP~gmӎ 4&;2S9{|[ߏ7zj9ҙ?ʹbWeL7Ϥw'H(Ӂd; .ɒXq2I{}qQS VAqMS<"t.pajsgT '! .mTpb"8k`/Ep;9܇~I]ߵ z!mW`43!)DC4l QK.(.Yv]@Gg;iI r2H[R\n^,hx/X>1_ ytU]ۊbv oi_$F+G6i|QAS!aJ$a$c4 "mVӛ$C1 xutBgJ#X\Ӫthzk2pϨ `@m[EYy&V]" o:lw>x8(V(_SDi|VY1,sx}w:ɲq&KC9 HEN^]t2J%yn w j{8sc^jix~+}ů6+Y+ ]h " Hw GQ;pEbM<c em+gYZPerl-APIReference-0.16/data/perlapi.5.8.6.pod.xz0000644000175000017500000006353411653441731017460 0ustar tseetsee7zXZִF!t/g]$P cǷ=[o^ɲh%*Q}Ԋ Y.Ʈ{P]jq>9xtU_&Wi-͟ϽbW`?|M4~۱Wh%̴vHyc[$Gj{9lXko1A>=0ma0 vj%⿌qA`&nHqԢ8Pȃp#FVHf+8TU@堵ˎUv wzmE:L .:s* HCWvTan,5őُI%2WZY qz?)^4G";ot!hcy8@#]5wVMz.S[Z]8oBI3:*t$(&J"Ji%%N~}-y Pn7^< 23byKοqbM */͎:M;H*:4ӊ8͜˨¬@)H/z`$lUgX-֎A2KE೭f0/^ dxbq%hM',f W U!ZlouEMg5X h5&ؼ^sm/S>C#s8^p3$ED ?P+bXa+104K;Wݭ4rc5QiVMp z6(aV>ϓgfϷՁn5,ߴ[?K0 i+%1i9Ki#y8 ;s6W5G3]&aj{F6~:]]|[=ZG˙l&*ɲ K 8!f)kx(,F~᮷TB"3+RGɔ :pI %*07UM]㱔YtBTh+K${Qrډ9UHPkLf? 3^҄g PZj* 9h7IT pd$sϷ-*н{ui|aaWx#l:m13vZjy0xolguoOHgz0F|[ma[6}=v@J{199IRW\Ȋ&t缉XdKmB1A*WvVl$Pib4p]PGx3S>lu"ԸlPt|^ )wܖC}ts/ #/?1 2Sucq0QAd9F jcc."$mf-켙m$L*xNY~=/1|?r&4Y`EK1=VTdOuA`QeNH#{:NV-MoFT^,yUo '(A8jfk%P~MVk ~y~6eE;au |stWC-~ JƪyIRV<23[>E2*]tCY;T ʬ MŷXf7Z)}K8Dԓ40%ik QPZ8t79y[j ; 81{xI8rST42_+;aV،F0sČˉFML(F^SÞ>%:Ljdd5ZTU"i&F͟`]I!sȹ;+8jd݋!K_Qpܯ/' &yra暈 8[٣P8,ʾ>@iޠ:Niy`-(#K?Tsuo`.0>uǴ?3b0o3j Gnu8_GL~ҧ"PGUy&LjcpQ#ۓLD;=fMrjeL%ϯڈ"&g3!b l89?$ Wsa8wNPd-?|B}>f$tNkLR3w O>-~0O;0msĝS?\,QF$g/b݄G ldJAk[F *|;Jۅ GI "qmxÖwueP sj((}ynEupr~!".ܶt\" @¶K_cȧ&grj[zv5xMk3؎Z=r-+,i3NC'fk[xHPUj| J&cb>n=q瘙(,R*H9 r 9e+%飆js97ULWVN%-8y:p-x?M:c5Cy>Ļ؊o$o{;Tkda]A!7 "cw8[ E'2Ek`1jjOj£&Ig3SXgX>3kz%t[}0nBUG8[ΏiTgO#q骛@y&D=`lH1Ed!9ARvmVK׮ Pw`˝܁yT'ִfQ(8/)腍ahƌ\5L%{ضY 1ߣf$:t\Ά#{qt~rH!uL ֨Tw`<1.>+_7п|;ܠmpkD Q]r.q~GF92iakO00.a`.FtS8uYsxy d&Oĭ\V4w Ά/~g:fTFiǷ|'9d@ id<\1b@CPVW%ȱ6bj>xh(9)w.?Jw\bkk"n z66;_񯝋769ؘH#!pUJ_q^#][Sb+ㅋ rqݝ߂oTVU(&(bĤ·G5uYm4Fm(&&CζJY1cGcRG}'bVXl+,ώO/dӨOQ^R qsm37'3⒪nY7k7l!!;_$$8 $_0vVJ9ꪖָ ~ 7c_;fΩ مtc.(z jV\%ZҭL3ʱ-p}\?OₘgYY3yT4+?I8Ev,`ҷB.}0퀷6.MQ-|0Bt7Gܭl >)ZEUڄsk S@'Dwc }8@$CMa)aa^e3%0O['e)ۭ}>qxT;5:;5_mȩГ&F3)?^%~+!1ъ81U1gYdoܾ=nKllLg$&C,lHGYi!3 Zȯ$'c:jwyIϋm9<(޳},#wЈ5uKo]q~DaJ`%E9Zob߃$,5=7i4BSP4>N>ň9P|"Vڃb(1~VjJ#\Qx6'wQ?*zKViLܻ}V}j>=6skJK} #r?sDɶA%D*xkr,y{s1RͪR8137'[ϰ)͘\-*9 R}Y Tq0c4@)3cJӹTm**[ypjvA0z@7?@SD#ߓENP]չX^N5u*60Cq{׍":sQ=;c4m,_$H$*B:Y*Yqߧ٭2,xU#U [hnSV{6xIV Fn'醸ХQc!qC @%CNüP}p,kG3QMMo7GI7u71o9Y y>e܀(tSX(B蔿-U>VU݃Jr[CGf['~ɔN´4 _փU`8y,>7K10 DLndTgJPY߮R8--W/~=Z fPS cWs -Ga>4;5$ 󳲀(FQ."#Cyz33_*>5%YON߻=qmxn9 _QPx5걲~ ng#n+[جbI]/1(h$&7YgӪnz[AT>8.* Iޝ#U9OȲ"\X?ίA꫟_/nHyjsh[ طvC_ 2~^PLܪ#,$iN{45 dICxmRɪS 'Mg̜ĤZJnN[^9\̇?A^<,O82(<'}p0L+d?ߒTwSGQj4Aw& } @nB_B:x`VۥWXi#~zQ ӉD!$g*|N"(nB,v!7oGWZF C}D~Owv]XtVAVH qw(ԁ jbo-kIP$%8*[K9p"W$i\(tA, th7ntӢ|wP \c FP;7QۚD$4h.& se1~E;cgEt n`j4NF_B8Ϩ3 Lm!&WBMpE;)g (Y篯s^Dix@RB)x㣽1@os'|8/hT{#sԵ_K_5Ξ19"$ C4q)]tj2&:ٿT4oހ(5f#Z$KNt}_l=o)c$+l(uUMb-sXX>cDMކi֙ Iy#Aw1[jߏ'Dd_kXJE}X`BzL@|7;!kLP[W,SwzP'i$?4S g`chC>@`-#(ۗf6LQzh|H%(5kK]ħW"27ԱCNGZ"n$9OKg{^Kw=1ćK~ s0S_>SSzcm,U_>pBD|j΃8ԘaeL$`!Ŕ@DKe«Oyf$T%ge=Zav"V;-9pwH&C/MB|9^Lm!~DUq6QbÉ?PR*t/6I~r$"٦C@&UGesT`' d>txK0VXoiw iYcTqU\V?/(rPw釠^1`b>zD$UnG' F,`l HQ7n.fq`$e(>4/]a@2yqK9`% 3}V}p^*fe ,Jʍ0 _F[zC0IM4#(Y, + "4¸"7KNBCjcvm\fx]gtu-'}!/y6Ẻ!JgΎNZ -˶`?x)㡾y!x(Pw&pa>5НFQ~/$~(Ժ@atu`wH?Dyw `img;CwPG'ԬJhp/P4ͣ2bJu Rp25,6I Tqj%\b$eP: Z^ MZMk&8ۗs+z0L;@%9%"HL5}~х<8Hݿh&|AAXo; ]eCڗweZ*Y#IV;֣Zy1:&^cCMT*Eyx]pxLMZvAMqzWSnӰCr _o #*7-ez5Y7(ũ_C /Y ńhL=_n+}ZvINj~>kE-BfwEcX,.f2W(߃á- ?U=~Ά ) IZy8]Nv3ϐ$(aNO6a﬙Jv3x9Zwy%wO@%h 6jNr>I!<bqז5:Clh|1V wCK4cY>QTU_3(Η/ZOg35ryz4W[eY'^02kĜ[;=7dJS?ğ]!TVqʜubۥ~&#L+U82 ڍ 9O QQh-ۘWT7jo}یiJ N՘Wel'aʖÙ.b앲5vV2П8zQOtTMˊu{oMkGFѤBM$nK]2vZPm?DzLV6o2jQT$=¾apFfC)+ tItAvja:c</n! A +%u}S )M!f*zh'DxĔiq3 1Ei;4>&OjX ' ^E=&i5LȄ1%Z }&Emu3p1MyI诪axl."y6$^ n@l Ge 킡^ot#q *!K.n| p#$?]x){Vsm̰@=g]CR)aIsPpt6`@v=V1Kniog "Da&Ji:x`uEp8M >ؔ+@:{%[rəܞ ƫDPoVˆy;ا7ƅS sYZ3}~7NbM{)+ I]DMd+fAL-%M4hv-`MOɾj61_WkM #x׮J3S0E'ig26FDv/>m$5iu,4gfg3{%yWl n-U{wՎQL?A[^8X3dm}|6eTUSf%Rl-C%4Wh߁$-ؖ2EPqBon-;fTci1V䗁H`4.$|9.A;(3gSk,U‘ot-I+uCmPaҼݙ&@{M1f.& + [TYVӋ PB4@=mg0]Rg'A6zp*gE!xSf4RAD@#'n9IX:w/4I4e.%3|0lMnFxm|tGPa0 i|H5x:P:kA.0v2,oo_>>JI"c! yΣբ"ė[[h'4{^~ǵ?ǸC $)ShkW"?ޟ30z4~ H!Nv+vobeSG:Z.g'dHĎ[7xg:K+֟O%HEkA_4gn}\#+ Jruӎ-^|NO۳;WM)IH *kLaMD~@ rJ_2);t8`qmD\T'GdV@2eha2ݴ.ӫWM: w-4wڼU Ut-ƦnYZk;]8. <Fg] BZ.>o?gUcB ^ 4Q b١0Ӽ(ղ܁17#ӳ\*,>0%HJ!dP^^mD<&2λ%# iFXjPbP9\"<ҍ̮3k?̰%^=x.䚦pX3P;2`G~2ݼjd@d5GKm (oTP!Tб,}KdGo-rm9r ;Ð HjC(J2Dl&Ve2?c;`"Kf`mNz ]Hfh)sΧl~0.oe^Wѐ* bB%榖ڒqns<5Q;8gHZ( ;JY2)ɐɿ%svqfnO%qکnIU:D߻/VhF+pqtFzSQ7X˧TҺ+U8n}TX关.p4߲$b--%./ԧ,s5w$~/?(D~hL/*ʻ 1w> SK2L!G9LTPv&B[ d҆FՏl|Q\5!fޡRc O8aKj5QC=y#̈im5#a)3w0@p]K^{RΜ3a` pOGOQH\8莺ݛn&Dչ j[pW Cpy-I0T RV|b{%w(^VUT(=sGB:0*B4FΎ޼TSt+L?YSxdP=L:"蝢7֞]W!Jb(1V50H[ZQAj *2Eч 0lU,Y  4Į xtu!;piS#Phh_Hy 9 2Cxӥ!DSNbbL8v6 K\߹ttɰګ&ŒYy[Qk KCDdrw`;ǩN覲}Tzs).28s]f(<.Cs3o=cogIt]oE@:ĝDڬ;}'Sg3 |ӭqݐO$Ri0+`G{097Y7\N;i$C/rݰtrY=z4y2cQgfZX?wwj<řY֠(~;O:@H?3V7CEPC|,%`"9B̝u:rH!q M\y|דrKZU/RqܢגMF8!$<8W΄ZM C](A3ԕJy9UE?#@ޟ*Bv}c} i`޽XH_xC41Px q2Xo10-Ss'RaLܜ <LCv7h`;ڼZϮCk&=,kc)nclQ?x~|L750Cnwau)XD t4UM&|Z[ |o<7(E9),?Lee1sCe؞dɡyVeq^6ޱsOЋ.-: 4pWl7C3R 0 <+wR]U_IQ)>9k^cvwvBZ:sbebE:Z25xLmKRlD6Aܕ$U` O- Td Wf'/{(Oez_6E 2?9O[9t>*V   dU\?x=ʂ+Ն)dgZ 4p}o(elktј w?XUٳMa#Uij2k,T'Ti( }Վ:Ί+og1@<iZUbMO[PWu2l ,:q%|9Al0_,c/h śfBwzNXϤ˾BTb֧U|yNAƯnxb)W֧a)[|\T5x>=O<#+~ @HgO2 V!ڽE'`qS$)@s0 io@o0@~y~(7ˇ5 ?e!3g7pGi}eꜙl.[/iklGr8 r0| tMMeLlSFL>[Lgo81) =u5?\:]ճULO^jk)x_nW fP~d>S>|&vj @|&qW;J$6'*>Hrǐ^^u!R1o:CK?C|]`_#A'˪,8Nu)_XV;C ʎZ]Ewh2&J)eܼخRq2yY^\mItAā]* xm3&1 !/!O3x\2 Y|IS3T"٦})vr8M >t+oEo44d%8^O*YC-D]䤰18ݒY \#f^%)9n7^ME^Rʴ)4ҁUq$t>/oCul hJR)N6$ J1AQ:aR⦩jB%Vl$ @z"]BdدJ5 Ibؒj/')`Tis3O!t'ˑuoA蚣yB?P)},-O]PaF2l8YC.֮m#3m_͎ &)o?ƝdP-7/0dm |wYt)X?'b~~J.< 5SPȅ)jMP$&I)9[uw;̤,Fyl>b:f)W MK'-C6{Ri1 u-l%F]z3pmVvf [ u$>0hQܯ9'd̿v,Ly/\x\?,J~(< lZ_~aO#pw*"P<{Kkր]+DYOq1@$:6cSEW,HJNubYv` ## 1i.!QLSp7W!. z8{;U {/7ie 8xL|-[,+σ+] ^β$tʅZIte} -ǩJiR_%ZCt0'\>[S}~e_zj66swX%jHe4?nŗ6f&PsЋµe":nWH~d {e 8qN5ԸòNH!o6?MAv>3F󭎙0T㗿G!2jnStbb́x9[8 Bk$D19UFp_2E8rp $ml weI[]TrPhde#O}ԙpUф~l#Lt&q@mP5aNwۉ;?*.D7e<r.% 3b' n^{p[&%.],ZL+XHma+XD![e%'B+)u[GFfBLYy62LN{t05ޑB}2 t 9VWϐ@̱Ce=qݫ.@SÛȭi=H{9exċ/Uzٚx̬*SzWeU'l ;ӎTrl:\Be0ln7Fm>FH!wgM!]wG`ڟCѻ};%ɮY1MR4'k /Hxx={ j=نŶ*g.KRԓ}vޫ;(nm'AجSV&-$`ƌ2$N@%'O;]z 8K-"eB,ʩ'[?j3Q 亨a0Ė h;ih]UVa!ۖH8.N)1{E (|=LꚨwV.>ٵ>@vOD)'.rC/P:|>5q"#n6v9<fMNaqop\֓xhUǟ#zک|;Vq5{?Yd= BLؗa0 !F;ctpד'YD2ޒtg]KpZ;e:z]d!ѐhf"-x"1DRr<1Ykm Rl쁿cT{jcÚYqcC/-6WTH֪v8 ŴXP2qN9RLJ)5L ^md}~l4pDu:5//B'WGZ:oQiB@'&Vh>A/䦐rCOugPK(R~2n2S8g缵35yBf33]C䦃>ta1#'rײcݍt>_5gBAbIQ˄%5h4v[' 錩y`˓ f\*1Ϸx)yW{,בTuZotxM|Z+9pv}3XQ#.H@!9 b6SPQ3ͷoi,bÈ5N|Dv$b^<4['C\h7|Dk&ؽN$+k/h^rc1T¤˼Fof/u ́ tAYa:%}Nz;9P:XG-=qR b Fq*?jpV#A{#ǨwR^k;۔iA*Q m8{U]C}|2wנT'wr %kUPExdwӋr5GHĹ!b}!9@juA+gM୫~u;Â"$HguL(K1Na|طn\qLc /y.|6#4*Zʥd--PV` U, g6 t= W#;$cyYvR?كމMvIlKFTḱk(T^/z)6S ɥrllwv#UJuHtTdl󄓗i-/- nNYg_!99:YAF BDzh⨧,C`NcMl , Ȳ\Xӽ|QdtDLs5.v(3Ɉh^M՚\t˴CVۊW&V~c\1հYKeY)ή|4ξL°tVgDƭ ؄ae5 K|h2)R;@M%(+{2L L4a| H8:} Pc@Jā$hrK͙T8(.t}!q=WO4l5p}t͠8C-b$HKq΅rst]ϗEEcw/**Ǥ$-{*Cg6V 0Ү1NtqSڛyagP$QhxyW?Gj5űat@ɉ*PQa 4Uyvypv{?ԩ~tn݈S>`~nRYg8&㲦igSb7G0{ 8>',gl A(ykTgK_xxM89QDKR^5*Qm q6k+]' #tKnk pX:2;KÍ)p䌃\!^&o %zJtMP ݵy*ТL$A?ٯ^-ьG,;YMf=\Df˂[I^0 ^f:΂_G}׻{gLr!ZE/=YK92Xu:z.|BV .Ɏ7pUomLjF?E~zbVV("iFlVb͚n"fR0L+D_zCHӁf-B⃸*Ʃ ccXzPmrjڝ=B y?q&\lmiÚ {A0y9S;;R)nen ǏʸOHE\"fQmI)2DRS]H[5;G͞Ώj5Y]~RfW:*"!jhB8gp!RȬ BnUc̾V)RbԌd~RfCF &q}Vr>E2#lQ`&\*l)JaƍNнʳ-t[:ٌ9pꇗY\^{PhAv<렩{'#=/%>x}&mz_Db[w)6ߜrmې(`cʅUU8J^n˛ :lN$i C>j Cϥokn|X %[RBcֱ_ J^eB[/qo!A*ǔƆ}qfO °q^v_9iK0GL)/I.ԸUVCN%Q+a2Q8-'Z89dGqDF< ,>S֤@fk87kRm\Iq✂Q֍[HHJຩQ<1 oaDԿp~VɐhÿX Ѹ wzQ-qBmE(sS9xhT ~v/.5FY&ZY''[@N,6K~?uP1'qo*; SعeYUCi+XoY9(8Eo[ghc?$JR9fF!a\1ܘG}F*5GN3Tٖk};0iIm#~=1!(1GgiV ypU~OY3n6c;AP럊+K5_kܚsH'[|YwVj5̍okX v\N#x|LT~W⹟ Ҵ`r%3m=j%).]W-O4&|%E2V8Xzwe\Jūo9K'{NkT^` yhoETE0S9:d'8kɒ=4s)%ȡh\73O N=p4Mh S';,5"e`ξg=9P1W%/̼Nj t@ѝy' %Oٮ0"2KXL}Rt2.|Y[}ȁAu+B,B抙hVBK}y(1j8y𾕢X>5#XvMgn2UL 6wjW6Vs8lbC4痗Va͔Qdql#?)'xÊ͞5^"SK1ʃ,gqhF#T2ƐCQ~!@f6%bRzp'k%4:ć2a)6crIn.h_Xy|S`ozbvDS""dOPMpþe77F XFN6~L'{ѕO B\"jUKJf9ZMguhG.vr {n_;`Ug?||ao 'צqb?1}}/M^4{(Ug6SԮ HєPQ*o:F c#vO `HiGձ K6KDVҼU_3A֪ xqh" :jkk0a (T[ZCӬӱZ&*:e0(ݎȆ98&'6S aH3YgP%ED\aXT,L8`Kٌ 8n#\osF~.4r@\ot[qg.$8n m[ݔ7_MU՜?D%U1}M$\6`rS!"w<D ⛑Z*n#ҕoNzJ/?DQqzΏ-lu4N;CG3Ô@pg5qԼ脛(M{@1/ŏB}x˫ʣI+әzTaB΀H]EF-ˮOEprÖ'MhAy_:aadfh4GN8M+B̬U\iQSޔek"Q`~r1$+,ow0E^ͣ*{SEN'&WCIh e7;^OxU>on~DՀ^AsuVX-Wox_YE\Ftu HX6V%¬ؠZ4SZD٬x:tzP!݈Au*+-5W(EXog,ca9lcnz慊Kz1ϰ81P}^+Al%[ofSҒ#+sQ&mH`zfƵrōPoN{foF\AɳbokOCL0@#ri^W,~k IjMv|'>s3?][4N4vB *-g#WLmmY)2`-?)y197Y߆T:19Pyd-;l".ꀭC!Rx%Ao&5ߕ

"&ٞ^@' 7W [rԏ;tGԌlMJhu"oD I8aq5>|ia] 7aK0:ggk%ݺ:"NWŘldSUi07)##g6j /{vp&q2'{l/u1Ci=W@u}rop@̞V/xya̓zLp_SdXF.!D9{.8gYZPerl-APIReference-0.16/data/perlapi.5.12.0.pod.xz0000644000175000017500000012424011653441731017515 0ustar tseetsee7zXZִF!t/'[_]c?V Or;6ǎ#x=j-CTx+'jj'UрP%p 'PQ\Yl]*({3#D` QYnA֌3)m(O0lgȾV>Ix2QŏnǾ8YioaRԽwC+9!74lH(ܖXvC#"D}%l9jSԸGXjog;~3̝Ħ7&ݺMT"0M7V:s_:ĸ*5.Jn۟F:gfqis >>o+7/#Y32TUSt<^$&̱(4wgAUiͮ栚{} '؝sA`~jh~.][éLgR6xtEҽ[Kim{<,/E)"=:\Y! J2&A/FB^+ޡE/g| PE-<;($EH̰ugS`tFӻ 7aS!@BKNfv|`(zYȵeUrEzj&:DS"EQX.N0Üsq7Zmͩ}Il8Xp f .keXg+ a'4q@IH(-vFbzYf7ysUͮҴhr%mcF>' :kh.0+ ʄT$ukk?Nk$ϨW15S4v8yk:je( ^TsE;\ P&gwגӹl5WҌY\B/q͞x|Mc[8B4`*A @nY((|$#,:ohӳ6K|=F.P,'Ip)KܜjNѻW˹73c 9w8^J~$qL=1qosqx7B^r9ƹcKkZ4؛M_Ձ!جc M[aKc15ոö Z rF WOKLuBm]Ϻ'x ʍ}즒}m mFJN?*_b|"_<mݎ$#ˡ̇lZw&H@EsJ>pݿ0B^  z~#]DXoy5xn&jcqv&g|p =vګu%ӜwCl}m^MO{Ɂ5laY+gUjjRϦifY;ҥ2xZvc%xS!# zix^dhC;-Z>tvӢ#/ {M!˸pB҄S]T!:voKb 7_:S5flkU ?>*jrD'ęddas9^Sw-㉦jnXϻ-$ UL4* !;dрpe"GBwݢALu \`ß9!C+cAî[䏚'veoo")EbC cTW/0oٙX\m`Ocf\Tݑn$_2Iߡ%WU*:{Tu rUXkr ;KV͵ؓ !:hXoLJ6?$>2ySlT{Cly5իujQ {Օ{&OD+p? _`fxvr ϵ(γpٝߗpu'Zqa'3|s-lR!YMf?9mFWQhϭxBR:V=tj"0IR$&<57!Fwvo8 _LE2̔Gt$#ud9>Ϋk*$'/Ʌc,fF`qEP1Y{xz?ϬHױGEz[5RbD) ŠE@ eL_X &m.!Q y2j;Q9EY*_q8ߪ}yj r( "KBb*M5lQ E7U iDW~P:iGDڞ::}cqeEvXO\3ьgZ zB}};{]yQP v Jct=KLz2~ $#YB[8ƤO)I">.C8x|'o^3 AW*Ze3Do§skW25p1ӽ@%1BPs|7gcn"PvG~OA8.Πa":JW>HxuVőK,4C&Y9X$Yg/24i)emhb|]FXCbm+,kdt_tՖ'Jߑiq^^q)êݯ/L"WϏ$¤LPx!poJ˗hOe U 1'@U+ Wn/yb sI~RP !.EJ9ɂT|GYtl%쟿?%*bI}Nш-(3EI8sž,zK5 q:d]kdž⍥ơx^aP悋RNmi%S$wu]QI7uH%^0Imy/HLxv+a{nHDe՜3xlv1"(f]YVriWbT#G̋nOPlr)MrM_~M`kv @F?Zx LrUFǟ@º<{( 1#&-=X ҥ2_;4c\LS*3,aq?X=qA$a+М0kO<׏ > \+*÷,oNV%dow4Lr 7tb86L Åb{zw٨NWFE{c]c42S*\Td@OG,YlJ*KxP4B1ZIw K.$jٔ9·yCUGB*^ `N3\7[kys UiUFɖp*dQQFZ .Q5fBY/ᘊӑT.bOTrT021zj5?T{u7\:h^Z/yit(Aq:oø"k х[_wJa$mO%qcu|ŧiӼ)[¡wtp4W&mO9pQG u[~jL P01ٺ x)^Cijʖ9_oRk}k '*2+IEɬ&Q.J4}"8\=0in3U;H\`Ulf#J9<B$&d}?Hث΍˗Kqm %W j78x<`Ƞ nrMǼ};^9Tͦd;Ӂ5iWs6QI'mca#/DUXMI7kc} C%yٜ&'|"oH_mPߍ"rMj"]bją:{1Y[MBބF[EӋ鎤,͛.IX!Y3 &Nj,*.ZO6ˆ`B! (l]CVo晱J7_荷s+p5^ uf:t9hɵ`O ?9X$>ҁW=q- ȱG׼Y64wahdal6)W.J @DuA 2|EoW~>5L~A;2[ -nbXw&t;Up Mک_(e.& R,&6Prݟk2~&3>0v0 ,D㾝聖%:L]x=1̜+pcJF8ZJpa wӜz'̩Z-Mc ^eTT ݶ$(J{p\2vO"UpʁEߣYyO`) <-d4{TS A,bǃohy㲁Սdhꎥ I@G{!ea^^  s4s7{o3S}'.ЊLSFˈ]j~1X G<68ET6buX̔(WǟF)L#ĈydfػDi5<+]3l魟,7336@Ci 1k(jӑr^B_>U|su}I8..CaRC}%ċ'YܠKuW1}u櫃/gorl -^G"|b]HUPQsml*&jĮj:mrq(D"vgF1q'jK[`JЖzG]DH~So@۝rH:rBnǞގK(;x'܅AS?띡ए50 hf ܘ,M=~þt3dj%7|hcc$<Ne H\R`Cd-}z?#4&wum9GFW P$2)S`[,wz* OǢ*W C$py;h_Ϩ~ݹwkJ봹nuvY@_˦G_xur\M'%C@P;j"ʠ$ԻTJ% Y[}A'qT:!50vνIu6X*R>ѽc3P| kĿ?Z !.X,3o'& ZSXH&yˆ#X sTZ2o3pF.h&ld#ǖ\\|Տ Ϛ~qpr#.~gcFCq^-k3=mS󵑨~7(jB'3٨q;u#ww(ZMw6A鄕Z`abmXC:sx=&$tE,Oo=] p[PݍkMcXY|ɝj%Qsh ILcp >Jgi/^#*rnl#?W<QJoLdsWo%A^UTOv`:9G\SUnFG3bDtn-b`ϏQ{CX0N\:6]ܷ sv _9df}$ B:+<'x#:I4Vزӱʨ.kR6IpYlYk+m*kp:Y46xh@ZK}r*8 (S,MgD<jT !D&xYnVU^|*z8\'9u@Mxв`iu[΍mhjZFIXD#>{ZYÙhew$!J c*$`?޳n^d( k$7Q& L bա܎| ظ8&VcfEZ<5?t4x2>nL]_VtY$-M "%; aȐ3sV⵺ώS=.ȋ^'e{>9ݝ{8WzCND|{ tb}[U`ͯTq}c/*tÄFsC8΁h" њoN7 U^<Z_3͛x> 1A]lf?exx)G. ?z4}JJtSko dӣ,HB8-A.9/JJL,omn){;j;0&\mo`rs59KEcȘf2,0Y4:go@Efwz;TT0o6R21'쇲=#iKHw!d~z:AZNNlvW\p0o!N5JfOmŃL dzt#SQ('jxh~]I28Z&WthU L&O)#@8'F 蝌CgPey?TI8! A'w :DZŭ%zvp=wC]QZ=ާҸtp# NUpV ~%IRġApDa3k SuVyިp*z0Pt<1!fk^nԐi}&iMF̀VPi? ӯ=HNFԔ*VLR.tX*_7Yp{x;uR] ;BvoY Ƭ]!RrWZ(0ɽT`nvCl()ZiLVԘb,oWj֐OI2 bq5)Lf(=)EM%.3 0JzwB%[k>]3DH1ҟf pD:GeA3~78>B% wI y՗e%g(\m<+?A 4Kʜ-eI} W@9BxoJԟnv b!2Y&dG%sm:D=.D76U=+ ";ǏdT•-*Sao#b   ?bKp|k"7or\K4Ͳƶ{|s^yD{=ʎRtldBxHYExoԕ)jD6(V{V"=t5f s٬3EZޫynՍ .sA:fz|b.e6ֆ%ņ;>|ExC?l!;Ɨ4(1u %?K}$;8]^DQC%bf^[/ 7d` \rK a}gFՅ<\1 # TeuW9ŧCcћ…`m_i|k ~Y,+B2og -aWz6ފli~vk ^T}q$t)vܒZ(hZ/db6Ex$Af8G|V`3ב{5h\neMO @Q3ϦŹ7h^/0hY!5qgeA];!q@7 / gȜ5#̏ttQGdk*vm <ːT~x됋2DMTL 8ft5Np(?x[; #cr-ah0 &7{ZQ ? !tջügz,+w8ApȆ^+BY"'YOCE gy UOL]hL8}i),OK@B81Uņ.sevΩc\tCcX(&)}hέCmơ iRS05 9OLDNwdi0&^'MRu"5P0N\^i[`ǧRϲfQ&yg@wovsɁB;X+%ߴd만k+Zoogxb\.2N85]Ԋ?4zS=WK-AKg01ʆ\l 爫t+EN \ HS\Vc _m} 6ևm|ڢ"9Gy\~QaÆm͗$|i;nlmgjE +ޕZ\/ 4C4;>%k|#5HVF#qia}*EY1_.IJ^/H]47>&(R1A18:5*'NX-Xizę7+6b ѿEt4ceY'Ʌ( vT<;὇)Mlů ]'#0.mBlV mЮc4J+ÉHJ\,H|&qa~Z&W#inM6~9J3ʉIR~)_#ІDYϲfqɱKyЊ)X  ̓ѺːvY aH창9\jJq+ (tFQ512[=`'9y^TYn7 Eٺr UnyOHf UN+ ɴ-.j[﫸0+HZ^X} [/r Lr\xYVB{몼塷w SR^Ҥ˅;x|7+$,)KR6]b!"J/=.cт}u4&Ė<0IQ:(UUlͭQJo75Ȯp5di] gLܠR*%ȋݻAէbG$L(3 YIIdyv{ 6L?Vy{j>|\1cHl@!*s.: Uk5'nC$'M%%"2+0]̶J,Bn0"ɭZWm<[Ir*cHR),o`)^¾m jv;0NPgRgT3 H"q.!0A{G$}帖] S=NGNs*JcwQd!dD.ZʈC_7WC63 A/Gu_#@zUv_ՊÀhLc.x'"])g!٣5д'~;Gi3q}aAM1ddD!ApWUKо[OZz)L\l>ѓF ́'vW\1HŨYY'4LEb0R%,n2,lͥhԃd>m' =jq^P(BCZH\ tnccy6`c tcЗ_:HGEQQ!y')'6 %v7f:Nq *^:MqPUs?ХJK D6mJʁ`p0~+_\wA;o?4&A ^V͜ݜlxz(P!"rv$.[=nEuyNCΩlQaqJ ~,'o8w~7ТJ W$Ðv$Wu@`5̇\YA3ȇlf~OGi^M.-Rh[ B̸cs+eJB{H ySBUaVGW":'56zFOj -'Aa۳,G%_eɩrl/;IxQo+mc22c+J|_Zء]m~UE>v-EKPi'1߄+OsoU!c'̟c ae9A [:Rd%G'-*#mDG)C8 }q\LMZ3063@zen>*)GBuq6j"ǀcf}'8 ^)5MNwj\FOdxj # -5 /PAo]@lqNq^[{f+JTx5  f!Qny/r#31kGF&/A䑤=#Ϙ~1caQiGm,dl`ף{#-~y 8 ??B¦e8#xθOXMd ɶa]ŗC.uu[4 վWֺ~>ieVpukUl1܎GKoL$w3eD:1p}U7v )5ZCms 폽thQ/1"Q>!>&TϘ0ҊLV&3WQeEB dEdj{BJؿaUvo@&{ղ<W؄hW %t ONVєG\2y#F &^/X20;iM@t/r@Q;Q)嘏>@k\7I|`iOExS)K̽xN,BBʠGardb'"NaĘ!"ΤCE<(ngKN7Z,wV;{o+j))h[BD\֪j,\-J| uf=[C,hˋU!V dȇOK"й)@?|MZG38 bXL4x2,p^%yh\/=xh!UZ/9_: ͤq" UAR cb}1\)ͻ* S2WN5!W#2`>}<:T- - 6 `bET)_0 jaN=iHrv#=ik4](RdEBq#%Az-ۏ3BMG_wB"i 25meɐok[3>DkV'yRY|}MvTw+c]ux&Yȯ=գκ pF&gG 3g^&=lt]1+Ta"W.9|{?mP:4x܂4?ZucUjNţj8#)u* e}-|rR> ~B ݬ291oKDpGR+h@HMMmu[86:s|gQ#P bk]=M <sup'> Hne+_r5ܐI+e֑YR$3қ`\#mXhD^Ӱa<ϯE@Qp︢mA;dh;36ZQ\)DdF{.4lgpEVD<ٴ%+ O>5>qe[WOnÂv9e)5)H`G\k+덐 Bk:p;YIsf#YTMЙމ N I3v&x56Vn{zR%Z%oC_Ui'˽R3~3hdd>9W5U,р;u{ˣ=BjJPnIUW:GdXp2m@Ň&Yb39' `wSWILfsT9Yu\7HdGݨ7P{K.MN&A@ H0`8kuҪٓ$qׇFko29l˕S{ Vd%}{wLhf=1k^OOS 6=_5)b| T'Eڗ"rM_=:oBk_oMdj(VNlӻNzeI- ڏ`unJ+015NGe#Nzw+PPZDٓTZBOE Gi4':Y-QaBaLǠ8 6u.0W{KnrVvљUf bZ[4cgED9/wgK'N2<Ww:B6CM>cYe0dܦR: P7cm ʲ7%20m q@Rw}F-LKľq"u}.q&VaAraW" YрFhe'&A%kD@"$ʑM.’x]a3Pg_" /O%k{AƊ_kL1nm|m =qK$QK{ Bݚ ZMP 1a+djٗ4*.J)~ g?A:iSjMyZwO&(s ;¤U؃ZˌX3+ZЇ*ڒPHБ,, ^Azz')ZNXPaY#S@=૽wKfl訴/lҁ08o霪hLKfDӉu2I#vlĩs-n)"5qS@y>.jrǯaSbir5Tz_/4vQ bQ†[NCtts%Ehl{⠪ul3V%I} έG8G:͔,03rGW~7Q(d;Hh6HRtԂތSB\4%gCU–l0]ԏBjT&ԇ`nDN 522U0BqX¤\Ɩ~Q~}8!'z,nL~d1bZ(N\|N"+n]`yj$ +;KZIx6I[EnBoqշ'hwiBw2ʻ@aJ#0RUpə/?p*nZ:^USx̒22^V5FE;26h7hMHlsj} _w(2,Q%"VcW+A$6ܓvZ}"\ښtr̿( LI5nb6jI]799ܿxK= M4-K-}pg:t:N FWCKMbo?qIH鍵\.@:U{WB3AMs6RɎkרÍ/0`:m_y8^JG:(.'ð*|VYߔ`߂-P;ֵrҦ {khOjȤx7FE? 3EWޮ4d JGJ @">Q$nߔvrūMR)`"7~id*:NBCmNyL3%WLG;C<ږ;9n'^7co.>S-d@ Aqx[A["u?2 ?̞"yߑNTxF\F)&ц+Ttu:{)shy|qKrWWubM"C{0.f8wGxNΝecy>LWtu׃B0 Pd i >)Ԅ_9U|}*?Xe$͞yW\ Rܐo 3soEׄtȑZ˦k~+j=4#+C>m,!KgVM~:krS5~3IJ3д6ѝ(Hbo`֍E4Í"cZw4xuiov0#$>C6_y)Hdf`.RL/눑]a8Z fMS-Lː Tlv(;MyF3ღFdT2be jY4Mlq: ?k܆K1Zl vM75@贩%ERi%=/_qyz].ϷKF}ǿTY`Y boJO3up (p*5J?FކH-'33mVvV.!|H72F0 LUm3˕R8"kd G2 z~d{^(w8|eZN_:Ijp?6:5T4r#*TU\*D[pcyT< `??΃G&>}c@O;eSDnl5d;EhkWb';HE67k%|&ήRQc 8iTn}*k~ⴵ1J+dO^DPZղ,-Q=qcxi5ᰉ{7  c^u5BZ$ ]`xOz5E{k[TD+MTn ~~h `. 64f {|kKkD5u֒ceKo*'@V OAd鰟dt6s8$)B=crS1 )=jYಎ70ȈNy(?"5ȥ?6#6Ck =nZVe?5?ʗm(G)dEچ! $K/S D^:5G;b`ri:QO#t3UW9w,J^,aݵ3PQezymkiX%c0v' 3Bt5<۸vMPcM,nt]iNQX v6.}ǺO̊p tON! g!TFK&ve~lh#Wnʂ9Ociһj %Mû 0ա.xo>Pz1NJ1P'jZYb/ {Z%VZ EV .0횓1v5m֮%59]$ji3^Om{!*${Qui=ʳ[;@YԭHDP?p#08So$%9%g ITnTy [eb[ϸ_sHfӄ#ʐBd䚲 :,M>:9 TzYRjj>lg,bo\N ޴'mFF#ƅGBdр{)E{uRGW,}#S:lWܖ@͛D.G>\Y/̉sPY!_ 3Ҥu4bo (;ًU6JFN8G}b6+(!G i\Eh;Xl*D2Ь2#wPLue]8nָ@a,lF:;Yr%20[-_jS"-kf?htk_h.<M-4ycR-ao+1+7w&R04V'RW5ҫyzQBIM2HP(MVSW r߉HBN.I&+hQKh=UW>ʅ^]MB,SS.z 3nyx 'BJfgEnDc** wj>79-ˌxwο4\sw'5J/nΓE(Lq/_*wF mlWC#mADlgg8 #3&O^w1Y4n@"J2X!m﫷yqOszFJ>TGjj1 lNor+j ?T.}lqzIV \fg;irܭϛӞGۗ4yޑh#FԎ5gO3*XP^:g83 ZV4[V{8պ68fxd̊$[k=;Fe_(^?ȗ(hy) ]䏁 hb qثWk;ب nFe?aDU:.eҜwJFӎ4 򵡶qb_ApJP5HV!U&N[T:ZUǬ8̀7ݿ;B<1MFȲ -~[;1) ~ܽwJL|DN?6NrvIA_6Hl.K-^Ai]ucɅ.7s9b1N|?': E@Xfa}zɣ_rנ+NZ3X9SveCG:JKJN_,^sZ3X@M1#IѨH؀/)[ ϙa["b `DB kA.EXu>&\9ڂ5$8Px2wC5G} ӢTЂfu+$3.3em'[]޽Ǻ]eB\jD;$49`bqP5cswVe#`EUd5eiBbxW^KW#A oŰFT")aİyg`)>Jg `N e˵Xӷq]E8q)zBj4U{0J_-{.Cɽy]M!]KXIq3.м9J-!Ny+8V/Ȅ"[WyN$8DA-r5{ŘёdeCu'_iu0OZ]8Xj!l^ ?lHFi#Ɏwn 8ss@/ul HN-Z/wYCelzs)lTRmY˲* }sT^N$Aga2W_\6h:UADt4#nOY4|鈩SdqҥGGzqE1_i7 6|Fb<ф^UE R³[В6r}btɳsKۂWF WcF#rKll$~=x=[S? y : ٚ)] /y$N+RHneنvzSP5a5mTr_߅_Z7^ȝp7z| @M{(rW%t^"cg𣼷~XIuPU lÐH+(&;3UՍT^(TE@sM~Sl ½s6d8J hhBsgl.GJ} 7O΀-+֒Q4tp".DOsـ~b$x6Gf?BB}hq\]~cۿN-{4|ϐ8sϋ3JCM6x߻Ƅl090FU|/`O41ŭGeV<.]j:fRMCVeJ T{gZ"8Y Cm먒0hS4=i\pW:ձ*X༑7εY#Z5#-s?o X!BMnZנ2-1~v>pذЖsp;DB˳e}PJT<̤0?}N\v7@Hֆ웽Ν[d)V_0Hu؁B?pDG\i&&T8v3-x [xSGNl6S-qQ>jm8C#GWvͲCv*ډov: 嚈TeLA 1 FxoRz)$a8CE6݄A!"49  4ޝj#r?W)ٙøe\ܬRo%U$ok[pڦh(o&r7 i ]^Kw2( "3TYTF7a9h[ZLb L_51jԣ0H._Ia,G?W(~p{mv %w8UTqƻs ]'o|pjn^VWl\RKcv݊:k-Pr|հT=^bD$DLVg=%=0A=4 [N迺'3clΡ*5IC5zXa*5ˣ,!n0'F JXt:9@i~;̘D큰2l\6ҥ(:!E#`BdTT8 4j eQ˅cfIO݂މùd1ѠmG¸P'Eq}U$HI1RN 幗hkzofJcp0Od:D6N ȄשEUM?b-7}z ˴ad- iᣥؓ l/I.fh}SyQ0E ZCeQ~̾R=a]W>-weN:UQߖf>턤0 3-yL,]16#Qy em' ,jbRQ;IKnykJ?q!X/xg=X>4:PMjn1*z>ճth0ZArG94)Q1jХ,/gEJ~VY϶qqJZ!|Fg{GЉ/|!O '26)]H ك)~Ȼ(_űEeBG+m"ESm~;&~-@ֹZK,_mfI[n8s誁]Q{HJ5GA7tx";+|mb]);# #Y,Ta!˨HaRry7IU%:Ľè@ |C|?2t!segf}}. Dl2-ջ-PK /rNh+qIC? JiɄM:КVKEX>}62N*ک6e).dgT`? Cw}@CoKs E^E4 "lg}Q>lr x8&Xn0q"!x[5Z<FnTb}_o,"o3CnZ̻bZ/jǔU=nJXb?x/T?C ڴaQ=#DWr;WBZ=f\Ҋǥ3AFa~nV~|>!KTY6Ş.#g)팬Xll9}d9l 8y ɥuikwۺx tO,ˉhzⰠl9?>|yYz2/ BBk- FkvңHw* ';O]sXSfFS&0|b%Aqqy`[ ^[ iAC'i,hy|&ntY'B(qH&}|^{s`R^>v|r~dy,.cAhJL}cCr/?ݻ!_-Ցt09[=Tccl9u TRŞő&{̅s-%q>ˬڙ{s|NQ:}gǠo@.|@lI!c fɿ9Bډ)I껋W#4:zv#0KO-h XE8ޜu'S3 *ŕ+7'E6뎒)F\S/7j\ z-Msv+g@*Za.A8hېH aZ/9'Z+E#R41ZxӵF U۾~̕#\.fO.ٱ{bҧAIJs5N T&U|sᅝ6X< *5>|cTX[g5#Hzkj@UILY2-@d-p9M2Xj.dgi ڇHkHE,ވ['|wœFSz)VƏ-TO sb9bšx^Uĕ߸j@ v~fu՚1Ǧ4St*`ڔ6{He")?6 ̔9ˆZQ_|sE @-mRf`+TwclGmk)!ޓ)pwZGT̬*;Y,Cvp[۱(LKT$sBt y)Tv64elr#6WËøjl޽V=b3EC|֟`j9EXLCph[Y2@-ٌE**y+h['cH_h/Hܿdȿ{µܰ@Gzxc4yj(_KE{cvrPm+^iLB[Uk\#bLG1P;z++*Հo[$yK!\/-7y]N!jqQ#g ,ƢRZҡ1z5U;S[0 cS@Q:2S=Ul7g_!5 5 ҌS_DMt oԧh-N- ƗAyl q7"-Wn??&bAID[} z gRBFVjOHk$5'͈Rg~w>$0w ]78h&e渒Fx FOթQ'agҶuRS;@"q}v{߇##o5gp`Ek [WөVXyHBI`/FcNv)o i4WYr'f41,E `uW7:$x꾤ܭm0*~o`t#kG9o2P !dcAgɘ2vSι+j<ߖk3 gSQ(\zH:i3Cl6wȚmFg5,2wb2J}vsu|WU;Bk+/嵯Yb1F!-n{  sn g~+ƺ0?إҭZ'rIKH:A0pC -q?qVHd<4RNj.=D}0.lض C55a+?GU쯡G̐;_HU[6l|ާ=?U%HyoCh~! $ 4}GQ+j(]HWfٽX =3E?C^!,;^kN㙁Q=Oଝ0=!0,bR4)ɍ$[ P/Nv;{IQ̛t3hJ|T6N-=d'XCe7 0qmXÝπ﹦S>|L-+U3, Lv!ssoI*4F-! QLnɾ ,eUXhY|קO/Z\aejlcHUTg MCϭ#'/-!6l6mXMƱUqCfBYefI:O2G|4NwŊ +X8ɻ_/~Müt0BAȤlЖggQ{[?:xhO4xXcWv#R%BI&\vdǜV>>g$-z~sK{T,ٗ ׾ @"_>(WMW)slepD?NR@4T||,r(g0kVFEdNIZ{7tS{!J7Nn yx$ պ!Pv ,P޵:tRw5WN 'ׇ&̀e~+pD`PZ~a$~6Y ^ Rl izdkcuzK %th dE͊ qq=ybQ差꾭?rm ^lDS<_~Bkj*&L wq}ߡֻcޏiQ >3?͋ m)@GW6JO2vZue:-%""->?tyڭwUi1B.TPrQ&ok#v74o0W[H0d<*">*jQ?,`f4n~ U\K/ۜhclG ~fu SNGG%NǢzmHp)k&و%*7I͝sK{ʪ[1]i/y3䢗 O[I'V␅)Bۓxoɩ )POUYoz#驭4TVWo: <yLg3Nx>˩ͬ@RVs@!eOU)z.8^ʄ4쇉#yi`@{yLќ֏c<P|^;o K7e(w7!J|:yf(b@{l;E:VڒwB* rzq/1@CmQ󜁃!{{GDE탊Y+Kl|;0@`,O IVW[FBĦ@_2FR 2sݖ1hZ@.\ͳY8gMx1 #y0:hu|p6AweT̤9,+} yVQ~œ:qiM!R9T *m7OEk ^D+JB֓%q-pL8{fXF'>=2{j'>O>؝i 3XYɕ3`ZnC% GN߮V ŧ^ Fy'nP]E[F!iCy0Z@ĵݥ0VXX g\=5W=bny<"OƔM ~_j+[5^ |&!gD;.Ne6F'~v]n(wl$M)Ri;υ̯/M#@H#zOu-W"1'Vku dz JٵƞmVX pCNs9cU"6JD-h{2źy1.Qμڤ:t49;hβ3 XZ@V<)Jtet7(ƥOsZrp& oR4%Ӹ@d+/Op m.C2 zq3fóFRVu!.wLђ}~0-FXǪݒX3OH8Y $g mqIr9Eh:lHp]܍>qns:\;x~hA-Hi]G;ĽUlOH=CH6]D\D;c\S4'Ci}#P"$596 ޓzI|881%*B#VɱTP;NAsʌRvm4F[XߺHGXvd +酔cj~5k}cLA廓艉 TZ9-zB'dgAil=c\>zαpx zH?W-b'Gr[h!j[KFxDl~ߗ,Qs;,yf.my@zOO.Oˢ hK4' wܝٞMt㰎wP=U=4Uex# B7k`iúaѻ}pcDb Ibw|.e'>"wGfi$L+Gyk8ZG?D v }|? wqKUZqs*HG}]O/ԺKbix?/0F鲟QpU3m2+ȔDtA]66ٺz˰/;+sI zXJ,` ګ$nyGNuPb!_6{rVBTXq{a nqzqO"w'Bj2 K<1G\!1]mvOi~A"93O+>!KKe:dHkF/HBɝXёCђWtaYy췇vˏ=AH*Pp?>YHt?NX5Uԣ4P훓4Oϳ 0Os'x kוWRy/U?N=0:]we6Hg~jog6 ` c {bAʜnDc<`~L[ ?7,gA$GFu~ (θ GaC'~t2OFlE) ҤR67Ԝ l$HT?ԫPH/s]y?~d-Z)A ;;BO} /ƫ=C_E! p$N d3gD}396u=Y^S0qRr9+nց%E-0S/^#~V!SJ *Z=1M..a?)~6L7!3Llfj^vCj*ȓͺ:c~|{gW;V1x*2wmaJ<ns Hכ|60Z+h{5}^J]8¹O.Fy[Pj^7VDŽGOc" ]] L_nWqztK?\*C%6dYqu&|P-!=- \0aOF7}K_!4puq:^J9L_ GYk(`S!rB>r*lі74].F(9wvT]/ К6S>.UDvA`Ya#b-2gi bږ~cm;ftm1 鬻ʀ!P&LV L"(\t p2h8v4{nMTߧy֯,i%Ms@_v'M?PB׊{A;[JkkDz*$zJ({gk ZW}tm+TAċ:#)#ڲurN[z*P*xXĞ7ugD(F,:S76`LsM6UV+Ee8*VF;= Yh#7|3lw$i3pu2⓲^g?>3x8s;5`6uH$ 穫!xYNk. qp#$t3T;͑\_qY*i/@7`%*{q81EZEdQw*Z |Bj:lOW q Gny$;-<\apW~kptFL@G^'h8ǪV@yFr6 VPF/M?Ӹ!Ze-P&aJ`V 볲Ƨl>:17;RUŶ^幎"\e13M=X"`Q;gc>fINSAAV (t豏**nR ,eԑBc3mTZё19M&ks׷ZG^ijdO7v-{ިo]L"IbAZ*]#k*LJM彅ZWqC4pn]2aĖE5g?蟗=k`X̎`1"a p"`U^xǽJO Cicӟ4-!;10|:=a vY$:TXd9vA<6@/|SK|t7ި7z?+B:g1(Sbe`czϺ&s "텸]A0BjkeLvNd'1V (Mѐ`䩊>4uZO^wf=݀6c_QL#򺷍cYfigᱽ}:qȌ4 ȸp"6?>4pe6%%pACL  f_eTGC 'FPTBm>QnRLsB$ 7v۠ow}743nN 0p)c< 9^؋I&>u-+ΒYkjiwծL*˼5dv{3|J뛇/TGfVȆ#ׂčr z1yaeVÜV[„ry˕<؊+|1&?DP4&R 73ψ0KƐwg!T"E|e^O"FFˉJpևBck?{ ];G|yִx|/&k-n{Ekʿl׻r&?IC9`R~'Z=^d\io^IƗk pX9`\: 9^{,;f+i|u6muۈilq?ϛiE?ԹyNS?/K.bU8<{u󌥅T }ؓ\z+oF$q2>@M3_ZE 7Un@}sIo[ESoKBP#0xml%Nl@K..@n 8B6L\:Ik%E A3XPr(Ezź7}K.0 CJ@RF5_IK-`51A䄐s7L7>jTHg ,`<Qэnɟzuۥ,ʖlB;F"m*"ZPFblrx ,=m>[id8ô<=%侖G"ň&A$Rͩ@(kTE%{#k[\E)w;eam7G(~r 奻0mR$?r͡svsEXTrp"{^*.zEˠ)_s2<@B\](J%? Е4QPYFV+`Ξ"CV¦=/5+>taJSAh>eOn̜Uٜ0ydTA")xr(QFgy`URL0'N9">}2\{YGyNo,59N.^c gei4ks.t6EК83f}ލތqGKpLIQSHڃN{Z@qv_jסVTs9LE%AV"!tQg8h$2?&]*j? BBrHci0xPf/*NІ$([X 9 |NPM&Q&Lз:m"=ʪJAӈ.sg{p?Tr$_zp.h}*A.Fb(r%_:e1H`YɅ }>YZ!駱ꥭ>Q$~{G.0bJZcWoR?4,WC(h"MI3S`{RkmǶڕ@A u3X$4+ݾ $ړ0]\U MU Osd8> dkoϷ\)MpXbm_$%h\c۪MC8N)ė Zj#T 9=y` :>֐Keev=eV9L,_#[*D3r `*ſ?<*Sр+pʊ>Eb29sN4+U=i8KhJC= +5ռ c%fgD0b|VZ6je  pLT1}2z.F|y U9xY}_h)|/??$FǟF)9pʁZix]T{zT{%!mD7GBy=XLqt?EG6XA ,%DSШ"e,E~sү(N vXSZ fR)$wh(Aw4Ɩ› #ƆU#,^2Fc IMJ"z=d!tya?s,$̗sbyL@}̳BÇkkmO[ֽ IY5~D<)g_'b IMXvʔ )u,{[u{*E]7ܞuFGsu> B!)O$Zi:l[$r5$|h,j3Qȼ()fIxƚШfEilP;NK?,B@Cl7{rzEҗ],KNsŋ_0k˘cv+O| -R:6eS&gFMnÍ_9rbSB#/@Ъ7yE ϫ7|ƟfW0q}kLh*!22KbQ4ѽȐh a@.H}9"ag"7}y_14iVr%},\v&P:kɁUpᄭ綱O!Avqq_AerrhhYZSHX]^)m}rưۦ4 Sd8&_)]KռksEirJVxD'6D\kX5e\IѬH"@(KU6"OTucnI#(Q9}үb b:oT&8L*sl5R֓Y6ch䊮>"]@ F,7D`gJmPMۃBd-P('"Ӣj#LZf2_$ILY"u{  jGgYZPerl-APIReference-0.16/data/perlapi.5.8.3.pod.xz0000644000175000017500000006207411653441731017453 0ustar tseetsee7zXZִF!t/[c]$P cǷ=[o^ɲh%*Q}Ԋ Y.Ʈ{P]jq>9xtU_&Wi-͟ϽbW`?|M4~۱Wh%̴vHyc[$Gj{9lXko1A>=0ma0 vj%⿌qA`&nHqԢ8Pȃp#FVHf+8TU@堵ˎUv wzmE:L .:s* HCWvTan,5őُI%2WZY qz?)^4G";ot!hcy8@#]5wVMz.S[Z]8oBI3:*t$(&J"Ji%%N~}-y Pn7^< 23byKοqbM */͎:M;H*:4ӊ8͜˨¬@)H/z`$lUgX-֎A2KE೭f0/^ dxbq%hM',f W U!ZlouEMg5X h5&ؼ^sm/S>C#s8^p3$ED ?P+bXa+104K;Wݭ4rc5QiVMp z6(aV>ϓgfϷՁn5,ߴ[?K0 ȗ,Ɏf1ϬdmkʝDފ_P[9X~sda0"X{0׈]OD@*",r DIĭe+ !%9Y:O*M?;o5-II[Xk=uun.4c6UoizWBm SRI>=B$X`؃X?Ƕ,<$ɴHsY .)22@Mž/m 7dT\I*b$r'.rXG])n +3Id5i'.m]ĨSJϲmƲqM{1„oBqi_r|= C tѯwF (5)o-[' [Xj3_z߾"Z֏O-ҝ(a^hbHm`"<]WO!)d7;Cg!BKȌVxZ֢@\TL #$_/c-Fl|!BTS@4Ggx#Vpڛ49UjWzdXkEFxzi&F,0ze.{i;N=n{]2RN}h@sk=MowCߪrð9 M# =,̤Kpc0]^Xk|<E_^Ee l)(olcZ ꦏ&b3x+c(.50jYߝnL|4\+84~/&OtߛS O$7 ]T3%WY Q:IT}RM6- 9Qٸ?;Hiʂ"N$T $ ̞iX"6mAi\o/ǽe}0Kñx kHz2=6pC[?7X&w,WR%X+=~W&ߩ}`|jo%8: cqbRRwe5Ȧ*<8ĝF\`^IDsYǴ527%xZ?^%}ou2߶ 6L\ Xq]YoM6_Iۨ FQ/ 8Y$ pez$kFgE"^3#J ̷LXyA]{co5&a$7z37vUi#Q?> Hq,7oN@ Mv5d5<,'# _בR%ojݦ.E?N\&z+(hOV ܷvH \ۋD 1%mA>jGh;l|w!QKV>j"Sp$ǿI5:6n?ڤH`^.0DXֆj>r3 b@b.\*0DsY1 c\FnyfMĞw밚g4E }oz9-1ٙؓIX`gsOҰR<&3I&v/YU=N}5c1x\zIu L՞q+(8CXe^z|6 >ȼ1IlDgkCay][|O:1Cn6eYޯk)%T"u:>޾cnf:|6 >ԃ7ӿka*9J ʗhPHc9Xx#.HGD91} G8c&E#n% !Zh|AIja7[6 E 6>-pG&(BŀQ:R}wLjdt՞(F+:;-mPs PBĸ}&5tw ]rfMBfjAt"Jⱟ[A¤ CrE`xamiRE9*.A_cZuwWl*CP1>$ðCBOe|Ʌ&3P>T־;v  kTmpFN0=ܽ^u &h3bpgi VC":[*^fWߣ4b i7ָ70 JT" kd_6e4) H^o+A-wYP4T B<nϕ^4{,xQYpFx =RrhP{Z4r'`{bB|Zx U٦RCh3.lW/W˜*jc"𺁱i-fێ= 9CKQŭpئW/?j%Z84+`eF`ITϖWI+S4:~Jn>y_? Ru1vlu;{nc|3Ed% V2jǷz}\/c#K5<" EKf1煢(9N&ulvntVc ƺ ʃ^v`Qs(&þ4u }R{ ⏞4*p.qJʗuxkH> Yp҃w.gz1k:V$ _nEj9/5Jj*fO2Ȫݾأx$V q vZ$`R} s[Ů?O (n@SŦ LhSGmJP"w܅ N(؁){Mpߺܙ5@P / j+I|` ^lco>1~nTgBV1|Z󪁯B,y©tFeA|rBN۰E_pZn;Ґ;E#|U,b!yQ騜;UtZBhѰxtl҄$u!t d?f/ES6J.Uv g5QҼmb^jG+nEez)U@KiT@<^:V\L+;Qh0shB&bݎK}'9\Duv Oӽ WEFY\{&6fd Oz̪ҥ<1+V+'5`hJLSf9,G)ΓX!a@x5A2DbQU%r d|G0(5w5JMu ӫdk’ByHW`e!a6.?qjT l(k&}khnR7gpg#9#&r߀+zd`fC)un(l\SGԋ)}\l%\,Mg ȘFZ`Τc8P5BYa|Y B<%s*ʶ6S@Q:Iw^.iH5fGUM} B뵚\ + BwDGfw^@y$|<%󃁌qЙ@yǍZg<Ф--z倳36F|}g#)yS-%M̕D$<5ش"u].&&AQ1Ά ORh9Y3 m덨wmD|  +vv¬>,Km\۴N 8d\!(i*ppʕ-$*LBHW 0Hhڇ!Rwr&4/`s<þ=BW@%\Z$ڱԖ .]M -'BayO?lʩ(,q" x#L GfTQMxziC_ _|6d.ƤV_+1vDʍg?r|j R5L{*MKNp2[ @aZTBkPVZy@TF\BUHйbSbJBR&uғ4:fL)M f?A"JA-2aNl '<" Lfn-vO- Y4_>nZ}Ma! mcBQń8"xаͭ գ뫇~bB :As5JE<L]#Ɖy]ƌ;BMWҩڍEWnNM@~ dL qשWaDhK>".ҙA@|rbw/7mjRoAX#A')j,X `H*, 5ʮ'`5^J pNYXǐOܺ>9ߟ?U6r’=Ley}&(pHI;J nq3re:Ҝ'b1iI]1ɆrX2$` ]Ku󻄁&e8粛쯿u o4Sin܏»Ys1(IY^[GRbyaOܶ.{AԻqT: G#Ȇ ֒!m9*e5VLq뤻F76Xgb,/\b0z1YtwٴjH[e(Ϸ]& K]7SLGCV;x¾8%V7^ܖ\B].; })*ע<8(srsD>\Pgui kyC햭Ph  Ţ[YN(49VD(8V} ck3qiݱԅ,_#i"&/~LD;wƫLc똏; Xw|_o2$9Z47i)7H(hQj39h7}d@rQB0Tgt(£f;tm=Cz-S¼ëb6QWRriMRX[n$"uz,IrmhvOBMAqE9kFL*N?=9*;LpWdu9|,n"!:*G?4Q!P7H7Nq!Kt|Az*6;mD )E.Yaj3 T1WrD{a952%u+=]F8oExmZ@޴u$;)R'뒾*ԫ{]"K -О30M93gT-q.0-ٮeY ~f1.&~Rvdz ts7Ã-)N GIOPȝA3 ς$og|u|14@RނG+Έތ8=NakW+Qb)vNUy򒏧׸% *xxqag rLT8! MU׹TM=q`(E"& piCl/hEB89FhsA (97yLJ>0*%[ 9ƴ d bYin 29pډ)Lk.jSH հim{gn|gC&BetJާyׅyr#!b:-ݖnc=0#ZQ_ߡ nѿa&^z6FK†qwҁ$<2=)ݻUK;iBAj\(>dӬ/lG4[:Fh:nHu iG Lm2PӂOB6Vgq~jI),qL7\,mgkD[FԚ{ ?J{f 4=29k3&XLVh7ޟV,aQgI|+gS[;rC>8`JGcf[ٍٺST($=?_ as% b{~߄30[޸[w^m^ p(ovBNXPʵՓOEzwۗaҫ<[+`rs-B 6xZOLNQ땽q,f+"άx!﷒v=u/ɸeo0+ttY#Xա"+q.hPׂka^;Ch^FYGb_։ =9 =m~ 9Cd4Rm$`ĝmɁs+@-k (mͺ k&My5yطh G6EܶIN~ʢ溄tϚGUЬj;­/M8z] 7,-G5lj3Q//7("`"$]5PW -zkqͥ |ҟ7k E1b_$ݿ4L B88#" A(xo7P]+G066u>~g3ILMF9m>O?@ 9h3g$u(i:`S:7BC`[f c60)ak}%~i:t8GBa9a>X|8) imfa21B[]F-%xf(2r/T k䠪.KaDm톒+Yk$I%"}ES SYNR@J^ Ztw t2cɳ;4 sDPH{N84f Mn5.`LJFU?|Sh'+ʗ;Xo9 H[lb|bsܬhJzm< TXN&}偺spɖM\܏'Tepn(SPxdiՋ!jn@TRk1$q,~u8gҐh8`Qޒ%e1d9/K;}-S(@Ahtm]YgX*d|-0- \RC7uc33K|+$OPhT_$MDѱ 'b~c.MsCs(s(-]CZ$UT@i{VrCsU\K m6acJ69J=@xq}KȺ9b&Gj:S93*G24 q(Ul-Ĵ0a)6$ȈSbf(!ʺD 9kUDI>w< (8l: a=fOvːTĻsܐX`$βCSiq,Ig~#F~Gq6IX7WiNvwCaRXd|'=Q W4%oڷ Yˌflr_^wCAyVС($ӯ#cV 9HاM)%!ywdJ\ΧJ4LCe2Emp&i/*7c çuWCfȖPocp,+zְtሆ<(25-/86Е/ė?,u<#o櫊G=U[n,C}Ņ2zL4J0S׹'q trIdXօu*rIg< Q<2\.7GP9Ԙ2"EvO~0Y(cml~G:h7vue ]yg\>N+ť&!2cbN(T+)Ir}2%l>>ʰO#"ˣ#NUvNsҜe"Oz#;藍—W,)qs ?a-l},|.D7P- !Z/8)_>i: PLMf[h(ZB: Lp #}7m,[W7WNlRTڕֱԾ=`gY"?-I e"iLߦKD?sugzEjReR䶥Vݞj[B@,Қd`JV hdDJ29at21F`. 3)~3 S`h^ǻ&1H~O)fٶ\ QknԛjL2lk̪Fg1*lX#݁hVP K+s7&BZ~f sƢQUiC9}OJ~=/'FBVDQǪ!ToG2LH^)Oӧ6W+w|iǸzAFFc%= ¥8GE mOu WϋlV)TC'Ko<[nqG1F[N$:1$y#^ uS/@<ػtVe$$3nU9 ~Y^8v!s߽ZHl#mBԻcy?K%D=3U7b,*P{&FCd93N `3(KP!R迣e>Eo͒rXɘ.LX Jc Vy:y#7ِsY%D品*3wpo֑A 0f}5;S LC14c r2%4F ݆Pi734SB\si D[OrS-+d>z빾j{Mibo[Q,tuԜp'M-T]V,% !+UmK1 %׊ FAL쬨'; >u} |{IMwLT$$qqU5[P|IJu\7#y`Bl,:$>v'inEuJgĘ/Z#VyPWϐTdЄS$q1G9;;Y5 2'ė _NZg!NwuTNŻUXU*<&v!( 7#)ӄD}`%H!^UuM!lD['Bx4LcYSl6(t`Wۢ)tnkKaqE0W86e9=y4[;qf룧M'| >ѕ^IWr84[M/ا4h@?XO*jml/ !`E=<8L<(4iSl0 c8$,AY*$do4)ނtL:hm5c9r@|<}e ]I']pb\]=Uq<|,ar:V3,Bm\ -6ߤ{S 6QW뙃YBяH:_r߽Zz%B5`^ꁩ$}j? ʄF Edopofyy qʕD݉iÎ>c2:1h I$~tQ߱^%Z}|B0-Ҵ儓եB-͆L?|5_@ꚓGپEGRG:pR`sb(>{ MCY }S] hȳ4|O\^`uFzꏉЫgbI<ԫG8chBy56Eo ]ґCF,^x@2 |d1ʄ4q u+bAM9hMbz>TO'fqHx+#<WLBSt֔}|(Q4ߘS_51[0<Ռ*ɻظ_B)UBɐVـ( AnU)eU7p d1<@́cY{AJuϓvmBgo.4J37J*'=;Qh7K8D]~BK#͝[}r7 <@ 2/wĦPM;[9 R ߍ-̀e%e8|v9P7~>$; zf!>RUD~*al#tƲјӖ| ?Xk 542Nc3*Vf!9ە23,X.`$U7 8$x՝!z[R?384)+*JVzG_87Wi(K(|2}ts,Bz$GbD *=zfKHOԃ\;IɻYϐLšJ\;ŒT g*}3EM@`~ DXϤ@ZR?kFOqD}`p+0*'oiH/dwM^2QtAyzљI6ʮe]~2aDbbzBn4!,}X~jȐm2x0o%`Pa< .'W hQWr]sIԭp ]mwFPVYMJ0RTQ>v.-h#Z!Rҳ_(_[dAI ,J8jbnԕӬfGDht7A܂Jë$vo74rw_Æi.#uȗI0ȥb;,_}I,~`[)QSV^߼BC"}ޟ1>ќXDQy=壼bIe<j8s~`U@1E ,q~MwRa=}#cNYF,H.q m 0V)ӳQ;e\ϔA&fGd[~7ĢLy CשU̝)0 FϾ +#SO(݊@O;#Msx*2TV29 78$hUC!u`~. η*/)WKn£| ZSbk#2W܄ΐ+<^L[I8(v)+о˞?c-]cUwbn$S=s5|]a~;ֱ<0}Ho O=6 89򨁛K bȉV !P l5PӾk{V_Sܹq#ER@V9oi( >vjMPkS.xj^=qD3_䀘2l8A(e*Zi NC٫Vq}ۋKtXFƃq@?3Վ̓׶)\?1/a/XivN~+8kV2~`Q/|DA VhL~]jHz@+P16n@Wљ֍5 7p yLLq>'q͌,L㶄ԭv8 R}u%.Q؂Vm74Vp4 `^1AzAf>ʺiv]τ ВVӋZ~('VN"M5W\蹦6[\|ȓZ5hM=a;e;4Fp)*/,f7bL%n` W#vtދWN)D h)y`+8;舎ЄW!@ g:?|u \Gim)%-4W>Ӄz!-ި+TQak3\ @r+~d t#2h-K@͈jGrO><̬b7.i+㭓H$7D2hurn.6|>;Y)ROD5)~9Dd@jP iӶ#`ݾ!xw)+1ps 1|P`OHw!7|cHj& @o3cf8}{=jJ% f#Lh^6Xx5n{K"Y0G?WqIvC\=ZYT- &sL| }皰y/,Op@168[ 5eu|;.m' {JVrMBAU3ħaa P X/ DJs$!QdsP}Ԉx"0A-$yyh5~6 @tU 3ڹKMgd~3So补Uz4\vG&)R"?~\;UCED R1޷s 9/uz|~g}T1 X%Pz]5b1O~^I8~-$5uJeP6\'|(@GeU/95N#9S9>3#^=g,W຋(:J{M%07axIҔ dLeG\VL琫q*l#v;{ `-" 7όN&zssU=x- 4}&rٮbj1?=S #؛g^ +a4I~+*:G.fU4}1 w[\u<-,p܉վ`]{'*(spc_^؏0E k~;`v T3s|#ܰTZoO`LO4f,*Ak C4mԞR\u(/@ھ'r(}`ː 'ȅm^B@[C8{'k%FY ~?/C6IA3R-X*9hpC/LxxZ3 鶓)ٺd/Ψ5#X'4a.XǠ$0C *1[#^É)E呅SNʛąUΪ >Wa'PȢX+o7eUs@5ǕriJSFmY4Y3a,/,/1g#(9lKp-;M}aT OD 0&ۺ_F7 i7k]]n.6;o& k *I=~'::2p6P_|<;c1;ԥI-Ů:RBbS1&?pI砫@눕s96ħڒ  V\gfj$ؼk;k%ZH~8Wֺq* B ݟx*rʐ dE sqў-J,הmwHXK:iMJG꫾$va0+c~oj8tvD*k(n&(óq!R Ogfr)"싮%8rciP:( ^C@S¾ SnVf3b1,JS^iRFT?ektD77y |Vf@dz-F56eD{]"r/ǝtj!9EC]BLN=˰2zUh Xj^Q{fx[/<`%"E0T\[f2 0Ό$Q(M:vӣϯK=^_"g\6wExj ?JigU4V/Z hd`::p jk 3%+;}3Ґcwx#LDoǚ b(_/q(f%|F\topS.,{#Srƹ>êY8޺T]ASʑF2&An_&МqJ)"!).JMIױ^_'Q6D2M,F:kB _QR1oDzF|y/TH Bԧ<8ѠA|+x&16ac"9|3^(,HAr`v]ʩ:@,z􅰜um{2+$BƼ%׼5QM -ҖXb0uknVJ@X" t=8.~PZDUxxoW3(RӈH+f6jq8AV L?cU:v-GQ%A[Vh &w޾4wRk1iD+ 9rG :ALHTqueXpս1=xl~R)G8>vCntUſv9ɣ5:70 qMt ؃g ޻q ԭngo\W]Gf Sgb&? TbFֲM8W7I\V1՛*%^-,I. S+L^֬Gx?a+GaOܱfVcB9TCjȩ/nsPkK=jwXo{xnrAK_p8ѽ݁׾Nx I=&_MIYZF五n8Wp%@h`AhkU*xBIlՓugɼʤ.!g Nj>o$Y`kumY4 +IUKL~ 8V!q6)|'ZV;ȼɳv;TJӏ>:Zv4s?PPe^>ίmϷ`neʥ_,_UsFƶG8LIJg6H  Qc$L  ͯUSͬP' x4Ή7儿^B:X43O(f8R^)ƒ? ;5#v@3 ~ѩIKemqc", lPsVp|K6_gӶ]vB[2NrOFQv®H+1?gޜGݍR>'2[}[5$^k! ܮ0՞kZԋH-}?ebQ DO!mGΓS9U6,aK$~u$݆ŹY}[lxɿ`[Ÿ\궓6-a|yϔ QBZ oM7<-彨A$ 0J[ ;]zNBٶFEeiy􁋔Vmn~:xWۡ.n[1{wgYIG+e\]lؙ;l<^^zUlI#N'1VX&B[C& IGz W^[k'q#}fo"}l]m>hL#o o <5q™|ژ/a!lI$-T&j=o] MR*8O:D!s Q>:=}hvר4M=+@? / YNX?s i'juw#]ofl~Ţ D.&؛mߴ%Llg7X~~[a]*^6TN׶_jD1c4$fJYI-vC\P ޹=!odS5:J$%&:O\{gA}ZGlz9zJ&?4fmӉF_F4y+Eb3c./2Aˉ<*:nT~σT#ЧiD@E~u?u5ޒXybrP/D\R' V`*$=5L*^#v@`#H:Tc6{3Sfcf\ܰgYZPerl-APIReference-0.16/data/perlapi.5.14.0.pod.xz0000644000175000017500000015720411653441731017525 0ustar tseetsee7zXZִF!t/aC]c?V Or;6ǎ#x=j-CTx+'jj'UрP%p 'PQ\Yl]*({3#D` QYnA֌3)m(O0lgȾV>Ix2QŏnǾ8YioaRԽwC+9!74lH(ܖXvC#"D}%l9jSԸGXjog;~3̝Ħ7&ݺMT"0M7V:s_:ĸKRd$׺ "v\( 3[P`\R!vl1jtjE{iJ{ZMcj[ua~!Z"WD.%e0-ΐ@ K!G٣jnFim9gzS5)Wh}p"4:vCF}ڨڦHׂ3c] u6!<4ڇ_Ͷ7`XOYr&.D$Ē f@D}>@C.庵}veƓxNHS) pVk}M8Q-J4e~^ \p0}?*D`-rf,X$6ͯcr%ozByiX@|6%_(Q-BF^՞H @\Y3:O"<ܥy[u;?md{\SyBE:Qnn _3jOwT/-I."MQ$J= !K&K˧:>Ј6yn)b^]Hf{B/]^UyC≠8 *)F&:phF5q(G +w)]R/aS K2} ;t~0S5{dQ{;^OH ܀Hᱞ]|`n%3ݟOpY: =~> ?8[0~aBg+}aF<.<6ȯw+wmbiIr`L0ǰ1vv* ·-?)QL*QwY'~4wIhRFl rVtGkhMb03oC4*VL<Ϊ15Ba'҆I#пƵ~kЅHR ,<\̈́|o{ ~xtFE;OdJ?0[B71ԏ;]i؛F2'WV}ӹBNTKÄ<yQ(8#~*>;mETQ\|HVy(\Qh~o2y؞ @%c (fÏ P҂Nq~6Fi< +q([iNsWDC/+1sBp3CF\`Ԏ3nڮ$[ķ#9&o 8*uI_ oI)+8&M^#WsciښE58c|z<8u$,s?~zfoMZrOC 遳}uHP83]G;-^ n{sݔCVxřj.Xɕr+Y寕/@Cf[e%XUUWI {vqd`GԉAKh@Jh5nPa@g11NJ,pb:W qdX w:5Fۅ}|&Dv<\wu$;`&McH_hi7'lyڧ^b3X%MMEջ5!OK8^j1vkO=0;2 ֤+?}^L;4…qcm|{In;9Ux9\N~=2\dz C#@׺3 q4FF =*h?L]vl PN(ZY{izKQ;&dƎ;\Ώ,Xxr xIL:Q(X1B"4{˻Gֈ84lJ.me, `B"g4erfK, T,w&S Y,Hf,mJakY'e1 6U 6g6PPVWiOQo'T2V_& SÄ zfB>_RY'MdOv#Y Ja @>?dekh)=%TPh:n)g8S3p[a}lOY|ä(!MZVW ٦HAlA>'db3Tdp;uZ6h5R 9^J0 @*_u1-BY(0R$. v9 gnolJx+8GjM$ \ӏg 2v+ [̖-POmN⌕Sn ?94S?'d MS:c~n_^޶Ic@j{.wLc#`{]ѥʨ#X7:Þk Gx"'ZRV-,V`XP YƑ[xZsy('EhDC5 4Hc5ᩰI<7&:J(=oAm0#ܱks N&v3 q!gҭ;H=9>aN ʕwwHԧnSd0sN0/T>wN#c= _ nǠYMa&X@2_յ;?3% }f,H𐫹 _')& .lTr 1t t&ZtN3/@Gq(ct?'Չl8'9^;q"O\ͥ$0f'Y=D0tLݗ%#G\ebsE<;5dhgP?pZF|\zQ9peI[5ކE&IJlfK A+0a@mQGDi+y0I£tvXrdL{$T@Ti| w>00b]| 0 c['7b$ynOF>#DΦ'¿p X#B F ˚T{2˰=t,j|nb忬tpjrچI5t$_,[U[{4g) ]q0#{}"ba)8E"p@$n> ; 8 ih3aph}ր3[{4b78$K@w׽ފNMz:'jc^,4ֳ=9<o`QĸQLy03 5݊<XdNpugNv >6Ѹh[#_h=hto"r 9y! ֽ#S Zyۀ,=P}!r3XWQrYH@K '2rA&PfraДZQ!sRRuh,7I!?Z'rdvdEeY7:x_X˦/0H'N5lRgیN숪| I{vw%H>Tok^G63=M88]!ԃI$}'F-: 7%^A0J'Eztqc ^ -[-߭T ,4)vMQ%9tِ"b \O‚_TgM g72g9:"JdȞ2_,8A 7_x@9LVnU_~F<ߝgz[w$B0k)ICtiB){-I\(s\eT,4̱ ZЗeդs_ .RT.ݻaQ3:8t TͅuR%MʱiIgq԰ܙ2@>cn/5O55bizthH@F5J'XU}qn2p(܁ ?[B@qy^d@`}ȴ9+E'z`*`>ODՖv7f/x2b)ܣ&7*6x-Q՘5;GG:PݔLGtR+N4 q.xȡ0D9([+C wA8"N7 -@ز'\vq,M6uRȍƩa ]~G Y`N^G9`cD+r?UI#؉ҪyG(EASS1%,z(xn+n wE&@&2hFP99y4 t^"bod?2+صn M;zJXvD1L3z4EK^R(N?K@\Žz+^;6TJCe$jp(}h ڦa93fIb8Z_+Â%(cUOER &xR^Z D9=K {ٖXmhyp!bK(#ňN qX`0S퀲O8JN\<^ þD""ʗWx2tSGI9CR(yQi-M/}9 gpXƫb l8D)Ԓ!J9^)z =AUnOlj}; \FR4gMrqEb_^?5b@rո XQ$րBt [¨6[<'!3Q5@ndg4'7bpV8:]jkpL|ud`!{GvN0Ђ.B,ZcrNnsP3AbCoenAvp ]s8EI#Lh+ԇ8+Mٝ\; dMK4 Zy'NI=Z$jŀ|Ob)}v)d)@+ieMm` .| x@ď{9g*XMlNL1:B$y[)ژۂSx(*eaa>]aCAMuTb S9h|Em88fze8gF D-% ͹SիJ_)qR?oK3ۋ+s$0p uȅpJY>Jdq\yoFpGL/jFYZK.*Dy(a Lǝ Yuk||~em*F7lHmE0'<FE^lcBnn|[ 5.[O8rnoփIy]GDJwR}}oҷY֜K^wUynb\^dAn9`]meLjӸ4t9NlG4:CAG#{d'@a_P ACI[Z"dM4 X9Ґ]{"iJhC 74N2M|*whԥXޕzگ@R)w|,{.ovZsi.~?lHNV`pUڿbd(q^w ߃8lvd_֥W.sAOsea$@#ϠpI X2bdqhU*)`E^<]2~(~h&j  V?}h>n\gNүr/ReK/|:`X̀2\Rc~SZx灵mdN=t95$lSU[^e;b.з-0!(Z.2.x>qil{Ml+=/tiwnlylo-*١ _DATQb 4 q%O ]uew= 績C+x!5-Cn KsYx N5mE[8X z[ގi$S*Ic9"4ˆ*>b#k r1fw#$b$;B^;u4K rjA235NROW+@7(I!?X]-bJ )`8w{=S&_ZBUBo*b cs\Lh^S}z~9|_hl>˿L񒿿?W=lOa2 \-m ޚ p_ TL[C߀qPW}\0s~ Tj AsG-+-NʎA5pub?[Hc>^imw>*Fepgp4#)v*CRzY2^>n#xn*o>0 O;̹؇c%GAXB0D֕gmf/ήewp *<ݞOv̪ٱ 8SE ߁"ϔK8iovq/ab]Ӱ$\/Uh+E@z.8Kn+@A0 /80"uK1[9\}SA{M9a2 [+A"RN_4^UCBU: D4ӈ] = \h Q$ ?ǀ}-2(Y #Ě QroNYvr\oI%eCe!9J&=p=^bn%B}zYٕ$cib-a [ wxpx;Pz` Ep񄇍=A]mOř*utvwolwī3S[{@7 d&vlOkQT>NJli=6^DLe0 dky#d^.`+s 4̵y6ϟGEU-Յqs֧>gU62nap]FۭUq?P5/x3nf*uYzuiTqm f2{g+A5;}HdCL1¸Pܙ%BhʉZ, BsxU6UN `P5QR@'6__FM F(Ƴ\zc(Jk[|RFWdM+F0ɮ-#]fy6_AxPCiH3~P'&yA-T߻oX/$< Å%v6;@zOoJ I0څ^xX{5 PY!A$̺~03.Aext"2(ak#8hKqʉ=`jJɐp _Ԇ fDU+u nrB$e2T{F&CCkõPJiA+RCY'1ʻl?ui,X;B 6 _ȵp˿ -I`fZ6,![Y pG5_?]}Op%1g݊U-ml#0z `?0gsXru;[M{eRZqD)^cRY]v˚jNpFuL +rUIJX j́,Nÿ _;ܔFgǽz4˷3O)(P&ϖ, 1[?Vl". OX1a=8AʨIi 4²{WY)4H@!'c!OoQ3zӠ J͍e4]L w+ZMGgJT<8!"i4ԂGsԺy7oLH#+ӺN km-sZ|5^c2l] bQ&d)sMbdݞd0W-p!~6a04l@生2ړnRPftR2PueXOrIygFjp]6wP3ŝͥƣ.T]4`L$5`i}9\DF)n =knШ&Z_=Bi4Pdž) q= N TGfgn:956l+ >P6ൾcXz{zqBͺ'd%afs=Wq$Y'.N~#9IjvD9Uo^68%YcH79:-'7=z!27VX0}I9^+[Elz2_M%Tzx&p{ ҋt8*,Re 8 eƣP3GX_LdY0/mH$/ _v <='4SQ GtBBT]LcGNWWkl < (r )r?tl2KF^؍G}g{*EI6,"Oʤh|4T8b#-'AMPXK(2"PYcLv?x١C^p͕oRDj=~pxTaʁ>L&?*ɓDŽԆ?a/D½F/0Hl]α/d =wҤ:7/KJi<2DUҿbQ^{{ Z.<7Aodf|YFXr<˺ oPB Y=IMTp`x1iw^PjpM\2t MÖ[Ԑ{ݢh. 1F%h&Q⹄E3Qƈ21 e #\1K գ7_=xp߁SvEFb* Zjl''mMHkz&ʟSoHcT5qY)M}P9@CkM*3\:< N˖b&95I "%K?n9~&1&YN\-XyV,ɺ ՅKw3mn6d)퇁:VM2?4zF8?uz|C,µɋ +HٷO%2ngXxr.:7W+g] ?Rוd\Ё0mr6R%d:9 VxofZNti0goz,Oɧoq+w 1X lz麷 bɬ.#Pd["-B7ҫC㒹j & K<- tN8kX2"A }~;`#٥ْJ\˜pΑT޻)'HdgߘHTmD0. 4`1 G5c ~ LK%yHrE ?|xayr; q1Vr䆊oͫt%5P?W:%.CÆ{ȓM^bӚ ݪcЌKt# _.}yi:f}YcI&ܻʬLw)8P@*|dM1Q > 8C Άvn.&CWoz` S ΥӚJʅA?Sr+{xo@6fz[멠΂jxODYfwT.|c'@N"Um` 0VĥыZ}~X0&r঳oë/-y˼xMmʊ4%83:3EЏnl<*H_g3v' J9MH^nH`e)WaKxOZ@YSh6خZ^6ܽs|"CXP+1 !@O=O{ԮJ\Ak $x'2T.RӉU<%4heJ闏+6oޝ FU̕1%HI euԃ_埑YOadG /e)-G*S*{;c[J:cuP3MexH:G<,9g=hm$-(o6X0N߳h=z" A˿); j*q2QPTBxVR\<9^JYC޺hk4=1J%>ɑ՝J0 h%pd↻ӖJ}3!˒e ! ՄTgjg=lXҺ?'-~ \Ce{{h}؀&V;{}OіQ$K=G(JdCSb.R:wbr`x#4/pE >X7Oɒ>y iELH$%H 2Tt ix&s숿313`U_ }k7gp!GCS~mT#29Rۓˏ;KV%l]ƭkte(Po4DɍKUb 9w]D6Y~]҃(RC8&BC J+/ D%c)*ʼnPFC7@K~SX}z,^$' fe 2F:ie2۳:n⨝!9#")~c\/ؗ<ܠ~/<]iuust*k>?IJI544S˰#U8ƸzX}ҩ έ9} F9'ߔJQkT4Ult^|WicGvG/cߏ!ڈO6xjM~r=EE,^`'Ed!|u*w}Jyen=+v6 ݬjEZ9_u%Y;ˈظ$|0zY73g\xVnf ҴFE8Ssm۰澂p:NgIPЗK[lΝq Եa*s gil+i9kmζ/XŽf;jrx5Jk(ؽ)2`*$z&r02T~! NEm?H~ Bcs-NI5cL0NB V{ ܱU]uw i\V[Q;k C$ؔ0B8Ql&΁"{f\gxDv@t hO,[_TlC\yOX"1P}ª ȩ^Zg_4foT톍Ij<:璟/W^{4 dϾ\]F7қA ׈XJeKK[/-s7ı'Kxb_Tw\+a^h.=V`mGwlwj}k@Fm%A91^ X^غ?'+y9Ee=G 7^3_h[W<fx^E܈bDI$D$A֋#I.~vrCU%\ד N4ωmHN]hMx4Ι/Fg řB-/8Kpbn8̸%zfD [MEQ9ntv@F]9M<8 yC .Ye?[aC2٧/gof`*'ɶu;lZ_Dڮsb'p4S"P\{.e1zbQrqܱV5 !ĩ& {[.!m^[D58Psn[ ĤTW ^#4lgfYEÆ "ű҉kU1iݕ1CoJJ_chK6I볭5Sy:^DPW"Q]8ؼ:eHtͫ0iSt6&\]/ePHoOӄ=@&9` }#Po1]ۗmڼ-{2[=tvRXhPEcCT+dViryZjE,2[@&/6T N7Y(LqԄxBi1ȑUSPı87 2xyz?-d ULnai:T5Ibz?8b~'I׏YY 2-xLJK>WYAɘgߨu s. dy (>;3! M\; R@" GHb` & ]fOjd]6-ƿ؏~cd8=r8zriJiG"JmYΤ̅R- y*Nyx' Kq7k/EHdgnZ'Kpf.ЂWi@0-F5+xF=X W;EU&M !9R%xX#0s#2gum{*dUppP 1lYJCۦ3mLrV. C ua5f3DCK᛽ra "}T;N5zCR;bl<1`)I<:cO >`+qZo),KtJd \ M^60{܏{0VX;2L^ `&Mh[6ˠXBƩ#SFrdz %x@ĹZe?#L\`o#.YL 5?rOEw賘WA$dhG9gM GMa Ȗf)CE()0ѾYk,ZZƓq fٻcU'>[Y\?Bۛb.b:|AfUUı:kkL)/m4e/OjAr&frqK^o̹o=@v)F qzZ@HQ  ;C)wN;T"Vt ]퓺}w)ĝ.c'.9$Q Myey=Dm5Emvc4bu9N fR/|. D/~?|n贤 YV L[E_$wdӊ-]~v!][)wB;kD5!mrHru-@nV~SF,@@`p`$ XS2A~*7@. ?n\Anf($p<iQ8rpOv!FsS췏&'UlĊCy[@^{oN+zm3+#6o8V ݍvS^_J*'M*x'Ǔww R[keL0sj`$[aH%wh 5a!G(2u}h ?}@atl mL\sU@]r D^UB_ ?$l1C*i+υ ?;0Idh /ɧr#v+b7{oCM`&xU.F{?njF|}~O-p?)6_ll-7Ȱ $!k2*IuNyb> d4＼MEM .-&3G/XC~`>niy! w9FQ@iE$a#f9Pީ 8y %keƹ,i XA#VazU<r SKEeL{xi:i7NGJ-. _,"f끘()x^ԧ0X<|\BQ?F־|VHPv$R ovOդT ﯦ׼4RY[<ݺE\ 钾'8S(i@=m1wj4N_u>YɌŵ(lpMbhADNKT^CaUc 0*NT;:(:o Ƹ\X,<(s#?LlUq'TnM>MhvD=MЪhi?6JaNP!Ev'/e`_Q?: C+t y֖Cdb 81CS"C$_nZݣ41~iv/̑圏G8}ݵQas*U73>tG'NMeUQ+}ӗ2Wd+v?Jk8g6-b*NcZ!?E $K'RF$W,W&ۤ#ZE6PH8&C_cåRHԘԱFRV$ Kɒli8n_.X_fwΦh'!˱!*D3? P䶠9UlNҷ?@f8ԁ?ԾaHnAE\ uf.xk0&U''h6u?+1ʪݕvU4X[OS@_U2Mۅ9[P#?ul*'؁Hsg4\ޣE%Ow`:uލtz.CkXSěH# D 8֥O~2֙;*4RG#"vf҆س0Ck7 3٭p̥qAPq6K"bfgPm@d\m(I%%7K5O@^Q+i 3VvetiLUwU֪|PYc3?Q(ѩj^K64Hۣ!k鄆Ne9zca²)AfjxFXl 4%O?zCApN ZwEλQZfP)y>x "SpЧbI?QVl"(=X<O&M+"j2/t k9ƇccBtZ=*&1>h9?zo=kZw\c=YAU?:1೜uk!H(.ʅ^E#El#8DJim[>)*4Ut)$9^QĴ@?>u֨6xi<޾.iO%X+:g$,]M}:uNSOaIC=Kt։ܐ{>;ڳmuf~XyVd)GLiV*fܹ:pA-P7~8* ?.mwȂull38ъm@`pP?ڸj=UKI\b-f= bTT_U(quF Akľ̯p'FFdz" ;bC\+ong3 m2l_ wǶiwQ|&w&g 5 Qԩ:2ky2 ׼%7rOb! R[90o.,MM²P,|c]0ZOMphXd3$kϵX]" K;ȩ kLX^E=&4[F`Bgt ij47E Yjijo*:|Ia))77Qs$1LςX /X^6|!k.,|( U jzB7O<'3yOP swPUw (LMky0o98kTdҬ+q̭|~¾yѩ0N$J p,z4oRl>3;m{gRQ2VjM,|j&z@NhX2Cme٠y, _} #]W&a(\tY&pqz/ijcJs`>RS_?:AvɬDbiv9-Q/+@S'C?rI7& [#YTP0Kt'- S"1 8[߫N "AS#y1V`M?vwF@~^كDڝ-No7 ! z,<^ [02♎#h$iX>3R?4vݔ)*BZ"= +ax&{OOK[̶6g9[y|[!.MMu61fb̪6~D}g'=$vD. *&u|苚^Rvno\,b|WϒF0{:QJYBkVuH)sgA; RCR$N%N;{58%ab2x<-)o:|qhTke"xHp͉*ReUlE]'<2YM~*B#8LB!ŏ&:/܂k@%_ ~š*bF=D|d&J}ѓ:iQ*FP!8`HolHNdڲ_فM7-X( f9v&x8_؝-|w !99վ+6G3c)|]JT7~u`> - 3d_>x IvGe[]ͬ4ԸOR:wDdEWr@y~aWn;v<E}7s }) (}J$AbR.[IWsAؙWQz QXH}yKY8xc][ ]j\c3I83L@mOwdzi6rtSRC*}ivis~.!ST^LLRBVs"վL^pb-U!k;(Sr)~]zcUp%oUn665-zꏒ8 sօF*r}le}?UF3 )b,Vhjwl2\08$ H(h7=@F\wj E.zKMKngqh'9q6zV'hV-)kDRxa.(`wkw=14s< !k' Jc+9F7G,G;˃s:N(Պկ&RVUs G;u1s[r=%ݏMm˼GvjXŸ(T9K%?BͶ{Z`y*VMEv"-a@c}y{ʒ.iJL`kqxWjlV釋|YnUh{eW8VmMx&J}-*ցYvGZMZ4%*CwBf*{Li-(-B)c!f!Vxٵ`1|q.1a7dwy:ReI@U"ް$1nzwɗыJ0AH90m0be[I5 c؏$ 8npX*df0E/=ΓO !^awb*A"Z^u9!G}{?Mf+rT6O@5, jv5 gbnu9|ԛlr%&œ (~ ߬BT&1&99^?lNmm9|z2y%PD+}0 ?(fHox?G),ǿ)vzxC6D_ !,ag0b }ȧ:ww~ұHE@{-r6O+::OՎPi⧘EExm2 *y蕷:gG_ظ<  xܙpJ79Q5:p^(JU dDXG'u{ӴS3<q *ij?~Ci8XZzq wH)qAO`>2jl}$:ń =8G *h#94e[~`}i<)^wd pFu_M\GV{WD[dAQ%/iT |qK(x(LipcYM@?d`bud^@<&]AM˹Wu!9?%9 \I |2:6XA;'bupZZbcćlYa7Tmֳ% +ݕdyŖzuD(6@7]"*DR걵Qwv{Qܤ(nfZ&G]* }yf'0INQ5~J&KC[5F Hv-&닩poXk.:,GOFk2JJ;t̂51JP#? ,2D&knD9wGKHU[ߩIʏ%;dĀ݊Ï0сwJɾ?Е#Ÿee?|ؤ}&(?`%2QN]pcu [pheXQ2M:ՓwZ)'% l){`E\Vgyu qlsכ͜၁*= z|Ap [k XOxnYd10DpBW&# No]e_?fKЍeoU Jj8vIgdGPj(Ռ?Qʙ఻aW`+K7AyXOB_ Fyq h,hd%Gۖr:GN[jCMʗo EJ/,qi6{߯DO;uv6)2u\ 3} MĵE no_\VH䨭 ό}o m"V¹%r]ҳ׬I_\'ڹԧ mgqߥ\rYnOtJZPwg~:ܝVdCupL?B 4-Ρ θy &L2r#ĀuOq'TN9(Qʊk|pv$8A7mU#0HkIh(,3ɺ5(En#c*P˕P=~XG-?m(vS\!R\An}~7by}!>Js@d{Q /Gy E "՟PLQO{W.3iaiq  hc}$1; ֺÊWdNձ|9ڧeEҀRo税X堖Ƙhm`=Fe6*Pݎ{䈡_D4 |(]ob`M-úǍsc;hn_._~e~GQз?Zqa+3vouͮBY2;DdbMp-=",BPxϤ`B';/X ¯s]%x-ʀh&Wi֠>+1\.}3qζ͍H4{1YF]k^K%.`FqȏR痏i=0>Ⱦ~1!eVL{wڂ4=&k5ƌQ_t`nT^NZ9Er:@󆓤!].w;7U~\]c&+V騦wєHL)4u:Г]'hԛFώD* ťg6ְَ|M-?bbpXle-Kn/etyO؃xqK($C,=3r>Ъ=G6~?pfx1`B +վP3=+tVBeW` DŘ ÔYt^ѭ%*ge$:\J@m +kv'o#|C)Lky}w&6l(";.,8BDL^M><'%qD0M{C 1X8gqr_N[._C?ᭌ@4aUIgT9"g9ܾy|ΕE[ ^`"JՆǪ< { .*ffX1+ۛ+v l'5aR[PV/VpHd1 |]g-N#D35ًjikDc*;vkc ;Gw QR/lw.im&yK >xo`] %vL+#Skxv8_y?/?48_'I&ՉmM+OD*6 gsz8 1WgiGy'6jWO#7mFKJÈkut7n /]̺%``[|zUeoyx@󅔂 iD&TP5ﴀŧt?C _q75~'#qGaFR=LG%1S_>KQ !!S^w^+6pqZHH!N^=YlAFX@{\6/f$-dk^_2CŹ+EVX/6ݚsUGlP_OI: vqHxwwؒuEFf| JRΆ>C/6d|BLS:F0r\шuo9d-̃ۄ)HU_:4~vf2s x~Y2b>h7j/i * "?r%O[C1UI?coAC+fX@-ن0_߭eEV yt+\/h,s`.WmYt|!T?` ζ}.dT_F"LB/b9?Ђ% Lz^^,*ӉHbS3oMEbx/[4 ar| .[$n.Ns)YRNC*÷|jq)~ =C+ {`{<2W[׬PO=If S½C,c bd ty% X 4M֯֡L"|n)V{ۭH@΁/ 'E=5t-ep K-cHݣ'itn%`J 2صKDNzF|;_9WUSk"-g-@3Lxd Ny'0r66*pCT(OcOФp z D$s"[*(Gz*̸+ҁ1⍴s|d )]_ ZDXMwhZuNX5x9zڎ¤-SՅ6feu 6c>,ɫ=k-ϐ;NyPS"BMBgED&W[KK C-ȇxKVf$sЋ uБێ|v4 X}TzACH>>AƗm2I5@A݋K01I2 >\}*Gz6fʟ ¹{O;c+r`qp& z'#eT=-ޤP2p9@ȧ7}Ǧb}{\bאZ+vWs9J{zJsH5Xu-Im,at6\.20<2q<`\*F`&5t. T1Ո`@!~&:Um#S')_[dPg<"Ua͸X?m$&o 3nӴ+rl/n2CMEutS}w o6l0,4j=!R3z̬WRLPyg+rl(/ tI gxdگֹ~qq)w@ /iCvs7E)/U`Gs?^pzCRXs.|z?^m])rԥ8?{G>\h6Wyl08Aͱ:M ҩnH-`,wCKVo- וQtGwٙ+!y%BmET; /V+V`ODEs N ꟶ%Ti_a$t7e'/rrv[<4{0:@H/L/+[R;sJL& @.JTGv߂Kg}ЧC܅{G; n`c`v@ENUX Ա(F l$XNiu*Ax Nc#az5eq} )|A{%\_9"g(xՃZ.F8V:{ ;'@l\&K&MHn{&da/i5ԧO;=~}iBad$Dw=E^+MμNtO Vm 2М;8#r6IÝo1UcѼ wGq<"Ck+(b/i۳R V &kI0I1Cѓ㡊 uc%5KjA_Y!&l#53: КVG`ST9Sf4.0 \QHh\x;%/R`faϐ0Pdw`+FK ɸX}+rjM"|v|fM2JD)5T@9Lfvt jkz."Rdq@_$eKC.ũE38zqJU$s̶j\ZBSK[ f*b =#iu֡Y)W佇@!eWԄTS*۔J߈ȲO:܈}͗enjNϥT;@WGX9z>\;7cT/;c$$x:$Ĭ,w>NK* f0F ق3G1ζw$A܀m')vFn>)gv%J$>%@uvSJȸ\H\Asϒ`ȒY(}*]#BRҩݹv=_F6K_Qm<@W>nBj=kņ9BE luZ$k&Fbk%W uvqIs<<.@h MZWыi_v[Dk}q+Ytp1R jk9ܯ\sÃmf*\`XC}sr+!5;/8-[FjO"x4W'T8 cnPJ|Ml{7 gKty<)N< YdF?y a 6 fo]>[CE~l wA<\ajVI+)wN z/xe!T^1 PY-sq 㓕gs `=@rm-HfOC 2"?Ft^c.B?RaE4D5/y8u)fu_h>\ߺ4t8o!a o݇- snd4i[샤-QJK"*+KM0`3;{lȧyWJI*m O߶cT߅˔Cxl&=LHJjHs;hn̢[e㑡BM/$+j K3H㞮ԈRbk -h Ƶ|F%z][.xie|/I#Tj1PkUׅGdžE r.2I{\xB_|ФdBu0RkbCkї|zn/@P#'t>^DXM];No9*#3Wkޔ]:}f EQ<GFqq5DVS0zz3m))!aou*4u3k'/Y=#G͚ vr}uH}m?gs/pmx ɻ88@[f,q(TVz9Pjfb`ŠfuT  vlB:&+"T9̖/ ,۞o! {U;WKcH\hgyMI֮R"ay%T{Q AJ[Mj }~A$P4!3w6e=lB &P@=ڡ`8G_+حJXS^9XM9Fҹ$|(^tP+Nl 44^+^u4Z8~UH\W@gp:.E/?ڱsk wOmw𝱊GErԧ#͊$83x΢.m#8gĔH/T} JtUCzi[kt1X7cn!fh&Fq8vZKBTf2|crcxWi̇ |d^MjJ){8<sM7Ͳ8GWmpZVP:WQ(/ҸyLV0r(W+aS9~(@2?{Xl0f63)iò"653 .Q ;5uv%yKB .fF]>,y!AwqxVQ;-NO a %K;6Gu'nMH'hYS@q'^_pHQ SH@~Hh(']>)r5?_c5E \q/b ˝f.՗ KQo.Yt4},\׺:aPk1 7rnOpe TIzS)v:8\x.:PpEB'2qPdUܟ86{p/'SЊV5[ AdR&QC,؉\K<yl :]tcUWspE7Z&fV]7Wk{LN-Ga],& G_c0jYeOKUޢv2ϘBӘgFr? Pqekr`NH_=؝70`V$='?cMo~10M/zje2ĸ7.^}((-WT)KE"☸ԙ/xE\q;M  2jOM(G6[]%q7r$=w>%?P>d ˢf9Y#T"{*/ͼl2}ʫ"Fظ\pn@ߴXd] @÷$#Bא[1B,yMY>dO8"lj*r5=3lrFZe"mAghoLT9٧PyZ VWç#Žژr<> X+Rحx. c갘"N%6!m,IR{ )Ysk/-E73o @/[MUVubI֖ecT}UNȶ1,s xJlm?jpŦB'%_B*Ox.>w+(o"{2VdƢ{Ow`!PI~iQ9lmԣ qU~{GKzDɦLDK dEm dc)_oi|)k$>8.7c,)]R1\QN &K?Wʈ8/xgQaqd5(7 3pkl5+0TʏX&Lt\& ~(B^ "\*qMrEeX-$1.ql$`f1]2k T*p|Œ Q;{ Y Xj۰@8"\^Au;f'@W/}^7 @c@ƀZ(s'Ͼ=պeRLE,!B" .#3(6\dd$-3]Rz֬^J̷0u'\񦼩`G̣FlEj-k^+ݩw /U@,/j@`XĮ)Hdx/)OJ_5l)X輕4$!Tô, =dKI@TRJD7"RLL4 ?ymnF濆CxPn=Aޢ 7:yÄˍ]esm}1Bn]c;AW9Ou0t-E$x/AA ^՝.ONj:9g\ S b 4z8-hVs@4F:D,8Zlt1e;iִbxQ(2T=0"ckNcÑ#<_-0J3P׉{UN}N2 Ȗi= C,h#Ւyz5`$[wй Uf@)Db#ƌcyQ'b^#zyiƎض 8̱k$-9bX(U#.t4F78SUx'z<ȷxykՆEi"*0nλIaFnp$ ޾ߏyFcO)b 3k vQ:;g0& ^\8p !x}Z r5 0[ۦ35c^uDb˃ΒFCh"_67Q6{!r.E& <?8AkbڳybL$ui6fNsa-&HIc,Tx_gDY"HØEGN~2`l{SKZFnQ8Z^-8\<\x+ Mר#Z}8tN{@4Kydut 3XPsxUǨoDR/4rO)vcsD#o;}2 VLh7ahI7TKnVB"da^?CϢ5 )x;h"f>A\9D)P 1/BeǪ'ϖRb d@* B9 "|UBW9-xUoq^mC"m++Eֲ"H[` y*}vζ9j>P>\W4zx#n}l< Tƥ% 6nL'U5A*G@zbk v`ud qG: DWbG) g`)%P$H4ϯ:&o^[Lm)y3-v\6-OF4.*˒mՖUrYa!*s1i/f"*Haww&+ֆ_\)vGL("kXIy(qN_x&9ZH 1(({7zw2e UWiAs&(IJIy0Qx2T{ǡ8.GWhBD4^<1 -O4E+nO@'q~J@ػ@.-D g(i?ll[|%i@7KHԬZ>T%(-ҫ-abd:p=arKL@ճ}/U=*3Vdw/&$Xcܷm3 S9eW-7 L| Gӏ12F7BJVeԀ4wgtM/Z_V"\Ǵ WG>/a4E3m5ࠋ"S{_?~FKd,ȌTɐ4Rpq*2x({-cdSK@OV"KźֺU\pLM1GI<7n[ 5;=)D>/!Q62Ci:Tʁܥo,wea],Io,"OL6Ũ*yqO#')"&Z,[l NRcf[&hCFdTz$d$W"Tt^9\hN;έ?!:9 @l~|_GR2K 셊4C̘y_5k2c_y7/p_.r2$/5->=#~ZhTlO7%˺潼+#raأY=yũIrNiH ܻxѧbȢP\r >j9i[1RVrCg\M[=g*|4]V- <觅gu砂0A+pϜ Oך tΎdu'/31Rn;ܘC=A0Clq z-<1LlXֈ(W8Z)b[p@$BJZD8Iir1GDy`;5r@y>c A:zFzݙE+'Џv?*o= 'ApJ}+{cWCEZ(4koϭDhj_^B'~rxZ19.e2bE9G;weeYKtО<Nנ1L]>8)W'r f"a@( =1R.MEeeRDNL v&Z(Ŧ=}  '(Vz [S \/柤: =HCF%P-)6\F# %)w6@@8~ )#jhAx_ Dw d )XL !d]ҕ5~UqQ*q`wJAVKIbew4rY[Ʌ ~'os!˟SX-8p={@YԵV>|:T)~ǔ]) j-X Gt|S8K?%O.HZ">o7Q>KWAqKH58C߲ch?EPXK0f(0Gmh5|s]j׉nsA[f檖\/Jph@uƬ L#GܘD E@ 53OSSǕƐ懿4Zm^1B'eU6 |UNJ)>BOVhCruӗܪp|U-w-A?_O$%/)9@Pp YXs$&0oI˯[΢Q4}T8S}h 5/Sލ1I_Wš)༆'z_%m_ҐD gO!sƱ͜g+ Sϴ*mVaHRJUUmw`Oo߉Zp> JU9't÷XReWbr0K N SG͍y":SUnN&^e4ID-' CmmP7^, siݔ+VN3FPOAD~)%qS Og0'B)nD[o8/)XiX8fSϸ+k~21=!6c/4zn4#TW.r!:q?,nAB.yw\D :| `WIg׻Ǧ*LFП=ۙW:a3@E8@XoD(y;AEBl}ѓsjm[X u>Tmv=l D4cygCnivNC$IuP h*Nf`}jEp!F?"VJ.],ܥ*T וuTL%gbaO}i2Cn%4M՞M $ \m"I.U5ޡǶ|# -O̊7xJNyv!$*ok69 `FA?J~i>ПAU0#{M>? Wmח )EyRjzpmsx h*';"+[I C 稗Lsf3K +6i^y=-S/pKX+]Vw̥%NLXb<չB؊62{q2G${1H8:= Q~+u^8bE~<OҜ1;E (tuR.7~JЪy~_ƿӑ3 pfH rIN(`EE~TW-'XRe꬝ 4w`MPkSnWx^iT x>tIߨ܌| 䃹A+TyC%^.~ܿ!P22/]h{nD`ɉAe8!<rRX{ Bx~V#kLcBJNn/aT[%^zPZ_۝^o~݈U}ǍpmpfvF _Q68Œ_+ H3G4n";(8 K|N` g`*_'\ig7/b[Ԯ돑5)Sĭ0$Gb5.[QjGͮb#'h4G6IdK9G>%}Q! 9w2IccgAܥs&$K%^sNE}}{P\_[eCv )2u)(>xP$/UK>:MfNH#ƣJ/P Ug̽p-N5e/ !v Rl?Ej}j*g,YםWƉ+)^mN,;%zv"Pn,I^yz69_XuO8Z'Qc@nV;N`6Yi~vs0JA}*O#XEp^ؽFl` { W$4F4)Nob:f"C6d$jB6g}Gp;ŀ-߆e0|mc@ >c%u"0el|} :[Jc9H27kkn؁MȰ{n_7h4G *㕵KRMNȟ7> XoIe;\+#eQ'=c*UUiBR}K2\ ?;7n1m,.4b)|%{U]ӯ!(5+K΢MB5q!6pl <,]L3(DVICԔ4=__WCBc6rT]hrYʺ CgC?96AX]mv 6Hd+uCgzK7 әSV-$% 6}2OۖaE}%-nI1PÝ&Vy>cxtlcYUFB)EgZ:q_ڀAW'GN{r[F K>nc&#}]5Pt“[#j,΅7'b]T7De{| # vۅ\` kze &7E/: GC(HL3t"IPSW+87oĆ[ҎմGE Qρ}//fΤqqzx΍6cv( 27tč%&VdR\eu@Կ- tfgXIABp%oVPuf%g7,g~da `s!%UR3nO=\Yس!hT-Kî\9cc%E4:;*a=iR"֘%I\JBpڲX|Ы.0aw D]cXěuLL9br7ϊكa5hC|ʣU 52r2K텍<4:d+5H Q)]zXeUᐄul>ik /R%〵2=NfC!DLHP-AFk zS(8A|haYwCK4 ݙ+H "n6bj #R/ehw^ob?74rJ:+^Mb(YN;̐XrygráHcϏҼijՙ fgL* C^%LԂ?ۙ@+v.uc_#fcVïHk@x -}E Ŀe_Gcjg _5EV\nxk .eYy\Uu/wL+}Z$O{z#z +`^GT^st,[buI4'" =e-)+r_ۓ6'Պߞ$ac~gNmǾѤĴhVtw?~;nR]T><6VR2YzZ *P_Ҡq̾8!rݚ_Ax}ݻ(X5:mq$#MID>PWl`O}>^ޞu,:I[i~֑;}:9yPDE _~3~V\?&.EOnirJsRyq̖+Ql +VV6_$O7p>\ xVo'H^'Mgq˅fb@KK8jrÁض'bmuYEH̡d" b{8[Zgq+DPZ6KPF}}ׇʊ#A:1_CМhe}Y, +Ml̘(0^w@]ejæU7HǮi,uWxc"|KJy*-.&mg?1 tUCw0mX]5[hyQzlma1jFw|oZi 5`"nPưHҟ\w0. p"^6dld|tM"LKc$ V eX ء}w+ۍ͏vxW["geY/ݩ~ӣή!yT8Xua"ʘGc (.Zlޖ#КC|,=F#σ@[ЏC\P5:XA`c0H )P݅xg]oP]Hsg~踍*fL篈z 8pJ_BMP"u"ECq6ìۤbWat$ |:Bڇ=p~V#ۓp<*͞uhl{ O 2 @ 7zqI4δRgqLFD~/,E}Y#;'6ʣN)\P oj{M ӑ!UQE?2-9uҙW#W-7*CܜO:5Oo&m(0mfˋȋ'S3x㿊,8y/5q6C0Qݐ #o-#ґe4*vuwpbgK\Y@4$>>o^úbkGY^&n9$CQ 17ΙT.yyJH !}#]gJ=P;h9 eNJ~d+nR)>mɀ'`Zwރ{>"JhWFl-Ar2qU)6ga a}Ĝȿp5N\<[dKǃg&ơ_|P3X(wjQDۅ62LC8'=0Be2ؑL!@cL&(3ZɌ/WoVcv-I_?R+O_Ԇ{1Kʱ"HN'eM[Uԏ;0fr#U:wq-w77!՛xz3]橒Ow8ƫ|}GE9: BsKMPDR_PrP;žS%\nOw.`*nA.$61h LIoޝՊj<<-]+$'WC6YNZPǧL *s878,*x:ojpAd"7rΰW뽰Yig&R&f˯*B;ԤÍ"##~jA@~tXHwFFb.p2F~wAȜ*-KnjBGC?*|u m\&;Hi|#k>C`1u'ۆ P@JR:S۵nau|@$40;,c9&o3n7"9>Hcf*ŧ_E)|>h,!V2pʾxEQKuE~m/IeI]d -3\V z.A[[F;Rմ*?sI"M|/ACnRbq2vt l/0Ce]O9(Mf kϤX=)ZDu{vMqb.Ї/ca i/vA)\bRlΊ"F}mhKuKbqcL6bR߉!ᙎ[GBmpT<6vH"..:^O..e].y,L[8Biu@pՖg(h?_d&r-|@G.7b/WN Q<@(~Yxڠrµ d˭<"Y4rߪDƠ.3X|ʶ:{`ϓa99(I8r=:ń db7D&J9αtJCDX$z>`r0mVԚw;wG?=L13ooH@uV# qi-]וH ^ M-SԤQ~$h2=ļ)lbTKG:ǹ,I dGo(֍+ w]j.̞3SO7MyWTFIT6;"Pe3h>?m'r +K6pW3za?9~ 0WԺnS:dKOf)o `F{bk8EQm ajpaP\,ZXD4D~(XXW8Vnt Xj6!oIZX|K&/zRoé<'.Rsj@/T[ i59x-_W&b BX.6'ǜs}EۍߙkIq(.u7= HAv̂ep*b>`-F4!Zc)~H aApxiH }%P deg>/$Ô15X i;MwU]3M̆_,8x:%-|'‹=%l;zb-HT,XTm;k"~8ؽ,˼yݙ甦KZR0@ӗ˯k6UI8i}ȎyӰW2 H͸$I >T8a-(}LvI7xm8*uZłT.mޏwDE\ɪ2a!^d'o{kL9-7o /qU!M܅oIE)c?7Qg =my#r#l|j'P_ȷJ4"xW^_}D1|6c8d/kLENg,##S,348ZXumjw@NM=<%?87:89rsy7_x8b%Dݨ)\ ۯÑ]8X0߹y䐞IơTyI>HbQ Q#0 3DNO4hpBxСw 0p-K}F\>%FWy4&`L,k(`O{&~ *.@$EԄ=I&@n"cmrz%{9<PPI(|?=`p+a4КRj 0Ӷ9p9O}r:~Jϑ&~W'4p?5Or-'oQϺ+JzC"4R#B2@:\2T,ؠ]5zm'tzBma\\@2e-AD$ȁy>kͨ{ZFQ=LXB^/!6F -5j 0؝>B&QLil*MSP<9;b\E07Efif@$ z7Q$sCBخbzi¸3Le?8g2F?ֻ&HD~:>|{d,CViRӱ=IE̷\cv6}[ҍh+an\u`sXd:?kj8V9KՍ>K›K/l|]l^TI<>E|]y9aTwm@שG {4ʋJS)B_S8 Yqmoę7t[ $ػIn ɘƀ*^ޅZD4SK(Pb:µTY}3$"3W4={k[.I "/ܖ:N=I$km/iNHK C]S+ U/ϱ'>\gFQ܃q"@6<@Պ]ɜo@B4mQ $YT JR mc9 \_!A .q-;rz0d/6+9$M8--(z_x1M`lXTbˡK'2ڨ )˲( *Xo9 jзƠ rG?ʝzDoBq5^$(ӮS0F49aO Zb+V- $;P47(x8zM Z8M:Jڹ9 {KBW6j4L}& v7%J输4B{(z͸>f0+#Hw-(׍`oW# t(>tgpBIF$)Pw3b2ɸ0ڶ5v!*Tl{0m ɲI{F>F`b[&a|ª%>^WhFֺڎy?uףFz⣣q8mrQЍtO̵ WrI UZ:΃&=elS(ZMBgD^3*YLWHTAjŵ]kKɴPDF`AuW&6^:[t杷@L΅,CF9>OҠ mњ>[aP \!U|ҼP*Fc_i>Z!G$Us=%hr;^j Fy#W]' "Kү dGz$LHiX jfz#YP3b}#6f.PNBe薥/F( u[&O9ΰOZWcAf:fwӤXJ %P ߊVl'9: UF%{$񠉟!Qelƭ(w(.aQ6dk;ʔPqz(BlJ|vڑ zd"!uюfN,_0?7 +-&.:|Tmqц ƒ42>.h,i̚QUl] _.* )?&]W%=7]pnqXA]n/T1& kZ^r9ZZ| Ds%a7R?Wy5->_pN[j*p*=/uک;t[>f[/Ŭdw!RKAZK$x?:V-G"XJ8#,7,TTU:AfA{AfL&i "%rɀUZ/7T/M.B`||13BcI ,mo.@.,]whlW|t/j"~y.k6By'_r@Zɾ"Bw5k7Jןbnٛ0&H[vG >z9{^'1&OZ5h19q}GoNOYg_VB3N%Zp~rcWl VJ@Ng4¨AU Ƞ}2"桵g弎b!X%꺛f,LJ{ "yeh*HPsY.~^S-+HzX 1.ʼn"̻0mQ1G¥ħIJn3a I0l~ ټ֏Hjk:$Qy=g.~GdD?uPw #>UxHyV8p59`yuW5]'J2E@I^U['߆Tg-rՂBB6,^5Y۰-jiYh7cȉ=sdhOyiE_5O\2:E8`~ߺ7F`qD*W7{==6 UK!c$dMM"*{/L;Jg3d[5SttD[Np5aU9㔺X.$-A3j3Kʈkcnba5ۇM$yoZҼҥX`NM\ɰ>5Ww@Ch5ǻ'U bU;*co.;T :`.E3EDZqΫjGeK%~Z,^xf)4+7qVPLu psD6t1j (i䩵C!T0-G LW|/yDv)o:AxEoލPU;3ᄋűcn*wI%PDߌy+5ܞ|^S KˢJ:-218}P&._Js!D$XT&Y#΃&rpP~#HU  >'RBϣMIyn;_ ʬ99agK-΅E^ϯ9 >ϪΊQh~bye^!m/6F7h-1 9`; u5]X@|"jnM)h<6o\U HzYK/ WtoU|ޭ/l_=z9@LtH]]µx\gASy՘!̃Gf-G55YJū] `U;dңnSeMv4}LM{T=BrTlf *E wZ ?ve9P*G rTYMM-k ,E{{o$NIv0 a/Y,ɭi?.&ݎE=rCUiV…irOEig Ah^gګ6b(D!Lb޳]|yOÒZe)^ݕ 2G`\1,C`Ib5cLW2 Iц̛[.P6^bb S'8l3N#QH)lj0 y1F9ۈ4JMg'UDPtytr2v{Pwwst"Ϳ$rͼ] 񨝴ѐCMP3yYm;WqGFTp ZkxgHc᲼XJX4GPG2(8ON˗cdkHBd#v!"zUxTgB>#ixBfSzWw@v|Éz*=N|[*-YUv|fwl0:όW%;Fixr 1Rk4\- -g:L:>2Ϸj#3C?n1c{D' +4Kècx 2U5g.{#4P>|~Ѻ0;v!iJ\y)YJ9[1zWBbv`1 ֻuYϞ/e8@(CkD2ww͌^Pd'2akhM-qcԃ, VŵvjBGEM yh_Sp!͵Œ@HAf,v%VKe&=s&`'BsxE&;46^ux:dQuzzȒ" vp(('9A2?jSBfUOg^il,m"1IFe+m#0VfE RB A=n3L6eqx0rJ/`#%jR3*g7h9mbK%JoK=# wD=e3߼?~gYZPerl-APIReference-0.16/data/perlapi.5.10.1.pod.xz0000644000175000017500000010530011653441731017510 0ustar tseetsee7zXZִF!t/ӊ~]c?V Or;6ǎ#x=j-CTx+'jj'UрP%p 'PQ\Yl]*({3#D` QYnA֌3)m(O0lgȾV>Ix2QŏnǾ8YioaRԽwC+9!74lH(ܖXvC#"D}%l9jSԸGXjog;~3̝Ħ7&ݺMT"0M7V:s_:ĸ*5.Jn۟F:gfqis >>o+7/#Y32TUSt<^$&̱(4wgAUiͮ栚{} '؝sA`~jh~.][éLgR6xtEҽ[Kim{<,/E)"=:\Y! J2&A/FB^+ޡE/g| PE-<;($EH̰ugS`tFӻ 7aS!@BKNfv|`(zYȵeUrEzj&:DS"EQX.N0Üsq7Zmͩ}Il8Xp f .keXg+ a'4q@IH(-vFbzYf7ysUͮҴhr%mcF>' :kh.0+ ʄT$ukk?Nk$ϨW15S4v8yk:je( ^TsE;\ P&gwגӹl5WҌY\B/q͞x|Mc[8B4`*A @nY((|$#,:ohӳ6K|=F.P,'Ip)KܜjNѻW˹73c 9w8^J~$qL=1qosqx7B^r9ƹcKkZ4؛M_Ձ!جc M[aKc15ոö Z rF WOKLuBm]Ϻ'x ʍ}즒}m mFJN?*_b|"_<mݎ$#ˡ̇lZw&H@EsJ>pݿ0B^  z~#]DXoy5xn&jcqv&g|p =vګu%ӜwCl}m^MO{Ɂ5laY+gUjjRϦifY;ҥ2xZvc%xS!# zix^dhC;-Z>tvӢ#/ {M!˸pB҄S]T!:voKb 7_:S5flkU ?>*jrD'ęddas9^Sw-㉦jnXϻ-$ UL4* !;dрpe"GBwݢALu \`ß9!C+cAî[䏚'veoo")EbC cTW/0oٙX\m`Ocf\Tݑn$_2Iߡ%WU*:{Tu rUXkr ;KV͵ؓ !:hXoLJ6?$>2ySlT{Cly5իujQ {Օ{&OD+p? _`fxvr ϵ(γpٝŬke{v BrÆ>m#=ɱwP;ׇZT}9=ϵ3mvSPm]rY5?sq+UH(ahm\1XdJ-:̨Jkd_Kx]S|.㑚\:#g+|rxha |v&/wƽ?7)ggp[-ZD)߰3?czԠ\S}eVb S~G73=Zˎ(/ٖ>o)􅳆hooԦ΄fpu*E0lP.-1Ƽsg*|TOY~rhoŎکAaڝi(Uftb{fhKHl>+v{^LL,p0`B_^lx9Dsb63`gwT; aVYKvM#1]~vs a.rOR7C\,񦍜dU'w](+4Tb/PODS5Po 1 I}Q2c%pƛg;Uﻗ3k5qpi/|(T }8"; oz%*l<jN/ShUKQ ڣ(7a 4;<'ċoPJq&\dp0M7Gl4*TkL vU QNc0V +)ޗG~X7,!,準}PyC~(c-b!lT|3W.b]g!v KWgȦiβM8ZIwiM{>bCl[toQь,r+x PlA~`hc"S@_ȿ@Kc3~W7\4x%-u|"/3OZ"r|.#D-幼VTIN0 fӣتWSO[ S %ԫӎ]j9+$߬Bq !'܌C* o߂8lǚnOXmVy{\y^6=5 /3xq y~ٯ0\lhy,kNdw£ ѴVkt7 ҏĺGm#)^ͫRN̅n쪖ewV)T;4TXԤ5py888tj}k?("~% e^M?'/Բ^MqVŪ8vTuH"\Q5ַ|S=P f G^I cdNB;Gv eYBb]`4sG;Sr91>t󲲔 el&K/$F3Aׄtc_Cu&t [VO W^7tڟsoЖ 0\x$uW`/'X0p7ݯ nG$>NH;o1TL,̂$_B 6G6;x2-VĿ^qGn=YF4yA0OW!QNC%,a=q12f딵ỖJ0bYqtl#?e I}_([agGQ=#ɒbF1E]sy3a!qHnc,4b}w<o#.#Fp;1LЪ@ _3aۨ0*TH&q{JOy[f |oel[%9UmWxnY^VLy;EfIw `~ˉ̠ ÍCxT_0,wR.M9i9SjY1o|J8!Z g`HKgoQ?*zIb|_ P41ai*\MjjW{N$:KρQsP`|cE'/2Z^ D7IŠՊ0P__Fl*Ur<e1v^)4[WIr3"SL%KM H:{ni0r:dn6")*HkxH$\`twcE O0dFTRt7JI#8nQjor??y?x$[AObEZCh"Lk֞vJf7:`}@}ژdS~],4XE]_}W~ލip~?~'Y֌-|VM i6o^3c1JAg'.8(1vzu+$ T@X}pih5L*N\L4?xirD~TePRT#D3' EE(`!b|J0Y0A(/bԌ≅ |z9Ѯu\F+-AEcſ:O?Z`iZ =n="-q!Rnujٖ*] GpHN輛$(@b.pYI{ ~ \֊r%цPBܝzo{ pgp,kVb*ia<(/4ʋ4]O>մ6GNp?yt ʽ_UFNaQ||_O kƪܷJ8 n~> HLqa!Xy9r|Ew"ڀ|b/dĶkOܵRC_S TmrIʴbYrb.8.lGp*c6VQNݫ()广D>${E.09v6&#)XNs~fwsFT =#RYlXo]:-qhgU-_1a~Xvl xFT>oڣ3@Col0-PN{,UT:'G4ս=K$eGR'߀Շw bߥC D|bKsfs4͞\2ht(*ȍm ["\`݁Ty} OuPۇ3xtI=^u =v ;;bc<,wğ)1:I6g5r=V C4MF%*D\Cx2+RVo|\~Ɖo/,o,`ehb<6}G($z^?*ߋU$DXE$ F.2V~gQc&">^u;6 ,i&|Wy:-R'mS]/#@ 8cixC%7`BD-Rt1f4ut"[T#/ɦ%?MIh8Mc D&.u0* Vz2Ph6T;8gg>6b#_|ft||HULYvd'uQ&@! &(\L-tO,˒nB^<*En(,iGTUX%0Rv4m5ݪC;QaD8`)qLo"rh|L.Z@yx* rt=,iFbf^v(t',4tRKjk>_|aӧl-jgzQMߥʾ!#5,|^v}8t @X<|zxфT)Jsn"űd&W3-^)== eȧԉ1~Nz8HC!x"cD"U")k\_l)7(]ԃ)S0A EEҒ޺Kc!`xUB_ I֡A]ex3kl>^Oi{z(00W%)2a@~a_|%N<浲VL֯ e{F7Z,PtݻKThUv=7l.A΍ y ilE$1n ZŸ"M&V __pe}q\I+ޓQ@_8GAth@S~̾ 0GيVT$ڐoIV9s;[ܛ?ZA᨞ƃŎob=ÎuD\K[Xx'Vx pֺ5{ $E,ZD#6ShtZo7k+aP !lYvٖ[ҟtPĭZxLxn ƉFfe['N%įC)L(1R.ܴ`7]e`Ar&Vi4TdUҵY‘z(JE77םrJ!fEMKdgCnc 6(:zU6u.ߴοM_OnI0 nL <`3Säq hvopD=tPaW5Yp!TWJcJڷaݭqIA+_1e32}4rkM QcY&5eQIm6p;%K5'4p% WU&Ҟ%+A,-% g$$=HI֠,vN(ɾBxuԺYƤxF?0@^4^ :51-?Nm."]iBe;yΗ*1ԈVxB `۳B׺*$ٯbfs3߸Ȗ@~O> ̍?)k3\Ҡ{qiLkva\Ʌd v}3i RQS&-3Q !1N"o_Np,,hOdCH;d4oIJ^)j~{46>] -0YOBk1a<L,N*ə.,¨q&Mzq@ 0/YuCj qӔ;5t[/"#Fzw TT+.m4Z#9I"J1JҳsX}BZ :z|`ALR@Uxs6H{[yo I-;ZUfT>MoR l VHS@6ɲݒ|"# k ix|Ƥy4N.hvR}s JcS p0G ۏH~D gR6ᩧJ~J+>fZ~SBgc}i %%th:]6o4X7aEڴ,Mߐ\iQ -N"b עxWWto/鰮T4 rƇ[|B\l@/I~B̾X>_ NHԘ]zi@y>ơ}~O!AA&A[ٯA}> wOmK*łe_c_Թ<ԯN;NC~rF}`M.&28v$r)HU+qvD7Z^OMNylqz??[W 5垾md'O;oYjQ85?PO,;;Q)F*,P6dbʅL+4ӜxoжֹZRP#FdvY䭤.#'Y!҉$ul}/MScvH-zM`enBöֳIIg8@2b}׏iqe*Er.^xx93:ۥR b$3;79]>%\R)[#=@D<djJрM,Aiuo{M2˞MCL|`hv1omX l,PoD'۔"SCDr|guˊ]8&|K;ImQ%<ˋyjʴYYFyț%Y86 "ʚL`biڳ uC钠hߋdخdνFTE>emYog|r1ؚdm2jG'd 5"2Ae˨- `LEWQOzmX(8Mڛ(֜ʉ{@ʙ` @kVmSPh\+c14Q_{l.k:kh#_/e=W{5l/_'M.omN<$zSvbZYx()=JQ0 ڊG(d.^?O7')xuByƾV͓Ьi0]Nǭ",)6j{ZN (U+LA]o"5zQ<{'Is\} y\UHM?5_B]͆d(X kk5NrH_RѴMdp:O$8Nf:񳙿ۑQDOPזoIB瘄Jjam9[X4h%O*ڲHU`$1@:Ip1@^ʹ.a +#*n)@-Zw|fF71਑WDhyLfցPD-`c cfh50{QLmP37*6: j, ;pChIF Ԯ8K89|ԊM0:ܕEzESltʈ6/LW7ڿdj`㉯[V T <҉gvkȼ25p$C:h"O'uz(pF?>Yvkx;ydLr+c6=M:Kd>%iԽP}|MV.bX=7ocO`{ 6Oi߯@~eL,Y=grH ? p}  *c&wK?GJkn]`kk)WJ!&$q1 tF޹Jpf_6B"@LL ɮӺFEli']gYצZI{U>J wm!&$ݾDxK$@;!ܖԎZ(6Aq'8koma _o:([m3Ђ_g]2~ ӽzՊR<~1~9 h^]n5W1wmII3^3 cev5~W~'EsKCK^PZQ|gJC%=  /锦4Et Yslړ[J6&vũPpM_}_ˊOS<ʝ+-t?_Ŝi0i;;\AX'rZA/Tr.\#jD]no;3_gUuu2Džqs㻘[ ztRt#ODMHυ/\i0ztlIhEc8'gsuLxlM'je(s9آ ER?GN}s.@I$UŷE@Td>|JrrhN !Qq%煻br[AqV'v)al\tn*=eb*Y"K /X2pNw;#WQ}^YYE=ĢM,g Aq,M wK] [w ϲRz.KbscrV)"td(e[YHB)dm(eo?pC+渾aߡq͉[oLFGƾ7٫v1ؕoy&&=^IO}nq0c,[ML )'d9A8nC[c{CUv4S2Sӫ@9aC)M{f q/Y,/ɷ]Rtsf?B3T>Wd89dk _¼eY]?(– $f-Rj3Nx?<;,L3?h ײehׁ8Ӵ ^DNBT:r>NDJ7T,)=EbC~* ,LMv4 xχ.aq(w2,ۃ҅Ո?M]6l*Hd##dy$KwK iWjWꔉ*ػ':bFvaTM\~ېB&0ۂGr3{>~Etl-m&6wm0Y[f.]VV%LM DJB2NW#֞uUdkb'A y:1q0ݺb'幑a,VVU.[_>AtG(b=a/qwIN]/T?^{GQWp&m#F[#X9׭uwQ </CK7O%YZd]P&=}ENdӄWi!|Gw),T\Rr;uȡߴ&R+[9NSfZf|E˩U LM8m[Aapu> f J%\vzsw;<+z{TLechF!,&LKgY.м w=H넻RND4 =d{.翺D!Z(<I[42T$vgxh u&-%]sUęC@Nw'=k{%!8 9ʾ,HibNUL!lj~_D(uב\RbHl}L31dP[27ҩVŴn칲َ=~7?F/ŌHqUJWP7|`YpJ Z!G˧2t"{ j Ҟt+uICMF۬b8 gkleiI'E[k:6k.36[ 0sNxt{wO±3Qq+`@o ʄ,Ff z fcͷMyFkϕ]Pw-׼2oᏴbaK{Ңyo]8\ bdx|sCՈ/r[(P%ıxi>C(bAO2X.=vly[/kݫRr(ek9U oуn|SI:w? (q RI{ e؎Q.A@5;wMIgG@S݄N譡sg1w"ȩ73ת]^<_|/OpYk6b;Kdm8]Ԍi w zUkOֽ 3Gc&?MIWМ҄$+iEـ98U3U]htUn椞8.sPf_G7.0T7 w">/@ Qr@< Z6o*ƺNɨx=18cUC?юFޞQ:u4F10\gV]`K.d '9վa;ƏnHe᰼Y_`zOw&>{[]t\?FpcqxR*'}߽OR:vh^?Cϔ5z:>RȺwߐi-% JCu4Ȣ+!@{ rke27U;C,5=$VCb4CSXTQ# kYO!p(}8a7\| ,8xw>eMmwALoI(D&k. ?ξnsEQ+,敓 uh'pecco=/-_Z^ ȗC;!O5fIqۂs}'*_Z Ŭ0tI'+EM8̻?S2Iө3ĹR'Y6/0${eI᳤tƆf,}܃11}L[ 2˂);6fErz'i=ڀ]dRpyLZ`]NXLs9 10&G%{}ݞ-v}Ӆ2}J=}rÍSʙ쳡!7$_i#B5^]GJX[D5޾$uџ8I"%ZS.[q+<>KwUb?ġtrB˹e\F#ёw#NA=ނ:wg15@~FŌ0x5ɫ;vd>lGŹE,";7e*<ޢKVsZtc<8F)rvf i_3yI' g}UcqBU|JzyPBىÏ 1ĆPWZvU)͂Kf*6CQd+Υ"3#ѳXJ۫1D 5>3 fqx2{ C ^%`v}n,MJn0Ҳc:&g`arljb0C>+1FX;uTI >0%Vv>Zj^1iSAZΫmRe')!>vDŽ?Еp^&`w^jqKGN ]{6|{-# -GS$isRvl^H*Ce j,1F+[{guXɫ|wKH7;jL,d[>Y-vN*|>[Cu }퍪Դ_7~" \yKGZDe! 7^ nU%`XJt {)MGCo%كH+Oݒa\ilhq&ۖ{R)TͿz)65dt:9p`G'CP(OV7 [D[vªTof|V !h @f;ߘhw[.UtZVG7;K|w|9>-N!NQϿuR bncGР{@wCـ!z6?^XhW ?QG*-X2|S-|8]):L/`jl3W{ۤJ_vq9(Q["O[zryTȭa'".|.O6;Lj <&74V_O*0d^ݡ -JOsÎNi,S8doQaQ5MK.Վ!2n@*M-HяiUsP r*b6W.Lg0HКz]:-ק4 $/tiIUBn|W4j ΃#á@3jd*˂Hh(C sW#FH|KI\V`nDw)'#ÇW: m5eBskNg_sDxW0ϼ- Hf>+DɎmlq'f.2γp]? bZ0` >R+"ey0i:R6K_j*!};e%YU%;2Q]s#6{ [~'n)Tݯgb2bs vp7e(<zR??N-ɲLG8 $y ׵%O~FCȠ`Y6WYuOQp6((|Ԑ6# +ϫ ^uHF &WKa^|bF*h3|EEIR)UUCh qHHP^%kIA qV9?Z0\KsJFG9`Íp:#DñV߀]yʨ5*z{EHǛe*8Ce b3:oNϘi\ө6z}Odh5]60cz]DSl~^7C ;6P nlh_S%%b2oH$QΏqsuIi5?KY#( c}ASSS9LL/8/S#$Y^UۿwhLYŨڭQ28EwY|D ¨V. )Eŭ)L>5gpa:]rET@ߘ{8 k`l|x|ws8H/I+=8jG4fD/=ůq7YtJojQ(%78cXn;*=g 'ȆG/`XAH!J|n|k5L, ^ S'rU{ 'b\ +"]]kqGKT Ջ#693K9Zǚ .?qq}ʓԒRv EP^eėLo0WgW ] qFGtL#<z&Tx2IRf,xyg+v{pHZE LjV덭{+k1TMBn IW~"ʼ\׈F JJVN\D8@Jrhp֞Ϥms+_\Ffdf1r$ :M\F(rBUހOy;u1ON<6{i0[;JʢkU$s|F_13,2 VR ?ټ T;dBaM4S흕B"q~Rw *'(SoDSscmf\ԸBpRU7p`)v˔DIfO[xᆨ$l=ɪ{2APw-uk35+-r\њzDg:(FA jiԊcmkt4F^2-Ҥ#p=BB#)DAp”_Rz_;$K$sP:¾( r&9\CޯRpN҄C0ơsv~@!Z)ZGA[g|ysv^ͧf/ЖKcw&@xМX 'zmna>1z|Se{OI;L0bƩtg%6k?$ކ_4bAD&ppkznPQTR=Pңet88[n)]>&˅<#[fEHy|z š|,ړo/3TռX!O^X))$wp/ ? oace3=p4:J$|;+0fIۧڣ7uzed7X)NLz)\J87Eo !y:)N6%,T8Gf{?cHhߐ[6xvz2;O}dY0K/ }Ԯ{&:&OP BH-l!1nߣG߿ABFu94XMz* }B<حӍ\]?ߖ`.hO:fuB2[H4'<%daTy BxD͍̓}/mk5V⢧>vffgna "U/iJ~p-]m?`9*r;qj՟jahfĝ)U+)f|ly94!E-r#k'I$IP};fzfʾRn,\,8TWR9L]b#c}[ ^/HkUΓ#huw.IilCƊ[`dOS@w4$o!W=h t{.U@${:@Cd!V伝M4rɽz}vW/*/>CdRAA;Q# F&f15rJ==$>q95Wf-ųb-^/b%my%(g\SěĎ QYIdbiՒB7EXnu(El#G@"ztNTz;gF}@mT*l{B nNu^T>r3R}GH}İ[l'sޓלͳRa["z`'[2jp;aYLjx J]}<+IGWoE"PL؎:6ܰ53x>+}->ͥ'D2,MTJ]hHA)!se%) k-O%{Ѭr 4L7to)b_pX: >;?IOfF*g+.)9"E5K;a޳¬!h3Z:SK}ioqBZ̿w(fF4Pny+D;+&?tXDbE}؁螳EKٲxY~jIOߖ>6_9YcU_q_8\V8:o;O/ƾYgzz6IP ֹ* Fz➴}CFmែan:[EUX*DhrY`Wyhؠq:6 49dm{YAU4#UnFq3R5?k˟ #`+,҈m*XjiplXJ\.i 9B!&[gt=_X`|eU`r7}]ɩ 93B>\PT4Йڸd\>4xzSWTM3YVHĮ" 9}%*ݫ풯}cxzs'df]\YISQ=3}erHGWOZ9mح2qG5 Eu-2݊ۓ *Bui+ =^ 連x/ܓGFYU?,r~8m  ղg %暨GlB!%39%//.Ge^yGuϼ8ʁ8h[ .BZBȄECM[uX=?VRgh&ox dXpCjEJzٶjKgQPBgA6T!!v@ڽ{g$| &Z?ԳgĐ<58J 0r2A۰B hhe23N[|:V+\Qw?6xYFG5L֎x[~K(Ji*%^ϟ`y+_nb2l=t?Z%]}CƇs EԯnQ%+-ȸԫ5a߭kBnI*l: By%KܖC+?=Q@hlj>Z25$^FgG<`y[flOwZxѩ|Cr1,KIzG2\]ϕ\st(9|)Jי"sch>i-AߋxXNa 9e^=N5[!Ί}T-\_qd$̎\%Ђ@%/  /޹1L%_[٥mVϟ@yi{2jnAj*b $\nd/'>` U5c=Yvŋ?[F""hWRmwIajXHl8kfԗ%Z*ڛ 藈g@8X'pQj Yf4[V3#𖉑'emjht%EF)pd4ę6 3c7Yor uXadftK}X(3ܨkrbs-MZ7Hi1-2]V ocPV;zZM0ĵ8+ obQU/~Twp@}݃`"ghv!qH"@ڍHj}4TXF_X e\nX`MPDdA2€d誏^ @m誑ܫQ|Q~Cj-~[m] %tF^5Չ%IGe_TEi,P:f7i2u,̩MS*yl{7r0a?4qp *E=)3a%+Lݵ'i4H.)[?~}qJDH*/}]!|bxC\/NMΘAA/{хR{2֓T {;ju4Llw [s2Ͻ!KV(3r,oI#ށ^yǮ3M`??4|vDװU|fUE*rjZ}v6(GKk\\LjQaS4kTef囻QX:#ezj%{V<Ჰ"]˸'&1ؙ^&d +=mYPH~*j*'LRE'|MRk#\bߘzV_\BJ rZc4p l^ep*n'ɕhQh1߱ȸ0)Xw']$~t`FS]UTnNb{"ŚR dm(`uO!)n)|M !=gG3`47}{xS;HNᣜ$+73rϴh=+ŽhA掉& }wQ'^uPt91s2cjV~2- 61WOθ`q]YE x=pj 썽<6JyT 5Mo@S̭?@iCjUP[ZD_g`z%s8Xa)sR94l*jM‘)k]"gUB2y8jJd\#;,\)֌KL%X:ʪ豮8c;@kЦi \mn 3ׅ`ć6A~bh㱻g~!ZWdd,ɗEs&&) "}͞!Y8X&駎-M;X8WO$)'Mw~Vիv"}d'#le;MS1$[?2317X?Kb;Vx6@n-޾N{K}Y4؋2i6c'+Sz(rr.kWygqx[EQÁ (Sl3I-ؽO.#`ڣ7\s1a]efQq#xr`)q4OτX}sm`mz&%AODq $I`γPf uTZP>%SlClO_f)MQ!GUؤbXxw99Oŀp`?<~=3S·in躍hЮEJƸܭm8n1c]hq9r^y p0Gs@4i8C1bs%gؘB @>~ ǵtuhqY= ^K@ٸPg]Ba6;#Gگ4ɬ/o3-9Dz$`EYkm`%+O gu%/F(tt|y` Ÿe"?^N1>ʵ0Ԝ ^AD6ɏ4⧃F KҖ-LL)Uk *LKaůF{V=|T6Z~KRKJP_՘WqS:b̑4TgLUM]x*'.O‡-eNh{I9Kuu`@~Q:E9d|ps>+wP{$?nզ|@*48y+z8t l E*sn&4fb}[Rw^GbѣMJR_T\ J7oGI0TdrEwC{X7Lkf-s='KILaG%y9p)Z&raRpF60d)Z e2žفvry_lʋ.J K*A3\|ɶ|G+QX&rm級FYA%qXm%%Ck[n4Ȍ=hb$RJC_'Pf Jh ߲pq,6T qb^E@j\Xyaq\ 9B @ƖBfn{OԼsx yEjO"2ofM.Fb=?/c}1,PH 66(HI ~ނࡦ5iNr]ڽ>UŅ>X]|SU@Nϕ,ɈR}Zm60~7.v4rN'Sc>|a1>dz}Kif٠6ߜRvV(fvwB6ƵӔڑkIw2U*?*$ŏ~Ru̽qzg`<|O  0@SAq˙^~垡pUE8jU2q{>lBa*%k֗+2 ULと^B~A(32tvA\l+ReܗWbBT@$rdăJ2n4cD"XOSouLTzTtyB+og^+F.^b*&'FK|[gh[c&ęA<> khggMDy؊@Ls 9teU&&]0ڦfUb8.{ݞB.GʬS@QPxyfXVT)2[A@WН}--;J.-XӼ )$ Ö͋Aycs +@b|YS3]I`tGLRO{T著x8}bC&nz:xo::9lhAT÷-г'˓ѾBC ׎oԍILV͗)@1[g8-Cr阚[9O-:<1֒THNtv ֟MP[ Ro`):}gQI>$KWKIɄ[v~4)#h"Gomrs3N_bWOa_̋7d+5jʻ_]t" rajJbbۀblp[I *YM:C g?`[f"pdQd P+^Xڛ'=+ȧE AS6.mH('naB 0v$=6 B utw:5?V@7FEЮ˴m)fVYsC\e-*S6vb!6eoeƪ$ Y|ZWRchfŞ8PS~!>ߊ5JN(T-?H!2{f2+"fϳ6a )$fh'Q+5wLG¶59ʕc;$i4Ⱥt.=}f鹒+,xr$dV]iE.<SQ*4-%ԧuÞ5*9va,IO_d$Pa4`9]Xٗmj V+4k#I$o hI>Cs6oCԆ gW񅓱1siM ' n'?/7Yr_ώ׵p) IP7!m{z\D#Jm:6W!eFof+}Z4=^5.ZHĹ|źsNpZB#;3DقAu9i3b^3RLיOqJ&+e @tCime.PAlߴ@ ڱv&ҫH-/{~JFޥN$e֌~.~~R+ ,(آ0wJh>=k$."6Ժc7g[緌LHX3DR $nykG*s O M~R;{wȢVuHdʖ40Rᢋf]ŌTh:m1l{P^Xc?;4#-'%hML+GB>J3TYNsiqĭN1?Bm{7n x@)|m T6ΖDh)D=)LeknH (7Œ4lWC[V`#-dJJ>Fx 3c,κF9B~29ma*KhXB2SP\ըI+@P!D/<)ٮnWEa%@Ѱ gK {ײqKWq["2WY-$dv%C:}'8RyIF*ء rH,w'y>e }'j'JR^M9]~&57QJ ^JG? )Cn E{VtcD6L7Ifem cmUGӵ t#R#V~;qaq8 =bqEym,NONrX!+[-FC[} &|J51l1yś PC _Ԙ]?ϲ&s:t?1wa 7{*=D:Ǭ\lʌv~ڞ҉aF,P=k U$@X^!bc,8'$IjT!d^mH'@nXm0pQ73z?K!#$.ѳKSu0d4_m[oPdJӅaEP4/ƓT ̭Gʔ`ꥧu%=Y:ʭa #z L:Pkt{)w=e;r yrEuQH[#}ՃU#he\:N^`b$g%6$ }uN^7͏ZBFyYABo,&2:!Z6IrL àx܅VQ&Z̍ZGGʪѣ_YSL <5JL7pq>|T54rso kIvюp(#c@fXҌ`~5һ%\^J$\+-xNfYe|y3!&8)sA[J.qv J,mR"Ũ'`/ůe>P)T6H7=^q1]4^A} 6 1W&Npf4k0QR\a=+# b^幉my): yT% qj7`Sc6ZfPr܀ogLq©KK lcsPgl-?ȉ',5ҐYV~2mcM(=B,#an I\wޢXٻޙfmGQU PZZ]=*v}+בx ;" 4Ǡ,noTg4Qb EۓsI)DWԲc-(*wi*"N0K.} X1t>񼻰!uHz\3nXΓ4rݓ8HSwWᴔryI[}nwZ 6xz O϶hV˲]c=hd{ R8#Z#Jp] 'nf1[wVI%+{ñʧ #'b@κ'.tW[i$G,I_PՊ hHK=A6gR@Tރ\dXȈ}bӕmsBm6*Y( <)He^"ii@{[Mcbzص,QӞk'Z&u<=!}:+j3?ナـP_xAp#OF wg pPWz%?X~(8 #6±qѲ5L3]KDaA]oG? # hN{Sm373✮9 EXTU(%\-m]t* h͊] Q"P̈6B qJWyV[!NTck:~ 1)kzjp@b2 pi*/.M1'UXі FE$DlʋkYZ %& =22@2Ͱ[A@.,+G!-?:s"xh{}xӃMtnh$KgGEp&ײTpTD8uzK%CƤ,D`FRhl\ Vjfa{yD͆>& (^jP,)dKwc 7 E5gqe>>xThcĤ ^ 4Jy9[ۊN쵚`eoE$CvAE᪜e$I ' z*Wf˵#_sl G^{6rIċ7n͓HrxЩv(^fo#YR=~w1vy5a2/cL+W_DO;~zr8ӡƧ:@-F#0ʯ2):MFU8w 6%2(f?mSD7y w?QKp(CP6+^IEQ+/}v ٲ͡E8]utӄ=1ޏ#Ti}:M@doQ}uOt\ {@Cqcè9/a $_1k M?}l,gkf]΍Ҹ{ юoH07 ղ*}/^Zà`!*дUY|N +?F w0^Dр/&]6 VCrH7WhL뉀*ۛg᪅cUi LOe޿y v[Cэn(3(ˆNpN*#|oED\: X3 x&TSN%T٬+1 _HT"R[ygY5DTitp jQKXC8Z \f<^`DsbF%IcT{z@^CMW.5}xƘ9VWcx$%aF qp #x IMB@wGT#W1!xR?0'"(CE^$Rg+D_5>>QeZlV'M<]'KUӶZږx+ͺ5v>Y&v<(mKNJ5Ab%Ve~ ^L`.6RReH#|-S:&τ9fnsnA D<-9ilGmFS֖~ȥ&[OffDxnmӬ u) 3!P8;Fay1TLD%ߝu1|ݢAoKy@ /xU%A abB}Wةe7KRFX% obņl rcNqE2=k"`32͏msO ݒq^U~%rKr"$7 5 C޲1s0YDW s:lg"ewp_mΥ~Xbg[*G5 PO{m8zWve}BfU`KzMi(.E;f!gUd}RIZI?z9_,0ьHG E"ǮKLa- Α.quhF<ՋGB?:eE4mb--•xNĔ붆?Fk{$RYH8=`S V7Qe O"| f ~,|X;(|g[@[ $6Z6N(v}v`ũ\(D˻^PPC:3 LO&?o@navL>p;>w_DS>ìhQW\7Q3 ~WN5:"e:7s ϻp:s* ] iޱ "xa*8BEH Z⿕63 0,աnAM+ncgK\XGӶJ׍3{QuNIy^UsQWS~<~$gj(ԫ ÐgYZPerl-APIReference-0.16/data/perlapi.5.18.0.pod.xz0000644000175000017500000020610412264521727017526 0ustar tseetsee7zXZִF!X䩔]c?V Or;6ǎ#x=j-CTx+'jj'UрP%p 'PQ\Yl]*({3#D` QYnA֌3)m(O0lgȾV>Ix2QŏnǾ8YioaRԽwC+9!74lH(*3q\.gfDfc&WdaU4-|CmnTsRFhɯ(}E Px)\[8ZAՅ?=4&k}!N.D]|MLB8Z)3l+Ni v U?CBbֺ qtzG.PPk'*A!érVqYdv|g=nҥ0PǬRC / p1ehs6fLظ_ M'V\jf31 uڧ =#4TMXrﮇ>&݇&[_z/x PϊxEj G~NGywu( `t -@V1vv^]vΫF@쾉.l.p'oٌ')_h}s򹴲3v#k88-)f~[l[9E2.ncDnZܙ9P?TIB{ypTxĵ\dlK=/ Uŀd tH()œ;=dm"4?KeG~Z}0QDXl +ozd o@9vvHr; 둧K,<)lGJ)،:;ZFĈ1}Bk` !sg,Q֊ 2:_NA1 $t+ 67Ap -3w+%|^$3&`q#ɦ鈋&i"2Ҟݟ7/T@Y޷-H蓼q1cKVU-I#]=KP&$"lxBh(%`HoiM$Rsnx EYq6E'یAR#*9cp,7#(. ߶{ 2J꿬sⅼ@oCsrl¼H@q\h@Ӯ7exNlQxM_YucY WH8M^]^_-rae*Oh+œiZJ חkUb$}x+_ֆg,0n >_BKw|1JzE1W=t8]}s^kd7*_GG@͇Tscwhmc !I⺽`g)˫[9=0JW$F 32ٿP#[]UJ뎃ӫND{{>jz%5w H34:/L]YHHmX: £Yy_J^LiF$ob{V + \h,ed&,-eR[{]v3dX  K +<aŻp LgGěT -wy<]:9+ ^wA9'5w^ s y;qhPwvSئ#N0[}ΥȳsKǃ['l1;~4|2pڠfm_q9? /#Ԭl~/Y,xe E,L 09SHd:Ή1iBw,Z;#DoY~*OqJ\**A@3M*s#s nVD#칺kGd]aټE׀W5diгc.љL_Tw*orp;(}v.7%xܠTAa'AwTH{<1q-D\!FE9&lipm&YJRZY^ c+[S }4VniS=a5B Sls}|VBnX1eڅq;puNdBOShI#xb_?s~$ "dO/ r?1_ұVuJ( +0!P>V߿z[DŽ"ߘ/>d-S}*{Ԥ>$P5`n-y8~10f8 #^TW+2%N+,h/SA7-"n/>lR5@A B FK%o{@r6^r.ۛE'2:mYmyk ij ʳZ=yMp(AZ)or OX ;ܤsVurn]r!uJ@Aܱ֩DU(YR@Vʴ5*< rk&c?RUS9@2/x].~wg \ӂmC3 p|ם-k]p-D<he4iAI'&UyڕáL6XVԮscf`hIZw|*<%";.i~ֆ!ha#gk}=atk.mzhƇ^́ٱT~Oy}h2oɍͤR"y_{25<\lK9gsOk4:04X)e"):stT«iƀ7,bƋl:m`ʘ%SQW >8ˆ\yR(j667XSǻJ/lY^ 4da`:29V0mBdx>Vg#Xp3'ŠCo̽-O'}tZK-i[C͊ 8UP pue-p 57m_-HV7l1pQ [BseP@d[mdiIK#gKh{A-"{$g`G4a2CZT@uH,ݴ)+/[%3=.NBr2埰 g76״667‚{| uɢPzjkQqf5 'a-5N5E*9Sl24~@x+ Rk9۵(MH?[y96H }ʑğI`)T_`kzkbmp)>2r"  * ˜z$O}Q:@7 P6li (c~?W' hb7wwSi,9&%4ۼ:gOlޢ@3̞!ʳ-/ J5m=3Sa HJD_5x㻏ybڴl,KqzqV`i*@֥PSA)zWC1DHZԹ$wK{z&\B4XNb/\mr)rװtT\~`f T`.săs+ 7S<Ho"ddZ2UDŽZ?"|iw +.4 eD->0s#~IE?~FI=2)'M8 qh;B_ V [29k Xk9 0GPBf*;!.VG!2zX'5pGE[7()PPP؂z0b4ٽUz7ȞgDA'Θw!^%#XI0­58\*̲H5Å?lG%uFAN{Pcn E3 9̳8y+ҙ2QQ ^'bP&UxB'a;`e$n55Ob4+-؀gU`s؈Ba{~H#݅x$z& qgw%R"[Ϯ@x^zHt,ZFDC29y3A6%Xk[+.8U&mJR>E]L0e>Ž-t" XH,bI}ud1dwCCZжgAׯܹC[YP4._UH*|T#o{r_%` "Ma]u}6-+Ơ /B:.M{, ̋"*0 3CAo$9 FkD[%U8]VšbU"†1/x\CU2&=p%ϚSwr Bwfmmrk*xzZOWv@nfuN#|gB#zzSg әtؚȑ]<vBOX|G2zb7V ^irqvX7=}$~11 .ccAj8PRtmQmRl Y3}ݦCtw=&'镻M%.LZ7_S(CL KyT; M&$^JϾ͍:0`L;@qSk`[쪆޺/s$Gfji*bCo$M\\šȃ7-mu{Â9gwRmȧ?Y9,&4϶X,4>LVXu -k|˥CQYdwm3ҘvŤȋ "e- c?i_B L{5hmxj>PA`؀;W(FюQdb{P_SƟP[k\N0]%R?XIP<"o8Ql,orB  P;nJiv%pvRsȁ P\&/] gk}jo;}oF$ ;(<@/*OM0ηt5%Tġ3KuYKh%u+o2 4*/I#F8⶗3UncZJg$'*@rPmLfRd$N1-_mx%S%4GbxPP u-$lp4jt ̗]*N0KĻNA=;nh糸l3:1څpm`/ņ5~#I PXMc 3A{,^ y̕Md{_P|fF79G|]yo?2#4mðE3WvchN:R$88RpJ6*vQ}5L}Pvxթ R\|E)on1o*2U(y㣟 #<s̒/t(g{tIOβ熻 ߦ=C/`B,X*'j*w(TLߏ7=Z/3"׾zUb9|zS9k݆%7'3(86#>4Jcԡ&5'В50%oc TWm4uQ4Q>wmF_-|Z9~BI6~mo1)ܴES&ܘ/$D]E1Ӳs#qc;SMxfiF)W%Sm"C=]=-(> F°k@82OqsVʾ& v(9@85.A gWXr u#͇W?o`ȝt@J>=~+¿hrƅ i f@\]g٠l%f{2SӜҎuXxc-w0ƺ+=ŴN53'm칽{{ԣYi>k/y^< ^YGJςqܨEFFS `y:(kPʜɅՅ0+tVaONdN L#D&SBWew賡4V]>ĿB08? ?6 We_1h.Q𨈇yU3\rJV{z."J#LVbK=AJ*$LTbg}8gB˽tVO;y6{ j3u9@HY/S*Ze,1=R؆ 43qtq4eЃ 5OH^͜3,-'izM/ r B5{HIK8Դ?"S!\#%\\VOmrzh.j mu&}inj=l.=WH;qxvN/=9/Հ=$fRxmP|wʃqE}*3w*@eRRa]@~F.O.?qV/Fvs#b^I%V_Ujh<0nYG;zlOޖ BZp]? ˣ(AEqz! QcAJiu !7KpOy m; x=zb%tȼtf5Z̥l ;c8V cxC?z㶒SuP^WxC^~I5c.6T=/"\*CuИV8 ha$&bKNU/`FBeۡe:_I=e6ѫt=3Di"~۟ ~!8B(9CNuH(/ҹmacخ .$"_lD}S.Z y2:JbD7/FR՛vu7#qY#Ƈ8=0Ok : ȍr\jNn,.)2#iZ2D_`&kkpIy!Hi 0&2𲢮edυ[Pèj_=[v.E4ps+M{Fo6P*SW5_Ț 7EV y!<  bVaO{ײƥLp93`Ԍ_E䥏%Ė?An/,\Dy[\,`6Iu+R1I*Gx fSF]%(dS3Hjέ0Z-ÑEw]1&0;#T<_֎z2o%R0T6kw1B}n!*1Pv}ZqfAIRHR%cz{Ɣy/Jq,ƊF 2 *C`JCɴK OUYdp8 65\k,Su˭+8ll\iJF ="8u5 49 콥ȴ X\Sm!Ks[D0%lhH/m ~Muv"\֜:Bel6Q)n_BکhHUy Vԧ%nkߠ_\ƐF6[c US&ȓU{F&SKzhS61s '7-2Eh6=ˌvǺ [Si!$?tT˺ҘMd;0Ӧ6[\. +qk1at~ϑ?GS 'Oxaa5dضrc##b08ڋݟ~O@ĨIGgSd@!LPDi;Sĺ#9/f `5ˬf)fʬ:ЏP|s,x`іNAt*M-/B 4\'$zb;-߇++S4$SW@@@o #H%Ȁfp6 JL.C/{^։)zY81o'J 5~03x=.c/k%٠=ߵ{FNOYV_ᵴ`h,]U D%zMzK㕝w -!#33(ZDXҨle 9s `e/bJo"̶H}Zl}ҐF\Oe$#ęOnݲmNCXNH]B eY#vb {ҧ'h.„%ݴ% zıpp/3xZJ<ˇ^*$w-QQ ; (jS\%&NSD@sNm?'\MMI\;qK_zQsʇYdݸt5t@HHfY& DU.8niC̓WMvPN6A%S a6VR)=/KL*x]0+6eby=]|qu=.㣿p0dzx=3wSԘ#6Y}[j F>W)H ϸ@Mi~aV=;mKDԪ:_ a-.{%E7B J U$:bYa6lMk%9h7? G7 WRi4f(tը#M`@9xӮX?S9v*t9ggUKIy| u*B.%b_W~\X=ETm=-; s f2McQ9=N =m،[FQff!AK)6#͓XDrxcJF ɉWs;'&$c^ > baq@*2CH CNCNznY3.+"iT2wL-(~(x7{DUVjoԕv6y rCWmn/IVAkFU 0\rOqh*# P?mɲ=w8/>0G2g,;9!_cɬxNG*7%o--Eݑ8z4ߝFmҷ}'/B$r$qRdǺs7@ﺱq ȊZj>5eƒq \Q~ﾨ\1ѪX٤-Ȑ^s\&T ,qU[mzݮş#ݚL+̡%Ls*FLL˞MHu:`";9R !i=h 7^"D7V"c*v%+q*#h bQ ~~Id鳐t@%]ͧiYbd.8=Fl*fszbMrʈf8j%x %g~_2m^;9 vy/ УhoϏQ.DѨ]9,!14X0é$M'p/<JcA ]Qo=eG?Yr(Ve'L@k[^MLuqo\X8?>{rѭ({޷$Y_PV9Vr4[# [9(5XKBҊw = x6 tg5fk <'*oC"nB [Ŭֽ>m<X).9H,8qGhL@>~aܝ);=aiX'CeSal1&~(ARbawa~}g K(]=pwi!uܵwZTlrXT;؟[poxk6ؚ`hJ_ W gT\U=`ʮK. 2:L6J/s|͙(׾;0Ð>NvA [7ex m-Mܩ#c8?} YqODoȮϥm|h5yt7}R~6 Z= .mw~ۭok' uOD^τ1b hFr}0yZ[mS*t]5a%x^5CMٽڒ=--1[dzvLv3n'PPP/jNE|fBA@)>^V&զhn"Z-! &dج)!ŨiioBC_MiUu!ԔRD!=`})w}=-j Ă)4=/XD\;ԠN4칲ƷDɰ; AWR}s2*ű޼Iz<͌<~df89 6y(8T7LUj때 z$WpIjQ& wl 0)\k.S VQ%h>Ju%?s yƲ*/yTOIX@B|Z:^Nsg<;f#+܈_(s zKjȗ-G3ӿ >2Rٓ)f j~ ^}@uw/ D~fYniȴcF>@q (? ow|S OT,mKzxj3m)Z9Pc=ct]&C@ppMMI.)ӄŚVcWzV8voQ5.FzH%RuBڍhoĵ$l96/R-pBd Q#\.'4Vsw`qSYrQv0~Łk{ddwO129'-3顭ꓲ˦m SZb+4d}ZҐ*菨t`񃙯V>r7b'|klyCyC<)~61C~=\EIփ}YDϨK;V)ӉW\)7鸸\&`#LKzCxsS-HD5jn #MO(ƅI,, Ug]ZR.q!G|ʥa=A]͟c(Tp ʴKBJeN51E99cm$PŮL~=jsb,.ؐIrC=_SUg>oȲ*[R:vOКRM^QMg X @TuEC8grJjG?fXyEnZL%zh<% wk65Q#bGLM&7cHLBEO+Wl&KGHbOhGFZ;m#)^.OSzPA9 fL$sx^ No6=JнlT*I<)ad"_Z__3ԤvhoH$~RI0ơŔJ*} 3 O?iɟYB0< KǪg_7d_f,ixb!3Me;`ja=n~כFXda oÏֆ"M(Y//.ӆ/W;}w ~Nߧ8! ¿ꢷu GP~]3]›ebiZfțb'3t'F1!4dN7cP@û6֊m8Fd\K|:ۀzfW? ~(Yñ2 ) nc# IF$TM'ˮz7#8QZSWecѯ3C=/z*IOXw0 N!9 ݵi Zgװ[R Rt %u` CjqL*f7Π8O fU l{LN͟"kG\;wCJpL`UIԡ,%E*:x5ysBz,ba0U}d?94Kn~ĴtwvQT9UG]>"&q8)@A!Kyc8gLmgtv/+ÀpZEܞkR# &#zh(gB?sNQ,ȳ9NI*jimX0??mQ874!yp`Vq7ĸb&قjc`n ᔤޛP/YX$ E@χtu1L19 [֨mjp|~+b8 mIԾ-(>28r쒤7_:IP(BW80 ."ڮT-~yDn._wxJZu RfD4k?pz+o6K;q75=ngfqIoi7;󢛡i-Si2&rp/\\2 z^yq ˣALG6ѵVͯ 6 F]O8싯gUV{ ڄ .mcK#éÖ,~ 'w1GGEzoTc+3zw %`_9uBPq^80 {J[5/_gW |27}ʒ`fu1(!qÕKѨJG{\$_ڊ6dOL93pT=[.;&LYS۷Q0BPKvh~u,XGrDrd|:ӟY5XwO4:ODÇ5dX{w{Y:CG)l# D 4c?& 0jHff_B!y>NLGhMss6;8ά ^ܸ/5Էpoo;K=b:K ߯`'6?1pGڇ+̆ty=v+fr1suǃc K'5\&a-|F3dj@w\`(&&ϋ,6`_1El2/xh]b@1{`2x-'d6Jt4W n9N4 Ҡ58ۭ6[y>vhOnp=yfI,.|mo&cWRVd>jQ4iݣ 3Z[AIh>Lqk^_jtGELoл3w`qZIN\Y)I[ǖ誐J*F*`Do||h1v<`~RעSTg3dגJ)MP?6A|F5b.9-2jHV{5 *.Dp2]rL#AOԖL~_1$rWrH10_轼a`&pjZv&_=}vR[`# +IyƚӓY&lm{jOBu)O2}?\2LzWMh5[~ރ6yG=n1"#L\(T}XA"\#]Ɗ u'^J*Z4ŸD|b}%w<[ݙ_䭯VsXMS]7ƅ2{T"jqjjx_a:7x'IJ~ B]8'PUt%(m}N 15_8fDR 5,) jro5) R+nFPLjmF LP`񃰂q0y{'MpIAa&AՃjDNb UVuN+{m`2Cw[vh5[3yfx5>nh}{PšNCԫ@KFJ΀FІ^uhUg?zUzYitw&MZ=o+Z3nwYQYL*ыF'6{e/Ƌ}`^=``U@m P` QF@$f|t=+<.j5 zRF{~rkռ.^<8mϳk7ᇊ;-*{~Xҋ=cklj]V=cYeGIVxu W< G<&ɐ@'8 hEҬ͂8 628H˻aG_d^}6zܲIlxmxjeg:^?fWdU|XG^hZ=ha1ݩ\Q;\>vh_roFk8RRV F`]^MFf3;2uJ^ w,;z|8erYqm JKfecM~3ܓߌqx}3hg?5}S17uRS:3!#JXϓ*Z=`VAi&"t~n6pJh/LClmX*Ǒ-c:vz sF8cs|<壦})kҬdב RΉ#AImnP6ҁ{!WM2pk };ЙåMicvnװ!vXppIw RVci>:&wyȖ)e1f3ZU'T}}v2^??26!2F E}[LVHoFmEmPϛC_8.$"0? ]`# A۪ -˺z-@D6 8/LU:+yo*UBh:^rȳ'ԫE-tr͠Ht$PPc|R Vca1N6\ t@G(X4uWeNw6 ῝EB \iltsҧrr4$~ZKBw.Ry3tQaٱcGkBfUv,ѳA`\))eU]mR݅8-m8= <[{ɉ Q$p* w-^Kc: 19g¶918v8\c"׏+4V_JF+䊓k?$hwM nS! ^[KK1RjXDyGȑyuY̷ݵ'D h '&,C8#Iqχh< C@|=s-[E'dT收2c%f19+t":fN2'dAŀSof?UKKj _IP qzFy&mo~uWcBQ:(ݠS<51/D1%A\(ђ]l¹__ɦB/Ɋʦej~y@__.Ɣp-%19f7X/a_~SuܸG SwZ9bKxj: CG(Mv.nfӒ7pot-_ZEI M3*HD9u\6Q "4#Y\.IMޡ ,B NIZ"ejajrd3AËc憎<@t9FNmZ6횺g|l+ KI`ʬ@Rp&KK,QuAqd7hT"d #[@ClCxvp<ݍ.pz|=G|*9`6CJ7\{D#Dx`.ٶO*oVӸ? QXkD pvŎ!:&OfxkyFvҼa1h9'BFu7R^%n< Kfy{[5 }:WasxHDS`[@T)SnZ3oe6 ;WvfT|L>7&~ƉK Ɯ*q`Bn< an%EΆJ:j_cFcUT{YWLI؜$dK=`؃uķ^jqw ܽݭr-"`Ud73ɝ' ;9 .TLd~3@$7P-ٝ@%썱F"U֥=V<ʉ~ 4f^|#Krpn?\+C1"in 'KI+ױS/s=={8|f:/&OքHsb !ĴSU-*#_v,9dƈʞG ~LAQql5Eg3i}|reG.E 8i xw!fqT& 1iXRIE߆ze%zfG2{X¤k#kU<< .Gς~80kqM@)VCdW(:)צoxp)u1F1݇d@PH1Obb3I/YdAWSG5I:G*ID ^t&6o°pdPFg,_#CH(s8Jɣc.4z5M*oG !`܁Fm nv0o|P?c(`"GïޓvO SB mwfykU#U\\;X&krbdYKvg٪U$K] 0, YWXQ09, rH-c"/7Kq&8r[qfog8g#0SӚΗu׬3DaWCսY߹=bIsV\fۋMR1d ֧&8Uխn>%X`y sc< Uzc"a ,.E Ӯx.7SW)iDRBb}kҿ@Ka &K92Q,UZw Y\8:Y}wXEϓqu.#vg}q\U>8<8jmi ;j<^T1B| ?ѭ,qGIRT(?B9.dŝ)yj6;˿>z @t)EpHt]XIjo@2פ ,f֛"'}Å y\.Dp0 ,HaTVjBn- HVLF&Q3)Atg4l[I"UOhl-aN n 9DԦyX]AVaps s>{?g/>Z7<:Y*..ua1*9lǜ2 1#mY4ǼPRgĈMg$rքC'6PYh]~F?+ f>3aF" 2{[SހtПހӞ2=:kPE&#`dnJfexj `^Mؤ$l,yqHa&ޡJ]KL(D 2D5 :ς ",^M\YŵbFt",*6J^vL gQhOA*,j5VOo$شیeUǫ|/4jAlu1So2ACf=!o:xg [R{l[lM78gqeRx]3ė2ԫ2!޷-G) ]w?|\Cssi Մ"޳L+F=lK!jq}W"j% L3@:1Dè3p~YyR Zg'k«LfCܨys>~<t.}Ե[=F `)ƒ4$Á#+(Ǥ ̎G{K,D" "|١Dʗxn˼svI ~D2'oV"wiPBai7,hV HZ" zÄ}ܸU`FK^bZH/kJ%r04R7Εt1՘(0,sjs d7tK|4m*N;N ^/22$E0(keo'͔%`ܯL(lуC}Yh7H9dfp%G~ꑩ}k÷W~"ؤ.ļ?N=tsƥH { ]q!@aZBA !t'ffN;[vYX.k=ofVP\nBrub`]$lՀ|;ewqN@= +tge(j5)Ce6؇ߢBL\Da4x zqr\sMS$Hq#Kh*Q]yyVY .IĉbytE?= GM@^F32CeӢ \]vޝX%\{Ղ͊i-s" .G/cUՄP+(H0 ]j7+  b;Ad{y_hTU*%62!26 bשha8 xr_çb9+2ʇ oނ'g9FCdsw-IXI'=YVëjYhzcE&Q"VIJME emX.x;ș&sW>ca y+/6lȐϦL,(s-s ^}/SK𾒗LE6~Sxcc戚2 Ѹrf $j>f5)Th񦕇_6  ګmM3~r]}O*C.nX: |Q3L:JvVfNY g<w-zŭ!ۍxKӧɽ)J1PC9^~Ҥbu~5gu s,8j,# Zt)?Xq0x2asj;i@K{99)>J:ieʋy*=!V]e6M.2㝐zmpX=8@GGّ|wIGfg5= G_Ê8:|rJ?cJj\lM:5 eG)Po\WC-? ZB˻$)CU{s\Ui/AY1Eؙ+@<ş\c3fX&qL;!be`y b8לN_< 9{˅|}V`)Cz 5Y1V-; ]iWOI&Ry;v_Hl)#k\FCw;?ftWJ#}FNi`(?)b^S, ݙPL{n ^c%pj4 qҢDns~[-IҦA۾AaZ>eТҴa|aLKXueDRJ!D-WL:p_n_ϢIWmig8MNNjƻ*9K6a4rdd(wYd4mp%(+ؓ=NHyG4mittmat+mRWO~|a˓&C,ɣJt2JzAUrFEOw.G1~mNRLXS\$q# 3ҌAp$D{@r/ 5WuY ?Nj!dM#g0)X3gcEkB RBk*(3p YM5cL>N}?hdB}p-((s6@g+eS%EQIA!0]LLaq%JH_؉|^veKeH"fScLg-^h&eHNȔIf쏸ւ Z Hy|O{>aˋiq8[W:7S[9JyQ|)srԩ),,Jv$[T8ZL>]uJoDzTycAsק B!×Y]_߁xA>m{hZ݈ ٪,e&hx G` y!wVcY;E?OF{; Y15~Z*%ԝż[\0V|RfŎDx4=@.YTM 'W1$M*&P)Cszc# ~}um!KD1Π7pa}yڧׯ{;%qHFpkbK(ߌY2gujwWY^R{H7(%:mte04AR\(𔗾=Kou[8RyּZny1}I5r02. 5s4cg cM gy󭴖U7 ]G l{~;l ˘|AT ]3 NC@`U8BX=52cas+||BxHPM9k Gd nfWT}FtTz=&-嗚q7Áy: >$"iϞ5v: >.rJc\CJ"dDL7T[-頺.% ]~"؁Bm<ݩ=  $'􄎞SER.DBVlHK 8 vԱ \)OcF-Cz_Jo6uqB(XCՌdKOZ{_ 4qpZ&̦& #D>g3Jsl7^/Uـt /a'WlUOSd MU@> K s%ukM)j׫~AV{ "bݡy)qIf{OrRn8{ ap_t$9= v/v\@ߔ#CVHR6X_q ׆W"q61qjZ>!G4654mNF sC ek#txg1H33ݒ'ۙX:\_8^)crSخu87qx=H2Uƣ {c*sM85IOQOM!Jw={] < @)BsUyOh حe F9D&wTq!CUZ+jD۸ ["Nܪt9>w=G<,*:`F|z1<hFS7Υ`nE; -~c:;{OKmjINF=?}a͕.=x1"DT6Ēޘ5&+`x$}"#; rR9b/} D)H}0GFr#:̰? T+ؗ[KXAUSIcX~KVU?7AAG|p9$cj7kR̿aG/ڪ{:}^'G:襬 b~Red#%\T3^ñѫwl\ߖ?q޲Q~M>n,^] `N/,4~7V,B5wrƧIw=̓5%>zL:W,C\˻ܡaz4V _ƐjmtCTn!߰2>7"QS+W OJNnpS`Ƽ`~1eIrhp\?Rj>mV%'*d}W{DŇtFb }$^ˣZcHi)Vq@pR6#梓_kP//"ܢfV̓)dqAKiaK^S,Y&M撡5QpzEBeNWtYHpN ,g׸tǍf}k~qF}|[4| أL<{@xdޡ Aqv|;k$c };&r~{1sT+0{ϖJjf@6uo5 Rop5a_k-%8L_(-\_(R4[MբuLuRdNJc*E2l f搋n'-a`I~aKߪ^pӮɌ37t_&(bz{cL>)N$'hjXKl[x Wl02)%4f܇߫e~;e0W& 5{3~;)UN :T.̣G" (miDЎiC"RF>G庞a;mطәL!K. p"C?fC44ؚ DdH-Vig#u8Q+rbBpX0ep[.Pw='E:H nUO,(FXGEҋ, Y;p{/y-=.lcTd4Yzh( &T@7?ل 3 cSXq?Ҽ7C qa* FѬ-x:4*VHlfx5,(dHIN`1,:B$,\/KY .y# _ TTŗD9djmnBm\J#уK{5Z]*+ϐsQBhv;J"Oˆ(_kHX/qtX4ZO<,s~Q=lcddJ4lX%٨^ME]Srlm6qD}t-V/>t>rWL&[z㒸_d۬0L! Ñ!*wmFꎘ(Ka@(σH(-i y K"@kӽ{,uN~nwlnC1[ˢcqM߁ⱴiЍ!i.VT8 ^W뚐JB^GN9L^q䬃횳'0e&Q6=&rGQ$9]7m%T27k~=Z1=}t}ɑ6L5vH)]Wd3KWؔ MAxzq<:o8w(xq;喀ގ;y1fϬ4Q?*D Ib[ Jy~ÖoTlx<zua{ɜ):mYJά-Ch7|XnG42CF L0ϞђP k2| 9 ;#ؙ}'Vb+-e)H->8?F)8I )FM;9SLlpGpwi.(@-3b2Rvמe \ [dž+9\/b!4a/oq('7g$?$U&Q'ò?:1@LK(^S?X IP(-b/@!}tr!@UW[es{B|u>FۤD1vEOLo&w_|R a6$ޝѮ6W >>d[;u'6VjK;,y%0/r'.(tF%H.wf#.]jad_v,18qOjS5i56ծT.M;2zͲp| Ds-h42r1du*YmFEM2p) 'h۩sXRC) *;,XP+~{]-R ]$΢qtr:ĐLE#@9D>ʕ݇KTgPt :;OH}6"f.&wEWTtN{?26zIuG]eOjx|`c?P?mePT MS.?jaUi8p$+-g*2#Ҕ շ4<*~䯧w-]{YS?Wj֎x7ELJ'&L{QAEsR&d.hhh\ZKV"{/Oc +Fw֩ž lWmbu36Pz\eBf"xU DX6,ۀkH"u`&N7: pCs$I$m dv\xRx58Fjxj_֙nܬm5\:X3xKOarBe6`sB$ǎ}n[d5J- MJ\O5f.S}#R*!u+->G 5"peAiBpA]eO| 5KȳϜ$Nb/r)#@#pDMd):]:PQv ֮2oXb* #gJ$:;վetZ T@`~Á+X'Hʻ1%fX(&W=yZ%7g&{ 7dÍikגR+l0OTiuF:]( Ԩ">OH~ߞp.h컓qpB^7ڼj䥄`@" |Jw^K]!hDMu*h r|xbe5]a=|drȫxMDB݅P5wNc))]٦E>ET]le`WS.HLJFl&w[ _ Dώ#n /W =B˽xjN1'O( #Zg΃51rLKk7=y~ ]~ :|hj޽dW^ͳGؕ!gFڂ.w)4_1f! cHA n RysΛ=p\_X[ĩK>@%(x/ )[m kBE6m Vz+m4eRNAn`3 N[Nqڈ3>M.\C3 {uzKVHTD6LEg0'Du%>2#OΩ[E>6w}M|p>amGg~-Lm.78xZ K[M^h|>F|YvHCղ=7Nݱmx1hD+LT[~'6KFlU R0C ,[>J66T~|,3L~N& FFEt?aLcYv:щ,36bA|IÅ"$U*7AY}iP*l xFm4@ι1.Kq':#Alk#U9b{35]wPcj/HS1F~dJ'0+iq4YapҔhL2Tţ9))3re;)݋ U^,{yČuE| pvҵIq1]QfaIS#c(QcK"}zv_M(jykXLĜ1M-~"(py9_?6+_(k4atKgQnV]$ivZdZ:Ix9 SW(]B.9LLILy!{cڱoVD+9ژm1XPExϗ1 wsh >*BmNj_Y4ͻ ' чE8vK/lF+ 6ewL HHq!FKb}꘩R|.˼]WdN\|^JXh1bZ`l'@nPvqO7M3lB8h\~[AwQm\Å%( R<ϊw`VQ א}&hDOzMX&2aLPy!LJП:q$T':]J#1Q w׉Mvjo_moΡ=S/nK)OEbmcyVtKu'5]] @/t>"P[wZ\^3 ?$Ӭ#2T9k8)yb=2:j3%rTBI`oAH73igW*.Aـ6"MPQQ]7 ǁ!dJq-5Xѥ#U iL+FTθ1SDгH5k @l@EYܶ*F}|P$*Peց>bǍ̜!p/JYfJ4'9Ee4H~i LB:ˍh ^DaEmH9O7gRɓ,?AqLR[hpX!pBäA9+~Ӿj ݏ7P:Ch,Τ;48L&TQŀ\5rW-]aJ2Hol745\GPn(}6xN)#-N7(AH{5Yj`;-Ae}Di۽Ogve&UCoGQZrĢЉ\i3„oZ N:\8S%"z*#L'UpH?GCtfA.0%X[`Q8 {Gn6 \l14 i`yEcŏnb?[RI}-Bj_ jK}/O3)E;TߏlI;)ha|"1z>RE9;0 aLKap٧gHs0/Fy˞†1;7L \ݭw@|f qgz[V R HimUbi~ژn+U2rZPplIK1<0a6aj/pPQ}291ŵDžJ-P2i+#(BMW0( SшA.k1ZM*@"~>-íؕɍRZViCh \PU( #!|"C r lՄE/Rqjpm(_-\'̄9ݰ'wĩĪ%'&qIR4zHq@xSbPf D,AZ3k"44Jf Y]$ }6P,ygIhZ7B .Л M}$3C1MK'FcStE>IX/ݪgs$l@FC0/"yﶜh;#=isύDnB_z{kGIF7F.`q(5 ]VԋWV<ו ?bmN .Koc 'aruxkJWDݎ%Z+ ̚ϣ; 2n~r$uڤj ,,C6aoTgj{Z1_(xZpe&/:tp*'W+֞4 Ӣ )+V-Æ^CVps1Hw0a)"Z\wJ/GQ2ef"wv{v\|cnE:񶩔ٍp rlx51oU!ct-#7pB$DHvsidoYP^k3%Cbv_o>u;O*1 gY-Z]`3)!Pe _[-i"P7T;FENEXw iUJG:"g@C# )_J<~;bFWyt-/#""D0n1Zbύ^6'h&A@ɶL;Y[FX-n=M`[7RkUb k;kkgbⅺ)utV2P `]6TN3AO3 l͠^ds;b1jF)-;+p[.~ʅ(zؽIs|aTH]8rMH>ULdp,dv4zȱs,/;6k1 / ,gb 3`ҰEtƁjP-" ,:7`aP2$ڭJ_톬y㈆w;tLu7$>-b*utXɞ~T4!mzצ}˲d['(xKwJ\I:S6>ў`+ 8IerKDRql jb ɿɮ2Tw~!5Ȱ`!Ui{-=&^ojqV1tO„sE*c~?*&t(iwQM-&tVI=dP_ĉP2/p(ꡢ8/Yq0A5XVa!Ue?QQZ`zVA?5zO$}X1xVܔUc͐ZʯFS iI6FڧI4`x}Í3l!6dp!IXnk+ڈ#f'!iٱmMǍiZ}ƒJRCo>R'9\ƱK@\DX$-po/2>nͯ~tX{J҈A4L[\?q)߿ #w\|%.$ 9S×CD"qH`ed8qAGL/Y<ؤL_23x@|W&9+|Qfm,I*Brd6O+r1KY&])(sUs8'*L֕yhiAP7Zt渁ad,O$B wvDjOq=:f¼48'`s\.+I98Lw^)I%w^:_}]V" .@A!6?WdqI¤Ί* `J❢Y[9d䍸q%Ie|^z,u5-jPQCՙIC#.8;Jr*Vo}c)!;kv+oF*G,\@ۼWV~V7LXUK JKزg2013*~^>9r"˸!`!wP=׈Ҝte%f 0F<:={$޲ 3N:Ha~qm9Y( T,Ĕԉc{")˱H=6J|ҤvOc eo"lKA}2n\&r3+T!N$ˈHSС xj>\o/ 81zhY/F=z-cCI svXbFHu?CK^(_IW#G؏{Yyg_o/m,GL8bO1ˇ \֯:ScM߃ze[+2whzN@Ic|0a[Fܞ;&zSzuB tu,^+T;'Q,3:B|Ŭ)(ycM 0I_umP&Bլ2uozP4Ԣ?1F,NҋP*L63 T3Hҵ+WTŨ=VM67S~BP9e7zRH;3d9-RߓPԤ2GǩfdX!6Bo w7Q?g=NWʈ@\u{&0|#-y`0,wVUs/K#NĊ|o+fY^C?%*>EL@(%bwpk'ԨWz{}+Å,usUmD X99޻3LZN:8L>^Cw ;Cx '&Զkz]| Um.בwc$t% LY$`$ij@PԬ_ą; 3|o.`ٔsD`(%#Xݲ_+ X|%缴)' UΏ9S6n?ъo"ՄKt9vb%l`.Y\}[ϢD6ܞ؉^sg" R%ů$o]Rf$bD/uGWtˆe׽|'?aM,9E,@ߔ8x<;9;_4ݰcYA$atDG=AڙLuj7ffT|`*7噈r՟=WKwҔ73J)1Z=I._N %:g+kboF> < -)K 2ȹ`TBͱաOv_gb%), q؉~ACr)̣]O]%3IM"bh#zj/]T^,YZ]p!&)6̝G$Mo`A~/蜎ޔ`Aհ̷BԖo,221 uvS˥'0rֵzf38i=4 ֵsph[~*'n!9ф9˚ pBYzq'4jEMsV?MES3-!1Eן8(FoR"$ Ƅ/jLާ9p``)9%.ӆJ7e|aU5C+nvǬݝ1ze/J| ]K)ziuל1{F%޻f&MBi7[iYv1= X yH;kV"^0Aڐ‚AJI:ax GڧY=) 59۝4͒*\Jp׵ _P]U ~IŻ)?N+Q4]δIx [9ekؒM(X0$HS5GQrJo4LKӿȢxC^Rcdo'!}Pܜ>$F@U}U32{\D{p:.4~u47uµ47Q Rb-Sc7)=]Ӊ_p]ax%XMӄ߁ps)AȆP !rSxt!}zE_w"}x@= ~~ٛ.}L5@?a!bw쯛Vf .Oc]g{/xcV:tY q5iFg"=[8%Cq09-6 e n0G~CZ=N#Dc<3$JǢdsWy pwvimS}\^C /xl>*wդĦan7)GJ .@:4`~b,.Ļ2+I^MVReWxSuC,ӢOzZzY<2ن""Ev &.Er*x=N5U]rrX#+$(C*CLdܖ@-]>pA+2.WXnyN?^}gVi1LfPjSYdb=m=熉9w*kQVP}[+0LVKP · - ,]}"8vǑne=9_蝀r)ƛRQwV1^eE>!W:&.) c~>?ŝ^_;ؐagGWnmIC Sd^5dН[,R 9͊ƚo(el/~]o%bA?CɁFAcL9E$:=㔑\V!W `i$31ZWޏ0͘!7Tcl.pWIL7JBPî!iuLQ J7IJ,QLj$k HC47 2橠4Np\ qٲY3a87,gX95{M }.E-YzR^BIN ,LH08cG2:#JQ;%H{-ydk*B= ltP LjDT$vj럯jiji yjX?+5Ů(C %b.h[`Y/Qk&>]ފ{= /]Ŏh,;R|U#!r01n":&Wi2j%KuF3[\*+ny{!b,\~R9 aTزy-ʗ4u&թL"y g1)Mrm((n.fԈ ~~YF֡??xXj7!ig"[pO#kܙ)g·M6/$"zvם-n˛B\l! K{nHi=D^2#cl`fsyG{yy~_C QѻߪXKJ A芾 2%@)\s"kaI"nc[Y8UBs,uZكC^\]drH&S>ooޣd ]18VaX6Ҙ $[Ix[m"e(oLX G#[>(}`K`9Uǡ46|#- eZ"KᛙM4g=fg27S>,?5tBHrfVYN؉*(LS|fEOjE–+Υj6u>ѶRfw~"_u@ܱhu[ȋN_)8?,rv8wɒ|מ՝*~jQ2vdFix`L/ᶒOܘzBi{ R}0"4FI` ΘgGW> 'ԫ!]x$㷊2ɞnǕ=lFɩ*ook@B|(Q8B*'=m>VS>k?،wz(!0oO_)#}R3|35D|;b~wީBJ03m݃K ɨR扺r%^fqQYOI+4a-7YXS\/7}<)_6GoJʿ7+I_!#82%Ug)JCvґ1tZ(|{h.^yrwoE߯d{hAϑ rm+k9Yy:WM2Шz})]vGЭ72l^#;(FI#˶%hD%CGhfVoD!K`UYɫ9Pt.O=okEbIㄕ˶C a?ŰS 8?>ab*(ݤ<ᅗr @ #셨 5(Jq)-Wҵ^jƿfX_Zwu8& jx ;Ix*׻I]ddC|~1Fhg[(`:|WRoFVr/+19hB/"_c/8;~7,ϦQ? &x#?6ANx>܂Z( % ;'?]%T8 W_iJ@l(|J*A]l̔a5u\oxr&d.A+zxnið>r@Kׁg8tfx"=:0]:ak}VF(4t)j̙U؇-IeZSáqlf hg n\~zm8"U(8E_R:|&3.5j-UYgx# bteB M`CoF&/6ʤ uB_)3Yxw oUQPif ȕn%+ܯ} UMϪsM)V3 s٭ y 9WliAJ_,8*:5E0 KхJ;%<GnWȚovK9xwsI˃<8U+t3PX= #KRa-b7<3e{ M .#B?:8 9GQUB1bT'-Тr+FX"ෛ{ $w8Wz,Dg[hwmI*9 x处C鏌3IoExbз8ݨӰm b+vd3 ڣK89$!Ӏpr-: zB땭x S:?CSR9irPA bG3_CIn~0}cz7Q6գGZ2^k'Vu6[~&< HpUk(I"cS})nN}6*]gC{::qh GK0. M9WÈOPjINK @~rr.yĝ`7ib˼ES|5]򽒎8UW2˯K,w]_>#LC|Ӝ1-o硯Pѳ%/aTa[vS9avZ}#-cDޒͿ]Ḣ`Sab52=$_ےxFLj0Z<2|YCXk"{Bׄw;6&)9fO`n"??ՐeZ>u_s"w##1޸i1-qle k$eڠ(S^xfcX韚ZWZ3(uDQƐ?Au9M@KK8jee5zhkEuIU_h r]BH|B6/%S]KlxdS;(T vi/OJ')@UAn+K &$gTi%52xk>Ֆ4L/T"DǙoL`j} teϽ0D_Bړ\ƽn3P*Ox2mKhZ`uZD| $ԚC.YN}iI,LE ' S/v%&A}x|ɅbrHMߞXm}xSTL Iʘ?;KE00S}}NrN嬯~ &LvMg^ )N[#C.u( xFyYufw̃EgM!ebj4Oo3d@PEZD~; {k\EX[K{̷yW> %^\V@SvVDeL"*~p[nrR;l/+A鿢Q`zq`5OY=y;`Ԟ3R_>u`# I{Ŀ}e} z?^6  A|#Vh,D7ryJ̀C߱I}EoA o f$cGqqm~UH"C&t:%?]mh=TQx%b/ tyHTC̋*=y>̜DG{ɸ'~YbzE= Xܧ!@6+ Ol^ Zӥ +3VТn*؋.Ѱ‚ʿFj` UvY1 "H#& z𔴐*3 mݽ*Æyi`T-H-)Kk|\/WEC)c%&]Jؔ[Ġ6Œh/-#Fm5oaSό.vߪ-i*RY|dq{&V<+>3_6LjOo }"= mR#KE+6q޷ߤB|KR?iQ*Ǒm+[J؅vs/HmĞMVXa6PuZױ@ Q8v aWtIvsˆ<5^he}*'۔B QIvZ@4*-_ʞz.O Hڠ.q_iF<-9ө^ t8Ϛ%>U" X%zU?(b/.e@=0'dQ'GC{~猎 Gff 4 缛YBMRwg.H&';+{x *0V;v&^C4:Vd啍kJuRJ|tF"!v5mA͒+5U 3QGҰܨ.<ʶޙ?;=r~i`9] <\odŎC{r/ù O#л+ '͑ޜB`>Jj.+i-S;hym'+С>+yf/fEQ2&e*4g:e{OP&!K:uZ(@^8v@3 ݖw9鴚3ND+^dX?ˇi^4yN.= ҀQE/b/rS١Yz٨Vi!cK߫8l2J\QQNpC1_VBL*,P W:acH(*h/&aQt&x )82{lu‰ eqp{؉E*˷DǞNtER/9Ƕ5C dD yFd6~d? K[zBV?K\l\IK?_l[6XTw#7`AU>P\A#՝ǪBdaȮClXʾڕAqp/bq}I>jZg9 -Sj9jS\^Q/}uS=~E]]eUיqCVoW;7n&A!KP8 Rq?l A>brbv%W؋4?Ro{׋x\,6:Nӹr[ˡ!#+"u)r(E/ycA|PРT7uN?JsD>v:֐eT^+C.XRY791HTz1qb^e-/eh,ЬgQ7vrV5iG&ބ@L#_*vC\T0,n{A'xEuzQ4%K!؄Ewm`sz,f]I`J)+0=gMApT,ܯpbɳ{RHLi<P;[悺7>8ѿqjrΆ&ueqV@5aeml6 *$M>kJ({7DI(-9e j֐ĭJw1,ƻ1ᒬ#V␣wyʫFuBf&{YqwG60B6mlN<88,*Yj*d'U4xԲ[LoUpc>9An7?2.~M@,dc"75NS$wÿ"ò'0zg}*of&o[AnF oj?X#NTy ] 5W]H% Czj&ЁggAZ۲o mt> |zwJƘ/*$F : D*#O jrl0 [90ԥ-hO>HA?[W y'gMn&-⪁Wwֿ]V7uwܛ] u\f_3z*֍a=ks)տJ]ϋ8}:b(|EgƑ{NDӡ\0@R-vQ0(Dʸ޶zz<.=DsN'خt!F vHzZ$d2ɕ8"Ws:Mh A(Cz;͸\Eb\z]BDfd uybGe"667ʜ7x+[C*L{펶d6I*MS'wq rQjARѷg9ס-e ?֧0mb@e.\Xecje (rL07aJGQI<Ϫʕ3p);~yhe"EQ1$V(`nT`V6M2 ~6 r q4hr@`{$z~C|"CYH6@vutH3w\{NF+Xq(D2TT5Tn- D(1iVPݾTϔHťXNpuU?vʻl~UŰVC kE[+Cwk34*haиEpZ\vДG`R?I0Ikõ>1\!G _6sh'3>s>;uɛ [ǜ!ߓL {O7 i\SO1%?%zI"7XBj@wRG.>B 79t չaԕjb~Jk09Vvz젒ob^ ~sY;rgc|ѵk"dm>,[^%~kڰ0e vm3U8/2օvMi/e-o>w҉3w\:rɽcq4'TOXեNU?J.G{*-$[D'2od C=ZM$nX!v?B_޶!C)5ݾ;%?foL!v:l~#((J 0o3<ɳ&-(G1Z ÎtnC=].`GS|{B8p~Z3``ިX&~+8 4Pth&?çXB}NQ5{?1ų' XXMSn*JBNE\= dDȰOP8\ >]waIIGU[v!^!ȸ'@F^2M$)/A]jmP= 4us[ uOO+^Ц3 #^ӁӍ20Aicf$ݪ2ڻ0gvS^y tf$S aTQEԕR?갉2U^lVC󠙫wLe8q7E>׭k#I7ECC pgiS7: >id=3ѡw^%o_:6M)sҶ?ǛM0>xhAB%QQ' 5,Kp o3 Έlim?'قMfB4.FGZA7~rDsS=dM`6XEK3=b#zL='vOȌks fͯ_t7,pAe O?luNE6$S+!HZl ze1?I|(7[я[K`3:~OBp{!6&*v68#oR!dT>ڥ%MEcU2o!VNYXUv4 p  ~1Ȟݚi}B  ܇ag̃JIT^] ,]FV'r6$ OUSK*E3k]Fzpcqo)q 1V7h":CU^TR(<@ @ }c3(J'?BW5u]\! 4 OJ*8&FD$`8@)hl~a Ipf[R;#XxWɉ 9R gn2d?~<(=E(Iu,5"4фn%ѝ|C/䳬=clIRuȹ[H0!|qeR ulvl64=OӶHoola4R/rU;uKݱZ/"2P,HZ(S DJ{ʥJ.`2[@7s[hUzز]͖/FYX;pop9:z?> @Z&oiO[xa}˷ħtg|yt Q1i?R BУ%T 0% fsjJ(7KK1L_zp]:p4:ƄLx% C lDp(}i[{Cf={lNNɩx>BI;p>/L'~5&N{Ff.ͣC'N[绋*EL1*Us`@1zzpI_-YHV^R$Ȥ'YP`U7K>E1 J=6CɄgT( %9B]O9bSgeUYM?uu[6l[b&m9άAr9`:ҧMh l[ (-,7|nm #kkNC*R$X-ѳ0;);%GkEVVRn2j^>_r{^ w( FOGF&.Qsx0m'Ւc@9rÕ 0¥hd{&+=9؏o,Sz%yGuPʭcAnuS:k<$ BVCiZR1$?]RbP!߬1f)nj c%#~fA SѠįQRKBŠ/o㹏ڬd](7 u@jzh pŖ-xa}M2΍&ΌG<0ѥ328?D̃c5c}{}-Pzȕꜚ'+ /s-K7I`DuqD*!uHTNMKq@hj#*N31rf9*{x"ҝ6 ~OFng[#5ъQ7}`# 8YM@:}ʸ)rS>"W}4w,5[N*D'QJCmsB>au4 6L4)J%7]vNiy}hdBq& ? ÔHi](9L>VmQ5,o۫Nq ܒE5u8c`#]X0K9D.✁]^nQphw@Le}~Fvf |ht 3:"2fXO;(ON=;Q'AϕP/xrx_**=uKbzj.hgf LaV ~q;#$A@#BWLD2OT=[- vhƁvgJ i'1ڎ6 @+ܲbE ~in~ۡwzY]!'O(ܞ)Y"XKRRzmӼ&q(z ɥgP\zlGd~s_\2^ƛ "4Y2닆5~r7Cʶ6iV3'pMk`Vc8):yE,-@ |PQ>@@]>#({kGfIOCs3>m٭z[l 5BnL"((%Dj BW[*Bg<\dJ~vv]Ӎpw.pVqyB/ :mMTJq?G gVI;wz$'*% 0rs{f>D8&ZZl.7|Q8j탩'х zUභ4<|]&*6KA1Dy`'ЮKhlP #U$PqYRѲ20' t>2Akݔƛ8 =ǵ4֟B_llSX[\_)ĩKvJ?Z^iHb_iqy^RMuahzs%9 ( U>^T1K&Sjɛd͢).[blȌIp-g1^OOJwg& 4~;78,"WXֲX|,woN)n]OeJ}@"!n%_3&ΡWu]rG"p2 ?f A[8%>bldOLoޢ qH?IB 02 "zjxN[psMXEP;&8?@v4Sjm)yNά.4 %M4~SBS؟>BWo]ֆI.4X,(zd>O1$]DOuX,ä#![h\4ҵy B{,⚔PLZ KMJ:{ (/Pl;24L}89;hȂ+W8[tKɏWZd x"쏃oyL_6)5XKzBx;Ъ `~LӒUCڕ"_CyT^4|@Smm7 %czpw!]apԋwx@= ԐsvMR+ߨ[PxgjyNĘXo[ g{s裕}:oz5F[(c%!Q"T_^Ø[^ Pq֡[.W+*fB""RMJ L _S¼P:jJ;MBڶ;B[o_>p< f4B: WPi֛A  Pޣ~GLufm/{2yu,pFHɎAP?`wء&$J9IZP-hSj4Fp;.l"TpzFpF1o#WPT_%SoABwR.jүJ4Q 1o& T~XYM\.Yn?\шYa_]yoZˑb'r((/!D0[gb *NOHyρM.ٜ+z lIRf+I#<=A〕,&W`7|]z5(`]v5B)d~w~)95^ ]F#RN:;;" eJٗSo 0huX0",)TP9DAB)|x73@3Cwo棱}Qtt= (^&OaaFA-zf)<'"4zB U$ƕz.tCehSZ.u=c7/MIŽBXH-:̗UṉrPqSujY |LrS\BT6"G./-_&}棸8;[ݮJYP1 xPL0.jk#Y ˺)fG\AE F,_J! ԋcy Vc-dL -08yέn<7B_m5 yaO{bOx0v,ݕ2eϔsȄ%| # ES pj" mv}xRhMnF\Ko$T˕:#AƣpuLX, Ѝ8DDje8SNu+ΓV /ڼcL!)l,dvhܾ2FdXT¼l`3EGn˸,{luQDfHcp$5#iO!7 EIH~ONctvP[6MϚ^m{ڱh U @Or͂)½HPx@`6i \r(]ڔawMd|re猥U\oz ;69?cYٵD[a~x!8\UW%0 %6I=3)K"Yw:yFOr،#'v/7%;fKW71Ϗh?[n7T #(mcgOZۓ xg'?KQ/4M L%@Xl [3 e*I1z Dx.vGoO?1ar}b_l5,`_CΥ2Qg?#Sq_aj`FCP&J Yr z~4L*sP.h~^ } i Ϛ !nӓdPo&MSԥp))m9Q|5L]{96][鉔H:"BD6xwFϋqP:zMEzx+4% D *E\eeNn*CLI?!烏X7@;=R#aFSP^Vu@*:ߓWsĊk7r/.DT61J|T Lǎ=iml}o?XE3W{ӧΛ wR3|)#zZm^1.e&D5vXO4 fhݶM.ElbMcS`N8O;Y0gYZPerl-APIReference-0.16/t/0000755000175000017500000000000012264521751013522 5ustar tseetseePerl-APIReference-0.16/t/02versions.t0000644000175000017500000000060712131462446015722 0ustar tseetseeuse strict; use warnings; use Perl::APIReference; my @Perls; BEGIN { @Perls = sort keys %Perl::APIReference::Perls; } use Test::More tests => scalar( @Perls ); foreach my $version (@Perls) { my $err; ok( eval { Perl::APIReference->new( perl_version => $version ); 1; } || do {$err = $@||'Zombie Error'; 0}, $version ) or warn "Caught exception: $err"; } Perl-APIReference-0.16/t/01load.t0000644000175000017500000000012611653441731014766 0ustar tseetseeuse strict; use warnings; use Test::More tests => 1; use Perl::APIReference; pass(); Perl-APIReference-0.16/META.json0000664000175000017500000000170312264521751014703 0ustar tseetsee{ "abstract" : "Programmatically query the perlapi", "author" : [ "Steffen Mueller " ], "dynamic_config" : 1, "generated_by" : "ExtUtils::MakeMaker version 6.64, CPAN::Meta::Converter version 2.120921", "license" : [ "unknown" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : "2" }, "name" : "Perl-APIReference", "no_index" : { "directory" : [ "t", "inc" ] }, "prereqs" : { "build" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "configure" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "runtime" : { "requires" : { "Class::XSAccessor" : "1.05", "Data::Dumper" : "0", "parent" : "0" } } }, "release_status" : "stable", "version" : "0.16" } Perl-APIReference-0.16/author_scripts/0000755000175000017500000000000012264521751016330 5ustar tseetseePerl-APIReference-0.16/author_scripts/generate.pl0000644000175000017500000000045411653441731020462 0ustar tseetseeuse strict; use warnings; use Perl::APIReference::Generator; die unless @ARGV >= 2; my $apipod_file = shift @ARGV; my $perl_version = shift @ARGV; my $api = Perl::APIReference::Generator->parse( file => $apipod_file, perl_version => $perl_version, ); if ($api) { $api->_dump_as_class(); } Perl-APIReference-0.16/MANIFEST.SKIP0000644000175000017500000000024312047667467015172 0ustar tseetsee^\..*\.sw.$ /\..*\.sw.$ ^MANIFEST.bak$ ^Makefile$ ^Makefile.old$ ^blib/ ^pm_to_blib ^blibdirs \B\.svn\b ^nohup.out ^Perl-APIReference-.*\.gz$ \.git/ \bMYMETA\..*$ Perl-APIReference-0.16/.gitignore0000644000175000017500000000020711653717174015255 0ustar tseetsee.*.swp .*.swo Makefile Makefile.old MYMETA.yml META.yml MYMETA.json META.json blib/ pm_to_blib Perl-APIReference-*.tar.gz MANIFEST.bak Perl-APIReference-0.16/Makefile.PL0000644000175000017500000000140511653441731015231 0ustar tseetseeuse 5.006; use strict; use warnings; use ExtUtils::MakeMaker; # See lib/ExtUtils/MakeMaker.pm for details of how to influence # the contents of the Makefile that is written. WriteMakefile( NAME => 'Perl::APIReference', VERSION_FROM => 'lib/Perl/APIReference.pm', # finds $VERSION PREREQ_PM => { 'parent' => '0', 'Data::Dumper' => '0', 'Class::XSAccessor' => '1.05', }, # e.g., Module::Name => 1.1 dist => { COMPRESS => 'gzip -9f', SUFFIX => 'gz', }, ($] >= 5.005 ? ## Add these new keywords supported since 5.005 (ABSTRACT_FROM => 'lib/Perl/APIReference.pm', # retrieve abstract from module AUTHOR => 'Steffen Mueller ') : ()), ); Perl-APIReference-0.16/Changes0000644000175000017500000000272112264521705014553 0ustar tseetseeRevision history for Perl extension Perl::APIReference. 0.16 Sun Jan 12 15:15:00 2014 - Perl 5.18.2 support. 0.15 Tue Aug 27 07:09:00 2013 - Perl 5.18.1 support. 0.14 Mon Jun 10 08:00:00 2013 - Perl 5.18.0 support. 0.13 Thu Nov 11 11:00:00 2012 - Fixes for some previous perl versions (Randall Sawyer) - Support for perlapi of 5.16.3 and 5.14.4. - Dropped support for 5.15.*. 0.12 Sun Nov 11 11:00:00 2012 - Support for perlapi of 5.12.5. 0.11 Fri Nov 02 07:00:00 2012 - Support for perlapi of 5.16.2. 0.10 Mon Oct 29 13:00:00 2012 - Support for perlapi of 5.14.3, 5.16.0, 5.16.1. - Dropped support for 5.15.1. 0.09 Tue Nov 1 08:24:00 2011 - Fix previous (broken) release. 0.08 Mon Oct 31 07:59:00 2011 - Support for perlapi of 5.14.2, 5.15.4 0.07 Wed Jul 20 23:44 2011 - Support for perlapi of 5.14.1, 5.15.1, 5.12.4 - Dropped support for 5.13.10 0.06 Sun Jun 5 20:12:00 2011 - Support for perlapi of 5.14.0 - Dropped support for 5.11 series 0.05 Sun Feb 27 17:00:00 2011 - Support for perlapi of 5.12.1, 5.12.2, 5.12.3, 5.13.10. 0.04 Sun Apr 18 20:00:00 2010 - Support for perlapi of 5.12.0. 0.03 Fri Nov 20 19:00:00 2009 - Support for all perlapi's of stable releases back to 5.6.0. - Support for all perlapi's of 5.11.0-2 development releases. - Offer api to get the perlapi of the most recent stable/devel release. - Do not erroneously require a recent perl. 0.01 Fri Nov 13 19:00 2009 - original version

is well-formed. The C is a pointer to the character buffer to put the conversion result to. The C is a pointer to the length of the result. The C is a pointer to the swash to use. Both the special and normal mappings are stored in F, and loaded by SWASHNEW, using F. The C (usually, but not always, a multicharacter mapping), is tried first. The C is a string like "utf8::ToSpecLower", which means the hash %utf8::ToSpecLower. The access to the hash is through Perl_to_utf8_case(). The C is a string like "ToLower" which means the swash %utf8::ToLower. UV to_utf8_case(const U8 *p, U8* ustrp, STRLEN *lenp, SV **swashp, const char *normal, const char *special)','name' => 'to_utf8_case'},'set_numeric_local' => {'text' => '','name' => 'set_numeric_local'},'calloc' => {'text' => '','name' => 'calloc'},'POPpbytex' => {'text' => 'Pops a string off the stack which must consist of bytes i.e. characters < 256. char* POPpbytex','name' => 'POPpbytex'},'cophh_store_sv' => {'text' => 'Like L, but takes a Perl scalar instead of a string/length pair. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_store_sv(const COPHH *cophh, SV *key, U32 hash, SV *value, U32 flags)','name' => 'cophh_store_sv'},'newPMOP' => {'text' => 'Constructs, checks, and returns an op of any pattern matching type. I is the opcode. I gives the eight bits of C and, shifted up eight bits, the eight bits of C. OP * newPMOP(I32 type, I32 flags)','name' => 'newPMOP'},'PL_peepp' => {'text' => 'Pointer to the per-subroutine peephole optimiser. This is a function that gets called at the end of compilation of a Perl subroutine (or equivalently independent piece of Perl code) to perform fixups of some ops and to perform small-scale optimisations. The function is called once for each subroutine that is compiled, and is passed, as sole parameter, a pointer to the op that is the entry point to the subroutine. It modifies the op tree in place. The peephole optimiser should never be completely replaced. Rather, add code to it by wrapping the existing optimiser. The basic way to do this can be seen in L. If the new code wishes to operate on ops throughout the subroutine\'s structure, rather than just at the top level, it is likely to be more convenient to wrap the L hook. peep_t PL_peepp','name' => 'PL_peepp'},'SvSetMagicSV' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV(SV* dsb, SV* ssv)','name' => 'SvSetMagicSV'},'isALPHANUMERIC' => {'text' => 'Returns a boolean indicating whether the specified character is a either an alphabetic character or decimal digit, analogous to C. See the L for an explanation of variants C, C, C, C, C, C, and C. bool isALPHANUMERIC(char ch)','name' => 'isALPHANUMERIC'},'Move' => {'text' => '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)','name' => 'Move'},'set_context' => {'text' => '','name' => 'set_context'},'sv_catpvn_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. If C has the C bit set, will C on C afterwards if appropriate. C and C are implemented in terms of this function. void sv_catpvn_flags(SV *const dstr, const char *sstr, const STRLEN len, const I32 flags)','name' => 'sv_catpvn_flags'},'PerlIO_flush' => {'text' => '','name' => 'PerlIO_flush'},'sv_2iv_flags' => {'text' => 'Return the integer value of an SV, doing any necessary string conversion. If flags includes SV_GMAGIC, does an mg_get() first. Normally used via the C and C macros. IV sv_2iv_flags(SV *const sv, const I32 flags)','name' => 'sv_2iv_flags'},'runops_standard' => {'text' => '','name' => 'runops_standard'},'gv_efullname3' => {'text' => '','name' => 'gv_efullname3'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs. I needs to be static storage, as it is used directly as CvFILE(), without a copy being made.','name' => 'newXS'},'XCPT_RETHROW' => {'text' => 'Rethrows a previously caught exception. See L. XCPT_RETHROW;','name' => 'XCPT_RETHROW'},'mg_dup' => {'text' => '','name' => 'mg_dup'},'cop_hints_fetch_pvs' => {'text' => 'Like L, but takes a literal string instead of a string/length pair, and no precomputed hash. SV * cop_hints_fetch_pvs(const COP *cop, const char *key, U32 flags)','name' => 'cop_hints_fetch_pvs'},'cop_store_label' => {'text' => 'Save a label into a C. You need to set flags to C for a utf-8 label. NOTE: this function is experimental and may change or be removed without notice. void cop_store_label(COP *const cop, const char *label, STRLEN len, U32 flags)','name' => 'cop_store_label'},'PUSHmortal' => {'text' => 'Push a new mortal SV onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void PUSHmortal()','name' => 'PUSHmortal'},'XS_EXTERNAL' => {'text' => 'Macro to declare an XSUB and its C parameter list explicitly exporting the symbols.','name' => 'XS_EXTERNAL'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'sv_dump' => {'text' => '','name' => 'sv_dump'},'pad_tidy' => {'text' => 'Tidy up a pad at the end of compilation of the code to which it belongs. Jobs performed here are: remove most stuff from the pads of anonsub prototypes; give it a @_; mark temporaries as such. I indicates the kind of subroutine: padtidy_SUB ordinary subroutine padtidy_SUBCLONE prototype for lexical closure padtidy_FORMAT format NOTE: this function is experimental and may change or be removed without notice. void pad_tidy(padtidy_type type)','name' => 'pad_tidy'},'OP_DESC' => {'text' => 'Return a short description of the provided OP. const char * OP_DESC(OP *o)','name' => 'OP_DESC'},'strLE' => {'text' => '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)','name' => 'strLE'},'newSVpvn_flags' => {'text' => '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. If the C argument is NULL the new SV will be undefined. Currently the only flag bits accepted are C and C. If C is set, then C is called on the result before returning. If C is set, C is considered to be in UTF-8 and the C flag will be set on the new SV. C is a convenience wrapper for this function, defined as #define newSVpvn_utf8(s, len, u) \\ newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0) SV* newSVpvn_flags(const char *const s, const STRLEN len, const U32 flags)','name' => 'newSVpvn_flags'},'XopFLAGS' => {'text' => 'Return the XOP\'s flags. U32 XopFLAGS(XOP *xop)','name' => 'XopFLAGS'},'SvOK' => {'text' => 'Returns a U32 value indicating whether the value is defined. This is only meaningful for scalars. U32 SvOK(SV* sv)','name' => 'SvOK'},'sv_setref_nv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_nv(SV *const rv, const char *const classname, const NV nv)','name' => 'sv_setref_nv'},'eval_pv' => {'text' => '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)','name' => 'eval_pv'},'lex_stuff_pvn' => {'text' => 'Insert characters into the lexer buffer (Llinestr>), immediately after the current lexing point (Lbufptr>), reallocating the buffer if necessary. This means that lexing code that runs later will see the characters as if they had appeared in the input. It is not recommended to do this as part of normal parsing, and most uses of this facility run the risk of the inserted characters being interpreted in an unintended manner. The string to be inserted is represented by I octets starting at I. These octets are interpreted as either UTF-8 or Latin-1, according to whether the C flag is set in I. The characters are recoded for the lexer buffer, according to how the buffer is currently being interpreted (L). If a string to be inserted is available as a Perl scalar, the L function is more convenient. NOTE: this function is experimental and may change or be removed without notice. void lex_stuff_pvn(const char *pv, STRLEN len, U32 flags)','name' => 'lex_stuff_pvn'},'sv_usepvn_flags' => {'text' => '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. It must be the start of a mallocked block of memory, and not a pointer to the middle of it. The string length, C, must be supplied. By default this function will realloc (i.e. move) the memory pointed to by C, so that pointer should not be freed or used by the programmer after giving it to sv_usepvn, and neither should any pointers from "behind" that pointer (e.g. ptr + 1) be used. If C & SV_SMAGIC is true, will call SvSETMAGIC. If C & SV_HAS_TRAILING_NUL is true, then C must be NUL, and the realloc will be skipped (i.e. the buffer is actually at least 1 byte longer than C, and already meets the requirements for storing in C). void sv_usepvn_flags(SV *const sv, char* ptr, const STRLEN len, const U32 flags)','name' => 'sv_usepvn_flags'},'hv_assert' => {'text' => 'Check that a hash is in an internally consistent state. void hv_assert(HV *hv)','name' => 'hv_assert'},'my_vsnprintf' => {'text' => 'The C library C if available and standards-compliant. However, if if the C is not available, will unfortunately use the unsafe C which can overrun the buffer (there is an overrun check, but that may be too late). Consider using C instead, or getting C. int my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap)','name' => 'my_vsnprintf'},'sv_free' => {'text' => 'Decrement an SV\'s reference count, and if it drops to zero, call C to invoke destructors and free up any memory used by the body; finally, deallocate the SV\'s head itself. Normally called via a wrapper macro C. void sv_free(SV *const sv)','name' => 'sv_free'},'die_nocontext' => {'text' => '','name' => 'die_nocontext'},'hv_eiter_p' => {'text' => '','name' => 'hv_eiter_p'},'SvPVbyte_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_force(SV* sv, STRLEN len)','name' => 'SvPVbyte_force'},'av_pop' => {'text' => 'Removes one SV from the end of the array, reducing its size by one and returning the SV (transferring control of one reference count) to the caller. Returns C<&PL_sv_undef> if the array is empty. Perl equivalent: C SV* av_pop(AV *av)','name' => 'av_pop'},'reg_named_buff_exists' => {'text' => '','name' => 'reg_named_buff_exists'},'save_bool' => {'text' => '','name' => 'save_bool'},'ckwarn_d' => {'text' => '','name' => 'ckwarn_d'},'croak' => {'text' => 'This is an XS interface to Perl\'s C function. Take a sprintf-style format pattern and argument list. These are used to generate a string message. If the message does not end with a newline, then it will be extended with some indication of the current location in the code, as described for L. The error message will be used as an exception, by default returning control to the nearest enclosing C, but subject to modification by a C<$SIG{__DIE__}> handler. In any case, the C function never returns normally. For historical reasons, if C is null then the contents of C (C<$@>) will be used as an error message or object instead of building an error message from arguments. If you want to throw a non-string object, or build an error message in an SV yourself, it is preferable to use the L function, which does not involve clobbering C. void croak(const char *pat, ...)','name' => 'croak'},'save_freepv' => {'text' => '','name' => 'save_freepv'},'THIS' => {'text' => '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','name' => 'THIS'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually handled by C. void XSRETURN(int nitems)','name' => 'XSRETURN'},'dump_indent' => {'text' => '','name' => 'dump_indent'},'screaminstr' => {'text' => '','name' => 'screaminstr'},'op_append_elem' => {'text' => 'Append an item to the list of ops contained directly within a list-type op, returning the lengthened list. I is the list-type op, and I is the op to append to the list. I specifies the intended opcode for the list. If I is not already a list of the right type, it will be upgraded into one. If either I or I is null, the other is returned unchanged. OP * op_append_elem(I32 optype, OP *first, OP *last)','name' => 'op_append_elem'},'lex_read_unichar' => {'text' => 'Reads the next (Unicode) character in the text currently being lexed. Returns the codepoint (unsigned integer value) of the character read, and moves Lbufptr> past the character, or returns -1 if lexing has reached the end of the input text. To non-destructively examine the next character, use L instead. If the next character is in (or extends into) the next chunk of input text, the next chunk will be read in. Normally the current chunk will be discarded at the same time, but if I includes C then the current chunk will not be discarded. If the input is being interpreted as UTF-8 and a UTF-8 encoding error is encountered, an exception is generated. NOTE: this function is experimental and may change or be removed without notice. I32 lex_read_unichar(U32 flags)','name' => 'lex_read_unichar'},'reginitcolors' => {'text' => '','name' => 'reginitcolors'},'get_av' => {'text' => 'Returns the AV of the specified Perl global or package array with the given name (so it won\'t work on lexical variables). C are passed to C. If C is set and the Perl variable does not exist then it will be created. If C is zero and the variable does not exist then NULL is returned. Perl equivalent: C<@{"$name"}>. NOTE: the perl_ form of this function is deprecated. AV* get_av(const char *name, I32 flags)','name' => 'get_av'},'sv_2pv_nolen' => {'text' => 'Like C, but doesn\'t return the length too. You should usually use the macro wrapper C instead. char* sv_2pv_nolen(SV* sv)','name' => 'sv_2pv_nolen'},'op_contextualize' => {'text' => 'Applies a syntactic context to an op tree representing an expression. I is the op tree, and I must be C, C, or C to specify the context to apply. The modified op tree is returned. OP * op_contextualize(OP *o, I32 context)','name' => 'op_contextualize'},'PoisonFree' => {'text' => 'PoisonWith(0xEF) for catching access to freed memory. void PoisonFree(void* dest, int nitems, type)','name' => 'PoisonFree'},'gv_SVadd' => {'text' => '','name' => 'gv_SVadd'},'hv_common' => {'text' => '','name' => 'hv_common'},'XopENTRY' => {'text' => 'Return a member of the XOP structure. I is a cpp token indicating which entry to return. If the member is not set this will return a default value. The return type depends on I. XopENTRY(XOP *xop, which)','name' => 'XopENTRY'},'newSVREF' => {'text' => '','name' => 'newSVREF'},'toUPPER' => {'text' => 'Converts the specified character to uppercase, if possible; otherwise returns the input character itself. char toUPPER(char ch)','name' => 'toUPPER'},'sv_catpvs_flags' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_catpvs_flags(SV* sv, const char* s, I32 flags)','name' => 'sv_catpvs_flags'},'is_lvalue_sub' => {'text' => '','name' => 'is_lvalue_sub'},'is_utf8_string_loc' => {'text' => 'Like L but stores the location of the failure (in the case of "utf8ness failure") or the location C+C (in the case of "utf8ness success") in the C. See also L() and L(). bool is_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep)','name' => 'is_utf8_string_loc'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally appending to the currently-stored string. If C is not 0, the line is appended to the SV instead of overwriting it. C should be set to the byte offset that the appended string should start at in the SV (typically, C is a suitable choice). char* sv_gets(SV *const sv, PerlIO *const fp, I32 append)','name' => 'sv_gets'},'GvAV' => {'text' => 'Return the AV from the GV. AV* GvAV(GV* gv)','name' => 'GvAV'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'pad_add_anon' => {'text' => 'Allocates a place in the currently-compiling pad (via L) for an anonymous function that is lexically scoped inside the currently-compiling function. The function I is linked into the pad, and its C link to the outer scope is weakened to avoid a reference loop. One reference count is stolen, so you may need to do C. I should be an opcode indicating the type of operation that the pad entry is to support. This doesn\'t affect operational semantics, but is used for debugging. PADOFFSET pad_add_anon(CV *func, I32 optype)','name' => 'pad_add_anon'},'dUNDERBAR' => {'text' => 'Sets up any variable needed by the C macro. It used to define C, but it is currently a noop. However, it is strongly advised to still use it for ensuring past and future compatibility. dUNDERBAR;','name' => 'dUNDERBAR'},'sv_uv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. UV sv_uv(SV* sv)','name' => 'sv_uv'},'ptr_table_split' => {'text' => '','name' => 'ptr_table_split'},'foldEQ_utf8' => {'text' => 'Returns true if the leading portions of the strings C and C (either or both of which may be in UTF-8) are the same case-insensitively; false otherwise. How far into the strings to compare is determined by other input parameters. If C is true, the string C is assumed to be in UTF-8-encoded Unicode; otherwise it is assumed to be in native 8-bit encoding. Correspondingly for C with respect to C. If the byte length C is non-zero, it says how far into C to check for fold equality. In other words, C+C will be used as a goal to reach. The scan will not be considered to be a match unless the goal is reached, and scanning won\'t continue past that goal. Correspondingly for C with respect to C. If C is non-NULL and the pointer it points to is not NULL, that pointer is considered an end pointer to the position 1 byte past the maximum point in C beyond which scanning will not continue under any circumstances. (This routine assumes that UTF-8 encoded input strings are not malformed; malformed input can cause it to read past C). This means that if both C and C are specified, and C is less than C+C, the match will never be successful because it can never get as far as its goal (and in fact is asserted against). Correspondingly for C with respect to C. At least one of C and C must have a goal (at least one of C and C must be non-zero), and if both do, both have to be reached for a successful match. Also, if the fold of a character is multiple characters, all of them must be matched (see tr21 reference below for \'folding\'). Upon a successful match, if C is non-NULL, it will be set to point to the beginning of the I character of C beyond what was matched. Correspondingly for C and C. For case-insensitiveness, the "casefolding" of Unicode is used instead of upper/lowercasing both the characters, see L (Case Mappings). I32 foldEQ_utf8(const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2)','name' => 'foldEQ_utf8'},'Nullch' => {'text' => 'Null character pointer. (No longer available when C is defined.)','name' => 'Nullch'},'sv_copypv_nomg' => {'text' => 'Like sv_copypv, but doesn\'t invoke get magic first. void sv_copypv_nomg(SV *const dsv, SV *const ssv)','name' => 'sv_copypv_nomg'},'get_context' => {'text' => '','name' => 'get_context'},'vcroak' => {'text' => 'This is an XS interface to Perl\'s C function. C and C are a sprintf-style format pattern and encapsulated argument list. These are used to generate a string message. If the message does not end with a newline, then it will be extended with some indication of the current location in the code, as described for L. The error message will be used as an exception, by default returning control to the nearest enclosing C, but subject to modification by a C<$SIG{__DIE__}> handler. In any case, the C function never returns normally. For historical reasons, if C is null then the contents of C (C<$@>) will be used as an error message or object instead of building an error message from arguments. If you want to throw a non-string object, or build an error message in an SV yourself, it is preferable to use the L function, which does not involve clobbering C. void vcroak(const char *pat, va_list *args)','name' => 'vcroak'},'parse_fullexpr' => {'text' => 'Parse a single complete Perl expression. This allows the full expression grammar, including the lowest-precedence operators such as C. The expression must be followed (and thus terminated) by a token that an expression would normally be terminated by: end-of-file, closing bracketing punctuation, semicolon, or one of the keywords that signals a postfix expression-statement modifier. If I includes C then the expression is optional, otherwise it is mandatory. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed and the lexical context for the expression. The op tree representing the expression is returned. If an optional expression is absent, a null pointer is returned, otherwise the pointer will be non-null. If an error occurs in parsing or compilation, in most cases a valid op tree is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. Some compilation errors, however, will throw an exception immediately. NOTE: this function is experimental and may change or be removed without notice. OP * parse_fullexpr(U32 flags)','name' => 'parse_fullexpr'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the supplied vtable and returns a pointer to the magic added. Note that C will allow things that C will not. In particular, you can add magic to SvREADONLY SVs, and add more than one instance of the same \'how\'. If C is greater than zero then a C I of C is stored, if C is zero then C is stored as-is and - as another special case - if C<(name && namlen == HEf_SVKEY)> then C is assumed to contain an C and is stored as-is with its REFCNT incremented. (This is now used as a subroutine by C.) MAGIC * sv_magicext(SV *const sv, SV *const obj, const int how, const MGVTBL *const vtbl, const char *const name, const I32 namlen)','name' => 'sv_magicext'},'gv_fullname4' => {'text' => '','name' => 'gv_fullname4'},'av_push' => {'text' => 'Pushes an SV onto the end of the array. The array will grow automatically to accommodate the addition. This takes ownership of one reference count. Perl equivalent: C. void av_push(AV *av, SV *val)','name' => 'av_push'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV *const sv)','name' => 'newRV_noinc'},'unsharepvn' => {'text' => '','name' => 'unsharepvn'},'my_memcmp' => {'text' => '','name' => 'my_memcmp'},'newSLICEOP' => {'text' => 'Constructs, checks, and returns an C (list slice) op. I gives the eight bits of C, except that C will be set automatically, and, shifted up eight bits, the eight bits of C, except that the bit with value 1 or 2 is automatically set as required. I and I supply the parameters of the slice; they are consumed by this function and become part of the constructed op tree. OP * newSLICEOP(I32 flags, OP *subscript, OP *listval)','name' => 'newSLICEOP'},'mfree' => {'text' => '','name' => 'mfree'},'save_re_context' => {'text' => '','name' => 'save_re_context'},'hv_iterinit' => {'text' => '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 *hv)','name' => 'hv_iterinit'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.018000', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_010_001.pm0000644000175000017500000046351011653441731020760 0ustar tseetseepackage Perl::APIReference::V5_010_001; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'hv_store_ent' => {'text' => '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. Effectively a successful hv_store_ent takes ownership of one reference to C. 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 C; unlike C it does not take ownership of it, so maintaining the correct reference count on C 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 L for more information on how to use this function on tied hashes. HE* hv_store_ent(HV *hv, SV *key, SV *val, U32 hash)','name' => 'hv_store_ent'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package. See C. HV* gv_stashsv(SV* sv, I32 flags)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'strGE' => {'text' => '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)','name' => 'strGE'},'form' => {'text' => '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, ...)','name' => 'form'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified version becoming C. Handles \'get\' magic. See also C for a version which guarantees to evaluate sv only once. char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'is_utf8_string' => {'text' => 'Returns true if first C bytes of the given string form a valid UTF-8 string, false otherwise. Note that \'a valid UTF-8 string\' does not mean \'a string that contains code points above 0x7F encoded in UTF-8\' because a valid ASCII string is a valid UTF-8 string. See also is_utf8_string_loclen() and is_utf8_string_loc(). bool is_utf8_string(const U8 *s, STRLEN len)','name' => 'is_utf8_string'},'croak_xs_usage' => {'text' => 'A specialised variant of C for emitting the usage message for xsubs croak_xs_usage(cv, "eee_yow"); works out the package name and subroutine name from C, and then calls C. Hence if C is C<&ouch::awk>, it would call C as: Perl_croak(aTHX_ "Usage %s::%s(%s)", "ouch" "awk", "eee_yow"); void croak_xs_usage(const CV *const cv, const char *const params)','name' => 'croak_xs_usage'},'sv_insert' => {'text' => 'Inserts a string at the specified offset/length within the SV. Similar to the Perl substr() function. Handles get magic. void sv_insert(SV *bigstr, STRLEN offset, STRLEN len, const char *little, STRLEN littlelen)','name' => 'sv_insert'},'SvPOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a character string. U32 SvPOK(SV* sv)','name' => 'SvPOK'},'sv_vsetpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vsetpvf_mg(SV* sv, const char* pat, va_list* args)','name' => 'sv_vsetpvf_mg'},'sv_destroyable' => {'text' => 'Dummy routine which reports that object can be destroyed when there is no sharing module present. It ignores its single SV argument, and returns \'true\'. Exists to avoid test for a NULL function pointer and because it could potentially warn under some level of strict-ness. bool sv_destroyable(SV *sv)','name' => 'sv_destroyable'},'SvPVutf8' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'sortsv_flags' => {'text' => 'Sort an array, with various options. void sortsv_flags(SV** array, size_t num_elts, SVCOMPARE_t cmp, U32 flags)','name' => 'sortsv_flags'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C.','name' => 'XS'},'scan_oct' => {'text' => 'For backwards compatibility. Use C instead. NV scan_oct(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_oct'},'sv_setpvn' => {'text' => 'Copies a string into an SV. The C parameter indicates the number of bytes to be copied. If the C argument is NULL the SV will become undefined. Does not handle \'set\' magic. See C. void sv_setpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_setpvn'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'newSVrv' => {'text' => '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)','name' => 'newSVrv'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'find_runcv' => {'text' => 'Locate the CV corresponding to the currently executing sub or eval. If db_seqp is non_null, skip CVs that are in the DB package and populate *db_seqp with the cop sequence number at the point that the DB:: code was entered. (allows debuggers to eval in the scope of the breakpoint rather than in the scope of the debugger itself). CV* find_runcv(U32 *db_seqp)','name' => 'find_runcv'},'PoisonWith' => {'text' => 'Fill up memory with a byte pattern (a byte repeated over and over again) that hopefully catches attempts to access uninitialized memory. void PoisonWith(void* dest, int nitems, type, U8 byte)','name' => 'PoisonWith'},'utf8n_to_uvuni' => {'text' => 'Bottom level UTF-8 decode routine. Returns the Unicode code point value of the first character in the string C which is assumed to be in UTF-8 encoding and no longer than C; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, the behaviour is dependent on the value of C: if it contains UTF8_CHECK_ONLY, it is assumed that the caller will raise a warning, and this function will silently just set C to C<-1> and return zero. If the C does not contain UTF8_CHECK_ONLY, warnings about malformations will be given, C will be set to the expected length of the UTF-8 character in bytes, and zero will be returned. The C can also contain various flags to allow deviations from the strict UTF-8 encoding (see F). Most code should use utf8_to_uvchr() rather than call this directly. UV utf8n_to_uvuni(const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvuni'},'av_create_and_unshift_one' => {'text' => 'Unshifts an SV onto the beginning of the array, creating the array if necessary. A small internal helper function to remove a commonly duplicated idiom. NOTE: this function is experimental and may change or be removed without notice. SV** av_create_and_unshift_one(AV **const avp, SV *const val)','name' => 'av_create_and_unshift_one'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'newSVpvn_utf8' => {'text' => 'Creates a new SV and copies a string into it. If utf8 is true, calls C on the new SV. Implemented as a wrapper around C. SV* newSVpvn_utf8(NULLOK const char* s, STRLEN len, U32 utf8)','name' => 'newSVpvn_utf8'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C to type C if necessary, then adds a new magic item of type C to the head of the magic list. See C (which C now calls) for a description of the handling of the C and C arguments. You need to use C to add magic to SvREADONLY SVs and also to add more than one instance of the same \'how\'. void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen)','name' => 'sv_magic'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'sv_utf8_upgrade_flags' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes are invariant in UTF-8. If C has C bit set, will C on C if appropriate, else not. Returns the number of bytes in the converted string C and C are implemented in terms of this function. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade_flags(SV *sv, I32 flags)','name' => 'sv_utf8_upgrade_flags'},'ibcmp_utf8' => {'text' => 'Return true if the strings s1 and s2 differ case-insensitively, false if not (if they are equal case-insensitively). If u1 is true, the string s1 is assumed to be in UTF-8-encoded Unicode. If u2 is true, the string s2 is assumed to be in UTF-8-encoded Unicode. If u1 or u2 are false, the respective string is assumed to be in native 8-bit encoding. If the pe1 and pe2 are non-NULL, the scanning pointers will be copied in there (they will point at the beginning of the I character). If the pointers behind pe1 or pe2 are non-NULL, they are the end pointers beyond which scanning will not continue under any circumstances. If the byte lengths l1 and l2 are non-zero, s1+l1 and s2+l2 will be used as goal end pointers that will also stop the scan, and which qualify towards defining a successful match: all the scans that define an explicit length must reach their goal pointers for a match to succeed). For case-insensitiveness, the "casefolding" of Unicode is used instead of upper/lowercasing both the characters, see http://www.unicode.org/unicode/reports/tr21/ (Case Mappings). I32 ibcmp_utf8(const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2)','name' => 'ibcmp_utf8'},'SvREFCNT_inc_void' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value. The macro doesn\'t need to return a meaningful value. void SvREFCNT_inc_void(SV* sv)','name' => 'SvREFCNT_inc_void'},'mXPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Does not use C. See also C, C and C. void mXPUSHp(char* str, STRLEN len)','name' => 'mXPUSHp'},'CvSTASH' => {'text' => 'Returns the stash of the CV. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'gv_const_sv' => {'text' => 'If C is a typeglob whose subroutine entry is a constant sub eligible for inlining, or C is a placeholder reference that would be promoted to such a typeglob, then returns the value returned by the sub. Otherwise, returns NULL. SV* gv_const_sv(GV* gv)','name' => 'gv_const_sv'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. The target SV physically takes over ownership of the body of the source SV and inherits its flags; however, the target keeps any magic it owns, and any magic in the source is discarded. Note that this is a rather specialist SV copying operation; most of the time you\'ll want to use C or one of its many macro front-ends. void sv_replace(SV* sv, SV* nsv)','name' => 'sv_replace'},'utf8n_to_uvchr' => {'text' => 'flags Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. Allows length and flags to be passed to low level routine. UV utf8n_to_uvchr(const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvchr'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and L.','name' => 'G_ARRAY'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'SvROK' => {'text' => 'Tests if the SV is an RV. U32 SvROK(SV* sv)','name' => 'SvROK'},'mXPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void mXPUSHn(NV nv)','name' => 'mXPUSHn'},'sv_unref' => {'text' => '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. This is C with the C being zero. See C. void sv_unref(SV* sv)','name' => 'sv_unref'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dsv, SV *ssv)','name' => 'sv_catsv_mg'},'call_argv' => {'text' => '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)','name' => 'call_argv'},'SvPV_nolen' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified form becoming C. Handles \'get\' magic. char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'perl_clone' => {'text' => '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->create 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 C, 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 *proto_perl, UV flags)','name' => 'perl_clone'},'sv_setnv' => {'text' => 'Copies a double into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setnv(SV* sv, NV num)','name' => 'sv_setnv'},'sv_2nv' => {'text' => 'Return the num value of an SV, doing any necessary string or integer conversion, magic etc. Normally used via the C and C macros. NV sv_2nv(SV* sv)','name' => 'sv_2nv'},'SvREFCNT_inc_simple_NN' => {'text' => 'Same as SvREFCNT_inc_simple, but can only be used if you know I is not NULL. Since we don\'t have to check the NULLness, it\'s faster and smaller. SV* SvREFCNT_inc_simple_NN(SV* sv)','name' => 'SvREFCNT_inc_simple_NN'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'hv_fetchs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV** hv_fetchs(HV* tb, const char* key, I32 lval)','name' => 'hv_fetchs'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1. HV* newHV()','name' => 'newHV'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or false. bool strNE(char* s1, char* s2)','name' => 'strNE'},'sv_pvutf8n_force' => {'text' => 'The backend for the C macro. Always use the macro instead. char* sv_pvutf8n_force(SV* sv, STRLEN* lp)','name' => 'sv_pvutf8n_force'},'savepv' => {'text' => 'Perl\'s version of C. Returns a pointer to a newly allocated string which is a duplicate of C. The size of the string is determined by C. The memory allocated for the new string can be freed with the C function. char* savepv(const char* pv)','name' => 'savepv'},'SvNV_set' => {'text' => 'Set the value of the NV pointer in sv to val. See C. void SvNV_set(SV* sv, NV val)','name' => 'SvNV_set'},'bytes_from_utf8' => {'text' => 'Converts a string C of length C from UTF-8 into native byte encoding. Unlike C but like C, returns a pointer to the newly-created string, and updates C to contain the new length. Returns the original string if no conversion occurs, C is unchanged. Do nothing if C points to 0. Sets C to 0 if C is converted or consisted entirely of characters that are invariant in utf8 (i.e., US-ASCII on non-EBCDIC machines). NOTE: this function is experimental and may change or be removed without notice. U8* bytes_from_utf8(const U8 *s, STRLEN *len, bool *is_utf8)','name' => 'bytes_from_utf8'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1. AV* newAV()','name' => 'newAV'},'HvNAME' => {'text' => 'Returns the package name of a stash, or NULL if C isn\'t a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV of the sv is assumed to be octets in that encoding, and the sv will be converted into Unicode (and UTF-8). If the sv already is UTF-8 (or if it is not POK), or if the encoding is not a reference, nothing is done to the sv. If the encoding is not an C Encoding object, bad things will happen. (See F and L). The PV of the sv is returned. char* sv_recode_to_utf8(SV* sv, SV *encoding)','name' => 'sv_recode_to_utf8'},'av_make' => {'text' => '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 **strp)','name' => 'av_make'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. See C for a version which guarantees to evaluate sv only once. UV SvUV(SV* sv)','name' => 'SvUV'},'PERL_SYS_INIT' => {'text' => 'Provides system-specific tune up of the C runtime environment necessary to run Perl interpreters. This should be called only once, before creating any Perl interpreters. void PERL_SYS_INIT(int argc, char** argv)','name' => 'PERL_SYS_INIT'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L. int perl_run(PerlInterpreter *my_perl)','name' => 'perl_run'},'vstringify' => {'text' => 'In order to maintain maximum compatibility with earlier versions of Perl, this function will return either the floating point notation or the multiple dotted notation, depending on whether the original version contained 1 or more dots, respectively SV* vstringify(SV *vs)','name' => 'vstringify'},'sv_catsv_flags' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. If C has C bit set, will C on the SVs if appropriate, else not. C and C are implemented in terms of this function. void sv_catsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_catsv_flags'},'sv_insert_flags' => {'text' => 'Same as C, but the extra C are passed the C that applies to C. void sv_insert_flags(SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen, const U32 flags)','name' => 'sv_insert_flags'},'SvPVutf8_nolen' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_nolen(SV* sv)','name' => 'SvPVutf8_nolen'},'SvRXOK' => {'text' => 'Returns a boolean indicating whether the SV contains qr magic (PERL_MAGIC_qr). If you want to do something with the REGEXP* later use SvRX instead and check for NULL. bool SvRXOK(SV* sv)','name' => 'SvRXOK'},'sv_setpviv' => {'text' => '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)','name' => 'sv_setpviv'},'sv_true' => {'text' => 'Returns true if the SV has a true value by Perl\'s rules. Use the C macro instead, which may call C or may instead use an in-line version. I32 sv_true(SV *sv)','name' => 'sv_true'},'sv_derived_from' => {'text' => 'Returns a boolean indicating whether the SV is derived from the specified class I. To check derivation at the Perl level, call C as a normal Perl method. bool sv_derived_from(SV* sv, const char* name)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp_locale(SV* sv1, SV* sv2)','name' => 'sv_cmp_locale'},'sv_catpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_catpvs(SV* sv, const char* s)','name' => 'sv_catpvs'},'hv_exists' => {'text' => 'Returns a boolean indicating whether the specified hash key exists. The C is the length of the key. bool hv_exists(HV *hv, const char *key, I32 klen)','name' => 'hv_exists'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'Nullsv' => {'text' => 'Null SV pointer.','name' => 'Nullsv'},'mg_length' => {'text' => 'Report on the SV\'s length. See C. U32 mg_length(SV* sv)','name' => 'mg_length'},'SvPVX' => {'text' => 'Returns a pointer to the physical string in the SV. The SV must contain a string. char* SvPVX(SV* sv)','name' => 'SvPVX'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'HEf_SVKEY' => {'text' => 'This flag, used in the length slot of hash entries and magic structures, specifies the structure contains an C pointer where a C pointer is to be expected. (For information only--not to be used).','name' => 'HEf_SVKEY'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C in characters. Stops at C (inclusive). If C s> or if the scan would end up past C, croaks. STRLEN utf8_length(const U8* s, const U8 *e)','name' => 'utf8_length'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted if tainting is enabled. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'SvIOK_only_UV' => {'text' => 'Tells and SV that it is an unsigned integer and disables all other OK bits. void SvIOK_only_UV(SV* sv)','name' => 'SvIOK_only_UV'},'sv_nolocking' => {'text' => '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. "Superseded" by sv_nosharing(). void sv_nolocking(SV *sv)','name' => 'sv_nolocking'},'sv_vcatpvfn' => {'text' => '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). Usually used via one of its frontends C and C. void sv_vcatpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vcatpvfn'},'strLT' => {'text' => '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)','name' => 'strLT'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_shift(AV *av)','name' => 'av_shift'},'sv_pvutf8n' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n(SV *sv, STRLEN *lp)','name' => 'sv_pvutf8n'},'newSV' => {'text' => '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 trailing 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. In 5.9.3, newSV() replaces the older NEWSV() API, and drops the first parameter, I, a debug aid which allowed callers to identify themselves. This aid has been superseded by a new build option, PERL_MEM_LOG (see L). The older API is still there for use in XS modules supporting older perls. SV* newSV(STRLEN len)','name' => 'newSV'},'sv_2pvutf8' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV, and set *lp to its length. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8(SV* sv, STRLEN* lp)','name' => 'sv_2pvutf8'},'sv_nounlocking' => {'text' => '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. "Superseded" by sv_nosharing(). void sv_nounlocking(SV *sv)','name' => 'sv_nounlocking'},'dITEMS' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dITEMS;','name' => 'dITEMS'},'SvUV_set' => {'text' => 'Set the value of the UV pointer in sv to val. See C. void SvUV_set(SV* sv, UV val)','name' => 'SvUV_set'},'CopyD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * CopyD(void* src, void* dest, int nitems, type)','name' => 'CopyD'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *sv, IV i)','name' => 'sv_setiv_mg'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C. See C and L for other uses. PUTBACK;','name' => 'PUTBACK'},'savesharedpvn' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. (With the specific difference that a NULL pointer is not acceptable) char* savesharedpvn(const char *const pv, const STRLEN len)','name' => 'savesharedpvn'},'dAXMARK' => {'text' => 'Sets up the C variable and stack marker variable C. This is usually handled automatically by C by calling C. dAXMARK;','name' => 'dAXMARK'},'SvCUR_set' => {'text' => 'Set the current length of the string which is in the SV. See C and C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'sv_2uv_flags' => {'text' => 'Return the unsigned integer value of an SV, doing any necessary string conversion. If flags includes SV_GMAGIC, does an mg_get() first. Normally used via the C and C macros. UV sv_2uv_flags(SV* sv, I32 flags)','name' => 'sv_2uv_flags'},'SvNOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a double. U32 SvNOK(SV* sv)','name' => 'SvNOK'},'mPUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void mPUSHn(NV nv)','name' => 'mPUSHn'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C, C, and L.','name' => 'G_SCALAR'},'sv_reset' => {'text' => 'Underlying implementation for the C Perl function. Note that the perl-level function is vaguely deprecated. void sv_reset(const char* s, HV* stash)','name' => 'sv_reset'},'sv_2pv_flags' => {'text' => 'Returns a pointer to the string value of an SV, and sets *lp to its length. If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string if necessary. Normally invoked via the C macro. C and C usually end up here too. char* sv_2pv_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_2pv_flags'},'SvTAINTED_off' => {'text' => '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)','name' => 'SvTAINTED_off'},'SvNVx' => {'text' => 'Coerces the given SV to a double and returns it. Guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. NV SvNVx(SV* sv)','name' => 'SvNVx'},'require_pv' => {'text' => 'Tells Perl to C the file named by the string argument. It is analogous to the Perl code C. 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)','name' => 'require_pv'},'sv_upgrade' => {'text' => 'Upgrade an SV to a more complex form. Generally adds a new body type to the SV, then copies across as much information as possible from the old body. You generally want to use the C macro wrapper. See also C. void sv_upgrade(SV* sv, svtype new_type)','name' => 'sv_upgrade'},'strEQ' => {'text' => 'Test two strings to see if they are equal. Returns true or false. bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'hv_store' => {'text' => '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. Effectively a successful hv_store takes ownership of one reference to C. 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 L for more information on how to use this function on tied hashes. SV** hv_store(HV *hv, const char *key, I32 klen, SV *val, U32 hash)','name' => 'hv_store'},'isUPPER' => {'text' => 'Returns a boolean indicating whether the C C is a US-ASCII (Basic Latin) uppercase character. bool isUPPER(char ch)','name' => 'isUPPER'},'sv_setsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setsv_mg(SV *dstr, SV *sstr)','name' => 'sv_setsv_mg'},'hv_fetch_ent' => {'text' => '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 *hv, SV *keysv, I32 lval, U32 hash)','name' => 'hv_fetch_ent'},'isLOWER' => {'text' => 'Returns a boolean indicating whether the C C is a US-ASCII (Basic Latin) lowercase character. bool isLOWER(char ch)','name' => 'isLOWER'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See C. char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'SvNOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a double. Checks the B setting. Use C instead. U32 SvNOKp(SV* sv)','name' => 'SvNOKp'},'Newx' => {'text' => 'The XSUB-writer\'s interface to the C C function. In 5.9.3, Newx() and friends replace the older New() API, and drops the first parameter, I, a debug aid which allowed callers to identify themselves. This aid has been superseded by a new build option, PERL_MEM_LOG (see L). The older API is still there for use in XS modules supporting older perls. void Newx(void* ptr, int nitems, type)','name' => 'Newx'},'PUSHs' => {'text' => 'Push an SV onto the stack. The stack must have room for this element. Does not handle \'set\' magic. Does not use C. See also C, C and C. void PUSHs(SV* sv)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setuv(SV* sv, UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'utf8_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvchr(const U8 *s, STRLEN *retlen)','name' => 'utf8_to_uvchr'},'nothreadhook' => {'text' => 'Stub that provides thread hook for perl_destruct when there are no threads. int nothreadhook()','name' => 'nothreadhook'},'bytes_to_utf8' => {'text' => 'Converts a string C of length C from the native encoding into UTF-8. Returns a pointer to the newly-created string, and sets C to reflect the new length. A NUL character will be written after the end of the string. If you want to convert to UTF-8 from encodings other than the native (Latin1 or EBCDIC), see sv_recode_to_utf8(). NOTE: this function is experimental and may change or be removed without notice. U8* bytes_to_utf8(const U8 *s, STRLEN *len)','name' => 'bytes_to_utf8'},'SvIsCOW_shared_hash' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write shared hash key scalar. bool SvIsCOW_shared_hash(SV* sv)','name' => 'SvIsCOW_shared_hash'},'sv_pvn' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn(SV *sv, STRLEN *lp)','name' => 'sv_pvn'},'sv_setref_iv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_iv(SV* rv, const char* classname, IV iv)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => '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. Uses the "OOK hack". Beware: after this function returns, C and SvPVX_const(sv) may no longer refer to the same chunk of data. void sv_chop(SV* sv, const char* ptr)','name' => 'sv_chop'},'sv_backoff' => {'text' => 'Remove any string offset. You should normally use the C macro wrapper instead. int sv_backoff(SV* sv)','name' => 'sv_backoff'},'sv_catsv_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_catsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_catsv_nomg'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setuv_mg(SV *sv, UV u)','name' => 'sv_setuv_mg'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually handled automatically by C. See C.','name' => 'XS_VERSION'},'PL_na' => {'text' => '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','name' => 'PL_na'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the SV is set to 1. SV* newSViv(IV i)','name' => 'newSViv'},'sv_untaint' => {'text' => 'Untaint an SV. Use C instead. void sv_untaint(SV* sv)','name' => 'sv_untaint'},'sv_setpv' => {'text' => '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)','name' => 'sv_setpv'},'Newxz' => {'text' => 'The XSUB-writer\'s interface to the C C function. The allocated memory is zeroed with C. See also C. void Newxz(void* ptr, int nitems, type)','name' => 'Newxz'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See C.','name' => 'SVt_PVHV'},'SvGROW' => {'text' => '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)','name' => 'SvGROW'},'gv_fetchmethod' => {'text' => 'See L. GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'dMULTICALL' => {'text' => 'Declare local variables for a multicall. See L. dMULTICALL;','name' => 'dMULTICALL'},'sv_catpv' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpv(SV* sv, const char* ptr)','name' => 'sv_catpv'},'sv_len' => {'text' => 'Returns the length of the string in the SV. Handles magic and type coercion. See also C, which gives raw access to the xpv_cur slot. STRLEN sv_len(SV* sv)','name' => 'sv_len'},'SvPVbyte_nolen' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_nolen(SV* sv)','name' => 'SvPVbyte_nolen'},'sv_pvutf8' => {'text' => 'Use the C macro instead char* sv_pvutf8(SV *sv)','name' => 'sv_pvutf8'},'SvRX' => {'text' => 'Convenience macro to get the REGEXP from a SV. This is approximately equivalent to the following snippet: if (SvMAGICAL(sv)) mg_get(sv); if (SvROK(sv) && (tmpsv = (SV*)SvRV(sv)) && SvTYPE(tmpsv) == SVt_PVMG && (tmpmg = mg_find(tmpsv, PERL_MAGIC_qr))) { return (REGEXP *)tmpmg->mg_obj; } NULL will be returned if a REGEXP* is not found. REGEXP * SvRX(SV *sv)','name' => 'SvRX'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See C.','name' => 'SVt_PVAV'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L. LEAVE;','name' => 'LEAVE'},'hv_undef' => {'text' => 'Undefines the hash. void hv_undef(HV *hv)','name' => 'hv_undef'},'SvSetMagicSV_nosteal' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetMagicSV_nosteal'},'hv_delete_ent' => {'text' => '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 *hv, SV *keysv, I32 flags, U32 hash)','name' => 'hv_delete_ent'},'CLASS' => {'text' => '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','name' => 'CLASS'},'savesvpv' => {'text' => 'A version of C/C which gets the string to duplicate from the passed in SV using C char* savesvpv(SV* sv)','name' => 'savesvpv'},'sv_isobject' => {'text' => '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)','name' => 'sv_isobject'},'sv_pvn_force_flags' => {'text' => 'Get a sensible string out of the SV somehow. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You normally want to use the various wrapper macros instead: see C and C char* sv_pvn_force_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_pvn_force_flags'},'HeKLEN' => {'text' => '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)','name' => 'HeKLEN'},'to_utf8_title' => {'text' => 'Convert the UTF-8 encoded character at p to its titlecase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the titlecase version may be longer than the original character. The first character of the titlecased version is returned (but note, as explained above, that there may be more.) UV to_utf8_title(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_title'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHn(NV nv)','name' => 'PUSHn'},'mPUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void mPUSHi(IV iv)','name' => 'mPUSHi'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it. See C for a version which guarantees to evaluate sv only once. IV SvIV(SV* sv)','name' => 'SvIV'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. SV PL_sv_yes','name' => 'PL_sv_yes'},'sv_nosharing' => {'text' => 'Dummy routine which "shares" an SV when there is no sharing module present. Or "locks" it. Or "unlocks" it. In other words, ignores its single SV argument. 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 *sv)','name' => 'sv_nosharing'},'SvUTF8_off' => {'text' => 'Unsets the UTF-8 status of an SV. void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'looks_like_number' => {'text' => 'Test if the content of an SV looks like a number (or is a number). C and C are treated as numbers (so will not issue a non-numeric warning), even if your atof() doesn\'t grok them. I32 looks_like_number(SV* sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpv_mg(SV *sv, const char *ptr)','name' => 'sv_catpv_mg'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'sv_setref_uv' => {'text' => 'Copies an unsigned 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 have a reference count of 1, and the RV will be returned. SV* sv_setref_uv(SV* rv, const char* classname, UV uv)','name' => 'sv_setref_uv'},'getcwd_sv' => {'text' => 'Fill the sv with current working directory int getcwd_sv(SV* sv)','name' => 'getcwd_sv'},'newSVpvs_share' => {'text' => 'Like C, but takes a literal string instead of a string/length pair and omits the hash parameter. SV* newSVpvs_share(const char* s)','name' => 'newSVpvs_share'},'newSVpv' => {'text' => '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)','name' => 'newSVpv'},'sv_2pvbyte' => {'text' => 'Return a pointer to the byte-encoded representation of the SV, and set *lp to its length. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte(SV* sv, STRLEN* lp)','name' => 'sv_2pvbyte'},'fbm_instr' => {'text' => '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* littlestr, U32 flags)','name' => 'fbm_instr'},'sv_setpvf' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Does not handle \'set\' magic. See C. void sv_setpvf(SV* sv, const char* pat, ...)','name' => 'sv_setpvf'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHn(NV nv)','name' => 'XPUSHn'},'SVt_PV' => {'text' => 'Pointer type flag for scalars. See C.','name' => 'SVt_PV'},'call_sv' => {'text' => '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, VOL I32 flags)','name' => 'call_sv'},'strGT' => {'text' => '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)','name' => 'strGT'},'mXPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary and mortalizes the SV. Does not use C. See also C and C. void mXPUSHs(SV* sv)','name' => 'mXPUSHs'},'sv_vcatpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. Does not handle \'set\' magic. See C. Usually used via its frontend C. void sv_vcatpvf(SV* sv, const char* pat, va_list* args)','name' => 'sv_vcatpvf'},'sv_pos_u2b' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from the start of the string, to a count of the equivalent number of bytes; if lenp is non-zero, it does the same to lenp, but this time starting from the offset, rather than from the start of the string. Handles magic and type coercion. void sv_pos_u2b(SV* sv, I32* offsetp, I32* lenp)','name' => 'sv_pos_u2b'},'PERL_SYS_INIT3' => {'text' => 'Provides system-specific tune up of the C runtime environment necessary to run Perl interpreters. This should be called only once, before creating any Perl interpreters. void PERL_SYS_INIT3(int argc, char** argv, char** env)','name' => 'PERL_SYS_INIT3'},'upg_version' => {'text' => 'In-place upgrade of the supplied SV to a version object. SV *sv = upg_version(SV *sv, bool qv); Returns a pointer to the upgraded SV. Set the boolean qv if you want to force this SV to be interpreted as an "extended" version. SV* upg_version(SV *ver, bool qv)','name' => 'upg_version'},'HeSVKEY_set' => {'text' => '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)','name' => 'HeSVKEY_set'},'POPl' => {'text' => 'Pops a long off the stack. long POPl','name' => 'POPl'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L. SPAGAIN;','name' => 'SPAGAIN'},'scan_version' => {'text' => 'Returns a pointer to the next character after the parsed version string, as well as upgrading the passed in SV to an RV. Function must be called with an already existing SV like sv = newSV(0); s = scan_version(s, SV *sv, bool qv); Performs some preprocessing to the string to ensure that it has the correct characteristics of a version. Flags the object if it contains an underscore (which denotes this is an alpha version). The boolean qv denotes that the version should be interpreted as if it had multiple decimals, even if it doesn\'t. const char* scan_version(const char *s, SV *rv, bool qv)','name' => 'scan_version'},'SvIOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains an integer. Checks the B setting. Use C instead. U32 SvIOKp(SV* sv)','name' => 'SvIOKp'},'get_cv' => {'text' => 'Uses C to get the length of C, then calls C. NOTE: the perl_ form of this function is deprecated. CV* get_cv(const char* name, I32 flags)','name' => 'get_cv'},'vnumify' => {'text' => 'Accepts a version object and returns the normalized floating point representation. Call like: sv = vnumify(rv); NOTE: you can pass either the object directly or the SV contained within the RV. SV* vnumify(SV *vs)','name' => 'vnumify'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the stack. void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'SvUNLOCK' => {'text' => 'Releases a mutual exclusion lock on sv if a suitable module has been loaded. void SvUNLOCK(SV* sv)','name' => 'SvUNLOCK'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C. int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV (using C). The new SV is marked as mortal. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_mortalcopy(SV* oldsv)','name' => 'sv_mortalcopy'},'sv_catpvn_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_catpvn_nomg(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn_nomg'},'newSVpvs_flags' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV* newSVpvs_flags(const char* s, U32 flags)','name' => 'newSVpvs_flags'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See L.','name' => 'G_NOARGS'},'savepvn' => {'text' => 'Perl\'s version of what C would be if it existed. Returns a pointer to a newly allocated string which is a duplicate of the first C bytes from C, plus a trailing NUL byte. The memory allocated for the new string can be freed with the C function. char* savepvn(const char* pv, I32 len)','name' => 'savepvn'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized. This relies on the fact that uninitialized array elements are set to C<&PL_sv_undef>. bool av_exists(AV *av, I32 key)','name' => 'av_exists'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C. STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'sv_bless' => {'text' => '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)','name' => 'sv_bless'},'sv_isa' => {'text' => '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)','name' => 'sv_isa'},'sv_catpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. If the appended data contains "wide" characters (including, but not limited to, SVs with a UTF-8 PV formatted with %s, and characters >255 formatted with %c), the original SV might get upgraded to UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. If the original SV was UTF-8, the pattern should be valid UTF-8; if the original SV was bytes, the pattern should be too. void sv_catpvf(SV* sv, const char* pat, ...)','name' => 'sv_catpvf'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C. void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'utf8_to_uvuni' => {'text' => 'Returns the Unicode code point of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. This function should only be used when the returned UV is considered an index into the Unicode semantic tables (e.g. swashes). If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvuni(const U8 *s, STRLEN *retlen)','name' => 'utf8_to_uvuni'},'sv_2io' => {'text' => 'Using various gambits, try to get an IO from an SV: the IO slot if its a GV; or the recursive result if we\'re an RV; or the IO slot of the symbol named after the PV if we\'re a string. IO* sv_2io(SV* sv)','name' => 'sv_2io'},'SvMAGIC_set' => {'text' => 'Set the value of the MAGIC pointer in sv to val. See C. void SvMAGIC_set(SV* sv, MAGIC* val)','name' => 'SvMAGIC_set'},'newSVhek' => {'text' => 'Creates a new SV from the hash key structure. It will generate scalars that point to the shared string table where possible. Returns a new (undefined) SV if the hek is NULL. SV* newSVhek(const HEK *hek)','name' => 'newSVhek'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the C C is a US-ASCII (Basic Latin) alphabetic character. bool isALPHA(char ch)','name' => 'isALPHA'},'Nullhv' => {'text' => 'Null HV pointer.','name' => 'Nullhv'},'av_fill' => {'text' => 'Set the highest index in the array to the given number, equivalent to Perl\'s C<$#array = $fill;>. The number of elements in the an array will be C after av_fill() returns. If the array was previously shorter then the additional elements appended are set to C. If the array was longer, then the excess elements are freed. C is the same as C. void av_fill(AV *av, I32 fill)','name' => 'av_fill'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV. All of the following SvREFCNT_inc* macros are optimized versions of SvREFCNT_inc, and can be replaced with SvREFCNT_inc. SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C. svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'MoveD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * MoveD(void* src, void* dest, int nitems, type)','name' => 'MoveD'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'grok_bin' => {'text' => 'converts a string representing a binary number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*flags> gives output flags. If the value is <= C it is returned as a UV, the output flags are clear, and nothing is written to I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The binary number may optionally be prefixed with "0b" or "b" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the binary number may use \'_\' characters to separate digits. UV grok_bin(const char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_bin'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L. void perl_free(PerlInterpreter *my_perl)','name' => 'perl_free'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C. MAGIC* mg_find(const SV* sv, int type)','name' => 'mg_find'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'XPUSHmortal' => {'text' => 'Push a new mortal SV onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void XPUSHmortal()','name' => 'XPUSHmortal'},'SvVOK' => {'text' => 'Returns a boolean indicating whether the SV contains a v-string. bool SvVOK(SV* sv)','name' => 'SvVOK'},'newSVpvn_share' => {'text' => 'Creates a new SV with its SvPVX_const pointing to a shared string in the string table. If the string does not already exist in the table, it is created first. Turns on READONLY and FAKE. If the C parameter is non-zero, that value is used; otherwise the hash is computed. The string\'s hash can be later be retrieved from the SV with the C macro. The idea here is that as the string table is used for shared hash keys these strings will have SvPVX_const == HeKEY and hash lookup will avoid string compare. SV* newSVpvn_share(const char* s, I32 len, U32 hash)','name' => 'newSVpvn_share'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_setpvf_mg'},'SvPOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a character string. Checks the B setting. Use C instead. U32 SvPOKp(SV* sv)','name' => 'SvPOKp'},'sv_catpvn' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpvn(SV *dsv, const char *sstr, STRLEN len)','name' => 'sv_catpvn'},'sv_setref_pv' => {'text' => '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 have a reference count of 1, and the RV will be returned. 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)','name' => 'sv_setref_pv'},'fbm_compile' => {'text' => '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)','name' => 'fbm_compile'},'sv_utf8_downgrade' => {'text' => 'Attempts to convert the PV of an SV from characters to bytes. If the PV contains a character that cannot fit in a byte, this conversion will fail; in this case, either returns false or, if C is not true, croaks. This is not as a general purpose Unicode to byte encoding interface: use the Encode extension for that. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_downgrade(SV *sv, bool fail_ok)','name' => 'sv_utf8_downgrade'},'SvNIOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a number, integer or double. Checks the B setting. Use C instead. U32 SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'PERL_SYS_TERM' => {'text' => 'Provides system-specific clean up of the C runtime environment after running Perl interpreters. This should be called only once, after freeing any remaining Perl interpreters. void PERL_SYS_TERM()','name' => 'PERL_SYS_TERM'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either forward or backward. WARNING: do not use the following unless you *know* C is within the UTF-8 data pointed to by C *and* that on entry C is aligned on the first byte of character or just after the last byte of a character. U8* utf8_hop(const U8 *s, I32 off)','name' => 'utf8_hop'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide UTF-8 bytes as a single character. Handles magic and type coercion. STRLEN sv_len_utf8(SV* sv)','name' => 'sv_len_utf8'},'sv_setref_pvn' => {'text' => '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 have a reference count of 1, and the RV will be returned. Note that C copies the pointer while this copies the string. SV* sv_setref_pvn(SV* rv, const char* classname, const char* pv, STRLEN n)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for blessed scalars. See C.','name' => 'SVt_PVMG'},'PUSHp' => {'text' => '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. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHp(char* str, STRLEN len)','name' => 'PUSHp'},'SvREFCNT_inc_simple_void' => {'text' => 'Same as SvREFCNT_inc_simple, but can only be used if you don\'t need the return value. The macro doesn\'t need to return a meaningful value. void SvREFCNT_inc_simple_void(SV* sv)','name' => 'SvREFCNT_inc_simple_void'},'hv_clear_placeholders' => {'text' => '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 *hv)','name' => 'hv_clear_placeholders'},'mXPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void mXPUSHi(IV iv)','name' => 'mXPUSHi'},'dAX' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dAX;','name' => 'dAX'},'PL_sv_undef' => {'text' => 'This is the C SV. Always refer to this as C<&PL_sv_undef>. SV PL_sv_undef','name' => 'PL_sv_undef'},'SvRV_set' => {'text' => 'Set the value of the RV pointer in sv to val. See C. void SvRV_set(SV* sv, SV* val)','name' => 'SvRV_set'},'hv_iterkeysv' => {'text' => '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)','name' => 'hv_iterkeysv'},'grok_number' => {'text' => '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)','name' => 'grok_number'},'SvIVx' => {'text' => 'Coerces the given SV to an integer and returns it. Guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. IV SvIVx(SV* sv)','name' => 'SvIVx'},'grok_numeric_radix' => {'text' => 'Scan and skip for a numeric decimal separator (radix). bool grok_numeric_radix(const char **sp, const char *send)','name' => 'grok_numeric_radix'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the stack. void XST_mNO(int pos)','name' => 'XST_mNO'},'mPUSHp' => {'text' => 'Push a string onto the stack. The stack must have room for this element. The C indicates the length of the string. Does not use C. See also C, C and C. void mPUSHp(char* str, STRLEN len)','name' => 'mPUSHp'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array. Returns the deleted element. If C equals C, the element is freed and null is returned. SV* av_delete(AV *av, I32 key, I32 flags)','name' => 'av_delete'},'utf8_distance' => {'text' => 'Returns the number of UTF-8 characters between the UTF-8 pointers C and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. IV utf8_distance(const U8 *a, const U8 *b)','name' => 'utf8_distance'},'SvPV_nomg' => {'text' => 'Like C but doesn\'t process magic. char* SvPV_nomg(SV* sv, STRLEN len)','name' => 'SvPV_nomg'},'savepvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. char* savepvs(const char* s)','name' => 'savepvs'},'SvSTASH_set' => {'text' => 'Set the value of the STASH pointer in sv to val. See C. void SvSTASH_set(SV* sv, HV* val)','name' => 'SvSTASH_set'},'sv_collxfrm' => {'text' => 'Add Collate Transform magic to an SV if it doesn\'t already have it. Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the scalar data of the variable, but transformed to such a format that a normal memory comparison can be used to compare the data according to the locale settings. char* sv_collxfrm(SV* sv, STRLEN* nxp)','name' => 'sv_collxfrm'},'ZeroD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * ZeroD(void* dest, int nitems, type)','name' => 'ZeroD'},'SvUV_nomg' => {'text' => 'Like C but doesn\'t process magic. UV SvUV_nomg(SV* sv)','name' => 'SvUV_nomg'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'POPpx' => {'text' => 'Pops a string off the stack. char* POPpx','name' => 'POPpx'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'gv_stashpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. HV* gv_stashpvs(const char* name, I32 create)','name' => 'gv_stashpvs'},'Zero' => {'text' => '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)','name' => 'Zero'},'vcmp' => {'text' => 'Version object aware cmp. Both operands must already have been converted into version objects. int vcmp(SV *lhv, SV *rhv)','name' => 'vcmp'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'sv_setpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_setpvs(SV* sv, const char* s)','name' => 'sv_setpvs'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_iv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. IV sv_iv(SV* sv)','name' => 'sv_iv'},'pv_escape' => {'text' => 'Escapes at most the first "count" chars of pv and puts the results into dsv such that the size of the escaped string will not exceed "max" chars and will not contain any incomplete escape sequences. If flags contains PERL_PV_ESCAPE_QUOTE then any double quotes in the string will also be escaped. Normally the SV will be cleared before the escaped string is prepared, but when PERL_PV_ESCAPE_NOCLEAR is set this will not occur. If PERL_PV_ESCAPE_UNI is set then the input string is treated as Unicode, if PERL_PV_ESCAPE_UNI_DETECT is set then the input string is scanned using C to determine if it is Unicode. If PERL_PV_ESCAPE_ALL is set then all input chars will be output using C<\\x01F1> style escapes, otherwise only chars above 255 will be escaped using this style, other non printable chars will use octal or common escaped patterns like C<\\n>. If PERL_PV_ESCAPE_NOBACKSLASH then all chars below 255 will be treated as printable and will be output as literals. If PERL_PV_ESCAPE_FIRSTCHAR is set then only the first char of the string will be escaped, regardles of max. If the string is utf8 and the chars value is >255 then it will be returned as a plain hex sequence. Thus the output will either be a single char, an octal escape sequence, a special escape like C<\\n> or a 3 or more digit hex value. If PERL_PV_ESCAPE_RE is set then the escape char used will be a \'%\' and not a \'\\\\\'. This is because regexes very often contain backslashed sequences, whereas \'%\' is not a particularly common character in patterns. Returns a pointer to the escaped text as held by dsv. char* pv_escape(SV *dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags)','name' => 'pv_escape'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C.','name' => 'SVt_PVCV'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpviv_mg(SV *sv, IV iv)','name' => 'sv_setpviv_mg'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. Guarantees to C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'sv_2bool' => {'text' => 'This function is only called on magical items, and is only used by sv_true() or its macro equivalent. bool sv_2bool(SV* sv)','name' => 'sv_2bool'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'sv_newmortal' => {'text' => 'Creates a new null SV which is mortal. The reference count of the SV is set to 1. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_newmortal()','name' => 'sv_newmortal'},'sv_clear' => {'text' => 'Clear an SV: call any destructors, free up any memory used by the body, and free the body itself. The SV\'s head is I freed, although its type is set to all 1\'s so that it won\'t inadvertently be assumed to be live during global destruction etc. This function should only be called when REFCNT is zero. Most of the time you\'ll want to call C (or its macro wrapper C) instead. void sv_clear(SV* sv)','name' => 'sv_clear'},'SvOOK' => {'text' => 'Returns a U32 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). U32 SvOOK(SV* sv)','name' => 'SvOOK'},'SvPV_set' => {'text' => 'Set the value of the PV pointer in sv to val. See C. void SvPV_set(SV* sv, char* val)','name' => 'SvPV_set'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'SvGAMAGIC' => {'text' => 'Returns true if the SV has get magic or overloading. If either is true then the scalar is active data, and has the potential to return a new value every time it is accessed. Hence you must be careful to only read it once per user logical operation and work with that returned value. If neither is true then the scalar\'s value cannot change unless written to. U32 SvGAMAGIC(SV* sv)','name' => 'SvGAMAGIC'},'svtype' => {'text' => '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.','name' => 'svtype'},'load_module' => {'text' => '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 C. The optional trailing SV* arguments can be used to specify arguments to the module\'s import() method, similar to C. They must be terminated with a final NULL pointer. Note that this list can only be omitted when the PERL_LOADMOD_NOIMPORT flag has been used. Otherwise at least a single NULL pointer to designate the default import list is required. void load_module(U32 flags, SV* name, SV* ver, ...)','name' => 'load_module'},'get_hv' => {'text' => 'Returns the HV of the specified Perl hash. C are passed to C. If C is set and the Perl variable does not exist then it will be created. If C is zero 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 flags)','name' => 'get_hv'},'hv_clear' => {'text' => 'Clears a hash, making it empty. void hv_clear(HV* hv)','name' => 'hv_clear'},'PoisonNew' => {'text' => 'PoisonWith(0xAB) for catching access to allocated but uninitialized memory. void PoisonNew(void* dest, int nitems, type)','name' => 'PoisonNew'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES;','name' => 'XSRETURN_YES'},'sv_nv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. NV sv_nv(SV* sv)','name' => 'sv_nv'},'Poison' => {'text' => 'PoisonWith(0xEF) for catching access to freed memory. void Poison(void* dest, int nitems, type)','name' => 'Poison'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_catpvf_mg'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHu(UV uv)','name' => 'PUSHu'},'get_sv' => {'text' => 'Returns the SV of the specified Perl scalar. C are passed to C. If C is set and the Perl variable does not exist then it will be created. If C is zero 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 flags)','name' => 'get_sv'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. (Uses C). SV* newSVsv(SV* old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C. void hv_magic(HV *hv, GV *gv, int how)','name' => 'hv_magic'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *sv, const char *ptr)','name' => 'sv_setpv_mg'},'sv_2mortal' => {'text' => 'Marks an existing SV as mortal. The SV will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. SvTEMP() is turned on which means that the SV\'s string buffer can be "stolen" if this SV is copied. See also C and C. SV* sv_2mortal(SV* sv)','name' => 'sv_2mortal'},'XCPT_TRY_END' => {'text' => 'Ends a try block. See L.','name' => 'XCPT_TRY_END'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself. void av_undef(AV *av)','name' => 'av_undef'},'HeKEY' => {'text' => '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)','name' => 'HeKEY'},'pack_cat' => {'text' => '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, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)','name' => 'pack_cat'},'sv_cmp' => {'text' => '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. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp(SV* sv1, SV* sv2)','name' => 'sv_cmp'},'SvEND' => {'text' => '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)','name' => 'SvEND'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C, C or C for void, scalar or list context, respectively. U32 GIMME_V','name' => 'GIMME_V'},'sv_force_normal_flags' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg; if we\'re a copy-on-write scalar, this is the on-write time when we do the copy, and is also used locally. If C is set then a copy-on-write scalar drops its PV buffer (if any) and becomes SvPOK_off rather than making a copy. (Used where this scalar is about to be set to some other value.) In addition, the C parameter gets passed to C when unrefing. C calls this function with flags set to 0. void sv_force_normal_flags(SV *sv, U32 flags)','name' => 'sv_force_normal_flags'},'sv_setsv_flags' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. If the C parameter has the C bit set, will C on C if appropriate, else not. If the C parameter has the C bit set then the buffers of temps will not be stolen. and C are implemented in terms of this function. You probably want to use one of the assortment of wrappers, such as C, C, C and C. This is the primary function for copying scalars, and most other copy-ish functions and macros use this underneath. void sv_setsv_flags(SV *dstr, SV *sstr, I32 flags)','name' => 'sv_setsv_flags'},'is_utf8_char' => {'text' => 'Tests if some arbitrary number of bytes begins in a valid UTF-8 character. Note that an INVARIANT (i.e. ASCII on non-EBCDIC machines) character is a valid UTF-8 character. The actual number of bytes in the UTF-8 character will be returned if it is valid, otherwise 0. STRLEN is_utf8_char(const U8 *s)','name' => 'is_utf8_char'},'Copy' => {'text' => '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)','name' => 'Copy'},'sv_taint' => {'text' => 'Taint an SV. Use C instead. void sv_taint(SV* sv)','name' => 'sv_taint'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'sv_utf8_upgrade' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Will C on C if appropriate. Always sets the SvUTF8 flag to avoid future validity checks even if the whole string is the same in UTF-8 as not. Returns the number of bytes in the converted string This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains a signed integer. bool SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. Sets up the C and C variables by calling C and C. This is usually handled automatically by C. dXSARGS;','name' => 'dXSARGS'},'savesharedpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the C C is a US-ASCII (Basic Latin) whitespace. bool isSPACE(char ch)','name' => 'isSPACE'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* ptr)','name' => 'Safefree'},'gv_stashpvn' => {'text' => 'Returns a pointer to the stash for a specified package. The C parameter indicates the length of the C, in bytes. C is passed to C, so if set to C then the package will be created if it does not already exist. If the package does not exist and C is 0 (or any other setting that does not create packages) then NULL is returned. HV* gv_stashpvn(const char* name, U32 namelen, I32 flags)','name' => 'gv_stashpvn'},'mPUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void mPUSHu(UV uv)','name' => 'mPUSHu'},'newSV_type' => {'text' => 'Creates a new SV, of the type specified. The reference count for the new SV is set to 1. SV* newSV_type(svtype type)','name' => 'newSV_type'},'sv_setsv_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_setsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_setsv_nomg'},'SvREFCNT_inc_void_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value, and you know that I is not NULL. The macro doesn\'t need to return a meaningful value, or check for NULLness, so it\'s smaller and faster. void SvREFCNT_inc_void_NN(SV* sv)','name' => 'SvREFCNT_inc_void_NN'},'Perl_signbit' => {'text' => 'Return a non-zero integer if the sign bit on an NV is set, and 0 if it is not. If Configure detects this system has a signbit() that will work with our NVs, then we just use it via the #define in perl.h. Otherwise, fall back on this implementation. As a first pass, this gets everything right except -0.0. Alas, catching -0.0 is the main use for this function, so this is not too helpful yet. Still, at least we have the scaffolding in place to support other systems, should that prove useful. Configure notes: This function is called \'Perl_signbit\' instead of a plain \'signbit\' because it is easy to imagine a system having a signbit() function or macro that doesn\'t happen to work with our particular choice of NVs. We shouldn\'t just re-#define signbit as Perl_signbit and expect the standard system headers to be happy. Also, this is a no-context function (no pTHX_) because Perl_signbit() is usually re-#defined in perl.h as a simple macro call to the system\'s signbit(). Users should just always call Perl_signbit(). NOTE: this function is experimental and may change or be removed without notice. int Perl_signbit(NV f)','name' => 'Perl_signbit'},'av_create_and_push' => {'text' => 'Push an SV onto the end of the array, creating the array if necessary. A small internal helper function to remove a commonly duplicated idiom. NOTE: this function is experimental and may change or be removed without notice. void av_create_and_push(AV **const avp, SV *const val)','name' => 'av_create_and_push'},'PUSH_MULTICALL' => {'text' => 'Opening bracket for a lightweight callback. See L. PUSH_MULTICALL;','name' => 'PUSH_MULTICALL'},'XPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHp(char* str, STRLEN len)','name' => 'XPUSHp'},'sv_utf8_encode' => {'text' => 'Converts the PV of an SV to UTF-8, but then turns the C flag off so that it looks like octets again. void sv_utf8_encode(SV *sv)','name' => 'sv_utf8_encode'},'SvUTF8_on' => {'text' => 'Turn on the UTF-8 status of an SV (the data is not changed, just the flag). Do not use frivolously. void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_setpvn_mg'},'toLOWER' => {'text' => 'Converts the specified character to lowercase. Characters outside the US-ASCII (Basic Latin) range are viewed as not having any case. char toLOWER(char ch)','name' => 'toLOWER'},'POPp' => {'text' => 'Pops a string off the stack. Deprecated. New code should use POPpx. char* POPp','name' => 'POPp'},'SvIV_nomg' => {'text' => 'Like C but doesn\'t process magic. IV SvIV_nomg(SV* sv)','name' => 'SvIV_nomg'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'new_version' => {'text' => 'Returns a new version object based on the passed in SV: SV *sv = new_version(SV *ver); Does not alter the passed in ver SV. See "upg_version" if you want to upgrade the SV. SV* new_version(SV *ver)','name' => 'new_version'},'sv_pvbyten' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten(SV *sv, STRLEN *lp)','name' => 'sv_pvbyten'},'Nullav' => {'text' => 'Null AV pointer.','name' => 'Nullav'},'sv_copypv' => {'text' => 'Copies a stringified representation of the source SV into the destination SV. Automatically performs any necessary mg_get and coercion of numeric values into strings. Guaranteed to preserve UTF8 flag even from overloaded objects. Similar in nature to sv_2pv[_flags] but operates directly on an SV instead of just the string. Mostly uses sv_2pv_flags to do its work, except when that would lose the UTF-8\'ness of the PV. void sv_copypv(SV* dsv, SV* ssv)','name' => 'sv_copypv'},'sv_pv' => {'text' => 'Use the C macro instead char* sv_pv(SV *sv)','name' => 'sv_pv'},'pv_pretty' => {'text' => 'Converts a string into something presentable, handling escaping via pv_escape() and supporting quoting and ellipses. If the PERL_PV_PRETTY_QUOTE flag is set then the result will be double quoted with any double quotes in the string escaped. Otherwise if the PERL_PV_PRETTY_LTGT flag is set then the result be wrapped in angle brackets. If the PERL_PV_PRETTY_ELLIPSES flag is set and not all characters in string were output then an ellipsis C<...> will be appended to the string. Note that this happens AFTER it has been quoted. If start_color is non-null then it will be inserted after the opening quote (if there is one) but before the escaped text. If end_color is non-null then it will be inserted after the escaped text but before any quotes or ellipses. Returns a pointer to the prettified text as held by dsv. char* pv_pretty(SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags)','name' => 'pv_pretty'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setnv_mg(SV *sv, NV num)','name' => 'sv_setnv_mg'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV *hv, char **key, I32 *retlen)','name' => 'hv_iternextsv'},'utf8_to_bytes' => {'text' => 'Converts a string C of length C from UTF-8 into native byte encoding. Unlike C, this over-writes the original string, and updates len to contain the new length. Returns zero on failure, setting C to -1. If you need a copy of the string, see C. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_pvbyten_force' => {'text' => 'The backend for the C macro. Always use the macro instead. char* sv_pvbyten_force(SV* sv, STRLEN* lp)','name' => 'sv_pvbyten_force'},'uvuni_to_utf8_flags' => {'text' => 'Adds the UTF-8 representation of the Unicode codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvuni_to_utf8_flags(d, uv, flags); or, in most cases, d = uvuni_to_utf8(d, uv); (which is equivalent to) d = uvuni_to_utf8_flags(d, uv, 0); is the recommended Unicode-aware way of saying *(d++) = uv; U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)','name' => 'uvuni_to_utf8_flags'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'mPUSHs' => {'text' => 'Push an SV onto the stack and mortalizes the SV. The stack must have room for this element. Does not use C. See also C and C. void mPUSHs(SV* sv)','name' => 'mPUSHs'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See L.','name' => 'G_DISCARD'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'XST_mNV' => {'text' => '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)','name' => 'XST_mNV'},'UNDERBAR' => {'text' => 'The SV* corresponding to the $_ variable. Works even if there is a lexical $_ in scope.','name' => 'UNDERBAR'},'pad_sv' => {'text' => '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)','name' => 'pad_sv'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'SvPVutf8_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_force(SV* sv, STRLEN len)','name' => 'SvPVutf8_force'},'sv_2pvutf8_nolen' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8_nolen(SV* sv)','name' => 'sv_2pvutf8_nolen'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C.','name' => 'SVt_NV'},'mro_get_linear_isa' => {'text' => 'Returns either C or C for the given stash, dependant upon which MRO is in effect for that stash. The return value is a read-only AV*. You are responsible for C on the return value if you plan to store it anywhere semi-permanently (otherwise it might be deleted out from under you the next time the cache is invalidated). AV* mro_get_linear_isa(HV* stash)','name' => 'mro_get_linear_isa'},'av_store' => {'text' => '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 *av, I32 key, SV *val)','name' => 'av_store'},'SvPVbytex' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex(SV* sv, STRLEN len)','name' => 'SvPVbytex'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and L. void PUSHMARK(SP)','name' => 'PUSHMARK'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. SV* ST(int ix)','name' => 'ST'},'call_pv' => {'text' => '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)','name' => 'call_pv'},'av_fetch' => {'text' => '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 *av, I32 key, I32 lval)','name' => 'av_fetch'},'gv_fetchmeth_autoload' => {'text' => '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 C. 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)','name' => 'gv_fetchmeth_autoload'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV *hv, HE *entry)','name' => 'hv_iterval'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. const char* sv_reftype(const SV* sv, int ob)','name' => 'sv_reftype'},'sv_pos_b2u' => {'text' => 'Converts the value pointed to by offsetp from a count of bytes from the start of the string, to a count of the equivalent number of UTF-8 chars. Handles magic and type coercion. void sv_pos_b2u(SV* sv, I32* offsetp)','name' => 'sv_pos_b2u'},'SvREFCNT_inc_simple_void_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value, and you know that I is not NULL. The macro doesn\'t need to return a meaningful value, or check for NULLness, so it\'s smaller and faster. void SvREFCNT_inc_simple_void_NN(SV* sv)','name' => 'SvREFCNT_inc_simple_void_NN'},'av_len' => {'text' => 'Returns the highest index in the array. The number of elements in the array is C. Returns -1 if the array is empty. I32 av_len(const AV *av)','name' => 'av_len'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C.','name' => 'SVt_IV'},'SvIsCOW' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write. (either shared hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for COW) bool SvIsCOW(SV* sv)','name' => 'SvIsCOW'},'sv_unmagic' => {'text' => 'Removes all magic of type C from an SV. int sv_unmagic(SV* sv, int type)','name' => 'sv_unmagic'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled. void SvTAINT(SV* sv)','name' => 'SvTAINT'},'sv_catsv' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catsv(SV *dstr, SV *sstr)','name' => 'sv_catsv'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'ax' => {'text' => 'Variable which is setup by C to indicate the stack base offset, used by the C, C and C macros. The C macro must be called prior to setup the C variable. I32 ax','name' => 'ax'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'my_sprintf' => {'text' => 'The C library C, wrapped if necessary, to ensure that it will return the length of the string written to the buffer. Only rare pre-ANSI systems need the wrapper function - usually this is a direct call to C. int my_sprintf(char *buffer, const char *pat, ...)','name' => 'my_sprintf'},'to_utf8_fold' => {'text' => 'Convert the UTF-8 encoded character at p to its foldcase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the foldcase version may be longer than the original character (up to three characters). The first character of the foldcased version is returned (but note, as explained above, that there may be more.) UV to_utf8_fold(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_fold'},'to_utf8_upper' => {'text' => 'Convert the UTF-8 encoded character at p to its uppercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the uppercase version may be longer than the original character. The first character of the uppercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_upper(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_upper'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. Uses C to determine the length of C, then calls C. HV* gv_stashpv(const char* name, I32 flags)','name' => 'gv_stashpv'},'sv_vcatpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vcatpvf_mg(SV* sv, const char* pat, va_list* args)','name' => 'sv_vcatpvf_mg'},'SvPVutf8x_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x_force(SV* sv, STRLEN len)','name' => 'SvPVutf8x_force'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHi(IV iv)','name' => 'PUSHi'},'mXPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void mXPUSHu(UV uv)','name' => 'mXPUSHu'},'hv_exists_ent' => {'text' => '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 *hv, SV *keysv, U32 hash)','name' => 'hv_exists_ent'},'SvLEN_set' => {'text' => 'Set the actual length of the string which is in the SV. See C. void SvLEN_set(SV* sv, STRLEN len)','name' => 'SvLEN_set'},'to_utf8_lower' => {'text' => 'Convert the UTF-8 encoded character at p to its lowercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the lowercase version may be longer than the original character. The first character of the lowercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_lower(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_lower'},'SvNIOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a number, integer or double. U32 SvNIOK(SV* sv)','name' => 'SvNIOK'},'mro_method_changed_in' => {'text' => 'Invalidates method caching on any child classes of the given stash, so that they might notice the changes in this one. Ideally, all instances of C in perl source outside of C should be replaced by calls to this. Perl automatically handles most of the common ways a method might be redefined. However, there are a few ways you could change a method in a stash without the cache code noticing, in which case you need to call this method afterwards: 1) Directly manipulating the stash HV entries from XS code. 2) Assigning a reference to a readonly scalar constant into a stash entry in order to create a constant subroutine (like constant.pm does). This same method is available from pure perl via, C. void mro_method_changed_in(HV* stash)','name' => 'mro_method_changed_in'},'unpack_str' => {'text' => '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(const char *pat, const char *patend, const char *s, const char *strbeg, const char *strend, char **new_s, I32 ocnt, U32 flags)','name' => 'unpack_str'},'newSVpvf' => {'text' => 'Creates a new SV and initializes it with the string formatted like C. SV* newSVpvf(const char* pat, ...)','name' => 'newSVpvf'},'Newxc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. See also C. void Newxc(void* ptr, int nitems, type, cast)','name' => 'Newxc'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C wrapper instead. SV* sv_newref(SV* sv)','name' => 'sv_newref'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L. int perl_destruct(PerlInterpreter *my_perl)','name' => 'perl_destruct'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'SvIVX' => {'text' => 'Returns the raw value in the SV\'s IV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. IV SvIVX(SV* sv)','name' => 'SvIVX'},'sv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the scalar sv, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument is as in pv_uni_display(). The pointer to the PV of the dsv is returned. char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim, UV flags)','name' => 'sv_uni_display'},'sv_vsetpvf' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Does not handle \'set\' magic. See C. Usually used via its frontend C. void sv_vsetpvf(SV* sv, const char* pat, va_list* args)','name' => 'sv_vsetpvf'},'newSVpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV* newSVpvs(const char* s)','name' => 'newSVpvs'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'XCPT_CATCH' => {'text' => 'Introduces a catch block. See L.','name' => 'XCPT_CATCH'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the stack. void XST_mYES(int pos)','name' => 'XST_mYES'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. You probably want to use one of the assortment of wrappers, such as C, C, C and C. void sv_setsv(SV *dstr, SV *sstr)','name' => 'sv_setsv'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'packlist' => {'text' => 'The engine implementing pack() Perl function. void packlist(SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist)','name' => 'packlist'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C for a version which guarantees to evaluate sv only once. NV SvNV(SV* sv)','name' => 'SvNV'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'SvUTF8' => {'text' => 'Returns a U32 value indicating whether the SV contains UTF-8 encoded data. Call this after SvPV() in case any call to string overloading updates the internal flag. U32 SvUTF8(SV* sv)','name' => 'SvUTF8'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an XSUB\'s aliases was used to invoke it. See L. I32 ix','name' => 'ix'},'cv_undef' => {'text' => 'Clear out all the active components of a CV. This can happen either by an explicit C, 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)','name' => 'cv_undef'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'XSRETURN_UV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_UV(IV uv)','name' => 'XSRETURN_UV'},'SvREFCNT_inc_simple' => {'text' => 'Same as SvREFCNT_inc, but can only be used with expressions without side effects. Since we don\'t have to store a temporary value, it\'s faster. SV* SvREFCNT_inc_simple(SV* sv)','name' => 'SvREFCNT_inc_simple'},'get_cvn_flags' => {'text' => 'Returns the CV of the specified Perl subroutine. C are passed to C. 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_cvn_flags(const char* name, STRLEN len, I32 flags)','name' => 'get_cvn_flags'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'vverify' => {'text' => 'Validates that the SV contains a valid version object. bool vverify(SV *vobj); Note that it only confirms the bare minimum structure (so as not to get confused by derived classes which may contain additional hash entries): bool vverify(SV *vs)','name' => 'vverify'},'dXSI32' => {'text' => 'Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. dXSI32;','name' => 'dXSI32'},'SvPVx' => {'text' => 'A version of C which guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. char* SvPVx(SV* sv, STRLEN len)','name' => 'SvPVx'},'dXCPT' => {'text' => 'Set up necessary local variables for exception handling. See L. dXCPT;','name' => 'dXCPT'},'sv_tainted' => {'text' => 'Test an SV for taintedness. Use C instead. bool sv_tainted(SV* sv)','name' => 'sv_tainted'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. If necessary, uses C and upgrades the SV to C. Returns a pointer to the character buffer. Use the C wrapper instead. char* sv_grow(SV* sv, STRLEN newlen)','name' => 'sv_grow'},'vnormal' => {'text' => 'Accepts a version object and returns the normalized string representation. Call like: sv = vnormal(rv); NOTE: you can pass either the object directly or the SV contained within the RV. SV* vnormal(SV *vs)','name' => 'vnormal'},'cv_const_sv' => {'text' => 'If C is a constant sub eligible for inlining. returns the constant value returned by the sub. Otherwise, returns NULL. Constant subs can be created with C or as described in L. SV* cv_const_sv(CV* cv)','name' => 'cv_const_sv'},'newSVnv' => {'text' => '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)','name' => 'newSVnv'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. Does not use C. See also C, C and C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry. SV* HeVAL(HE* he)','name' => 'HeVAL'},'HePV' => {'text' => '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. See also C. If you are using C to get values to pass to C to create a new SV, you should consider using C as it is more efficient. char* HePV(HE* he, STRLEN len)','name' => 'HePV'},'pv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the string spv, length len, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument can have UNI_DISPLAY_ISPRINT set to display isPRINT()able characters as themselves, UNI_DISPLAY_BACKSLASH to display the \\\\[nrfta\\\\] as the backslashed versions (like \'\\n\') (UNI_DISPLAY_BACKSLASH is preferred over UNI_DISPLAY_ISPRINT for \\\\). UNI_DISPLAY_QQ (and its alias UNI_DISPLAY_REGEX) have both UNI_DISPLAY_BACKSLASH and UNI_DISPLAY_ISPRINT turned on. The pointer to the PV of the dsv is returned. char* pv_uni_display(SV *dsv, const U8 *spv, STRLEN len, STRLEN pvlim, UV flags)','name' => 'pv_uni_display'},'SvGETMAGIC' => {'text' => 'Invokes C on an SV if it has \'get\' magic. This macro evaluates its argument more than once. void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_inc(SV* sv)','name' => 'sv_inc'},'sv_usepvn' => {'text' => 'Tells an SV to use C to find its string value. Implemented by calling C with C of 0, hence does not handle \'set\' magic. See C. void sv_usepvn(SV* sv, char* ptr, STRLEN len)','name' => 'sv_usepvn'},'SvPVbytex_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex_force(SV* sv, STRLEN len)','name' => 'SvPVbytex_force'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'warn' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Call this function the same way you call the C C function. See C. void warn(const char* pat, ...)','name' => 'warn'},'hv_delete' => {'text' => '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 *hv, const char *key, I32 klen, I32 flags)','name' => 'hv_delete'},'sv_cat_decode' => {'text' => 'The encoding is assumed to be an Encode object, the PV of the ssv is assumed to be octets in that encoding and decoding the input starts from the position which (PV + *offset) pointed to. The dsv will be concatenated the decoded UTF-8 string from ssv. Decoding will terminate when the string tstr appears in decoding output or the input ends on the PV of the ssv. The value which the offset points will be modified to the last input position on the ssv. Returns TRUE if the terminator was found, else returns FALSE. bool sv_cat_decode(SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen)','name' => 'sv_cat_decode'},'POP_MULTICALL' => {'text' => 'Closing bracket for a lightweight callback. See L. POP_MULTICALL;','name' => 'POP_MULTICALL'},'SvIV_set' => {'text' => 'Set the value of the IV pointer in sv to val. It is possible to perform the same function of this macro with an lvalue assignment to C. With future Perls, however, it will be more efficient to use C instead of the lvalue assignment to C. void SvIV_set(SV* sv, IV val)','name' => 'SvIV_set'},'sv_setiv' => {'text' => 'Copies an integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setiv(SV* sv, IV num)','name' => 'sv_setiv'},'sv_report_used' => {'text' => 'Dump the contents of all SVs not yet freed. (Debugging aid). void sv_report_used()','name' => 'sv_report_used'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. void EXTEND(SP, int nitems)','name' => 'EXTEND'},'SvNVX' => {'text' => 'Returns the raw value in the SV\'s NV slot, without checks or conversions. Only use when you are sure SvNOK is true. See also C. NV SvNVX(SV* sv)','name' => 'SvNVX'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(UV u)','name' => 'newSVuv'},'gv_fetchmeth' => {'text' => '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. 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)','name' => 'gv_fetchmeth'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. U32 HeHASH(HE* he)','name' => 'HeHASH'},'SvIOK' => {'text' => 'Returns a U32 value indicating whether the SV contains an integer. U32 SvIOK(SV* sv)','name' => 'SvIOK'},'sv_does' => {'text' => 'Returns a boolean indicating whether the SV performs a specific, named role. The SV can be a Perl object or the name of a Perl class. bool sv_does(SV* sv, const char* name)','name' => 'sv_does'},'SvPV_force' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'HeUTF8' => {'text' => 'Returns whether the C value returned by C is encoded in UTF-8, doing any necessary dereferencing of possibly C keys. The value returned will be 0 or non-0, not necessarily 1 (or even a value with any low bits set), so B blindly assign this to a C variable, as C may be a typedef for C. char* HeUTF8(HE* he, STRLEN len)','name' => 'HeUTF8'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part attributable to C. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a string and disables all other OK bits, and leaves the UTF-8 status as it was. void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic after a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'},'SvTRUE' => {'text' => 'Returns a boolean indicating whether Perl would evaluate the SV as true or false. See SvOK() for a defined/undefined test. Does not handle \'get\' magic. bool SvTRUE(SV* sv)','name' => 'SvTRUE'},'grok_hex' => {'text' => 'converts a string representing a hex number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0x" or "x" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the hex number may use \'_\' characters to separate digits. UV grok_hex(const char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_hex'},'hv_iternext_flags' => {'text' => 'Returns entries from a hash iterator. See C and C. The C 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 C<&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 *hv, I32 flags)','name' => 'hv_iternext_flags'},'is_utf8_string_loclen' => {'text' => 'Like is_utf8_string() but stores the location of the failure (in the case of "utf8ness failure") or the location s+len (in the case of "utf8ness success") in the C, and the number of UTF-8 encoded characters in the C. See also is_utf8_string_loc() and is_utf8_string(). bool is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el)','name' => 'is_utf8_string_loclen'},'call_method' => {'text' => '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)','name' => 'call_method'},'SvLOCK' => {'text' => 'Arranges for a mutual exclusion lock to be obtained on sv if a suitable module has been loaded. void SvLOCK(SV* sv)','name' => 'SvLOCK'},'sv_vsetpvfn' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Usually used via one of its frontends C and C. void sv_vsetpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vsetpvfn'},'perl_parse' => {'text' => 'Tells a Perl interpreter to parse a Perl script. See L. int perl_parse(PerlInterpreter *my_perl, XSINIT_t xsinit, int argc, char** argv, char** env)','name' => 'perl_parse'},'to_utf8_case' => {'text' => 'The "p" contains the pointer to the UTF-8 string encoding the character that is being converted. The "ustrp" is a pointer to the character buffer to put the conversion result to. The "lenp" is a pointer to the length of the result. The "swashp" is a pointer to the swash to use. Both the special and normal mappings are stored lib/unicore/To/Foo.pl, and loaded by SWASHNEW, using lib/utf8_heavy.pl. The special (usually, but not always, a multicharacter mapping), is tried first. The "special" is a string like "utf8::ToSpecLower", which means the hash %utf8::ToSpecLower. The access to the hash is through Perl_to_utf8_case(). The "normal" is a string like "ToLower" which means the swash %utf8::ToLower. UV to_utf8_case(const U8 *p, U8* ustrp, STRLEN *lenp, SV **swashp, const char *normal, const char *special)','name' => 'to_utf8_case'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory used by the array itself. void av_clear(AV *av)','name' => 'av_clear'},'sv_force_normal' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. See also C. void sv_force_normal(SV *sv)','name' => 'sv_force_normal'},'av_unshift' => {'text' => '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 *av, I32 num)','name' => 'av_unshift'},'SvREFCNT_inc_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you know I is not NULL. Since we don\'t have to check the NULLness, it\'s faster and smaller. SV* SvREFCNT_inc_NN(SV* sv)','name' => 'SvREFCNT_inc_NN'},'POPpbytex' => {'text' => 'Pops a string off the stack which must consist of bytes i.e. characters < 256. char* POPpbytex','name' => 'POPpbytex'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. UV SvUVX(SV* sv)','name' => 'SvUVX'},'SvSetMagicSV' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV(SV* dsb, SV* ssv)','name' => 'SvSetMagicSV'},'sv_utf8_decode' => {'text' => 'If the PV of the SV is an octet sequence in UTF-8 and contains a multiple-byte character, the C flag is turned on so that it looks like a character. If the PV contains only single-byte characters, the C flag stays being off. Scans PV for validity and returns false if the PV is invalid UTF-8. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_decode(SV *sv)','name' => 'sv_utf8_decode'},'hv_stores' => {'text' => 'Like C, but takes a literal string instead of a string/length pair and omits the hash parameter. SV** hv_stores(HV* tb, const char* key, NULLOK SV* val)','name' => 'hv_stores'},'eval_sv' => {'text' => '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)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'sv_utf8_upgrade_nomg' => {'text' => 'Like sv_utf8_upgrade, but doesn\'t do magic on C STRLEN sv_utf8_upgrade_nomg(SV *sv)','name' => 'sv_utf8_upgrade_nomg'},'Move' => {'text' => '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)','name' => 'Move'},'sv_catpvn_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. void sv_catpvn_flags(SV *dstr, const char *sstr, STRLEN len, I32 flags)','name' => 'sv_catpvn_flags'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'GIMME' => {'text' => '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','name' => 'GIMME'},'sv_2iv_flags' => {'text' => 'Return the integer value of an SV, doing any necessary string conversion. If flags includes SV_GMAGIC, does an mg_get() first. Normally used via the C and C macros. IV sv_2iv_flags(SV* sv, I32 flags)','name' => 'sv_2iv_flags'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs. I needs to be static storage, as it is used directly as CvFILE(), without a copy being made.','name' => 'newXS'},'isALNUM' => {'text' => 'Returns a boolean indicating whether the C C is a US-ASCII (Basic Latin) alphanumeric character (including underscore) or digit. bool isALNUM(char ch)','name' => 'isALNUM'},'XCPT_RETHROW' => {'text' => 'Rethrows a previously caught exception. See L. XCPT_RETHROW;','name' => 'XCPT_RETHROW'},'my_snprintf' => {'text' => 'The C library C functionality, if available and standards-compliant (uses C, actually). However, if the C is not available, will unfortunately use the unsafe C which can overrun the buffer (there is an overrun check, but that may be too late). Consider using C instead, or getting C. int my_snprintf(char *buffer, const Size_t len, const char *format, ...)','name' => 'my_snprintf'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. bool SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'PUSHmortal' => {'text' => 'Push a new mortal SV onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void PUSHmortal()','name' => 'PUSHmortal'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter *my_perl)','name' => 'perl_construct'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. bool SvUOK(SV* sv)','name' => 'SvUOK'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_dec(SV* sv)','name' => 'sv_dec'},'strLE' => {'text' => '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)','name' => 'strLE'},'pv_display' => {'text' => 'Similar to pv_escape(dsv,pv,cur,pvlim,PERL_PV_ESCAPE_QUOTE); except that an additional "\\0" will be appended to the string when len > cur and pv[cur] is "\\0". Note that the final string may be up to 7 chars longer than pvlim. char* pv_display(SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)','name' => 'pv_display'},'newSVpvn_flags' => {'text' => '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. If the C argument is NULL the new SV will be undefined. Currently the only flag bits accepted are C and C. If C is set, then C is called on the result before returning. If C is set, then it will be set on the new SV. C is a convenience wrapper for this function, defined as #define newSVpvn_utf8(s, len, u) \\ newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0) SV* newSVpvn_flags(const char* s, STRLEN len, U32 flags)','name' => 'newSVpvn_flags'},'sv_2pvbyte_nolen' => {'text' => 'Return a pointer to the byte-encoded representation of the SV. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'SvOK' => {'text' => 'Returns a U32 value indicating whether the value is defined. This is only meaningful for scalars. U32 SvOK(SV* sv)','name' => 'SvOK'},'sv_setref_nv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_nv(SV* rv, const char* classname, NV nv)','name' => 'sv_setref_nv'},'uvchr_to_utf8' => {'text' => 'Adds the UTF-8 representation of the Native codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvchr_to_utf8(d, uv); is the recommended wide native character-aware way of saying *(d++) = uv; U8* uvchr_to_utf8(U8 *d, UV uv)','name' => 'uvchr_to_utf8'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the C C is a US-ASCII (Basic Latin) digit. bool isDIGIT(char ch)','name' => 'isDIGIT'},'eval_pv' => {'text' => '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)','name' => 'eval_pv'},'sv_usepvn_flags' => {'text' => '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. By default this function will realloc (i.e. move) the memory pointed to by C, so that pointer should not be freed or used by the programmer after giving it to sv_usepvn, and neither should any pointers from "behind" that pointer (e.g. ptr + 1) be used. If C & SV_SMAGIC is true, will call SvSETMAGIC. If C & SV_HAS_TRAILING_NUL is true, then C must be NUL, and the realloc will be skipped. (i.e. the buffer is actually at least 1 byte longer than C, and already meets the requirements for storing in C) void sv_usepvn_flags(SV* sv, char* ptr, STRLEN len, U32 flags)','name' => 'sv_usepvn_flags'},'hv_assert' => {'text' => 'Check that a hash is in an internally consistent state. void hv_assert(HV *hv)','name' => 'hv_assert'},'my_vsnprintf' => {'text' => 'The C library C if available and standards-compliant. However, if if the C is not available, will unfortunately use the unsafe C which can overrun the buffer (there is an overrun check, but that may be too late). Consider using C instead, or getting C. int my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap)','name' => 'my_vsnprintf'},'sv_free' => {'text' => 'Decrement an SV\'s reference count, and if it drops to zero, call C to invoke destructors and free up any memory used by the body; finally, deallocate the SV\'s head itself. Normally called via a wrapper macro C. void sv_free(SV* sv)','name' => 'sv_free'},'SvPVbyte_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_force(SV* sv, STRLEN len)','name' => 'SvPVbyte_force'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. CV* newCONSTSUB(HV* stash, const char* name, SV* sv)','name' => 'newCONSTSUB'},'SvSHARE' => {'text' => 'Arranges for sv to be shared between threads if a suitable module has been loaded. void SvSHARE(SV* sv)','name' => 'SvSHARE'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_pop(AV *av)','name' => 'av_pop'},'croak' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Normally call this function the same way you call the C C function. Calling C returns control directly to Perl, sidestepping the normal C order of execution. See C. If you want to throw an exception object, assign the object to C<$@> and then pass C to croak(): errsv = get_sv("@", GV_ADD); sv_setsv(errsv, exception_object); croak(NULL); void croak(const char* pat, ...)','name' => 'croak'},'sortsv' => {'text' => 'Sort an array. Here is an example: sortsv(AvARRAY(av), av_len(av)+1, Perl_sv_cmp_locale); Currently this always uses mergesort. See sortsv_flags for a more flexible routine. void sortsv(SV** array, size_t num_elts, SVCOMPARE_t cmp)','name' => 'sortsv'},'THIS' => {'text' => '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','name' => 'THIS'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually handled by C. void XSRETURN(int nitems)','name' => 'XSRETURN'},'scan_bin' => {'text' => 'For backwards compatibility. Use C instead. NV scan_bin(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_bin'},'Nullcv' => {'text' => 'Null CV pointer.','name' => 'Nullcv'},'get_av' => {'text' => 'Returns the AV of the specified Perl array. C are passed to C. If C is set and the Perl variable does not exist then it will be created. If C is zero 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 flags)','name' => 'get_av'},'sv_2pv_nolen' => {'text' => 'Like C, but doesn\'t return the length too. You should usually use the macro wrapper C instead. char* sv_2pv_nolen(SV* sv)','name' => 'sv_2pv_nolen'},'MULTICALL' => {'text' => 'Make a lightweight callback. See L. MULTICALL;','name' => 'MULTICALL'},'SvPVbyte' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'PoisonFree' => {'text' => 'PoisonWith(0xEF) for catching access to freed memory. void PoisonFree(void* dest, int nitems, type)','name' => 'PoisonFree'},'toUPPER' => {'text' => 'Converts the specified character to uppercase. Characters outside the US-ASCII (Basic Latin) range are viewed as not having any case. char toUPPER(char ch)','name' => 'toUPPER'},'is_utf8_string_loc' => {'text' => 'Like is_utf8_string() but stores the location of the failure (in the case of "utf8ness failure") or the location s+len (in the case of "utf8ness success") in the C. See also is_utf8_string_loclen() and is_utf8_string(). bool is_utf8_string_loc(const U8 *s, STRLEN len, const U8 **p)','name' => 'is_utf8_string_loc'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally appending to the currently-stored string. char* sv_gets(SV* sv, PerlIO* fp, I32 append)','name' => 'sv_gets'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'SvPVutf8x' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'sv_2cv' => {'text' => 'Using various gambits, try to get a CV from an SV; in addition, try if possible to set C<*st> and C<*gvp> to the stash and GV associated with it. The flags in C are passed to sv_fetchsv. CV* sv_2cv(SV* sv, HV** st, GV** gvp, I32 lref)','name' => 'sv_2cv'},'SvPV_force_nomg' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. Doesn\'t process magic. char* SvPV_force_nomg(SV* sv, STRLEN len)','name' => 'SvPV_force_nomg'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. Will also turn off the UTF-8 status. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'dUNDERBAR' => {'text' => 'Sets up the C variable for an XSUB that wishes to use C. dUNDERBAR;','name' => 'dUNDERBAR'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'XCPT_TRY_START' => {'text' => 'Starts a try block. See L.','name' => 'XCPT_TRY_START'},'sv_pvbyte' => {'text' => 'Use C instead. char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'sv_uv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. UV sv_uv(SV* sv)','name' => 'sv_uv'},'hv_fetch' => {'text' => '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 an C. See L for more information on how to use this function on tied hashes. SV** hv_fetch(HV *hv, const char *key, I32 klen, I32 lval)','name' => 'hv_fetch'},'sv_unref_flags' => {'text' => '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. The C argument can contain C to force the reference count to be decremented (otherwise the decrementing is conditional on the reference count being different from one or the reference being a readonly SV). See C. void sv_unref_flags(SV *ref, U32 flags)','name' => 'sv_unref_flags'},'hv_scalar' => {'text' => 'Evaluates the hash in scalar context and returns the result. Handles magic when the hash is tied. SV* hv_scalar(HV *hv)','name' => 'hv_scalar'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'Nullch' => {'text' => 'Null character pointer.','name' => 'Nullch'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV *sv, SV *nsv, const char *key, I32 klen)','name' => 'mg_copy'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'grok_oct' => {'text' => 'converts a string representing an octal number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). If C is set in I<*flags> then the octal number may use \'_\' characters to separate digits. UV grok_oct(const char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_oct'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C flag on this RV; give the referred-to SV C magic if it hasn\'t already; and push a back-reference to this RV onto the array of backreferences associated with that magic. If the RV is magical, set magic will be called after the RV is cleared. SV* sv_rvweaken(SV *sv)','name' => 'sv_rvweaken'},'scan_hex' => {'text' => 'For backwards compatibility. Use C instead. NV scan_hex(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_hex'},'newSVpvn' => {'text' => '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. If the C argument is NULL the new SV will be undefined. SV* newSVpvn(const char* s, STRLEN len)','name' => 'newSVpvn'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the supplied vtable and returns a pointer to the magic added. Note that C will allow things that C will not. In particular, you can add magic to SvREADONLY SVs, and add more than one instance of the same \'how\'. If C is greater than zero then a C I of C is stored, if C is zero then C is stored as-is and - as another special case - if C<(name && namlen == HEf_SVKEY)> then C is assumed to contain an C and is stored as-is with its REFCNT incremented. (This is now used as a subroutine by C.) MAGIC * sv_magicext(SV* sv, SV* obj, int how, const MGVTBL *vtbl, const char* name, I32 namlen)','name' => 'sv_magicext'},'av_push' => {'text' => 'Pushes an SV onto the end of the array. The array will grow automatically to accommodate the addition. Like C, this takes ownership of one reference count. void av_push(AV *av, SV *val)','name' => 'av_push'},'unpackstring' => {'text' => 'The engine implementing unpack() Perl function. C puts the extracted list items on the stack and returns the number of elements. Issue C before and C after the call to this function. I32 unpackstring(const char *pat, const char *patend, const char *s, const char *strend, U32 flags)','name' => 'unpackstring'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV *av, I32 key)','name' => 'av_extend'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV* sv)','name' => 'newRV_noinc'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. You may call C or C 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 C, so you must not discard your iterator immediately else the entry will leak - call C to trigger the resource deallocation. HE* hv_iternext(HV *hv)','name' => 'hv_iternext'},'hv_iterinit' => {'text' => '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 *hv)','name' => 'hv_iterinit'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.010001', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_010_000.pm0000644000175000017500000045264011653441731020761 0ustar tseetseepackage Perl::APIReference::V5_010_000; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'hv_store_ent' => {'text' => '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. Effectively a successful hv_store_ent takes ownership of one reference to C. 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 C; unlike C it does not take ownership of it, so maintaining the correct reference count on C 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 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)','name' => 'hv_store_ent'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package. See C. HV* gv_stashsv(SV* sv, I32 flags)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'strGE' => {'text' => '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)','name' => 'strGE'},'form' => {'text' => '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, ...)','name' => 'form'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified version becoming C. Handles \'get\' magic. See also C for a version which guarantees to evaluate sv only once. char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'is_utf8_string' => {'text' => 'Returns true if first C bytes of the given string form a valid UTF-8 string, false otherwise. Note that \'a valid UTF-8 string\' does not mean \'a string that contains code points above 0x7F encoded in UTF-8\' because a valid ASCII string is a valid UTF-8 string. See also is_utf8_string_loclen() and is_utf8_string_loc(). bool is_utf8_string(const U8 *s, STRLEN len)','name' => 'is_utf8_string'},'sv_insert' => {'text' => '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, const char* little, STRLEN littlelen)','name' => 'sv_insert'},'SvPOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a character string. U32 SvPOK(SV* sv)','name' => 'SvPOK'},'sv_vsetpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vsetpvf_mg(SV* sv, const char* pat, va_list* args)','name' => 'sv_vsetpvf_mg'},'sv_destroyable' => {'text' => 'Dummy routine which reports that object can be destroyed when there is no sharing module present. It ignores its single SV argument, and returns \'true\'. Exists to avoid test for a NULL function pointer and because it could potentially warn under some level of strict-ness. bool sv_destroyable(SV *sv)','name' => 'sv_destroyable'},'SvPVutf8' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'sortsv_flags' => {'text' => 'Sort an array, with various options. void sortsv_flags(SV** array, size_t num_elts, SVCOMPARE_t cmp, U32 flags)','name' => 'sortsv_flags'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C.','name' => 'XS'},'scan_oct' => {'text' => 'For backwards compatibility. Use C instead. NV scan_oct(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_oct'},'sv_setpvn' => {'text' => 'Copies a string into an SV. The C parameter indicates the number of bytes to be copied. If the C argument is NULL the SV will become undefined. Does not handle \'set\' magic. See C. void sv_setpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_setpvn'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'newSVrv' => {'text' => '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)','name' => 'newSVrv'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'find_runcv' => {'text' => 'Locate the CV corresponding to the currently executing sub or eval. If db_seqp is non_null, skip CVs that are in the DB package and populate *db_seqp with the cop sequence number at the point that the DB:: code was entered. (allows debuggers to eval in the scope of the breakpoint rather than in the scope of the debugger itself). CV* find_runcv(U32 *db_seqp)','name' => 'find_runcv'},'PoisonWith' => {'text' => 'Fill up memory with a byte pattern (a byte repeated over and over again) that hopefully catches attempts to access uninitialized memory. void PoisonWith(void* dest, int nitems, type, U8 byte)','name' => 'PoisonWith'},'utf8n_to_uvuni' => {'text' => 'Bottom level UTF-8 decode routine. Returns the Unicode code point value of the first character in the string C which is assumed to be in UTF-8 encoding and no longer than C; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, the behaviour is dependent on the value of C: if it contains UTF8_CHECK_ONLY, it is assumed that the caller will raise a warning, and this function will silently just set C to C<-1> and return zero. If the C does not contain UTF8_CHECK_ONLY, warnings about malformations will be given, C will be set to the expected length of the UTF-8 character in bytes, and zero will be returned. The C can also contain various flags to allow deviations from the strict UTF-8 encoding (see F). Most code should use utf8_to_uvchr() rather than call this directly. UV utf8n_to_uvuni(const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvuni'},'av_create_and_unshift_one' => {'text' => 'Unshifts an SV onto the beginning of the array, creating the array if necessary. A small internal helper function to remove a commonly duplicated idiom. NOTE: this function is experimental and may change or be removed without notice. SV** av_create_and_unshift_one(AV **const avp, SV *const val)','name' => 'av_create_and_unshift_one'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C to type C if necessary, then adds a new magic item of type C to the head of the magic list. See C (which C now calls) for a description of the handling of the C and C arguments. You need to use C to add magic to SvREADONLY SVs and also to add more than one instance of the same \'how\'. void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen)','name' => 'sv_magic'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'sv_utf8_upgrade_flags' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade_flags(SV *sv, I32 flags)','name' => 'sv_utf8_upgrade_flags'},'ibcmp_utf8' => {'text' => 'Return true if the strings s1 and s2 differ case-insensitively, false if not (if they are equal case-insensitively). If u1 is true, the string s1 is assumed to be in UTF-8-encoded Unicode. If u2 is true, the string s2 is assumed to be in UTF-8-encoded Unicode. If u1 or u2 are false, the respective string is assumed to be in native 8-bit encoding. If the pe1 and pe2 are non-NULL, the scanning pointers will be copied in there (they will point at the beginning of the I character). If the pointers behind pe1 or pe2 are non-NULL, they are the end pointers beyond which scanning will not continue under any circumstances. If the byte lengths l1 and l2 are non-zero, s1+l1 and s2+l2 will be used as goal end pointers that will also stop the scan, and which qualify towards defining a successful match: all the scans that define an explicit length must reach their goal pointers for a match to succeed). For case-insensitiveness, the "casefolding" of Unicode is used instead of upper/lowercasing both the characters, see http://www.unicode.org/unicode/reports/tr21/ (Case Mappings). I32 ibcmp_utf8(const char* a, char **pe1, UV l1, bool u1, const char* b, char **pe2, UV l2, bool u2)','name' => 'ibcmp_utf8'},'SvREFCNT_inc_void' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value. The macro doesn\'t need to return a meaningful value. void SvREFCNT_inc_void(SV* sv)','name' => 'SvREFCNT_inc_void'},'mXPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Handles \'set\' magic. Does not use C. See also C, C and C. void mXPUSHp(char* str, STRLEN len)','name' => 'mXPUSHp'},'CvSTASH' => {'text' => 'Returns the stash of the CV. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'gv_const_sv' => {'text' => 'If C is a typeglob whose subroutine entry is a constant sub eligible for inlining, or C is a placeholder reference that would be promoted to such a typeglob, then returns the value returned by the sub. Otherwise, returns NULL. SV* gv_const_sv(GV* gv)','name' => 'gv_const_sv'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. The target SV physically takes over ownership of the body of the source SV and inherits its flags; however, the target keeps any magic it owns, and any magic in the source is discarded. Note that this is a rather specialist SV copying operation; most of the time you\'ll want to use C or one of its many macro front-ends. void sv_replace(SV* sv, SV* nsv)','name' => 'sv_replace'},'utf8n_to_uvchr' => {'text' => 'flags Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. Allows length and flags to be passed to low level routine. UV utf8n_to_uvchr(const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvchr'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and L.','name' => 'G_ARRAY'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'SvROK' => {'text' => 'Tests if the SV is an RV. U32 SvROK(SV* sv)','name' => 'SvROK'},'mXPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. Does not use C. See also C, C and C. void mXPUSHn(NV nv)','name' => 'mXPUSHn'},'sv_unref' => {'text' => '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. This is C with the C being zero. See C. void sv_unref(SV* sv)','name' => 'sv_unref'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dstr, SV *sstr)','name' => 'sv_catsv_mg'},'call_argv' => {'text' => '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)','name' => 'call_argv'},'SvPV_nolen' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified form becoming C. Handles \'get\' magic. char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'perl_clone' => {'text' => '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->create 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 C, 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)','name' => 'perl_clone'},'sv_setnv' => {'text' => 'Copies a double into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setnv(SV* sv, NV num)','name' => 'sv_setnv'},'sv_2nv' => {'text' => 'Return the num value of an SV, doing any necessary string or integer conversion, magic etc. Normally used via the C and C macros. NV sv_2nv(SV* sv)','name' => 'sv_2nv'},'SvREFCNT_inc_simple_NN' => {'text' => 'Same as SvREFCNT_inc_simple, but can only be used if you know I is not NULL. Since we don\'t have to check the NULLness, it\'s faster and smaller. SV* SvREFCNT_inc_simple_NN(SV* sv)','name' => 'SvREFCNT_inc_simple_NN'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'hv_fetchs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV** hv_fetchs(HV* tb, const char* key, I32 lval)','name' => 'hv_fetchs'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1. HV* newHV()','name' => 'newHV'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or false. bool strNE(char* s1, char* s2)','name' => 'strNE'},'sv_pvutf8n_force' => {'text' => 'The backend for the C macro. Always use the macro instead. char* sv_pvutf8n_force(SV* sv, STRLEN* lp)','name' => 'sv_pvutf8n_force'},'savepv' => {'text' => 'Perl\'s version of C. Returns a pointer to a newly allocated string which is a duplicate of C. The size of the string is determined by C. The memory allocated for the new string can be freed with the C function. char* savepv(const char* pv)','name' => 'savepv'},'SvNV_set' => {'text' => 'Set the value of the NV pointer in sv to val. See C. void SvNV_set(SV* sv, NV val)','name' => 'SvNV_set'},'bytes_from_utf8' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike C but like C, returns a pointer to the newly-created string, and updates C to contain the new length. Returns the original string if no conversion occurs, C is unchanged. Do nothing if C points to 0. Sets C to 0 if C is converted or contains all 7bit characters. NOTE: this function is experimental and may change or be removed without notice. U8* bytes_from_utf8(const U8 *s, STRLEN *len, bool *is_utf8)','name' => 'bytes_from_utf8'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1. AV* newAV()','name' => 'newAV'},'HvNAME' => {'text' => 'Returns the package name of a stash, or NULL if C isn\'t a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV of the sv is assumed to be octets in that encoding, and the sv will be converted into Unicode (and UTF-8). If the sv already is UTF-8 (or if it is not POK), or if the encoding is not a reference, nothing is done to the sv. If the encoding is not an C Encoding object, bad things will happen. (See F and L). The PV of the sv is returned. char* sv_recode_to_utf8(SV* sv, SV *encoding)','name' => 'sv_recode_to_utf8'},'av_make' => {'text' => '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)','name' => 'av_make'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. See C for a version which guarantees to evaluate sv only once. UV SvUV(SV* sv)','name' => 'SvUV'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L. int perl_run(PerlInterpreter* interp)','name' => 'perl_run'},'vstringify' => {'text' => 'In order to maintain maximum compatibility with earlier versions of Perl, this function will return either the floating point notation or the multiple dotted notation, depending on whether the original version contained 1 or more dots, respectively SV* vstringify(SV *vs)','name' => 'vstringify'},'sv_catsv_flags' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. If C has C bit set, will C on the SVs if appropriate, else not. C and C are implemented in terms of this function. void sv_catsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_catsv_flags'},'SvPVutf8_nolen' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_nolen(SV* sv)','name' => 'SvPVutf8_nolen'},'SvRXOK' => {'text' => 'Returns a boolean indicating whether the SV contains qr magic (PERL_MAGIC_qr). If you want to do something with the REGEXP* later use SvRX instead and check for NULL. bool SvRXOK(SV* sv)','name' => 'SvRXOK'},'sv_setpviv' => {'text' => '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)','name' => 'sv_setpviv'},'sv_true' => {'text' => 'Returns true if the SV has a true value by Perl\'s rules. Use the C macro instead, which may call C or may instead use an in-line version. I32 sv_true(SV *sv)','name' => 'sv_true'},'sv_derived_from' => {'text' => 'Returns a boolean indicating whether the SV is derived from the specified class I. To check derivation at the Perl level, call C as a normal Perl method. bool sv_derived_from(SV* sv, const char* name)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. See also C. I32 sv_cmp_locale(SV* sv1, SV* sv2)','name' => 'sv_cmp_locale'},'sv_catpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_catpvs(SV* sv, const char* s)','name' => 'sv_catpvs'},'hv_exists' => {'text' => '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, I32 klen)','name' => 'hv_exists'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'Nullsv' => {'text' => 'Null SV pointer.','name' => 'Nullsv'},'mg_length' => {'text' => 'Report on the SV\'s length. See C. U32 mg_length(SV* sv)','name' => 'mg_length'},'SvPVX' => {'text' => 'Returns a pointer to the physical string in the SV. The SV must contain a string. char* SvPVX(SV* sv)','name' => 'SvPVX'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'HEf_SVKEY' => {'text' => 'This flag, used in the length slot of hash entries and magic structures, specifies the structure contains an C pointer where a C pointer is to be expected. (For information only--not to be used).','name' => 'HEf_SVKEY'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C in characters. Stops at C (inclusive). If C s> or if the scan would end up past C, croaks. STRLEN utf8_length(const U8* s, const U8 *e)','name' => 'utf8_length'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted if tainting is enabled. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'SvIOK_only_UV' => {'text' => 'Tells and SV that it is an unsigned integer and disables all other OK bits. void SvIOK_only_UV(SV* sv)','name' => 'SvIOK_only_UV'},'sv_nolocking' => {'text' => '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. "Superseded" by sv_nosharing(). void sv_nolocking(SV *sv)','name' => 'sv_nolocking'},'sv_vcatpvfn' => {'text' => '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). Usually used via one of its frontends C and C. void sv_vcatpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vcatpvfn'},'strLT' => {'text' => '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)','name' => 'strLT'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. SV* av_shift(AV* ar)','name' => 'av_shift'},'sv_pvutf8n' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n(SV *sv, STRLEN *len)','name' => 'sv_pvutf8n'},'newSV' => {'text' => '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 trailing 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. In 5.9.3, newSV() replaces the older NEWSV() API, and drops the first parameter, I, a debug aid which allowed callers to identify themselves. This aid has been superseded by a new build option, PERL_MEM_LOG (see L). The older API is still there for use in XS modules supporting older perls. SV* newSV(STRLEN len)','name' => 'newSV'},'sv_2pvutf8' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV, and set *lp to its length. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8(SV* sv, STRLEN* lp)','name' => 'sv_2pvutf8'},'sv_nounlocking' => {'text' => '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. "Superseded" by sv_nosharing(). void sv_nounlocking(SV *sv)','name' => 'sv_nounlocking'},'dITEMS' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dITEMS;','name' => 'dITEMS'},'SvUV_set' => {'text' => 'Set the value of the UV pointer in sv to val. See C. void SvUV_set(SV* sv, UV val)','name' => 'SvUV_set'},'CopyD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * CopyD(void* src, void* dest, int nitems, type)','name' => 'CopyD'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *sv, IV i)','name' => 'sv_setiv_mg'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C. See C and L for other uses. PUTBACK;','name' => 'PUTBACK'},'savesharedpvn' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. (With the specific difference that a NULL pointer is not acceptable) char* savesharedpvn(const char *const pv, const STRLEN len)','name' => 'savesharedpvn'},'dAXMARK' => {'text' => 'Sets up the C variable and stack marker variable C. This is usually handled automatically by C by calling C. dAXMARK;','name' => 'dAXMARK'},'SvCUR_set' => {'text' => 'Set the current length of the string which is in the SV. See C and C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'sv_2uv_flags' => {'text' => 'Return the unsigned integer value of an SV, doing any necessary string conversion. If flags includes SV_GMAGIC, does an mg_get() first. Normally used via the C and C macros. UV sv_2uv_flags(SV* sv, I32 flags)','name' => 'sv_2uv_flags'},'SvNOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a double. U32 SvNOK(SV* sv)','name' => 'SvNOK'},'mPUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. Does not use C. See also C, C and C. void mPUSHn(NV nv)','name' => 'mPUSHn'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C, C, and L.','name' => 'G_SCALAR'},'sv_reset' => {'text' => 'Underlying implementation for the C Perl function. Note that the perl-level function is vaguely deprecated. void sv_reset(const char* s, HV* stash)','name' => 'sv_reset'},'sv_2pv_flags' => {'text' => 'Returns a pointer to the string value of an SV, and sets *lp to its length. If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string if necessary. Normally invoked via the C macro. C and C usually end up here too. char* sv_2pv_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_2pv_flags'},'SvTAINTED_off' => {'text' => '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)','name' => 'SvTAINTED_off'},'SvNVx' => {'text' => 'Coerces the given SV to a double and returns it. Guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. NV SvNVx(SV* sv)','name' => 'SvNVx'},'require_pv' => {'text' => 'Tells Perl to C the file named by the string argument. It is analogous to the Perl code C. 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)','name' => 'require_pv'},'sv_upgrade' => {'text' => 'Upgrade an SV to a more complex form. Generally adds a new body type to the SV, then copies across as much information as possible from the old body. You generally want to use the C macro wrapper. See also C. void sv_upgrade(SV* sv, svtype new_type)','name' => 'sv_upgrade'},'strEQ' => {'text' => 'Test two strings to see if they are equal. Returns true or false. bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'hv_store' => {'text' => '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. Effectively a successful hv_store takes ownership of one reference to C. 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 L 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)','name' => 'hv_store'},'isUPPER' => {'text' => 'Returns a boolean indicating whether the C C is an uppercase character. bool isUPPER(char ch)','name' => 'isUPPER'},'sv_setsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setsv_mg(SV *dstr, SV *sstr)','name' => 'sv_setsv_mg'},'hv_fetch_ent' => {'text' => '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)','name' => 'hv_fetch_ent'},'isLOWER' => {'text' => 'Returns a boolean indicating whether the C C is a lowercase character. bool isLOWER(char ch)','name' => 'isLOWER'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See C. char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'SvNOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a double. Checks the B setting. Use C. U32 SvNOKp(SV* sv)','name' => 'SvNOKp'},'Newx' => {'text' => 'The XSUB-writer\'s interface to the C C function. In 5.9.3, Newx() and friends replace the older New() API, and drops the first parameter, I, a debug aid which allowed callers to identify themselves. This aid has been superseded by a new build option, PERL_MEM_LOG (see L). The older API is still there for use in XS modules supporting older perls. void Newx(void* ptr, int nitems, type)','name' => 'Newx'},'PUSHs' => {'text' => 'Push an SV onto the stack. The stack must have room for this element. Does not handle \'set\' magic. Does not use C. See also C, C and C. void PUSHs(SV* sv)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setuv(SV* sv, UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'utf8_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvchr(const U8 *s, STRLEN *retlen)','name' => 'utf8_to_uvchr'},'nothreadhook' => {'text' => 'Stub that provides thread hook for perl_destruct when there are no threads. int nothreadhook()','name' => 'nothreadhook'},'bytes_to_utf8' => {'text' => 'Converts a string C of length C from ASCII into UTF-8 encoding. Returns a pointer to the newly-created string, and sets C to reflect the new length. If you want to convert to UTF-8 from other encodings than ASCII, see sv_recode_to_utf8(). NOTE: this function is experimental and may change or be removed without notice. U8* bytes_to_utf8(const U8 *s, STRLEN *len)','name' => 'bytes_to_utf8'},'SvIsCOW_shared_hash' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write shared hash key scalar. bool SvIsCOW_shared_hash(SV* sv)','name' => 'SvIsCOW_shared_hash'},'sv_pvn' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn(SV *sv, STRLEN *len)','name' => 'sv_pvn'},'sv_setref_iv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_iv(SV* rv, const char* classname, IV iv)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => '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. Uses the "OOK hack". Beware: after this function returns, C and SvPVX_const(sv) may no longer refer to the same chunk of data. void sv_chop(SV* sv, const char* ptr)','name' => 'sv_chop'},'sv_backoff' => {'text' => 'Remove any string offset. You should normally use the C macro wrapper instead. int sv_backoff(SV* sv)','name' => 'sv_backoff'},'sv_catsv_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_catsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_catsv_nomg'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setuv_mg(SV *sv, UV u)','name' => 'sv_setuv_mg'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually handled automatically by C. See C.','name' => 'XS_VERSION'},'PL_na' => {'text' => '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','name' => 'PL_na'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the SV is set to 1. SV* newSViv(IV i)','name' => 'newSViv'},'sv_untaint' => {'text' => 'Untaint an SV. Use C instead. void sv_untaint(SV* sv)','name' => 'sv_untaint'},'sv_setpv' => {'text' => '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)','name' => 'sv_setpv'},'Newxz' => {'text' => 'The XSUB-writer\'s interface to the C C function. The allocated memory is zeroed with C. See also C. void Newxz(void* ptr, int nitems, type)','name' => 'Newxz'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See C.','name' => 'SVt_PVHV'},'SvGROW' => {'text' => '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)','name' => 'SvGROW'},'gv_fetchmethod' => {'text' => 'See L. GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'dMULTICALL' => {'text' => 'Declare local variables for a multicall. See L. dMULTICALL;','name' => 'dMULTICALL'},'sv_catpv' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpv(SV* sv, const char* ptr)','name' => 'sv_catpv'},'sv_len' => {'text' => 'Returns the length of the string in the SV. Handles magic and type coercion. See also C, which gives raw access to the xpv_cur slot. STRLEN sv_len(SV* sv)','name' => 'sv_len'},'SvPVbyte_nolen' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_nolen(SV* sv)','name' => 'SvPVbyte_nolen'},'sv_pvutf8' => {'text' => 'Use the C macro instead char* sv_pvutf8(SV *sv)','name' => 'sv_pvutf8'},'SvRX' => {'text' => 'Convenience macro to get the REGEXP from a SV. This is approximately equivalent to the following snippet: if (SvMAGICAL(sv)) mg_get(sv); if (SvROK(sv) && (tmpsv = (SV*)SvRV(sv)) && SvTYPE(tmpsv) == SVt_PVMG && (tmpmg = mg_find(tmpsv, PERL_MAGIC_qr))) { return (REGEXP *)tmpmg->mg_obj; } NULL will be returned if a REGEXP* is not found. REGEXP * SvRX(SV *sv)','name' => 'SvRX'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See C.','name' => 'SVt_PVAV'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L. LEAVE;','name' => 'LEAVE'},'hv_undef' => {'text' => 'Undefines the hash. void hv_undef(HV* tb)','name' => 'hv_undef'},'SvSetMagicSV_nosteal' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetMagicSV_nosteal'},'hv_delete_ent' => {'text' => '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)','name' => 'hv_delete_ent'},'CLASS' => {'text' => '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','name' => 'CLASS'},'savesvpv' => {'text' => 'A version of C/C which gets the string to duplicate from the passed in SV using C char* savesvpv(SV* sv)','name' => 'savesvpv'},'sv_isobject' => {'text' => '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)','name' => 'sv_isobject'},'sv_pvn_force_flags' => {'text' => 'Get a sensible string out of the SV somehow. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You normally want to use the various wrapper macros instead: see C and C char* sv_pvn_force_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_pvn_force_flags'},'HeKLEN' => {'text' => '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)','name' => 'HeKLEN'},'to_utf8_title' => {'text' => 'Convert the UTF-8 encoded character at p to its titlecase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the titlecase version may be longer than the original character. The first character of the titlecased version is returned (but note, as explained above, that there may be more.) UV to_utf8_title(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_title'},'mPUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Does not use C. See also C, C and C. void mPUSHi(IV iv)','name' => 'mPUSHi'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHn(NV nv)','name' => 'PUSHn'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it. See C for a version which guarantees to evaluate sv only once. IV SvIV(SV* sv)','name' => 'SvIV'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. SV PL_sv_yes','name' => 'PL_sv_yes'},'sv_nosharing' => {'text' => 'Dummy routine which "shares" an SV when there is no sharing module present. Or "locks" it. Or "unlocks" it. In other words, ignores its single SV argument. 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 *sv)','name' => 'sv_nosharing'},'SvUTF8_off' => {'text' => 'Unsets the UTF-8 status of an SV. void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'looks_like_number' => {'text' => 'Test if the content of an SV looks like a number (or is a number). C and C are treated as numbers (so will not issue a non-numeric warning), even if your atof() doesn\'t grok them. I32 looks_like_number(SV* sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpv_mg(SV *sv, const char *ptr)','name' => 'sv_catpv_mg'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'sv_setref_uv' => {'text' => 'Copies an unsigned 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 have a reference count of 1, and the RV will be returned. SV* sv_setref_uv(SV* rv, const char* classname, UV uv)','name' => 'sv_setref_uv'},'getcwd_sv' => {'text' => 'Fill the sv with current working directory int getcwd_sv(SV* sv)','name' => 'getcwd_sv'},'newSVpvs_share' => {'text' => 'Like C, but takes a literal string instead of a string/length pair and omits the hash parameter. SV* newSVpvs_share(const char* s)','name' => 'newSVpvs_share'},'newSVpv' => {'text' => '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)','name' => 'newSVpv'},'sv_2pvbyte' => {'text' => 'Return a pointer to the byte-encoded representation of the SV, and set *lp to its length. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte(SV* sv, STRLEN* lp)','name' => 'sv_2pvbyte'},'fbm_instr' => {'text' => '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)','name' => 'fbm_instr'},'sv_setpvf' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Does not handle \'set\' magic. See C. void sv_setpvf(SV* sv, const char* pat, ...)','name' => 'sv_setpvf'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHn(NV nv)','name' => 'XPUSHn'},'SVt_PV' => {'text' => 'Pointer type flag for scalars. See C.','name' => 'SVt_PV'},'call_sv' => {'text' => '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)','name' => 'call_sv'},'strGT' => {'text' => '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)','name' => 'strGT'},'sv_vcatpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. Does not handle \'set\' magic. See C. Usually used via its frontend C. void sv_vcatpvf(SV* sv, const char* pat, va_list* args)','name' => 'sv_vcatpvf'},'sv_pos_u2b' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from the start of the string, to a count of the equivalent number of bytes; if lenp is non-zero, it does the same to lenp, but this time starting from the offset, rather than from the start of the string. Handles magic and type coercion. void sv_pos_u2b(SV* sv, I32* offsetp, I32* lenp)','name' => 'sv_pos_u2b'},'upg_version' => {'text' => 'In-place upgrade of the supplied SV to a version object. SV *sv = upg_version(SV *sv, bool qv); Returns a pointer to the upgraded SV. Set the boolean qv if you want to force this SV to be interpreted as an "extended" version. SV* upg_version(SV *ver, bool qv)','name' => 'upg_version'},'HeSVKEY_set' => {'text' => '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)','name' => 'HeSVKEY_set'},'POPl' => {'text' => 'Pops a long off the stack. long POPl','name' => 'POPl'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L. SPAGAIN;','name' => 'SPAGAIN'},'scan_version' => {'text' => 'Returns a pointer to the next character after the parsed version string, as well as upgrading the passed in SV to an RV. Function must be called with an already existing SV like sv = newSV(0); s = scan_version(s, SV *sv, bool qv); Performs some preprocessing to the string to ensure that it has the correct characteristics of a version. Flags the object if it contains an underscore (which denotes this is an alpha version). The boolean qv denotes that the version should be interpreted as if it had multiple decimals, even if it doesn\'t. const char* scan_version(const char *vstr, SV *sv, bool qv)','name' => 'scan_version'},'SvIOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains an integer. Checks the B setting. Use C. U32 SvIOKp(SV* sv)','name' => 'SvIOKp'},'get_cv' => {'text' => 'Uses C to get the length of C, then calls C. NOTE: the perl_ form of this function is deprecated. CV* get_cv(const char* name, I32 flags)','name' => 'get_cv'},'vnumify' => {'text' => 'Accepts a version object and returns the normalized floating point representation. Call like: sv = vnumify(rv); NOTE: you can pass either the object directly or the SV contained within the RV. SV* vnumify(SV *vs)','name' => 'vnumify'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the stack. void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'SvUNLOCK' => {'text' => 'Releases a mutual exclusion lock on sv if a suitable module has been loaded. void SvUNLOCK(SV* sv)','name' => 'SvUNLOCK'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C. int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV (using C). The new SV is marked as mortal. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_mortalcopy(SV* oldsv)','name' => 'sv_mortalcopy'},'sv_catpvn_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_catpvn_nomg(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn_nomg'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See L.','name' => 'G_NOARGS'},'savepvn' => {'text' => 'Perl\'s version of what C would be if it existed. Returns a pointer to a newly allocated string which is a duplicate of the first C bytes from C, plus a trailing NUL byte. The memory allocated for the new string can be freed with the C function. char* savepvn(const char* pv, I32 len)','name' => 'savepvn'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized. This relies on the fact that uninitialized array elements are set to C<&PL_sv_undef>. bool av_exists(AV* ar, I32 key)','name' => 'av_exists'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C. STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'sv_bless' => {'text' => '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)','name' => 'sv_bless'},'sv_isa' => {'text' => '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)','name' => 'sv_isa'},'sv_catpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. If the appended data contains "wide" characters (including, but not limited to, SVs with a UTF-8 PV formatted with %s, and characters >255 formatted with %c), the original SV might get upgraded to UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. If the original SV was UTF-8, the pattern should be valid UTF-8; if the original SV was bytes, the pattern should be too. void sv_catpvf(SV* sv, const char* pat, ...)','name' => 'sv_catpvf'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C. void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'utf8_to_uvuni' => {'text' => 'Returns the Unicode code point of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. This function should only be used when returned UV is considered an index into the Unicode semantic tables (e.g. swashes). If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvuni(const U8 *s, STRLEN *retlen)','name' => 'utf8_to_uvuni'},'sv_2io' => {'text' => 'Using various gambits, try to get an IO from an SV: the IO slot if its a GV; or the recursive result if we\'re an RV; or the IO slot of the symbol named after the PV if we\'re a string. IO* sv_2io(SV* sv)','name' => 'sv_2io'},'SvMAGIC_set' => {'text' => 'Set the value of the MAGIC pointer in sv to val. See C. void SvMAGIC_set(SV* sv, MAGIC* val)','name' => 'SvMAGIC_set'},'newSVhek' => {'text' => 'Creates a new SV from the hash key structure. It will generate scalars that point to the shared string table where possible. Returns a new (undefined) SV if the hek is NULL. SV* newSVhek(const HEK *hek)','name' => 'newSVhek'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphabetic character. bool isALPHA(char ch)','name' => 'isALPHA'},'Nullhv' => {'text' => 'Null HV pointer.','name' => 'Nullhv'},'av_fill' => {'text' => 'Set the highest index in the array to the given number, equivalent to Perl\'s C<$#array = $fill;>. The number of elements in the an array will be C after av_fill() returns. If the array was previously shorter then the additional elements appended are set to C. If the array was longer, then the excess elements are freed. C is the same as C. void av_fill(AV* ar, I32 fill)','name' => 'av_fill'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV. All of the following SvREFCNT_inc* macros are optimized versions of SvREFCNT_inc, and can be replaced with SvREFCNT_inc. SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C. svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'MoveD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * MoveD(void* src, void* dest, int nitems, type)','name' => 'MoveD'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'grok_bin' => {'text' => 'converts a string representing a binary number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*flags> gives output flags. If the value is <= C it is returned as a UV, the output flags are clear, and nothing is written to I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The binary number may optionally be prefixed with "0b" or "b" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the binary number may use \'_\' characters to separate digits. UV grok_bin(const char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_bin'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L. void perl_free(PerlInterpreter* interp)','name' => 'perl_free'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C. MAGIC* mg_find(const SV* sv, int type)','name' => 'mg_find'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'XPUSHmortal' => {'text' => 'Push a new mortal SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. Does not use C. See also C, C and C. void XPUSHmortal()','name' => 'XPUSHmortal'},'SvVOK' => {'text' => 'Returns a boolean indicating whether the SV contains a v-string. bool SvVOK(SV* sv)','name' => 'SvVOK'},'newSVpvn_share' => {'text' => 'Creates a new SV with its SvPVX_const pointing to a shared string in the string table. If the string does not already exist in the table, it is created first. Turns on READONLY and FAKE. If the C parameter is non-zero, that value is used; otherwise the hash is computed. The string\'s hash can be later be retrieved from the SV with the C macro. The idea here is that as the string table is used for shared hash keys these strings will have SvPVX_const == HeKEY and hash lookup will avoid string compare. SV* newSVpvn_share(const char* s, I32 len, U32 hash)','name' => 'newSVpvn_share'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_setpvf_mg'},'SvPOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a character string. Checks the B setting. Use C. U32 SvPOKp(SV* sv)','name' => 'SvPOKp'},'sv_catpvn' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn'},'sv_setref_pv' => {'text' => '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 have a reference count of 1, and the RV will be returned. 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)','name' => 'sv_setref_pv'},'fbm_compile' => {'text' => '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)','name' => 'fbm_compile'},'sv_utf8_downgrade' => {'text' => 'Attempts to convert the PV of an SV from characters to bytes. If the PV contains a character beyond byte, this conversion will fail; in this case, either returns false or, if C is not true, croaks. This is not as a general purpose Unicode to byte encoding interface: use the Encode extension for that. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_downgrade(SV *sv, bool fail_ok)','name' => 'sv_utf8_downgrade'},'SvNIOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a number, integer or double. Checks the B setting. Use C. U32 SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either forward or backward. WARNING: do not use the following unless you *know* C is within the UTF-8 data pointed to by C *and* that on entry C is aligned on the first byte of character or just after the last byte of a character. U8* utf8_hop(const U8 *s, I32 off)','name' => 'utf8_hop'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide UTF-8 bytes as a single character. Handles magic and type coercion. STRLEN sv_len_utf8(SV* sv)','name' => 'sv_len_utf8'},'sv_setref_pvn' => {'text' => '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 have a reference count of 1, and the RV will be returned. Note that C copies the pointer while this copies the string. SV* sv_setref_pvn(SV* rv, const char* classname, const char* pv, STRLEN n)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for blessed scalars. See C.','name' => 'SVt_PVMG'},'PUSHp' => {'text' => '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. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHp(char* str, STRLEN len)','name' => 'PUSHp'},'SvREFCNT_inc_simple_void' => {'text' => 'Same as SvREFCNT_inc_simple, but can only be used if you don\'t need the return value. The macro doesn\'t need to return a meaningful value. void SvREFCNT_inc_simple_void(SV* sv)','name' => 'SvREFCNT_inc_simple_void'},'hv_clear_placeholders' => {'text' => '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)','name' => 'hv_clear_placeholders'},'mXPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Does not use C. See also C, C and C. void mXPUSHi(IV iv)','name' => 'mXPUSHi'},'dAX' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dAX;','name' => 'dAX'},'PL_sv_undef' => {'text' => 'This is the C SV. Always refer to this as C<&PL_sv_undef>. SV PL_sv_undef','name' => 'PL_sv_undef'},'SvRV_set' => {'text' => 'Set the value of the RV pointer in sv to val. See C. void SvRV_set(SV* sv, SV* val)','name' => 'SvRV_set'},'hv_iterkeysv' => {'text' => '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)','name' => 'hv_iterkeysv'},'grok_number' => {'text' => '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)','name' => 'grok_number'},'SvIVx' => {'text' => 'Coerces the given SV to an integer and returns it. Guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. IV SvIVx(SV* sv)','name' => 'SvIVx'},'grok_numeric_radix' => {'text' => 'Scan and skip for a numeric decimal separator (radix). bool grok_numeric_radix(const char **sp, const char *send)','name' => 'grok_numeric_radix'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the stack. void XST_mNO(int pos)','name' => 'XST_mNO'},'mPUSHp' => {'text' => '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. Does not use C. See also C, C and C. void mPUSHp(char* str, STRLEN len)','name' => 'mPUSHp'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array. Returns the deleted element. If C equals C, the element is freed and null is returned. SV* av_delete(AV* ar, I32 key, I32 flags)','name' => 'av_delete'},'utf8_distance' => {'text' => 'Returns the number of UTF-8 characters between the UTF-8 pointers C and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. IV utf8_distance(const U8 *a, const U8 *b)','name' => 'utf8_distance'},'SvPV_nomg' => {'text' => 'Like C but doesn\'t process magic. char* SvPV_nomg(SV* sv, STRLEN len)','name' => 'SvPV_nomg'},'savepvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. char* savepvs(const char* s)','name' => 'savepvs'},'SvSTASH_set' => {'text' => 'Set the value of the STASH pointer in sv to val. See C. void SvSTASH_set(SV* sv, HV* val)','name' => 'SvSTASH_set'},'sv_collxfrm' => {'text' => 'Add Collate Transform magic to an SV if it doesn\'t already have it. Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the scalar data of the variable, but transformed to such a format that a normal memory comparison can be used to compare the data according to the locale settings. char* sv_collxfrm(SV* sv, STRLEN* nxp)','name' => 'sv_collxfrm'},'ZeroD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * ZeroD(void* dest, int nitems, type)','name' => 'ZeroD'},'SvUV_nomg' => {'text' => 'Like C but doesn\'t process magic. UV SvUV_nomg(SV* sv)','name' => 'SvUV_nomg'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'POPpx' => {'text' => 'Pops a string off the stack. char* POPpx','name' => 'POPpx'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'gv_stashpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. HV* gv_stashpvs(const char* name, I32 create)','name' => 'gv_stashpvs'},'Zero' => {'text' => '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)','name' => 'Zero'},'vcmp' => {'text' => 'Version object aware cmp. Both operands must already have been converted into version objects. int vcmp(SV *lvs, SV *rvs)','name' => 'vcmp'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'sv_setpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_setpvs(SV* sv, const char* s)','name' => 'sv_setpvs'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_iv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. IV sv_iv(SV* sv)','name' => 'sv_iv'},'pv_escape' => {'text' => '|const STRLEN count|const STRLEN max |STRLEN const *escaped, const U32 flags Escapes at most the first "count" chars of pv and puts the results into dsv such that the size of the escaped string will not exceed "max" chars and will not contain any incomplete escape sequences. If flags contains PERL_PV_ESCAPE_QUOTE then any double quotes in the string will also be escaped. Normally the SV will be cleared before the escaped string is prepared, but when PERL_PV_ESCAPE_NOCLEAR is set this will not occur. If PERL_PV_ESCAPE_UNI is set then the input string is treated as Unicode, if PERL_PV_ESCAPE_UNI_DETECT is set then the input string is scanned using C to determine if it is Unicode. If PERL_PV_ESCAPE_ALL is set then all input chars will be output using C<\\x01F1> style escapes, otherwise only chars above 255 will be escaped using this style, other non printable chars will use octal or common escaped patterns like C<\\n>. If PERL_PV_ESCAPE_NOBACKSLASH then all chars below 255 will be treated as printable and will be output as literals. If PERL_PV_ESCAPE_FIRSTCHAR is set then only the first char of the string will be escaped, regardles of max. If the string is utf8 and the chars value is >255 then it will be returned as a plain hex sequence. Thus the output will either be a single char, an octal escape sequence, a special escape like C<\\n> or a 3 or more digit hex value. If PERL_PV_ESCAPE_RE is set then the escape char used will be a \'%\' and not a \'\\\\\'. This is because regexes very often contain backslashed sequences, whereas \'%\' is not a particularly common character in patterns. Returns a pointer to the escaped text as held by dsv. NOTE: the perl_ form of this function is deprecated. char* pv_escape(SV *dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags)','name' => 'pv_escape'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C.','name' => 'SVt_PVCV'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpviv_mg(SV *sv, IV iv)','name' => 'sv_setpviv_mg'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. Guarantees to C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'sv_2bool' => {'text' => 'This function is only called on magical items, and is only used by sv_true() or its macro equivalent. bool sv_2bool(SV* sv)','name' => 'sv_2bool'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'sv_newmortal' => {'text' => 'Creates a new null SV which is mortal. The reference count of the SV is set to 1. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_newmortal()','name' => 'sv_newmortal'},'sv_clear' => {'text' => 'Clear an SV: call any destructors, free up any memory used by the body, and free the body itself. The SV\'s head is I freed, although its type is set to all 1\'s so that it won\'t inadvertently be assumed to be live during global destruction etc. This function should only be called when REFCNT is zero. Most of the time you\'ll want to call C (or its macro wrapper C) instead. void sv_clear(SV* sv)','name' => 'sv_clear'},'SvOOK' => {'text' => 'Returns a U32 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). U32 SvOOK(SV* sv)','name' => 'SvOOK'},'SvPV_set' => {'text' => 'Set the value of the PV pointer in sv to val. See C. void SvPV_set(SV* sv, char* val)','name' => 'SvPV_set'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'SvGAMAGIC' => {'text' => 'Returns true if the SV has get magic or overloading. If either is true then the scalar is active data, and has the potential to return a new value every time it is accessed. Hence you must be careful to only read it once per user logical operation and work with that returned value. If neither is true then the scalar\'s value cannot change unless written to. char* SvGAMAGIC(SV* sv)','name' => 'SvGAMAGIC'},'svtype' => {'text' => '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.','name' => 'svtype'},'load_module' => {'text' => '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 C. The optional trailing SV* arguments can be used to specify arguments to the module\'s import() method, similar to C. void load_module(U32 flags, SV* name, SV* ver, ...)','name' => 'load_module'},'get_hv' => {'text' => '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)','name' => 'get_hv'},'hv_clear' => {'text' => 'Clears a hash, making it empty. void hv_clear(HV* tb)','name' => 'hv_clear'},'PoisonNew' => {'text' => 'PoisonWith(0xAB) for catching access to allocated but uninitialized memory. void PoisonNew(void* dest, int nitems, type)','name' => 'PoisonNew'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES;','name' => 'XSRETURN_YES'},'sv_nv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. NV sv_nv(SV* sv)','name' => 'sv_nv'},'Poison' => {'text' => 'PoisonWith(0xEF) for catching access to freed memory. void Poison(void* dest, int nitems, type)','name' => 'Poison'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_catpvf_mg'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHu(UV uv)','name' => 'PUSHu'},'get_sv' => {'text' => '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)','name' => 'get_sv'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. (Uses C). SV* newSVsv(SV* old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C. void hv_magic(HV* hv, GV* gv, int how)','name' => 'hv_magic'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *sv, const char *ptr)','name' => 'sv_setpv_mg'},'sv_2mortal' => {'text' => 'Marks an existing SV as mortal. The SV will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. SvTEMP() is turned on which means that the SV\'s string buffer can be "stolen" if this SV is copied. See also C and C. SV* sv_2mortal(SV* sv)','name' => 'sv_2mortal'},'XCPT_TRY_END' => {'text' => 'Ends a try block. See L.','name' => 'XCPT_TRY_END'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself. void av_undef(AV* ar)','name' => 'av_undef'},'HeKEY' => {'text' => '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)','name' => 'HeKEY'},'pack_cat' => {'text' => '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, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)','name' => 'pack_cat'},'sv_cmp' => {'text' => '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. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp(SV* sv1, SV* sv2)','name' => 'sv_cmp'},'SvEND' => {'text' => '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)','name' => 'SvEND'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C, C or C for void, scalar or list context, respectively. U32 GIMME_V','name' => 'GIMME_V'},'sv_force_normal_flags' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg; if we\'re a copy-on-write scalar, this is the on-write time when we do the copy, and is also used locally. If C is set then a copy-on-write scalar drops its PV buffer (if any) and becomes SvPOK_off rather than making a copy. (Used where this scalar is about to be set to some other value.) In addition, the C parameter gets passed to C when unrefing. C calls this function with flags set to 0. void sv_force_normal_flags(SV *sv, U32 flags)','name' => 'sv_force_normal_flags'},'sv_setsv_flags' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. If the C parameter has the C bit set, will C on C if appropriate, else not. If the C parameter has the C bit set then the buffers of temps will not be stolen. and C are implemented in terms of this function. You probably want to use one of the assortment of wrappers, such as C, C, C and C. This is the primary function for copying scalars, and most other copy-ish functions and macros use this underneath. void sv_setsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_setsv_flags'},'is_utf8_char' => {'text' => 'Tests if some arbitrary number of bytes begins in a valid UTF-8 character. Note that an INVARIANT (i.e. ASCII) character is a valid UTF-8 character. The actual number of bytes in the UTF-8 character will be returned if it is valid, otherwise 0. STRLEN is_utf8_char(const U8 *p)','name' => 'is_utf8_char'},'Copy' => {'text' => '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)','name' => 'Copy'},'sv_taint' => {'text' => 'Taint an SV. Use C instead. void sv_taint(SV* sv)','name' => 'sv_taint'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'sv_utf8_upgrade' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains a signed integer. bool SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. Sets up the C and C variables by calling C and C. This is usually handled automatically by C. dXSARGS;','name' => 'dXSARGS'},'savesharedpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the C C is whitespace. bool isSPACE(char ch)','name' => 'isSPACE'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* ptr)','name' => 'Safefree'},'gv_stashpvn' => {'text' => 'Returns a pointer to the stash for a specified package. The C parameter indicates the length of the C, in bytes. C is passed to C, so if set to C then the package will be created if it does not already exist. If the package does not exist and C is 0 (or any other setting that does not create packages) then NULL is returned. HV* gv_stashpvn(const char* name, U32 namelen, I32 flags)','name' => 'gv_stashpvn'},'mPUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Does not use C. See also C, C and C. void mPUSHu(UV uv)','name' => 'mPUSHu'},'newSV_type' => {'text' => 'Creates a new SV, of the type specified. The reference count for the new SV is set to 1. SV* newSV_type(svtype type)','name' => 'newSV_type'},'sv_setsv_nomg' => {'text' => 'Like C but doesn\'t process magic. void sv_setsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_setsv_nomg'},'SvREFCNT_inc_void_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value, and you know that I is not NULL. The macro doesn\'t need to return a meaningful value, or check for NULLness, so it\'s smaller and faster. void SvREFCNT_inc_void_NN(SV* sv)','name' => 'SvREFCNT_inc_void_NN'},'Perl_signbit' => {'text' => 'Return a non-zero integer if the sign bit on an NV is set, and 0 if it is not. If Configure detects this system has a signbit() that will work with our NVs, then we just use it via the #define in perl.h. Otherwise, fall back on this implementation. As a first pass, this gets everything right except -0.0. Alas, catching -0.0 is the main use for this function, so this is not too helpful yet. Still, at least we have the scaffolding in place to support other systems, should that prove useful. Configure notes: This function is called \'Perl_signbit\' instead of a plain \'signbit\' because it is easy to imagine a system having a signbit() function or macro that doesn\'t happen to work with our particular choice of NVs. We shouldn\'t just re-#define signbit as Perl_signbit and expect the standard system headers to be happy. Also, this is a no-context function (no pTHX_) because Perl_signbit() is usually re-#defined in perl.h as a simple macro call to the system\'s signbit(). Users should just always call Perl_signbit(). NOTE: this function is experimental and may change or be removed without notice. int Perl_signbit(NV f)','name' => 'Perl_signbit'},'av_create_and_push' => {'text' => 'Push an SV onto the end of the array, creating the array if necessary. A small internal helper function to remove a commonly duplicated idiom. NOTE: this function is experimental and may change or be removed without notice. void av_create_and_push(AV **const avp, SV *const val)','name' => 'av_create_and_push'},'PUSH_MULTICALL' => {'text' => 'Opening bracket for a lightweight callback. See L. PUSH_MULTICALL;','name' => 'PUSH_MULTICALL'},'XPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHp(char* str, STRLEN len)','name' => 'XPUSHp'},'sv_utf8_encode' => {'text' => 'Converts the PV of an SV to UTF-8, but then turns the C flag off so that it looks like octets again. void sv_utf8_encode(SV *sv)','name' => 'sv_utf8_encode'},'SvUTF8_on' => {'text' => 'Turn on the UTF-8 status of an SV (the data is not changed, just the flag). Do not use frivolously. void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_setpvn_mg'},'toLOWER' => {'text' => 'Converts the specified character to lowercase. char toLOWER(char ch)','name' => 'toLOWER'},'POPp' => {'text' => 'Pops a string off the stack. Deprecated. New code should use POPpx. char* POPp','name' => 'POPp'},'SvIV_nomg' => {'text' => 'Like C but doesn\'t process magic. IV SvIV_nomg(SV* sv)','name' => 'SvIV_nomg'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'new_version' => {'text' => 'Returns a new version object based on the passed in SV: SV *sv = new_version(SV *ver); Does not alter the passed in ver SV. See "upg_version" if you want to upgrade the SV. SV* new_version(SV *ver)','name' => 'new_version'},'sv_pvbyten' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten(SV *sv, STRLEN *len)','name' => 'sv_pvbyten'},'Nullav' => {'text' => 'Null AV pointer.','name' => 'Nullav'},'sv_copypv' => {'text' => 'Copies a stringified representation of the source SV into the destination SV. Automatically performs any necessary mg_get and coercion of numeric values into strings. Guaranteed to preserve UTF8 flag even from overloaded objects. Similar in nature to sv_2pv[_flags] but operates directly on an SV instead of just the string. Mostly uses sv_2pv_flags to do its work, except when that would lose the UTF-8\'ness of the PV. void sv_copypv(SV* dsv, SV* ssv)','name' => 'sv_copypv'},'sv_pv' => {'text' => 'Use the C macro instead char* sv_pv(SV *sv)','name' => 'sv_pv'},'pv_pretty' => {'text' => '|const STRLEN count|const STRLEN max\\ |const char const *start_color| const char const *end_color\\ |const U32 flags Converts a string into something presentable, handling escaping via pv_escape() and supporting quoting and ellipses. If the PERL_PV_PRETTY_QUOTE flag is set then the result will be double quoted with any double quotes in the string escaped. Otherwise if the PERL_PV_PRETTY_LTGT flag is set then the result be wrapped in angle brackets. If the PERL_PV_PRETTY_ELLIPSES flag is set and not all characters in string were output then an ellipsis C<...> will be appended to the string. Note that this happens AFTER it has been quoted. If start_color is non-null then it will be inserted after the opening quote (if there is one) but before the escaped text. If end_color is non-null then it will be inserted after the escaped text but before any quotes or ellipses. Returns a pointer to the prettified text as held by dsv. NOTE: the perl_ form of this function is deprecated. char* pv_pretty(SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags)','name' => 'pv_pretty'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setnv_mg(SV *sv, NV num)','name' => 'sv_setnv_mg'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV* hv, char** key, I32* retlen)','name' => 'hv_iternextsv'},'utf8_to_bytes' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike C, this over-writes the original string, and updates len to contain the new length. Returns zero on failure, setting C to -1. If you need a copy of the string, see C. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_pvbyten_force' => {'text' => 'The backend for the C macro. Always use the macro instead. char* sv_pvbyten_force(SV* sv, STRLEN* lp)','name' => 'sv_pvbyten_force'},'uvuni_to_utf8_flags' => {'text' => 'Adds the UTF-8 representation of the Unicode codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvuni_to_utf8_flags(d, uv, flags); or, in most cases, d = uvuni_to_utf8(d, uv); (which is equivalent to) d = uvuni_to_utf8_flags(d, uv, 0); is the recommended Unicode-aware way of saying *(d++) = uv; U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)','name' => 'uvuni_to_utf8_flags'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See L.','name' => 'G_DISCARD'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'XST_mNV' => {'text' => '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)','name' => 'XST_mNV'},'UNDERBAR' => {'text' => 'The SV* corresponding to the $_ variable. Works even if there is a lexical $_ in scope.','name' => 'UNDERBAR'},'pad_sv' => {'text' => '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)','name' => 'pad_sv'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'SvPVutf8_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_force(SV* sv, STRLEN len)','name' => 'SvPVutf8_force'},'sv_2pvutf8_nolen' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8_nolen(SV* sv)','name' => 'sv_2pvutf8_nolen'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C.','name' => 'SVt_NV'},'mro_get_linear_isa' => {'text' => 'Returns either C or C for the given stash, dependant upon which MRO is in effect for that stash. The return value is a read-only AV*. You are responsible for C on the return value if you plan to store it anywhere semi-permanently (otherwise it might be deleted out from under you the next time the cache is invalidated). AV* mro_get_linear_isa(HV* stash)','name' => 'mro_get_linear_isa'},'av_store' => {'text' => '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)','name' => 'av_store'},'SvPVbytex' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex(SV* sv, STRLEN len)','name' => 'SvPVbytex'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and L. void PUSHMARK(SP)','name' => 'PUSHMARK'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. SV* ST(int ix)','name' => 'ST'},'call_pv' => {'text' => '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)','name' => 'call_pv'},'av_fetch' => {'text' => '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)','name' => 'av_fetch'},'gv_fetchmeth_autoload' => {'text' => '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 C. 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)','name' => 'gv_fetchmeth_autoload'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV* tb, HE* entry)','name' => 'hv_iterval'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. const char* sv_reftype(const SV* sv, int ob)','name' => 'sv_reftype'},'sv_pos_b2u' => {'text' => 'Converts the value pointed to by offsetp from a count of bytes from the start of the string, to a count of the equivalent number of UTF-8 chars. Handles magic and type coercion. void sv_pos_b2u(SV* sv, I32* offsetp)','name' => 'sv_pos_b2u'},'SvREFCNT_inc_simple_void_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value, and you know that I is not NULL. The macro doesn\'t need to return a meaningful value, or check for NULLness, so it\'s smaller and faster. void SvREFCNT_inc_simple_void_NN(SV* sv)','name' => 'SvREFCNT_inc_simple_void_NN'},'av_len' => {'text' => 'Returns the highest index in the array. The number of elements in the array is C. Returns -1 if the array is empty. I32 av_len(const AV* ar)','name' => 'av_len'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C.','name' => 'SVt_IV'},'SvIsCOW' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write. (either shared hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for COW) bool SvIsCOW(SV* sv)','name' => 'SvIsCOW'},'sv_unmagic' => {'text' => 'Removes all magic of type C from an SV. int sv_unmagic(SV* sv, int type)','name' => 'sv_unmagic'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled. void SvTAINT(SV* sv)','name' => 'SvTAINT'},'sv_catsv' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catsv(SV* dsv, SV* ssv)','name' => 'sv_catsv'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'ax' => {'text' => 'Variable which is setup by C to indicate the stack base offset, used by the C, C and C macros. The C macro must be called prior to setup the C variable. I32 ax','name' => 'ax'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'my_sprintf' => {'text' => 'The C library C, wrapped if necessary, to ensure that it will return the length of the string written to the buffer. Only rare pre-ANSI systems need the wrapper function - usually this is a direct call to C. int my_sprintf(char *buffer, const char *pat, ...)','name' => 'my_sprintf'},'to_utf8_fold' => {'text' => 'Convert the UTF-8 encoded character at p to its foldcase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the foldcase version may be longer than the original character (up to three characters). The first character of the foldcased version is returned (but note, as explained above, that there may be more.) UV to_utf8_fold(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_fold'},'to_utf8_upper' => {'text' => 'Convert the UTF-8 encoded character at p to its uppercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the uppercase version may be longer than the original character. The first character of the uppercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_upper(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_upper'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. Uses C to determine the length of C, then calls C. HV* gv_stashpv(const char* name, I32 flags)','name' => 'gv_stashpv'},'SvPVutf8x_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x_force(SV* sv, STRLEN len)','name' => 'SvPVutf8x_force'},'sv_vcatpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vcatpvf_mg(SV* sv, const char* pat, va_list* args)','name' => 'sv_vcatpvf_mg'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void PUSHi(IV iv)','name' => 'PUSHi'},'mXPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Does not use C. See also C, C and C. void mXPUSHu(UV uv)','name' => 'mXPUSHu'},'hv_exists_ent' => {'text' => '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)','name' => 'hv_exists_ent'},'SvLEN_set' => {'text' => 'Set the actual length of the string which is in the SV. See C. void SvLEN_set(SV* sv, STRLEN len)','name' => 'SvLEN_set'},'to_utf8_lower' => {'text' => 'Convert the UTF-8 encoded character at p to its lowercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since the lowercase version may be longer than the original character. The first character of the lowercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_lower(const U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_lower'},'SvNIOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a number, integer or double. U32 SvNIOK(SV* sv)','name' => 'SvNIOK'},'mro_method_changed_in' => {'text' => 'Invalidates method caching on any child classes of the given stash, so that they might notice the changes in this one. Ideally, all instances of C in perl source outside of C should be replaced by calls to this. Perl automatically handles most of the common ways a method might be redefined. However, there are a few ways you could change a method in a stash without the cache code noticing, in which case you need to call this method afterwards: 1) Directly manipulating the stash HV entries from XS code. 2) Assigning a reference to a readonly scalar constant into a stash entry in order to create a constant subroutine (like constant.pm does). This same method is available from pure perl via, C. void mro_method_changed_in(HV* stash)','name' => 'mro_method_changed_in'},'unpack_str' => {'text' => '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(const char *pat, const char *patend, const char *s, const char *strbeg, const char *strend, char **new_s, I32 ocnt, U32 flags)','name' => 'unpack_str'},'newSVpvf' => {'text' => 'Creates a new SV and initializes it with the string formatted like C. SV* newSVpvf(const char* pat, ...)','name' => 'newSVpvf'},'Newxc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. See also C. void Newxc(void* ptr, int nitems, type, cast)','name' => 'Newxc'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C wrapper instead. SV* sv_newref(SV* sv)','name' => 'sv_newref'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L. int perl_destruct(PerlInterpreter* interp)','name' => 'perl_destruct'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'SvIVX' => {'text' => 'Returns the raw value in the SV\'s IV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. IV SvIVX(SV* sv)','name' => 'SvIVX'},'sv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the scalar sv, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument is as in pv_uni_display(). The pointer to the PV of the dsv is returned. char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim, UV flags)','name' => 'sv_uni_display'},'newSVpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV* newSVpvs(const char* s)','name' => 'newSVpvs'},'sv_vsetpvf' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Does not handle \'set\' magic. See C. Usually used via its frontend C. void sv_vsetpvf(SV* sv, const char* pat, va_list* args)','name' => 'sv_vsetpvf'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'XCPT_CATCH' => {'text' => 'Introduces a catch block. See L.','name' => 'XCPT_CATCH'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the stack. void XST_mYES(int pos)','name' => 'XST_mYES'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. You probably want to use one of the assortment of wrappers, such as C, C, C and C. void sv_setsv(SV* dsv, SV* ssv)','name' => 'sv_setsv'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'packlist' => {'text' => 'The engine implementing pack() Perl function. void packlist(SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist)','name' => 'packlist'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C for a version which guarantees to evaluate sv only once. NV SvNV(SV* sv)','name' => 'SvNV'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'SvUTF8' => {'text' => 'Returns a U32 value indicating whether the SV contains UTF-8 encoded data. Call this after SvPV() in case any call to string overloading updates the internal flag. U32 SvUTF8(SV* sv)','name' => 'SvUTF8'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an XSUB\'s aliases was used to invoke it. See L. I32 ix','name' => 'ix'},'cv_undef' => {'text' => 'Clear out all the active components of a CV. This can happen either by an explicit C, 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)','name' => 'cv_undef'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'XSRETURN_UV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_UV(IV uv)','name' => 'XSRETURN_UV'},'SvREFCNT_inc_simple' => {'text' => 'Same as SvREFCNT_inc, but can only be used with expressions without side effects. Since we don\'t have to store a temporary value, it\'s faster. SV* SvREFCNT_inc_simple(SV* sv)','name' => 'SvREFCNT_inc_simple'},'get_cvn_flags' => {'text' => 'Returns the CV of the specified Perl subroutine. C are passed to C. 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_cvn_flags(const char* name, STRLEN len, I32 flags)','name' => 'get_cvn_flags'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'vverify' => {'text' => 'Validates that the SV contains a valid version object. bool vverify(SV *vobj); Note that it only confirms the bare minimum structure (so as not to get confused by derived classes which may contain additional hash entries): bool vverify(SV *vs)','name' => 'vverify'},'dXSI32' => {'text' => 'Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. dXSI32;','name' => 'dXSI32'},'SvPVx' => {'text' => 'A version of C which guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. char* SvPVx(SV* sv, STRLEN len)','name' => 'SvPVx'},'dXCPT' => {'text' => 'Set up necessary local variables for exception handling. See L. dXCPT;','name' => 'dXCPT'},'sv_tainted' => {'text' => 'Test an SV for taintedness. Use C instead. bool sv_tainted(SV* sv)','name' => 'sv_tainted'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. If necessary, uses C and upgrades the SV to C. Returns a pointer to the character buffer. Use the C wrapper instead. char* sv_grow(SV* sv, STRLEN newlen)','name' => 'sv_grow'},'vnormal' => {'text' => 'Accepts a version object and returns the normalized string representation. Call like: sv = vnormal(rv); NOTE: you can pass either the object directly or the SV contained within the RV. SV* vnormal(SV *vs)','name' => 'vnormal'},'cv_const_sv' => {'text' => 'If C is a constant sub eligible for inlining. returns the constant value returned by the sub. Otherwise, returns NULL. Constant subs can be created with C or as described in L. SV* cv_const_sv(CV* cv)','name' => 'cv_const_sv'},'newSVnv' => {'text' => '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)','name' => 'newSVnv'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. Does not use C. See also C, C and C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry. SV* HeVAL(HE* he)','name' => 'HeVAL'},'HePV' => {'text' => '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)','name' => 'HePV'},'pv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the string spv, length len, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument can have UNI_DISPLAY_ISPRINT set to display isPRINT()able characters as themselves, UNI_DISPLAY_BACKSLASH to display the \\\\[nrfta\\\\] as the backslashed versions (like \'\\n\') (UNI_DISPLAY_BACKSLASH is preferred over UNI_DISPLAY_ISPRINT for \\\\). UNI_DISPLAY_QQ (and its alias UNI_DISPLAY_REGEX) have both UNI_DISPLAY_BACKSLASH and UNI_DISPLAY_ISPRINT turned on. The pointer to the PV of the dsv is returned. char* pv_uni_display(SV *dsv, const U8 *spv, STRLEN len, STRLEN pvlim, UV flags)','name' => 'pv_uni_display'},'SvGETMAGIC' => {'text' => 'Invokes C on an SV if it has \'get\' magic. This macro evaluates its argument more than once. void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_inc(SV* sv)','name' => 'sv_inc'},'sv_usepvn' => {'text' => 'Tells an SV to use C to find its string value. Implemented by calling C with C of 0, hence does not handle \'set\' magic. See C. void sv_usepvn(SV* sv, char* ptr, STRLEN len)','name' => 'sv_usepvn'},'SvPVbytex_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex_force(SV* sv, STRLEN len)','name' => 'SvPVbytex_force'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'warn' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Call this function the same way you call the C C function. See C. void warn(const char* pat, ...)','name' => 'warn'},'hv_delete' => {'text' => '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, I32 klen, I32 flags)','name' => 'hv_delete'},'sv_cat_decode' => {'text' => 'The encoding is assumed to be an Encode object, the PV of the ssv is assumed to be octets in that encoding and decoding the input starts from the position which (PV + *offset) pointed to. The dsv will be concatenated the decoded UTF-8 string from ssv. Decoding will terminate when the string tstr appears in decoding output or the input ends on the PV of the ssv. The value which the offset points will be modified to the last input position on the ssv. Returns TRUE if the terminator was found, else returns FALSE. bool sv_cat_decode(SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen)','name' => 'sv_cat_decode'},'POP_MULTICALL' => {'text' => 'Closing bracket for a lightweight callback. See L. POP_MULTICALL;','name' => 'POP_MULTICALL'},'SvIV_set' => {'text' => 'Set the value of the IV pointer in sv to val. It is possible to perform the same function of this macro with an lvalue assignment to C. With future Perls, however, it will be more efficient to use C instead of the lvalue assignment to C. void SvIV_set(SV* sv, IV val)','name' => 'SvIV_set'},'sv_setiv' => {'text' => 'Copies an integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setiv(SV* sv, IV num)','name' => 'sv_setiv'},'sv_report_used' => {'text' => 'Dump the contents of all SVs not yet freed. (Debugging aid). void sv_report_used()','name' => 'sv_report_used'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. void EXTEND(SP, int nitems)','name' => 'EXTEND'},'SvNVX' => {'text' => 'Returns the raw value in the SV\'s NV slot, without checks or conversions. Only use when you are sure SvNOK is true. See also C. NV SvNVX(SV* sv)','name' => 'SvNVX'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(UV u)','name' => 'newSVuv'},'gv_fetchmeth' => {'text' => '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. 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)','name' => 'gv_fetchmeth'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. U32 HeHASH(HE* he)','name' => 'HeHASH'},'SvIOK' => {'text' => 'Returns a U32 value indicating whether the SV contains an integer. U32 SvIOK(SV* sv)','name' => 'SvIOK'},'sv_does' => {'text' => 'Returns a boolean indicating whether the SV performs a specific, named role. The SV can be a Perl object or the name of a Perl class. bool sv_does(SV* sv, const char* name)','name' => 'sv_does'},'SvPV_force' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part attributable to C. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a string and disables all other OK bits, and leaves the UTF-8 status as it was. void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic after a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'},'SvTRUE' => {'text' => '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)','name' => 'SvTRUE'},'grok_hex' => {'text' => 'converts a string representing a hex number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0x" or "x" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the hex number may use \'_\' characters to separate digits. UV grok_hex(const char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_hex'},'hv_iternext_flags' => {'text' => 'Returns entries from a hash iterator. See C and C. The C 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 C<&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)','name' => 'hv_iternext_flags'},'is_utf8_string_loclen' => {'text' => 'Like is_utf8_string() but stores the location of the failure (in the case of "utf8ness failure") or the location s+len (in the case of "utf8ness success") in the C, and the number of UTF-8 encoded characters in the C. See also is_utf8_string_loc() and is_utf8_string(). bool is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el)','name' => 'is_utf8_string_loclen'},'call_method' => {'text' => '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)','name' => 'call_method'},'SvLOCK' => {'text' => 'Arranges for a mutual exclusion lock to be obtained on sv if a suitable module has been loaded. void SvLOCK(SV* sv)','name' => 'SvLOCK'},'sv_vsetpvfn' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Usually used via one of its frontends C and C. void sv_vsetpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vsetpvfn'},'perl_parse' => {'text' => '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)','name' => 'perl_parse'},'to_utf8_case' => {'text' => 'The "p" contains the pointer to the UTF-8 string encoding the character that is being converted. The "ustrp" is a pointer to the character buffer to put the conversion result to. The "lenp" is a pointer to the length of the result. The "swashp" is a pointer to the swash to use. Both the special and normal mappings are stored lib/unicore/To/Foo.pl, and loaded by SWASHNEW, using lib/utf8_heavy.pl. The special (usually, but not always, a multicharacter mapping), is tried first. The "special" is a string like "utf8::ToSpecLower", which means the hash %utf8::ToSpecLower. The access to the hash is through Perl_to_utf8_case(). The "normal" is a string like "ToLower" which means the swash %utf8::ToLower. UV to_utf8_case(const U8 *p, U8* ustrp, STRLEN *lenp, SV **swashp, const char *normal, const char *special)','name' => 'to_utf8_case'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory used by the array itself. void av_clear(AV* ar)','name' => 'av_clear'},'sv_force_normal' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. See also C. void sv_force_normal(SV *sv)','name' => 'sv_force_normal'},'av_unshift' => {'text' => '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)','name' => 'av_unshift'},'SvREFCNT_inc_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you know I is not NULL. Since we don\'t have to check the NULLness, it\'s faster and smaller. SV* SvREFCNT_inc_NN(SV* sv)','name' => 'SvREFCNT_inc_NN'},'POPpbytex' => {'text' => 'Pops a string off the stack which must consist of bytes i.e. characters < 256. char* POPpbytex','name' => 'POPpbytex'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. UV SvUVX(SV* sv)','name' => 'SvUVX'},'SvSetMagicSV' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV(SV* dsb, SV* ssv)','name' => 'SvSetMagicSV'},'sv_utf8_decode' => {'text' => 'If the PV of the SV is an octet sequence in UTF-8 and contains a multiple-byte character, the C flag is turned on so that it looks like a character. If the PV contains only single-byte characters, the C flag stays being off. Scans PV for validity and returns false if the PV is invalid UTF-8. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_decode(SV *sv)','name' => 'sv_utf8_decode'},'hv_stores' => {'text' => 'Like C, but takes a literal string instead of a string/length pair and omits the hash parameter. SV** hv_stores(HV* tb, const char* key, NULLOK SV* val)','name' => 'hv_stores'},'eval_sv' => {'text' => '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)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'Move' => {'text' => '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)','name' => 'Move'},'sv_catpvn_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. void sv_catpvn_flags(SV* sv, const char* ptr, STRLEN len, I32 flags)','name' => 'sv_catpvn_flags'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'GIMME' => {'text' => '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','name' => 'GIMME'},'sv_2iv_flags' => {'text' => 'Return the integer value of an SV, doing any necessary string conversion. If flags includes SV_GMAGIC, does an mg_get() first. Normally used via the C and C macros. IV sv_2iv_flags(SV* sv, I32 flags)','name' => 'sv_2iv_flags'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs. I needs to be static storage, as it is used directly as CvFILE(), without a copy being made.','name' => 'newXS'},'isALNUM' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphanumeric character (including underscore) or digit. bool isALNUM(char ch)','name' => 'isALNUM'},'XCPT_RETHROW' => {'text' => 'Rethrows a previously caught exception. See L. XCPT_RETHROW;','name' => 'XCPT_RETHROW'},'my_snprintf' => {'text' => 'The C library C functionality, if available and standards-compliant (uses C, actually). However, if the C is not available, will unfortunately use the unsafe C which can overrun the buffer (there is an overrun check, but that may be too late). Consider using C instead, or getting C. int my_snprintf(char *buffer, const Size_t len, const char *format, ...)','name' => 'my_snprintf'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. bool SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'PUSHmortal' => {'text' => 'Push a new mortal SV onto the stack. The stack must have room for this element. Does not handle \'set\' magic. Does not use C. See also C, C and C. void PUSHmortal()','name' => 'PUSHmortal'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter* interp)','name' => 'perl_construct'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. bool SvUOK(SV* sv)','name' => 'SvUOK'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_dec(SV* sv)','name' => 'sv_dec'},'strLE' => {'text' => '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)','name' => 'strLE'},'pv_display' => {'text' => 'char *pv_display(SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim, U32 flags) Similar to pv_escape(dsv,pv,cur,pvlim,PERL_PV_ESCAPE_QUOTE); except that an additional "\\0" will be appended to the string when len > cur and pv[cur] is "\\0". Note that the final string may be up to 7 chars longer than pvlim. char* pv_display(SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)','name' => 'pv_display'},'sv_2pvbyte_nolen' => {'text' => 'Return a pointer to the byte-encoded representation of the SV. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'SvOK' => {'text' => 'Returns a U32 value indicating whether the value is an SV. It also tells whether the value is defined or not. U32 SvOK(SV* sv)','name' => 'SvOK'},'sv_setref_nv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_nv(SV* rv, const char* classname, NV nv)','name' => 'sv_setref_nv'},'uvchr_to_utf8' => {'text' => 'Adds the UTF-8 representation of the Native codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvchr_to_utf8(d, uv); is the recommended wide native character-aware way of saying *(d++) = uv; U8* uvchr_to_utf8(U8 *d, UV uv)','name' => 'uvchr_to_utf8'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII digit. bool isDIGIT(char ch)','name' => 'isDIGIT'},'eval_pv' => {'text' => '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)','name' => 'eval_pv'},'sv_usepvn_flags' => {'text' => '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. By default this function will realloc (i.e. move) the memory pointed to by C, so that pointer should not be freed or used by the programmer after giving it to sv_usepvn, and neither should any pointers from "behind" that pointer (e.g. ptr + 1) be used. If C & SV_SMAGIC is true, will call SvSETMAGIC. If C & SV_HAS_TRAILING_NUL is true, then C must be NUL, and the realloc will be skipped. (i.e. the buffer is actually at least 1 byte longer than C, and already meets the requirements for storing in C) void sv_usepvn_flags(SV* sv, char* ptr, STRLEN len, U32 flags)','name' => 'sv_usepvn_flags'},'hv_assert' => {'text' => 'Check that a hash is in an internally consistent state. void hv_assert(HV* tb)','name' => 'hv_assert'},'my_vsnprintf' => {'text' => 'The C library C if available and standards-compliant. However, if if the C is not available, will unfortunately use the unsafe C which can overrun the buffer (there is an overrun check, but that may be too late). Consider using C instead, or getting C. int my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap)','name' => 'my_vsnprintf'},'sv_free' => {'text' => 'Decrement an SV\'s reference count, and if it drops to zero, call C to invoke destructors and free up any memory used by the body; finally, deallocate the SV\'s head itself. Normally called via a wrapper macro C. void sv_free(SV* sv)','name' => 'sv_free'},'SvPVbyte_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_force(SV* sv, STRLEN len)','name' => 'SvPVbyte_force'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. CV* newCONSTSUB(HV* stash, const char* name, SV* sv)','name' => 'newCONSTSUB'},'SvSHARE' => {'text' => 'Arranges for sv to be shared between threads if a suitable module has been loaded. void SvSHARE(SV* sv)','name' => 'SvSHARE'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_pop(AV* ar)','name' => 'av_pop'},'croak' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Normally call this function the same way you call the C C function. Calling C returns control directly to Perl, sidestepping the normal C order of execution. See C. If you want to throw an exception object, assign the object to C<$@> and then pass C to croak(): errsv = get_sv("@", TRUE); sv_setsv(errsv, exception_object); croak(NULL); void croak(const char* pat, ...)','name' => 'croak'},'sortsv' => {'text' => 'Sort an array. Here is an example: sortsv(AvARRAY(av), av_len(av)+1, Perl_sv_cmp_locale); Currently this always uses mergesort. See sortsv_flags for a more flexible routine. void sortsv(SV** array, size_t num_elts, SVCOMPARE_t cmp)','name' => 'sortsv'},'THIS' => {'text' => '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','name' => 'THIS'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually handled by C. void XSRETURN(int nitems)','name' => 'XSRETURN'},'scan_bin' => {'text' => 'For backwards compatibility. Use C instead. NV scan_bin(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_bin'},'Nullcv' => {'text' => 'Null CV pointer.','name' => 'Nullcv'},'get_av' => {'text' => '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)','name' => 'get_av'},'sv_2pv_nolen' => {'text' => 'Like C, but doesn\'t return the length too. You should usually use the macro wrapper C instead. char* sv_2pv_nolen(SV* sv)','name' => 'sv_2pv_nolen'},'MULTICALL' => {'text' => 'Make a lightweight callback. See L. MULTICALL;','name' => 'MULTICALL'},'SvPVbyte' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'PoisonFree' => {'text' => 'PoisonWith(0xEF) for catching access to freed memory. void PoisonFree(void* dest, int nitems, type)','name' => 'PoisonFree'},'toUPPER' => {'text' => 'Converts the specified character to uppercase. char toUPPER(char ch)','name' => 'toUPPER'},'is_utf8_string_loc' => {'text' => 'Like is_utf8_string() but stores the location of the failure (in the case of "utf8ness failure") or the location s+len (in the case of "utf8ness success") in the C. See also is_utf8_string_loclen() and is_utf8_string(). bool is_utf8_string_loc(const U8 *s, STRLEN len, const U8 **p)','name' => 'is_utf8_string_loc'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally appending to the currently-stored string. char* sv_gets(SV* sv, PerlIO* fp, I32 append)','name' => 'sv_gets'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'SvPVutf8x' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'sv_2cv' => {'text' => 'Using various gambits, try to get a CV from an SV; in addition, try if possible to set C<*st> and C<*gvp> to the stash and GV associated with it. The flags in C are passed to sv_fetchsv. CV* sv_2cv(SV* sv, HV** st, GV** gvp, I32 lref)','name' => 'sv_2cv'},'SvPV_force_nomg' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. Doesn\'t process magic. char* SvPV_force_nomg(SV* sv, STRLEN len)','name' => 'SvPV_force_nomg'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. Will also turn off the UTF-8 status. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'dUNDERBAR' => {'text' => 'Sets up the C variable for an XSUB that wishes to use C. dUNDERBAR;','name' => 'dUNDERBAR'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'XCPT_TRY_START' => {'text' => 'Starts a try block. See L.','name' => 'XCPT_TRY_START'},'sv_pvbyte' => {'text' => 'Use C instead. char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'sv_uv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. UV sv_uv(SV* sv)','name' => 'sv_uv'},'hv_fetch' => {'text' => '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 an C. See L for more information on how to use this function on tied hashes. SV** hv_fetch(HV* tb, const char* key, I32 klen, I32 lval)','name' => 'hv_fetch'},'sv_unref_flags' => {'text' => '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. The C argument can contain C to force the reference count to be decremented (otherwise the decrementing is conditional on the reference count being different from one or the reference being a readonly SV). See C. void sv_unref_flags(SV* sv, U32 flags)','name' => 'sv_unref_flags'},'hv_scalar' => {'text' => 'Evaluates the hash in scalar context and returns the result. Handles magic when the hash is tied. SV* hv_scalar(HV* hv)','name' => 'hv_scalar'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'Nullch' => {'text' => 'Null character pointer.','name' => 'Nullch'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)','name' => 'mg_copy'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'grok_oct' => {'text' => 'converts a string representing an octal number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an invalid character will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). If C is set in I<*flags> then the octal number may use \'_\' characters to separate digits. UV grok_oct(const char* start, STRLEN* len_p, I32* flags, NV *result)','name' => 'grok_oct'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C flag on this RV; give the referred-to SV C magic if it hasn\'t already; and push a back-reference to this RV onto the array of backreferences associated with that magic. If the RV is magical, set magic will be called after the RV is cleared. SV* sv_rvweaken(SV *sv)','name' => 'sv_rvweaken'},'scan_hex' => {'text' => 'For backwards compatibility. Use C instead. NV scan_hex(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_hex'},'newSVpvn' => {'text' => '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. If the C argument is NULL the new SV will be undefined. SV* newSVpvn(const char* s, STRLEN len)','name' => 'newSVpvn'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the supplied vtable and returns a pointer to the magic added. Note that C will allow things that C will not. In particular, you can add magic to SvREADONLY SVs, and add more than one instance of the same \'how\'. If C is greater than zero then a C I of C is stored, if C is zero then C is stored as-is and - as another special case - if C<(name && namlen == HEf_SVKEY)> then C is assumed to contain an C and is stored as-is with its REFCNT incremented. (This is now used as a subroutine by C.) MAGIC * sv_magicext(SV* sv, SV* obj, int how, const MGVTBL *vtbl, const char* name, I32 namlen)','name' => 'sv_magicext'},'av_push' => {'text' => '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)','name' => 'av_push'},'unpackstring' => {'text' => 'The engine implementing unpack() Perl function. C puts the extracted list items on the stack and returns the number of elements. Issue C before and C after the call to this function. I32 unpackstring(const char *pat, const char *patend, const char *s, const char *strend, U32 flags)','name' => 'unpackstring'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV* ar, I32 key)','name' => 'av_extend'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV* sv)','name' => 'newRV_noinc'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. You may call C or C 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 C, so you must not discard your iterator immediately else the entry will leak - call C to trigger the resource deallocation. HE* hv_iternext(HV* tb)','name' => 'hv_iternext'},'hv_iterinit' => {'text' => '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)','name' => 'hv_iterinit'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.010000', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_008_000.pm0000644000175000017500000033310611653441731020763 0ustar tseetseepackage Perl::APIReference::V5_008_000; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'SvOOK' => {'text' => '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)','name' => 'SvOOK'},'hv_store_ent' => {'text' => '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)','name' => 'hv_store_ent'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package, which must be a valid UTF-8 string. See C. HV* gv_stashsv(SV* sv, I32 create)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'strGE' => {'text' => '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)','name' => 'strGE'},'form' => {'text' => '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, ...)','name' => 'form'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified version becoming C. Handles \'get\' magic. See also C for a version which guarantees to evaluate sv only once. char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'is_utf8_string' => {'text' => 'Returns true if first C bytes of the given string form a valid UTF8 string, false otherwise. Note that \'a valid UTF8 string\' does not mean \'a string that contains UTF8\' because a valid ASCII string is a valid UTF8 string. bool is_utf8_string(U8 *s, STRLEN len)','name' => 'is_utf8_string'},'svtype' => {'text' => '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.','name' => 'svtype'},'hv_clear' => {'text' => 'Clears a hash, making it empty. void hv_clear(HV* tb)','name' => 'hv_clear'},'get_hv' => {'text' => '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)','name' => 'get_hv'},'load_module' => {'text' => '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 C. The optional trailing SV* arguments can be used to specify arguments to the module\'s import() method, similar to C. void load_module(U32 flags, SV* name, SV* ver, ...)','name' => 'load_module'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES;','name' => 'XSRETURN_YES'},'sv_nv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. NV sv_nv(SV* sv)','name' => 'sv_nv'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'Poison' => {'text' => '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)','name' => 'Poison'},'sv_insert' => {'text' => '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)','name' => 'sv_insert'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_catpvf_mg'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'SvPOK' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. bool SvPOK(SV* sv)','name' => 'SvPOK'},'get_sv' => {'text' => '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)','name' => 'get_sv'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. See C. void PUSHu(UV uv)','name' => 'PUSHu'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. (Uses C). SV* newSVsv(SV* old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C. void hv_magic(HV* hv, GV* gv, int how)','name' => 'hv_magic'},'SvPVutf8' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *sv, const char *ptr)','name' => 'sv_setpv_mg'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C.','name' => 'XS'},'scan_oct' => {'text' => 'For backwards compatibility. Use C instead. NV scan_oct(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_oct'},'sv_setpvn' => {'text' => '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)','name' => 'sv_setpvn'},'sv_2mortal' => {'text' => 'Marks an existing SV as mortal. The SV will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_2mortal(SV* sv)','name' => 'sv_2mortal'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'newSVrv' => {'text' => '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)','name' => 'newSVrv'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself. void av_undef(AV* ar)','name' => 'av_undef'},'HeKEY' => {'text' => '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)','name' => 'HeKEY'},'pack_cat' => {'text' => 'The engine implementing pack() Perl function. void pack_cat(SV *cat, char *pat, char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)','name' => 'pack_cat'},'utf8n_to_uvuni' => {'text' => 'Bottom level UTF-8 decode routine. Returns the unicode code point value of the first character in the string C which is assumed to be in UTF8 encoding and no longer than C; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF8 character, the behaviour is dependent on the value of C: if it contains UTF8_CHECK_ONLY, it is assumed that the caller will raise a warning, and this function will silently just set C to C<-1> and return zero. If the C does not contain UTF8_CHECK_ONLY, warnings about malformations will be given, C will be set to the expected length of the UTF-8 character in bytes, and zero will be returned. The C can also contain various flags to allow deviations from the strict UTF-8 encoding (see F). Most code should use utf8_to_uvchr() rather than call this directly. UV utf8n_to_uvuni(U8 *s, STRLEN curlen, STRLEN* retlen, U32 flags)','name' => 'utf8n_to_uvuni'},'sv_cmp' => {'text' => '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. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp(SV* sv1, SV* sv2)','name' => 'sv_cmp'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'SvEND' => {'text' => '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)','name' => 'SvEND'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C to type C if necessary, then adds a new magic item of type C to the head of the magic list. void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen)','name' => 'sv_magic'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C, C or C for void, scalar or list context, respectively. U32 GIMME_V','name' => 'GIMME_V'},'sv_force_normal_flags' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. The C parameter gets passed to C when unrefing. C calls this function with flags set to 0. void sv_force_normal_flags(SV *sv, U32 flags)','name' => 'sv_force_normal_flags'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'sv_setsv_flags' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. If the C parameter has the C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You probably want to use one of the assortment of wrappers, such as C, C, C and C. This is the primary function for copying scalars, and most other copy-ish functions and macros use this underneath. void sv_setsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_setsv_flags'},'sv_utf8_upgrade_flags' => {'text' => 'Convert the PV of an SV to its UTF8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade_flags(SV *sv, I32 flags)','name' => 'sv_utf8_upgrade_flags'},'New' => {'text' => 'The XSUB-writer\'s interface to the C C function. void New(int id, void* ptr, int nitems, type)','name' => 'New'},'is_utf8_char' => {'text' => 'Tests if some arbitrary number of bytes begins in a valid UTF-8 character. Note that an INVARIANT (i.e. ASCII) character is a valid UTF-8 character. The actual number of bytes in the UTF-8 character will be returned if it is valid, otherwise 0. STRLEN is_utf8_char(U8 *p)','name' => 'is_utf8_char'},'Copy' => {'text' => '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)','name' => 'Copy'},'ibcmp_utf8' => {'text' => 'Return true if the strings s1 and s2 differ case-insensitively, false if not (if they are equal case-insensitively). If u1 is true, the string s1 is assumed to be in UTF-8-encoded Unicode. If u2 is true, the string s2 is assumed to be in UTF-8-encoded Unicode. If u1 or u2 are false, the respective string is assumed to be in native 8-bit encoding. If the pe1 and pe2 are non-NULL, the scanning pointers will be copied in there (they will point at the beginning of the I character). If the pointers behind pe1 or pe2 are non-NULL, they are the end pointers beyond which scanning will not continue under any circustances. If the byte lengths l1 and l2 are non-zero, s1+l1 and s2+l2 will be used as goal end pointers that will also stop the scan, and which qualify towards defining a successful match: all the scans that define an explicit length must reach their goal pointers for a match to succeed). For case-insensitiveness, the "casefolding" of Unicode is used instead of upper/lowercasing both the characters, see http://www.unicode.org/unicode/reports/tr21/ (Case Mappings). I32 ibcmp_utf8(const char* a, char **pe1, UV l1, bool u1, const char* b, char **pe2, UV l2, bool u2)','name' => 'ibcmp_utf8'},'CvSTASH' => {'text' => 'Returns the stash of the CV. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'sv_taint' => {'text' => 'Taint an SV. Use C instead. void sv_taint(SV* sv)','name' => 'sv_taint'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. The target SV physically takes over ownership of the body of the source SV and inherits its flags; however, the target keeps any magic it owns, and any magic in the source is discarded. Note that this is a rather specialist SV copying operation; most of the time you\'ll want to use C or one of its many macro front-ends. void sv_replace(SV* sv, SV* nsv)','name' => 'sv_replace'},'utf8n_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF8 encoding; C will be set to the length, in bytes, of that character. Allows length and flags to be passed to low level routine. UV utf8n_to_uvchr(U8 *s, STRLEN curlen, STRLEN* retlen, U32 flags)','name' => 'utf8n_to_uvchr'},'sv_utf8_upgrade' => {'text' => 'Convert the PV of an SV to its UTF8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains a signed integer. void SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and L.','name' => 'G_ARRAY'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. Sets up the C and C variables by calling C and C. This is usually handled automatically by C. dXSARGS;','name' => 'dXSARGS'},'sv_2iv' => {'text' => 'Return the integer value of an SV, doing any necessary string conversion, magic etc. Normally used via the C and C macros. IV sv_2iv(SV* sv)','name' => 'sv_2iv'},'savesharedpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* ptr)','name' => 'Safefree'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the C C is whitespace. bool isSPACE(char ch)','name' => 'isSPACE'},'SvROK' => {'text' => 'Tests if the SV is an RV. bool SvROK(SV* sv)','name' => 'SvROK'},'new_vstring' => {'text' => 'Returns a pointer to the next character after the parsed vstring, as well as updating the passed in sv. Function must be called like sv = NEWSV(92,5); s = new_vstring(s,sv); The sv must already be large enough to store the vstring passed in. char* new_vstring(char *vstr, SV *sv)','name' => 'new_vstring'},'sv_unref' => {'text' => '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. This is C with the C being zero. See C. void sv_unref(SV* sv)','name' => 'sv_unref'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dstr, SV *sstr)','name' => 'sv_catsv_mg'},'call_argv' => {'text' => '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)','name' => 'call_argv'},'SvPV_nolen' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified form becoming C. Handles \'get\' magic. char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'perl_clone' => {'text' => 'Create and return a new interpreter by cloning the current one. PerlInterpreter* perl_clone(PerlInterpreter* interp, UV flags)','name' => 'perl_clone'},'sv_setnv' => {'text' => 'Copies a double into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setnv(SV* sv, NV num)','name' => 'sv_setnv'},'sv_2nv' => {'text' => 'Return the num value of an SV, doing any necessary string or integer conversion, magic etc. Normally used via the C and C macros. NV sv_2nv(SV* sv)','name' => 'sv_2nv'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'XPUSHp' => {'text' => '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)','name' => 'XPUSHp'},'sv_utf8_encode' => {'text' => 'Convert the PV of an SV to UTF8-encoded, but then turn off the C flag so that it looks like octets again. Used as a building block for encode_utf8 in Encode.xs void sv_utf8_encode(SV *sv)','name' => 'sv_utf8_encode'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1. HV* newHV()','name' => 'newHV'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or false. bool strNE(char* s1, char* s2)','name' => 'strNE'},'SvUTF8_on' => {'text' => 'Turn on the UTF8 status of an SV (the data is not changed, just the flag). Do not use frivolously. void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_setpvn_mg'},'sv_pvutf8n_force' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n_force(SV* sv, STRLEN* lp)','name' => 'sv_pvutf8n_force'},'savepv' => {'text' => 'Perl\'s version of C. Returns a pointer to a newly allocated string which is a duplicate of C. The size of the string is determined by C. The memory allocated for the new string can be freed with the C function. char* savepv(const char* pv)','name' => 'savepv'},'toLOWER' => {'text' => 'Converts the specified character to lowercase. char toLOWER(char ch)','name' => 'toLOWER'},'bytes_from_utf8' => {'text' => 'Converts a string C of length C from UTF8 into byte encoding. Unlike but like C, returns a pointer to the newly-created string, and updates C to contain the new length. Returns the original string if no conversion occurs, C is unchanged. Do nothing if C points to 0. Sets C to 0 if C is converted or contains all 7bit characters. NOTE: this function is experimental and may change or be removed without notice. U8* bytes_from_utf8(U8 *s, STRLEN *len, bool *is_utf8)','name' => 'bytes_from_utf8'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1. AV* newAV()','name' => 'newAV'},'POPp' => {'text' => 'Pops a string off the stack. Deprecated. New code should provide a STRLEN n_a and use POPpx. char* POPp','name' => 'POPp'},'HvNAME' => {'text' => 'Returns the package name of a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV of the sv is assumed to be octets in that encoding, and the sv will be converted into Unicode (and UTF-8). If the sv already is UTF-8 (or if it is not POK), or if the encoding is not a reference, nothing is done to the sv. If the encoding is not an C Encoding object, bad things will happen. (See F and L). The PV of the sv is returned. char* sv_recode_to_utf8(SV* sv, SV *encoding)','name' => 'sv_recode_to_utf8'},'av_make' => {'text' => '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)','name' => 'av_make'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. See C for a version which guarantees to evaluate sv only once. UV SvUV(SV* sv)','name' => 'SvUV'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L. int perl_run(PerlInterpreter* interp)','name' => 'perl_run'},'sv_pvbyten' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten(SV *sv, STRLEN *len)','name' => 'sv_pvbyten'},'sv_catsv_flags' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. If C has C bit set, will C on the SVs if appropriate, else not. C and C are implemented in terms of this function. void sv_catsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_catsv_flags'},'Nullav' => {'text' => 'Null AV pointer.','name' => 'Nullav'},'sv_copypv' => {'text' => 'Copies a stringified representation of the source SV into the destination SV. Automatically performs any necessary mg_get and coercion of numeric values into strings. Guaranteed to preserve UTF-8 flag even from overloaded objects. Similar in nature to sv_2pv[_flags] but operates directly on an SV instead of just the string. Mostly uses sv_2pv_flags to do its work, except when that would lose the UTF-8\'ness of the PV. void sv_copypv(SV* dsv, SV* ssv)','name' => 'sv_copypv'},'sv_pv' => {'text' => 'Use the C macro instead char* sv_pv(SV *sv)','name' => 'sv_pv'},'SvPVutf8_nolen' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_nolen(SV* sv)','name' => 'SvPVutf8_nolen'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setnv_mg(SV *sv, NV num)','name' => 'sv_setnv_mg'},'sv_true' => {'text' => 'Returns true if the SV has a true value by Perl\'s rules. Use the C macro instead, which may call C or may instead use an in-line version. I32 sv_true(SV *sv)','name' => 'sv_true'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV* hv, char** key, I32* retlen)','name' => 'hv_iternextsv'},'utf8_to_bytes' => {'text' => 'Converts a string C of length C from UTF8 into byte encoding. Unlike C, this over-writes the original string, and updates len to contain the new length. Returns zero on failure, setting C to -1. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_pvbyten_force' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten_force(SV* sv, STRLEN* lp)','name' => 'sv_pvbyten_force'},'sv_derived_from' => {'text' => '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)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. See also C. I32 sv_cmp_locale(SV* sv1, SV* sv2)','name' => 'sv_cmp_locale'},'uvuni_to_utf8_flags' => {'text' => 'Adds the UTF8 representation of the Unicode codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvuni_to_utf8_flags(d, uv, flags); or, in most cases, d = uvuni_to_utf8(d, uv); (which is equivalent to) d = uvuni_to_utf8_flags(d, uv, 0); is the recommended Unicode-aware way of saying *(d++) = uv; U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)','name' => 'uvuni_to_utf8_flags'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'hv_exists' => {'text' => '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, I32 klen)','name' => 'hv_exists'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See L.','name' => 'G_DISCARD'},'Nullsv' => {'text' => 'Null SV pointer.','name' => 'Nullsv'},'mg_length' => {'text' => 'Report on the SV\'s length. See C. U32 mg_length(SV* sv)','name' => 'mg_length'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'SvPVX' => {'text' => 'Returns a pointer to the physical string in the SV. The SV must contain a string. char* SvPVX(SV* sv)','name' => 'SvPVX'},'XST_mNV' => {'text' => '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)','name' => 'XST_mNV'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. See C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'HEf_SVKEY' => {'text' => 'This flag, used in the length slot of hash entries and magic structures, specifies the structure contains an C pointer where a C pointer is to be expected. (For information only--not to be used).','name' => 'HEf_SVKEY'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C in characters. Stops at C (inclusive). If C s> or if the scan would end up past C, croaks. STRLEN utf8_length(U8* s, U8 *e)','name' => 'utf8_length'},'SvPVutf8_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_force(SV* sv, STRLEN len)','name' => 'SvPVutf8_force'},'sv_2pvutf8_nolen' => {'text' => 'Return a pointer to the UTF8-encoded representation of the SV. May cause the SV to be upgraded to UTF8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8_nolen(SV* sv)','name' => 'sv_2pvutf8_nolen'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'SvIOK_only_UV' => {'text' => 'Tells and SV that it is an unsigned integer and disables all other OK bits. void SvIOK_only_UV(SV* sv)','name' => 'SvIOK_only_UV'},'sv_nolocking' => {'text' => '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 *)','name' => 'sv_nolocking'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C.','name' => 'SVt_NV'},'sv_vcatpvfn' => {'text' => '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). Usually used via one of its frontends C and C. void sv_vcatpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vcatpvfn'},'SvPVbytex' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex(SV* sv, STRLEN len)','name' => 'SvPVbytex'},'av_store' => {'text' => '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)','name' => 'av_store'},'sv_2uv' => {'text' => 'Return the unsigned integer value of an SV, doing any necessary string conversion, magic etc. Normally used via the C and C macros. UV sv_2uv(SV* sv)','name' => 'sv_2uv'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and L. PUSHMARK;','name' => 'PUSHMARK'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. SV* ST(int ix)','name' => 'ST'},'strLT' => {'text' => '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)','name' => 'strLT'},'sv_pvutf8n' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n(SV *sv, STRLEN *len)','name' => 'sv_pvutf8n'},'call_pv' => {'text' => '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)','name' => 'call_pv'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. SV* av_shift(AV* ar)','name' => 'av_shift'},'newSV' => {'text' => 'Create a new null SV, or if len > 0, create a new empty SVt_PV type SV with an initial PV allocation of len+1. Normally accessed via the C macro. SV* newSV(STRLEN len)','name' => 'newSV'},'av_fetch' => {'text' => '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)','name' => 'av_fetch'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'gv_fetchmeth_autoload' => {'text' => '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 C. 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)','name' => 'gv_fetchmeth_autoload'},'sv_nounlocking' => {'text' => '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 *)','name' => 'sv_nounlocking'},'sv_2pvutf8' => {'text' => 'Return a pointer to the UTF8-encoded representation of the SV, and set *lp to its length. May cause the SV to be upgraded to UTF8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8(SV* sv, STRLEN* lp)','name' => 'sv_2pvutf8'},'dITEMS' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dITEMS;','name' => 'dITEMS'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV* tb, HE* entry)','name' => 'hv_iterval'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. char* sv_reftype(SV* sv, int ob)','name' => 'sv_reftype'},'sv_pos_b2u' => {'text' => 'Converts the value pointed to by offsetp from a count of bytes from the start of the string, to a count of the equivalent number of UTF8 chars. Handles magic and type coercion. void sv_pos_b2u(SV* sv, I32* offsetp)','name' => 'sv_pos_b2u'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C.','name' => 'SVt_IV'},'av_len' => {'text' => 'Returns the highest index in the array. Returns -1 if the array is empty. I32 av_len(AV* ar)','name' => 'av_len'},'sv_unmagic' => {'text' => 'Removes all magic of type C from an SV. int sv_unmagic(SV* sv, int type)','name' => 'sv_unmagic'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *sv, IV i)','name' => 'sv_setiv_mg'},'sv_catsv' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catsv(SV* dsv, SV* ssv)','name' => 'sv_catsv'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled void SvTAINT(SV* sv)','name' => 'SvTAINT'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C. See C and L for other uses. PUTBACK;','name' => 'PUTBACK'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'ax' => {'text' => 'Variable which is setup by C to indicate the stack base offset, used by the C, C and C macros. The C macro must be called prior to setup the C variable. I32 ax','name' => 'ax'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'SvCUR_set' => {'text' => 'Set the length of the string which is in the SV. See C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'to_utf8_fold' => {'text' => 'Convert the UTF-8 encoded character at p to its foldcase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_FOLD+1 bytes since the foldcase version may be longer than the original character (up to three characters). The first character of the foldcased version is returned (but note, as explained above, that there may be more.) UV to_utf8_fold(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_fold'},'to_utf8_upper' => {'text' => 'Convert the UTF-8 encoded character at p to its uppercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the uppercase version may be longer than the original character (up to two characters). The first character of the uppercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_upper(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_upper'},'SvNOK' => {'text' => 'Returns a boolean indicating whether the SV contains a double. bool SvNOK(SV* sv)','name' => 'SvNOK'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. C should be a valid UTF-8 string. 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)','name' => 'gv_stashpv'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C, C, and L.','name' => 'G_SCALAR'},'SvPVutf8x_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x_force(SV* sv, STRLEN len)','name' => 'SvPVutf8x_force'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. See C. void PUSHi(IV iv)','name' => 'PUSHi'},'sv_reset' => {'text' => 'Underlying implementation for the C Perl function. Note that the perl-level function is vaguely deprecated. void sv_reset(char* s, HV* stash)','name' => 'sv_reset'},'hv_exists_ent' => {'text' => '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)','name' => 'hv_exists_ent'},'to_utf8_lower' => {'text' => 'Convert the UTF-8 encoded character at p to its lowercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the lowercase version may be longer than the original character (up to two characters). The first character of the lowercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_lower(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_lower'},'SvNIOK' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. bool SvNIOK(SV* sv)','name' => 'SvNIOK'},'sv_2pv_flags' => {'text' => 'Returns a pointer to the string value of an SV, and sets *lp to its length. If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string if necessary. Normally invoked via the C macro. C and C usually end up here too. char* sv_2pv_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_2pv_flags'},'SvTAINTED_off' => {'text' => '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)','name' => 'SvTAINTED_off'},'SvNVx' => {'text' => 'Coerces the given SV to a double and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. NV SvNVx(SV* sv)','name' => 'SvNVx'},'unpack_str' => {'text' => 'The engine implementing unpack() Perl function. I32 unpack_str(char *pat, char *patend, char *s, char *strbeg, char *strend, char **new_s, I32 ocnt, U32 flags)','name' => 'unpack_str'},'newSVpvf' => {'text' => 'Creates a new SV and initializes it with the string formatted like C. SV* newSVpvf(const char* pat, ...)','name' => 'newSVpvf'},'require_pv' => {'text' => 'Tells Perl to C the file named by the string argument. It is analogous to the Perl code C. It\'s even implemented that way; consider using Perl_load_module instead. NOTE: the perl_ form of this function is deprecated. void require_pv(const char* pv)','name' => 'require_pv'},'sv_upgrade' => {'text' => 'Upgrade an SV to a more complex form. Generally adds a new body type to the SV, then copies across as much information as possible from the old body. You generally want to use the C macro wrapper. See also C. bool sv_upgrade(SV* sv, U32 mt)','name' => 'sv_upgrade'},'strEQ' => {'text' => 'Test two strings to see if they are equal. Returns true or false. bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C wrapper instead. SV* sv_newref(SV* sv)','name' => 'sv_newref'},'hv_store' => {'text' => '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, I32 klen, SV* val, U32 hash)','name' => 'hv_store'},'SvIVX' => {'text' => 'Returns the raw value in the SV\'s IV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. IV SvIVX(SV* sv)','name' => 'SvIVX'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L. int perl_destruct(PerlInterpreter* interp)','name' => 'perl_destruct'},'sv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the scalar sv, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument is as in pv_uni_display(). The pointer to the PV of the dsv is returned. char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim, UV flags)','name' => 'sv_uni_display'},'isUPPER' => {'text' => 'Returns a boolean indicating whether the C C is an uppercase character. bool isUPPER(char ch)','name' => 'isUPPER'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. You probably want to use one of the assortment of wrappers, such as C, C, C and C. void sv_setsv(SV* dsv, SV* ssv)','name' => 'sv_setsv'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the stack. void XST_mYES(int pos)','name' => 'XST_mYES'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C for a version which guarantees to evaluate sv only once. NV SvNV(SV* sv)','name' => 'SvNV'},'SvUTF8' => {'text' => 'Returns a boolean indicating whether the SV contains UTF-8 encoded data. void SvUTF8(SV* sv)','name' => 'SvUTF8'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'sv_setsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setsv_mg(SV *dstr, SV *sstr)','name' => 'sv_setsv_mg'},'hv_fetch_ent' => {'text' => '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)','name' => 'hv_fetch_ent'},'isLOWER' => {'text' => 'Returns a boolean indicating whether the C C is a lowercase character. bool isLOWER(char ch)','name' => 'isLOWER'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See C. char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an XSUB\'s aliases was used to invoke it. See L. I32 ix','name' => 'ix'},'SvNOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a double. Checks the B setting. Use C. bool SvNOKp(SV* sv)','name' => 'SvNOKp'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'PUSHs' => {'text' => '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)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setuv(SV* sv, UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'utf8_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF8 encoding; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvchr(U8 *s, STRLEN* retlen)','name' => 'utf8_to_uvchr'},'nothreadhook' => {'text' => 'Stub that provides thread hook for perl_destruct when there are no threads. int nothreadhook()','name' => 'nothreadhook'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'bytes_to_utf8' => {'text' => 'Converts a string C of length C from ASCII into UTF8 encoding. Returns a pointer to the newly-created string, and sets C to reflect the new length. NOTE: this function is experimental and may change or be removed without notice. U8* bytes_to_utf8(U8 *s, STRLEN *len)','name' => 'bytes_to_utf8'},'sv_pvn' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn(SV *sv, STRLEN *len)','name' => 'sv_pvn'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'dXSI32' => {'text' => 'Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. dXSI32;','name' => 'dXSI32'},'sv_setref_iv' => {'text' => '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)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => '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. Uses the "OOK hack". void sv_chop(SV* sv, char* ptr)','name' => 'sv_chop'},'SvPVx' => {'text' => 'A version of C which guarantees to evaluate sv only once. char* SvPVx(SV* sv, STRLEN len)','name' => 'SvPVx'},'sv_backoff' => {'text' => 'Remove any string offset. You should normally use the C macro wrapper instead. int sv_backoff(SV* sv)','name' => 'sv_backoff'},'sv_tainted' => {'text' => 'Test an SV for taintedness. Use C instead. bool sv_tainted(SV* sv)','name' => 'sv_tainted'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. If necessary, uses C and upgrades the SV to C. Returns a pointer to the character buffer. Use the C wrapper instead. char* sv_grow(SV* sv, STRLEN newlen)','name' => 'sv_grow'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. See C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setuv_mg(SV *sv, UV u)','name' => 'sv_setuv_mg'},'cv_const_sv' => {'text' => 'If C is a constant sub eligible for inlining. returns the constant value returned by the sub. Otherwise, returns NULL. Constant subs can be created with C or as described in L. SV* cv_const_sv(CV* cv)','name' => 'cv_const_sv'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually handled automatically by C. See C.','name' => 'XS_VERSION'},'newSVnv' => {'text' => '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)','name' => 'newSVnv'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. See C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry. SV* HeVAL(HE* he)','name' => 'HeVAL'},'PL_na' => {'text' => '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','name' => 'PL_na'},'HePV' => {'text' => '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)','name' => 'HePV'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the SV is set to 1. SV* newSViv(IV i)','name' => 'newSViv'},'sv_untaint' => {'text' => 'Untaint an SV. Use C instead. void sv_untaint(SV* sv)','name' => 'sv_untaint'},'sv_setpv' => {'text' => '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)','name' => 'sv_setpv'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See C.','name' => 'SVt_PVHV'},'pv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the string spv, length len, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument can have UNI_DISPLAY_ISPRINT set to display isPRINT()able characters as themselves, UNI_DISPLAY_BACKSLASH to display the \\\\[nrfta\\\\] as the backslashed versions (like \'\\n\') (UNI_DISPLAY_BACKSLASH is preferred over UNI_DISPLAY_ISPRINT for \\\\). UNI_DISPLAY_QQ (and its alias UNI_DISPLAY_REGEX) have both UNI_DISPLAY_BACKSLASH and UNI_DISPLAY_ISPRINT turned on. The pointer to the PV of the dsv is returned. char* pv_uni_display(SV *dsv, U8 *spv, STRLEN len, STRLEN pvlim, UV flags)','name' => 'pv_uni_display'},'gv_fetchmethod' => {'text' => 'See L. GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'SvGETMAGIC' => {'text' => 'Invokes C on an SV if it has \'get\' magic. This macro evaluates its argument more than once. void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'SvGROW' => {'text' => '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)','name' => 'SvGROW'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_inc(SV* sv)','name' => 'sv_inc'},'sv_usepvn' => {'text' => '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)','name' => 'sv_usepvn'},'SvPVbytex_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex_force(SV* sv, STRLEN len)','name' => 'SvPVbytex_force'},'sv_catpv' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. If the SV has the UTF8 status set, then the bytes appended should be valid UTF8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpv(SV* sv, const char* ptr)','name' => 'sv_catpv'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'sv_len' => {'text' => 'Returns the length of the string in the SV. Handles magic and type coercion. See also C, which gives raw access to the xpv_cur slot. STRLEN sv_len(SV* sv)','name' => 'sv_len'},'warn' => {'text' => '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, ...)','name' => 'warn'},'sv_pvutf8' => {'text' => 'Use the C macro instead char* sv_pvutf8(SV *sv)','name' => 'sv_pvutf8'},'SvPVbyte_nolen' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_nolen(SV* sv)','name' => 'SvPVbyte_nolen'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L. LEAVE;','name' => 'LEAVE'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See C.','name' => 'SVt_PVAV'},'hv_delete' => {'text' => '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, I32 klen, I32 flags)','name' => 'hv_delete'},'hv_undef' => {'text' => 'Undefines the hash. void hv_undef(HV* tb)','name' => 'hv_undef'},'SvSetMagicSV_nosteal' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetMagicSV_nosteal'},'hv_delete_ent' => {'text' => '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)','name' => 'hv_delete_ent'},'CLASS' => {'text' => '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','name' => 'CLASS'},'sv_isobject' => {'text' => '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)','name' => 'sv_isobject'},'Newc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Newc(int id, void* ptr, int nitems, type, cast)','name' => 'Newc'},'sv_pvn_force_flags' => {'text' => 'Get a sensible string out of the SV somehow. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You normally want to use the various wrapper macros instead: see C and C char* sv_pvn_force_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_pvn_force_flags'},'HeKLEN' => {'text' => '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)','name' => 'HeKLEN'},'to_utf8_title' => {'text' => 'Convert the UTF-8 encoded character at p to its titlecase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the titlecase version may be longer than the original character (up to two characters). The first character of the titlecased version is returned (but note, as explained above, that there may be more.) UV to_utf8_title(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_title'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. See C. void PUSHn(NV nv)','name' => 'PUSHn'},'sv_setiv' => {'text' => 'Copies an integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setiv(SV* sv, IV num)','name' => 'sv_setiv'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it. See C for a version which guarantees to evaluate sv only once. IV SvIV(SV* sv)','name' => 'SvIV'},'sv_report_used' => {'text' => 'Dump the contents of all SVs not yet freed. (Debugging aid). void sv_report_used()','name' => 'sv_report_used'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. void EXTEND(SP, int nitems)','name' => 'EXTEND'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. SV PL_sv_yes','name' => 'PL_sv_yes'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(UV u)','name' => 'newSVuv'},'SvNVX' => {'text' => 'Returns the raw value in the SV\'s NV slot, without checks or conversions. Only use when you are sure SvNOK is true. See also C. NV SvNVX(SV* sv)','name' => 'SvNVX'},'sv_nosharing' => {'text' => '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 *)','name' => 'sv_nosharing'},'gv_fetchmeth' => {'text' => '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)','name' => 'gv_fetchmeth'},'SvUTF8_off' => {'text' => 'Unsets the UTF8 status of an SV. void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'looks_like_number' => {'text' => 'Test if the content of an SV looks like a number (or is a number). C and C are treated as numbers (so will not issue a non-numeric warning), even if your atof() doesn\'t grok them. I32 looks_like_number(SV* sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpv_mg(SV *sv, const char *ptr)','name' => 'sv_catpv_mg'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. U32 HeHASH(HE* he)','name' => 'HeHASH'},'sv_setref_uv' => {'text' => 'Copies an unsigned 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_uv(SV* rv, const char* classname, UV uv)','name' => 'sv_setref_uv'},'SvIOK' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. bool SvIOK(SV* sv)','name' => 'SvIOK'},'getcwd_sv' => {'text' => 'Fill the sv with current working directory int getcwd_sv(SV* sv)','name' => 'getcwd_sv'},'newSVpv' => {'text' => '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)','name' => 'newSVpv'},'sv_2pvbyte' => {'text' => 'Return a pointer to the byte-encoded representation of the SV, and set *lp to its length. May cause the SV to be downgraded from UTF8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte(SV* sv, STRLEN* lp)','name' => 'sv_2pvbyte'},'fbm_instr' => {'text' => '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)','name' => 'fbm_instr'},'sv_setpvf' => {'text' => '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, ...)','name' => 'sv_setpvf'},'SvPV_force' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. See C. void XPUSHn(NV nv)','name' => 'XPUSHn'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part attributable to C. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'call_sv' => {'text' => '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)','name' => 'call_sv'},'SVt_PV' => {'text' => 'Pointer type flag for scalars. See C.','name' => 'SVt_PV'},'strGT' => {'text' => '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)','name' => 'strGT'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a string and disables all other OK bits, and leaves the UTF8 status as it was. void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic after a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'},'sv_pos_u2b' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF8 chars from the start of the string, to a count of the equivalent number of bytes; if lenp is non-zero, it does the same to lenp, but this time starting from the offset, rather than from the start of the string. Handles magic and type coercion. void sv_pos_u2b(SV* sv, I32* offsetp, I32* lenp)','name' => 'sv_pos_u2b'},'SvTRUE' => {'text' => '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)','name' => 'SvTRUE'},'HeSVKEY_set' => {'text' => '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)','name' => 'HeSVKEY_set'},'POPl' => {'text' => 'Pops a long off the stack. long POPl','name' => 'POPl'},'hv_iternext_flags' => {'text' => 'Returns entries from a hash iterator. See C and C. The C 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 literally <&Perl_sv_undef> (a regular C value is a normal read-write SV for which C is false). 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)','name' => 'hv_iternext_flags'},'grok_hex' => {'text' => 'converts a string representing a hex number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first non-hex-digit character. On return I<*len> is set to the length scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0x" or "x" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the hex number may use \'_\' characters to separate digits. UV grok_hex(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_hex'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L. SPAGAIN;','name' => 'SPAGAIN'},'call_method' => {'text' => '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)','name' => 'call_method'},'SvLOCK' => {'text' => 'Arranges for a mutual exclusion lock to be obtained on sv if a suitable module has been loaded. void SvLOCK(SV* sv)','name' => 'SvLOCK'},'sv_vsetpvfn' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Usually used via one of its frontends C and C. void sv_vsetpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vsetpvfn'},'get_cv' => {'text' => '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)','name' => 'get_cv'},'SvIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. Checks the B setting. Use C. bool SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the stack. void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'perl_parse' => {'text' => '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)','name' => 'perl_parse'},'to_utf8_case' => {'text' => 'The "p" contains the pointer to the UTF-8 string encoding the character that is being converted. The "ustrp" is a pointer to the character buffer to put the conversion result to. The "lenp" is a pointer to the length of the result. The "swashp" is a pointer to the swash to use. Both the special and normal mappings are stored lib/unicore/To/Foo.pl, and loaded by SWASHGET, using lib/utf8_heavy.pl. The special (usually, but not always, a multicharacter mapping), is tried first. The "special" is a string like "utf8::ToSpecLower", which means the hash %utf8::ToSpecLower. The access to the hash is through Perl_to_utf8_case(). The "normal" is a string like "ToLower" which means the swash %utf8::ToLower. UV to_utf8_case(U8 *p, U8* ustrp, STRLEN *lenp, SV **swash, char *normal, char *special)','name' => 'to_utf8_case'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory used by the array itself. void av_clear(AV* ar)','name' => 'av_clear'},'sv_force_normal' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. See also C. void sv_force_normal(SV *sv)','name' => 'sv_force_normal'},'av_unshift' => {'text' => '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)','name' => 'av_unshift'},'SvUNLOCK' => {'text' => 'Releases a mutual exclusion lock on sv if a suitable module has been loaded. void SvUNLOCK(SV* sv)','name' => 'SvUNLOCK'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C. int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV (using C). The new SV is marked as mortal. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_mortalcopy(SV* oldsv)','name' => 'sv_mortalcopy'},'POPpbytex' => {'text' => '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','name' => 'POPpbytex'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. UV SvUVX(SV* sv)','name' => 'SvUVX'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See L.','name' => 'G_NOARGS'},'SvSetMagicSV' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV(SV* dsb, SV* ssv)','name' => 'SvSetMagicSV'},'sv_utf8_decode' => {'text' => 'Convert the octets in the PV from UTF-8 to chars. Scan for validity and then turn off SvUTF8 if needed so that we see characters. Used as a building block for decode_utf8 in Encode.xs NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_decode(SV *sv)','name' => 'sv_utf8_decode'},'Newz' => {'text' => '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)','name' => 'Newz'},'savepvn' => {'text' => 'Perl\'s version of what C would be if it existed. Returns a pointer to a newly allocated string which is a duplicate of the first C bytes from C. The memory allocated for the new string can be freed with the C function. char* savepvn(const char* pv, I32 len)','name' => 'savepvn'},'eval_sv' => {'text' => '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)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized. This relies on the fact that uninitialized array elements are set to C<&PL_sv_undef>. bool av_exists(AV* ar, I32 key)','name' => 'av_exists'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C. STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'Move' => {'text' => '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)','name' => 'Move'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'sv_catpvn_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF8 status set, then the bytes appended should be valid UTF8. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. void sv_catpvn_flags(SV* sv, const char* ptr, STRLEN len, I32 flags)','name' => 'sv_catpvn_flags'},'GIMME' => {'text' => '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','name' => 'GIMME'},'sv_bless' => {'text' => '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)','name' => 'sv_bless'},'NEWSV' => {'text' => '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)','name' => 'NEWSV'},'sv_isa' => {'text' => '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)','name' => 'sv_isa'},'isALNUM' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphanumeric character (including underscore) or digit. bool isALNUM(char ch)','name' => 'isALNUM'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs.','name' => 'newXS'},'sv_catpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. If the appended data contains "wide" characters (including, but not limited to, SVs with a UTF-8 PV formatted with %s, and characters >255 formatted with %c), the original SV might get upgraded to UTF-8. 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, ...)','name' => 'sv_catpvf'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. void SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C. void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'utf8_to_uvuni' => {'text' => 'Returns the Unicode code point of the first character in the string C which is assumed to be in UTF8 encoding; C will be set to the length, in bytes, of that character. This function should only be used when returned UV is considered an index into the Unicode semantic tables (e.g. swashes). If C does not point to a well-formed UTF8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvuni(U8 *s, STRLEN* retlen)','name' => 'utf8_to_uvuni'},'sv_2io' => {'text' => 'Using various gambits, try to get an IO from an SV: the IO slot if its a GV; or the recursive result if we\'re an RV; or the IO slot of the symbol named after the PV if we\'re a string. IO* sv_2io(SV* sv)','name' => 'sv_2io'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphabetic character. bool isALPHA(char ch)','name' => 'isALPHA'},'Nullhv' => {'text' => 'Null HV pointer.','name' => 'Nullhv'},'av_fill' => {'text' => 'Ensure than an array has a given number of elements, equivalent to Perl\'s C<$#array = $fill;>. void av_fill(AV* ar, I32 fill)','name' => 'av_fill'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV. SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C. svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter* interp)','name' => 'perl_construct'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. void SvUOK(SV* sv)','name' => 'SvUOK'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_dec(SV* sv)','name' => 'sv_dec'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'strLE' => {'text' => '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)','name' => 'strLE'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'grok_bin' => {'text' => 'converts a string representing a binary number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. On return I<*len> is set to the length scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0b" or "b" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the binary number may use \'_\' characters to separate digits. UV grok_bin(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_bin'},'sv_2pvbyte_nolen' => {'text' => 'Return a pointer to the byte-encoded representation of the SV. May cause the SV to be downgraded from UTF8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L. void perl_free(PerlInterpreter* interp)','name' => 'perl_free'},'SvOK' => {'text' => 'Returns a boolean indicating whether the value is an SV. bool SvOK(SV* sv)','name' => 'SvOK'},'sv_setref_nv' => {'text' => '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)','name' => 'sv_setref_nv'},'uvchr_to_utf8' => {'text' => 'Adds the UTF8 representation of the Native codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvchr_to_utf8(d, uv); is the recommended wide native character-aware way of saying *(d++) = uv; U8* uvchr_to_utf8(U8 *d, UV uv)','name' => 'uvchr_to_utf8'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C. MAGIC* mg_find(SV* sv, int type)','name' => 'mg_find'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII digit. bool isDIGIT(char ch)','name' => 'isDIGIT'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'eval_pv' => {'text' => '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)','name' => 'eval_pv'},'newSVpvn_share' => {'text' => 'Creates a new SV with its SvPVX pointing to a shared string in the string table. If the string does not already exist in the table, it is created first. Turns on READONLY and FAKE. The string\'s hash is stored in the UV slot of the SV; if the C parameter is non-zero, that value is used; otherwise the hash is computed. The idea here is that as the string table is used for shared hash keys these strings will have SvPVX == HeKEY and hash lookup will avoid string compare. SV* newSVpvn_share(const char* s, I32 len, U32 hash)','name' => 'newSVpvn_share'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_setpvf_mg'},'SvPOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. Checks the B setting. Use C. bool SvPOKp(SV* sv)','name' => 'SvPOKp'},'sv_free' => {'text' => 'Decrement an SV\'s reference count, and if it drops to zero, call C to invoke destructors and free up any memory used by the body; finally, deallocate the SV\'s head itself. Normally called via a wrapper macro C. void sv_free(SV* sv)','name' => 'sv_free'},'sv_catpvn' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF8 status set, then the bytes appended should be valid UTF8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn'},'SvPVbyte_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_force(SV* sv, STRLEN len)','name' => 'SvPVbyte_force'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. CV* newCONSTSUB(HV* stash, char* name, SV* sv)','name' => 'newCONSTSUB'},'sv_setref_pv' => {'text' => '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)','name' => 'sv_setref_pv'},'SvSHARE' => {'text' => 'Arranges for sv to be shared between threads if a suitable module has been loaded. void SvSHARE(SV* sv)','name' => 'SvSHARE'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_pop(AV* ar)','name' => 'av_pop'},'fbm_compile' => {'text' => '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)','name' => 'fbm_compile'},'sv_utf8_downgrade' => {'text' => 'Attempt to convert the PV of an SV from UTF8-encoded to byte encoding. This may not be possible if the PV contains non-byte encoding characters; if this is the case, either returns false or, if C is not true, croaks. This is not as a general purpose Unicode to byte encoding interface: use the Encode extension for that. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_downgrade(SV *sv, bool fail_ok)','name' => 'sv_utf8_downgrade'},'SvNIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. Checks the B setting. Use C. bool SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'croak' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Normally use this function the same way you use the C C function. See C. If you want to throw an exception object, assign the object to C<$@> and then pass C to croak(): errsv = get_sv("@", TRUE); sv_setsv(errsv, exception_object); croak(Nullch); void croak(const char* pat, ...)','name' => 'croak'},'sortsv' => {'text' => '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)','name' => 'sortsv'},'THIS' => {'text' => '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','name' => 'THIS'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either forward or backward. WARNING: do not use the following unless you *know* C is within the UTF-8 data pointed to by C *and* that on entry C is aligned on the first byte of character or just after the last byte of a character. U8* utf8_hop(U8 *s, I32 off)','name' => 'utf8_hop'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide UTF8 bytes as a single character. Handles magic and type coercion. STRLEN sv_len_utf8(SV* sv)','name' => 'sv_len_utf8'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually handled by C. void XSRETURN(int nitems)','name' => 'XSRETURN'},'sv_setref_pvn' => {'text' => '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)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for blessed scalars. See C.','name' => 'SVt_PVMG'},'PUSHp' => {'text' => '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)','name' => 'PUSHp'},'scan_bin' => {'text' => 'For backwards compatibility. Use C instead. NV scan_bin(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_bin'},'Nullcv' => {'text' => 'Null CV pointer.','name' => 'Nullcv'},'dAX' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dAX;','name' => 'dAX'},'sv_2pv_nolen' => {'text' => 'Like C, but doesn\'t return the length too. You should usually use the macro wrapper C instead. char* sv_2pv_nolen(SV* sv)','name' => 'sv_2pv_nolen'},'get_av' => {'text' => '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)','name' => 'get_av'},'PL_sv_undef' => {'text' => 'This is the C SV. Always refer to this as C<&PL_sv_undef>. SV PL_sv_undef','name' => 'PL_sv_undef'},'SvPVbyte' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'hv_iterkeysv' => {'text' => '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)','name' => 'hv_iterkeysv'},'grok_number' => {'text' => '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)','name' => 'grok_number'},'SvIVx' => {'text' => 'Coerces the given SV to an integer and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. IV SvIVx(SV* sv)','name' => 'SvIVx'},'grok_numeric_radix' => {'text' => 'Scan and skip for a numeric decimal separator (radix). bool grok_numeric_radix(const char **sp, const char *send)','name' => 'grok_numeric_radix'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the stack. void XST_mNO(int pos)','name' => 'XST_mNO'},'toUPPER' => {'text' => 'Converts the specified character to uppercase. char toUPPER(char ch)','name' => 'toUPPER'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array. Returns the deleted element. C is currently ignored. SV* av_delete(AV* ar, I32 key, I32 flags)','name' => 'av_delete'},'utf8_distance' => {'text' => 'Returns the number of UTF8 characters between the UTF-8 pointers C and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. IV utf8_distance(U8 *a, U8 *b)','name' => 'utf8_distance'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally appending to the currently-stored string. char* sv_gets(SV* sv, PerlIO* fp, I32 append)','name' => 'sv_gets'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'SvPVutf8x' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'sv_collxfrm' => {'text' => 'Add Collate Transform magic to an SV if it doesn\'t already have it. Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the scalar data of the variable, but transformed to such a format that a normal memory comparison can be used to compare the data according to the locale settings. char* sv_collxfrm(SV* sv, STRLEN* nxp)','name' => 'sv_collxfrm'},'sv_2cv' => {'text' => 'Using various gambits, try to get a CV from an SV; in addition, try if possible to set C<*st> and C<*gvp> to the stash and GV associated with it. CV* sv_2cv(SV* sv, HV** st, GV** gvp, I32 lref)','name' => 'sv_2cv'},'SvPV_force_nomg' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. Doesn\'t process magic. char* SvPV_force_nomg(SV* sv, STRLEN len)','name' => 'SvPV_force_nomg'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. Will also turn off the UTF8 status. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'POPpx' => {'text' => 'Pops a string off the stack. Requires a variable STRLEN n_a in scope. char* POPpx','name' => 'POPpx'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'sv_uv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. UV sv_uv(SV* sv)','name' => 'sv_uv'},'sv_pvbyte' => {'text' => 'Use C instead. char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'hv_fetch' => {'text' => '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 an C. See L for more information on how to use this function on tied hashes. SV** hv_fetch(HV* tb, const char* key, I32 klen, I32 lval)','name' => 'hv_fetch'},'Zero' => {'text' => '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)','name' => 'Zero'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_unref_flags' => {'text' => '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. The C argument can contain C to force the reference count to be decremented (otherwise the decrementing is conditional on the reference count being different from one or the reference being a readonly SV). See C. void sv_unref_flags(SV* sv, U32 flags)','name' => 'sv_unref_flags'},'sv_iv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. IV sv_iv(SV* sv)','name' => 'sv_iv'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'Nullch' => {'text' => 'Null character pointer. =for hackers Found in file handy.h','name' => 'Nullch'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)','name' => 'mg_copy'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C flag on this RV; give the referred-to SV C magic if it hasn\'t already; and push a back-reference to this RV onto the array of backreferences associated with that magic. SV* sv_rvweaken(SV *sv)','name' => 'sv_rvweaken'},'grok_oct' => {'text' => 'UV grok_oct(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_oct'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'scan_hex' => {'text' => 'For backwards compatibility. Use C instead. NV scan_hex(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_hex'},'newSVpvn' => {'text' => '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)','name' => 'newSVpvn'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the supplied vtable and returns pointer to the magic added. Note that sv_magicext will allow things that sv_magic will not. In particular you can add magic to SvREADONLY SVs and and more than one instance of the same \'how\' I C is greater then zero then a savepvn() I of C is stored, if C is zero then C is stored as-is and - as another special case - if C<(name && namelen == HEf_SVKEY)> then C is assumed to contain an C and has its REFCNT incremented (This is now used as a subroutine by sv_magic.) MAGIC * sv_magicext(SV* sv, SV* obj, int how, MGVTBL *vtbl, const char* name, I32 namlen )','name' => 'sv_magicext'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C.','name' => 'SVt_PVCV'},'av_push' => {'text' => '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)','name' => 'av_push'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV* ar, I32 key)','name' => 'av_extend'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV *sv)','name' => 'newRV_noinc'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'sv_2bool' => {'text' => 'This function is only called on magical items, and is only used by sv_true() or its macro equivalent. bool sv_2bool(SV* sv)','name' => 'sv_2bool'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. You may call C or C 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 C, so you must not discard your iterator immediately else the entry will leak - call C to trigger the resource deallocation. HE* hv_iternext(HV* tb)','name' => 'hv_iternext'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'sv_newmortal' => {'text' => 'Creates a new null SV which is mortal. The reference count of the SV is set to 1. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_newmortal()','name' => 'sv_newmortal'},'sv_clear' => {'text' => 'Clear an SV: call any destructors, free up any memory used by the body, and free the body itself. The SV\'s head is I freed, although its type is set to all 1\'s so that it won\'t inadvertently be assumed to be live during global destruction etc. This function should only be called when REFCNT is zero. Most of the time you\'ll want to call C (or its macro wrapper C) instead. void sv_clear(SV* sv)','name' => 'sv_clear'},'hv_iterinit' => {'text' => '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)','name' => 'hv_iterinit'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.008000', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_008_002.pm0000644000175000017500000034563511653441731020777 0ustar tseetseepackage Perl::APIReference::V5_008_002; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'SvOOK' => {'text' => '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)','name' => 'SvOOK'},'hv_store_ent' => {'text' => '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. Effectively a successful hv_store_ent takes ownership of one reference to C. 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 C; unlike C it does not take ownership of it, so maintaining the correct reference count on C 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 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)','name' => 'hv_store_ent'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package, which must be a valid UTF-8 string. See C. HV* gv_stashsv(SV* sv, I32 create)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'strGE' => {'text' => '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)','name' => 'strGE'},'form' => {'text' => '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, ...)','name' => 'form'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified version becoming C. Handles \'get\' magic. See also C for a version which guarantees to evaluate sv only once. char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'is_utf8_string' => {'text' => 'Returns true if first C bytes of the given string form a valid UTF-8 string, false otherwise. Note that \'a valid UTF-8 string\' does not mean \'a string that contains code points above 0x7F encoded in UTF-8\' because a valid ASCII string is a valid UTF-8 string. bool is_utf8_string(U8 *s, STRLEN len)','name' => 'is_utf8_string'},'svtype' => {'text' => '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.','name' => 'svtype'},'hv_clear' => {'text' => 'Clears a hash, making it empty. void hv_clear(HV* tb)','name' => 'hv_clear'},'get_hv' => {'text' => '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)','name' => 'get_hv'},'load_module' => {'text' => '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 C. The optional trailing SV* arguments can be used to specify arguments to the module\'s import() method, similar to C. void load_module(U32 flags, SV* name, SV* ver, ...)','name' => 'load_module'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES;','name' => 'XSRETURN_YES'},'sv_nv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. NV sv_nv(SV* sv)','name' => 'sv_nv'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'Poison' => {'text' => '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)','name' => 'Poison'},'sv_insert' => {'text' => '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)','name' => 'sv_insert'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_catpvf_mg'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'SvPOK' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. bool SvPOK(SV* sv)','name' => 'SvPOK'},'get_sv' => {'text' => '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)','name' => 'get_sv'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. See C. void PUSHu(UV uv)','name' => 'PUSHu'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. (Uses C). SV* newSVsv(SV* old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C. void hv_magic(HV* hv, GV* gv, int how)','name' => 'hv_magic'},'SvPVutf8' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *sv, const char *ptr)','name' => 'sv_setpv_mg'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C.','name' => 'XS'},'scan_oct' => {'text' => 'For backwards compatibility. Use C instead. NV scan_oct(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_oct'},'sv_setpvn' => {'text' => '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)','name' => 'sv_setpvn'},'sv_2mortal' => {'text' => 'Marks an existing SV as mortal. The SV will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_2mortal(SV* sv)','name' => 'sv_2mortal'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'newSVrv' => {'text' => '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)','name' => 'newSVrv'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself. void av_undef(AV* ar)','name' => 'av_undef'},'HeKEY' => {'text' => '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)','name' => 'HeKEY'},'pack_cat' => {'text' => '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)','name' => 'pack_cat'},'utf8n_to_uvuni' => {'text' => 'Bottom level UTF-8 decode routine. Returns the unicode code point value of the first character in the string C which is assumed to be in UTF-8 encoding and no longer than C; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, the behaviour is dependent on the value of C: if it contains UTF8_CHECK_ONLY, it is assumed that the caller will raise a warning, and this function will silently just set C to C<-1> and return zero. If the C does not contain UTF8_CHECK_ONLY, warnings about malformations will be given, C will be set to the expected length of the UTF-8 character in bytes, and zero will be returned. The C can also contain various flags to allow deviations from the strict UTF-8 encoding (see F). Most code should use utf8_to_uvchr() rather than call this directly. UV utf8n_to_uvuni(U8 *s, STRLEN curlen, STRLEN* retlen, U32 flags)','name' => 'utf8n_to_uvuni'},'sv_cmp' => {'text' => '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. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp(SV* sv1, SV* sv2)','name' => 'sv_cmp'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'SvEND' => {'text' => '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)','name' => 'SvEND'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C to type C if necessary, then adds a new magic item of type C to the head of the magic list. void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen)','name' => 'sv_magic'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C, C or C for void, scalar or list context, respectively. U32 GIMME_V','name' => 'GIMME_V'},'sv_force_normal_flags' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. The C parameter gets passed to C when unrefing. C calls this function with flags set to 0. void sv_force_normal_flags(SV *sv, U32 flags)','name' => 'sv_force_normal_flags'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'sv_setsv_flags' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. If the C parameter has the C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You probably want to use one of the assortment of wrappers, such as C, C, C and C. This is the primary function for copying scalars, and most other copy-ish functions and macros use this underneath. void sv_setsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_setsv_flags'},'sv_utf8_upgrade_flags' => {'text' => 'Convert the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade_flags(SV *sv, I32 flags)','name' => 'sv_utf8_upgrade_flags'},'New' => {'text' => 'The XSUB-writer\'s interface to the C C function. void New(int id, void* ptr, int nitems, type)','name' => 'New'},'is_utf8_char' => {'text' => 'Tests if some arbitrary number of bytes begins in a valid UTF-8 character. Note that an INVARIANT (i.e. ASCII) character is a valid UTF-8 character. The actual number of bytes in the UTF-8 character will be returned if it is valid, otherwise 0. STRLEN is_utf8_char(U8 *p)','name' => 'is_utf8_char'},'Copy' => {'text' => '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)','name' => 'Copy'},'ibcmp_utf8' => {'text' => 'Return true if the strings s1 and s2 differ case-insensitively, false if not (if they are equal case-insensitively). If u1 is true, the string s1 is assumed to be in UTF-8-encoded Unicode. If u2 is true, the string s2 is assumed to be in UTF-8-encoded Unicode. If u1 or u2 are false, the respective string is assumed to be in native 8-bit encoding. If the pe1 and pe2 are non-NULL, the scanning pointers will be copied in there (they will point at the beginning of the I character). If the pointers behind pe1 or pe2 are non-NULL, they are the end pointers beyond which scanning will not continue under any circustances. If the byte lengths l1 and l2 are non-zero, s1+l1 and s2+l2 will be used as goal end pointers that will also stop the scan, and which qualify towards defining a successful match: all the scans that define an explicit length must reach their goal pointers for a match to succeed). For case-insensitiveness, the "casefolding" of Unicode is used instead of upper/lowercasing both the characters, see http://www.unicode.org/unicode/reports/tr21/ (Case Mappings). I32 ibcmp_utf8(const char* a, char **pe1, UV l1, bool u1, const char* b, char **pe2, UV l2, bool u2)','name' => 'ibcmp_utf8'},'CvSTASH' => {'text' => 'Returns the stash of the CV. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'sv_taint' => {'text' => 'Taint an SV. Use C instead. void sv_taint(SV* sv)','name' => 'sv_taint'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. The target SV physically takes over ownership of the body of the source SV and inherits its flags; however, the target keeps any magic it owns, and any magic in the source is discarded. Note that this is a rather specialist SV copying operation; most of the time you\'ll want to use C or one of its many macro front-ends. void sv_replace(SV* sv, SV* nsv)','name' => 'sv_replace'},'utf8n_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. Allows length and flags to be passed to low level routine. UV utf8n_to_uvchr(U8 *s, STRLEN curlen, STRLEN* retlen, U32 flags)','name' => 'utf8n_to_uvchr'},'sv_utf8_upgrade' => {'text' => 'Convert the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains a signed integer. void SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and L.','name' => 'G_ARRAY'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. Sets up the C and C variables by calling C and C. This is usually handled automatically by C. dXSARGS;','name' => 'dXSARGS'},'sv_2iv' => {'text' => 'Return the integer value of an SV, doing any necessary string conversion, magic etc. Normally used via the C and C macros. IV sv_2iv(SV* sv)','name' => 'sv_2iv'},'savesharedpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* ptr)','name' => 'Safefree'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the C C is whitespace. bool isSPACE(char ch)','name' => 'isSPACE'},'SvROK' => {'text' => 'Tests if the SV is an RV. bool SvROK(SV* sv)','name' => 'SvROK'},'sv_unref' => {'text' => '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. This is C with the C being zero. See C. void sv_unref(SV* sv)','name' => 'sv_unref'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dstr, SV *sstr)','name' => 'sv_catsv_mg'},'call_argv' => {'text' => '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)','name' => 'call_argv'},'SvPV_nolen' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified form becoming C. Handles \'get\' magic. char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'perl_clone' => {'text' => '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 C, 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)','name' => 'perl_clone'},'sv_setnv' => {'text' => 'Copies a double into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setnv(SV* sv, NV num)','name' => 'sv_setnv'},'sv_2nv' => {'text' => 'Return the num value of an SV, doing any necessary string or integer conversion, magic etc. Normally used via the C and C macros. NV sv_2nv(SV* sv)','name' => 'sv_2nv'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'XPUSHp' => {'text' => '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)','name' => 'XPUSHp'},'sv_utf8_encode' => {'text' => 'Convert the PV of an SV to UTF-8-encoded, but then turn off the C flag so that it looks like octets again. Used as a building block for encode_utf8 in Encode.xs void sv_utf8_encode(SV *sv)','name' => 'sv_utf8_encode'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1. HV* newHV()','name' => 'newHV'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or false. bool strNE(char* s1, char* s2)','name' => 'strNE'},'SvUTF8_on' => {'text' => 'Turn on the UTF-8 status of an SV (the data is not changed, just the flag). Do not use frivolously. void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_setpvn_mg'},'sv_pvutf8n_force' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n_force(SV* sv, STRLEN* lp)','name' => 'sv_pvutf8n_force'},'savepv' => {'text' => 'Perl\'s version of C. Returns a pointer to a newly allocated string which is a duplicate of C. The size of the string is determined by C. The memory allocated for the new string can be freed with the C function. char* savepv(const char* pv)','name' => 'savepv'},'toLOWER' => {'text' => 'Converts the specified character to lowercase. char toLOWER(char ch)','name' => 'toLOWER'},'bytes_from_utf8' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike but like C, returns a pointer to the newly-created string, and updates C to contain the new length. Returns the original string if no conversion occurs, C is unchanged. Do nothing if C points to 0. Sets C to 0 if C is converted or contains all 7bit characters. NOTE: this function is experimental and may change or be removed without notice. U8* bytes_from_utf8(U8 *s, STRLEN *len, bool *is_utf8)','name' => 'bytes_from_utf8'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1. AV* newAV()','name' => 'newAV'},'POPp' => {'text' => 'Pops a string off the stack. Deprecated. New code should provide a STRLEN n_a and use POPpx. char* POPp','name' => 'POPp'},'HvNAME' => {'text' => 'Returns the package name of a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV of the sv is assumed to be octets in that encoding, and the sv will be converted into Unicode (and UTF-8). If the sv already is UTF-8 (or if it is not POK), or if the encoding is not a reference, nothing is done to the sv. If the encoding is not an C Encoding object, bad things will happen. (See F and L). The PV of the sv is returned. char* sv_recode_to_utf8(SV* sv, SV *encoding)','name' => 'sv_recode_to_utf8'},'av_make' => {'text' => '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)','name' => 'av_make'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. See C for a version which guarantees to evaluate sv only once. UV SvUV(SV* sv)','name' => 'SvUV'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L. int perl_run(PerlInterpreter* interp)','name' => 'perl_run'},'sv_pvbyten' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten(SV *sv, STRLEN *len)','name' => 'sv_pvbyten'},'sv_catsv_flags' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. If C has C bit set, will C on the SVs if appropriate, else not. C and C are implemented in terms of this function. void sv_catsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_catsv_flags'},'Nullav' => {'text' => 'Null AV pointer.','name' => 'Nullav'},'sv_copypv' => {'text' => 'Copies a stringified representation of the source SV into the destination SV. Automatically performs any necessary mg_get and coercion of numeric values into strings. Guaranteed to preserve UTF-8 flag even from overloaded objects. Similar in nature to sv_2pv[_flags] but operates directly on an SV instead of just the string. Mostly uses sv_2pv_flags to do its work, except when that would lose the UTF-8\'ness of the PV. void sv_copypv(SV* dsv, SV* ssv)','name' => 'sv_copypv'},'sv_pv' => {'text' => 'Use the C macro instead char* sv_pv(SV *sv)','name' => 'sv_pv'},'SvPVutf8_nolen' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_nolen(SV* sv)','name' => 'SvPVutf8_nolen'},'sv_setpviv' => {'text' => '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)','name' => 'sv_setpviv'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setnv_mg(SV *sv, NV num)','name' => 'sv_setnv_mg'},'sv_true' => {'text' => 'Returns true if the SV has a true value by Perl\'s rules. Use the C macro instead, which may call C or may instead use an in-line version. I32 sv_true(SV *sv)','name' => 'sv_true'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV* hv, char** key, I32* retlen)','name' => 'hv_iternextsv'},'utf8_to_bytes' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike C, this over-writes the original string, and updates len to contain the new length. Returns zero on failure, setting C to -1. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_pvbyten_force' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten_force(SV* sv, STRLEN* lp)','name' => 'sv_pvbyten_force'},'sv_derived_from' => {'text' => '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)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. See also C. I32 sv_cmp_locale(SV* sv1, SV* sv2)','name' => 'sv_cmp_locale'},'uvuni_to_utf8_flags' => {'text' => 'Adds the UTF-8 representation of the Unicode codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvuni_to_utf8_flags(d, uv, flags); or, in most cases, d = uvuni_to_utf8(d, uv); (which is equivalent to) d = uvuni_to_utf8_flags(d, uv, 0); is the recommended Unicode-aware way of saying *(d++) = uv; U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)','name' => 'uvuni_to_utf8_flags'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'hv_exists' => {'text' => '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, I32 klen)','name' => 'hv_exists'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See L.','name' => 'G_DISCARD'},'Nullsv' => {'text' => 'Null SV pointer.','name' => 'Nullsv'},'mg_length' => {'text' => 'Report on the SV\'s length. See C. U32 mg_length(SV* sv)','name' => 'mg_length'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'SvPVX' => {'text' => 'Returns a pointer to the physical string in the SV. The SV must contain a string. char* SvPVX(SV* sv)','name' => 'SvPVX'},'XST_mNV' => {'text' => '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)','name' => 'XST_mNV'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. See C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'HEf_SVKEY' => {'text' => 'This flag, used in the length slot of hash entries and magic structures, specifies the structure contains an C pointer where a C pointer is to be expected. (For information only--not to be used).','name' => 'HEf_SVKEY'},'pad_sv' => {'text' => '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)','name' => 'pad_sv'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C in characters. Stops at C (inclusive). If C s> or if the scan would end up past C, croaks. STRLEN utf8_length(U8* s, U8 *e)','name' => 'utf8_length'},'SvPVutf8_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_force(SV* sv, STRLEN len)','name' => 'SvPVutf8_force'},'sv_2pvutf8_nolen' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8_nolen(SV* sv)','name' => 'sv_2pvutf8_nolen'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted if tainting is enabled. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'SvIOK_only_UV' => {'text' => 'Tells and SV that it is an unsigned integer and disables all other OK bits. void SvIOK_only_UV(SV* sv)','name' => 'SvIOK_only_UV'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C.','name' => 'SVt_NV'},'sv_nolocking' => {'text' => '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 *)','name' => 'sv_nolocking'},'sv_vcatpvfn' => {'text' => '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). Usually used via one of its frontends C and C. void sv_vcatpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vcatpvfn'},'SvPVbytex' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex(SV* sv, STRLEN len)','name' => 'SvPVbytex'},'av_store' => {'text' => '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)','name' => 'av_store'},'sv_2uv' => {'text' => 'Return the unsigned integer value of an SV, doing any necessary string conversion, magic etc. Normally used via the C and C macros. UV sv_2uv(SV* sv)','name' => 'sv_2uv'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and L. PUSHMARK;','name' => 'PUSHMARK'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. SV* ST(int ix)','name' => 'ST'},'strLT' => {'text' => '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)','name' => 'strLT'},'sv_pvutf8n' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n(SV *sv, STRLEN *len)','name' => 'sv_pvutf8n'},'call_pv' => {'text' => '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)','name' => 'call_pv'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. SV* av_shift(AV* ar)','name' => 'av_shift'},'newSV' => {'text' => 'Create a new null SV, or if len > 0, create a new empty SVt_PV type SV with an initial PV allocation of len+1. Normally accessed via the C macro. SV* newSV(STRLEN len)','name' => 'newSV'},'av_fetch' => {'text' => '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)','name' => 'av_fetch'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'gv_fetchmeth_autoload' => {'text' => '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 C. 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)','name' => 'gv_fetchmeth_autoload'},'sv_2pvutf8' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV, and set *lp to its length. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8(SV* sv, STRLEN* lp)','name' => 'sv_2pvutf8'},'sv_nounlocking' => {'text' => '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 *)','name' => 'sv_nounlocking'},'dITEMS' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dITEMS;','name' => 'dITEMS'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV* tb, HE* entry)','name' => 'hv_iterval'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. char* sv_reftype(SV* sv, int ob)','name' => 'sv_reftype'},'sv_pos_b2u' => {'text' => 'Converts the value pointed to by offsetp from a count of bytes from the start of the string, to a count of the equivalent number of UTF-8 chars. Handles magic and type coercion. void sv_pos_b2u(SV* sv, I32* offsetp)','name' => 'sv_pos_b2u'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C.','name' => 'SVt_IV'},'av_len' => {'text' => 'Returns the highest index in the array. Returns -1 if the array is empty. I32 av_len(AV* ar)','name' => 'av_len'},'SvIsCOW' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write. (either shared hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for COW) bool SvIsCOW(SV* sv)','name' => 'SvIsCOW'},'sv_unmagic' => {'text' => 'Removes all magic of type C from an SV. int sv_unmagic(SV* sv, int type)','name' => 'sv_unmagic'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *sv, IV i)','name' => 'sv_setiv_mg'},'sv_catsv' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catsv(SV* dsv, SV* ssv)','name' => 'sv_catsv'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled. void SvTAINT(SV* sv)','name' => 'SvTAINT'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C. See C and L for other uses. PUTBACK;','name' => 'PUTBACK'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'ax' => {'text' => 'Variable which is setup by C to indicate the stack base offset, used by the C, C and C macros. The C macro must be called prior to setup the C variable. I32 ax','name' => 'ax'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'SvCUR_set' => {'text' => 'Set the length of the string which is in the SV. See C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'to_utf8_fold' => {'text' => 'Convert the UTF-8 encoded character at p to its foldcase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_FOLD+1 bytes since the foldcase version may be longer than the original character (up to three characters). The first character of the foldcased version is returned (but note, as explained above, that there may be more.) UV to_utf8_fold(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_fold'},'to_utf8_upper' => {'text' => 'Convert the UTF-8 encoded character at p to its uppercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the uppercase version may be longer than the original character (up to two characters). The first character of the uppercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_upper(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_upper'},'SvNOK' => {'text' => 'Returns a boolean indicating whether the SV contains a double. bool SvNOK(SV* sv)','name' => 'SvNOK'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. C should be a valid UTF-8 string. 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)','name' => 'gv_stashpv'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C, C, and L.','name' => 'G_SCALAR'},'SvPVutf8x_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x_force(SV* sv, STRLEN len)','name' => 'SvPVutf8x_force'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. See C. void PUSHi(IV iv)','name' => 'PUSHi'},'sv_reset' => {'text' => 'Underlying implementation for the C Perl function. Note that the perl-level function is vaguely deprecated. void sv_reset(char* s, HV* stash)','name' => 'sv_reset'},'hv_exists_ent' => {'text' => '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)','name' => 'hv_exists_ent'},'to_utf8_lower' => {'text' => 'Convert the UTF-8 encoded character at p to its lowercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the lowercase version may be longer than the original character (up to two characters). The first character of the lowercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_lower(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_lower'},'SvNIOK' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. bool SvNIOK(SV* sv)','name' => 'SvNIOK'},'sv_2pv_flags' => {'text' => 'Returns a pointer to the string value of an SV, and sets *lp to its length. If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string if necessary. Normally invoked via the C macro. C and C usually end up here too. char* sv_2pv_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_2pv_flags'},'SvTAINTED_off' => {'text' => '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)','name' => 'SvTAINTED_off'},'SvNVx' => {'text' => 'Coerces the given SV to a double and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. NV SvNVx(SV* sv)','name' => 'SvNVx'},'unpack_str' => {'text' => '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)','name' => 'unpack_str'},'newSVpvf' => {'text' => 'Creates a new SV and initializes it with the string formatted like C. SV* newSVpvf(const char* pat, ...)','name' => 'newSVpvf'},'require_pv' => {'text' => 'Tells Perl to C the file named by the string argument. It is analogous to the Perl code C. 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)','name' => 'require_pv'},'sv_upgrade' => {'text' => 'Upgrade an SV to a more complex form. Generally adds a new body type to the SV, then copies across as much information as possible from the old body. You generally want to use the C macro wrapper. See also C. bool sv_upgrade(SV* sv, U32 mt)','name' => 'sv_upgrade'},'strEQ' => {'text' => 'Test two strings to see if they are equal. Returns true or false. bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C wrapper instead. SV* sv_newref(SV* sv)','name' => 'sv_newref'},'hv_store' => {'text' => '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. Effectively a successful hv_store takes ownership of one reference to C. 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 L 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)','name' => 'hv_store'},'SvIVX' => {'text' => 'Returns the raw value in the SV\'s IV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. IV SvIVX(SV* sv)','name' => 'SvIVX'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L. int perl_destruct(PerlInterpreter* interp)','name' => 'perl_destruct'},'sv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the scalar sv, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument is as in pv_uni_display(). The pointer to the PV of the dsv is returned. char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim, UV flags)','name' => 'sv_uni_display'},'isUPPER' => {'text' => 'Returns a boolean indicating whether the C C is an uppercase character. bool isUPPER(char ch)','name' => 'isUPPER'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. You probably want to use one of the assortment of wrappers, such as C, C, C and C. void sv_setsv(SV* dsv, SV* ssv)','name' => 'sv_setsv'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the stack. void XST_mYES(int pos)','name' => 'XST_mYES'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C for a version which guarantees to evaluate sv only once. NV SvNV(SV* sv)','name' => 'SvNV'},'packlist' => {'text' => 'The engine implementing pack() Perl function. void packlist(SV *cat, char *pat, char *patend, SV **beglist, SV **endlist)','name' => 'packlist'},'SvUTF8' => {'text' => 'Returns a boolean indicating whether the SV contains UTF-8 encoded data. void SvUTF8(SV* sv)','name' => 'SvUTF8'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'sv_setsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setsv_mg(SV *dstr, SV *sstr)','name' => 'sv_setsv_mg'},'hv_fetch_ent' => {'text' => '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)','name' => 'hv_fetch_ent'},'isLOWER' => {'text' => 'Returns a boolean indicating whether the C C is a lowercase character. bool isLOWER(char ch)','name' => 'isLOWER'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See C. char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an XSUB\'s aliases was used to invoke it. See L. I32 ix','name' => 'ix'},'SvNOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a double. Checks the B setting. Use C. bool SvNOKp(SV* sv)','name' => 'SvNOKp'},'XSRETURN_UV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_UV(IV uv)','name' => 'XSRETURN_UV'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'cv_undef' => {'text' => 'Clear out all the active components of a CV. This can happen either by an explicit C, 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)','name' => 'cv_undef'},'PUSHs' => {'text' => '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)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setuv(SV* sv, UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'utf8_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvchr(U8 *s, STRLEN* retlen)','name' => 'utf8_to_uvchr'},'nothreadhook' => {'text' => 'Stub that provides thread hook for perl_destruct when there are no threads. int nothreadhook()','name' => 'nothreadhook'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'bytes_to_utf8' => {'text' => 'Converts a string C of length C from ASCII into UTF-8 encoding. Returns a pointer to the newly-created string, and sets C to reflect the new length. If you want to convert to UTF-8 from other encodings than ASCII, see sv_recode_to_utf8(). NOTE: this function is experimental and may change or be removed without notice. U8* bytes_to_utf8(U8 *s, STRLEN *len)','name' => 'bytes_to_utf8'},'sv_pvn' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn(SV *sv, STRLEN *len)','name' => 'sv_pvn'},'SvIsCOW_shared_hash' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write shared hash key scalar. bool SvIsCOW_shared_hash(SV* sv)','name' => 'SvIsCOW_shared_hash'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'dXSI32' => {'text' => 'Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. dXSI32;','name' => 'dXSI32'},'sv_setref_iv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_iv(SV* rv, const char* classname, IV iv)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => '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. Uses the "OOK hack". Beware: after this function returns, C and SvPVX(sv) may no longer refer to the same chunk of data. void sv_chop(SV* sv, char* ptr)','name' => 'sv_chop'},'SvPVx' => {'text' => 'A version of C which guarantees to evaluate sv only once. char* SvPVx(SV* sv, STRLEN len)','name' => 'SvPVx'},'sv_backoff' => {'text' => 'Remove any string offset. You should normally use the C macro wrapper instead. int sv_backoff(SV* sv)','name' => 'sv_backoff'},'sv_tainted' => {'text' => 'Test an SV for taintedness. Use C instead. bool sv_tainted(SV* sv)','name' => 'sv_tainted'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. If necessary, uses C and upgrades the SV to C. Returns a pointer to the character buffer. Use the C wrapper instead. char* sv_grow(SV* sv, STRLEN newlen)','name' => 'sv_grow'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. See C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setuv_mg(SV *sv, UV u)','name' => 'sv_setuv_mg'},'cv_const_sv' => {'text' => 'If C is a constant sub eligible for inlining. returns the constant value returned by the sub. Otherwise, returns NULL. Constant subs can be created with C or as described in L. SV* cv_const_sv(CV* cv)','name' => 'cv_const_sv'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually handled automatically by C. See C.','name' => 'XS_VERSION'},'newSVnv' => {'text' => '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)','name' => 'newSVnv'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. See C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry. SV* HeVAL(HE* he)','name' => 'HeVAL'},'PL_na' => {'text' => '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','name' => 'PL_na'},'HePV' => {'text' => '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)','name' => 'HePV'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the SV is set to 1. SV* newSViv(IV i)','name' => 'newSViv'},'sv_untaint' => {'text' => 'Untaint an SV. Use C instead. void sv_untaint(SV* sv)','name' => 'sv_untaint'},'sv_setpv' => {'text' => '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)','name' => 'sv_setpv'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See C.','name' => 'SVt_PVHV'},'pv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the string spv, length len, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument can have UNI_DISPLAY_ISPRINT set to display isPRINT()able characters as themselves, UNI_DISPLAY_BACKSLASH to display the \\\\[nrfta\\\\] as the backslashed versions (like \'\\n\') (UNI_DISPLAY_BACKSLASH is preferred over UNI_DISPLAY_ISPRINT for \\\\). UNI_DISPLAY_QQ (and its alias UNI_DISPLAY_REGEX) have both UNI_DISPLAY_BACKSLASH and UNI_DISPLAY_ISPRINT turned on. The pointer to the PV of the dsv is returned. char* pv_uni_display(SV *dsv, U8 *spv, STRLEN len, STRLEN pvlim, UV flags)','name' => 'pv_uni_display'},'gv_fetchmethod' => {'text' => 'See L. GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'SvGETMAGIC' => {'text' => 'Invokes C on an SV if it has \'get\' magic. This macro evaluates its argument more than once. void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'SvGROW' => {'text' => '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)','name' => 'SvGROW'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_inc(SV* sv)','name' => 'sv_inc'},'sv_usepvn' => {'text' => '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)','name' => 'sv_usepvn'},'SvPVbytex_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex_force(SV* sv, STRLEN len)','name' => 'SvPVbytex_force'},'sv_catpv' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpv(SV* sv, const char* ptr)','name' => 'sv_catpv'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'sv_len' => {'text' => 'Returns the length of the string in the SV. Handles magic and type coercion. See also C, which gives raw access to the xpv_cur slot. STRLEN sv_len(SV* sv)','name' => 'sv_len'},'warn' => {'text' => '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, ...)','name' => 'warn'},'sv_pvutf8' => {'text' => 'Use the C macro instead char* sv_pvutf8(SV *sv)','name' => 'sv_pvutf8'},'SvPVbyte_nolen' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_nolen(SV* sv)','name' => 'SvPVbyte_nolen'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L. LEAVE;','name' => 'LEAVE'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See C.','name' => 'SVt_PVAV'},'hv_delete' => {'text' => '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, I32 klen, I32 flags)','name' => 'hv_delete'},'hv_undef' => {'text' => 'Undefines the hash. void hv_undef(HV* tb)','name' => 'hv_undef'},'SvSetMagicSV_nosteal' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetMagicSV_nosteal'},'hv_delete_ent' => {'text' => '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)','name' => 'hv_delete_ent'},'CLASS' => {'text' => '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','name' => 'CLASS'},'sv_isobject' => {'text' => '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)','name' => 'sv_isobject'},'Newc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Newc(int id, void* ptr, int nitems, type, cast)','name' => 'Newc'},'sv_pvn_force_flags' => {'text' => 'Get a sensible string out of the SV somehow. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You normally want to use the various wrapper macros instead: see C and C char* sv_pvn_force_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_pvn_force_flags'},'HeKLEN' => {'text' => '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)','name' => 'HeKLEN'},'to_utf8_title' => {'text' => 'Convert the UTF-8 encoded character at p to its titlecase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the titlecase version may be longer than the original character (up to two characters). The first character of the titlecased version is returned (but note, as explained above, that there may be more.) UV to_utf8_title(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_title'},'sv_cat_decode' => {'text' => 'The encoding is assumed to be an Encode object, the PV of the ssv is assumed to be octets in that encoding and decoding the input starts from the position which (PV + *offset) pointed to. The dsv will be concatenated the decoded UTF-8 string from ssv. Decoding will terminate when the string tstr appears in decoding output or the input ends on the PV of the ssv. The value which the offset points will be modified to the last input position on the ssv. Returns TRUE if the terminator was found, else returns FALSE. bool sv_cat_decode(SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen)','name' => 'sv_cat_decode'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. See C. void PUSHn(NV nv)','name' => 'PUSHn'},'sv_setiv' => {'text' => 'Copies an integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setiv(SV* sv, IV num)','name' => 'sv_setiv'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it. See C for a version which guarantees to evaluate sv only once. IV SvIV(SV* sv)','name' => 'SvIV'},'sv_report_used' => {'text' => 'Dump the contents of all SVs not yet freed. (Debugging aid). void sv_report_used()','name' => 'sv_report_used'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. void EXTEND(SP, int nitems)','name' => 'EXTEND'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. SV PL_sv_yes','name' => 'PL_sv_yes'},'SvNVX' => {'text' => 'Returns the raw value in the SV\'s NV slot, without checks or conversions. Only use when you are sure SvNOK is true. See also C. NV SvNVX(SV* sv)','name' => 'SvNVX'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(UV u)','name' => 'newSVuv'},'gv_fetchmeth' => {'text' => '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)','name' => 'gv_fetchmeth'},'sv_nosharing' => {'text' => '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 *)','name' => 'sv_nosharing'},'SvUTF8_off' => {'text' => 'Unsets the UTF-8 status of an SV. void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'looks_like_number' => {'text' => 'Test if the content of an SV looks like a number (or is a number). C and C are treated as numbers (so will not issue a non-numeric warning), even if your atof() doesn\'t grok them. I32 looks_like_number(SV* sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpv_mg(SV *sv, const char *ptr)','name' => 'sv_catpv_mg'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. U32 HeHASH(HE* he)','name' => 'HeHASH'},'sv_setref_uv' => {'text' => 'Copies an unsigned 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 have a reference count of 1, and the RV will be returned. SV* sv_setref_uv(SV* rv, const char* classname, UV uv)','name' => 'sv_setref_uv'},'SvIOK' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. bool SvIOK(SV* sv)','name' => 'SvIOK'},'getcwd_sv' => {'text' => 'Fill the sv with current working directory int getcwd_sv(SV* sv)','name' => 'getcwd_sv'},'newSVpv' => {'text' => '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)','name' => 'newSVpv'},'sv_2pvbyte' => {'text' => 'Return a pointer to the byte-encoded representation of the SV, and set *lp to its length. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte(SV* sv, STRLEN* lp)','name' => 'sv_2pvbyte'},'fbm_instr' => {'text' => '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)','name' => 'fbm_instr'},'sv_setpvf' => {'text' => '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, ...)','name' => 'sv_setpvf'},'SvPV_force' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. See C. void XPUSHn(NV nv)','name' => 'XPUSHn'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part attributable to C. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'call_sv' => {'text' => '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)','name' => 'call_sv'},'SVt_PV' => {'text' => 'Pointer type flag for scalars. See C.','name' => 'SVt_PV'},'strGT' => {'text' => '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)','name' => 'strGT'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a string and disables all other OK bits, and leaves the UTF-8 status as it was. void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic after a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'},'sv_pos_u2b' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from the start of the string, to a count of the equivalent number of bytes; if lenp is non-zero, it does the same to lenp, but this time starting from the offset, rather than from the start of the string. Handles magic and type coercion. void sv_pos_u2b(SV* sv, I32* offsetp, I32* lenp)','name' => 'sv_pos_u2b'},'SvTRUE' => {'text' => '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)','name' => 'SvTRUE'},'HeSVKEY_set' => {'text' => '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)','name' => 'HeSVKEY_set'},'POPl' => {'text' => 'Pops a long off the stack. long POPl','name' => 'POPl'},'hv_iternext_flags' => {'text' => 'Returns entries from a hash iterator. See C and C. The C 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 C<&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)','name' => 'hv_iternext_flags'},'grok_hex' => {'text' => 'converts a string representing a hex number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first non-hex-digit character. On return I<*len> is set to the length scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0x" or "x" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the hex number may use \'_\' characters to separate digits. UV grok_hex(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_hex'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L. SPAGAIN;','name' => 'SPAGAIN'},'call_method' => {'text' => '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)','name' => 'call_method'},'SvLOCK' => {'text' => 'Arranges for a mutual exclusion lock to be obtained on sv if a suitable module has been loaded. void SvLOCK(SV* sv)','name' => 'SvLOCK'},'sv_vsetpvfn' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Usually used via one of its frontends C and C. void sv_vsetpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vsetpvfn'},'get_cv' => {'text' => '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)','name' => 'get_cv'},'SvIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. Checks the B setting. Use C. bool SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the stack. void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'perl_parse' => {'text' => '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)','name' => 'perl_parse'},'to_utf8_case' => {'text' => 'The "p" contains the pointer to the UTF-8 string encoding the character that is being converted. The "ustrp" is a pointer to the character buffer to put the conversion result to. The "lenp" is a pointer to the length of the result. The "swashp" is a pointer to the swash to use. Both the special and normal mappings are stored lib/unicore/To/Foo.pl, and loaded by SWASHGET, using lib/utf8_heavy.pl. The special (usually, but not always, a multicharacter mapping), is tried first. The "special" is a string like "utf8::ToSpecLower", which means the hash %utf8::ToSpecLower. The access to the hash is through Perl_to_utf8_case(). The "normal" is a string like "ToLower" which means the swash %utf8::ToLower. UV to_utf8_case(U8 *p, U8* ustrp, STRLEN *lenp, SV **swash, char *normal, char *special)','name' => 'to_utf8_case'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory used by the array itself. void av_clear(AV* ar)','name' => 'av_clear'},'sv_force_normal' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. See also C. void sv_force_normal(SV *sv)','name' => 'sv_force_normal'},'av_unshift' => {'text' => '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)','name' => 'av_unshift'},'SvUNLOCK' => {'text' => 'Releases a mutual exclusion lock on sv if a suitable module has been loaded. void SvUNLOCK(SV* sv)','name' => 'SvUNLOCK'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C. int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV (using C). The new SV is marked as mortal. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_mortalcopy(SV* oldsv)','name' => 'sv_mortalcopy'},'POPpbytex' => {'text' => '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','name' => 'POPpbytex'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. UV SvUVX(SV* sv)','name' => 'SvUVX'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See L.','name' => 'G_NOARGS'},'SvSetMagicSV' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV(SV* dsb, SV* ssv)','name' => 'SvSetMagicSV'},'sv_utf8_decode' => {'text' => 'Convert the octets in the PV from UTF-8 to chars. Scan for validity and then turn off SvUTF8 if needed so that we see characters. Used as a building block for decode_utf8 in Encode.xs NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_decode(SV *sv)','name' => 'sv_utf8_decode'},'Newz' => {'text' => '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)','name' => 'Newz'},'savepvn' => {'text' => 'Perl\'s version of what C would be if it existed. Returns a pointer to a newly allocated string which is a duplicate of the first C bytes from C. The memory allocated for the new string can be freed with the C function. char* savepvn(const char* pv, I32 len)','name' => 'savepvn'},'eval_sv' => {'text' => '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)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized. This relies on the fact that uninitialized array elements are set to C<&PL_sv_undef>. bool av_exists(AV* ar, I32 key)','name' => 'av_exists'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C. STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'Move' => {'text' => '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)','name' => 'Move'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'sv_catpvn_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. void sv_catpvn_flags(SV* sv, const char* ptr, STRLEN len, I32 flags)','name' => 'sv_catpvn_flags'},'GIMME' => {'text' => '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','name' => 'GIMME'},'sv_bless' => {'text' => '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)','name' => 'sv_bless'},'NEWSV' => {'text' => '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)','name' => 'NEWSV'},'sv_isa' => {'text' => '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)','name' => 'sv_isa'},'isALNUM' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphanumeric character (including underscore) or digit. bool isALNUM(char ch)','name' => 'isALNUM'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs.','name' => 'newXS'},'sv_catpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. If the appended data contains "wide" characters (including, but not limited to, SVs with a UTF-8 PV formatted with %s, and characters >255 formatted with %c), the original SV might get upgraded to UTF-8. 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, ...)','name' => 'sv_catpvf'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. void SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C. void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'utf8_to_uvuni' => {'text' => 'Returns the Unicode code point of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. This function should only be used when returned UV is considered an index into the Unicode semantic tables (e.g. swashes). If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvuni(U8 *s, STRLEN* retlen)','name' => 'utf8_to_uvuni'},'sv_2io' => {'text' => 'Using various gambits, try to get an IO from an SV: the IO slot if its a GV; or the recursive result if we\'re an RV; or the IO slot of the symbol named after the PV if we\'re a string. IO* sv_2io(SV* sv)','name' => 'sv_2io'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphabetic character. bool isALPHA(char ch)','name' => 'isALPHA'},'Nullhv' => {'text' => 'Null HV pointer.','name' => 'Nullhv'},'av_fill' => {'text' => 'Ensure than an array has a given number of elements, equivalent to Perl\'s C<$#array = $fill;>. void av_fill(AV* ar, I32 fill)','name' => 'av_fill'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV. SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C. svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter* interp)','name' => 'perl_construct'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. void SvUOK(SV* sv)','name' => 'SvUOK'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_dec(SV* sv)','name' => 'sv_dec'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'strLE' => {'text' => '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)','name' => 'strLE'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'grok_bin' => {'text' => 'converts a string representing a binary number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. On return I<*len> is set to the length scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0b" or "b" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the binary number may use \'_\' characters to separate digits. UV grok_bin(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_bin'},'sv_2pvbyte_nolen' => {'text' => 'Return a pointer to the byte-encoded representation of the SV. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'SvOK' => {'text' => 'Returns a boolean indicating whether the value is an SV. bool SvOK(SV* sv)','name' => 'SvOK'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L. void perl_free(PerlInterpreter* interp)','name' => 'perl_free'},'sv_setref_nv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_nv(SV* rv, const char* classname, NV nv)','name' => 'sv_setref_nv'},'uvchr_to_utf8' => {'text' => 'Adds the UTF-8 representation of the Native codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvchr_to_utf8(d, uv); is the recommended wide native character-aware way of saying *(d++) = uv; U8* uvchr_to_utf8(U8 *d, UV uv)','name' => 'uvchr_to_utf8'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C. MAGIC* mg_find(SV* sv, int type)','name' => 'mg_find'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII digit. bool isDIGIT(char ch)','name' => 'isDIGIT'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'eval_pv' => {'text' => '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)','name' => 'eval_pv'},'newSVpvn_share' => {'text' => 'Creates a new SV with its SvPVX pointing to a shared string in the string table. If the string does not already exist in the table, it is created first. Turns on READONLY and FAKE. The string\'s hash is stored in the UV slot of the SV; if the C parameter is non-zero, that value is used; otherwise the hash is computed. The idea here is that as the string table is used for shared hash keys these strings will have SvPVX == HeKEY and hash lookup will avoid string compare. SV* newSVpvn_share(const char* s, I32 len, U32 hash)','name' => 'newSVpvn_share'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_setpvf_mg'},'SvPOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. Checks the B setting. Use C. bool SvPOKp(SV* sv)','name' => 'SvPOKp'},'sv_free' => {'text' => 'Decrement an SV\'s reference count, and if it drops to zero, call C to invoke destructors and free up any memory used by the body; finally, deallocate the SV\'s head itself. Normally called via a wrapper macro C. void sv_free(SV* sv)','name' => 'sv_free'},'sv_catpvn' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn'},'SvPVbyte_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_force(SV* sv, STRLEN len)','name' => 'SvPVbyte_force'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. CV* newCONSTSUB(HV* stash, char* name, SV* sv)','name' => 'newCONSTSUB'},'sv_setref_pv' => {'text' => '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 have a reference count of 1, and the RV will be returned. 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)','name' => 'sv_setref_pv'},'SvSHARE' => {'text' => 'Arranges for sv to be shared between threads if a suitable module has been loaded. void SvSHARE(SV* sv)','name' => 'SvSHARE'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_pop(AV* ar)','name' => 'av_pop'},'fbm_compile' => {'text' => '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)','name' => 'fbm_compile'},'sv_utf8_downgrade' => {'text' => 'Attempt to convert the PV of an SV from UTF-8-encoded to byte encoding. This may not be possible if the PV contains non-byte encoding characters; if this is the case, either returns false or, if C is not true, croaks. This is not as a general purpose Unicode to byte encoding interface: use the Encode extension for that. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_downgrade(SV *sv, bool fail_ok)','name' => 'sv_utf8_downgrade'},'SvNIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. Checks the B setting. Use C. bool SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'croak' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Normally use this function the same way you use the C C function. See C. If you want to throw an exception object, assign the object to C<$@> and then pass C to croak(): errsv = get_sv("@", TRUE); sv_setsv(errsv, exception_object); croak(Nullch); void croak(const char* pat, ...)','name' => 'croak'},'sortsv' => {'text' => '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)','name' => 'sortsv'},'THIS' => {'text' => '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','name' => 'THIS'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either forward or backward. WARNING: do not use the following unless you *know* C is within the UTF-8 data pointed to by C *and* that on entry C is aligned on the first byte of character or just after the last byte of a character. U8* utf8_hop(U8 *s, I32 off)','name' => 'utf8_hop'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide UTF-8 bytes as a single character. Handles magic and type coercion. STRLEN sv_len_utf8(SV* sv)','name' => 'sv_len_utf8'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually handled by C. void XSRETURN(int nitems)','name' => 'XSRETURN'},'sv_setref_pvn' => {'text' => '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 have a reference count of 1, and the RV will be returned. Note that C copies the pointer while this copies the string. SV* sv_setref_pvn(SV* rv, const char* classname, char* pv, STRLEN n)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for blessed scalars. See C.','name' => 'SVt_PVMG'},'PUSHp' => {'text' => '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)','name' => 'PUSHp'},'scan_bin' => {'text' => 'For backwards compatibility. Use C instead. NV scan_bin(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_bin'},'Nullcv' => {'text' => 'Null CV pointer.','name' => 'Nullcv'},'dAX' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dAX;','name' => 'dAX'},'sv_2pv_nolen' => {'text' => 'Like C, but doesn\'t return the length too. You should usually use the macro wrapper C instead. char* sv_2pv_nolen(SV* sv)','name' => 'sv_2pv_nolen'},'get_av' => {'text' => '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)','name' => 'get_av'},'PL_sv_undef' => {'text' => 'This is the C SV. Always refer to this as C<&PL_sv_undef>. SV PL_sv_undef','name' => 'PL_sv_undef'},'SvPVbyte' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'hv_iterkeysv' => {'text' => '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)','name' => 'hv_iterkeysv'},'grok_number' => {'text' => '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)','name' => 'grok_number'},'SvIVx' => {'text' => 'Coerces the given SV to an integer and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. IV SvIVx(SV* sv)','name' => 'SvIVx'},'grok_numeric_radix' => {'text' => 'Scan and skip for a numeric decimal separator (radix). bool grok_numeric_radix(const char **sp, const char *send)','name' => 'grok_numeric_radix'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the stack. void XST_mNO(int pos)','name' => 'XST_mNO'},'toUPPER' => {'text' => 'Converts the specified character to uppercase. char toUPPER(char ch)','name' => 'toUPPER'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array. Returns the deleted element. C is currently ignored. SV* av_delete(AV* ar, I32 key, I32 flags)','name' => 'av_delete'},'is_utf8_string_loc' => {'text' => 'Like is_ut8_string but store the location of the failure in the last argument. bool is_utf8_string_loc(U8 *s, STRLEN len, U8 **p)','name' => 'is_utf8_string_loc'},'utf8_distance' => {'text' => 'Returns the number of UTF-8 characters between the UTF-8 pointers C and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. IV utf8_distance(U8 *a, U8 *b)','name' => 'utf8_distance'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally appending to the currently-stored string. char* sv_gets(SV* sv, PerlIO* fp, I32 append)','name' => 'sv_gets'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'SvPVutf8x' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'sv_collxfrm' => {'text' => 'Add Collate Transform magic to an SV if it doesn\'t already have it. Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the scalar data of the variable, but transformed to such a format that a normal memory comparison can be used to compare the data according to the locale settings. char* sv_collxfrm(SV* sv, STRLEN* nxp)','name' => 'sv_collxfrm'},'sv_2cv' => {'text' => 'Using various gambits, try to get a CV from an SV; in addition, try if possible to set C<*st> and C<*gvp> to the stash and GV associated with it. CV* sv_2cv(SV* sv, HV** st, GV** gvp, I32 lref)','name' => 'sv_2cv'},'SvPV_force_nomg' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. Doesn\'t process magic. char* SvPV_force_nomg(SV* sv, STRLEN len)','name' => 'SvPV_force_nomg'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. Will also turn off the UTF-8 status. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'POPpx' => {'text' => 'Pops a string off the stack. Requires a variable STRLEN n_a in scope. char* POPpx','name' => 'POPpx'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'sv_uv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. UV sv_uv(SV* sv)','name' => 'sv_uv'},'sv_pvbyte' => {'text' => 'Use C instead. char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'hv_fetch' => {'text' => '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 an C. See L for more information on how to use this function on tied hashes. SV** hv_fetch(HV* tb, const char* key, I32 klen, I32 lval)','name' => 'hv_fetch'},'Zero' => {'text' => '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)','name' => 'Zero'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_unref_flags' => {'text' => '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. The C argument can contain C to force the reference count to be decremented (otherwise the decrementing is conditional on the reference count being different from one or the reference being a readonly SV). See C. void sv_unref_flags(SV* sv, U32 flags)','name' => 'sv_unref_flags'},'sv_iv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. IV sv_iv(SV* sv)','name' => 'sv_iv'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'Nullch' => {'text' => 'Null character pointer.','name' => 'Nullch'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)','name' => 'mg_copy'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C flag on this RV; give the referred-to SV C magic if it hasn\'t already; and push a back-reference to this RV onto the array of backreferences associated with that magic. SV* sv_rvweaken(SV *sv)','name' => 'sv_rvweaken'},'grok_oct' => {'text' => 'UV grok_oct(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_oct'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'scan_hex' => {'text' => 'For backwards compatibility. Use C instead. NV scan_hex(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_hex'},'newSVpvn' => {'text' => '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)','name' => 'newSVpvn'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the supplied vtable and returns pointer to the magic added. Note that sv_magicext will allow things that sv_magic will not. In particular you can add magic to SvREADONLY SVs and and more than one instance of the same \'how\' I C is greater then zero then a savepvn() I of C is stored, if C is zero then C is stored as-is and - as another special case - if C<(name && namelen == HEf_SVKEY)> then C is assumed to contain an C and has its REFCNT incremented (This is now used as a subroutine by sv_magic.) MAGIC * sv_magicext(SV* sv, SV* obj, int how, MGVTBL *vtbl, const char* name, I32 namlen )','name' => 'sv_magicext'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C.','name' => 'SVt_PVCV'},'av_push' => {'text' => '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)','name' => 'av_push'},'unpackstring' => {'text' => 'The engine implementing unpack() Perl function. C puts the extracted list items on the stack and returns the number of elements. Issue C before and C after the call to this function. I32 unpackstring(char *pat, char *patend, char *s, char *strend, U32 flags)','name' => 'unpackstring'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV* ar, I32 key)','name' => 'av_extend'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV *sv)','name' => 'newRV_noinc'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpviv_mg(SV *sv, IV iv)','name' => 'sv_setpviv_mg'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'sv_2bool' => {'text' => 'This function is only called on magical items, and is only used by sv_true() or its macro equivalent. bool sv_2bool(SV* sv)','name' => 'sv_2bool'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. You may call C or C 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 C, so you must not discard your iterator immediately else the entry will leak - call C to trigger the resource deallocation. HE* hv_iternext(HV* tb)','name' => 'hv_iternext'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'sv_newmortal' => {'text' => 'Creates a new null SV which is mortal. The reference count of the SV is set to 1. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_newmortal()','name' => 'sv_newmortal'},'sv_clear' => {'text' => 'Clear an SV: call any destructors, free up any memory used by the body, and free the body itself. The SV\'s head is I freed, although its type is set to all 1\'s so that it won\'t inadvertently be assumed to be live during global destruction etc. This function should only be called when REFCNT is zero. Most of the time you\'ll want to call C (or its macro wrapper C) instead. void sv_clear(SV* sv)','name' => 'sv_clear'},'hv_iterinit' => {'text' => '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)','name' => 'hv_iterinit'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.008002', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_012_005.pm0000644000175000017500000000040712047667377020774 0ustar tseetseepackage Perl::APIReference::V5_012_005; use strict; use warnings; use parent 'Perl::APIReference::V5_012_000'; sub new { my $class = shift; my $obj = $class->SUPER::new(@_); $obj->{perl_version} = '5.012005'; bless $obj => $class; return $obj; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_008_001.pm0000644000175000017500000034536611653441731020777 0ustar tseetseepackage Perl::APIReference::V5_008_001; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'SvOOK' => {'text' => '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)','name' => 'SvOOK'},'hv_store_ent' => {'text' => '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. Effectively a successful hv_store_ent takes ownership of one reference to C. 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 C; unlike C it does not take ownership of it, so maintaining the correct reference count on C 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 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)','name' => 'hv_store_ent'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package, which must be a valid UTF-8 string. See C. HV* gv_stashsv(SV* sv, I32 create)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'strGE' => {'text' => '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)','name' => 'strGE'},'form' => {'text' => '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, ...)','name' => 'form'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified version becoming C. Handles \'get\' magic. See also C for a version which guarantees to evaluate sv only once. char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'is_utf8_string' => {'text' => 'Returns true if first C bytes of the given string form a valid UTF-8 string, false otherwise. Note that \'a valid UTF-8 string\' does not mean \'a string that contains code points above 0x7F encoded in UTF-8\' because a valid ASCII string is a valid UTF-8 string. bool is_utf8_string(U8 *s, STRLEN len)','name' => 'is_utf8_string'},'svtype' => {'text' => '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.','name' => 'svtype'},'hv_clear' => {'text' => 'Clears a hash, making it empty. void hv_clear(HV* tb)','name' => 'hv_clear'},'get_hv' => {'text' => '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)','name' => 'get_hv'},'load_module' => {'text' => '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 C. The optional trailing SV* arguments can be used to specify arguments to the module\'s import() method, similar to C. void load_module(U32 flags, SV* name, SV* ver, ...)','name' => 'load_module'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES;','name' => 'XSRETURN_YES'},'sv_nv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. NV sv_nv(SV* sv)','name' => 'sv_nv'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'Poison' => {'text' => '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)','name' => 'Poison'},'sv_insert' => {'text' => '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)','name' => 'sv_insert'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_catpvf_mg'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'SvPOK' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. bool SvPOK(SV* sv)','name' => 'SvPOK'},'get_sv' => {'text' => '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)','name' => 'get_sv'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. See C. void PUSHu(UV uv)','name' => 'PUSHu'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. (Uses C). SV* newSVsv(SV* old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C. void hv_magic(HV* hv, GV* gv, int how)','name' => 'hv_magic'},'SvPVutf8' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *sv, const char *ptr)','name' => 'sv_setpv_mg'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C.','name' => 'XS'},'scan_oct' => {'text' => 'For backwards compatibility. Use C instead. NV scan_oct(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_oct'},'sv_setpvn' => {'text' => '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)','name' => 'sv_setpvn'},'sv_2mortal' => {'text' => 'Marks an existing SV as mortal. The SV will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_2mortal(SV* sv)','name' => 'sv_2mortal'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'newSVrv' => {'text' => '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)','name' => 'newSVrv'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself. void av_undef(AV* ar)','name' => 'av_undef'},'HeKEY' => {'text' => '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)','name' => 'HeKEY'},'pack_cat' => {'text' => '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)','name' => 'pack_cat'},'utf8n_to_uvuni' => {'text' => 'Bottom level UTF-8 decode routine. Returns the unicode code point value of the first character in the string C which is assumed to be in UTF-8 encoding and no longer than C; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, the behaviour is dependent on the value of C: if it contains UTF8_CHECK_ONLY, it is assumed that the caller will raise a warning, and this function will silently just set C to C<-1> and return zero. If the C does not contain UTF8_CHECK_ONLY, warnings about malformations will be given, C will be set to the expected length of the UTF-8 character in bytes, and zero will be returned. The C can also contain various flags to allow deviations from the strict UTF-8 encoding (see F). Most code should use utf8_to_uvchr() rather than call this directly. UV utf8n_to_uvuni(U8 *s, STRLEN curlen, STRLEN* retlen, U32 flags)','name' => 'utf8n_to_uvuni'},'sv_cmp' => {'text' => '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. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp(SV* sv1, SV* sv2)','name' => 'sv_cmp'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'SvEND' => {'text' => '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)','name' => 'SvEND'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C to type C if necessary, then adds a new magic item of type C to the head of the magic list. void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen)','name' => 'sv_magic'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C, C or C for void, scalar or list context, respectively. U32 GIMME_V','name' => 'GIMME_V'},'sv_force_normal_flags' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. The C parameter gets passed to C when unrefing. C calls this function with flags set to 0. void sv_force_normal_flags(SV *sv, U32 flags)','name' => 'sv_force_normal_flags'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'sv_setsv_flags' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. If the C parameter has the C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You probably want to use one of the assortment of wrappers, such as C, C, C and C. This is the primary function for copying scalars, and most other copy-ish functions and macros use this underneath. void sv_setsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_setsv_flags'},'sv_utf8_upgrade_flags' => {'text' => 'Convert the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade_flags(SV *sv, I32 flags)','name' => 'sv_utf8_upgrade_flags'},'New' => {'text' => 'The XSUB-writer\'s interface to the C C function. void New(int id, void* ptr, int nitems, type)','name' => 'New'},'is_utf8_char' => {'text' => 'Tests if some arbitrary number of bytes begins in a valid UTF-8 character. Note that an INVARIANT (i.e. ASCII) character is a valid UTF-8 character. The actual number of bytes in the UTF-8 character will be returned if it is valid, otherwise 0. STRLEN is_utf8_char(U8 *p)','name' => 'is_utf8_char'},'Copy' => {'text' => '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)','name' => 'Copy'},'ibcmp_utf8' => {'text' => 'Return true if the strings s1 and s2 differ case-insensitively, false if not (if they are equal case-insensitively). If u1 is true, the string s1 is assumed to be in UTF-8-encoded Unicode. If u2 is true, the string s2 is assumed to be in UTF-8-encoded Unicode. If u1 or u2 are false, the respective string is assumed to be in native 8-bit encoding. If the pe1 and pe2 are non-NULL, the scanning pointers will be copied in there (they will point at the beginning of the I character). If the pointers behind pe1 or pe2 are non-NULL, they are the end pointers beyond which scanning will not continue under any circustances. If the byte lengths l1 and l2 are non-zero, s1+l1 and s2+l2 will be used as goal end pointers that will also stop the scan, and which qualify towards defining a successful match: all the scans that define an explicit length must reach their goal pointers for a match to succeed). For case-insensitiveness, the "casefolding" of Unicode is used instead of upper/lowercasing both the characters, see http://www.unicode.org/unicode/reports/tr21/ (Case Mappings). I32 ibcmp_utf8(const char* a, char **pe1, UV l1, bool u1, const char* b, char **pe2, UV l2, bool u2)','name' => 'ibcmp_utf8'},'CvSTASH' => {'text' => 'Returns the stash of the CV. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'sv_taint' => {'text' => 'Taint an SV. Use C instead. void sv_taint(SV* sv)','name' => 'sv_taint'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. The target SV physically takes over ownership of the body of the source SV and inherits its flags; however, the target keeps any magic it owns, and any magic in the source is discarded. Note that this is a rather specialist SV copying operation; most of the time you\'ll want to use C or one of its many macro front-ends. void sv_replace(SV* sv, SV* nsv)','name' => 'sv_replace'},'utf8n_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. Allows length and flags to be passed to low level routine. UV utf8n_to_uvchr(U8 *s, STRLEN curlen, STRLEN* retlen, U32 flags)','name' => 'utf8n_to_uvchr'},'sv_utf8_upgrade' => {'text' => 'Convert the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains a signed integer. void SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and L.','name' => 'G_ARRAY'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. Sets up the C and C variables by calling C and C. This is usually handled automatically by C. dXSARGS;','name' => 'dXSARGS'},'sv_2iv' => {'text' => 'Return the integer value of an SV, doing any necessary string conversion, magic etc. Normally used via the C and C macros. IV sv_2iv(SV* sv)','name' => 'sv_2iv'},'savesharedpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* ptr)','name' => 'Safefree'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the C C is whitespace. bool isSPACE(char ch)','name' => 'isSPACE'},'SvROK' => {'text' => 'Tests if the SV is an RV. bool SvROK(SV* sv)','name' => 'SvROK'},'sv_unref' => {'text' => '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. This is C with the C being zero. See C. void sv_unref(SV* sv)','name' => 'sv_unref'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dstr, SV *sstr)','name' => 'sv_catsv_mg'},'call_argv' => {'text' => '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)','name' => 'call_argv'},'SvPV_nolen' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified form becoming C. Handles \'get\' magic. char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'perl_clone' => {'text' => '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 C, 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)','name' => 'perl_clone'},'sv_setnv' => {'text' => 'Copies a double into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setnv(SV* sv, NV num)','name' => 'sv_setnv'},'sv_2nv' => {'text' => 'Return the num value of an SV, doing any necessary string or integer conversion, magic etc. Normally used via the C and C macros. NV sv_2nv(SV* sv)','name' => 'sv_2nv'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'XPUSHp' => {'text' => '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)','name' => 'XPUSHp'},'sv_utf8_encode' => {'text' => 'Convert the PV of an SV to UTF-8-encoded, but then turn off the C flag so that it looks like octets again. Used as a building block for encode_utf8 in Encode.xs void sv_utf8_encode(SV *sv)','name' => 'sv_utf8_encode'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1. HV* newHV()','name' => 'newHV'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or false. bool strNE(char* s1, char* s2)','name' => 'strNE'},'SvUTF8_on' => {'text' => 'Turn on the UTF-8 status of an SV (the data is not changed, just the flag). Do not use frivolously. void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_setpvn_mg'},'sv_pvutf8n_force' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n_force(SV* sv, STRLEN* lp)','name' => 'sv_pvutf8n_force'},'savepv' => {'text' => 'Perl\'s version of C. Returns a pointer to a newly allocated string which is a duplicate of C. The size of the string is determined by C. The memory allocated for the new string can be freed with the C function. char* savepv(const char* pv)','name' => 'savepv'},'toLOWER' => {'text' => 'Converts the specified character to lowercase. char toLOWER(char ch)','name' => 'toLOWER'},'bytes_from_utf8' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike but like C, returns a pointer to the newly-created string, and updates C to contain the new length. Returns the original string if no conversion occurs, C is unchanged. Do nothing if C points to 0. Sets C to 0 if C is converted or contains all 7bit characters. NOTE: this function is experimental and may change or be removed without notice. U8* bytes_from_utf8(U8 *s, STRLEN *len, bool *is_utf8)','name' => 'bytes_from_utf8'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1. AV* newAV()','name' => 'newAV'},'POPp' => {'text' => 'Pops a string off the stack. Deprecated. New code should provide a STRLEN n_a and use POPpx. char* POPp','name' => 'POPp'},'HvNAME' => {'text' => 'Returns the package name of a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV of the sv is assumed to be octets in that encoding, and the sv will be converted into Unicode (and UTF-8). If the sv already is UTF-8 (or if it is not POK), or if the encoding is not a reference, nothing is done to the sv. If the encoding is not an C Encoding object, bad things will happen. (See F and L). The PV of the sv is returned. char* sv_recode_to_utf8(SV* sv, SV *encoding)','name' => 'sv_recode_to_utf8'},'av_make' => {'text' => '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)','name' => 'av_make'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. See C for a version which guarantees to evaluate sv only once. UV SvUV(SV* sv)','name' => 'SvUV'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L. int perl_run(PerlInterpreter* interp)','name' => 'perl_run'},'sv_pvbyten' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten(SV *sv, STRLEN *len)','name' => 'sv_pvbyten'},'sv_catsv_flags' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. If C has C bit set, will C on the SVs if appropriate, else not. C and C are implemented in terms of this function. void sv_catsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_catsv_flags'},'Nullav' => {'text' => 'Null AV pointer.','name' => 'Nullav'},'sv_copypv' => {'text' => 'Copies a stringified representation of the source SV into the destination SV. Automatically performs any necessary mg_get and coercion of numeric values into strings. Guaranteed to preserve UTF-8 flag even from overloaded objects. Similar in nature to sv_2pv[_flags] but operates directly on an SV instead of just the string. Mostly uses sv_2pv_flags to do its work, except when that would lose the UTF-8\'ness of the PV. void sv_copypv(SV* dsv, SV* ssv)','name' => 'sv_copypv'},'sv_pv' => {'text' => 'Use the C macro instead char* sv_pv(SV *sv)','name' => 'sv_pv'},'SvPVutf8_nolen' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_nolen(SV* sv)','name' => 'SvPVutf8_nolen'},'sv_setpviv' => {'text' => '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)','name' => 'sv_setpviv'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setnv_mg(SV *sv, NV num)','name' => 'sv_setnv_mg'},'sv_true' => {'text' => 'Returns true if the SV has a true value by Perl\'s rules. Use the C macro instead, which may call C or may instead use an in-line version. I32 sv_true(SV *sv)','name' => 'sv_true'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV* hv, char** key, I32* retlen)','name' => 'hv_iternextsv'},'utf8_to_bytes' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike C, this over-writes the original string, and updates len to contain the new length. Returns zero on failure, setting C to -1. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_pvbyten_force' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten_force(SV* sv, STRLEN* lp)','name' => 'sv_pvbyten_force'},'sv_derived_from' => {'text' => '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)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. See also C. I32 sv_cmp_locale(SV* sv1, SV* sv2)','name' => 'sv_cmp_locale'},'uvuni_to_utf8_flags' => {'text' => 'Adds the UTF-8 representation of the Unicode codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvuni_to_utf8_flags(d, uv, flags); or, in most cases, d = uvuni_to_utf8(d, uv); (which is equivalent to) d = uvuni_to_utf8_flags(d, uv, 0); is the recommended Unicode-aware way of saying *(d++) = uv; U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)','name' => 'uvuni_to_utf8_flags'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'hv_exists' => {'text' => '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, I32 klen)','name' => 'hv_exists'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See L.','name' => 'G_DISCARD'},'Nullsv' => {'text' => 'Null SV pointer.','name' => 'Nullsv'},'mg_length' => {'text' => 'Report on the SV\'s length. See C. U32 mg_length(SV* sv)','name' => 'mg_length'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'SvPVX' => {'text' => 'Returns a pointer to the physical string in the SV. The SV must contain a string. char* SvPVX(SV* sv)','name' => 'SvPVX'},'XST_mNV' => {'text' => '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)','name' => 'XST_mNV'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. See C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'HEf_SVKEY' => {'text' => 'This flag, used in the length slot of hash entries and magic structures, specifies the structure contains an C pointer where a C pointer is to be expected. (For information only--not to be used).','name' => 'HEf_SVKEY'},'pad_sv' => {'text' => '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)','name' => 'pad_sv'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C in characters. Stops at C (inclusive). If C s> or if the scan would end up past C, croaks. STRLEN utf8_length(U8* s, U8 *e)','name' => 'utf8_length'},'SvPVutf8_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_force(SV* sv, STRLEN len)','name' => 'SvPVutf8_force'},'sv_2pvutf8_nolen' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8_nolen(SV* sv)','name' => 'sv_2pvutf8_nolen'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted if tainting is enabled. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'SvIOK_only_UV' => {'text' => 'Tells and SV that it is an unsigned integer and disables all other OK bits. void SvIOK_only_UV(SV* sv)','name' => 'SvIOK_only_UV'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C.','name' => 'SVt_NV'},'sv_nolocking' => {'text' => '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 *)','name' => 'sv_nolocking'},'sv_vcatpvfn' => {'text' => '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). Usually used via one of its frontends C and C. void sv_vcatpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vcatpvfn'},'SvPVbytex' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex(SV* sv, STRLEN len)','name' => 'SvPVbytex'},'av_store' => {'text' => '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)','name' => 'av_store'},'sv_2uv' => {'text' => 'Return the unsigned integer value of an SV, doing any necessary string conversion, magic etc. Normally used via the C and C macros. UV sv_2uv(SV* sv)','name' => 'sv_2uv'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and L. PUSHMARK;','name' => 'PUSHMARK'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. SV* ST(int ix)','name' => 'ST'},'strLT' => {'text' => '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)','name' => 'strLT'},'sv_pvutf8n' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n(SV *sv, STRLEN *len)','name' => 'sv_pvutf8n'},'call_pv' => {'text' => '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)','name' => 'call_pv'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. SV* av_shift(AV* ar)','name' => 'av_shift'},'newSV' => {'text' => 'Create a new null SV, or if len > 0, create a new empty SVt_PV type SV with an initial PV allocation of len+1. Normally accessed via the C macro. SV* newSV(STRLEN len)','name' => 'newSV'},'av_fetch' => {'text' => '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)','name' => 'av_fetch'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'gv_fetchmeth_autoload' => {'text' => '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 C. 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)','name' => 'gv_fetchmeth_autoload'},'sv_2pvutf8' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV, and set *lp to its length. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8(SV* sv, STRLEN* lp)','name' => 'sv_2pvutf8'},'sv_nounlocking' => {'text' => '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 *)','name' => 'sv_nounlocking'},'dITEMS' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dITEMS;','name' => 'dITEMS'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV* tb, HE* entry)','name' => 'hv_iterval'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. char* sv_reftype(SV* sv, int ob)','name' => 'sv_reftype'},'sv_pos_b2u' => {'text' => 'Converts the value pointed to by offsetp from a count of bytes from the start of the string, to a count of the equivalent number of UTF-8 chars. Handles magic and type coercion. void sv_pos_b2u(SV* sv, I32* offsetp)','name' => 'sv_pos_b2u'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C.','name' => 'SVt_IV'},'av_len' => {'text' => 'Returns the highest index in the array. Returns -1 if the array is empty. I32 av_len(AV* ar)','name' => 'av_len'},'SvIsCOW' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write. (either shared hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for COW) bool SvIsCOW(SV* sv)','name' => 'SvIsCOW'},'sv_unmagic' => {'text' => 'Removes all magic of type C from an SV. int sv_unmagic(SV* sv, int type)','name' => 'sv_unmagic'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *sv, IV i)','name' => 'sv_setiv_mg'},'sv_catsv' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catsv(SV* dsv, SV* ssv)','name' => 'sv_catsv'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled. void SvTAINT(SV* sv)','name' => 'SvTAINT'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C. See C and L for other uses. PUTBACK;','name' => 'PUTBACK'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'ax' => {'text' => 'Variable which is setup by C to indicate the stack base offset, used by the C, C and C macros. The C macro must be called prior to setup the C variable. I32 ax','name' => 'ax'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'SvCUR_set' => {'text' => 'Set the length of the string which is in the SV. See C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'to_utf8_fold' => {'text' => 'Convert the UTF-8 encoded character at p to its foldcase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_FOLD+1 bytes since the foldcase version may be longer than the original character (up to three characters). The first character of the foldcased version is returned (but note, as explained above, that there may be more.) UV to_utf8_fold(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_fold'},'to_utf8_upper' => {'text' => 'Convert the UTF-8 encoded character at p to its uppercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the uppercase version may be longer than the original character (up to two characters). The first character of the uppercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_upper(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_upper'},'SvNOK' => {'text' => 'Returns a boolean indicating whether the SV contains a double. bool SvNOK(SV* sv)','name' => 'SvNOK'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. C should be a valid UTF-8 string. 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)','name' => 'gv_stashpv'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C, C, and L.','name' => 'G_SCALAR'},'SvPVutf8x_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x_force(SV* sv, STRLEN len)','name' => 'SvPVutf8x_force'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. See C. void PUSHi(IV iv)','name' => 'PUSHi'},'sv_reset' => {'text' => 'Underlying implementation for the C Perl function. Note that the perl-level function is vaguely deprecated. void sv_reset(char* s, HV* stash)','name' => 'sv_reset'},'hv_exists_ent' => {'text' => '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)','name' => 'hv_exists_ent'},'to_utf8_lower' => {'text' => 'Convert the UTF-8 encoded character at p to its lowercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the lowercase version may be longer than the original character (up to two characters). The first character of the lowercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_lower(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_lower'},'SvNIOK' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. bool SvNIOK(SV* sv)','name' => 'SvNIOK'},'sv_2pv_flags' => {'text' => 'Returns a pointer to the string value of an SV, and sets *lp to its length. If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string if necessary. Normally invoked via the C macro. C and C usually end up here too. char* sv_2pv_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_2pv_flags'},'SvTAINTED_off' => {'text' => '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)','name' => 'SvTAINTED_off'},'SvNVx' => {'text' => 'Coerces the given SV to a double and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. NV SvNVx(SV* sv)','name' => 'SvNVx'},'unpack_str' => {'text' => '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)','name' => 'unpack_str'},'newSVpvf' => {'text' => 'Creates a new SV and initializes it with the string formatted like C. SV* newSVpvf(const char* pat, ...)','name' => 'newSVpvf'},'require_pv' => {'text' => 'Tells Perl to C the file named by the string argument. It is analogous to the Perl code C. 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)','name' => 'require_pv'},'sv_upgrade' => {'text' => 'Upgrade an SV to a more complex form. Generally adds a new body type to the SV, then copies across as much information as possible from the old body. You generally want to use the C macro wrapper. See also C. bool sv_upgrade(SV* sv, U32 mt)','name' => 'sv_upgrade'},'strEQ' => {'text' => 'Test two strings to see if they are equal. Returns true or false. bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C wrapper instead. SV* sv_newref(SV* sv)','name' => 'sv_newref'},'hv_store' => {'text' => '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. Effectively a successful hv_store takes ownership of one reference to C. 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 L 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)','name' => 'hv_store'},'SvIVX' => {'text' => 'Returns the raw value in the SV\'s IV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. IV SvIVX(SV* sv)','name' => 'SvIVX'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L. int perl_destruct(PerlInterpreter* interp)','name' => 'perl_destruct'},'sv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the scalar sv, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument is as in pv_uni_display(). The pointer to the PV of the dsv is returned. char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim, UV flags)','name' => 'sv_uni_display'},'isUPPER' => {'text' => 'Returns a boolean indicating whether the C C is an uppercase character. bool isUPPER(char ch)','name' => 'isUPPER'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. You probably want to use one of the assortment of wrappers, such as C, C, C and C. void sv_setsv(SV* dsv, SV* ssv)','name' => 'sv_setsv'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the stack. void XST_mYES(int pos)','name' => 'XST_mYES'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C for a version which guarantees to evaluate sv only once. NV SvNV(SV* sv)','name' => 'SvNV'},'packlist' => {'text' => 'The engine implementing pack() Perl function. void packlist(SV *cat, char *pat, char *patend, SV **beglist, SV **endlist)','name' => 'packlist'},'SvUTF8' => {'text' => 'Returns a boolean indicating whether the SV contains UTF-8 encoded data. void SvUTF8(SV* sv)','name' => 'SvUTF8'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'sv_setsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setsv_mg(SV *dstr, SV *sstr)','name' => 'sv_setsv_mg'},'hv_fetch_ent' => {'text' => '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)','name' => 'hv_fetch_ent'},'isLOWER' => {'text' => 'Returns a boolean indicating whether the C C is a lowercase character. bool isLOWER(char ch)','name' => 'isLOWER'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See C. char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an XSUB\'s aliases was used to invoke it. See L. I32 ix','name' => 'ix'},'SvNOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a double. Checks the B setting. Use C. bool SvNOKp(SV* sv)','name' => 'SvNOKp'},'XSRETURN_UV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_UV(IV uv)','name' => 'XSRETURN_UV'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'cv_undef' => {'text' => 'Clear out all the active components of a CV. This can happen either by an explicit C, 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)','name' => 'cv_undef'},'PUSHs' => {'text' => '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)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setuv(SV* sv, UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'utf8_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvchr(U8 *s, STRLEN* retlen)','name' => 'utf8_to_uvchr'},'nothreadhook' => {'text' => 'Stub that provides thread hook for perl_destruct when there are no threads. int nothreadhook()','name' => 'nothreadhook'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'bytes_to_utf8' => {'text' => 'Converts a string C of length C from ASCII into UTF-8 encoding. Returns a pointer to the newly-created string, and sets C to reflect the new length. If you want to convert to UTF-8 from other encodings than ASCII, see sv_recode_to_utf8(). NOTE: this function is experimental and may change or be removed without notice. U8* bytes_to_utf8(U8 *s, STRLEN *len)','name' => 'bytes_to_utf8'},'sv_pvn' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn(SV *sv, STRLEN *len)','name' => 'sv_pvn'},'SvIsCOW_shared_hash' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write shared hash key scalar. bool SvIsCOW_shared_hash(SV* sv)','name' => 'SvIsCOW_shared_hash'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'dXSI32' => {'text' => 'Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. dXSI32;','name' => 'dXSI32'},'sv_setref_iv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_iv(SV* rv, const char* classname, IV iv)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => '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. Uses the "OOK hack". Beware: after this function returns, C and SvPVX(sv) may no longer refer to the same chunk of data. void sv_chop(SV* sv, char* ptr)','name' => 'sv_chop'},'SvPVx' => {'text' => 'A version of C which guarantees to evaluate sv only once. char* SvPVx(SV* sv, STRLEN len)','name' => 'SvPVx'},'sv_backoff' => {'text' => 'Remove any string offset. You should normally use the C macro wrapper instead. int sv_backoff(SV* sv)','name' => 'sv_backoff'},'sv_tainted' => {'text' => 'Test an SV for taintedness. Use C instead. bool sv_tainted(SV* sv)','name' => 'sv_tainted'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. If necessary, uses C and upgrades the SV to C. Returns a pointer to the character buffer. Use the C wrapper instead. char* sv_grow(SV* sv, STRLEN newlen)','name' => 'sv_grow'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. See C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setuv_mg(SV *sv, UV u)','name' => 'sv_setuv_mg'},'cv_const_sv' => {'text' => 'If C is a constant sub eligible for inlining. returns the constant value returned by the sub. Otherwise, returns NULL. Constant subs can be created with C or as described in L. SV* cv_const_sv(CV* cv)','name' => 'cv_const_sv'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually handled automatically by C. See C.','name' => 'XS_VERSION'},'newSVnv' => {'text' => '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)','name' => 'newSVnv'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. See C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry. SV* HeVAL(HE* he)','name' => 'HeVAL'},'PL_na' => {'text' => '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','name' => 'PL_na'},'HePV' => {'text' => '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)','name' => 'HePV'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the SV is set to 1. SV* newSViv(IV i)','name' => 'newSViv'},'sv_untaint' => {'text' => 'Untaint an SV. Use C instead. void sv_untaint(SV* sv)','name' => 'sv_untaint'},'sv_setpv' => {'text' => '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)','name' => 'sv_setpv'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See C.','name' => 'SVt_PVHV'},'pv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the string spv, length len, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument can have UNI_DISPLAY_ISPRINT set to display isPRINT()able characters as themselves, UNI_DISPLAY_BACKSLASH to display the \\\\[nrfta\\\\] as the backslashed versions (like \'\\n\') (UNI_DISPLAY_BACKSLASH is preferred over UNI_DISPLAY_ISPRINT for \\\\). UNI_DISPLAY_QQ (and its alias UNI_DISPLAY_REGEX) have both UNI_DISPLAY_BACKSLASH and UNI_DISPLAY_ISPRINT turned on. The pointer to the PV of the dsv is returned. char* pv_uni_display(SV *dsv, U8 *spv, STRLEN len, STRLEN pvlim, UV flags)','name' => 'pv_uni_display'},'gv_fetchmethod' => {'text' => 'See L. GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'SvGETMAGIC' => {'text' => 'Invokes C on an SV if it has \'get\' magic. This macro evaluates its argument more than once. void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'SvGROW' => {'text' => '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)','name' => 'SvGROW'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_inc(SV* sv)','name' => 'sv_inc'},'sv_usepvn' => {'text' => '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)','name' => 'sv_usepvn'},'SvPVbytex_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex_force(SV* sv, STRLEN len)','name' => 'SvPVbytex_force'},'sv_catpv' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpv(SV* sv, const char* ptr)','name' => 'sv_catpv'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'sv_len' => {'text' => 'Returns the length of the string in the SV. Handles magic and type coercion. See also C, which gives raw access to the xpv_cur slot. STRLEN sv_len(SV* sv)','name' => 'sv_len'},'warn' => {'text' => '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, ...)','name' => 'warn'},'sv_pvutf8' => {'text' => 'Use the C macro instead char* sv_pvutf8(SV *sv)','name' => 'sv_pvutf8'},'SvPVbyte_nolen' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_nolen(SV* sv)','name' => 'SvPVbyte_nolen'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L. LEAVE;','name' => 'LEAVE'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See C.','name' => 'SVt_PVAV'},'hv_delete' => {'text' => '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, I32 klen, I32 flags)','name' => 'hv_delete'},'hv_undef' => {'text' => 'Undefines the hash. void hv_undef(HV* tb)','name' => 'hv_undef'},'SvSetMagicSV_nosteal' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetMagicSV_nosteal'},'hv_delete_ent' => {'text' => '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)','name' => 'hv_delete_ent'},'CLASS' => {'text' => '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','name' => 'CLASS'},'sv_isobject' => {'text' => '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)','name' => 'sv_isobject'},'Newc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Newc(int id, void* ptr, int nitems, type, cast)','name' => 'Newc'},'sv_pvn_force_flags' => {'text' => 'Get a sensible string out of the SV somehow. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You normally want to use the various wrapper macros instead: see C and C char* sv_pvn_force_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_pvn_force_flags'},'HeKLEN' => {'text' => '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)','name' => 'HeKLEN'},'to_utf8_title' => {'text' => 'Convert the UTF-8 encoded character at p to its titlecase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the titlecase version may be longer than the original character (up to two characters). The first character of the titlecased version is returned (but note, as explained above, that there may be more.) UV to_utf8_title(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_title'},'sv_cat_decode' => {'text' => 'The encoding is assumed to be an Encode object, the PV of the ssv is assumed to be octets in that encoding and decoding the input starts from the position which (PV + *offset) pointed to. The dsv will be concatenated the decoded UTF-8 string from ssv. Decoding will terminate when the string tstr appears in decoding output or the input ends on the PV of the ssv. The value which the offset points will be modified to the last input position on the ssv. Returns TRUE if the terminator was found, else returns FALSE. bool sv_cat_decode(SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen)','name' => 'sv_cat_decode'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. See C. void PUSHn(NV nv)','name' => 'PUSHn'},'sv_setiv' => {'text' => 'Copies an integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setiv(SV* sv, IV num)','name' => 'sv_setiv'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it. See C for a version which guarantees to evaluate sv only once. IV SvIV(SV* sv)','name' => 'SvIV'},'sv_report_used' => {'text' => 'Dump the contents of all SVs not yet freed. (Debugging aid). void sv_report_used()','name' => 'sv_report_used'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. void EXTEND(SP, int nitems)','name' => 'EXTEND'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. SV PL_sv_yes','name' => 'PL_sv_yes'},'SvNVX' => {'text' => 'Returns the raw value in the SV\'s NV slot, without checks or conversions. Only use when you are sure SvNOK is true. See also C. NV SvNVX(SV* sv)','name' => 'SvNVX'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(UV u)','name' => 'newSVuv'},'gv_fetchmeth' => {'text' => '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)','name' => 'gv_fetchmeth'},'sv_nosharing' => {'text' => '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 *)','name' => 'sv_nosharing'},'SvUTF8_off' => {'text' => 'Unsets the UTF-8 status of an SV. void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'looks_like_number' => {'text' => 'Test if the content of an SV looks like a number (or is a number). C and C are treated as numbers (so will not issue a non-numeric warning), even if your atof() doesn\'t grok them. I32 looks_like_number(SV* sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpv_mg(SV *sv, const char *ptr)','name' => 'sv_catpv_mg'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. U32 HeHASH(HE* he)','name' => 'HeHASH'},'sv_setref_uv' => {'text' => 'Copies an unsigned 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 have a reference count of 1, and the RV will be returned. SV* sv_setref_uv(SV* rv, const char* classname, UV uv)','name' => 'sv_setref_uv'},'SvIOK' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. bool SvIOK(SV* sv)','name' => 'SvIOK'},'getcwd_sv' => {'text' => 'Fill the sv with current working directory int getcwd_sv(SV* sv)','name' => 'getcwd_sv'},'newSVpv' => {'text' => '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)','name' => 'newSVpv'},'sv_2pvbyte' => {'text' => 'Return a pointer to the byte-encoded representation of the SV, and set *lp to its length. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte(SV* sv, STRLEN* lp)','name' => 'sv_2pvbyte'},'fbm_instr' => {'text' => '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)','name' => 'fbm_instr'},'sv_setpvf' => {'text' => '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, ...)','name' => 'sv_setpvf'},'SvPV_force' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. See C. void XPUSHn(NV nv)','name' => 'XPUSHn'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part attributable to C. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'call_sv' => {'text' => '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)','name' => 'call_sv'},'SVt_PV' => {'text' => 'Pointer type flag for scalars. See C.','name' => 'SVt_PV'},'strGT' => {'text' => '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)','name' => 'strGT'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a string and disables all other OK bits, and leaves the UTF-8 status as it was. void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic after a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'},'sv_pos_u2b' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from the start of the string, to a count of the equivalent number of bytes; if lenp is non-zero, it does the same to lenp, but this time starting from the offset, rather than from the start of the string. Handles magic and type coercion. void sv_pos_u2b(SV* sv, I32* offsetp, I32* lenp)','name' => 'sv_pos_u2b'},'SvTRUE' => {'text' => '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)','name' => 'SvTRUE'},'HeSVKEY_set' => {'text' => '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)','name' => 'HeSVKEY_set'},'POPl' => {'text' => 'Pops a long off the stack. long POPl','name' => 'POPl'},'hv_iternext_flags' => {'text' => 'Returns entries from a hash iterator. See C and C. The C 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 C<&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)','name' => 'hv_iternext_flags'},'grok_hex' => {'text' => 'converts a string representing a hex number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first non-hex-digit character. On return I<*len> is set to the length scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0x" or "x" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the hex number may use \'_\' characters to separate digits. UV grok_hex(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_hex'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L. SPAGAIN;','name' => 'SPAGAIN'},'call_method' => {'text' => '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)','name' => 'call_method'},'SvLOCK' => {'text' => 'Arranges for a mutual exclusion lock to be obtained on sv if a suitable module has been loaded. void SvLOCK(SV* sv)','name' => 'SvLOCK'},'sv_vsetpvfn' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Usually used via one of its frontends C and C. void sv_vsetpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vsetpvfn'},'get_cv' => {'text' => '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)','name' => 'get_cv'},'SvIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. Checks the B setting. Use C. bool SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the stack. void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'perl_parse' => {'text' => '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)','name' => 'perl_parse'},'to_utf8_case' => {'text' => 'The "p" contains the pointer to the UTF-8 string encoding the character that is being converted. The "ustrp" is a pointer to the character buffer to put the conversion result to. The "lenp" is a pointer to the length of the result. The "swashp" is a pointer to the swash to use. Both the special and normal mappings are stored lib/unicore/To/Foo.pl, and loaded by SWASHGET, using lib/utf8_heavy.pl. The special (usually, but not always, a multicharacter mapping), is tried first. The "special" is a string like "utf8::ToSpecLower", which means the hash %utf8::ToSpecLower. The access to the hash is through Perl_to_utf8_case(). The "normal" is a string like "ToLower" which means the swash %utf8::ToLower. UV to_utf8_case(U8 *p, U8* ustrp, STRLEN *lenp, SV **swash, char *normal, char *special)','name' => 'to_utf8_case'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory used by the array itself. void av_clear(AV* ar)','name' => 'av_clear'},'sv_force_normal' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. See also C. void sv_force_normal(SV *sv)','name' => 'sv_force_normal'},'av_unshift' => {'text' => '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)','name' => 'av_unshift'},'SvUNLOCK' => {'text' => 'Releases a mutual exclusion lock on sv if a suitable module has been loaded. void SvUNLOCK(SV* sv)','name' => 'SvUNLOCK'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C. int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV (using C). The new SV is marked as mortal. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_mortalcopy(SV* oldsv)','name' => 'sv_mortalcopy'},'POPpbytex' => {'text' => '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','name' => 'POPpbytex'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. UV SvUVX(SV* sv)','name' => 'SvUVX'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See L.','name' => 'G_NOARGS'},'SvSetMagicSV' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV(SV* dsb, SV* ssv)','name' => 'SvSetMagicSV'},'sv_utf8_decode' => {'text' => 'Convert the octets in the PV from UTF-8 to chars. Scan for validity and then turn off SvUTF8 if needed so that we see characters. Used as a building block for decode_utf8 in Encode.xs NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_decode(SV *sv)','name' => 'sv_utf8_decode'},'Newz' => {'text' => '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)','name' => 'Newz'},'savepvn' => {'text' => 'Perl\'s version of what C would be if it existed. Returns a pointer to a newly allocated string which is a duplicate of the first C bytes from C. The memory allocated for the new string can be freed with the C function. char* savepvn(const char* pv, I32 len)','name' => 'savepvn'},'eval_sv' => {'text' => '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)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized. This relies on the fact that uninitialized array elements are set to C<&PL_sv_undef>. bool av_exists(AV* ar, I32 key)','name' => 'av_exists'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C. STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'Move' => {'text' => '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)','name' => 'Move'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'sv_catpvn_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. void sv_catpvn_flags(SV* sv, const char* ptr, STRLEN len, I32 flags)','name' => 'sv_catpvn_flags'},'GIMME' => {'text' => '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','name' => 'GIMME'},'sv_bless' => {'text' => '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)','name' => 'sv_bless'},'NEWSV' => {'text' => '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)','name' => 'NEWSV'},'sv_isa' => {'text' => '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)','name' => 'sv_isa'},'isALNUM' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphanumeric character (including underscore) or digit. bool isALNUM(char ch)','name' => 'isALNUM'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs.','name' => 'newXS'},'sv_catpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. If the appended data contains "wide" characters (including, but not limited to, SVs with a UTF-8 PV formatted with %s, and characters >255 formatted with %c), the original SV might get upgraded to UTF-8. 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, ...)','name' => 'sv_catpvf'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. void SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C. void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'utf8_to_uvuni' => {'text' => 'Returns the Unicode code point of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. This function should only be used when returned UV is considered an index into the Unicode semantic tables (e.g. swashes). If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvuni(U8 *s, STRLEN* retlen)','name' => 'utf8_to_uvuni'},'sv_2io' => {'text' => 'Using various gambits, try to get an IO from an SV: the IO slot if its a GV; or the recursive result if we\'re an RV; or the IO slot of the symbol named after the PV if we\'re a string. IO* sv_2io(SV* sv)','name' => 'sv_2io'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphabetic character. bool isALPHA(char ch)','name' => 'isALPHA'},'Nullhv' => {'text' => 'Null HV pointer.','name' => 'Nullhv'},'av_fill' => {'text' => 'Ensure than an array has a given number of elements, equivalent to Perl\'s C<$#array = $fill;>. void av_fill(AV* ar, I32 fill)','name' => 'av_fill'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV. SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C. svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter* interp)','name' => 'perl_construct'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. void SvUOK(SV* sv)','name' => 'SvUOK'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_dec(SV* sv)','name' => 'sv_dec'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'strLE' => {'text' => '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)','name' => 'strLE'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'grok_bin' => {'text' => 'converts a string representing a binary number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. On return I<*len> is set to the length scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0b" or "b" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the binary number may use \'_\' characters to separate digits. UV grok_bin(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_bin'},'sv_2pvbyte_nolen' => {'text' => 'Return a pointer to the byte-encoded representation of the SV. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'SvOK' => {'text' => 'Returns a boolean indicating whether the value is an SV. bool SvOK(SV* sv)','name' => 'SvOK'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L. void perl_free(PerlInterpreter* interp)','name' => 'perl_free'},'sv_setref_nv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_nv(SV* rv, const char* classname, NV nv)','name' => 'sv_setref_nv'},'uvchr_to_utf8' => {'text' => 'Adds the UTF-8 representation of the Native codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvchr_to_utf8(d, uv); is the recommended wide native character-aware way of saying *(d++) = uv; U8* uvchr_to_utf8(U8 *d, UV uv)','name' => 'uvchr_to_utf8'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C. MAGIC* mg_find(SV* sv, int type)','name' => 'mg_find'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII digit. bool isDIGIT(char ch)','name' => 'isDIGIT'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'eval_pv' => {'text' => '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)','name' => 'eval_pv'},'newSVpvn_share' => {'text' => 'Creates a new SV with its SvPVX pointing to a shared string in the string table. If the string does not already exist in the table, it is created first. Turns on READONLY and FAKE. The string\'s hash is stored in the UV slot of the SV; if the C parameter is non-zero, that value is used; otherwise the hash is computed. The idea here is that as the string table is used for shared hash keys these strings will have SvPVX == HeKEY and hash lookup will avoid string compare. SV* newSVpvn_share(const char* s, I32 len, U32 hash)','name' => 'newSVpvn_share'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_setpvf_mg'},'SvPOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. Checks the B setting. Use C. bool SvPOKp(SV* sv)','name' => 'SvPOKp'},'sv_free' => {'text' => 'Decrement an SV\'s reference count, and if it drops to zero, call C to invoke destructors and free up any memory used by the body; finally, deallocate the SV\'s head itself. Normally called via a wrapper macro C. void sv_free(SV* sv)','name' => 'sv_free'},'sv_catpvn' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn'},'SvPVbyte_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_force(SV* sv, STRLEN len)','name' => 'SvPVbyte_force'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. CV* newCONSTSUB(HV* stash, char* name, SV* sv)','name' => 'newCONSTSUB'},'sv_setref_pv' => {'text' => '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 have a reference count of 1, and the RV will be returned. 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)','name' => 'sv_setref_pv'},'SvSHARE' => {'text' => 'Arranges for sv to be shared between threads if a suitable module has been loaded. void SvSHARE(SV* sv)','name' => 'SvSHARE'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_pop(AV* ar)','name' => 'av_pop'},'fbm_compile' => {'text' => '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)','name' => 'fbm_compile'},'sv_utf8_downgrade' => {'text' => 'Attempt to convert the PV of an SV from UTF-8-encoded to byte encoding. This may not be possible if the PV contains non-byte encoding characters; if this is the case, either returns false or, if C is not true, croaks. This is not as a general purpose Unicode to byte encoding interface: use the Encode extension for that. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_downgrade(SV *sv, bool fail_ok)','name' => 'sv_utf8_downgrade'},'SvNIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. Checks the B setting. Use C. bool SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'croak' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Normally use this function the same way you use the C C function. See C. If you want to throw an exception object, assign the object to C<$@> and then pass C to croak(): errsv = get_sv("@", TRUE); sv_setsv(errsv, exception_object); croak(Nullch); void croak(const char* pat, ...)','name' => 'croak'},'sortsv' => {'text' => '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)','name' => 'sortsv'},'THIS' => {'text' => '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','name' => 'THIS'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either forward or backward. WARNING: do not use the following unless you *know* C is within the UTF-8 data pointed to by C *and* that on entry C is aligned on the first byte of character or just after the last byte of a character. U8* utf8_hop(U8 *s, I32 off)','name' => 'utf8_hop'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide UTF-8 bytes as a single character. Handles magic and type coercion. STRLEN sv_len_utf8(SV* sv)','name' => 'sv_len_utf8'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually handled by C. void XSRETURN(int nitems)','name' => 'XSRETURN'},'sv_setref_pvn' => {'text' => '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 have a reference count of 1, and the RV will be returned. Note that C copies the pointer while this copies the string. SV* sv_setref_pvn(SV* rv, const char* classname, char* pv, STRLEN n)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for blessed scalars. See C.','name' => 'SVt_PVMG'},'PUSHp' => {'text' => '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)','name' => 'PUSHp'},'scan_bin' => {'text' => 'For backwards compatibility. Use C instead. NV scan_bin(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_bin'},'Nullcv' => {'text' => 'Null CV pointer.','name' => 'Nullcv'},'dAX' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dAX;','name' => 'dAX'},'sv_2pv_nolen' => {'text' => 'Like C, but doesn\'t return the length too. You should usually use the macro wrapper C instead. char* sv_2pv_nolen(SV* sv)','name' => 'sv_2pv_nolen'},'get_av' => {'text' => '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)','name' => 'get_av'},'PL_sv_undef' => {'text' => 'This is the C SV. Always refer to this as C<&PL_sv_undef>. SV PL_sv_undef','name' => 'PL_sv_undef'},'SvPVbyte' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'hv_iterkeysv' => {'text' => '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)','name' => 'hv_iterkeysv'},'grok_number' => {'text' => '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)','name' => 'grok_number'},'SvIVx' => {'text' => 'Coerces the given SV to an integer and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. IV SvIVx(SV* sv)','name' => 'SvIVx'},'grok_numeric_radix' => {'text' => 'Scan and skip for a numeric decimal separator (radix). bool grok_numeric_radix(const char **sp, const char *send)','name' => 'grok_numeric_radix'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the stack. void XST_mNO(int pos)','name' => 'XST_mNO'},'toUPPER' => {'text' => 'Converts the specified character to uppercase. char toUPPER(char ch)','name' => 'toUPPER'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array. Returns the deleted element. C is currently ignored. SV* av_delete(AV* ar, I32 key, I32 flags)','name' => 'av_delete'},'is_utf8_string_loc' => {'text' => 'Like is_ut8_string but store the location of the failure in the last argument. bool is_utf8_string_loc(U8 *s, STRLEN len, U8 **p)','name' => 'is_utf8_string_loc'},'utf8_distance' => {'text' => 'Returns the number of UTF-8 characters between the UTF-8 pointers C and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. IV utf8_distance(U8 *a, U8 *b)','name' => 'utf8_distance'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally appending to the currently-stored string. char* sv_gets(SV* sv, PerlIO* fp, I32 append)','name' => 'sv_gets'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'SvPVutf8x' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'sv_collxfrm' => {'text' => 'Add Collate Transform magic to an SV if it doesn\'t already have it. Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the scalar data of the variable, but transformed to such a format that a normal memory comparison can be used to compare the data according to the locale settings. char* sv_collxfrm(SV* sv, STRLEN* nxp)','name' => 'sv_collxfrm'},'sv_2cv' => {'text' => 'Using various gambits, try to get a CV from an SV; in addition, try if possible to set C<*st> and C<*gvp> to the stash and GV associated with it. CV* sv_2cv(SV* sv, HV** st, GV** gvp, I32 lref)','name' => 'sv_2cv'},'SvPV_force_nomg' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. Doesn\'t process magic. char* SvPV_force_nomg(SV* sv, STRLEN len)','name' => 'SvPV_force_nomg'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. Will also turn off the UTF-8 status. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'POPpx' => {'text' => 'Pops a string off the stack. Requires a variable STRLEN n_a in scope. char* POPpx','name' => 'POPpx'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'sv_uv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. UV sv_uv(SV* sv)','name' => 'sv_uv'},'sv_pvbyte' => {'text' => 'Use C instead. char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'hv_fetch' => {'text' => '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 an C. See L for more information on how to use this function on tied hashes. SV** hv_fetch(HV* tb, const char* key, I32 klen, I32 lval)','name' => 'hv_fetch'},'Zero' => {'text' => '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)','name' => 'Zero'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_unref_flags' => {'text' => '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. The C argument can contain C to force the reference count to be decremented (otherwise the decrementing is conditional on the reference count being different from one or the reference being a readonly SV). See C. void sv_unref_flags(SV* sv, U32 flags)','name' => 'sv_unref_flags'},'sv_iv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. IV sv_iv(SV* sv)','name' => 'sv_iv'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'Nullch' => {'text' => 'Null character pointer.','name' => 'Nullch'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)','name' => 'mg_copy'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C flag on this RV; give the referred-to SV C magic if it hasn\'t already; and push a back-reference to this RV onto the array of backreferences associated with that magic. SV* sv_rvweaken(SV *sv)','name' => 'sv_rvweaken'},'grok_oct' => {'text' => 'UV grok_oct(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_oct'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'scan_hex' => {'text' => 'For backwards compatibility. Use C instead. NV scan_hex(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_hex'},'newSVpvn' => {'text' => '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)','name' => 'newSVpvn'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the supplied vtable and returns pointer to the magic added. Note that sv_magicext will allow things that sv_magic will not. In particular you can add magic to SvREADONLY SVs and and more than one instance of the same \'how\' I C is greater then zero then a savepvn() I of C is stored, if C is zero then C is stored as-is and - as another special case - if C<(name && namelen == HEf_SVKEY)> then C is assumed to contain an C and has its REFCNT incremented (This is now used as a subroutine by sv_magic.) MAGIC * sv_magicext(SV* sv, SV* obj, int how, MGVTBL *vtbl, const char* name, I32 namlen )','name' => 'sv_magicext'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C.','name' => 'SVt_PVCV'},'av_push' => {'text' => '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)','name' => 'av_push'},'unpackstring' => {'text' => 'The engine implementing unpack() Perl function. I32 unpackstring(char *pat, char *patend, char *s, char *strend, U32 flags)','name' => 'unpackstring'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV* ar, I32 key)','name' => 'av_extend'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV *sv)','name' => 'newRV_noinc'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpviv_mg(SV *sv, IV iv)','name' => 'sv_setpviv_mg'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'sv_2bool' => {'text' => 'This function is only called on magical items, and is only used by sv_true() or its macro equivalent. bool sv_2bool(SV* sv)','name' => 'sv_2bool'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. You may call C or C 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 C, so you must not discard your iterator immediately else the entry will leak - call C to trigger the resource deallocation. HE* hv_iternext(HV* tb)','name' => 'hv_iternext'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'sv_newmortal' => {'text' => 'Creates a new null SV which is mortal. The reference count of the SV is set to 1. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_newmortal()','name' => 'sv_newmortal'},'sv_clear' => {'text' => 'Clear an SV: call any destructors, free up any memory used by the body, and free the body itself. The SV\'s head is I freed, although its type is set to all 1\'s so that it won\'t inadvertently be assumed to be live during global destruction etc. This function should only be called when REFCNT is zero. Most of the time you\'ll want to call C (or its macro wrapper C) instead. void sv_clear(SV* sv)','name' => 'sv_clear'},'hv_iterinit' => {'text' => '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)','name' => 'hv_iterinit'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.008001', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_008_004.pm0000644000175000017500000034745511653441731021003 0ustar tseetseepackage Perl::APIReference::V5_008_004; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'SvOOK' => {'text' => '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)','name' => 'SvOOK'},'hv_store_ent' => {'text' => '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. Effectively a successful hv_store_ent takes ownership of one reference to C. 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 C; unlike C it does not take ownership of it, so maintaining the correct reference count on C 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 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)','name' => 'hv_store_ent'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package, which must be a valid UTF-8 string. See C. HV* gv_stashsv(SV* sv, I32 create)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'strGE' => {'text' => '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)','name' => 'strGE'},'form' => {'text' => '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, ...)','name' => 'form'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified version becoming C. Handles \'get\' magic. See also C for a version which guarantees to evaluate sv only once. char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'is_utf8_string' => {'text' => 'Returns true if first C bytes of the given string form a valid UTF-8 string, false otherwise. Note that \'a valid UTF-8 string\' does not mean \'a string that contains code points above 0x7F encoded in UTF-8\' because a valid ASCII string is a valid UTF-8 string. bool is_utf8_string(U8 *s, STRLEN len)','name' => 'is_utf8_string'},'svtype' => {'text' => '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.','name' => 'svtype'},'hv_clear' => {'text' => 'Clears a hash, making it empty. void hv_clear(HV* tb)','name' => 'hv_clear'},'get_hv' => {'text' => '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)','name' => 'get_hv'},'load_module' => {'text' => '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 C. The optional trailing SV* arguments can be used to specify arguments to the module\'s import() method, similar to C. void load_module(U32 flags, SV* name, SV* ver, ...)','name' => 'load_module'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES;','name' => 'XSRETURN_YES'},'sv_nv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. NV sv_nv(SV* sv)','name' => 'sv_nv'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'Poison' => {'text' => '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)','name' => 'Poison'},'sv_insert' => {'text' => '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)','name' => 'sv_insert'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_catpvf_mg'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'SvPOK' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. bool SvPOK(SV* sv)','name' => 'SvPOK'},'get_sv' => {'text' => '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)','name' => 'get_sv'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. See C. void PUSHu(UV uv)','name' => 'PUSHu'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. (Uses C). SV* newSVsv(SV* old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C. void hv_magic(HV* hv, GV* gv, int how)','name' => 'hv_magic'},'SvPVutf8' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *sv, const char *ptr)','name' => 'sv_setpv_mg'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C.','name' => 'XS'},'scan_oct' => {'text' => 'For backwards compatibility. Use C instead. NV scan_oct(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_oct'},'sv_setpvn' => {'text' => '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)','name' => 'sv_setpvn'},'sv_2mortal' => {'text' => 'Marks an existing SV as mortal. The SV will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_2mortal(SV* sv)','name' => 'sv_2mortal'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'newSVrv' => {'text' => '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)','name' => 'newSVrv'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself. void av_undef(AV* ar)','name' => 'av_undef'},'HeKEY' => {'text' => '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)','name' => 'HeKEY'},'pack_cat' => {'text' => '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)','name' => 'pack_cat'},'utf8n_to_uvuni' => {'text' => 'Bottom level UTF-8 decode routine. Returns the unicode code point value of the first character in the string C which is assumed to be in UTF-8 encoding and no longer than C; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, the behaviour is dependent on the value of C: if it contains UTF8_CHECK_ONLY, it is assumed that the caller will raise a warning, and this function will silently just set C to C<-1> and return zero. If the C does not contain UTF8_CHECK_ONLY, warnings about malformations will be given, C will be set to the expected length of the UTF-8 character in bytes, and zero will be returned. The C can also contain various flags to allow deviations from the strict UTF-8 encoding (see F). Most code should use utf8_to_uvchr() rather than call this directly. UV utf8n_to_uvuni(U8 *s, STRLEN curlen, STRLEN* retlen, U32 flags)','name' => 'utf8n_to_uvuni'},'sv_cmp' => {'text' => '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. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp(SV* sv1, SV* sv2)','name' => 'sv_cmp'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'SvEND' => {'text' => '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)','name' => 'SvEND'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C to type C if necessary, then adds a new magic item of type C to the head of the magic list. void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen)','name' => 'sv_magic'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C, C or C for void, scalar or list context, respectively. U32 GIMME_V','name' => 'GIMME_V'},'sv_force_normal_flags' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. The C parameter gets passed to C when unrefing. C calls this function with flags set to 0. void sv_force_normal_flags(SV *sv, U32 flags)','name' => 'sv_force_normal_flags'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'sv_setsv_flags' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. If the C parameter has the C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You probably want to use one of the assortment of wrappers, such as C, C, C and C. This is the primary function for copying scalars, and most other copy-ish functions and macros use this underneath. void sv_setsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_setsv_flags'},'sv_utf8_upgrade_flags' => {'text' => 'Convert the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade_flags(SV *sv, I32 flags)','name' => 'sv_utf8_upgrade_flags'},'New' => {'text' => 'The XSUB-writer\'s interface to the C C function. void New(int id, void* ptr, int nitems, type)','name' => 'New'},'is_utf8_char' => {'text' => 'Tests if some arbitrary number of bytes begins in a valid UTF-8 character. Note that an INVARIANT (i.e. ASCII) character is a valid UTF-8 character. The actual number of bytes in the UTF-8 character will be returned if it is valid, otherwise 0. STRLEN is_utf8_char(U8 *p)','name' => 'is_utf8_char'},'Copy' => {'text' => '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)','name' => 'Copy'},'ibcmp_utf8' => {'text' => 'Return true if the strings s1 and s2 differ case-insensitively, false if not (if they are equal case-insensitively). If u1 is true, the string s1 is assumed to be in UTF-8-encoded Unicode. If u2 is true, the string s2 is assumed to be in UTF-8-encoded Unicode. If u1 or u2 are false, the respective string is assumed to be in native 8-bit encoding. If the pe1 and pe2 are non-NULL, the scanning pointers will be copied in there (they will point at the beginning of the I character). If the pointers behind pe1 or pe2 are non-NULL, they are the end pointers beyond which scanning will not continue under any circustances. If the byte lengths l1 and l2 are non-zero, s1+l1 and s2+l2 will be used as goal end pointers that will also stop the scan, and which qualify towards defining a successful match: all the scans that define an explicit length must reach their goal pointers for a match to succeed). For case-insensitiveness, the "casefolding" of Unicode is used instead of upper/lowercasing both the characters, see http://www.unicode.org/unicode/reports/tr21/ (Case Mappings). I32 ibcmp_utf8(const char* a, char **pe1, UV l1, bool u1, const char* b, char **pe2, UV l2, bool u2)','name' => 'ibcmp_utf8'},'CvSTASH' => {'text' => 'Returns the stash of the CV. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'sv_taint' => {'text' => 'Taint an SV. Use C instead. void sv_taint(SV* sv)','name' => 'sv_taint'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. The target SV physically takes over ownership of the body of the source SV and inherits its flags; however, the target keeps any magic it owns, and any magic in the source is discarded. Note that this is a rather specialist SV copying operation; most of the time you\'ll want to use C or one of its many macro front-ends. void sv_replace(SV* sv, SV* nsv)','name' => 'sv_replace'},'utf8n_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. Allows length and flags to be passed to low level routine. UV utf8n_to_uvchr(U8 *s, STRLEN curlen, STRLEN* retlen, U32 flags)','name' => 'utf8n_to_uvchr'},'sv_utf8_upgrade' => {'text' => 'Convert the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Always sets the SvUTF8 flag to avoid future validity checks even if all the bytes have hibit clear. This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains a signed integer. bool SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and L.','name' => 'G_ARRAY'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. Sets up the C and C variables by calling C and C. This is usually handled automatically by C. dXSARGS;','name' => 'dXSARGS'},'sv_2iv' => {'text' => 'Return the integer value of an SV, doing any necessary string conversion, magic etc. Normally used via the C and C macros. IV sv_2iv(SV* sv)','name' => 'sv_2iv'},'savesharedpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* ptr)','name' => 'Safefree'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the C C is whitespace. bool isSPACE(char ch)','name' => 'isSPACE'},'SvROK' => {'text' => 'Tests if the SV is an RV. bool SvROK(SV* sv)','name' => 'SvROK'},'sv_unref' => {'text' => '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. This is C with the C being zero. See C. void sv_unref(SV* sv)','name' => 'sv_unref'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dstr, SV *sstr)','name' => 'sv_catsv_mg'},'call_argv' => {'text' => '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)','name' => 'call_argv'},'SvPV_nolen' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified form becoming C. Handles \'get\' magic. char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'perl_clone' => {'text' => '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 C, 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)','name' => 'perl_clone'},'sv_setnv' => {'text' => 'Copies a double into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setnv(SV* sv, NV num)','name' => 'sv_setnv'},'sv_2nv' => {'text' => 'Return the num value of an SV, doing any necessary string or integer conversion, magic etc. Normally used via the C and C macros. NV sv_2nv(SV* sv)','name' => 'sv_2nv'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'XPUSHp' => {'text' => '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)','name' => 'XPUSHp'},'sv_utf8_encode' => {'text' => 'Convert the PV of an SV to UTF-8-encoded, but then turn off the C flag so that it looks like octets again. Used as a building block for encode_utf8 in Encode.xs void sv_utf8_encode(SV *sv)','name' => 'sv_utf8_encode'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1. HV* newHV()','name' => 'newHV'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or false. bool strNE(char* s1, char* s2)','name' => 'strNE'},'SvUTF8_on' => {'text' => 'Turn on the UTF-8 status of an SV (the data is not changed, just the flag). Do not use frivolously. void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_setpvn_mg'},'sv_pvutf8n_force' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n_force(SV* sv, STRLEN* lp)','name' => 'sv_pvutf8n_force'},'savepv' => {'text' => 'Perl\'s version of C. Returns a pointer to a newly allocated string which is a duplicate of C. The size of the string is determined by C. The memory allocated for the new string can be freed with the C function. char* savepv(const char* pv)','name' => 'savepv'},'toLOWER' => {'text' => 'Converts the specified character to lowercase. char toLOWER(char ch)','name' => 'toLOWER'},'bytes_from_utf8' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike but like C, returns a pointer to the newly-created string, and updates C to contain the new length. Returns the original string if no conversion occurs, C is unchanged. Do nothing if C points to 0. Sets C to 0 if C is converted or contains all 7bit characters. NOTE: this function is experimental and may change or be removed without notice. U8* bytes_from_utf8(U8 *s, STRLEN *len, bool *is_utf8)','name' => 'bytes_from_utf8'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1. AV* newAV()','name' => 'newAV'},'POPp' => {'text' => 'Pops a string off the stack. Deprecated. New code should provide a STRLEN n_a and use POPpx. char* POPp','name' => 'POPp'},'HvNAME' => {'text' => 'Returns the package name of a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV of the sv is assumed to be octets in that encoding, and the sv will be converted into Unicode (and UTF-8). If the sv already is UTF-8 (or if it is not POK), or if the encoding is not a reference, nothing is done to the sv. If the encoding is not an C Encoding object, bad things will happen. (See F and L). The PV of the sv is returned. char* sv_recode_to_utf8(SV* sv, SV *encoding)','name' => 'sv_recode_to_utf8'},'av_make' => {'text' => '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)','name' => 'av_make'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. See C for a version which guarantees to evaluate sv only once. UV SvUV(SV* sv)','name' => 'SvUV'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L. int perl_run(PerlInterpreter* interp)','name' => 'perl_run'},'sv_pvbyten' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten(SV *sv, STRLEN *len)','name' => 'sv_pvbyten'},'sv_catsv_flags' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. If C has C bit set, will C on the SVs if appropriate, else not. C and C are implemented in terms of this function. void sv_catsv_flags(SV* dsv, SV* ssv, I32 flags)','name' => 'sv_catsv_flags'},'Nullav' => {'text' => 'Null AV pointer.','name' => 'Nullav'},'sv_copypv' => {'text' => 'Copies a stringified representation of the source SV into the destination SV. Automatically performs any necessary mg_get and coercion of numeric values into strings. Guaranteed to preserve UTF-8 flag even from overloaded objects. Similar in nature to sv_2pv[_flags] but operates directly on an SV instead of just the string. Mostly uses sv_2pv_flags to do its work, except when that would lose the UTF-8\'ness of the PV. void sv_copypv(SV* dsv, SV* ssv)','name' => 'sv_copypv'},'sv_pv' => {'text' => 'Use the C macro instead char* sv_pv(SV *sv)','name' => 'sv_pv'},'SvPVutf8_nolen' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_nolen(SV* sv)','name' => 'SvPVutf8_nolen'},'sv_setpviv' => {'text' => '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)','name' => 'sv_setpviv'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setnv_mg(SV *sv, NV num)','name' => 'sv_setnv_mg'},'sv_true' => {'text' => 'Returns true if the SV has a true value by Perl\'s rules. Use the C macro instead, which may call C or may instead use an in-line version. I32 sv_true(SV *sv)','name' => 'sv_true'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV* hv, char** key, I32* retlen)','name' => 'hv_iternextsv'},'utf8_to_bytes' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding. Unlike C, this over-writes the original string, and updates len to contain the new length. Returns zero on failure, setting C to -1. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_pvbyten_force' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvbyten_force(SV* sv, STRLEN* lp)','name' => 'sv_pvbyten_force'},'sv_derived_from' => {'text' => '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)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. See also C. I32 sv_cmp_locale(SV* sv1, SV* sv2)','name' => 'sv_cmp_locale'},'uvuni_to_utf8_flags' => {'text' => 'Adds the UTF-8 representation of the Unicode codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvuni_to_utf8_flags(d, uv, flags); or, in most cases, d = uvuni_to_utf8(d, uv); (which is equivalent to) d = uvuni_to_utf8_flags(d, uv, 0); is the recommended Unicode-aware way of saying *(d++) = uv; U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)','name' => 'uvuni_to_utf8_flags'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'hv_exists' => {'text' => '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, I32 klen)','name' => 'hv_exists'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See L.','name' => 'G_DISCARD'},'Nullsv' => {'text' => 'Null SV pointer.','name' => 'Nullsv'},'mg_length' => {'text' => 'Report on the SV\'s length. See C. U32 mg_length(SV* sv)','name' => 'mg_length'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'SvPVX' => {'text' => 'Returns a pointer to the physical string in the SV. The SV must contain a string. char* SvPVX(SV* sv)','name' => 'SvPVX'},'XST_mNV' => {'text' => '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)','name' => 'XST_mNV'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. See C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'HEf_SVKEY' => {'text' => 'This flag, used in the length slot of hash entries and magic structures, specifies the structure contains an C pointer where a C pointer is to be expected. (For information only--not to be used).','name' => 'HEf_SVKEY'},'pad_sv' => {'text' => '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)','name' => 'pad_sv'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C in characters. Stops at C (inclusive). If C s> or if the scan would end up past C, croaks. STRLEN utf8_length(U8* s, U8 *e)','name' => 'utf8_length'},'SvPVutf8_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8_force(SV* sv, STRLEN len)','name' => 'SvPVutf8_force'},'sv_2pvutf8_nolen' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8_nolen(SV* sv)','name' => 'sv_2pvutf8_nolen'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted if tainting is enabled. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'SvIOK_only_UV' => {'text' => 'Tells and SV that it is an unsigned integer and disables all other OK bits. void SvIOK_only_UV(SV* sv)','name' => 'SvIOK_only_UV'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C.','name' => 'SVt_NV'},'sv_nolocking' => {'text' => '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 *)','name' => 'sv_nolocking'},'sv_vcatpvfn' => {'text' => '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). Usually used via one of its frontends C and C. void sv_vcatpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vcatpvfn'},'SvPVbytex' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex(SV* sv, STRLEN len)','name' => 'SvPVbytex'},'av_store' => {'text' => '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)','name' => 'av_store'},'sv_2uv' => {'text' => 'Return the unsigned integer value of an SV, doing any necessary string conversion, magic etc. Normally used via the C and C macros. UV sv_2uv(SV* sv)','name' => 'sv_2uv'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and L. PUSHMARK;','name' => 'PUSHMARK'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. SV* ST(int ix)','name' => 'ST'},'strLT' => {'text' => '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)','name' => 'strLT'},'sv_pvutf8n' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvutf8n(SV *sv, STRLEN *len)','name' => 'sv_pvutf8n'},'call_pv' => {'text' => '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)','name' => 'call_pv'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. SV* av_shift(AV* ar)','name' => 'av_shift'},'newSV' => {'text' => 'Create a new null SV, or if len > 0, create a new empty SVt_PV type SV with an initial PV allocation of len+1. Normally accessed via the C macro. SV* newSV(STRLEN len)','name' => 'newSV'},'av_fetch' => {'text' => '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)','name' => 'av_fetch'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'gv_fetchmeth_autoload' => {'text' => '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 C. 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)','name' => 'gv_fetchmeth_autoload'},'sv_2pvutf8' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV, and set *lp to its length. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8(SV* sv, STRLEN* lp)','name' => 'sv_2pvutf8'},'sv_nounlocking' => {'text' => '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 *)','name' => 'sv_nounlocking'},'dITEMS' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dITEMS;','name' => 'dITEMS'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV* tb, HE* entry)','name' => 'hv_iterval'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. char* sv_reftype(SV* sv, int ob)','name' => 'sv_reftype'},'sv_pos_b2u' => {'text' => 'Converts the value pointed to by offsetp from a count of bytes from the start of the string, to a count of the equivalent number of UTF-8 chars. Handles magic and type coercion. void sv_pos_b2u(SV* sv, I32* offsetp)','name' => 'sv_pos_b2u'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C.','name' => 'SVt_IV'},'av_len' => {'text' => 'Returns the highest index in the array. Returns -1 if the array is empty. I32 av_len(AV* ar)','name' => 'av_len'},'SvIsCOW' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write. (either shared hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for COW) bool SvIsCOW(SV* sv)','name' => 'SvIsCOW'},'sv_unmagic' => {'text' => 'Removes all magic of type C from an SV. int sv_unmagic(SV* sv, int type)','name' => 'sv_unmagic'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *sv, IV i)','name' => 'sv_setiv_mg'},'sv_catsv' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catsv(SV* dsv, SV* ssv)','name' => 'sv_catsv'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled. void SvTAINT(SV* sv)','name' => 'SvTAINT'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C. See C and L for other uses. PUTBACK;','name' => 'PUTBACK'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'ax' => {'text' => 'Variable which is setup by C to indicate the stack base offset, used by the C, C and C macros. The C macro must be called prior to setup the C variable. I32 ax','name' => 'ax'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'SvCUR_set' => {'text' => 'Set the length of the string which is in the SV. See C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'to_utf8_fold' => {'text' => 'Convert the UTF-8 encoded character at p to its foldcase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_FOLD+1 bytes since the foldcase version may be longer than the original character (up to three characters). The first character of the foldcased version is returned (but note, as explained above, that there may be more.) UV to_utf8_fold(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_fold'},'to_utf8_upper' => {'text' => 'Convert the UTF-8 encoded character at p to its uppercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the uppercase version may be longer than the original character (up to two characters). The first character of the uppercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_upper(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_upper'},'SvNOK' => {'text' => 'Returns a boolean indicating whether the SV contains a double. bool SvNOK(SV* sv)','name' => 'SvNOK'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. C should be a valid UTF-8 string. 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)','name' => 'gv_stashpv'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C, C, and L.','name' => 'G_SCALAR'},'SvPVutf8x_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x_force(SV* sv, STRLEN len)','name' => 'SvPVutf8x_force'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. See C. void PUSHi(IV iv)','name' => 'PUSHi'},'sv_reset' => {'text' => 'Underlying implementation for the C Perl function. Note that the perl-level function is vaguely deprecated. void sv_reset(char* s, HV* stash)','name' => 'sv_reset'},'hv_exists_ent' => {'text' => '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)','name' => 'hv_exists_ent'},'to_utf8_lower' => {'text' => 'Convert the UTF-8 encoded character at p to its lowercase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the lowercase version may be longer than the original character (up to two characters). The first character of the lowercased version is returned (but note, as explained above, that there may be more.) UV to_utf8_lower(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_lower'},'SvNIOK' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. bool SvNIOK(SV* sv)','name' => 'SvNIOK'},'sv_2pv_flags' => {'text' => 'Returns a pointer to the string value of an SV, and sets *lp to its length. If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string if necessary. Normally invoked via the C macro. C and C usually end up here too. char* sv_2pv_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_2pv_flags'},'SvTAINTED_off' => {'text' => '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)','name' => 'SvTAINTED_off'},'SvNVx' => {'text' => 'Coerces the given SV to a double and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. NV SvNVx(SV* sv)','name' => 'SvNVx'},'unpack_str' => {'text' => '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)','name' => 'unpack_str'},'newSVpvf' => {'text' => 'Creates a new SV and initializes it with the string formatted like C. SV* newSVpvf(const char* pat, ...)','name' => 'newSVpvf'},'require_pv' => {'text' => 'Tells Perl to C the file named by the string argument. It is analogous to the Perl code C. 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)','name' => 'require_pv'},'sv_upgrade' => {'text' => 'Upgrade an SV to a more complex form. Generally adds a new body type to the SV, then copies across as much information as possible from the old body. You generally want to use the C macro wrapper. See also C. bool sv_upgrade(SV* sv, U32 mt)','name' => 'sv_upgrade'},'strEQ' => {'text' => 'Test two strings to see if they are equal. Returns true or false. bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C wrapper instead. SV* sv_newref(SV* sv)','name' => 'sv_newref'},'hv_store' => {'text' => '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. Effectively a successful hv_store takes ownership of one reference to C. 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 L 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)','name' => 'hv_store'},'SvIVX' => {'text' => 'Returns the raw value in the SV\'s IV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. IV SvIVX(SV* sv)','name' => 'SvIVX'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L. int perl_destruct(PerlInterpreter* interp)','name' => 'perl_destruct'},'sv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the scalar sv, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument is as in pv_uni_display(). The pointer to the PV of the dsv is returned. char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim, UV flags)','name' => 'sv_uni_display'},'isUPPER' => {'text' => 'Returns a boolean indicating whether the C C is an uppercase character. bool isUPPER(char ch)','name' => 'isUPPER'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C into the destination SV C. The source SV may be destroyed if it is mortal, so don\'t use this function if the source SV needs to be reused. Does not handle \'set\' magic. Loosely speaking, it performs a copy-by-value, obliterating any previous content of the destination. You probably want to use one of the assortment of wrappers, such as C, C, C and C. void sv_setsv(SV* dsv, SV* ssv)','name' => 'sv_setsv'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the stack. void XST_mYES(int pos)','name' => 'XST_mYES'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C for a version which guarantees to evaluate sv only once. NV SvNV(SV* sv)','name' => 'SvNV'},'packlist' => {'text' => 'The engine implementing pack() Perl function. void packlist(SV *cat, char *pat, char *patend, SV **beglist, SV **endlist)','name' => 'packlist'},'SvUTF8' => {'text' => 'Returns a boolean indicating whether the SV contains UTF-8 encoded data. bool SvUTF8(SV* sv)','name' => 'SvUTF8'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'sv_setsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setsv_mg(SV *dstr, SV *sstr)','name' => 'sv_setsv_mg'},'hv_fetch_ent' => {'text' => '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)','name' => 'hv_fetch_ent'},'isLOWER' => {'text' => 'Returns a boolean indicating whether the C C is a lowercase character. bool isLOWER(char ch)','name' => 'isLOWER'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See C. char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an XSUB\'s aliases was used to invoke it. See L. I32 ix','name' => 'ix'},'SvNOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a double. Checks the B setting. Use C. bool SvNOKp(SV* sv)','name' => 'SvNOKp'},'XSRETURN_UV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_UV(IV uv)','name' => 'XSRETURN_UV'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'cv_undef' => {'text' => 'Clear out all the active components of a CV. This can happen either by an explicit C, 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)','name' => 'cv_undef'},'PUSHs' => {'text' => '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)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setuv(SV* sv, UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'utf8_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvchr(U8 *s, STRLEN* retlen)','name' => 'utf8_to_uvchr'},'nothreadhook' => {'text' => 'Stub that provides thread hook for perl_destruct when there are no threads. int nothreadhook()','name' => 'nothreadhook'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'bytes_to_utf8' => {'text' => 'Converts a string C of length C from ASCII into UTF-8 encoding. Returns a pointer to the newly-created string, and sets C to reflect the new length. If you want to convert to UTF-8 from other encodings than ASCII, see sv_recode_to_utf8(). NOTE: this function is experimental and may change or be removed without notice. U8* bytes_to_utf8(U8 *s, STRLEN *len)','name' => 'bytes_to_utf8'},'sv_pvn' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn(SV *sv, STRLEN *len)','name' => 'sv_pvn'},'SvIsCOW_shared_hash' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write shared hash key scalar. bool SvIsCOW_shared_hash(SV* sv)','name' => 'SvIsCOW_shared_hash'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'dXSI32' => {'text' => 'Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. dXSI32;','name' => 'dXSI32'},'sv_setref_iv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_iv(SV* rv, const char* classname, IV iv)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => '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. Uses the "OOK hack". Beware: after this function returns, C and SvPVX(sv) may no longer refer to the same chunk of data. void sv_chop(SV* sv, char* ptr)','name' => 'sv_chop'},'SvPVx' => {'text' => 'A version of C which guarantees to evaluate sv only once. char* SvPVx(SV* sv, STRLEN len)','name' => 'SvPVx'},'sv_backoff' => {'text' => 'Remove any string offset. You should normally use the C macro wrapper instead. int sv_backoff(SV* sv)','name' => 'sv_backoff'},'sv_tainted' => {'text' => 'Test an SV for taintedness. Use C instead. bool sv_tainted(SV* sv)','name' => 'sv_tainted'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. If necessary, uses C and upgrades the SV to C. Returns a pointer to the character buffer. Use the C wrapper instead. char* sv_grow(SV* sv, STRLEN newlen)','name' => 'sv_grow'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. See C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setuv_mg(SV *sv, UV u)','name' => 'sv_setuv_mg'},'cv_const_sv' => {'text' => 'If C is a constant sub eligible for inlining. returns the constant value returned by the sub. Otherwise, returns NULL. Constant subs can be created with C or as described in L. SV* cv_const_sv(CV* cv)','name' => 'cv_const_sv'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually handled automatically by C. See C.','name' => 'XS_VERSION'},'newSVnv' => {'text' => '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)','name' => 'newSVnv'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. See C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry. SV* HeVAL(HE* he)','name' => 'HeVAL'},'PL_na' => {'text' => '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','name' => 'PL_na'},'HePV' => {'text' => '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)','name' => 'HePV'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the SV is set to 1. SV* newSViv(IV i)','name' => 'newSViv'},'sv_untaint' => {'text' => 'Untaint an SV. Use C instead. void sv_untaint(SV* sv)','name' => 'sv_untaint'},'sv_setpv' => {'text' => '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)','name' => 'sv_setpv'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See C.','name' => 'SVt_PVHV'},'pv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the string spv, length len, the displayable version being at most pvlim bytes long (if longer, the rest is truncated and "..." will be appended). The flags argument can have UNI_DISPLAY_ISPRINT set to display isPRINT()able characters as themselves, UNI_DISPLAY_BACKSLASH to display the \\\\[nrfta\\\\] as the backslashed versions (like \'\\n\') (UNI_DISPLAY_BACKSLASH is preferred over UNI_DISPLAY_ISPRINT for \\\\). UNI_DISPLAY_QQ (and its alias UNI_DISPLAY_REGEX) have both UNI_DISPLAY_BACKSLASH and UNI_DISPLAY_ISPRINT turned on. The pointer to the PV of the dsv is returned. char* pv_uni_display(SV *dsv, U8 *spv, STRLEN len, STRLEN pvlim, UV flags)','name' => 'pv_uni_display'},'gv_fetchmethod' => {'text' => 'See L. GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'SvGETMAGIC' => {'text' => 'Invokes C on an SV if it has \'get\' magic. This macro evaluates its argument more than once. void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'SvGROW' => {'text' => '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)','name' => 'SvGROW'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_inc(SV* sv)','name' => 'sv_inc'},'sv_usepvn' => {'text' => '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)','name' => 'sv_usepvn'},'SvPVbytex_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex_force(SV* sv, STRLEN len)','name' => 'SvPVbytex_force'},'sv_catpv' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpv(SV* sv, const char* ptr)','name' => 'sv_catpv'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'sv_len' => {'text' => 'Returns the length of the string in the SV. Handles magic and type coercion. See also C, which gives raw access to the xpv_cur slot. STRLEN sv_len(SV* sv)','name' => 'sv_len'},'warn' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Call this function the same way you call the C C function. See C. void warn(const char* pat, ...)','name' => 'warn'},'sv_pvutf8' => {'text' => 'Use the C macro instead char* sv_pvutf8(SV *sv)','name' => 'sv_pvutf8'},'SvPVbyte_nolen' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_nolen(SV* sv)','name' => 'SvPVbyte_nolen'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L. LEAVE;','name' => 'LEAVE'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See C.','name' => 'SVt_PVAV'},'hv_delete' => {'text' => '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, I32 klen, I32 flags)','name' => 'hv_delete'},'hv_undef' => {'text' => 'Undefines the hash. void hv_undef(HV* tb)','name' => 'hv_undef'},'SvSetMagicSV_nosteal' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetMagicSV_nosteal'},'hv_delete_ent' => {'text' => '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)','name' => 'hv_delete_ent'},'CLASS' => {'text' => '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','name' => 'CLASS'},'sv_isobject' => {'text' => '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)','name' => 'sv_isobject'},'Newc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Newc(int id, void* ptr, int nitems, type, cast)','name' => 'Newc'},'sv_pvn_force_flags' => {'text' => 'Get a sensible string out of the SV somehow. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. You normally want to use the various wrapper macros instead: see C and C char* sv_pvn_force_flags(SV* sv, STRLEN* lp, I32 flags)','name' => 'sv_pvn_force_flags'},'HeKLEN' => {'text' => '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)','name' => 'HeKLEN'},'to_utf8_title' => {'text' => 'Convert the UTF-8 encoded character at p to its titlecase version and store that in UTF-8 in ustrp and its length in bytes in lenp. Note that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the titlecase version may be longer than the original character (up to two characters). The first character of the titlecased version is returned (but note, as explained above, that there may be more.) UV to_utf8_title(U8 *p, U8* ustrp, STRLEN *lenp)','name' => 'to_utf8_title'},'sv_cat_decode' => {'text' => 'The encoding is assumed to be an Encode object, the PV of the ssv is assumed to be octets in that encoding and decoding the input starts from the position which (PV + *offset) pointed to. The dsv will be concatenated the decoded UTF-8 string from ssv. Decoding will terminate when the string tstr appears in decoding output or the input ends on the PV of the ssv. The value which the offset points will be modified to the last input position on the ssv. Returns TRUE if the terminator was found, else returns FALSE. bool sv_cat_decode(SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen)','name' => 'sv_cat_decode'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. See C. void PUSHn(NV nv)','name' => 'PUSHn'},'sv_setiv' => {'text' => 'Copies an integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setiv(SV* sv, IV num)','name' => 'sv_setiv'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it. See C for a version which guarantees to evaluate sv only once. IV SvIV(SV* sv)','name' => 'SvIV'},'sv_report_used' => {'text' => 'Dump the contents of all SVs not yet freed. (Debugging aid). void sv_report_used()','name' => 'sv_report_used'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. void EXTEND(SP, int nitems)','name' => 'EXTEND'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. SV PL_sv_yes','name' => 'PL_sv_yes'},'SvNVX' => {'text' => 'Returns the raw value in the SV\'s NV slot, without checks or conversions. Only use when you are sure SvNOK is true. See also C. NV SvNVX(SV* sv)','name' => 'SvNVX'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(UV u)','name' => 'newSVuv'},'gv_fetchmeth' => {'text' => '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)','name' => 'gv_fetchmeth'},'sv_nosharing' => {'text' => '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 *)','name' => 'sv_nosharing'},'SvUTF8_off' => {'text' => 'Unsets the UTF-8 status of an SV. void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'looks_like_number' => {'text' => 'Test if the content of an SV looks like a number (or is a number). C and C are treated as numbers (so will not issue a non-numeric warning), even if your atof() doesn\'t grok them. I32 looks_like_number(SV* sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpv_mg(SV *sv, const char *ptr)','name' => 'sv_catpv_mg'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. U32 HeHASH(HE* he)','name' => 'HeHASH'},'sv_setref_uv' => {'text' => 'Copies an unsigned 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 have a reference count of 1, and the RV will be returned. SV* sv_setref_uv(SV* rv, const char* classname, UV uv)','name' => 'sv_setref_uv'},'SvIOK' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. bool SvIOK(SV* sv)','name' => 'SvIOK'},'getcwd_sv' => {'text' => 'Fill the sv with current working directory int getcwd_sv(SV* sv)','name' => 'getcwd_sv'},'newSVpv' => {'text' => '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)','name' => 'newSVpv'},'sv_2pvbyte' => {'text' => 'Return a pointer to the byte-encoded representation of the SV, and set *lp to its length. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte(SV* sv, STRLEN* lp)','name' => 'sv_2pvbyte'},'fbm_instr' => {'text' => '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)','name' => 'fbm_instr'},'sv_setpvf' => {'text' => '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, ...)','name' => 'sv_setpvf'},'SvPV_force' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. See C. void XPUSHn(NV nv)','name' => 'XPUSHn'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part attributable to C. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'call_sv' => {'text' => '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)','name' => 'call_sv'},'SVt_PV' => {'text' => 'Pointer type flag for scalars. See C.','name' => 'SVt_PV'},'strGT' => {'text' => '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)','name' => 'strGT'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a string and disables all other OK bits, and leaves the UTF-8 status as it was. void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic after a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'},'sv_pos_u2b' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from the start of the string, to a count of the equivalent number of bytes; if lenp is non-zero, it does the same to lenp, but this time starting from the offset, rather than from the start of the string. Handles magic and type coercion. void sv_pos_u2b(SV* sv, I32* offsetp, I32* lenp)','name' => 'sv_pos_u2b'},'SvTRUE' => {'text' => '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)','name' => 'SvTRUE'},'HeSVKEY_set' => {'text' => '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)','name' => 'HeSVKEY_set'},'POPl' => {'text' => 'Pops a long off the stack. long POPl','name' => 'POPl'},'hv_iternext_flags' => {'text' => 'Returns entries from a hash iterator. See C and C. The C 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 C<&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)','name' => 'hv_iternext_flags'},'grok_hex' => {'text' => 'converts a string representing a hex number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first non-hex-digit character. On return I<*len> is set to the length scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0x" or "x" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the hex number may use \'_\' characters to separate digits. UV grok_hex(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_hex'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L. SPAGAIN;','name' => 'SPAGAIN'},'call_method' => {'text' => '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)','name' => 'call_method'},'SvLOCK' => {'text' => 'Arranges for a mutual exclusion lock to be obtained on sv if a suitable module has been loaded. void SvLOCK(SV* sv)','name' => 'SvLOCK'},'sv_vsetpvfn' => {'text' => 'Works like C but copies the text into the SV instead of appending it. Usually used via one of its frontends C and C. void sv_vsetpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vsetpvfn'},'get_cv' => {'text' => '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)','name' => 'get_cv'},'SvIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. Checks the B setting. Use C. bool SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the stack. void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'perl_parse' => {'text' => '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)','name' => 'perl_parse'},'to_utf8_case' => {'text' => 'The "p" contains the pointer to the UTF-8 string encoding the character that is being converted. The "ustrp" is a pointer to the character buffer to put the conversion result to. The "lenp" is a pointer to the length of the result. The "swashp" is a pointer to the swash to use. Both the special and normal mappings are stored lib/unicore/To/Foo.pl, and loaded by SWASHGET, using lib/utf8_heavy.pl. The special (usually, but not always, a multicharacter mapping), is tried first. The "special" is a string like "utf8::ToSpecLower", which means the hash %utf8::ToSpecLower. The access to the hash is through Perl_to_utf8_case(). The "normal" is a string like "ToLower" which means the swash %utf8::ToLower. UV to_utf8_case(U8 *p, U8* ustrp, STRLEN *lenp, SV **swash, char *normal, char *special)','name' => 'to_utf8_case'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory used by the array itself. void av_clear(AV* ar)','name' => 'av_clear'},'sv_force_normal' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg. See also C. void sv_force_normal(SV *sv)','name' => 'sv_force_normal'},'av_unshift' => {'text' => '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)','name' => 'av_unshift'},'SvUNLOCK' => {'text' => 'Releases a mutual exclusion lock on sv if a suitable module has been loaded. void SvUNLOCK(SV* sv)','name' => 'SvUNLOCK'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C. int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV (using C). The new SV is marked as mortal. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_mortalcopy(SV* oldsv)','name' => 'sv_mortalcopy'},'POPpbytex' => {'text' => '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','name' => 'POPpbytex'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. UV SvUVX(SV* sv)','name' => 'SvUVX'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See L.','name' => 'G_NOARGS'},'SvSetMagicSV' => {'text' => 'Like C, but does any set magic required afterwards. void SvSetMagicSV(SV* dsb, SV* ssv)','name' => 'SvSetMagicSV'},'sv_utf8_decode' => {'text' => 'Convert the octets in the PV from UTF-8 to chars. Scan for validity and then turn off SvUTF8 if needed so that we see characters. Used as a building block for decode_utf8 in Encode.xs NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_decode(SV *sv)','name' => 'sv_utf8_decode'},'Newz' => {'text' => '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)','name' => 'Newz'},'savepvn' => {'text' => 'Perl\'s version of what C would be if it existed. Returns a pointer to a newly allocated string which is a duplicate of the first C bytes from C. The memory allocated for the new string can be freed with the C function. char* savepvn(const char* pv, I32 len)','name' => 'savepvn'},'eval_sv' => {'text' => '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)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized. This relies on the fact that uninitialized array elements are set to C<&PL_sv_undef>. bool av_exists(AV* ar, I32 key)','name' => 'av_exists'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C. STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'Move' => {'text' => '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)','name' => 'Move'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'sv_catpvn_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. If C has C bit set, will C on C if appropriate, else not. C and C are implemented in terms of this function. void sv_catpvn_flags(SV* sv, const char* ptr, STRLEN len, I32 flags)','name' => 'sv_catpvn_flags'},'GIMME' => {'text' => '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','name' => 'GIMME'},'sv_bless' => {'text' => '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)','name' => 'sv_bless'},'NEWSV' => {'text' => '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)','name' => 'NEWSV'},'sv_isa' => {'text' => '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)','name' => 'sv_isa'},'isALNUM' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphanumeric character (including underscore) or digit. bool isALNUM(char ch)','name' => 'isALNUM'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs.','name' => 'newXS'},'sv_catpvf' => {'text' => 'Processes its arguments like C and appends the formatted output to an SV. If the appended data contains "wide" characters (including, but not limited to, SVs with a UTF-8 PV formatted with %s, and characters >255 formatted with %c), the original SV might get upgraded to UTF-8. 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, ...)','name' => 'sv_catpvf'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. bool SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C. void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'utf8_to_uvuni' => {'text' => 'Returns the Unicode code point of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. This function should only be used when returned UV is considered an index into the Unicode semantic tables (e.g. swashes). If C does not point to a well-formed UTF-8 character, zero is returned and retlen is set, if possible, to -1. UV utf8_to_uvuni(U8 *s, STRLEN* retlen)','name' => 'utf8_to_uvuni'},'sv_2io' => {'text' => 'Using various gambits, try to get an IO from an SV: the IO slot if its a GV; or the recursive result if we\'re an RV; or the IO slot of the symbol named after the PV if we\'re a string. IO* sv_2io(SV* sv)','name' => 'sv_2io'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphabetic character. bool isALPHA(char ch)','name' => 'isALPHA'},'Nullhv' => {'text' => 'Null HV pointer.','name' => 'Nullhv'},'av_fill' => {'text' => 'Ensure than an array has a given number of elements, equivalent to Perl\'s C<$#array = $fill;>. void av_fill(AV* ar, I32 fill)','name' => 'av_fill'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV. SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C. svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter* interp)','name' => 'perl_construct'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. void SvUOK(SV* sv)','name' => 'SvUOK'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion if necessary. Handles \'get\' magic. void sv_dec(SV* sv)','name' => 'sv_dec'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'strLE' => {'text' => '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)','name' => 'strLE'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'grok_bin' => {'text' => 'converts a string representing a binary number to numeric form. On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. On return I<*len> is set to the length scanned string, and I<*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 I<*result>. If the value is > UV_MAX C returns UV_MAX, sets C in the output flags, and writes the value to I<*result> (or the value is discarded if I is NULL). The hex number may optionally be prefixed with "0b" or "b" unless C is set in I<*flags> on entry. If C is set in I<*flags> then the binary number may use \'_\' characters to separate digits. UV grok_bin(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_bin'},'sv_2pvbyte_nolen' => {'text' => 'Return a pointer to the byte-encoded representation of the SV. May cause the SV to be downgraded from UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'SvOK' => {'text' => 'Returns a boolean indicating whether the value is an SV. bool SvOK(SV* sv)','name' => 'SvOK'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L. void perl_free(PerlInterpreter* interp)','name' => 'perl_free'},'sv_setref_nv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_nv(SV* rv, const char* classname, NV nv)','name' => 'sv_setref_nv'},'uvchr_to_utf8' => {'text' => 'Adds the UTF-8 representation of the Native codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uvchr_to_utf8(d, uv); is the recommended wide native character-aware way of saying *(d++) = uv; U8* uvchr_to_utf8(U8 *d, UV uv)','name' => 'uvchr_to_utf8'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C. MAGIC* mg_find(SV* sv, int type)','name' => 'mg_find'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII digit. bool isDIGIT(char ch)','name' => 'isDIGIT'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'eval_pv' => {'text' => '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)','name' => 'eval_pv'},'newSVpvn_share' => {'text' => 'Creates a new SV with its SvPVX pointing to a shared string in the string table. If the string does not already exist in the table, it is created first. Turns on READONLY and FAKE. The string\'s hash is stored in the UV slot of the SV; if the C parameter is non-zero, that value is used; otherwise the hash is computed. The idea here is that as the string table is used for shared hash keys these strings will have SvPVX == HeKEY and hash lookup will avoid string compare. SV* newSVpvn_share(const char* s, I32 len, U32 hash)','name' => 'newSVpvn_share'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_setpvf_mg'},'SvPOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. Checks the B setting. Use C. bool SvPOKp(SV* sv)','name' => 'SvPOKp'},'sv_free' => {'text' => 'Decrement an SV\'s reference count, and if it drops to zero, call C to invoke destructors and free up any memory used by the body; finally, deallocate the SV\'s head itself. Normally called via a wrapper macro C. void sv_free(SV* sv)','name' => 'sv_free'},'sv_catpvn' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The C indicates number of bytes to copy. If the SV has the UTF-8 status set, then the bytes appended should be valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn'},'SvPVbyte_force' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte_force(SV* sv, STRLEN len)','name' => 'SvPVbyte_force'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. CV* newCONSTSUB(HV* stash, char* name, SV* sv)','name' => 'newCONSTSUB'},'sv_setref_pv' => {'text' => '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 have a reference count of 1, and the RV will be returned. 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)','name' => 'sv_setref_pv'},'SvSHARE' => {'text' => 'Arranges for sv to be shared between threads if a suitable module has been loaded. void SvSHARE(SV* sv)','name' => 'SvSHARE'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_pop(AV* ar)','name' => 'av_pop'},'fbm_compile' => {'text' => '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)','name' => 'fbm_compile'},'sv_utf8_downgrade' => {'text' => 'Attempt to convert the PV of an SV from UTF-8-encoded to byte encoding. This may not be possible if the PV contains non-byte encoding characters; if this is the case, either returns false or, if C is not true, croaks. This is not as a general purpose Unicode to byte encoding interface: use the Encode extension for that. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_downgrade(SV *sv, bool fail_ok)','name' => 'sv_utf8_downgrade'},'SvNIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. Checks the B setting. Use C. bool SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'croak' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Normally call this function the same way you call the C C function. Calling C returns control directly to Perl, sidestepping the normal C order of execution. See C. If you want to throw an exception object, assign the object to C<$@> and then pass C to croak(): errsv = get_sv("@", TRUE); sv_setsv(errsv, exception_object); croak(Nullch); void croak(const char* pat, ...)','name' => 'croak'},'sortsv' => {'text' => '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)','name' => 'sortsv'},'THIS' => {'text' => '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','name' => 'THIS'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either forward or backward. WARNING: do not use the following unless you *know* C is within the UTF-8 data pointed to by C *and* that on entry C is aligned on the first byte of character or just after the last byte of a character. U8* utf8_hop(U8 *s, I32 off)','name' => 'utf8_hop'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide UTF-8 bytes as a single character. Handles magic and type coercion. STRLEN sv_len_utf8(SV* sv)','name' => 'sv_len_utf8'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually handled by C. void XSRETURN(int nitems)','name' => 'XSRETURN'},'sv_setref_pvn' => {'text' => '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 have a reference count of 1, and the RV will be returned. Note that C copies the pointer while this copies the string. SV* sv_setref_pvn(SV* rv, const char* classname, char* pv, STRLEN n)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for blessed scalars. See C.','name' => 'SVt_PVMG'},'PUSHp' => {'text' => '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)','name' => 'PUSHp'},'scan_bin' => {'text' => 'For backwards compatibility. Use C instead. NV scan_bin(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_bin'},'Nullcv' => {'text' => 'Null CV pointer.','name' => 'Nullcv'},'hv_clear_placeholders' => {'text' => '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 reaasigned 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)','name' => 'hv_clear_placeholders'},'dAX' => {'text' => 'Sets up the C variable. This is usually handled automatically by C by calling C. dAX;','name' => 'dAX'},'sv_2pv_nolen' => {'text' => 'Like C, but doesn\'t return the length too. You should usually use the macro wrapper C instead. char* sv_2pv_nolen(SV* sv)','name' => 'sv_2pv_nolen'},'get_av' => {'text' => '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)','name' => 'get_av'},'PL_sv_undef' => {'text' => 'This is the C SV. Always refer to this as C<&PL_sv_undef>. SV PL_sv_undef','name' => 'PL_sv_undef'},'SvPVbyte' => {'text' => 'Like C, but converts sv to byte representation first if necessary. char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'hv_iterkeysv' => {'text' => '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)','name' => 'hv_iterkeysv'},'grok_number' => {'text' => '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)','name' => 'grok_number'},'SvIVx' => {'text' => 'Coerces the given SV to an integer and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. IV SvIVx(SV* sv)','name' => 'SvIVx'},'grok_numeric_radix' => {'text' => 'Scan and skip for a numeric decimal separator (radix). bool grok_numeric_radix(const char **sp, const char *send)','name' => 'grok_numeric_radix'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the stack. void XST_mNO(int pos)','name' => 'XST_mNO'},'toUPPER' => {'text' => 'Converts the specified character to uppercase. char toUPPER(char ch)','name' => 'toUPPER'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array. Returns the deleted element. C is currently ignored. SV* av_delete(AV* ar, I32 key, I32 flags)','name' => 'av_delete'},'is_utf8_string_loc' => {'text' => 'Like is_ut8_string but store the location of the failure in the last argument. bool is_utf8_string_loc(U8 *s, STRLEN len, U8 **p)','name' => 'is_utf8_string_loc'},'utf8_distance' => {'text' => 'Returns the number of UTF-8 characters between the UTF-8 pointers C and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. IV utf8_distance(U8 *a, U8 *b)','name' => 'utf8_distance'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally appending to the currently-stored string. char* sv_gets(SV* sv, PerlIO* fp, I32 append)','name' => 'sv_gets'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'SvPVutf8x' => {'text' => 'Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'sv_collxfrm' => {'text' => 'Add Collate Transform magic to an SV if it doesn\'t already have it. Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the scalar data of the variable, but transformed to such a format that a normal memory comparison can be used to compare the data according to the locale settings. char* sv_collxfrm(SV* sv, STRLEN* nxp)','name' => 'sv_collxfrm'},'sv_2cv' => {'text' => 'Using various gambits, try to get a CV from an SV; in addition, try if possible to set C<*st> and C<*gvp> to the stash and GV associated with it. CV* sv_2cv(SV* sv, HV** st, GV** gvp, I32 lref)','name' => 'sv_2cv'},'SvPV_force_nomg' => {'text' => 'Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. Doesn\'t process magic. char* SvPV_force_nomg(SV* sv, STRLEN len)','name' => 'SvPV_force_nomg'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. Will also turn off the UTF-8 status. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'POPpx' => {'text' => 'Pops a string off the stack. Requires a variable STRLEN n_a in scope. char* POPpx','name' => 'POPpx'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'sv_uv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. UV sv_uv(SV* sv)','name' => 'sv_uv'},'sv_pvbyte' => {'text' => 'Use C instead. char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'hv_fetch' => {'text' => '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 an C. See L for more information on how to use this function on tied hashes. SV** hv_fetch(HV* tb, const char* key, I32 klen, I32 lval)','name' => 'hv_fetch'},'Zero' => {'text' => '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)','name' => 'Zero'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_unref_flags' => {'text' => '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. The C argument can contain C to force the reference count to be decremented (otherwise the decrementing is conditional on the reference count being different from one or the reference being a readonly SV). See C. void sv_unref_flags(SV* sv, U32 flags)','name' => 'sv_unref_flags'},'sv_iv' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. IV sv_iv(SV* sv)','name' => 'sv_iv'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'hv_scalar' => {'text' => 'Evaluates the hash in scalar context and returns the result. Handles magic when the hash is tied. SV* hv_scalar(HV* hv)','name' => 'hv_scalar'},'Nullch' => {'text' => 'Null character pointer.','name' => 'Nullch'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)','name' => 'mg_copy'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C flag on this RV; give the referred-to SV C magic if it hasn\'t already; and push a back-reference to this RV onto the array of backreferences associated with that magic. SV* sv_rvweaken(SV *sv)','name' => 'sv_rvweaken'},'grok_oct' => {'text' => 'UV grok_oct(char* start, STRLEN* len, I32* flags, NV *result)','name' => 'grok_oct'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'scan_hex' => {'text' => 'For backwards compatibility. Use C instead. NV scan_hex(char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_hex'},'newSVpvn' => {'text' => '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)','name' => 'newSVpvn'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the supplied vtable and returns pointer to the magic added. Note that sv_magicext will allow things that sv_magic will not. In particular you can add magic to SvREADONLY SVs and and more than one instance of the same \'how\' I C is greater then zero then a savepvn() I of C is stored, if C is zero then C is stored as-is and - as another special case - if C<(name && namelen == HEf_SVKEY)> then C is assumed to contain an C and has its REFCNT incremented (This is now used as a subroutine by sv_magic.) MAGIC * sv_magicext(SV* sv, SV* obj, int how, MGVTBL *vtbl, const char* name, I32 namlen )','name' => 'sv_magicext'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C.','name' => 'SVt_PVCV'},'av_push' => {'text' => '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)','name' => 'av_push'},'unpackstring' => {'text' => 'The engine implementing unpack() Perl function. C puts the extracted list items on the stack and returns the number of elements. Issue C before and C after the call to this function. I32 unpackstring(char *pat, char *patend, char *s, char *strend, U32 flags)','name' => 'unpackstring'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV* ar, I32 key)','name' => 'av_extend'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV *sv)','name' => 'newRV_noinc'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpviv_mg(SV *sv, IV iv)','name' => 'sv_setpviv_mg'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. Guarantees to evaluate sv only once. Use the more efficient C otherwise. UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'sv_2bool' => {'text' => 'This function is only called on magical items, and is only used by sv_true() or its macro equivalent. bool sv_2bool(SV* sv)','name' => 'sv_2bool'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. You may call C or C 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 C, so you must not discard your iterator immediately else the entry will leak - call C to trigger the resource deallocation. HE* hv_iternext(HV* tb)','name' => 'hv_iternext'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'sv_newmortal' => {'text' => 'Creates a new null SV which is mortal. The reference count of the SV is set to 1. It will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. See also C and C. SV* sv_newmortal()','name' => 'sv_newmortal'},'sv_clear' => {'text' => 'Clear an SV: call any destructors, free up any memory used by the body, and free the body itself. The SV\'s head is I freed, although its type is set to all 1\'s so that it won\'t inadvertently be assumed to be live during global destruction etc. This function should only be called when REFCNT is zero. Most of the time you\'ll want to call C (or its macro wrapper C) instead. void sv_clear(SV* sv)','name' => 'sv_clear'},'hv_iterinit' => {'text' => '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)','name' => 'hv_iterinit'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.008004', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_006_002.pm0000644000175000017500000021267011653441731020765 0ustar tseetseepackage Perl::APIReference::V5_006_002; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'SvOOK' => {'text' => '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)','name' => 'SvOOK'},'hv_store_ent' => {'text' => '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)','name' => 'hv_store_ent'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package, which must be a valid UTF-8 string. See C. HV* gv_stashsv(SV* sv, I32 create)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs.','name' => 'newXSproto'},'XSRETURN_NV' => {'text' => 'Return an double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'strGE' => {'text' => '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)','name' => 'strGE'},'SvPV' => {'text' => '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)','name' => 'SvPV'},'svtype' => {'text' => '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.','name' => 'svtype'},'is_utf8_string' => {'text' => 'Returns true if first C bytes of the given string form valid a UTF8 string, false otherwise. bool is_utf8_string(U8 *s, STRLEN len)','name' => 'is_utf8_string'},'hv_clear' => {'text' => 'Clears a hash, making it empty. void hv_clear(HV* tb)','name' => 'hv_clear'},'get_hv' => {'text' => '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)','name' => 'get_hv'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C. XSRETURN_YES;','name' => 'XSRETURN_YES'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'sv_insert' => {'text' => '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)','name' => 'sv_insert'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_catpvf_mg'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'SvPOK' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. bool SvPOK(SV* sv)','name' => 'SvPOK'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this element. See C. void PUSHu(UV uv)','name' => 'PUSHu'},'get_sv' => {'text' => '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)','name' => 'get_sv'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. SV* newSVsv(SV* old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C. void hv_magic(HV* hv, GV* gv, int how)','name' => 'hv_magic'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *sv, const char *ptr)','name' => 'sv_setpv_mg'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by C.','name' => 'XS'},'sv_setpvn' => {'text' => '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)','name' => 'sv_setpvn'},'sv_2mortal' => {'text' => 'Marks an SV as mortal. The SV will be destroyed when the current context ends. SV* sv_2mortal(SV* sv)','name' => 'sv_2mortal'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C. void mg_magical(SV* sv)','name' => 'mg_magical'},'newSVrv' => {'text' => '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)','name' => 'newSVrv'},'strnEQ' => {'text' => '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)','name' => 'strnEQ'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself. void av_undef(AV* ar)','name' => 'av_undef'},'HeKEY' => {'text' => '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)','name' => 'HeKEY'},'sv_cmp' => {'text' => '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)','name' => 'sv_cmp'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'SvEND' => {'text' => '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)','name' => 'SvEND'},'utf8_to_uv_simple' => {'text' => 'Returns the character value of the first character in the string C which is assumed to be in UTF8 encoding; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF8 character, zero is returned and retlen is set, if possible, to -1. NOTE: this function is experimental and may change or be removed without notice. UV utf8_to_uv_simple(U8 *s, STRLEN* retlen)','name' => 'utf8_to_uv_simple'},'sv_magic' => {'text' => 'Adds magic to an SV. void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen)','name' => 'sv_magic'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C, C or C for void, scalar or list context, respectively. U32 GIMME_V','name' => 'GIMME_V'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'New' => {'text' => 'The XSUB-writer\'s interface to the C C function. void New(int id, void* ptr, int nitems, type)','name' => 'New'},'is_utf8_char' => {'text' => 'Tests if some arbitrary number of bytes begins in a valid UTF-8 character. The actual number of bytes in the UTF-8 character will be returned if it is valid, otherwise 0. STRLEN is_utf8_char(U8 *p)','name' => 'is_utf8_char'},'Copy' => {'text' => '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)','name' => 'Copy'},'CvSTASH' => {'text' => 'Returns the stash of the CV. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. void sv_replace(SV* sv, SV* nsv)','name' => 'sv_replace'},'sv_utf8_upgrade' => {'text' => 'Convert the PV of an SV to its UTF8-encoded form. NOTE: this function is experimental and may change or be removed without notice. void sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains an signed integer. void SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and L.','name' => 'G_ARRAY'},'dXSARGS' => {'text' => '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;','name' => 'dXSARGS'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* ptr)','name' => 'Safefree'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the C C is whitespace. bool isSPACE(char ch)','name' => 'isSPACE'},'SvROK' => {'text' => 'Tests if the SV is an RV. bool SvROK(SV* sv)','name' => 'SvROK'},'sv_unref' => {'text' => '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)','name' => 'sv_unref'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dstr, SV *sstr)','name' => 'sv_catsv_mg'},'call_argv' => {'text' => '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)','name' => 'call_argv'},'SvPV_nolen' => {'text' => '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)','name' => 'SvPV_nolen'},'sv_setnv' => {'text' => 'Copies a double into the given SV. Does not handle \'set\' magic. See C. void sv_setnv(SV* sv, NV num)','name' => 'sv_setnv'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'XPUSHp' => {'text' => '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)','name' => 'XPUSHp'},'sv_utf8_encode' => {'text' => 'Convert the PV of an SV to UTF8-encoded, but then turn off the C flag so that it looks like bytes again. Nothing calls this. NOTE: this function is experimental and may change or be removed without notice. void sv_utf8_encode(SV *sv)','name' => 'sv_utf8_encode'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1. HV* newHV()','name' => 'newHV'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or false. bool strNE(char* s1, char* s2)','name' => 'strNE'},'SvUTF8_on' => {'text' => 'Tells an SV that it is a string and encoded in UTF8. Do not use frivolously. void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_setpvn_mg'},'sv_pvutf8n_force' => {'text' => 'Get a sensible UTF8-encoded string out of the SV somehow. See L. char* sv_pvutf8n_force(SV* sv, STRLEN* lp)','name' => 'sv_pvutf8n_force'},'savepv' => {'text' => 'Copy a string to a safe spot. This does not use an SV. char* savepv(const char* sv)','name' => 'savepv'},'toLOWER' => {'text' => 'Converts the specified character to lowercase. char toLOWER(char ch)','name' => 'toLOWER'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1. AV* newAV()','name' => 'newAV'},'bytes_from_utf8' => {'text' => 'Converts a string C of length C from UTF8 into byte encoding. Unlike but like C, returns a pointer to the newly-created string, and updates C to contain the new length. Returns the original string if no conversion occurs, C is unchanged. Do nothing if C points to 0. Sets C to 0 if C is converted or contains all 7bit characters. NOTE: this function is experimental and may change or be removed without notice. U8* bytes_from_utf8(U8 *s, STRLEN *len, bool *is_utf8)','name' => 'bytes_from_utf8'},'POPp' => {'text' => 'Pops a string off the stack. char* POPp','name' => 'POPp'},'HvNAME' => {'text' => 'Returns the package name of a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'av_make' => {'text' => '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)','name' => 'av_make'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. UV SvUV(SV* sv)','name' => 'SvUV'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L. int perl_run(PerlInterpreter* interp)','name' => 'perl_run'},'Nullav' => {'text' => 'Null AV pointer.','name' => 'Nullav'},'sv_setpviv' => {'text' => '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)','name' => 'sv_setpviv'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setnv_mg(SV *sv, NV num)','name' => 'sv_setnv_mg'},'sv_true' => {'text' => 'Returns true if the SV has a true value by Perl\'s rules. I32 sv_true(SV *sv)','name' => 'sv_true'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV* hv, char** key, I32* retlen)','name' => 'hv_iternextsv'},'utf8_to_bytes' => {'text' => 'Converts a string C of length C from UTF8 into byte encoding. Unlike C, this over-writes the original string, and updates len to contain the new length. Returns zero on failure, setting C to -1. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_derived_from' => {'text' => '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)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. See L I32 sv_cmp_locale(SV* sv1, SV* sv2)','name' => 'sv_cmp_locale'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'hv_exists' => {'text' => '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)','name' => 'hv_exists'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See L.','name' => 'G_DISCARD'},'Nullsv' => {'text' => 'Null SV pointer.','name' => 'Nullsv'},'mg_length' => {'text' => 'Report on the SV\'s length. See C. U32 mg_length(SV* sv)','name' => 'mg_length'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'SvPVX' => {'text' => 'Returns a pointer to the string in the SV. The SV must contain a string. char* SvPVX(SV* sv)','name' => 'SvPVX'},'XST_mNV' => {'text' => '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)','name' => 'XST_mNV'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. See C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'HEf_SVKEY' => {'text' => '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).','name' => 'HEf_SVKEY'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C in characters. Stops at C (inclusive). If C s> or if the scan would end up past C, croaks. NOTE: this function is experimental and may change or be removed without notice. STRLEN utf8_length(U8* s, U8 *e)','name' => 'utf8_length'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'SvIOK_only_UV' => {'text' => 'Tells and SV that it is an unsigned integer and disables all other OK bits. void SvIOK_only_UV(SV* sv)','name' => 'SvIOK_only_UV'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C.','name' => 'SVt_NV'},'sv_vcatpvfn' => {'text' => '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)','name' => 'sv_vcatpvfn'},'av_store' => {'text' => '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)','name' => 'av_store'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and L. PUSHMARK;','name' => 'PUSHMARK'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. SV* ST(int ix)','name' => 'ST'},'strLT' => {'text' => '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)','name' => 'strLT'},'call_pv' => {'text' => '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)','name' => 'call_pv'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. SV* av_shift(AV* ar)','name' => 'av_shift'},'av_fetch' => {'text' => '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)','name' => 'av_fetch'},'utf8_to_uv' => {'text' => 'Returns the character value of the first character in the string C which is assumed to be in UTF8 encoding and no longer than C; C will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF8 character, the behaviour is dependent on the value of C: if it contains UTF8_CHECK_ONLY, it is assumed that the caller will raise a warning, and this function will silently just set C to C<-1> and return zero. If the C does not contain UTF8_CHECK_ONLY, warnings about malformations will be given, C will be set to the expected length of the UTF-8 character in bytes, and zero will be returned. The C can also contain various flags to allow deviations from the strict UTF-8 encoding (see F). NOTE: this function is experimental and may change or be removed without notice. UV utf8_to_uv(U8 *s, STRLEN curlen, STRLEN* retlen, U32 flags)','name' => 'utf8_to_uv'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV* tb, HE* entry)','name' => 'hv_iterval'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. char* sv_reftype(SV* sv, int ob)','name' => 'sv_reftype'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C.','name' => 'SVt_IV'},'av_len' => {'text' => 'Returns the highest index in the array. Returns -1 if the array is empty. I32 av_len(AV* ar)','name' => 'av_len'},'sv_unmagic' => {'text' => 'Removes magic from an SV. int sv_unmagic(SV* sv, int type)','name' => 'sv_unmagic'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *sv, IV i)','name' => 'sv_setiv_mg'},'sv_catsv' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. Handles \'get\' magic, but not \'set\' magic. See C. void sv_catsv(SV* dsv, SV* ssv)','name' => 'sv_catsv'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled void SvTAINT(SV* sv)','name' => 'SvTAINT'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C. See C and L for other uses. PUTBACK;','name' => 'PUTBACK'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'SvCUR_set' => {'text' => 'Set the length of the string which is in the SV. See C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'SvNOK' => {'text' => 'Returns a boolean indicating whether the SV contains a double. bool SvNOK(SV* sv)','name' => 'SvNOK'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. C should be a valid UTF-8 string. 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)','name' => 'gv_stashpv'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C, C, and L.','name' => 'G_SCALAR'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. Handles \'set\' magic. See C. void PUSHi(IV iv)','name' => 'PUSHi'},'hv_exists_ent' => {'text' => '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)','name' => 'hv_exists_ent'},'SvNIOK' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. bool SvNIOK(SV* sv)','name' => 'SvNIOK'},'SvTAINTED_off' => {'text' => '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)','name' => 'SvTAINTED_off'},'newSVpvf' => {'text' => 'Creates a new SV an initialize it with the string formatted like C. SV* newSVpvf(const char* pat, ...)','name' => 'newSVpvf'},'require_pv' => {'text' => 'Tells Perl to C a module. NOTE: the perl_ form of this function is deprecated. void require_pv(const char* pv)','name' => 'require_pv'},'sv_upgrade' => {'text' => 'Upgrade an SV to a more complex form. Use C. See C. bool sv_upgrade(SV* sv, U32 mt)','name' => 'sv_upgrade'},'strEQ' => {'text' => 'Test two strings to see if they are equal. Returns true or false. bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'hv_store' => {'text' => '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)','name' => 'hv_store'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C. void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'SvIVX' => {'text' => 'Returns the integer which is stored in the SV, assuming SvIOK is true. IV SvIVX(SV* sv)','name' => 'SvIVX'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L. void perl_destruct(PerlInterpreter* interp)','name' => 'perl_destruct'},'isUPPER' => {'text' => 'Returns a boolean indicating whether the C C is an uppercase character. bool isUPPER(char ch)','name' => 'isUPPER'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the stack. void XST_mYES(int pos)','name' => 'XST_mYES'},'sv_setsv' => {'text' => '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)','name' => 'sv_setsv'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'POPs' => {'text' => 'Pops an SV off the stack. SV* POPs','name' => 'POPs'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. NV SvNV(SV* sv)','name' => 'SvNV'},'SvUTF8' => {'text' => 'Returns a boolean indicating whether the SV contains UTF-8 encoded data. void SvUTF8(SV* sv)','name' => 'SvUTF8'},'gv_fetchmethod_autoload' => {'text' => '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_autoload(HV* stash, const char* name, I32 autoload)','name' => 'gv_fetchmethod_autoload'},'sv_setsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setsv_mg(SV *dstr, SV *sstr)','name' => 'sv_setsv_mg'},'hv_fetch_ent' => {'text' => '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)','name' => 'hv_fetch_ent'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'isLOWER' => {'text' => 'Returns a boolean indicating whether the C C is a lowercase character. bool isLOWER(char ch)','name' => 'isLOWER'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are identical. I32 sv_eq(SV* sv1, SV* sv2)','name' => 'sv_eq'},'SvTAINTED' => {'text' => 'Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See C. char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'SvNOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a double. Checks the B setting. Use C. bool SvNOKp(SV* sv)','name' => 'SvNOKp'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an XSUB\'s aliases was used to invoke it. See L. I32 ix','name' => 'ix'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'PUSHs' => {'text' => '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)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV. Does not handle \'set\' magic. See C. void sv_setuv(SV* sv, UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'bytes_to_utf8' => {'text' => 'Converts a string C of length C from ASCII into UTF8 encoding. Returns a pointer to the newly-created string, and sets C to reflect the new length. NOTE: this function is experimental and may change or be removed without notice. U8* bytes_to_utf8(U8 *s, STRLEN *len)','name' => 'bytes_to_utf8'},'items' => {'text' => 'Variable which is setup by C to indicate the number of items on the stack. See L. I32 items','name' => 'items'},'XST_mPV' => {'text' => '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)','name' => 'XST_mPV'},'dXSI32' => {'text' => 'Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. dXSI32;','name' => 'dXSI32'},'sv_setref_iv' => {'text' => '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)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => '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)','name' => 'sv_chop'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. See C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_grow' => {'text' => '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)','name' => 'sv_grow'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setuv_mg(SV *sv, UV u)','name' => 'sv_setuv_mg'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually handled automatically by C. See C.','name' => 'XS_VERSION'},'newSVnv' => {'text' => '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)','name' => 'newSVnv'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not handle \'set\' magic. See C. void XPUSHs(SV* sv)','name' => 'XPUSHs'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry. SV* HeVAL(HE* he)','name' => 'HeVAL'},'HePV' => {'text' => '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)','name' => 'HePV'},'PL_na' => {'text' => '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','name' => 'PL_na'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the SV is set to 1. SV* newSViv(IV i)','name' => 'newSViv'},'sv_setpv' => {'text' => '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)','name' => 'sv_setpv'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See C.','name' => 'SVt_PVHV'},'uv_to_utf8' => {'text' => 'Adds the UTF8 representation of the Unicode codepoint C to the end of the string C; C should be have at least C free bytes available. The return value is the pointer to the byte after the end of the new character. In other words, d = uv_to_utf8(d, uv); is the recommended Unicode-aware way of saying *(d++) = uv; NOTE: this function is experimental and may change or be removed without notice. U8* uv_to_utf8(U8 *d, UV uv)','name' => 'uv_to_utf8'},'gv_fetchmethod' => {'text' => 'See L. GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'SvGETMAGIC' => {'text' => 'Invokes C on an SV if it has \'get\' magic. This macro evaluates its argument more than once. void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'SvGROW' => {'text' => '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)','name' => 'SvGROW'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV. void sv_inc(SV* sv)','name' => 'sv_inc'},'sv_usepvn' => {'text' => '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)','name' => 'sv_usepvn'},'sv_catpv' => {'text' => '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)','name' => 'sv_catpv'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'sv_len' => {'text' => 'Returns the length of the string in the SV. See also C. STRLEN sv_len(SV* sv)','name' => 'sv_len'},'warn' => {'text' => '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, ...)','name' => 'warn'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L. LEAVE;','name' => 'LEAVE'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See C.','name' => 'SVt_PVAV'},'hv_delete' => {'text' => '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)','name' => 'hv_delete'},'hv_undef' => {'text' => 'Undefines the hash. void hv_undef(HV* tb)','name' => 'hv_undef'},'hv_delete_ent' => {'text' => '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)','name' => 'hv_delete_ent'},'CLASS' => {'text' => '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','name' => 'CLASS'},'sv_isobject' => {'text' => '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)','name' => 'sv_isobject'},'Newc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with cast. void Newc(int id, void* ptr, int nitems, type, cast)','name' => 'Newc'},'HeKLEN' => {'text' => '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)','name' => 'HeKLEN'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Handles \'set\' magic. See C. void PUSHn(NV nv)','name' => 'PUSHn'},'sv_setiv' => {'text' => 'Copies an integer into the given SV. Does not handle \'set\' magic. See C. void sv_setiv(SV* sv, IV num)','name' => 'sv_setiv'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it. IV SvIV(SV* sv)','name' => 'SvIV'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. void EXTEND(SP, int nitems)','name' => 'EXTEND'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. SV PL_sv_yes','name' => 'PL_sv_yes'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. The reference count for the SV is set to 1. SV* newSVuv(UV u)','name' => 'newSVuv'},'SvNVX' => {'text' => 'Returns the double which is stored in the SV, assuming SvNOK is true. NV SvNVX(SV* sv)','name' => 'SvNVX'},'gv_fetchmeth' => {'text' => '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)','name' => 'gv_fetchmeth'},'SvUTF8_off' => {'text' => 'Unsets the UTF8 status of an SV. void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'looks_like_number' => {'text' => 'Test if an the content of an SV looks like a number (or is a number). I32 looks_like_number(SV* sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpv_mg(SV *sv, const char *ptr)','name' => 'sv_catpv_mg'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. U32 HeHASH(HE* he)','name' => 'HeHASH'},'SvIOK' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. bool SvIOK(SV* sv)','name' => 'SvIOK'},'newSVpv' => {'text' => '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)','name' => 'newSVpv'},'fbm_instr' => {'text' => '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)','name' => 'fbm_instr'},'sv_setpvf' => {'text' => '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, ...)','name' => 'sv_setpvf'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles \'set\' magic. See C. void XPUSHn(NV nv)','name' => 'XPUSHn'},'SvPV_force' => {'text' => '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)','name' => 'SvPV_force'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part attributable to C. See C. STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'call_sv' => {'text' => '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)','name' => 'call_sv'},'SVt_PV' => {'text' => 'Pointer type flag for scalars. See C.','name' => 'SVt_PV'},'strGT' => {'text' => '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)','name' => 'strGT'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a UTF8 string (do not use frivolously) and disables all other OK bits. void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic after a value is retrieved from the SV. See C. int mg_get(SV* sv)','name' => 'mg_get'},'SvTRUE' => {'text' => '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)','name' => 'SvTRUE'},'HeSVKEY_set' => {'text' => '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)','name' => 'HeSVKEY_set'},'POPl' => {'text' => 'Pops a long off the stack. long POPl','name' => 'POPl'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L. SPAGAIN;','name' => 'SPAGAIN'},'call_method' => {'text' => '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)','name' => 'call_method'},'sv_vsetpvfn' => {'text' => '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)','name' => 'sv_vsetpvfn'},'get_cv' => {'text' => '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)','name' => 'get_cv'},'SvIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. Checks the B setting. Use C. bool SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the stack. void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'perl_parse' => {'text' => '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)','name' => 'perl_parse'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory used by the array itself. void av_clear(AV* ar)','name' => 'av_clear'},'av_unshift' => {'text' => '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)','name' => 'av_unshift'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C. int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV. The new SV is marked as mortal. SV* sv_mortalcopy(SV* oldsv)','name' => 'sv_mortalcopy'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See L.','name' => 'G_NOARGS'},'SvUVX' => {'text' => 'Returns the unsigned integer which is stored in the SV, assuming SvIOK is true. UV SvUVX(SV* sv)','name' => 'SvUVX'},'Newz' => {'text' => '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)','name' => 'Newz'},'savepvn' => {'text' => '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)','name' => 'savepvn'},'eval_sv' => {'text' => '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)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and L. FREETMPS;','name' => 'FREETMPS'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized. This relies on the fact that uninitialized array elements are set to C<&PL_sv_undef>. bool av_exists(AV* ar, I32 key)','name' => 'av_exists'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C. STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'Move' => {'text' => '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)','name' => 'Move'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'GIMME' => {'text' => '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','name' => 'GIMME'},'NEWSV' => {'text' => '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)','name' => 'NEWSV'},'sv_bless' => {'text' => '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)','name' => 'sv_bless'},'sv_isa' => {'text' => '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)','name' => 'sv_isa'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs.','name' => 'newXS'},'isALNUM' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphanumeric character (including underscore) or digit. bool isALNUM(char ch)','name' => 'isALNUM'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. void SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'sv_catpvf' => {'text' => '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, ...)','name' => 'sv_catpvf'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C. void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphabetic character. bool isALPHA(char ch)','name' => 'isALPHA'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L. PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'Nullhv' => {'text' => 'Null HV pointer.','name' => 'Nullhv'},'av_fill' => {'text' => 'Ensure than an array has a given number of elements, equivalent to Perl\'s C<$#array = $fill;>. void av_fill(AV* ar, I32 fill)','name' => 'av_fill'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV. SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L. void perl_construct(PerlInterpreter* interp)','name' => 'perl_construct'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C. svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV. void sv_dec(SV* sv)','name' => 'sv_dec'},'strLE' => {'text' => '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)','name' => 'strLE'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L. void perl_free(PerlInterpreter* interp)','name' => 'perl_free'},'SvOK' => {'text' => 'Returns a boolean indicating whether the value is an SV. bool SvOK(SV* sv)','name' => 'SvOK'},'sv_setref_nv' => {'text' => '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)','name' => 'sv_setref_nv'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C. MAGIC* mg_find(SV* sv, int type)','name' => 'mg_find'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII digit. bool isDIGIT(char ch)','name' => 'isDIGIT'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'eval_pv' => {'text' => '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)','name' => 'eval_pv'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_setpvf_mg'},'SvPOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a character string. Checks the B setting. Use C. bool SvPOKp(SV* sv)','name' => 'SvPOKp'},'sv_free' => {'text' => 'Free the memory used by an SV. void sv_free(SV* sv)','name' => 'sv_free'},'sv_catpvn' => {'text' => '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)','name' => 'sv_catpvn'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is eligible for inlining at compile-time. void newCONSTSUB(HV* stash, char* name, SV* sv)','name' => 'newCONSTSUB'},'sv_setref_pv' => {'text' => '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)','name' => 'sv_setref_pv'},'fbm_compile' => {'text' => '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)','name' => 'fbm_compile'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array is empty. SV* av_pop(AV* ar)','name' => 'av_pop'},'sv_utf8_downgrade' => {'text' => 'Attempt to convert the PV of an SV from UTF8-encoded to byte encoding. This may not be possible if the PV contains non-byte encoding characters; if this is the case, either returns false or, if C is not true, croaks. NOTE: this function is experimental and may change or be removed without notice. bool sv_utf8_downgrade(SV *sv, bool fail_ok)','name' => 'sv_utf8_downgrade'},'SvNIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or double. Checks the B setting. Use C. bool SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'croak' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Normally use this function the same way you use the C C function. See C. If you want to throw an exception object, assign the object to C<$@> and then pass C to croak(): errsv = get_sv("@", TRUE); sv_setsv(errsv, exception_object); croak(Nullch); void croak(const char* pat, ...)','name' => 'croak'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either forward or backward. WARNING: do not use the following unless you *know* C is within the UTF-8 data pointed to by C *and* that on entry C is aligned on the first byte of character or just after the last byte of a character. NOTE: this function is experimental and may change or be removed without notice. U8* utf8_hop(U8 *s, I32 off)','name' => 'utf8_hop'},'THIS' => {'text' => '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','name' => 'THIS'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide UTF8 bytes as a single character. STRLEN sv_len_utf8(SV* sv)','name' => 'sv_len_utf8'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually handled by C. void XSRETURN(int nitems)','name' => 'XSRETURN'},'sv_setref_pvn' => {'text' => '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)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for blessed scalars. See C.','name' => 'SVt_PVMG'},'PUSHp' => {'text' => '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)','name' => 'PUSHp'},'Nullcv' => {'text' => 'Null CV pointer.','name' => 'Nullcv'},'get_av' => {'text' => '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)','name' => 'get_av'},'PL_sv_undef' => {'text' => 'This is the C SV. Always refer to this as C<&PL_sv_undef>. SV PL_sv_undef','name' => 'PL_sv_undef'},'hv_iterkeysv' => {'text' => '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)','name' => 'hv_iterkeysv'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the stack. void XST_mNO(int pos)','name' => 'XST_mNO'},'toUPPER' => {'text' => 'Converts the specified character to uppercase. char toUPPER(char ch)','name' => 'toUPPER'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array. Returns the deleted element. C is currently ignored. SV* av_delete(AV* ar, I32 key, I32 flags)','name' => 'av_delete'},'utf8_distance' => {'text' => 'Returns the number of UTF8 characters between the UTF-8 pointers C and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. NOTE: this function is experimental and may change or be removed without notice. IV utf8_distance(U8 *a, U8 *b)','name' => 'utf8_distance'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and L. SAVETMPS;','name' => 'SAVETMPS'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally appending to the currently-stored string. char* sv_gets(SV* sv, PerlIO* fp, I32 append)','name' => 'sv_gets'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead. int AvFILL(AV* av)','name' => 'AvFILL'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and C.','name' => 'SP'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'SvSetSV_nosteal' => {'text' => '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)','name' => 'SvSetSV_nosteal'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'Zero' => {'text' => '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)','name' => 'Zero'},'hv_fetch' => {'text' => '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)','name' => 'hv_fetch'},'SvSTASH' => {'text' => 'Returns the stash of the SV. HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C. XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. SV* SvRV(SV* sv)','name' => 'SvRV'},'Nullch' => {'text' => 'Null character pointer.','name' => 'Nullch'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C. int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)','name' => 'mg_copy'},'HeSVKEY_force' => {'text' => '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)','name' => 'HeSVKEY_force'},'sv_rvweaken' => {'text' => 'Weaken a reference. SV* sv_rvweaken(SV *sv)','name' => 'sv_rvweaken'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'newSVpvn' => {'text' => '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)','name' => 'newSVpvn'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is incremented. SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C.','name' => 'SVt_PVCV'},'av_push' => {'text' => '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)','name' => 'av_push'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C. XSRETURN_NO;','name' => 'XSRETURN_NO'},'POPn' => {'text' => 'Pops a double off the stack. NV POPn','name' => 'POPn'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is B incremented. SV* newRV_noinc(SV *sv)','name' => 'newRV_noinc'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be extended. void av_extend(AV* ar, I32 key)','name' => 'av_extend'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpviv_mg(SV *sv, IV iv)','name' => 'sv_setpviv_mg'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C. HE* hv_iternext(HV* tb)','name' => 'hv_iternext'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C. dORIGMARK;','name' => 'dORIGMARK'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'sv_newmortal' => {'text' => 'Creates a new SV which is mortal. The reference count of the SV is set to 1. SV* sv_newmortal()','name' => 'sv_newmortal'},'hv_iterinit' => {'text' => '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)','name' => 'hv_iterinit'},'sv_clear' => {'text' => 'Clear an SV, making it empty. Does not free the memory used by the SV itself. void sv_clear(SV* sv)','name' => 'sv_clear'}};}; my $self = bless({ 'index' => $VAR1, perl_version => '5.006002', } => $class); return $self; } 1; Perl-APIReference-0.16/lib/Perl/APIReference/V5_016_000.pm0000644000175000017500000115021512043467451020762 0ustar tseetseepackage Perl::APIReference::V5_016_000; use strict; use warnings; use parent 'Perl::APIReference'; sub new { my $class = shift; my $VAR1; do{$VAR1 = {'newBINOP' => {'text' => 'Constructs, checks, and returns an op of any binary type. I is the opcode. I gives the eight bits of C, except that C will be set automatically, and, shifted up eight bits, the eight bits of C, except that the bit with value 1 or 2 is automatically set as required. I and I supply up to two ops to be the direct children of the binary op; they are consumed by this function and become part of the constructed op tree. OP * newBINOP(I32 type, I32 flags, OP *first, OP *last)','name' => 'newBINOP'},'strGE' => {'text' => '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)','name' => 'strGE'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified version becoming C. Handles \'get\' magic. See also C for a version which guarantees to evaluate sv only once. char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'sv_vsetpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. Usually used via its frontend C. void sv_vsetpvf_mg(SV *const sv, const char *const pat, va_list *const args)','name' => 'sv_vsetpvf_mg'},'SvPVutf8' => {'text' => 'Like C, but converts sv to utf8 first if necessary. char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'sortsv_flags' => {'text' => 'Sort an array, with various options. void sortsv_flags(SV** array, size_t num_elts, SVCOMPARE_t cmp, U32 flags)','name' => 'sortsv_flags'},'vwarn' => {'text' => 'This is an XS interface to Perl\'s C function. C and C are a sprintf-style format pattern and encapsulated argument list. These are used to generate a string message. If the message does not end with a newline, then it will be extended with some indication of the current location in the code, as described for L. The error message or object will by default be written to standard error, but this is subject to modification by a C<$SIG{__WARN__}> handler. Unlike with L, C is not permitted to be null. void vwarn(const char *pat, va_list *args)','name' => 'vwarn'},'scan_oct' => {'text' => 'For backwards compatibility. Use C instead. NV scan_oct(const char* start, STRLEN len, STRLEN* retlen)','name' => 'scan_oct'},'my_strlcat' => {'text' => '','name' => 'my_strlcat'},'av_arylen_p' => {'text' => '','name' => 'av_arylen_p'},'gv_add_by_type' => {'text' => '','name' => 'gv_add_by_type'},'newGVOP' => {'text' => 'Constructs, checks, and returns an op of any type that involves an embedded reference to a GV. I is the opcode. I gives the eight bits of C. I identifies the GV that the op should reference; calling this function does not transfer ownership of any reference to it. OP * newGVOP(I32 type, I32 flags, GV *gv)','name' => 'newGVOP'},'XopDISABLE' => {'text' => 'Temporarily disable a member of the XOP, by clearing the appropriate flag. void XopDISABLE(XOP *xop, which)','name' => 'XopDISABLE'},'is_uni_ascii' => {'text' => '','name' => 'is_uni_ascii'},'find_runcv' => {'text' => 'Locate the CV corresponding to the currently executing sub or eval. If db_seqp is non_null, skip CVs that are in the DB package and populate *db_seqp with the cop sequence number at the point that the DB:: code was entered. (allows debuggers to eval in the scope of the breakpoint rather than in the scope of the debugger itself). CV* find_runcv(U32 *db_seqp)','name' => 'find_runcv'},'utf8n_to_uvuni' => {'text' => 'Bottom level UTF-8 decode routine. Returns the code point value of the first character in the string C, which is assumed to be in UTF-8 (or UTF-EBCDIC) encoding, and no longer than C bytes; C<*retlen> (if C isn\'t NULL) will be set to the length, in bytes, of that character. The value of C determines the behavior when C does not point to a well-formed UTF-8 character. If C is 0, when a malformation is found, zero is returned and C<*retlen> is set so that (S + C<*retlen>>) is the next possible position in C that could begin a non-malformed character. Also, if UTF-8 warnings haven\'t been lexically disabled, a warning is raised. Various ALLOW flags can be set in C to allow (and not warn on) individual types of malformations, such as the sequence being overlong (that is, when there is a shorter sequence that can express the same code point; overlong sequences are expressly forbidden in the UTF-8 standard due to potential security issues). Another malformation example is the first byte of a character not being a legal first byte. See F for the list of such flags. For allowed 0 length strings, this function returns 0; for allowed overlong sequences, the computed code point is returned; for all other allowed malformations, the Unicode REPLACEMENT CHARACTER is returned, as these have no determinable reasonable value. The UTF8_CHECK_ONLY flag overrides the behavior when a non-allowed (by other flags) malformation is found. If this flag is set, the routine assumes that the caller will raise a warning, and this function will silently just set C to C<-1> and return zero. Certain code points are considered problematic. These are Unicode surrogates, Unicode non-characters, and code points above the Unicode maximum of 0x10FFFF. By default these are considered regular code points, but certain situations warrant special handling for them. If C contains UTF8_DISALLOW_ILLEGAL_INTERCHANGE, all three classes are treated as malformations and handled as such. The flags UTF8_DISALLOW_SURROGATE, UTF8_DISALLOW_NONCHAR, and UTF8_DISALLOW_SUPER (meaning above the legal Unicode maximum) can be set to disallow these categories individually. The flags UTF8_WARN_ILLEGAL_INTERCHANGE, UTF8_WARN_SURROGATE, UTF8_WARN_NONCHAR, and UTF8_WARN_SUPER will cause warning messages to be raised for their respective categories, but otherwise the code points are considered valid (not malformations). To get a category to both be treated as a malformation and raise a warning, specify both the WARN and DISALLOW flags. (But note that warnings are not raised if lexically disabled nor if UTF8_CHECK_ONLY is also specified.) Very large code points (above 0x7FFF_FFFF) are considered more problematic than the others that are above the Unicode legal maximum. There are several reasons: they requre at least 32 bits to represent them on ASCII platforms, are not representable at all on EBCDIC platforms, and the original UTF-8 specification never went above this number (the current 0x10FFFF limit was imposed later). (The smaller ones, those that fit into 32 bits, are representable by a UV on ASCII platforms, but not by an IV, which means that the number of operations that can be performed on them is quite restricted.) The UTF-8 encoding on ASCII platforms for these large code points begins with a byte containing 0xFE or 0xFF. The UTF8_DISALLOW_FE_FF flag will cause them to be treated as malformations, while allowing smaller above-Unicode code points. (Of course UTF8_DISALLOW_SUPER will treat all above-Unicode code points, including these, as malformations.) Similarly, UTF8_WARN_FE_FF acts just like the other WARN flags, but applies just to these code points. All other code points corresponding to Unicode characters, including private use and those yet to be assigned, are never considered malformed and never warn. Most code should use L() rather than call this directly. UV utf8n_to_uvuni(const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvuni'},'newSVpvn_utf8' => {'text' => 'Creates a new SV and copies a string into it. If utf8 is true, calls C on the new SV. Implemented as a wrapper around C. SV* newSVpvn_utf8(NULLOK const char* s, STRLEN len, U32 utf8)','name' => 'newSVpvn_utf8'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and C. dMARK;','name' => 'dMARK'},'whichsig_pv' => {'text' => '','name' => 'whichsig_pv'},'gv_fetchmeth_sv_autoload' => {'text' => 'Exactly like L, but takes the name string in the form of an SV instead of a string/length pair. GV* gv_fetchmeth_sv_autoload(HV* stash, SV* namesv, I32 level, U32 flags)','name' => 'gv_fetchmeth_sv_autoload'},'pregcomp' => {'text' => '','name' => 'pregcomp'},'my_cxt_index' => {'text' => '','name' => 'my_cxt_index'},'lex_discard_to' => {'text' => 'Discards the first part of the Llinestr> buffer, up to I. The remaining content of the buffer will be moved, and all pointers into the buffer updated appropriately. I must not be later in the buffer than the position of Lbufptr>: it is not permitted to discard text that has yet to be lexed. Normally it is not necessarily to do this directly, because it suffices to use the implicit discarding behaviour of L and things based on it. However, if a token stretches across multiple lines, and the lexing code has kept multiple lines of text in the buffer for that purpose, then after completion of the token it would be wise to explicitly discard the now-unneeded earlier lines, to avoid future multi-line tokens growing the buffer without bound. NOTE: this function is experimental and may change or be removed without notice. void lex_discard_to(char *ptr)','name' => 'lex_discard_to'},'markstack_grow' => {'text' => '','name' => 'markstack_grow'},'cv_get_call_checker' => {'text' => 'Retrieves the function that will be used to fix up a call to I. Specifically, the function is applied to an C op tree for a subroutine call, not marked with C<&>, where the callee can be identified at compile time as I. The C-level function pointer is returned in I<*ckfun_p>, and an SV argument for it is returned in I<*ckobj_p>. The function is intended to be called in this manner: entersubop = (*ckfun_p)(aTHX_ entersubop, namegv, (*ckobj_p)); In this call, I is a pointer to the C op, which may be replaced by the check function, and I is a GV supplying the name that should be used by the check function to refer to the callee of the C op if it needs to emit any diagnostics. It is permitted to apply the check function in non-standard situations, such as to a call to a different subroutine or to a method call. By default, the function is L, and the SV parameter is I itself. This implements standard prototype processing. It can be changed, for a particular subroutine, by L. void cv_get_call_checker(CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p)','name' => 'cv_get_call_checker'},'mXPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Does not use C. See also C, C and C. void mXPUSHp(char* str, STRLEN len)','name' => 'mXPUSHp'},'lex_stuff_sv' => {'text' => 'Insert characters into the lexer buffer (Llinestr>), immediately after the current lexing point (Lbufptr>), reallocating the buffer if necessary. This means that lexing code that runs later will see the characters as if they had appeared in the input. It is not recommended to do this as part of normal parsing, and most uses of this facility run the risk of the inserted characters being interpreted in an unintended manner. The string to be inserted is the string value of I. The characters are recoded for the lexer buffer, according to how the buffer is currently being interpreted (L). If a string to be inserted is not already a Perl scalar, the L function avoids the need to construct a scalar. NOTE: this function is experimental and may change or be removed without notice. void lex_stuff_sv(SV *sv, U32 flags)','name' => 'lex_stuff_sv'},'ibcmp_utf8' => {'text' => 'This is a synonym for (! foldEQ_utf8()) I32 ibcmp_utf8(const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2)','name' => 'ibcmp_utf8'},'CvSTASH' => {'text' => 'Returns the stash of the CV. A stash is the symbol table hash, containing the package-scoped variables in the package where the subroutine was defined. For more information, see L. This also has a special use with XS AUTOLOAD subs. See L. HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'gv_const_sv' => {'text' => 'If C is a typeglob whose subroutine entry is a constant sub eligible for inlining, or C is a placeholder reference that would be promoted to such a typeglob, then returns the value returned by the sub. Otherwise, returns NULL. SV* gv_const_sv(GV* gv)','name' => 'gv_const_sv'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. The target SV physically takes over ownership of the body of the source SV and inherits its flags; however, the target keeps any magic it owns, and any magic in the source is discarded. Note that this is a rather specialist SV copying operation; most of the time you\'ll want to use C or one of its many macro front-ends. void sv_replace(SV *const sv, SV *const nsv)','name' => 'sv_replace'},'utf8n_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string C which is assumed to be in UTF-8 encoding; C will be set to the length, in bytes, of that character. C and C are the same as L(). UV utf8n_to_uvchr(const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvchr'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and L.','name' => 'G_ARRAY'},'sv_2iv' => {'text' => '','name' => 'sv_2iv'},'ck_warner_d' => {'text' => '','name' => 'ck_warner_d'},'XS_VERSION_BOOTCHECK' => {'text' => '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;','name' => 'XS_VERSION_BOOTCHECK'},'pad_compname_type' => {'text' => 'Looks up the type of the lexical variable at position I in the currently-compiling pad. If the variable is typed, the stash of the class to which it is typed is returned. If not, C is returned. HV * pad_compname_type(PADOFFSET po)','name' => 'pad_compname_type'},'mXPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. void mXPUSHn(NV nv)','name' => 'mXPUSHn'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its argument more than once. void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See L.','name' => 'G_EVAL'},'is_utf8_punct' => {'text' => '','name' => 'is_utf8_punct'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catsv_mg(SV *dsv, SV *ssv)','name' => 'sv_catsv_mg'},'call_argv' => {'text' => 'Performs a callback to the specified named and package-scoped Perl subroutine with C (a NULL-terminated array of strings) as arguments. See L. Approximate Perl equivalent: C<&{"$sub_name"}(@$argv)>. NOTE: the perl_ form of this function is deprecated. I32 call_argv(const char* sub_name, I32 flags, char** argv)','name' => 'call_argv'},'save_freeop' => {'text' => '','name' => 'save_freeop'},'SvPV_nolen' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified form becoming C. Handles \'get\' magic. char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'perl_clone' => {'text' => '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->create 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 C, 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 *proto_perl, UV flags )','name' => 'perl_clone'},'save_alloc' => {'text' => '','name' => 'save_alloc'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments more than once. void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'rninstr' => {'text' => '','name' => 'rninstr'},'pad_findmy_pvn' => {'text' => 'Given the name of a lexical variable, find its position in the currently-compiling pad. I/I specify the variable\'s name, including leading sigil. I is reserved and must be zero. If it is not in the current pad but appears in the pad of any lexically enclosing scope, then a pseudo-entry for it is added in the current pad. Returns the offset in the current pad, or C if no such lexical is in scope. PADOFFSET pad_findmy_pvn(const char *namepv, STRLEN namelen, U32 flags)','name' => 'pad_findmy_pvn'},'hv_fetchs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. SV** hv_fetchs(HV* tb, const char* key, I32 lval)','name' => 'hv_fetchs'},'strnNE' => {'text' => '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)','name' => 'strnNE'},'cophh_store_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of a string/length pair. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_store_pv(const COPHH *cophh, const char *key, U32 hash, SV *value, U32 flags)','name' => 'cophh_store_pv'},'savepv' => {'text' => 'Perl\'s version of C. Returns a pointer to a newly allocated string which is a duplicate of C. The size of the string is determined by C. The memory allocated for the new string can be freed with the C function. char* savepv(const char* pv)','name' => 'savepv'},'save_iv' => {'text' => '','name' => 'save_iv'},'HvNAME' => {'text' => 'Returns the package name of a stash, or NULL if C isn\'t a stash. See C, C. char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV of the sv is assumed to be octets in that encoding, and the sv will be converted into Unicode (and UTF-8). If the sv already is UTF-8 (or if it is not POK), or if the encoding is not a reference, nothing is done to the sv. If the encoding is not an C Encoding object, bad things will happen. (See F and L.) The PV of the sv is returned. char* sv_recode_to_utf8(SV* sv, SV *encoding)','name' => 'sv_recode_to_utf8'},'save_hptr' => {'text' => '','name' => 'save_hptr'},'runops_debug' => {'text' => '','name' => 'runops_debug'},'do_gvgv_dump' => {'text' => '','name' => 'do_gvgv_dump'},'PERL_SYS_INIT' => {'text' => 'Provides system-specific tune up of the C runtime environment necessary to run Perl interpreters. This should be called only once, before creating any Perl interpreters. void PERL_SYS_INIT(int argc, char** argv)','name' => 'PERL_SYS_INIT'},'vstringify' => {'text' => 'In order to maintain maximum compatibility with earlier versions of Perl, this function will return either the floating point notation or the multiple dotted notation, depending on whether the original version contained 1 or more dots, respectively. The SV returned has a refcount of 1. SV* vstringify(SV *vs)','name' => 'vstringify'},'sv_catsv_flags' => {'text' => 'Concatenates the string from SV C onto the end of the string in SV C. Modifies C but not C. If C has C bit set, will C on the C, if appropriate, before reading it. If the C contain C, C will be called on the modified SV afterward, if appropriate. C and C are implemented in terms of this function. void sv_catsv_flags(SV *const dsv, SV *const ssv, const I32 flags)','name' => 'sv_catsv_flags'},'is_uni_alpha' => {'text' => '','name' => 'is_uni_alpha'},'str_to_version' => {'text' => '','name' => 'str_to_version'},'sv_derived_from' => {'text' => 'Exactly like L, but doesn\'t take a C parameter. bool sv_derived_from(SV* sv, const char *const name)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp_locale(SV *const sv1, SV *const sv2)','name' => 'sv_cmp_locale'},'sv_catpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_catpvs(SV* sv, const char* s)','name' => 'sv_catpvs'},'set_numeric_standard' => {'text' => '','name' => 'set_numeric_standard'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via the C macro. See C. dSP;','name' => 'dSP'},'Nullsv' => {'text' => 'Null SV pointer. (No longer available when C is defined.)','name' => 'Nullsv'},'scan_vstring' => {'text' => '','name' => 'scan_vstring'},'ptr_table_new' => {'text' => '','name' => 'ptr_table_new'},'do_op_dump' => {'text' => '','name' => 'do_op_dump'},'foldEQ' => {'text' => 'Returns true if the leading len bytes of the strings s1 and s2 are the same case-insensitively; false otherwise. Uppercase and lowercase ASCII range bytes match themselves and their opposite case counterparts. Non-cased and non-ASCII range bytes match only themselves. I32 foldEQ(const char* a, const char* b, I32 len)','name' => 'foldEQ'},'PerlIO_get_base' => {'text' => '','name' => 'PerlIO_get_base'},'SvPVX' => {'text' => 'Returns a pointer to the physical string in the SV. The SV must contain a string. This is also used to store the name of an autoloaded subroutine in an XS AUTOLOAD routine. See L. char* SvPVX(SV* sv)','name' => 'SvPVX'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHi(IV iv)','name' => 'XPUSHi'},'is_utf8_perl_word' => {'text' => '','name' => 'is_utf8_perl_word'},'debop' => {'text' => '','name' => 'debop'},'ref' => {'text' => '','name' => 'ref'},'is_uni_print_lc' => {'text' => '','name' => 'is_uni_print_lc'},'sv_does_sv' => {'text' => 'Returns a boolean indicating whether the SV performs a specific, named role. The SV can be a Perl object or the name of a Perl class. bool sv_does_sv(SV* sv, SV* namesv, U32 flags)','name' => 'sv_does_sv'},'SvOOK_offset' => {'text' => 'Reads into I the offset from SvPVX back to the true start of the allocated buffer, which will be non-zero if C has been used to efficiently remove characters from start of the buffer. Implemented as a macro, which takes the address of I, which must be of type C. Evaluates I more than once. Sets I to 0 if C is false. void SvOOK_offset(NN SV*sv, STRLEN len)','name' => 'SvOOK_offset'},'save_list' => {'text' => '','name' => 'save_list'},'is_uni_idfirst_lc' => {'text' => '','name' => 'is_uni_idfirst_lc'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted if tainting is enabled. void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'newGIVENOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C block. I supplies the expression that will be locally assigned to a lexical variable, and I supplies the body of the C construct; they are consumed by this function and become part of the constructed op tree. I is the pad offset of the scalar lexical variable that will be affected. OP * newGIVENOP(OP *cond, OP *block, PADOFFSET defsv_off)','name' => 'newGIVENOP'},'sv_nolocking' => {'text' => '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. "Superseded" by sv_nosharing(). void sv_nolocking(SV *sv)','name' => 'sv_nolocking'},'parse_listexpr' => {'text' => 'Parse a Perl list expression. This may contain operators of precedence down to the comma operator. The expression must be followed (and thus terminated) either by a low-precedence logic operator such as C or by something that would normally terminate an expression such as semicolon. If I includes C then the expression is optional, otherwise it is mandatory. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed and the lexical context for the expression. The op tree representing the expression is returned. If an optional expression is absent, a null pointer is returned, otherwise the pointer will be non-null. If an error occurs in parsing or compilation, in most cases a valid op tree is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. Some compilation errors, however, will throw an exception immediately. NOTE: this function is experimental and may change or be removed without notice. OP * parse_listexpr(U32 flags)','name' => 'parse_listexpr'},'ibcmp' => {'text' => 'This is a synonym for (! foldEQ()) I32 ibcmp(const char* a, const char* b, I32 len)','name' => 'ibcmp'},'isWORDCHAR' => {'text' => 'Returns a boolean indicating whether the specified character is a character that is any of: alphabetic, numeric, or an underscore. This is the same as what C<\\w> matches in a regular expression. C is a synonym provided for backward compatibility. Note that it does not have the standard C language meaning of alphanumeric, since it matches an underscore and the standard meaning does not. See the L for an explanation of variants C and C. bool isWORDCHAR(char ch)','name' => 'isWORDCHAR'},'Slab_Alloc' => {'text' => '','name' => 'Slab_Alloc'},'strLT' => {'text' => '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)','name' => 'strLT'},'save_pushptr' => {'text' => '','name' => 'save_pushptr'},'save_clearsv' => {'text' => '','name' => 'save_clearsv'},'Slab_Free' => {'text' => '','name' => 'Slab_Free'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array. Returns C<&PL_sv_undef> if the array is empty. Perl equivalent: C SV* av_shift(AV *av)','name' => 'av_shift'},'sv_setpvf_nocontext' => {'text' => '','name' => 'sv_setpvf_nocontext'},'HvENAMEUTF8' => {'text' => 'Returns true if the effective name is in UTF8 encoding. unsigned char HvENAMEUTF8(HV *stash)','name' => 'HvENAMEUTF8'},'sv_nounlocking' => {'text' => '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. "Superseded" by sv_nosharing(). void sv_nounlocking(SV *sv)','name' => 'sv_nounlocking'},'perl_clone_using' => {'text' => '','name' => 'perl_clone_using'},'PerlIO_context_layers' => {'text' => '','name' => 'PerlIO_context_layers'},'lex_unstuff' => {'text' => 'Discards text about to be lexed, from Lbufptr> up to I. Text following I will be moved, and the buffer shortened. This hides the discarded text from any lexing code that runs later, as if the text had never appeared. This is not the normal way to consume lexed text. For that, use L. NOTE: this function is experimental and may change or be removed without notice. void lex_unstuff(char *ptr)','name' => 'lex_unstuff'},'newSVpvf_nocontext' => {'text' => '','name' => 'newSVpvf_nocontext'},'SvUV_set' => {'text' => 'Set the value of the UV pointer in sv to val. See C. void SvUV_set(SV* sv, UV val)','name' => 'SvUV_set'},'rvpv_dup' => {'text' => '','name' => 'rvpv_dup'},'filter_read' => {'text' => '','name' => 'filter_read'},'ckwarn' => {'text' => '','name' => 'ckwarn'},'warner' => {'text' => '','name' => 'warner'},'savesharedsvpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedsvpv(SV *sv)','name' => 'savesharedsvpv'},'CopyD' => {'text' => 'Like C but returns dest. Useful for encouraging compilers to tail-call optimise. void * CopyD(void* src, void* dest, int nitems, type)','name' => 'CopyD'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setiv_mg(SV *const sv, const IV i)','name' => 'sv_setiv_mg'},'sv_does_pvn' => {'text' => 'Like L, but takes a string/length pair instead of an SV. bool sv_does_pvn(SV* sv, const char *const name, const STRLEN len, U32 flags)','name' => 'sv_does_pvn'},'newFOROP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C loop (iteration through a list of values). This is a heavyweight loop, with structure that allows exiting the loop by C and suchlike. I optionally supplies the variable that will be aliased to each item in turn; if null, it defaults to C<$_> (either lexical or global). I supplies the list of values to iterate over. I supplies the main body of the loop, and I optionally supplies a C block that operates as a second half of the body. All of these optree inputs are consumed by this function and become part of the constructed op tree. I gives the eight bits of C for the C op and, shifted up eight bits, the eight bits of C for the C op, except that (in both cases) some bits will be set automatically. OP * newFOROP(I32 flags, OP *sv, OP *expr, OP *block, OP *cont)','name' => 'newFOROP'},'HvENAME' => {'text' => 'Returns the effective name of a stash, or NULL if there is none. The effective name represents a location in the symbol table where this stash resides. It is updated automatically when packages are aliased or deleted. A stash that is no longer in the symbol table has no effective name. This name is preferable to C for use in MRO linearisations and isa caches. char* HvENAME(HV* stash)','name' => 'HvENAME'},'save_generic_svref' => {'text' => '','name' => 'save_generic_svref'},'savesharedpvn' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. (With the specific difference that a NULL pointer is not acceptable) char* savesharedpvn(const char *const pv, const STRLEN len)','name' => 'savesharedpvn'},'utf8_to_uvchr_buf' => {'text' => 'Returns the native code point of the first character in the string C which is assumed to be in UTF-8 encoding; C points to 1 beyond the end of C. C<*retlen> will be set to the length, in bytes, of that character. If C does not point to a well-formed UTF-8 character and UTF8 warnings are enabled, zero is returned and C<*retlen> is set (if C isn\'t NULL) to -1. If those warnings are off, the computed value if well-defined (or the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen> is set (if C isn\'t NULL) so that (S + C<*retlen>>) is the next possible position in C that could begin a non-malformed character. See L for details on when the REPLACEMENT CHARACTER is returned. UV utf8_to_uvchr_buf(const U8 *s, const U8 *send, STRLEN *retlen)','name' => 'utf8_to_uvchr_buf'},'SvCUR_set' => {'text' => 'Set the current length of the string which is in the SV. See C and C. void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'_is_utf8_quotemeta' => {'text' => '','name' => '_is_utf8_quotemeta'},'sv_2pv' => {'text' => '','name' => 'sv_2pv'},'SvNOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a double. U32 SvNOK(SV* sv)','name' => 'SvNOK'},'mPUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. void mPUSHn(NV nv)','name' => 'mPUSHn'},'is_uni_digit_lc' => {'text' => '','name' => 'is_uni_digit_lc'},'pad_setsv' => {'text' => 'Set the value at offset I in the current (compiling or executing) pad. Use the macro PAD_SETSV() rather than calling this function directly. void pad_setsv(PADOFFSET po, SV *sv)','name' => 'pad_setsv'},'sv_reset' => {'text' => 'Underlying implementation for the C Perl function. Note that the perl-level function is vaguely deprecated. void sv_reset(const char* s, HV *const stash)','name' => 'sv_reset'},'cophh_delete_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of a string/length pair. NOTE: this function is experimental and may change or be removed without notice. COPHH * cophh_delete_pv(const COPHH *cophh, const char *key, U32 hash, U32 flags)','name' => 'cophh_delete_pv'},'sv_2pv_flags' => {'text' => 'Returns a pointer to the string value of an SV, and sets *lp to its length. If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string if necessary. Normally invoked via the C macro. C and C usually end up here too. char* sv_2pv_flags(SV *const sv, STRLEN *const lp, const I32 flags)','name' => 'sv_2pv_flags'},'push_scope' => {'text' => '','name' => 'push_scope'},'SvNVx' => {'text' => 'Coerces the given SV to a double and returns it. Guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. NV SvNVx(SV* sv)','name' => 'SvNVx'},'setdefout' => {'text' => 'Sets PL_defoutgv, the default file handle for output, to the passed in typeglob. As PL_defoutgv "owns" a reference on its typeglob, the reference count of the passed in typeglob is increased by one, and the reference count of the typeglob that PL_defoutgv points to is decreased by one. void setdefout(GV* gv)','name' => 'setdefout'},'form_nocontext' => {'text' => '','name' => 'form_nocontext'},'hv_store' => {'text' => 'Stores an SV in a hash. The hash key is specified as C and the absolute value of C is the length of the key. If C is negative the key is assumed to be in UTF-8-encoded Unicode. 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. Effectively a successful hv_store takes ownership of one reference to C. 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 L for more information on how to use this function on tied hashes. SV** hv_store(HV *hv, const char *key, I32 klen, SV *val, U32 hash)','name' => 'hv_store'},'sys_intern_dup' => {'text' => '','name' => 'sys_intern_dup'},'do_binmode' => {'text' => '','name' => 'do_binmode'},'get_op_names' => {'text' => '','name' => 'get_op_names'},'cop_hints_fetch_sv' => {'text' => 'Like L, but takes a Perl scalar instead of a string/length pair. SV * cop_hints_fetch_sv(const COP *cop, SV *key, U32 hash, U32 flags)','name' => 'cop_hints_fetch_sv'},'ck_entersub_args_proto_or_list' => {'text' => 'Performs the fixup of the arguments part of an C op tree either based on a subroutine prototype or using default list-context processing. This is the standard treatment used on a subroutine call, not marked with C<&>, where the callee can be identified at compile time. I supplies the subroutine prototype to be applied to the call, or indicates that there is no prototype. It may be a normal scalar, in which case if it is defined then the string value will be used as a prototype, and if it is undefined then there is no prototype. Alternatively, for convenience, it may be a subroutine object (a C that has been cast to C), of which the prototype will be used if it has one. The prototype (or lack thereof) supplied, in whichever form, does not need to match the actual callee referenced by the op tree. If the argument ops disagree with the prototype, for example by having an unacceptable number of arguments, a valid op tree is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. In the error message, the callee is referred to by the name defined by the I parameter. OP * ck_entersub_args_proto_or_list(OP *entersubop, GV *namegv, SV *protosv)','name' => 'ck_entersub_args_proto_or_list'},'op_null' => {'text' => '','name' => 'op_null'},'hv_fetch_ent' => {'text' => '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 *hv, SV *keysv, I32 lval, U32 hash)','name' => 'hv_fetch_ent'},'gv_fetchpvn_flags' => {'text' => '','name' => 'gv_fetchpvn_flags'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L. ENTER;','name' => 'ENTER'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as C<&PL_sv_no>. SV PL_sv_no','name' => 'PL_sv_no'},'Newx' => {'text' => 'The XSUB-writer\'s interface to the C C function. In 5.9.3, Newx() and friends replace the older New() API, and drops the first parameter, I, a debug aid which allowed callers to identify themselves. This aid has been superseded by a new build option, PERL_MEM_LOG (see L). The older API is still there for use in XS modules supporting older perls. void Newx(void* ptr, int nitems, type)','name' => 'Newx'},'newFORM' => {'text' => '','name' => 'newFORM'},'PUSHs' => {'text' => 'Push an SV onto the stack. The stack must have room for this element. Does not handle \'set\' magic. Does not use C. See also C, C and C. void PUSHs(SV* sv)','name' => 'PUSHs'},'to_uni_upper_lc' => {'text' => '','name' => 'to_uni_upper_lc'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary. Does not handle \'set\' magic. See also C. void sv_setuv(SV *const sv, const UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => '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)','name' => 'SvUPGRADE'},'cv_clone' => {'text' => 'Clone a CV, making a lexical closure. I supplies the prototype of the function: its code, pad structure, and other attributes. The prototype is combined with a capture of outer lexicals to which the code refers, which are taken from the currently-executing instance of the immediately surrounding code. CV * cv_clone(CV *proto)','name' => 'cv_clone'},'is_uni_upper_lc' => {'text' => '','name' => 'is_uni_upper_lc'},'do_aspawn' => {'text' => '','name' => 'do_aspawn'},'sv_pvn' => {'text' => 'A private implementation of the C macro for compilers which can\'t cope with complex macro expressions. Always use the macro instead. char* sv_pvn(SV *sv, STRLEN *lp)','name' => 'sv_pvn'},'do_openn' => {'text' => '','name' => 'do_openn'},'wrap_op_checker' => {'text' => 'Puts a C function into the chain of check functions for a specified op type. This is the preferred way to manipulate the L array. I specifies which type of op is to be affected. I is a pointer to the C function that is to be added to that opcode\'s check chain, and I points to the storage location where a pointer to the next function in the chain will be stored. The value of I is written into the L array, while the value previously stored there is written to I<*old_checker_p>. L is global to an entire process, and a module wishing to hook op checking may find itself invoked more than once per process, typically in different threads. To handle that situation, this function is idempotent. The location I<*old_checker_p> must initially (once per process) contain a null pointer. A C variable of static duration (declared at file scope, typically also marked C to give it internal linkage) will be implicitly initialised appropriately, if it does not have an explicit initialiser. This function will only actually modify the check chain if it finds I<*old_checker_p> to be null. This function is also thread safe on the small scale. It uses appropriate locking to avoid race conditions in accessing L. When this function is called, the function referenced by I must be ready to be called, except for I<*old_checker_p> being unfilled. In a threading situation, I may be called immediately, even before this function has returned. I<*old_checker_p> will always be appropriately set before I is called. If I decides not to do anything special with an op that it is given (which is the usual case for most uses of op check hooking), it must chain the check function referenced by I<*old_checker_p>. If you want to influence compilation of calls to a specific subroutine, then use L rather than hooking checking of all C ops. void wrap_op_checker(Optype opcode, Perl_check_t new_checker, Perl_check_t *old_checker_p)','name' => 'wrap_op_checker'},'mro_get_from_name' => {'text' => '','name' => 'mro_get_from_name'},'sv_setref_iv' => {'text' => '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 have a reference count of 1, and the RV will be returned. SV* sv_setref_iv(SV *const rv, const char *const classname, const IV iv)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => '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. Uses the "OOK hack". Beware: after this function returns, C and SvPVX_const(sv) may no longer refer to the same chunk of data. The unfortunate similarity of this function\'s name to that of Perl\'s C operator is strictly coincidental. This function works from the left; C works from the right. void sv_chop(SV *const sv, const char *const ptr)','name' => 'sv_chop'},'sv_backoff' => {'text' => 'Remove any string offset. You should normally use the C macro wrapper instead. int sv_backoff(SV *const sv)','name' => 'sv_backoff'},'reentrant_retry' => {'text' => '','name' => 'reentrant_retry'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. Handles \'set\' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB\'s - see C instead. See also C and C. void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_pvn_nomg' => {'text' => '','name' => 'sv_pvn_nomg'},'is_uni_space_lc' => {'text' => '','name' => 'is_uni_space_lc'},'stack_grow' => {'text' => '','name' => 'stack_grow'},'dump_mstats' => {'text' => '','name' => 'dump_mstats'},'newLOOPEX' => {'text' => 'Constructs, checks, and returns a loop-exiting op (such as C or C). I is the opcode. I and C. WARNING: use only if you *know* that the pointers point inside the same UTF-8 buffer. IV utf8_distance(const U8 *a, const U8 *b)','name' => 'utf8_distance'},'SvPV_nomg' => {'text' => 'Like C but doesn\'t process magic. char* SvPV_nomg(SV* sv, STRLEN len)','name' => 'SvPV_nomg'},'parser_dup' => {'text' => '','name' => 'parser_dup'},'do_sprintf' => {'text' => '','name' => 'do_sprintf'},'SvUV_nomg' => {'text' => 'Like C but doesn\'t process magic. UV SvUV_nomg(SV* sv)','name' => 'SvUV_nomg'},'save_I32' => {'text' => '','name' => 'save_I32'},'gv_autoload4' => {'text' => '','name' => 'gv_autoload4'},'POPpx' => {'text' => 'Pops a string off the stack. char* POPpx','name' => 'POPpx'},'PL_modglobal' => {'text' => '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','name' => 'PL_modglobal'},'newCONDOP' => {'text' => 'Constructs, checks, and returns a conditional-expression (C) op. I gives the eight bits of C, except that C will be set automatically, and, shifted up eight bits, the eight bits of C, except that the bit with value 1 is automatically set. I supplies the expression selecting between the two branches, and I and I supply the branches; they are consumed by this function and become part of the constructed op tree. OP * newCONDOP(I32 flags, OP *first, OP *trueop, OP *falseop)','name' => 'newCONDOP'},'save_pushi32ptr' => {'text' => '','name' => 'save_pushi32ptr'},'sv_setpvs' => {'text' => 'Like C, but takes a literal string instead of a string/length pair. void sv_setpvs(SV* sv, const char* s)','name' => 'sv_setpvs'},'is_uni_punct_lc' => {'text' => '','name' => 'is_uni_punct_lc'},'cxinc' => {'text' => '','name' => 'cxinc'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. Guarantees to C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. void SvROK_on(SV* sv)','name' => 'SvROK_on'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'sv_clear' => {'text' => 'Clear an SV: call any destructors, free up any memory used by the body, and free the body itself. The SV\'s head is I freed, although its type is set to all 1\'s so that it won\'t inadvertently be assumed to be live during global destruction etc. This function should only be called when REFCNT is zero. Most of the time you\'ll want to call C (or its macro wrapper C) instead. void sv_clear(SV *const orig_sv)','name' => 'sv_clear'},'lex_read_space' => {'text' => 'Reads optional spaces, in Perl style, in the text currently being lexed. The spaces may include ordinary whitespace characters and Perl-style comments. C<#line> directives are processed if encountered. Lbufptr> is moved past the spaces, so that it points at a non-space character (or the end of the input text). If spaces extend into the next chunk of input text, the next chunk will be read in. Normally the current chunk will be discarded at the same time, but if I includes C then the current chunk will not be discarded. NOTE: this function is experimental and may change or be removed without notice. void lex_read_space(U32 flags)','name' => 'lex_read_space'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C. void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'SvGAMAGIC' => {'text' => 'Returns true if the SV has get magic or overloading. If either is true then the scalar is active data, and has the potential to return a new value every time it is accessed. Hence you must be careful to only read it once per user logical operation and work with that returned value. If neither is true then the scalar\'s value cannot change unless written to. U32 SvGAMAGIC(SV* sv)','name' => 'SvGAMAGIC'},'svtype' => {'text' => '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.','name' => 'svtype'},'hv_placeholders_get' => {'text' => '','name' => 'hv_placeholders_get'},'load_module' => {'text' => '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 and not NULL, provides version semantics similar to C. The optional trailing SV* arguments can be used to specify arguments to the module\'s import() method, similar to C. They must be terminated with a final NULL pointer. Note that this list can only be omitted when the PERL_LOADMOD_NOIMPORT flag has been used. Otherwise at least a single NULL pointer to designate the default import list is required. The reference count for each specified C parameter is decremented. void load_module(U32 flags, SV* name, SV* ver, ...)','name' => 'load_module'},'dump_eval' => {'text' => '','name' => 'dump_eval'},'Poison' => {'text' => 'PoisonWith(0xEF) for catching access to freed memory. void Poison(void* dest, int nitems, type)','name' => 'Poison'},'is_uni_alpha_lc' => {'text' => '','name' => 'is_uni_alpha_lc'},'sv_catpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_catpvf_mg(SV *const sv, const char *const pat, ...)','name' => 'sv_catpvf_mg'},'get_sv' => {'text' => 'Returns the SV of the specified Perl scalar. C are passed to C. If C is set and the Perl variable does not exist then it will be created. If C is zero 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 flags)','name' => 'get_sv'},'warn_sv' => {'text' => 'This is an XS interface to Perl\'s C function. C is the error message or object. If it is a reference, it will be used as-is. Otherwise it is used as a string, and if it does not end with a newline then it will be extended with some indication of the current location in the code, as described for L. The error message or object will by default be written to standard error, but this is subject to modification by a C<$SIG{__WARN__}> handler. To warn with a simple string message, the L function may be more convenient. void warn_sv(SV *baseex)','name' => 'warn_sv'},'GetVars' => {'text' => '','name' => 'GetVars'},'do_hv_dump' => {'text' => '','name' => 'do_hv_dump'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic. void sv_setpv_mg(SV *const sv, const char *const ptr)','name' => 'sv_setpv_mg'},'whichsig' => {'text' => '','name' => 'whichsig'},'lex_next_chunk' => {'text' => 'Reads in the next chunk of text to be lexed, appending it to Llinestr>. This should be called when lexing code has looked to the end of the current chunk and wants to know more. It is usual, but not necessary, for lexing to have consumed the entirety of the current chunk at this time. If Lbufptr> is pointing to the very end of the current chunk (i.e., the current chunk has been entirely consumed), normally the current chunk will be discarded at the same time that the new chunk is read in. If I includes C, the current chunk will not be discarded. If the current chunk has not been entirely consumed, then it will not be discarded regardless of the flag. Returns true if some new text was added to the buffer, or false if the buffer has reached the end of the input text. NOTE: this function is experimental and may change or be removed without notice. bool lex_next_chunk(U32 flags)','name' => 'lex_next_chunk'},'sv_2mortal' => {'text' => 'Marks an existing SV as mortal. The SV will be destroyed "soon", either by an explicit call to FREETMPS, or by an implicit call at places such as statement boundaries. SvTEMP() is turned on which means that the SV\'s string buffer can be "stolen" if this SV is copied. See also C and C. SV* sv_2mortal(SV *const sv)','name' => 'sv_2mortal'},'sv_2bool_flags' => {'text' => 'This function is only used by sv_true() and friends, and only if the latter\'s argument is neither SvPOK, SvIOK nor SvNOK. If the flags contain SV_GMAGIC, then it does an mg_get() first. bool sv_2bool_flags(SV *const sv, const I32 flags)','name' => 'sv_2bool_flags'},'is_uni_graph' => {'text' => '','name' => 'is_uni_graph'},'malloc' => {'text' => '','name' => 'malloc'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the av to store its list of scalars. If any destructors are triggered as a result, the av itself may be freed. void av_undef(AV *av)','name' => 'av_undef'},'parse_label' => {'text' => 'Parse a single label, possibly optional, of the type that may prefix a Perl statement. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed. If I includes C then the label is optional, otherwise it is mandatory. The name of the label is returned in the form of a fresh scalar. If an optional label is absent, a null pointer is returned. If an error occurs in parsing, which can only occur if the label is mandatory, a valid label is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. NOTE: this function is experimental and may change or be removed without notice. SV * parse_label(U32 flags)','name' => 'parse_label'},'PL_check' => {'text' => 'Array, indexed by opcode, of functions that will be called for the "check" phase of optree building during compilation of Perl code. For most (but not all) types of op, once the op has been initially built and populated with child ops it will be filtered through the check function referenced by the appropriate element of this array. The new op is passed in as the sole argument to the check function, and the check function returns the completed op. The check function may (as the name suggests) check the op for validity and signal errors. It may also initialise or modify parts of the ops, or perform more radical surgery such as adding or removing child ops, or even throw the op away and return a different op in its place. This array of function pointers is a convenient place to hook into the compilation process. An XS module can put its own custom check function in place of any of the standard ones, to influence the compilation of a particular type of op. However, a custom check function must never fully replace a standard check function (or even a custom check function from another module). A module modifying checking must instead B the preexisting check function. A custom check function must be selective about when to apply its custom behaviour. In the usual case where it decides not to do anything special with an op, it must chain the preexisting op function. Check functions are thus linked in a chain, with the core\'s base checker at the end. For thread safety, modules should not write directly to this array. Instead, use the function L.','name' => 'PL_check'},'pack_cat' => {'text' => '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, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)','name' => 'pack_cat'},'PerlIO_read' => {'text' => '','name' => 'PerlIO_read'},'sv_cmp' => {'text' => '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. Is UTF-8 and \'use bytes\' aware, handles get magic, and will coerce its args to strings if necessary. See also C. I32 sv_cmp(SV *const sv1, SV *const sv2)','name' => 'sv_cmp'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C. int mg_free(SV* sv)','name' => 'mg_free'},'sv_force_normal_flags' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to an xpvmg; if we\'re a copy-on-write scalar, this is the on-write time when we do the copy, and is also used locally. If C is set then a copy-on-write scalar drops its PV buffer (if any) and becomes SvPOK_off rather than making a copy. (Used where this scalar is about to be set to some other value.) In addition, the C parameter gets passed to C when unreffing. C calls this function with flags set to 0. void sv_force_normal_flags(SV *const sv, const U32 flags)','name' => 'sv_force_normal_flags'},'cophh_fetch_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of a string/length pair. NOTE: this function is experimental and may change or be removed without notice. SV * cophh_fetch_pv(const COPHH *cophh, const char *key, U32 hash, U32 flags)','name' => 'cophh_fetch_pv'},'tmps_grow' => {'text' => '','name' => 'tmps_grow'},'is_utf8_char' => {'text' => 'DEPRECATED! Tests if some arbitrary number of bytes begins in a valid UTF-8 character. Note that an INVARIANT (i.e. ASCII on non-EBCDIC machines) character is a valid UTF-8 character. The actual number of bytes in the UTF-8 character will be returned if it is valid, otherwise 0. This function is deprecated due to the possibility that malformed input could cause reading beyond the end of the input buffer. Use L instead. STRLEN is_utf8_char(const U8 *s)','name' => 'is_utf8_char'},'get_vtbl' => {'text' => '','name' => 'get_vtbl'},'save_hints' => {'text' => '','name' => 'save_hints'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'gv_fetchmeth_pv_autoload' => {'text' => 'Exactly like L, but takes a nul-terminated string instead of a string/length pair. GV* gv_fetchmeth_pv_autoload(HV* stash, const char* name, I32 level, U32 flags)','name' => 'gv_fetchmeth_pv_autoload'},'sv_utf8_upgrade' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. Forces the SV to string form if it is not already. Will C on C if appropriate. Always sets the SvUTF8 flag to avoid future validity checks even if the whole string is the same in UTF-8 as not. Returns the number of bytes in the converted string This is not as a general purpose byte encoding to Unicode interface: use the Encode extension for that. STRLEN sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. Sets up the C and C variables by calling C and C. This is usually handled automatically by C. dXSARGS;','name' => 'dXSARGS'},'savesharedpv' => {'text' => 'A version of C which allocates the duplicate string in memory which is shared between threads. char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the specified character is a whitespace character in the platform\'s native character set. This is the same as what C<\\s> matches in a regular expression. See the L for an explanation of variants C and C. bool isSPACE(char ch)','name' => 'isSPACE'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function. void Safefree(void* ptr)','name' => 'Safefree'},'custom_op_desc' => {'text' => 'Return the description of a given custom op. This was once used by the OP_DESC macro, but is no longer: it has only been kept for compatibility, and should not be used. const char * custom_op_desc(const OP *o)','name' => 'custom_op_desc'},'regdupe_internal' => {'text' => '','name' => 'regdupe_internal'},'gv_stashpvn' => {'text' => 'Returns a pointer to the stash for a specified package. The C parameter indicates the length of the C, in bytes. C is passed to C, so if set to C then the package will be created if it does not already exist. If the package does not exist and C is 0 (or any other setting that does not create packages) then NULL is returned. HV* gv_stashpvn(const char* name, U32 namelen, I32 flags)','name' => 'gv_stashpvn'},'vmess' => {'text' => 'C and C are a sprintf-style format pattern and encapsulated argument list. These are used to generate a string message. If the message does not end with a newline, then it will be extended with some indication of the current location in the code, as described for L. Normally, the resulting message is returned in a new mortal SV. During global destruction a single SV may be shared between uses of this function. SV * vmess(const char *pat, va_list *args)','name' => 'vmess'},'to_uni_fold' => {'text' => '','name' => 'to_uni_fold'},'new_collate' => {'text' => '','name' => 'new_collate'},'my_stat' => {'text' => '','name' => 'my_stat'},'my_setenv' => {'text' => '','name' => 'my_setenv'},'newSV_type' => {'text' => 'Creates a new SV, of the type specified. The reference count for the new SV is set to 1. SV* newSV_type(const svtype type)','name' => 'newSV_type'},'SvREFCNT_inc_void_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value, and you know that I is not NULL. The macro doesn\'t need to return a meaningful value, or check for NULLness, so it\'s smaller and faster. void SvREFCNT_inc_void_NN(SV* sv)','name' => 'SvREFCNT_inc_void_NN'},'Perl_signbit' => {'text' => 'Return a non-zero integer if the sign bit on an NV is set, and 0 if it is not. If Configure detects this system has a signbit() that will work with our NVs, then we just use it via the #define in perl.h. Otherwise, fall back on this implementation. As a first pass, this gets everything right except -0.0. Alas, catching -0.0 is the main use for this function, so this is not too helpful yet. Still, at least we have the scaffolding in place to support other systems, should that prove useful. Configure notes: This function is called \'Perl_signbit\' instead of a plain \'signbit\' because it is easy to imagine a system having a signbit() function or macro that doesn\'t happen to work with our particular choice of NVs. We shouldn\'t just re-#define signbit as Perl_signbit and expect the standard system headers to be happy. Also, this is a no-context function (no pTHX_) because Perl_signbit() is usually re-#defined in perl.h as a simple macro call to the system\'s signbit(). Users should just always call Perl_signbit(). NOTE: this function is experimental and may change or be removed without notice. int Perl_signbit(NV f)','name' => 'Perl_signbit'},'PUSH_MULTICALL' => {'text' => 'Opening bracket for a lightweight callback. See L. PUSH_MULTICALL;','name' => 'PUSH_MULTICALL'},'new_ctype' => {'text' => '','name' => 'new_ctype'},'save_svref' => {'text' => '','name' => 'save_svref'},'to_uni_upper' => {'text' => '','name' => 'to_uni_upper'},'newNULLLIST' => {'text' => 'Constructs, checks, and returns a new C op, which represents an empty list expression. OP * newNULLLIST()','name' => 'newNULLLIST'},'is_uni_cntrl_lc' => {'text' => '','name' => 'is_uni_cntrl_lc'},'is_utf8_lower' => {'text' => '','name' => 'is_utf8_lower'},'sv_pos_u2b_flags' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from the start of the string, to a count of the equivalent number of bytes; if lenp is non-zero, it does the same to lenp, but this time starting from the offset, rather than from the start of the string. Handles type coercion. I is passed to C, and usually should be C to handle magic. STRLEN sv_pos_u2b_flags(SV *const sv, STRLEN uoffset, STRLEN *const lenp, U32 flags)','name' => 'sv_pos_u2b_flags'},'init_tm' => {'text' => '','name' => 'init_tm'},'newWHILEOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C loop. This is a heavyweight loop, with structure that allows exiting the loop by C and suchlike. I is an optional preconstructed C op to use in the loop; if it is null then a suitable op will be constructed automatically. I supplies the loop\'s controlling expression. I supplies the main body of the loop, and I optionally supplies a C block that operates as a second half of the body. All of these optree inputs are consumed by this function and become part of the constructed op tree. I gives the eight bits of C for the C op and, shifted up eight bits, the eight bits of C for the C op, except that (in both cases) some bits will be set automatically. I is currently unused and should always be 1. I can be supplied as true to force the loop body to be enclosed in its own scope. OP * newWHILEOP(I32 flags, I32 debuggable, LOOP *loop, OP *expr, OP *block, OP *cont, I32 has_my)','name' => 'newWHILEOP'},'Gv_AMupdate' => {'text' => '','name' => 'Gv_AMupdate'},'filter_del' => {'text' => '','name' => 'filter_del'},'POPp' => {'text' => 'Pops a string off the stack. Deprecated. New code should use POPpx. char* POPp','name' => 'POPp'},'SvIV_nomg' => {'text' => 'Like C but doesn\'t process magic. IV SvIV_nomg(SV* sv)','name' => 'SvIV_nomg'},'RETVAL' => {'text' => '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','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not contain an C key. SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'newANONLIST' => {'text' => '','name' => 'newANONLIST'},'mg_findext' => {'text' => 'Finds the magic pointer of C with the given C for the C. See C. MAGIC* mg_findext(const SV* sv, int type, const MGVTBL *vtbl)','name' => 'mg_findext'},'my_memset' => {'text' => '','name' => 'my_memset'},'my_atof2' => {'text' => '','name' => 'my_atof2'},'PerlIO_get_ptr' => {'text' => '','name' => 'PerlIO_get_ptr'},'save_destructor' => {'text' => '','name' => 'save_destructor'},'sv_cmp_flags' => {'text' => '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. Is UTF-8 and \'use bytes\' aware and will coerce its args to strings if necessary. If the flags include SV_GMAGIC, it handles get magic. See also C. I32 sv_cmp_flags(SV *const sv1, SV *const sv2, const U32 flags)','name' => 'sv_cmp_flags'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one operation. SV* hv_iternextsv(HV *hv, char **key, I32 *retlen)','name' => 'hv_iternextsv'},'lex_read_to' => {'text' => 'Consume text in the lexer buffer, from Lbufptr> up to I. This advances Lbufptr> to match I, performing the correct bookkeeping whenever a newline character is passed. This is the normal way to consume lexed text. Interpretation of the buffer\'s octets can be abstracted out by using the slightly higher-level functions L and L. NOTE: this function is experimental and may change or be removed without notice. void lex_read_to(char *ptr)','name' => 'lex_read_to'},'sv_pvbyten_force' => {'text' => 'The backend for the C macro. Always use the macro instead. char* sv_pvbyten_force(SV *const sv, STRLEN *const lp)','name' => 'sv_pvbyten_force'},'reg_named_buff_fetch' => {'text' => '','name' => 'reg_named_buff_fetch'},'ibcmp_locale' => {'text' => 'This is a synonym for (! foldEQ_locale()) I32 ibcmp_locale(const char* a, const char* b, I32 len)','name' => 'ibcmp_locale'},'XST_mIV' => {'text' => '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)','name' => 'XST_mIV'},'save_pptr' => {'text' => '','name' => 'save_pptr'},'PerlIO_set_ptrcnt' => {'text' => '','name' => 'PerlIO_set_ptrcnt'},'mPUSHs' => {'text' => 'Push an SV onto the stack and mortalizes the SV. The stack must have room for this element. Does not use C. See also C and C. void mPUSHs(SV* sv)','name' => 'mPUSHs'},'dump_packsubs' => {'text' => '','name' => 'dump_packsubs'},'is_utf8_digit' => {'text' => '','name' => 'is_utf8_digit'},'GvSV' => {'text' => 'Return the SV from the GV. SV* GvSV(GV* gv)','name' => 'GvSV'},'init_i18nl10n' => {'text' => '','name' => 'init_i18nl10n'},'vform' => {'text' => '','name' => 'vform'},'get_op_descs' => {'text' => '','name' => 'get_op_descs'},'safesyscalloc' => {'text' => '','name' => 'safesyscalloc'},'PL_curpad' => {'text' => 'Points directly to the body of the L array. (I.e., this is C.) NOTE: this function is experimental and may change or be removed without notice.','name' => 'PL_curpad'},'POPi' => {'text' => 'Pops an integer off the stack. IV POPi','name' => 'POPi'},'parse_stmtseq' => {'text' => 'Parse a sequence of zero or more Perl statements. These may be normal imperative statements, including optional labels, or declarations that have compile-time effect, or any mixture thereof. The statement sequence ends when a closing brace or end-of-file is encountered in a place where a new statement could have validly started. It is up to the caller to ensure that the dynamic parser state (L et al) is correctly set to reflect the source of the code to be parsed and the lexical context for the statements. The op tree representing the statement sequence is returned. This may be a null pointer if the statements were all null, for example if there were no statements or if there were only subroutine definitions (which have compile-time side effects). If not null, it will be a C list, normally including C or equivalent ops. If an error occurs in parsing or compilation, in most cases a valid op tree is returned anyway. The error is reflected in the parser state, normally resulting in a single exception at the top level of parsing which covers all the compilation errors that occurred. Some compilation errors, however, will throw an exception immediately. The I parameter is reserved for future use, and must always be zero. NOTE: this function is experimental and may change or be removed without notice. OP * parse_stmtseq(U32 flags)','name' => 'parse_stmtseq'},'sv_2pvutf8_nolen' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV. May cause the SV to be upgraded to UTF-8 as a side-effect. Usually accessed via the C macro. char* sv_2pvutf8_nolen(SV* sv)','name' => 'sv_2pvutf8_nolen'},'gv_HVadd' => {'text' => '','name' => 'gv_HVadd'},'custom_op_xop' => {'text' => 'Return the XOP structure for a given custom op. This function should be considered internal to OP_NAME and the other access macros: use them instead. NOTE: this function must be explicitly called as Perl_custom_op_xop with an aTHX_ parameter. const XOP * Perl_custom_op_xop(pTHX_ const OP *o)','name' => 'custom_op_xop'},'mro_get_linear_isa' => {'text' => 'Returns the mro linearisation for the given stash. By default, this will be whatever C returns unless some other MRO is in effect for the stash. The return value is a read-only AV*. You are responsible for C on the return value if you plan to store it anywhere semi-permanently (otherwise it might be deleted out from under you the next time the cache is invalidated). AV* mro_get_linear_isa(HV* stash)','name' => 'mro_get_linear_isa'},'SvPVbytex' => {'text' => 'Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. char* SvPVbytex(SV* sv, STRLEN len)','name' => 'SvPVbytex'},'av_store' => {'text' => '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 C that was stored there (= 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. Approximate Perl equivalent: C<$myarray[$key] = $val;>. See L for more information on how to use this function on tied arrays. SV** av_store(AV *av, I32 key, SV *val)','name' => 'av_store'},'reg_named_buff_scalar' => {'text' => '','name' => 'reg_named_buff_scalar'},'unlnk' => {'text' => '','name' => 'unlnk'},'av_fetch' => {'text' => 'Returns the SV at the specified index in the array. The C is the index. If lval is true, you are guaranteed to get a real SV back (in case it wasn\'t real before), which you can then modify. 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. The rough perl equivalent is C<$myarray[$idx]>. SV** av_fetch(AV *av, I32 key, I32 lval)','name' => 'av_fetch'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See C. SV* hv_iterval(HV *hv, HE *entry)','name' => 'hv_iterval'},'is_uni_xdigit_lc' => {'text' => '','name' => 'is_uni_xdigit_lc'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. const char* sv_reftype(const SV *const sv, const int ob)','name' => 'sv_reftype'},'foldEQ_locale' => {'text' => 'Returns true if the leading len bytes of the strings s1 and s2 are the same case-insensitively in the current locale; false otherwise. I32 foldEQ_locale(const char* a, const char* b, I32 len)','name' => 'foldEQ_locale'},'cophh_2hv' => {'text' => 'Generates and returns a standard Perl hash representing the full set of key/value pairs in the cop hints hash I. I is currently unused and must be zero. NOTE: this function is experimental and may change or be removed without notice. HV * cophh_2hv(const COPHH *cophh, U32 flags)','name' => 'cophh_2hv'},'SvREFCNT_inc_simple_void_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return value, and you know that I is not NULL. The macro doesn\'t need to return a meaningful value, or check for NULLness, so it\'s smaller and faster. void SvREFCNT_inc_simple_void_NN(SV* sv)','name' => 'SvREFCNT_inc_simple_void_NN'},'rsignal_state' => {'text' => '','name' => 'rsignal_state'},'av_len' => {'text' => 'Returns the highest index in the array. The number of elements in the array is C. Returns -1 if the array is empty. The Perl equivalent for this is C<$#myarray>. I32 av_len(AV *av)','name' => 'av_len'},'sv_unmagic' => {'text' => 'Removes all magic of type C from an SV. int sv_unmagic(SV *const sv, const int type)','name' => 'sv_unmagic'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled, and if some input to the current expression is tainted--usually a variable, but possibly also implicit inputs such as locale settings. C propagates that taintedness to the outputs of an expression in a pessimistic fashion; i.e., without paying attention to precisely which outputs are influenced by which inputs. void SvTAINT(SV* sv)','name' => 'SvTAINT'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C. int mg_clear(SV* sv)','name' => 'mg_clear'},'my_sprintf' => {'text' => 'The C library C, wrapped if necessary, to ensure that it will return the length of the string written to the buffer. Only rare pre-ANSI systems need the wrapper function - usually this is a direct call to C. int my_sprintf(char *buffer, const char *pat, ...)','name' => 'my_sprintf'},'to_utf8_fold' => {'text' => 'Convert the UTF-8 encoded character at C