File Coverage

blib/lib/Perl/APIReference/V5_008_004.pm
Criterion Covered Total %
statement 15 15 100.0
branch n/a
condition n/a
subroutine 4 4 100.0
pod 1 1 100.0
total 20 20 100.0


line stmt bran cond sub pod time code
1             package Perl::APIReference::V5_008_004;
2 1     1   7 use strict;
  1         2  
  1         61  
3 1     1   8 use warnings;
  1         2  
  1         48  
4 1     1   9 use parent 'Perl::APIReference';
  1         1  
  1         10  
5              
6             sub new {
7 1     1 1 4 my $class = shift;
8 1         3 my $VAR1;
9              
10 1         3 do{$VAR1 = {'SvOOK' => {'text' => 'Returns a boolean indicating whether the SvIVX is a valid offset value for
  1         1120  
11             the SvPVX. This hack is used internally to speed up removal of characters
12             from the beginning of a SvPV. When SvOOK is true, then the start of the
13             allocated string buffer is really (SvPVX - SvIVX).
14              
15             bool SvOOK(SV* sv)','name' => 'SvOOK'},'hv_store_ent' => {'text' => 'Stores C in a hash. The hash key is specified as C. The C
16             parameter is the precomputed hash value; if it is zero then Perl will
17             compute it. The return value is the new hash entry so created. It will be
18             NULL if the operation failed or if the value did not need to be actually
19             stored within the hash (as in the case of tied hashes). Otherwise the
20             contents of the return value can be accessed using the C macros
21             described here. Note that the caller is responsible for suitably
22             incrementing the reference count of C before the call, and
23             decrementing it if the function returned NULL. Effectively a successful
24             hv_store_ent takes ownership of one reference to C. This is
25             usually what you want; a newly created SV has a reference count of one, so
26             if all your code does is create SVs then store them in a hash, hv_store
27             will own the only reference to the new SV, and your code doesn\'t need to do
28             anything further to tidy up. Note that hv_store_ent only reads the C;
29             unlike C it does not take ownership of it, so maintaining the correct
30             reference count on C is entirely the caller\'s responsibility. hv_store
31             is not implemented as a call to hv_store_ent, and does not create a temporary
32             SV for the key, so if your key data is not already in SV form then use
33             hv_store in preference to hv_store_ent.
34              
35             See L for more
36             information on how to use this function on tied hashes.
37              
38             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
39             valid UTF-8 string. See C.
40              
41             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
42             the subs.','name' => 'newXSproto'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C.
43              
44             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
45             the second, C. Returns true or false.
46              
47             bool strGE(char* s1, char* s2)','name' => 'strGE'},'form' => {'text' => 'Takes a sprintf-style format pattern and conventional
48             (non-SV) arguments and returns the formatted string.
49              
50             (char *) Perl_form(pTHX_ const char* pat, ...)
51              
52             can be used any place a string (char *) is required:
53              
54             char * s = Perl_form("%d.%d",major,minor);
55              
56             Uses a single private buffer so if you want to format several strings you
57             must explicitly copy the earlier strings away (and free the copies when you
58             are done).
59              
60             char* form(const char* pat, ...)','name' => 'form'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of
61             the SV if the SV does not contain a string. The SV may cache the
62             stringified version becoming C. Handles \'get\' magic. See also
63             C for a version which guarantees to evaluate sv only once.
64              
65             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
66             UTF-8 string, false otherwise. Note that \'a valid UTF-8 string\' does
67             not mean \'a string that contains code points above 0x7F encoded in UTF-8\'
68             because a valid ASCII string is a valid UTF-8 string.
69              
70             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
71             in the C enum. Test these flags with the C macro.','name' => 'svtype'},'hv_clear' => {'text' => 'Clears a hash, making it empty.
72              
73             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
74             Perl variable does not exist then it will be created. If C is not
75             set and the variable does not exist then NULL is returned.
76              
77             NOTE: the perl_ form of this function is deprecated.
78              
79             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.
80             Note that the actual module name, not its filename, should be given.
81             Eg, "Foo::Bar" instead of "Foo/Bar.pm". flags can be any of
82             PERL_LOADMOD_DENY, PERL_LOADMOD_NOIMPORT, or PERL_LOADMOD_IMPORT_OPS
83             (or 0 for no flags). ver, if specified, provides version semantics
84             similar to C. The optional trailing SV*
85             arguments can be used to specify arguments to the module\'s import()
86             method, similar to C.
87              
88             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.
89              
90             XSRETURN_YES;','name' => 'XSRETURN_YES'},'sv_nv' => {'text' => 'A private implementation of the C macro for compilers which can\'t
91             cope with complex macro expressions. Always use the macro instead.
92              
93             NV sv_nv(SV* sv)','name' => 'sv_nv'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with
94             cast.
95              
96             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
97             hopefully catches attempts to access uninitialized memory.
98              
99             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
100             the Perl substr() function.
101              
102             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.
103              
104             void sv_catpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_catpvf_mg'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV.
105              
106             void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'SvPOK' => {'text' => 'Returns a boolean indicating whether the SV contains a character
107             string.
108              
109             bool SvPOK(SV* sv)','name' => 'SvPOK'},'get_sv' => {'text' => 'Returns the SV of the specified Perl scalar. If C is set and the
110             Perl variable does not exist then it will be created. If C is not
111             set and the variable does not exist then NULL is returned.
112              
113             NOTE: the perl_ form of this function is deprecated.
114              
115             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
116             element. See C.
117              
118             void PUSHu(UV uv)','name' => 'PUSHu'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV.
119             (Uses C).
120              
121             SV* newSVsv(SV* old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C.
122              
123             void hv_magic(HV* hv, GV* gv, int how)','name' => 'hv_magic'},'SvPVutf8' => {'text' => 'Like C, but converts sv to utf8 first if necessary.
124              
125             char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic.
126              
127             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
128             C.','name' => 'XS'},'scan_oct' => {'text' => 'For backwards compatibility. Use C instead.
129              
130             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
131             bytes to be copied. Does not handle \'set\' magic. See C.
132              
133             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
134             by an explicit call to FREETMPS, or by an implicit call at places such as
135             statement boundaries. See also C and C.
136              
137             SV* sv_2mortal(SV* sv)','name' => 'sv_2mortal'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C.
138              
139             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
140             it will be upgraded to one. If C is non-null then the new SV will
141             be blessed in the specified package. The new SV is returned and its
142             reference count is 1.
143              
144             SV* newSVrv(SV* rv, const char* classname)','name' => 'newSVrv'},'strnEQ' => {'text' => 'Test two strings to see if they are equal. The C parameter indicates
145             the number of bytes to compare. Returns true or false. (A wrapper for
146             C).
147              
148             bool strnEQ(char* s1, char* s2, STRLEN len)','name' => 'strnEQ'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself.
149              
150             void av_undef(AV* ar)','name' => 'av_undef'},'HeKEY' => {'text' => 'Returns the actual pointer stored in the key slot of the hash entry. The
151             pointer may be either C or C, depending on the value of
152             C. Can be assigned to. The C or C macros are
153             usually preferable for finding the value of a key.
154              
155             void* HeKEY(HE* he)','name' => 'HeKEY'},'pack_cat' => {'text' => 'The engine implementing pack() Perl function. Note: parameters next_in_list and
156             flags are not used. This call should not be used; use packlist instead.
157              
158             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.
159             Returns the unicode code point value of the first character in the string C
160             which is assumed to be in UTF-8 encoding and no longer than C;
161             C will be set to the length, in bytes, of that character.
162              
163             If C does not point to a well-formed UTF-8 character, the behaviour
164             is dependent on the value of C: if it contains UTF8_CHECK_ONLY,
165             it is assumed that the caller will raise a warning, and this function
166             will silently just set C to C<-1> and return zero. If the
167             C does not contain UTF8_CHECK_ONLY, warnings about
168             malformations will be given, C will be set to the expected
169             length of the UTF-8 character in bytes, and zero will be returned.
170              
171             The C can also contain various flags to allow deviations from
172             the strict UTF-8 encoding (see F).
173              
174             Most code should use utf8_to_uvchr() rather than call this directly.
175              
176             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
177             string in C is less than, equal to, or greater than the string in
178             C. Is UTF-8 and \'use bytes\' aware, handles get magic, and will
179             coerce its args to strings if necessary. See also C.
180              
181             I32 sv_cmp(SV* sv1, SV* sv2)','name' => 'sv_cmp'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV.
182              
183             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.
184             See C. Access the character as *(SvEND(sv)).
185              
186             char* SvEND(SV* sv)','name' => 'SvEND'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C to type C if necessary,
187             then adds a new magic item of type C to the head of the magic list.
188              
189             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.
190              
191             int mg_free(SV* sv)','name' => 'mg_free'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C,
192             C or C for void, scalar or list context,
193             respectively.
194              
195             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
196             a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to
197             an xpvmg. The C parameter gets passed to C
198             when unrefing. C calls this function with flags set to 0.
199              
200             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
201             C.
202              
203             dMARK;','name' => 'dMARK'},'sv_setsv_flags' => {'text' => 'Copies the contents of the source SV C into the destination SV
204             C. The source SV may be destroyed if it is mortal, so don\'t use this
205             function if the source SV needs to be reused. Does not handle \'set\' magic.
206             Loosely speaking, it performs a copy-by-value, obliterating any previous
207             content of the destination.
208             If the C parameter has the C bit set, will C on
209             C if appropriate, else not. C and C are
210             implemented in terms of this function.
211              
212             You probably want to use one of the assortment of wrappers, such as
213             C, C, C and
214             C.
215              
216             This is the primary function for copying scalars, and most other
217             copy-ish functions and macros use this underneath.
218              
219             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.
220             Forces the SV to string form if it is not already.
221             Always sets the SvUTF8 flag to avoid future validity checks even
222             if all the bytes have hibit clear. If C has C bit set,
223             will C on C if appropriate, else not. C and
224             C are implemented in terms of this function.
225              
226             This is not as a general purpose byte encoding to Unicode interface:
227             use the Encode extension for that.
228              
229             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.
230              
231             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
232             character. Note that an INVARIANT (i.e. ASCII) character is a valid
233             UTF-8 character. The actual number of bytes in the UTF-8 character
234             will be returned if it is valid, otherwise 0.
235              
236             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
237             source, C is the destination, C is the number of items, and C is
238             the type. May fail on overlapping copies. See also C.
239              
240             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
241             if not (if they are equal case-insensitively). If u1 is true, the
242             string s1 is assumed to be in UTF-8-encoded Unicode. If u2 is true,
243             the string s2 is assumed to be in UTF-8-encoded Unicode. If u1 or u2
244             are false, the respective string is assumed to be in native 8-bit
245             encoding.
246              
247             If the pe1 and pe2 are non-NULL, the scanning pointers will be copied
248             in there (they will point at the beginning of the I character).
249             If the pointers behind pe1 or pe2 are non-NULL, they are the end
250             pointers beyond which scanning will not continue under any
251             circustances. If the byte lengths l1 and l2 are non-zero, s1+l1 and
252             s2+l2 will be used as goal end pointers that will also stop the scan,
253             and which qualify towards defining a successful match: all the scans
254             that define an explicit length must reach their goal pointers for
255             a match to succeed).
256              
257             For case-insensitiveness, the "casefolding" of Unicode is used
258             instead of upper/lowercasing both the characters, see
259             http://www.unicode.org/unicode/reports/tr21/ (Case Mappings).
260              
261             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.
262              
263             HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'sv_taint' => {'text' => 'Taint an SV. Use C instead.
264             void sv_taint(SV* sv)','name' => 'sv_taint'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV.
265              
266             void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original.
267             The target SV physically takes over ownership of the body of the source SV
268             and inherits its flags; however, the target keeps any magic it owns,
269             and any magic in the source is discarded.
270             Note that this is a rather specialist SV copying operation; most of the
271             time you\'ll want to use C or one of its many macro front-ends.
272              
273             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
274             which is assumed to be in UTF-8 encoding; C will be set to the
275             length, in bytes, of that character.
276              
277             Allows length and flags to be passed to low level routine.
278              
279             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.
280             Forces the SV to string form if it is not already.
281             Always sets the SvUTF8 flag to avoid future validity checks even
282             if all the bytes have hibit clear.
283              
284             This is not as a general purpose byte encoding to Unicode interface:
285             use the Encode extension for that.
286              
287             STRLEN sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains a signed integer.
288              
289             bool SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and
290             L.','name' => 'G_ARRAY'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK.
291             Sets up the C and C variables by calling C and C.
292             This is usually handled automatically by C.
293              
294             dXSARGS;','name' => 'dXSARGS'},'sv_2iv' => {'text' => 'Return the integer value of an SV, doing any necessary string conversion,
295             magic etc. Normally used via the C and C macros.
296              
297             IV sv_2iv(SV* sv)','name' => 'sv_2iv'},'savesharedpv' => {'text' => 'A version of C which allocates the duplicate string in memory
298             which is shared between threads.
299              
300             char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'XS_VERSION_BOOTCHECK' => {'text' => 'Macro to verify that a PM module\'s $VERSION variable matches the XS
301             module\'s C variable. This is usually handled automatically by
302             C. See L.
303              
304             XS_VERSION_BOOTCHECK;','name' => 'XS_VERSION_BOOTCHECK'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function.
305              
306             void Safefree(void* ptr)','name' => 'Safefree'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the C C is whitespace.
307              
308             bool isSPACE(char ch)','name' => 'isSPACE'},'SvROK' => {'text' => 'Tests if the SV is an RV.
309              
310             bool SvROK(SV* sv)','name' => 'SvROK'},'sv_unref' => {'text' => 'Unsets the RV status of the SV, and decrements the reference count of
311             whatever was being referenced by the RV. This can almost be thought of
312             as a reversal of C. This is C with the C
313             being zero. See C.
314              
315             void sv_unref(SV* sv)','name' => 'sv_unref'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its
316             argument more than once.
317              
318             void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See
319             L.','name' => 'G_EVAL'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic.
320              
321             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.
322              
323             NOTE: the perl_ form of this function is deprecated.
324              
325             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
326             the SV if the SV does not contain a string. The SV may cache the
327             stringified form becoming C. Handles \'get\' magic.
328              
329             char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'perl_clone' => {'text' => 'Create and return a new interpreter by cloning the current one.
330              
331             perl_clone takes these flags as parameters:
332              
333             CLONEf_COPY_STACKS - is used to, well, copy the stacks also,
334             without it we only clone the data and zero the stacks,
335             with it we copy the stacks and the new perl interpreter is
336             ready to run at the exact same point as the previous one.
337             The pseudo-fork code uses COPY_STACKS while the
338             threads->new doesn\'t.
339              
340             CLONEf_KEEP_PTR_TABLE
341             perl_clone keeps a ptr_table with the pointer of the old
342             variable as a key and the new variable as a value,
343             this allows it to check if something has been cloned and not
344             clone it again but rather just use the value and increase the
345             refcount. If KEEP_PTR_TABLE is not set then perl_clone will kill
346             the ptr_table using the function
347             C,
348             reason to keep it around is if you want to dup some of your own
349             variable who are outside the graph perl scans, example of this
350             code is in threads.xs create
351              
352             CLONEf_CLONE_HOST
353             This is a win32 thing, it is ignored on unix, it tells perls
354             win32host code (which is c++) to clone itself, this is needed on
355             win32 if you want to run two threads at the same time,
356             if you just want to do some stuff in a separate perl interpreter
357             and then throw it away and return to the original one,
358             you don\'t need to do anything.
359              
360             PerlInterpreter* perl_clone(PerlInterpreter* interp, UV flags)','name' => 'perl_clone'},'sv_setnv' => {'text' => 'Copies a double into the given SV, upgrading first if necessary.
361             Does not handle \'set\' magic. See also C.
362              
363             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
364             conversion, magic etc. Normally used via the C and C
365             macros.
366              
367             NV sv_2nv(SV* sv)','name' => 'sv_2nv'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments
368             more than once.
369              
370             void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'XPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C
371             indicates the length of the string. Handles \'set\' magic. See
372             C.
373              
374             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
375             flag so that it looks like octets again. Used as a building block
376             for encode_utf8 in Encode.xs
377              
378             void sv_utf8_encode(SV *sv)','name' => 'sv_utf8_encode'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1.
379              
380             HV* newHV()','name' => 'newHV'},'strnNE' => {'text' => 'Test two strings to see if they are different. The C parameter
381             indicates the number of bytes to compare. Returns true or false. (A
382             wrapper for C).
383              
384             bool strnNE(char* s1, char* s2, STRLEN len)','name' => 'strnNE'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or
385             false.
386              
387             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).
388             Do not use frivolously.
389              
390             void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic.
391              
392             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
393             which can\'t cope with complex macro expressions. Always use the macro
394             instead.
395              
396             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
397             string which is a duplicate of C. The size of the string is
398             determined by C. The memory allocated for the new string can
399             be freed with the C function.
400              
401             char* savepv(const char* pv)','name' => 'savepv'},'toLOWER' => {'text' => 'Converts the specified character to lowercase.
402              
403             char toLOWER(char ch)','name' => 'toLOWER'},'bytes_from_utf8' => {'text' => 'Converts a string C of length C from UTF-8 into byte encoding.
404             Unlike but like C, returns a pointer to
405             the newly-created string, and updates C to contain the new
406             length. Returns the original string if no conversion occurs, C
407             is unchanged. Do nothing if C points to 0. Sets C to
408             0 if C is converted or contains all 7bit characters.
409              
410             NOTE: this function is experimental and may change or be
411             removed without notice.
412              
413             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.
414              
415             AV* newAV()','name' => 'newAV'},'POPp' => {'text' => 'Pops a string off the stack. Deprecated. New code should provide
416             a STRLEN n_a and use POPpx.
417              
418             char* POPp','name' => 'POPp'},'HvNAME' => {'text' => 'Returns the package name of a stash. See C, C.
419              
420             char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV
421             of the sv is assumed to be octets in that encoding, and the sv
422             will be converted into Unicode (and UTF-8).
423              
424             If the sv already is UTF-8 (or if it is not POK), or if the encoding
425             is not a reference, nothing is done to the sv. If the encoding is not
426             an C Encoding object, bad things will happen.
427             (See F and L).
428              
429             The PV of the sv is returned.
430              
431             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
432             into the array, so they may be freed after the call to av_make. The new AV
433             will have a reference count of 1.
434              
435             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
436             XSUB. This is always the proper type for the XSUB. See
437             L.
438              
439             (whatever) RETVAL','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not
440             contain an C key.
441              
442             SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. See C
443             for a version which guarantees to evaluate sv only once.
444              
445             UV SvUV(SV* sv)','name' => 'SvUV'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L.
446              
447             int perl_run(PerlInterpreter* interp)','name' => 'perl_run'},'sv_pvbyten' => {'text' => 'A private implementation of the C macro for compilers
448             which can\'t cope with complex macro expressions. Always use the macro
449             instead.
450              
451             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
452             SV C. Modifies C but not C. If C has C
453             bit set, will C on the SVs if appropriate, else not. C
454             and C are implemented in terms of this function.
455              
456             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
457             destination SV. Automatically performs any necessary mg_get and
458             coercion of numeric values into strings. Guaranteed to preserve
459             UTF-8 flag even from overloaded objects. Similar in nature to
460             sv_2pv[_flags] but operates directly on an SV instead of just the
461             string. Mostly uses sv_2pv_flags to do its work, except when that
462             would lose the UTF-8\'ness of the PV.
463              
464             void sv_copypv(SV* dsv, SV* ssv)','name' => 'sv_copypv'},'sv_pv' => {'text' => 'Use the C macro instead
465              
466             char* sv_pv(SV *sv)','name' => 'sv_pv'},'SvPVutf8_nolen' => {'text' => 'Like C, but converts sv to utf8 first if necessary.
467              
468             char* SvPVutf8_nolen(SV* sv)','name' => 'SvPVutf8_nolen'},'sv_setpviv' => {'text' => 'Copies an integer into the given SV, also updating its string value.
469             Does not handle \'set\' magic. See C.
470              
471             void sv_setpviv(SV* sv, IV num)','name' => 'sv_setpviv'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic.
472              
473             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.
474             Use the C macro instead, which may call C or may
475             instead use an in-line version.
476              
477             I32 sv_true(SV *sv)','name' => 'sv_true'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one
478             operation.
479              
480             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.
481             Unlike C, this over-writes the original string, and
482             updates len to contain the new length.
483             Returns zero on failure, setting C to -1.
484              
485             NOTE: this function is experimental and may change or be
486             removed without notice.
487              
488             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
489             which can\'t cope with complex macro expressions. Always use the macro
490             instead.
491              
492             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
493             class. This is the function that implements C. It works
494             for class names as well as for objects.
495              
496             bool sv_derived_from(SV* sv, const char* name)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer.
497              
498             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
499             \'use bytes\' aware, handles get magic, and will coerce its args to strings
500             if necessary. See also C. See also C.
501              
502             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
503             of the string C; C should be have at least C free
504             bytes available. The return value is the pointer to the byte after the
505             end of the new character. In other words,
506              
507             d = uvuni_to_utf8_flags(d, uv, flags);
508              
509             or, in most cases,
510              
511             d = uvuni_to_utf8(d, uv);
512              
513             (which is equivalent to)
514              
515             d = uvuni_to_utf8_flags(d, uv, 0);
516              
517             is the recommended Unicode-aware way of saying
518              
519             *(d++) = uv;
520              
521             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
522             value is stored in a new mortal SV.
523              
524             void XST_mIV(int pos, IV iv)','name' => 'XST_mIV'},'hv_exists' => {'text' => 'Returns a boolean indicating whether the specified hash key exists. The
525             C is the length of the key.
526              
527             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
528             the C macro. See C.
529              
530             dSP;','name' => 'dSP'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See
531             L.','name' => 'G_DISCARD'},'Nullsv' => {'text' => 'Null SV pointer.','name' => 'Nullsv'},'mg_length' => {'text' => 'Report on the SV\'s length. See C.
532              
533             U32 mg_length(SV* sv)','name' => 'mg_length'},'GvSV' => {'text' => 'Return the SV from the GV.
534              
535             SV* GvSV(GV* gv)','name' => 'GvSV'},'SvPVX' => {'text' => 'Returns a pointer to the physical string in the SV. The SV must contain a
536             string.
537              
538             char* SvPVX(SV* sv)','name' => 'SvPVX'},'XST_mNV' => {'text' => 'Place a double into the specified position C on the stack. The value
539             is stored in a new mortal SV.
540              
541             void XST_mNV(int pos, NV nv)','name' => 'XST_mNV'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles
542             \'set\' magic. See C.
543              
544             void XPUSHi(IV iv)','name' => 'XPUSHi'},'HEf_SVKEY' => {'text' => 'This flag, used in the length slot of hash entries and magic structures,
545             specifies the structure contains an C pointer where a C pointer
546             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.
547             Use macro PAD_SV instead of calling this function directly.
548              
549             SV* pad_sv(PADOFFSET po)','name' => 'pad_sv'},'POPi' => {'text' => 'Pops an integer off the stack.
550              
551             IV POPi','name' => 'POPi'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C in characters.
552             Stops at C (inclusive). If C s> or if the scan would end
553             up past C, croaks.
554              
555             STRLEN utf8_length(U8* s, U8 *e)','name' => 'utf8_length'},'SvPVutf8_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary.
556              
557             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.
558             May cause the SV to be upgraded to UTF-8 as a side-effect.
559              
560             Usually accessed via the C macro.
561              
562             char* sv_2pvutf8_nolen(SV* sv)','name' => 'sv_2pvutf8_nolen'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted if tainting is enabled.
563              
564             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.
565              
566             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.
567             Exists to avoid test for a NULL function pointer and because it could potentially warn under
568             some level of strict-ness.
569              
570             void sv_nolocking(SV *)','name' => 'sv_nolocking'},'sv_vcatpvfn' => {'text' => 'Processes its arguments like C and appends the formatted output
571             to an SV. Uses an array of SVs if the C style variable argument list is
572             missing (NULL). When running with taint checks enabled, indicates via
573             C if results are untrustworthy (often due to the use of
574             locales).
575              
576             Usually used via one of its frontends C and C.
577              
578             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.
579             Guarantees to evaluate sv only once; use the more efficient C
580             otherwise.
581              
582             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
583             return value will be NULL if the operation failed or if the value did not
584             need to be actually stored within the array (as in the case of tied
585             arrays). Otherwise it can be dereferenced to get the original C. Note
586             that the caller is responsible for suitably incrementing the reference
587             count of C before the call, and decrementing it if the function
588             returned NULL.
589              
590             See L for
591             more information on how to use this function on tied arrays.
592              
593             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
594             conversion, magic etc. Normally used via the C and C
595             macros.
596              
597             UV sv_2uv(SV* sv)','name' => 'sv_2uv'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and
598             L.
599              
600             PUSHMARK;','name' => 'PUSHMARK'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack.
601              
602             SV* ST(int ix)','name' => 'ST'},'strLT' => {'text' => 'Test two strings to see if the first, C, is less than the second,
603             C. Returns true or false.
604              
605             bool strLT(char* s1, char* s2)','name' => 'strLT'},'sv_pvutf8n' => {'text' => 'A private implementation of the C macro for compilers
606             which can\'t cope with complex macro expressions. Always use the macro
607             instead.
608              
609             char* sv_pvutf8n(SV *sv, STRLEN *len)','name' => 'sv_pvutf8n'},'call_pv' => {'text' => 'Performs a callback to the specified Perl sub. See L.
610              
611             NOTE: the perl_ form of this function is deprecated.
612              
613             I32 call_pv(const char* sub_name, I32 flags)','name' => 'call_pv'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array.
614              
615             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
616             with an initial PV allocation of len+1. Normally accessed via the C
617             macro.
618              
619             SV* newSV(STRLEN len)','name' => 'newSV'},'av_fetch' => {'text' => 'Returns the SV at the specified index in the array. The C is the
620             index. If C is set then the fetch will be part of a store. Check
621             that the return value is non-null before dereferencing it to a C.
622              
623             See L for
624             more information on how to use this function on tied arrays.
625              
626             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.
627              
628             void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'gv_fetchmeth_autoload' => {'text' => 'Same as gv_fetchmeth(), but looks for autoloaded subroutines too.
629             Returns a glob for the subroutine.
630              
631             For an autoloaded subroutine without a GV, will create a GV even
632             if C. For an autoloaded subroutine without a stub, GvCV()
633             of the result may be zero.
634              
635             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
636             to its length. May cause the SV to be upgraded to UTF-8 as a side-effect.
637              
638             Usually accessed via the C macro.
639              
640             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.
641             Exists to avoid test for a NULL function pointer and because it could potentially warn under
642             some level of strict-ness.
643              
644             void sv_nounlocking(SV *)','name' => 'sv_nounlocking'},'dITEMS' => {'text' => 'Sets up the C variable.
645             This is usually handled automatically by C by calling C.
646              
647             dITEMS;','name' => 'dITEMS'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See
648             C.
649              
650             SV* hv_iterval(HV* tb, HE* entry)','name' => 'hv_iterval'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to.
651              
652             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
653             start of the string, to a count of the equivalent number of UTF-8 chars.
654             Handles magic and type coercion.
655              
656             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
657             empty.
658              
659             I32 av_len(AV* ar)','name' => 'av_len'},'SvIsCOW' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write. (either shared
660             hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for
661             COW)
662              
663             bool SvIsCOW(SV* sv)','name' => 'SvIsCOW'},'sv_unmagic' => {'text' => 'Removes all magic of type C from an SV.
664              
665             int sv_unmagic(SV* sv, int type)','name' => 'sv_unmagic'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic.
666              
667             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
668             SV C. Modifies C but not C. Handles \'get\' magic, but
669             not \'set\' magic. See C.
670              
671             void sv_catsv(SV* dsv, SV* ssv)','name' => 'sv_catsv'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled.
672              
673             void SvTAINT(SV* sv)','name' => 'SvTAINT'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C.
674             See C and L for other uses.
675              
676             PUTBACK;','name' => 'PUTBACK'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string.
677              
678             void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'ax' => {'text' => 'Variable which is setup by C to indicate the stack base offset,
679             used by the C, C and C macros. The C macro
680             must be called prior to setup the C variable.
681              
682             I32 ax','name' => 'ax'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C.
683              
684             int mg_clear(SV* sv)','name' => 'mg_clear'},'SvCUR_set' => {'text' => 'Set the length of the string which is in the SV. See C.
685              
686             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
687             store that in UTF-8 in ustrp and its length in bytes in lenp. Note
688             that the ustrp needs to be at least UTF8_MAXLEN_FOLD+1 bytes since the
689             foldcase version may be longer than the original character (up to
690             three characters).
691              
692             The first character of the foldcased version is returned
693             (but note, as explained above, that there may be more.)
694              
695             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
696             store that in UTF-8 in ustrp and its length in bytes in lenp. Note
697             that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the
698             uppercase version may be longer than the original character (up to two
699             characters).
700              
701             The first character of the uppercased version is returned
702             (but note, as explained above, that there may be more.)
703              
704             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.
705              
706             bool SvNOK(SV* sv)','name' => 'SvNOK'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. C should
707             be a valid UTF-8 string. If C is set then the package will be
708             created if it does not already exist. If C is not set and the
709             package does not exist then NULL is returned.
710              
711             HV* gv_stashpv(const char* name, I32 create)','name' => 'gv_stashpv'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C, C, and
712             L.','name' => 'G_SCALAR'},'SvPVutf8x_force' => {'text' => 'Like C, but converts sv to utf8 first if necessary.
713             Guarantees to evaluate sv only once; use the more efficient C
714             otherwise.
715              
716             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.
717             Handles \'set\' magic. See C.
718              
719             void PUSHi(IV iv)','name' => 'PUSHi'},'sv_reset' => {'text' => 'Underlying implementation for the C Perl function.
720             Note that the perl-level function is vaguely deprecated.
721              
722             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
723             can be a valid precomputed hash value, or 0 to ask for it to be
724             computed.
725              
726             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
727             store that in UTF-8 in ustrp and its length in bytes in lenp. Note
728             that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the
729             lowercase version may be longer than the original character (up to two
730             characters).
731              
732             The first character of the lowercased version is returned
733             (but note, as explained above, that there may be more.)
734              
735             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
736             double.
737              
738             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.
739             If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string
740             if necessary.
741             Normally invoked via the C macro. C and C
742             usually end up here too.
743              
744             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
745             some of Perl\'s fundamental security features. XS module authors should not
746             use this function unless they fully understand all the implications of
747             unconditionally untainting the value. Untainting should be done in the
748             standard perl fashion, via a carefully crafted regexp, rather than directly
749             untainting variables.
750              
751             void SvTAINTED_off(SV* sv)','name' => 'SvTAINTED_off'},'SvNVx' => {'text' => 'Coerces the given SV to a double and returns it. Guarantees to evaluate
752             sv only once. Use the more efficient C otherwise.
753              
754             NV SvNVx(SV* sv)','name' => 'SvNVx'},'unpack_str' => {'text' => 'The engine implementing unpack() Perl function. Note: parameters strbeg, new_s
755             and ocnt are not used. This call should not be used, use unpackstring instead.
756              
757             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
758             C.
759              
760             SV* newSVpvf(const char* pat, ...)','name' => 'newSVpvf'},'require_pv' => {'text' => 'Tells Perl to C the file named by the string argument. It is
761             analogous to the Perl code C. It\'s even
762             implemented that way; consider using load_module instead.
763              
764             NOTE: the perl_ form of this function is deprecated.
765              
766             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
767             SV, then copies across as much information as possible from the old body.
768             You generally want to use the C macro wrapper. See also C.
769              
770             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.
771              
772             bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C wrapper
773             instead.
774              
775             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
776             the length of the key. The C parameter is the precomputed hash
777             value; if it is zero then Perl will compute it. The return value will be
778             NULL if the operation failed or if the value did not need to be actually
779             stored within the hash (as in the case of tied hashes). Otherwise it can
780             be dereferenced to get the original C. Note that the caller is
781             responsible for suitably incrementing the reference count of C before
782             the call, and decrementing it if the function returned NULL. Effectively
783             a successful hv_store takes ownership of one reference to C. This is
784             usually what you want; a newly created SV has a reference count of one, so
785             if all your code does is create SVs then store them in a hash, hv_store
786             will own the only reference to the new SV, and your code doesn\'t need to do
787             anything further to tidy up. hv_store is not implemented as a call to
788             hv_store_ent, and does not create a temporary SV for the key, so if your
789             key data is not already in SV form then use hv_store in preference to
790             hv_store_ent.
791              
792             See L for more
793             information on how to use this function on tied hashes.
794              
795             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.
796             Only use when you are sure SvIOK is true. See also C.
797              
798             IV SvIVX(SV* sv)','name' => 'SvIVX'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C.
799              
800             void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L.
801              
802             int perl_destruct(PerlInterpreter* interp)','name' => 'perl_destruct'},'sv_uni_display' => {'text' => 'Build to the scalar dsv a displayable version of the scalar sv,
803             the displayable version being at most pvlim bytes long
804             (if longer, the rest is truncated and "..." will be appended).
805              
806             The flags argument is as in pv_uni_display().
807              
808             The pointer to the PV of the dsv is returned.
809              
810             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
811             character.
812              
813             bool isUPPER(char ch)','name' => 'isUPPER'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV.
814              
815             void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C into the destination SV
816             C. The source SV may be destroyed if it is mortal, so don\'t use this
817             function if the source SV needs to be reused. Does not handle \'set\' magic.
818             Loosely speaking, it performs a copy-by-value, obliterating any previous
819             content of the destination.
820              
821             You probably want to use one of the assortment of wrappers, such as
822             C, C, C and
823             C.
824              
825             void sv_setsv(SV* dsv, SV* ssv)','name' => 'sv_setsv'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV.
826              
827             void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the
828             stack.
829              
830             void XST_mYES(int pos)','name' => 'XST_mYES'},'POPs' => {'text' => 'Pops an SV off the stack.
831              
832             SV* POPs','name' => 'POPs'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C for a version
833             which guarantees to evaluate sv only once.
834              
835             NV SvNV(SV* sv)','name' => 'SvNV'},'packlist' => {'text' => 'The engine implementing pack() Perl function.
836              
837             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.
838              
839             bool SvUTF8(SV* sv)','name' => 'SvUTF8'},'gv_fetchmethod_autoload' => {'text' => 'Returns the glob which contains the subroutine to call to invoke the method
840             on the C. In fact in the presence of autoloading this may be the
841             glob for "AUTOLOAD". In this case the corresponding variable $AUTOLOAD is
842             already setup.
843              
844             The third parameter of C determines whether
845             AUTOLOAD lookup is performed if the given method is not present: non-zero
846             means yes, look for AUTOLOAD; zero means no, don\'t look for AUTOLOAD.
847             Calling C is equivalent to calling C
848             with a non-zero C parameter.
849              
850             These functions grant C<"SUPER"> token as a prefix of the method name. Note
851             that if you want to keep the returned glob for a long time, you need to
852             check for it being "AUTOLOAD", since at the later time the call may load a
853             different subroutine due to $AUTOLOAD changing its value. Use the glob
854             created via a side effect to do this.
855              
856             These functions have the same side-effects and as C with
857             C. C should be writable if contains C<\':\'> or C<\'
858             \'\'>. The warning against passing the GV returned by C to
859             C apply equally to these functions.
860              
861             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.
862              
863             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.
864             C must be a valid precomputed hash number for the given C, or 0
865             if you want the function to compute it. IF C is set then the fetch
866             will be part of a store. Make sure the return value is non-null before
867             accessing it. The return value when C is a tied hash is a pointer to a
868             static location, so be sure to make a copy of the structure if you need to
869             store it somewhere.
870              
871             See L for more
872             information on how to use this function on tied hashes.
873              
874             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
875             character.
876              
877             bool isLOWER(char ch)','name' => 'isLOWER'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L.
878              
879             ENTER;','name' => 'ENTER'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are
880             identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will
881             coerce its args to strings if necessary.
882              
883             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
884             not.
885              
886             bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as
887             C<&PL_sv_no>.
888              
889             SV PL_sv_no','name' => 'PL_sv_no'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See
890             C.
891              
892             char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an
893             XSUB\'s aliases was used to invoke it. See L.
894              
895             I32 ix','name' => 'ix'},'SvNOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a double. Checks the
896             B setting. Use C.
897              
898             bool SvNOKp(SV* sv)','name' => 'SvNOKp'},'XSRETURN_UV' => {'text' => 'Return an integer from an XSUB immediately. Uses C.
899              
900             void XSRETURN_UV(IV uv)','name' => 'XSRETURN_UV'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another.
901              
902             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
903             by an explicit C, or by the reference count going to zero.
904             In the former case, we keep the CvOUTSIDE pointer, so that any anonymous
905             children can still follow the full lexical scope chain.
906              
907             void cv_undef(CV* cv)','name' => 'cv_undef'},'PUSHs' => {'text' => 'Push an SV onto the stack. The stack must have room for this element.
908             Does not handle \'set\' magic. See C.
909              
910             void PUSHs(SV* sv)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary.
911             Does not handle \'set\' magic. See also C.
912              
913             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
914             perform the upgrade if necessary. See C.
915              
916             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
917             which is assumed to be in UTF-8 encoding; C will be set to the
918             length, in bytes, of that character.
919              
920             If C does not point to a well-formed UTF-8 character, zero is
921             returned and retlen is set, if possible, to -1.
922              
923             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
924             no threads.
925              
926             int nothreadhook()','name' => 'nothreadhook'},'items' => {'text' => 'Variable which is setup by C to indicate the number of
927             items on the stack. See L.
928              
929             I32 items','name' => 'items'},'bytes_to_utf8' => {'text' => 'Converts a string C of length C from ASCII into UTF-8 encoding.
930             Returns a pointer to the newly-created string, and sets C to
931             reflect the new length.
932              
933             If you want to convert to UTF-8 from other encodings than ASCII,
934             see sv_recode_to_utf8().
935              
936             NOTE: this function is experimental and may change or be
937             removed without notice.
938              
939             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
940             cope with complex macro expressions. Always use the macro instead.
941              
942             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
943             scalar.
944              
945             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.
946             The value is stored in a new mortal SV.
947              
948             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
949             handled automatically by C.
950              
951             dXSI32;','name' => 'dXSI32'},'sv_setref_iv' => {'text' => 'Copies an integer into a new SV, optionally blessing the SV. The C
952             argument will be upgraded to an RV. That RV will be modified to point to
953             the new SV. The C argument indicates the package for the
954             blessing. Set C to C to avoid the blessing. The new SV
955             will have a reference count of 1, and the RV will be returned.
956              
957             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.
958             SvPOK(sv) must be true and the C must be a pointer to somewhere inside
959             the string buffer. The C becomes the first character of the adjusted
960             string. Uses the "OOK hack".
961             Beware: after this function returns, C and SvPVX(sv) may no longer
962             refer to the same chunk of data.
963              
964             void sv_chop(SV* sv, char* ptr)','name' => 'sv_chop'},'SvPVx' => {'text' => 'A version of C which guarantees to evaluate sv only once.
965              
966             char* SvPVx(SV* sv, STRLEN len)','name' => 'SvPVx'},'sv_backoff' => {'text' => 'Remove any string offset. You should normally use the C macro
967             wrapper instead.
968              
969             int sv_backoff(SV* sv)','name' => 'sv_backoff'},'sv_tainted' => {'text' => 'Test an SV for taintedness. Use C instead.
970             bool sv_tainted(SV* sv)','name' => 'sv_tainted'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. If necessary, uses C and
971             upgrades the SV to C. Returns a pointer to the character buffer.
972             Use the C wrapper instead.
973              
974             char* sv_grow(SV* sv, STRLEN newlen)','name' => 'sv_grow'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary.
975             See C.
976              
977             void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic.
978              
979             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
980             value returned by the sub. Otherwise, returns NULL.
981              
982             Constant subs can be created with C or as described in
983             L.
984              
985             SV* cv_const_sv(CV* cv)','name' => 'cv_const_sv'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually
986             handled automatically by C. See C.','name' => 'XS_VERSION'},'newSVnv' => {'text' => 'Creates a new SV and copies a floating point value into it.
987             The reference count for the SV is set to 1.
988              
989             SV* newSVnv(NV n)','name' => 'newSVnv'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not
990             handle \'set\' magic. See C.
991              
992             void XPUSHs(SV* sv)','name' => 'XPUSHs'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry.
993              
994             SV* HeVAL(HE* he)','name' => 'HeVAL'},'PL_na' => {'text' => 'A convenience variable which is typically used with C when one
995             doesn\'t care about the length of the string. It is usually more efficient
996             to either declare a local variable and use that instead or to use the
997             C macro.
998              
999             STRLEN PL_na','name' => 'PL_na'},'HePV' => {'text' => 'Returns the key slot of the hash entry as a C value, doing any
1000             necessary dereferencing of possibly C keys. The length of the string
1001             is placed in C (this is a macro, so do I use C<&len>). If you do
1002             not care about what the length of the key is, you may use the global
1003             variable C, though this is rather less efficient than using a local
1004             variable. Remember though, that hash keys in perl are free to contain
1005             embedded nulls, so using C or similar is not a good way to find
1006             the length of hash keys. This is very similar to the C macro
1007             described elsewhere in this document.
1008              
1009             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
1010             SV is set to 1.
1011              
1012             SV* newSViv(IV i)','name' => 'newSViv'},'sv_untaint' => {'text' => 'Untaint an SV. Use C instead.
1013             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
1014             handle \'set\' magic. See C.
1015              
1016             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,
1017             length len, the displayable version being at most pvlim bytes long
1018             (if longer, the rest is truncated and "..." will be appended).
1019              
1020             The flags argument can have UNI_DISPLAY_ISPRINT set to display
1021             isPRINT()able characters as themselves, UNI_DISPLAY_BACKSLASH
1022             to display the \\\\[nrfta\\\\] as the backslashed versions (like \'\\n\')
1023             (UNI_DISPLAY_BACKSLASH is preferred over UNI_DISPLAY_ISPRINT for \\\\).
1024             UNI_DISPLAY_QQ (and its alias UNI_DISPLAY_REGEX) have both
1025             UNI_DISPLAY_BACKSLASH and UNI_DISPLAY_ISPRINT turned on.
1026              
1027             The pointer to the PV of the dsv is returned.
1028              
1029             char* pv_uni_display(SV *dsv, U8 *spv, STRLEN len, STRLEN pvlim, UV flags)','name' => 'pv_uni_display'},'gv_fetchmethod' => {'text' => 'See L.
1030              
1031             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
1032             argument more than once.
1033              
1034             void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'SvGROW' => {'text' => 'Expands the character buffer in the SV so that it has room for the
1035             indicated number of bytes (remember to reserve space for an extra trailing
1036             NUL character). Calls C to perform the expansion if necessary.
1037             Returns a pointer to the character buffer.
1038              
1039             char * SvGROW(SV* sv, STRLEN len)','name' => 'SvGROW'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion
1040             if necessary. Handles \'get\' magic.
1041              
1042             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
1043             stored inside the SV but sv_usepvn allows the SV to use an outside string.
1044             The C should point to memory that was allocated by C. The
1045             string length, C, must be supplied. This function will realloc the
1046             memory pointed to by C, so that pointer should not be freed or used by
1047             the programmer after giving it to sv_usepvn. Does not handle \'set\' magic.
1048             See C.
1049              
1050             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.
1051             Guarantees to evaluate sv only once; use the more efficient C
1052             otherwise.
1053              
1054             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.
1055             If the SV has the UTF-8 status set, then the bytes appended should be
1056             valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C.
1057              
1058             void sv_catpv(SV* sv, const char* ptr)','name' => 'sv_catpv'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count.
1059              
1060             U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'sv_len' => {'text' => 'Returns the length of the string in the SV. Handles magic and type
1061             coercion. See also C, which gives raw access to the xpv_cur slot.
1062              
1063             STRLEN sv_len(SV* sv)','name' => 'sv_len'},'warn' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Call this
1064             function the same way you call the C C function. See C.
1065              
1066             void warn(const char* pat, ...)','name' => 'warn'},'sv_pvutf8' => {'text' => 'Use the C macro instead
1067              
1068             char* sv_pvutf8(SV *sv)','name' => 'sv_pvutf8'},'SvPVbyte_nolen' => {'text' => 'Like C, but converts sv to byte representation first if necessary.
1069              
1070             char* SvPVbyte_nolen(SV* sv)','name' => 'SvPVbyte_nolen'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L.
1071              
1072             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
1073             hash and returned to the caller. The C is the length of the key.
1074             The C value will normally be zero; if set to G_DISCARD then NULL
1075             will be returned.
1076              
1077             SV* hv_delete(HV* tb, const char* key, I32 klen, I32 flags)','name' => 'hv_delete'},'hv_undef' => {'text' => 'Undefines the hash.
1078              
1079             void hv_undef(HV* tb)','name' => 'hv_undef'},'SvSetMagicSV_nosteal' => {'text' => 'Like C, but does any set magic required afterwards.
1080              
1081             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
1082             hash and returned to the caller. The C value will normally be zero;
1083             if set to G_DISCARD then NULL will be returned. C can be a valid
1084             precomputed hash value, or 0 to ask for it to be computed.
1085              
1086             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
1087             class name for a C++ XS constructor. This is always a C. See C.
1088              
1089             char* CLASS','name' => 'CLASS'},'sv_isobject' => {'text' => 'Returns a boolean indicating whether the SV is an RV pointing to a blessed
1090             object. If the SV is not an RV, or if the object is not blessed, then this
1091             will return false.
1092              
1093             int sv_isobject(SV* sv)','name' => 'sv_isobject'},'Newc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with
1094             cast.
1095              
1096             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.
1097             If C has C bit set, will C on C if
1098             appropriate, else not. C and C are
1099             implemented in terms of this function.
1100             You normally want to use the various wrapper macros instead: see
1101             C and C
1102              
1103             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
1104             holds an C key. Otherwise, holds the actual length of the key. Can
1105             be assigned to. The C macro is usually preferable for finding key
1106             lengths.
1107              
1108             STRLEN HeKLEN(HE* he)','name' => 'HeKLEN'},'to_utf8_title' => {'text' => 'Convert the UTF-8 encoded character at p to its titlecase version and
1109             store that in UTF-8 in ustrp and its length in bytes in lenp. Note
1110             that the ustrp needs to be at least UTF8_MAXLEN_UCLC+1 bytes since the
1111             titlecase version may be longer than the original character (up to two
1112             characters).
1113              
1114             The first character of the titlecased version is returned
1115             (but note, as explained above, that there may be more.)
1116              
1117             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
1118             assumed to be octets in that encoding and decoding the input starts
1119             from the position which (PV + *offset) pointed to. The dsv will be
1120             concatenated the decoded UTF-8 string from ssv. Decoding will terminate
1121             when the string tstr appears in decoding output or the input ends on
1122             the PV of the ssv. The value which the offset points will be modified
1123             to the last input position on the ssv.
1124              
1125             Returns TRUE if the terminator was found, else returns FALSE.
1126              
1127             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.
1128             Handles \'set\' magic. See C.
1129              
1130             void PUSHn(NV nv)','name' => 'PUSHn'},'sv_setiv' => {'text' => 'Copies an integer into the given SV, upgrading first if necessary.
1131             Does not handle \'set\' magic. See also C.
1132              
1133             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
1134             version which guarantees to evaluate sv only once.
1135              
1136             IV SvIV(SV* sv)','name' => 'SvIV'},'sv_report_used' => {'text' => 'Dump the contents of all SVs not yet freed. (Debugging aid).
1137              
1138             void sv_report_used()','name' => 'sv_report_used'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once
1139             used, guarantees that there is room for at least C to be pushed
1140             onto the stack.
1141              
1142             void EXTEND(SP, int nitems)','name' => 'EXTEND'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as
1143             C<&PL_sv_yes>.
1144              
1145             SV PL_sv_yes','name' => 'PL_sv_yes'},'SvNVX' => {'text' => 'Returns the raw value in the SV\'s NV slot, without checks or conversions.
1146             Only use when you are sure SvNOK is true. See also C.
1147              
1148             NV SvNVX(SV* sv)','name' => 'SvNVX'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it.
1149             The reference count for the SV is set to 1.
1150              
1151             SV* newSVuv(UV u)','name' => 'newSVuv'},'gv_fetchmeth' => {'text' => 'Returns the glob with the given C and a defined subroutine or
1152             C. The glob lives in the given C, or in the stashes
1153             accessible via @ISA and UNIVERSAL::.
1154              
1155             The argument C should be either 0 or -1. If C, as a
1156             side-effect creates a glob with the given C in the given C
1157             which in the case of success contains an alias for the subroutine, and sets
1158             up caching info for this glob. Similarly for all the searched stashes.
1159              
1160             This function grants C<"SUPER"> token as a postfix of the stash name. The
1161             GV returned from C may be a method cache entry, which is not
1162             visible to Perl code. So when calling C, you should not use
1163             the GV directly; instead, you should use the method\'s CV, which can be
1164             obtained from the GV with the C macro.
1165              
1166             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.
1167             Exists to avoid test for a NULL function pointer and because it could potentially warn under
1168             some level of strict-ness.
1169              
1170             void sv_nosharing(SV *)','name' => 'sv_nosharing'},'SvUTF8_off' => {'text' => 'Unsets the UTF-8 status of an SV.
1171              
1172             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).
1173             C and C are treated as numbers (so will not issue a
1174             non-numeric warning), even if your atof() doesn\'t grok them.
1175              
1176             I32 looks_like_number(SV* sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic.
1177              
1178             void sv_catpv_mg(SV *sv, const char *ptr)','name' => 'sv_catpv_mg'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately.
1179              
1180              
1181             XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry.
1182              
1183             U32 HeHASH(HE* he)','name' => 'HeHASH'},'sv_setref_uv' => {'text' => 'Copies an unsigned integer into a new SV, optionally blessing the SV. The C
1184             argument will be upgraded to an RV. That RV will be modified to point to
1185             the new SV. The C argument indicates the package for the
1186             blessing. Set C to C to avoid the blessing. The new SV
1187             will have a reference count of 1, and the RV will be returned.
1188              
1189             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.
1190              
1191             bool SvIOK(SV* sv)','name' => 'SvIOK'},'getcwd_sv' => {'text' => 'Fill the sv with current working directory
1192              
1193             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
1194             SV is set to 1. If C is zero, Perl will compute the length using
1195             strlen(). For efficiency, consider using C instead.
1196              
1197             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
1198             to its length. May cause the SV to be downgraded from UTF-8 as a
1199             side-effect.
1200              
1201             Usually accessed via the C macro.
1202              
1203             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
1204             C. It returns C if the string can\'t be found. The C
1205             does not have to be fbm_compiled, but the search will not be as fast
1206             then.
1207              
1208             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
1209             output. Does not handle \'set\' magic. See C.
1210              
1211             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
1212             (C). You want force if you are going to update the C
1213             directly.
1214              
1215             char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles
1216             \'set\' magic. See C.
1217              
1218             void XPUSHn(NV nv)','name' => 'XPUSHn'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part
1219             attributable to C. See C.
1220              
1221             STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'call_sv' => {'text' => 'Performs a callback to the Perl sub whose name is in the SV. See
1222             L.
1223              
1224             NOTE: the perl_ form of this function is deprecated.
1225              
1226             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,
1227             C. Returns true or false.
1228              
1229             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,
1230             and leaves the UTF-8 status as it was.
1231              
1232             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.
1233              
1234             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
1235             the start of the string, to a count of the equivalent number of bytes; if
1236             lenp is non-zero, it does the same to lenp, but this time starting from
1237             the offset, rather than from the start of the string. Handles magic and
1238             type coercion.
1239              
1240             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
1241             false, defined or undefined. Does not handle \'get\' magic.
1242              
1243             bool SvTRUE(SV* sv)','name' => 'SvTRUE'},'HeSVKEY_set' => {'text' => 'Sets the key to a given C, taking care to set the appropriate flags to
1244             indicate the presence of an C key, and returns the same
1245             C.
1246              
1247             SV* HeSVKEY_set(HE* he, SV* sv)','name' => 'HeSVKEY_set'},'POPl' => {'text' => 'Pops a long off the stack.
1248              
1249             long POPl','name' => 'POPl'},'hv_iternext_flags' => {'text' => 'Returns entries from a hash iterator. See C and C.
1250             The C value will normally be zero; if HV_ITERNEXT_WANTPLACEHOLDERS is
1251             set the placeholders keys (for restricted hashes) will be returned in addition
1252             to normal keys. By default placeholders are automatically skipped over.
1253             Currently a placeholder is implemented with a value that is
1254             C<&Perl_sv_placeholder>. Note that the implementation of placeholders and
1255             restricted hashes may change, and the implementation currently is
1256             insufficiently abstracted for any change to be tidy.
1257              
1258             NOTE: this function is experimental and may change or be
1259             removed without notice.
1260              
1261             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.
1262              
1263             On entry I and I<*len> give the string to scan, I<*flags> gives
1264             conversion flags, and I should be NULL or a pointer to an NV.
1265             The scan stops at the end of the string, or the first non-hex-digit character.
1266             On return I<*len> is set to the length scanned string, and I<*flags> gives
1267             output flags.
1268              
1269             If the value is <= UV_MAX it is returned as a UV, the output flags are clear,
1270             and nothing is written to I<*result>. If the value is > UV_MAX C
1271             returns UV_MAX, sets C in the output flags,
1272             and writes the value to I<*result> (or the value is discarded if I
1273             is NULL).
1274              
1275             The hex number may optionally be prefixed with "0x" or "x" unless
1276             C is set in I<*flags> on entry. If
1277             C is set in I<*flags> then the hex
1278             number may use \'_\' characters to separate digits.
1279              
1280             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.
1281              
1282             SPAGAIN;','name' => 'SPAGAIN'},'call_method' => {'text' => 'Performs a callback to the specified Perl method. The blessed object must
1283             be on the stack. See L.
1284              
1285             NOTE: the perl_ form of this function is deprecated.
1286              
1287             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
1288             has been loaded.
1289              
1290             void SvLOCK(SV* sv)','name' => 'SvLOCK'},'sv_vsetpvfn' => {'text' => 'Works like C but copies the text into the SV instead of
1291             appending it.
1292              
1293             Usually used via one of its frontends C and C.
1294              
1295             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
1296             the Perl subroutine does not exist then it will be declared (which has the
1297             same effect as saying C). If C is not set and the
1298             subroutine does not exist then NULL is returned.
1299              
1300             NOTE: the perl_ form of this function is deprecated.
1301              
1302             CV* get_cv(const char* name, I32 create)','name' => 'get_cv'},'SvIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. Checks
1303             the B setting. Use C.
1304              
1305             bool SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the
1306             stack.
1307              
1308             void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'perl_parse' => {'text' => 'Tells a Perl interpreter to parse a Perl script. See L.
1309              
1310             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
1311             the character that is being converted.
1312              
1313             The "ustrp" is a pointer to the character buffer to put the
1314             conversion result to. The "lenp" is a pointer to the length
1315             of the result.
1316              
1317             The "swashp" is a pointer to the swash to use.
1318              
1319             Both the special and normal mappings are stored lib/unicore/To/Foo.pl,
1320             and loaded by SWASHGET, using lib/utf8_heavy.pl. The special (usually,
1321             but not always, a multicharacter mapping), is tried first.
1322              
1323             The "special" is a string like "utf8::ToSpecLower", which means the
1324             hash %utf8::ToSpecLower. The access to the hash is through
1325             Perl_to_utf8_case().
1326              
1327             The "normal" is a string like "ToLower" which means the swash
1328             %utf8::ToLower.
1329              
1330             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
1331             array itself.
1332              
1333             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
1334             a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to
1335             an xpvmg. See also C.
1336              
1337             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
1338             array. The array will grow automatically to accommodate the addition. You
1339             must then use C to assign values to these new elements.
1340              
1341             void av_unshift(AV* ar, I32 num)','name' => 'av_unshift'},'SvUNLOCK' => {'text' => 'Releases a mutual exclusion lock on sv if a suitable module
1342             has been loaded.
1343              
1344              
1345             void SvUNLOCK(SV* sv)','name' => 'SvUNLOCK'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C.
1346              
1347             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).
1348             The new SV is marked as mortal. It will be destroyed "soon", either by an
1349             explicit call to FREETMPS, or by an implicit call at places such as
1350             statement boundaries. See also C and C.
1351              
1352             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.
1353             Requires a variable STRLEN n_a in scope.
1354              
1355             char* POPpbytex','name' => 'POPpbytex'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions.
1356             Only use when you are sure SvIOK is true. See also C.
1357              
1358             UV SvUVX(SV* sv)','name' => 'SvUVX'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See
1359             L.','name' => 'G_NOARGS'},'SvSetMagicSV' => {'text' => 'Like C, but does any set magic required afterwards.
1360              
1361             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
1362             turn off SvUTF8 if needed so that we see characters. Used as a building block
1363             for decode_utf8 in Encode.xs
1364              
1365             NOTE: this function is experimental and may change or be
1366             removed without notice.
1367              
1368             bool sv_utf8_decode(SV *sv)','name' => 'sv_utf8_decode'},'Newz' => {'text' => 'The XSUB-writer\'s interface to the C C function. The allocated
1369             memory is zeroed with C.
1370              
1371             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
1372             pointer to a newly allocated string which is a duplicate of the first
1373             C bytes from C. The memory allocated for the new string can be
1374             freed with the C function.
1375              
1376             char* savepvn(const char* pv, I32 len)','name' => 'savepvn'},'eval_sv' => {'text' => 'Tells Perl to C the string in the SV.
1377              
1378             NOTE: the perl_ form of this function is deprecated.
1379              
1380             I32 eval_sv(SV* sv, I32 flags)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and
1381             L.
1382              
1383             FREETMPS;','name' => 'FREETMPS'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized.
1384              
1385             This relies on the fact that uninitialized array elements are set to
1386             C<&PL_sv_undef>.
1387              
1388             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.
1389              
1390             STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'Move' => {'text' => 'The XSUB-writer\'s interface to the C C function. The C is the
1391             source, C is the destination, C is the number of items, and C is
1392             the type. Can do overlapping moves. See also C.
1393              
1394             void Move(void* src, void* dest, int nitems, type)','name' => 'Move'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow.
1395             A private implementation of the C macro for compilers which
1396             can\'t cope with complex macro expressions. Always use the macro instead.
1397              
1398             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
1399             C indicates number of bytes to copy. If the SV has the UTF-8
1400             status set, then the bytes appended should be valid UTF-8.
1401             If C has C bit set, will C on C if
1402             appropriate, else not. C and C are implemented
1403             in terms of this function.
1404              
1405             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
1406             C or C; in a void context, it returns C.
1407             Deprecated. Use C instead.
1408              
1409             U32 GIMME','name' => 'GIMME'},'sv_bless' => {'text' => 'Blesses an SV into a specified package. The SV must be an RV. The package
1410             must be designated by its stash (see C). The reference count
1411             of the SV is unaffected.
1412              
1413             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
1414             bytes of preallocated string space the SV should have. An extra byte for a
1415             tailing NUL is also reserved. (SvPOK is not set for the SV even if string
1416             space is allocated.) The reference count for the new SV is set to 1.
1417             C is an integer id between 0 and 1299 (used to identify leaks).
1418              
1419              
1420             SV* NEWSV(int id, STRLEN len)','name' => 'NEWSV'},'sv_isa' => {'text' => 'Returns a boolean indicating whether the SV is blessed into the specified
1421             class. This does not check for subtypes; use C to verify
1422             an inheritance relationship.
1423              
1424             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
1425             character (including underscore) or digit.
1426              
1427             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
1428             output to an SV. If the appended data contains "wide" characters
1429             (including, but not limited to, SVs with a UTF-8 PV formatted with %s,
1430             and characters >255 formatted with %c), the original SV might get
1431             upgraded to UTF-8. Handles \'get\' magic, but not \'set\' magic.
1432             C must typically be called after calling this function
1433             to handle \'set\' magic.
1434              
1435             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.
1436              
1437             bool SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C.
1438              
1439             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
1440             which is assumed to be in UTF-8 encoding; C will be set to the
1441             length, in bytes, of that character.
1442              
1443             This function should only be used when returned UV is considered
1444             an index into the Unicode semantic tables (e.g. swashes).
1445              
1446             If C does not point to a well-formed UTF-8 character, zero is
1447             returned and retlen is set, if possible, to -1.
1448              
1449             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
1450             GV; or the recursive result if we\'re an RV; or the IO slot of the symbol
1451             named after the PV if we\'re a string.
1452              
1453             IO* sv_2io(SV* sv)','name' => 'sv_2io'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L.
1454              
1455             PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphabetic
1456             character.
1457              
1458             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
1459             Perl\'s C<$#array = $fill;>.
1460              
1461             void av_fill(AV* ar, I32 fill)','name' => 'av_fill'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV.
1462              
1463             SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C.
1464              
1465             svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L.
1466              
1467             void perl_construct(PerlInterpreter* interp)','name' => 'perl_construct'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer.
1468              
1469             void SvUOK(SV* sv)','name' => 'SvUOK'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion
1470             if necessary. Handles \'get\' magic.
1471              
1472             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.
1473              
1474             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
1475             second, C. Returns true or false.
1476              
1477             bool strLE(char* s1, char* s2)','name' => 'strLE'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV.
1478              
1479             void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function.
1480              
1481             void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'grok_bin' => {'text' => 'converts a string representing a binary number to numeric form.
1482              
1483             On entry I and I<*len> give the string to scan, I<*flags> gives
1484             conversion flags, and I should be NULL or a pointer to an NV.
1485             The scan stops at the end of the string, or the first invalid character.
1486             On return I<*len> is set to the length scanned string, and I<*flags> gives
1487             output flags.
1488              
1489             If the value is <= UV_MAX it is returned as a UV, the output flags are clear,
1490             and nothing is written to I<*result>. If the value is > UV_MAX C
1491             returns UV_MAX, sets C in the output flags,
1492             and writes the value to I<*result> (or the value is discarded if I
1493             is NULL).
1494              
1495             The hex number may optionally be prefixed with "0b" or "b" unless
1496             C is set in I<*flags> on entry. If
1497             C is set in I<*flags> then the binary
1498             number may use \'_\' characters to separate digits.
1499              
1500             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.
1501             May cause the SV to be downgraded from UTF-8 as a side-effect.
1502              
1503             Usually accessed via the C macro.
1504              
1505             char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'SvOK' => {'text' => 'Returns a boolean indicating whether the value is an SV.
1506              
1507             bool SvOK(SV* sv)','name' => 'SvOK'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L.
1508              
1509             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
1510             argument will be upgraded to an RV. That RV will be modified to point to
1511             the new SV. The C argument indicates the package for the
1512             blessing. Set C to C to avoid the blessing. The new SV
1513             will have a reference count of 1, and the RV will be returned.
1514              
1515             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
1516             of the string C; C should be have at least C free
1517             bytes available. The return value is the pointer to the byte after the
1518             end of the new character. In other words,
1519              
1520             d = uvchr_to_utf8(d, uv);
1521              
1522             is the recommended wide native character-aware way of saying
1523              
1524             *(d++) = uv;
1525              
1526             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.
1527              
1528             MAGIC* mg_find(SV* sv, int type)','name' => 'mg_find'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII
1529             digit.
1530              
1531             bool isDIGIT(char ch)','name' => 'isDIGIT'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double.
1532              
1533             void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'eval_pv' => {'text' => 'Tells Perl to C the given string and return an SV* result.
1534              
1535             NOTE: the perl_ form of this function is deprecated.
1536              
1537             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
1538             table. If the string does not already exist in the table, it is created
1539             first. Turns on READONLY and FAKE. The string\'s hash is stored in the UV
1540             slot of the SV; if the C parameter is non-zero, that value is used;
1541             otherwise the hash is computed. The idea here is that as the string table
1542             is used for shared hash keys these strings will have SvPVX == HeKEY and
1543             hash lookup will avoid string compare.
1544              
1545             SV* newSVpvn_share(const char* s, I32 len, U32 hash)','name' => 'newSVpvn_share'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic.
1546              
1547             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.
1548             Checks the B setting. Use C.
1549              
1550             bool SvPOKp(SV* sv)','name' => 'SvPOKp'},'sv_free' => {'text' => 'Decrement an SV\'s reference count, and if it drops to zero, call
1551             C to invoke destructors and free up any memory used by
1552             the body; finally, deallocate the SV\'s head itself.
1553             Normally called via a wrapper macro C.
1554              
1555             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
1556             C indicates number of bytes to copy. If the SV has the UTF-8
1557             status set, then the bytes appended should be valid UTF-8.
1558             Handles \'get\' magic, but not \'set\' magic. See C.
1559              
1560             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.
1561              
1562             char* SvPVbyte_force(SV* sv, STRLEN len)','name' => 'SvPVbyte_force'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is
1563             eligible for inlining at compile-time.
1564              
1565             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
1566             argument will be upgraded to an RV. That RV will be modified to point to
1567             the new SV. If the C argument is NULL then C will be placed
1568             into the SV. The C argument indicates the package for the
1569             blessing. Set C to C to avoid the blessing. The new SV
1570             will have a reference count of 1, and the RV will be returned.
1571              
1572             Do not use with other Perl types such as HV, AV, SV, CV, because those
1573             objects will become corrupted by the pointer copy process.
1574              
1575             Note that C copies the string while this copies the pointer.
1576              
1577             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
1578             has been loaded.
1579              
1580             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
1581             is empty.
1582              
1583             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()
1584             -- the Boyer-Moore algorithm.
1585              
1586             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.
1587             This may not be possible if the PV contains non-byte encoding characters;
1588             if this is the case, either returns false or, if C is not
1589             true, croaks.
1590              
1591             This is not as a general purpose Unicode to byte encoding interface:
1592             use the Encode extension for that.
1593              
1594             NOTE: this function is experimental and may change or be
1595             removed without notice.
1596              
1597             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
1598             double. Checks the B setting. Use C.
1599              
1600             bool SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'croak' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function.
1601             Normally call this function the same way you call the C C
1602             function. Calling C returns control directly to Perl,
1603             sidestepping the normal C order of execution. See C.
1604              
1605             If you want to throw an exception object, assign the object to
1606             C<$@> and then pass C to croak():
1607              
1608             errsv = get_sv("@", TRUE);
1609             sv_setsv(errsv, exception_object);
1610             croak(Nullch);
1611              
1612             void croak(const char* pat, ...)','name' => 'croak'},'sortsv' => {'text' => 'Sort an array. Here is an example:
1613              
1614             sortsv(AvARRAY(av), av_len(av)+1, Perl_sv_cmp_locale);
1615              
1616             See lib/sort.pm for details about controlling the sorting algorithm.
1617              
1618             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++
1619             XSUB. This is always the proper type for the C++ object. See C and
1620             L.
1621              
1622             (whatever) THIS','name' => 'THIS'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either
1623             forward or backward.
1624              
1625             WARNING: do not use the following unless you *know* C is within
1626             the UTF-8 data pointed to by C *and* that on entry C is aligned
1627             on the first byte of character or just after the last byte of a character.
1628              
1629             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
1630             UTF-8 bytes as a single character. Handles magic and type coercion.
1631              
1632             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
1633             handled by C.
1634              
1635             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
1636             string must be specified with C. The C argument will be upgraded to
1637             an RV. That RV will be modified to point to the new SV. The C
1638             argument indicates the package for the blessing. Set C to
1639             C to avoid the blessing. The new SV will have a reference count
1640             of 1, and the RV will be returned.
1641              
1642             Note that C copies the pointer while this copies the string.
1643              
1644             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.
1645             The C indicates the length of the string. Handles \'set\' magic. See
1646             C.
1647              
1648             void PUSHp(char* str, STRLEN len)','name' => 'PUSHp'},'scan_bin' => {'text' => 'For backwards compatibility. Use C instead.
1649              
1650             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
1651             marked as readonly and the key is subsequently deleted, the key is not actually
1652             deleted but is marked by assigning it a value of &PL_sv_placeholder. This tags
1653             it so it will be ignored by future operations such as iterating over the hash,
1654             but will still allow the hash to have a value reaasigned to the key at some
1655             future point. This function clears any such placeholder keys from the hash.
1656             See Hash::Util::lock_keys() for an example of its use.
1657              
1658             void hv_clear_placeholders(HV* hb)','name' => 'hv_clear_placeholders'},'dAX' => {'text' => 'Sets up the C variable.
1659             This is usually handled automatically by C by calling C.
1660              
1661             dAX;','name' => 'dAX'},'sv_2pv_nolen' => {'text' => 'Like C, but doesn\'t return the length too. You should usually
1662             use the macro wrapper C instead.
1663             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
1664             Perl variable does not exist then it will be created. If C is not
1665             set and the variable does not exist then NULL is returned.
1666              
1667             NOTE: the perl_ form of this function is deprecated.
1668              
1669             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>.
1670              
1671             SV PL_sv_undef','name' => 'PL_sv_undef'},'SvPVbyte' => {'text' => 'Like C, but converts sv to byte representation first if necessary.
1672              
1673             char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'hv_iterkeysv' => {'text' => 'Returns the key as an C from the current position of the hash
1674             iterator. The return value will always be a mortal copy of the key. Also
1675             see C.
1676              
1677             SV* hv_iterkeysv(HE* entry)','name' => 'hv_iterkeysv'},'grok_number' => {'text' => 'Recognise (or not) a number. The type of the number is returned
1678             (0 if unrecognised), otherwise it is a bit-ORed combination of
1679             IS_NUMBER_IN_UV, IS_NUMBER_GREATER_THAN_UV_MAX, IS_NUMBER_NOT_INT,
1680             IS_NUMBER_NEG, IS_NUMBER_INFINITY, IS_NUMBER_NAN (defined in perl.h).
1681              
1682             If the value of the number can fit an in UV, it is returned in the *valuep
1683             IS_NUMBER_IN_UV will be set to indicate that *valuep is valid, IS_NUMBER_IN_UV
1684             will never be set unless *valuep is valid, but *valuep may have been assigned
1685             to during processing even though IS_NUMBER_IN_UV is not set on return.
1686             If valuep is NULL, IS_NUMBER_IN_UV will be set for the same cases as when
1687             valuep is non-NULL, but no actual assignment (or SEGV) will occur.
1688              
1689             IS_NUMBER_NOT_INT will be set with IS_NUMBER_IN_UV if trailing decimals were
1690             seen (in which case *valuep gives the true value truncated to an integer), and
1691             IS_NUMBER_NEG if the number is negative (in which case *valuep holds the
1692             absolute value). IS_NUMBER_IN_UV is not set if e notation was used or the
1693             number is larger than a UV.
1694              
1695             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
1696             sv only once. Use the more efficient C otherwise.
1697              
1698             IV SvIVx(SV* sv)','name' => 'SvIVx'},'grok_numeric_radix' => {'text' => 'Scan and skip for a numeric decimal separator (radix).
1699              
1700             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
1701             stack.
1702              
1703             void XST_mNO(int pos)','name' => 'XST_mNO'},'toUPPER' => {'text' => 'Converts the specified character to uppercase.
1704              
1705             char toUPPER(char ch)','name' => 'toUPPER'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array. Returns the
1706             deleted element. C is currently ignored.
1707              
1708             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
1709             the last argument.
1710              
1711             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
1712             and C.
1713              
1714             WARNING: use only if you *know* that the pointers point inside the
1715             same UTF-8 buffer.
1716              
1717             IV utf8_distance(U8 *a, U8 *b)','name' => 'utf8_distance'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and
1718             L.
1719              
1720             SAVETMPS;','name' => 'SAVETMPS'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally
1721             appending to the currently-stored string.
1722              
1723             char* sv_gets(SV* sv, PerlIO* fp, I32 append)','name' => 'sv_gets'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead.
1724              
1725             int AvFILL(AV* av)','name' => 'AvFILL'},'SvPVutf8x' => {'text' => 'Like C, but converts sv to utf8 first if necessary.
1726             Guarantees to evaluate sv only once; use the more efficient C
1727             otherwise.
1728              
1729             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.
1730              
1731             Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the
1732             scalar data of the variable, but transformed to such a format that a normal
1733             memory comparison can be used to compare the data according to the locale
1734             settings.
1735              
1736             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
1737             possible to set C<*st> and C<*gvp> to the stash and GV associated with it.
1738              
1739             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
1740             (C). You want force if you are going to update the C
1741             directly. Doesn\'t process magic.
1742              
1743             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
1744             C.','name' => 'SP'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits.
1745             Will also turn off the UTF-8 status.
1746              
1747             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
1748             ssv. May evaluate arguments more than once.
1749              
1750             void SvSetSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetSV_nosteal'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic.
1751              
1752             void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'POPpx' => {'text' => 'Pops a string off the stack.
1753             Requires a variable STRLEN n_a in scope.
1754              
1755             char* POPpx','name' => 'POPpx'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic.
1756              
1757             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
1758             cope with complex macro expressions. Always use the macro instead.
1759              
1760             UV sv_uv(SV* sv)','name' => 'sv_uv'},'sv_pvbyte' => {'text' => 'Use C instead.
1761              
1762             char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'SvSTASH' => {'text' => 'Returns the stash of the SV.
1763              
1764             HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'hv_fetch' => {'text' => 'Returns the SV which corresponds to the specified key in the hash. The
1765             C is the length of the key. If C is set then the fetch will be
1766             part of a store. Check that the return value is non-null before
1767             dereferencing it to an C.
1768              
1769             See L for more
1770             information on how to use this function on tied hashes.
1771              
1772             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
1773             destination, C is the number of items, and C is the type.
1774              
1775             void Zero(void* dest, int nitems, type)','name' => 'Zero'},'PL_modglobal' => {'text' => 'C is a general purpose, interpreter global HV for use by
1776             extensions that need to keep information on a per-interpreter basis.
1777             In a pinch, it can also be used as a symbol table for extensions
1778             to share data among each other. It is a good idea to use keys
1779             prefixed by the package name of the extension that owns the data.
1780              
1781             HV* PL_modglobal','name' => 'PL_modglobal'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C.
1782              
1783             XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_unref_flags' => {'text' => 'Unsets the RV status of the SV, and decrements the reference count of
1784             whatever was being referenced by the RV. This can almost be thought of
1785             as a reversal of C. The C argument can contain
1786             C to force the reference count to be decremented
1787             (otherwise the decrementing is conditional on the reference count being
1788             different from one or the reference being a readonly SV).
1789             See C.
1790              
1791             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
1792             cope with complex macro expressions. Always use the macro instead.
1793              
1794             IV sv_iv(SV* sv)','name' => 'sv_iv'},'SvRV' => {'text' => 'Dereferences an RV to return the SV.
1795              
1796             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.
1797              
1798             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.
1799              
1800             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
1801             C if the hash entry contains only a C key.
1802              
1803             SV* HeSVKEY_force(HE* he)','name' => 'HeSVKEY_force'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C flag on this RV; give the
1804             referred-to SV C magic if it hasn\'t already; and
1805             push a back-reference to this RV onto the array of backreferences
1806             associated with that magic.
1807              
1808             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.
1809              
1810             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
1811             SV is set to 1. Note that if C is zero, Perl will create a zero length
1812             string. You are responsible for ensuring that the source string is at least
1813             C bytes long.
1814              
1815             SV* newSVpvn(const char* s, STRLEN len)','name' => 'newSVpvn'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the
1816             supplied vtable and returns pointer to the magic added.
1817              
1818             Note that sv_magicext will allow things that sv_magic will not.
1819             In particular you can add magic to SvREADONLY SVs and and more than
1820             one instance of the same \'how\'
1821              
1822             I C is greater then zero then a savepvn() I of C is stored,
1823             if C is zero then C is stored as-is and - as another special
1824             case - if C<(name && namelen == HEf_SVKEY)> then C is assumed to contain
1825             an C and has its REFCNT incremented
1826              
1827             (This is now used as a subroutine by sv_magic.)
1828              
1829             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
1830             incremented.
1831              
1832             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
1833             to accommodate the addition.
1834              
1835             void av_push(AV* ar, SV* val)','name' => 'av_push'},'unpackstring' => {'text' => 'The engine implementing unpack() Perl function. C puts the
1836             extracted list items on the stack and returns the number of elements.
1837             Issue C before and C after the call to this function.
1838              
1839             I32 unpackstring(char *pat, char *patend, char *s, char *strend, U32 flags)','name' => 'unpackstring'},'POPn' => {'text' => 'Pops a double off the stack.
1840              
1841             NV POPn','name' => 'POPn'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C.
1842              
1843             XSRETURN_NO;','name' => 'XSRETURN_NO'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be
1844             extended.
1845              
1846             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
1847             SV is B incremented.
1848              
1849             SV* newRV_noinc(SV *sv)','name' => 'newRV_noinc'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic.
1850              
1851             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
1852             evaluate sv only once. Use the more efficient C otherwise.
1853              
1854             UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV.
1855              
1856             void SvROK_on(SV* sv)','name' => 'SvROK_on'},'sv_2bool' => {'text' => 'This function is only called on magical items, and is only used by
1857             sv_true() or its macro equivalent.
1858              
1859             bool sv_2bool(SV* sv)','name' => 'sv_2bool'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C.
1860              
1861             You may call C or C on the hash entry that the
1862             iterator currently points to, without losing your place or invalidating your
1863             iterator. Note that in this case the current entry is deleted from the hash
1864             with your iterator holding the last reference to it. Your iterator is flagged
1865             to free the entry on the next call to C, so you must not discard
1866             your iterator immediately else the entry will leak - call C to
1867             trigger the resource deallocation.
1868              
1869             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.
1870              
1871             dORIGMARK;','name' => 'dORIGMARK'},'sv_newmortal' => {'text' => 'Creates a new null SV which is mortal. The reference count of the SV is
1872             set to 1. It will be destroyed "soon", either by an explicit call to
1873             FREETMPS, or by an implicit call at places such as statement boundaries.
1874             See also C and C.
1875              
1876             SV* sv_newmortal()','name' => 'sv_newmortal'},'sv_clear' => {'text' => 'Clear an SV: call any destructors, free up any memory used by the body,
1877             and free the body itself. The SV\'s head is I freed, although
1878             its type is set to all 1\'s so that it won\'t inadvertently be assumed
1879             to be live during global destruction etc.
1880             This function should only be called when REFCNT is zero. Most of the time
1881             you\'ll want to call C (or its macro wrapper C)
1882             instead.
1883              
1884             void sv_clear(SV* sv)','name' => 'sv_clear'},'hv_iterinit' => {'text' => 'Prepares a starting point to traverse a hash table. Returns the number of
1885             keys in the hash (i.e. the same as C). The return value is
1886             currently only meaningful for hashes without tie magic.
1887              
1888             NOTE: Before version 5.004_65, C used to return the number of
1889             hash buckets that happen to be in use. If you still need that esoteric
1890             value, you can get it through the macro C.
1891              
1892              
1893             I32 hv_iterinit(HV* tb)','name' => 'hv_iterinit'}};};
1894              
1895 1         25 my $self = bless({
1896             'index' => $VAR1,
1897             perl_version => '5.008004',
1898             } => $class);
1899 1         272 return $self;
1900             }
1901              
1902             1;