File Coverage

blib/lib/Perl/APIReference/V5_006_002.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_006_002;
2 1     1   6 use strict;
  1         1  
  1         54  
3 1     1   6 use warnings;
  1         2  
  1         42  
4 1     1   7 use parent 'Perl::APIReference';
  1         2  
  1         8  
5              
6             sub new {
7 1     1 1 3 my $class = shift;
8 1         1 my $VAR1;
9              
10 1         2 do{$VAR1 = {'SvOOK' => {'text' => 'Returns a boolean indicating whether the SvIVX is a valid offset value for
  1         705  
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.
24              
25             See L for more
26             information on how to use this function on tied hashes.
27              
28             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
29             valid UTF-8 string. See C.
30              
31             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
32             the subs.','name' => 'newXSproto'},'XSRETURN_NV' => {'text' => 'Return an double from an XSUB immediately. Uses C.
33              
34             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
35             the second, C. Returns true or false.
36              
37             bool strGE(char* s1, char* s2)','name' => 'strGE'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV
38             if the SV does not contain a string. Handles \'get\' magic.
39              
40             char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'svtype' => {'text' => 'An enum of flags for Perl types. These are found in the file B
41             in the C enum. Test these flags with the C macro.','name' => 'svtype'},'is_utf8_string' => {'text' => 'Returns true if first C bytes of the given string form valid a UTF8
42             string, false otherwise.
43              
44             bool is_utf8_string(U8 *s, STRLEN len)','name' => 'is_utf8_string'},'hv_clear' => {'text' => 'Clears a hash, making it empty.
45              
46             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
47             Perl variable does not exist then it will be created. If C is not
48             set and the variable does not exist then NULL is returned.
49              
50             NOTE: the perl_ form of this function is deprecated.
51              
52             HV* get_hv(const char* name, I32 create)','name' => 'get_hv'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C.
53              
54             XSRETURN_YES;','name' => 'XSRETURN_YES'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with
55             cast.
56              
57             void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'sv_insert' => {'text' => 'Inserts a string at the specified offset/length within the SV. Similar to
58             the Perl substr() function.
59              
60             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.
61              
62             void sv_catpvf_mg(SV *sv, const char* pat, ...)','name' => 'sv_catpvf_mg'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV.
63              
64             void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'SvPOK' => {'text' => 'Returns a boolean indicating whether the SV contains a character
65             string.
66              
67             bool SvPOK(SV* sv)','name' => 'SvPOK'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this
68             element. See C.
69              
70             void PUSHu(UV uv)','name' => 'PUSHu'},'get_sv' => {'text' => 'Returns the SV of the specified Perl scalar. If C is set and the
71             Perl variable does not exist then it will be created. If C is not
72             set and the variable does not exist then NULL is returned.
73              
74             NOTE: the perl_ form of this function is deprecated.
75              
76             SV* get_sv(const char* name, I32 create)','name' => 'get_sv'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV.
77              
78             SV* newSVsv(SV* old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C.
79              
80             void hv_magic(HV* hv, GV* gv, int how)','name' => 'hv_magic'},'sv_setpv_mg' => {'text' => 'Like C, but also handles \'set\' magic.
81              
82             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
83             C.','name' => 'XS'},'sv_setpvn' => {'text' => 'Copies a string into an SV. The C parameter indicates the number of
84             bytes to be copied. Does not handle \'set\' magic. See C.
85              
86             void sv_setpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_setpvn'},'sv_2mortal' => {'text' => 'Marks an SV as mortal. The SV will be destroyed when the current context
87             ends.
88              
89             SV* sv_2mortal(SV* sv)','name' => 'sv_2mortal'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C.
90              
91             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
92             it will be upgraded to one. If C is non-null then the new SV will
93             be blessed in the specified package. The new SV is returned and its
94             reference count is 1.
95              
96             SV* newSVrv(SV* rv, const char* classname)','name' => 'newSVrv'},'strnEQ' => {'text' => 'Test two strings to see if they are equal. The C parameter indicates
97             the number of bytes to compare. Returns true or false. (A wrapper for
98             C).
99              
100             bool strnEQ(char* s1, char* s2, STRLEN len)','name' => 'strnEQ'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the array itself.
101              
102             void av_undef(AV* ar)','name' => 'av_undef'},'HeKEY' => {'text' => 'Returns the actual pointer stored in the key slot of the hash entry. The
103             pointer may be either C or C, depending on the value of
104             C. Can be assigned to. The C or C macros are
105             usually preferable for finding the value of a key.
106              
107             void* HeKEY(HE* he)','name' => 'HeKEY'},'sv_cmp' => {'text' => 'Compares the strings in two SVs. Returns -1, 0, or 1 indicating whether the
108             string in C is less than, equal to, or greater than the string in
109             C.
110              
111             I32 sv_cmp(SV* sv1, SV* sv2)','name' => 'sv_cmp'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV.
112              
113             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.
114             See C. Access the character as *(SvEND(sv)).
115              
116             char* SvEND(SV* sv)','name' => 'SvEND'},'utf8_to_uv_simple' => {'text' => 'Returns the character value of the first character in the string C
117             which is assumed to be in UTF8 encoding; C will be set to the
118             length, in bytes, of that character.
119              
120             If C does not point to a well-formed UTF8 character, zero is
121             returned and retlen is set, if possible, to -1.
122              
123             NOTE: this function is experimental and may change or be
124             removed without notice.
125              
126             UV utf8_to_uv_simple(U8 *s, STRLEN* retlen)','name' => 'utf8_to_uv_simple'},'sv_magic' => {'text' => 'Adds magic to an SV.
127              
128             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.
129              
130             int mg_free(SV* sv)','name' => 'mg_free'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C. Returns C,
131             C or C for void, scalar or list context,
132             respectively.
133              
134             U32 GIMME_V','name' => 'GIMME_V'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and
135             C.
136              
137             dMARK;','name' => 'dMARK'},'New' => {'text' => 'The XSUB-writer\'s interface to the C C function.
138              
139             void New(int id, void* ptr, int nitems, type)','name' => 'New'},'is_utf8_char' => {'text' => 'Tests if some arbitrary number of bytes begins in a valid UTF-8 character.
140             The actual number of bytes in the UTF-8 character will be returned if it
141             is valid, otherwise 0.
142            
143             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
144             source, C is the destination, C is the number of items, and C is
145             the type. May fail on overlapping copies. See also C.
146              
147             void Copy(void* src, void* dest, int nitems, type)','name' => 'Copy'},'CvSTASH' => {'text' => 'Returns the stash of the CV.
148              
149             HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV.
150              
151             void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original.
152              
153             void sv_replace(SV* sv, SV* nsv)','name' => 'sv_replace'},'sv_utf8_upgrade' => {'text' => 'Convert the PV of an SV to its UTF8-encoded form.
154              
155             NOTE: this function is experimental and may change or be
156             removed without notice.
157              
158             void sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains an signed integer.
159              
160             void SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C, C and
161             L.','name' => 'G_ARRAY'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. This
162             is usually handled automatically by C. Declares the C
163             variable to indicate the number of items on the stack.
164              
165             dXSARGS;','name' => 'dXSARGS'},'XS_VERSION_BOOTCHECK' => {'text' => 'Macro to verify that a PM module\'s $VERSION variable matches the XS
166             module\'s C variable. This is usually handled automatically by
167             C. See L.
168              
169             XS_VERSION_BOOTCHECK;','name' => 'XS_VERSION_BOOTCHECK'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C function.
170              
171             void Safefree(void* ptr)','name' => 'Safefree'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the C C is whitespace.
172              
173             bool isSPACE(char ch)','name' => 'isSPACE'},'SvROK' => {'text' => 'Tests if the SV is an RV.
174              
175             bool SvROK(SV* sv)','name' => 'SvROK'},'sv_unref' => {'text' => 'Unsets the RV status of the SV, and decrements the reference count of
176             whatever was being referenced by the RV. This can almost be thought of
177             as a reversal of C. See C.
178              
179             void sv_unref(SV* sv)','name' => 'sv_unref'},'SvSETMAGIC' => {'text' => 'Invokes C on an SV if it has \'set\' magic. This macro evaluates its
180             argument more than once.
181              
182             void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C wrapper around a callback. See
183             L.','name' => 'G_EVAL'},'sv_catsv_mg' => {'text' => 'Like C, but also handles \'set\' magic.
184              
185             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.
186              
187             NOTE: the perl_ form of this function is deprecated.
188              
189             I32 call_argv(const char* sub_name, I32 flags, char** argv)','name' => 'call_argv'},'SvPV_nolen' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of the SV
190             if the SV does not contain a string. Handles \'get\' magic.
191              
192             char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'sv_setnv' => {'text' => 'Copies a double into the given SV. Does not handle \'set\' magic. See
193             C.
194              
195             void sv_setnv(SV* sv, NV num)','name' => 'sv_setnv'},'SvSetSV' => {'text' => 'Calls C if dsv is not the same as ssv. May evaluate arguments
196             more than once.
197              
198             void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'XPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C
199             indicates the length of the string. Handles \'set\' magic. See
200             C.
201              
202             void XPUSHp(char* str, STRLEN len)','name' => 'XPUSHp'},'sv_utf8_encode' => {'text' => 'Convert the PV of an SV to UTF8-encoded, but then turn off the C
203             flag so that it looks like bytes again. Nothing calls this.
204              
205             NOTE: this function is experimental and may change or be
206             removed without notice.
207              
208             void sv_utf8_encode(SV *sv)','name' => 'sv_utf8_encode'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1.
209              
210             HV* newHV()','name' => 'newHV'},'strnNE' => {'text' => 'Test two strings to see if they are different. The C parameter
211             indicates the number of bytes to compare. Returns true or false. (A
212             wrapper for C).
213              
214             bool strnNE(char* s1, char* s2, STRLEN len)','name' => 'strnNE'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or
215             false.
216              
217             bool strNE(char* s1, char* s2)','name' => 'strNE'},'SvUTF8_on' => {'text' => 'Tells an SV that it is a string and encoded in UTF8. Do not use frivolously.
218              
219             void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_setpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic.
220              
221             void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_setpvn_mg'},'sv_pvutf8n_force' => {'text' => 'Get a sensible UTF8-encoded string out of the SV somehow. See
222             L.
223              
224             char* sv_pvutf8n_force(SV* sv, STRLEN* lp)','name' => 'sv_pvutf8n_force'},'savepv' => {'text' => 'Copy a string to a safe spot. This does not use an SV.
225              
226             char* savepv(const char* sv)','name' => 'savepv'},'toLOWER' => {'text' => 'Converts the specified character to lowercase.
227              
228             char toLOWER(char ch)','name' => 'toLOWER'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1.
229              
230             AV* newAV()','name' => 'newAV'},'bytes_from_utf8' => {'text' => 'Converts a string C of length C from UTF8 into byte encoding.
231             Unlike but like C, returns a pointer to
232             the newly-created string, and updates C to contain the new
233             length. Returns the original string if no conversion occurs, C
234             is unchanged. Do nothing if C points to 0. Sets C to
235             0 if C is converted or contains all 7bit characters.
236              
237             NOTE: this function is experimental and may change or be
238             removed without notice.
239              
240             U8* bytes_from_utf8(U8 *s, STRLEN *len, bool *is_utf8)','name' => 'bytes_from_utf8'},'POPp' => {'text' => 'Pops a string off the stack.
241              
242             char* POPp','name' => 'POPp'},'HvNAME' => {'text' => 'Returns the package name of a stash. See C, C.
243              
244             char* HvNAME(HV* stash)','name' => 'HvNAME'},'av_make' => {'text' => 'Creates a new AV and populates it with a list of SVs. The SVs are copied
245             into the array, so they may be freed after the call to av_make. The new AV
246             will have a reference count of 1.
247              
248             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
249             XSUB. This is always the proper type for the XSUB. See
250             L.
251              
252             (whatever) RETVAL','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C, or C if the hash entry does not
253             contain an C key.
254              
255             SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it.
256              
257             UV SvUV(SV* sv)','name' => 'SvUV'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L.
258              
259             int perl_run(PerlInterpreter* interp)','name' => 'perl_run'},'Nullav' => {'text' => 'Null AV pointer.','name' => 'Nullav'},'sv_setpviv' => {'text' => 'Copies an integer into the given SV, also updating its string value.
260             Does not handle \'set\' magic. See C.
261              
262             void sv_setpviv(SV* sv, IV num)','name' => 'sv_setpviv'},'sv_setnv_mg' => {'text' => 'Like C, but also handles \'set\' magic.
263              
264             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.
265              
266             I32 sv_true(SV *sv)','name' => 'sv_true'},'hv_iternextsv' => {'text' => 'Performs an C, C, and C in one
267             operation.
268              
269             SV* hv_iternextsv(HV* hv, char** key, I32* retlen)','name' => 'hv_iternextsv'},'utf8_to_bytes' => {'text' => 'Converts a string C of length C from UTF8 into byte encoding.
270             Unlike C, this over-writes the original string, and
271             updates len to contain the new length.
272             Returns zero on failure, setting C to -1.
273              
274             NOTE: this function is experimental and may change or be
275             removed without notice.
276              
277             U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_derived_from' => {'text' => 'Returns a boolean indicating whether the SV is derived from the specified
278             class. This is the function that implements C. It works
279             for class names as well as for objects.
280              
281             bool sv_derived_from(SV* sv, const char* name)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer.
282              
283             void SvIOK_on(SV* sv)','name' => 'SvIOK_on'},'sv_cmp_locale' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. See
284             L
285              
286             I32 sv_cmp_locale(SV* sv1, SV* sv2)','name' => 'sv_cmp_locale'},'XST_mIV' => {'text' => 'Place an integer into the specified position C on the stack. The
287             value is stored in a new mortal SV.
288              
289             void XST_mIV(int pos, IV iv)','name' => 'XST_mIV'},'hv_exists' => {'text' => 'Returns a boolean indicating whether the specified hash key exists. The
290             C is the length of the key.
291              
292             bool hv_exists(HV* tb, const char* key, U32 klen)','name' => 'hv_exists'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via
293             the C macro. See C.
294              
295             dSP;','name' => 'dSP'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See
296             L.','name' => 'G_DISCARD'},'Nullsv' => {'text' => 'Null SV pointer.','name' => 'Nullsv'},'mg_length' => {'text' => 'Report on the SV\'s length. See C.
297              
298             U32 mg_length(SV* sv)','name' => 'mg_length'},'GvSV' => {'text' => 'Return the SV from the GV.
299              
300             SV* GvSV(GV* gv)','name' => 'GvSV'},'SvPVX' => {'text' => 'Returns a pointer to the string in the SV. The SV must contain a
301             string.
302              
303             char* SvPVX(SV* sv)','name' => 'SvPVX'},'XST_mNV' => {'text' => 'Place a double into the specified position C on the stack. The value
304             is stored in a new mortal SV.
305              
306             void XST_mNV(int pos, NV nv)','name' => 'XST_mNV'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles
307             \'set\' magic. See C.
308              
309             void XPUSHi(IV iv)','name' => 'XPUSHi'},'HEf_SVKEY' => {'text' => 'This flag, used in the length slot of hash entries and magic structures,
310             specifies the structure contains a C pointer where a C pointer
311             is to be expected. (For information only--not to be used).','name' => 'HEf_SVKEY'},'POPi' => {'text' => 'Pops an integer off the stack.
312              
313             IV POPi','name' => 'POPi'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C in characters.
314             Stops at C (inclusive). If C s> or if the scan would end
315             up past C, croaks.
316              
317             NOTE: this function is experimental and may change or be
318             removed without notice.
319              
320             STRLEN utf8_length(U8* s, U8 *e)','name' => 'utf8_length'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted.
321              
322             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.
323              
324             void SvIOK_only_UV(SV* sv)','name' => 'SvIOK_only_UV'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C.','name' => 'SVt_NV'},'sv_vcatpvfn' => {'text' => 'Processes its arguments like C and appends the formatted output
325             to an SV. Uses an array of SVs if the C style variable argument list is
326             missing (NULL). When running with taint checks enabled, indicates via
327             C if results are untrustworthy (often due to the use of
328             locales).
329              
330             void sv_vcatpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)','name' => 'sv_vcatpvfn'},'av_store' => {'text' => 'Stores an SV in an array. The array index is specified as C. The
331             return value will be NULL if the operation failed or if the value did not
332             need to be actually stored within the array (as in the case of tied
333             arrays). Otherwise it can be dereferenced to get the original C. Note
334             that the caller is responsible for suitably incrementing the reference
335             count of C before the call, and decrementing it if the function
336             returned NULL.
337              
338             See L for
339             more information on how to use this function on tied arrays.
340              
341             SV** av_store(AV* ar, I32 key, SV* val)','name' => 'av_store'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C and
342             L.
343              
344             PUSHMARK;','name' => 'PUSHMARK'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack.
345              
346             SV* ST(int ix)','name' => 'ST'},'strLT' => {'text' => 'Test two strings to see if the first, C, is less than the second,
347             C. Returns true or false.
348              
349             bool strLT(char* s1, char* s2)','name' => 'strLT'},'call_pv' => {'text' => 'Performs a callback to the specified Perl sub. See L.
350              
351             NOTE: the perl_ form of this function is deprecated.
352              
353             I32 call_pv(const char* sub_name, I32 flags)','name' => 'call_pv'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the array.
354              
355             SV* av_shift(AV* ar)','name' => 'av_shift'},'av_fetch' => {'text' => 'Returns the SV at the specified index in the array. The C is the
356             index. If C is set then the fetch will be part of a store. Check
357             that the return value is non-null before dereferencing it to a C.
358              
359             See L for
360             more information on how to use this function on tied arrays.
361              
362             SV** av_fetch(AV* ar, I32 key, I32 lval)','name' => 'av_fetch'},'utf8_to_uv' => {'text' => 'Returns the character value of the first character in the string C
363             which is assumed to be in UTF8 encoding and no longer than C;
364             C will be set to the length, in bytes, of that character.
365              
366             If C does not point to a well-formed UTF8 character, the behaviour
367             is dependent on the value of C: if it contains UTF8_CHECK_ONLY,
368             it is assumed that the caller will raise a warning, and this function
369             will silently just set C to C<-1> and return zero. If the
370             C does not contain UTF8_CHECK_ONLY, warnings about
371             malformations will be given, C will be set to the expected
372             length of the UTF-8 character in bytes, and zero will be returned.
373              
374             The C can also contain various flags to allow deviations from
375             the strict UTF-8 encoding (see F).
376              
377             NOTE: this function is experimental and may change or be
378             removed without notice.
379              
380             UV utf8_to_uv(U8 *s, STRLEN curlen, STRLEN* retlen, U32 flags)','name' => 'utf8_to_uv'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits.
381              
382             void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See
383             C.
384              
385             SV* hv_iterval(HV* tb, HE* entry)','name' => 'hv_iterval'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to.
386              
387             char* sv_reftype(SV* sv, int ob)','name' => 'sv_reftype'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C.','name' => 'SVt_IV'},'av_len' => {'text' => 'Returns the highest index in the array. Returns -1 if the array is
388             empty.
389              
390             I32 av_len(AV* ar)','name' => 'av_len'},'sv_unmagic' => {'text' => 'Removes magic from an SV.
391              
392             int sv_unmagic(SV* sv, int type)','name' => 'sv_unmagic'},'sv_setiv_mg' => {'text' => 'Like C, but also handles \'set\' magic.
393              
394             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
395             SV C. Modifies C but not C. Handles \'get\' magic, but
396             not \'set\' magic. See C.
397              
398             void sv_catsv(SV* dsv, SV* ssv)','name' => 'sv_catsv'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled
399              
400             void SvTAINT(SV* sv)','name' => 'SvTAINT'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C.
401             See C and L for other uses.
402              
403             PUTBACK;','name' => 'PUTBACK'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string.
404              
405             void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C.
406              
407             int mg_clear(SV* sv)','name' => 'mg_clear'},'SvCUR_set' => {'text' => 'Set the length of the string which is in the SV. See C.
408              
409             void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'SvNOK' => {'text' => 'Returns a boolean indicating whether the SV contains a double.
410              
411             bool SvNOK(SV* sv)','name' => 'SvNOK'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. C should
412             be a valid UTF-8 string. If C is set then the package will be
413             created if it does not already exist. If C is not set and the
414             package does not exist then NULL is returned.
415              
416             HV* gv_stashpv(const char* name, I32 create)','name' => 'gv_stashpv'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C, C, and
417             L.','name' => 'G_SCALAR'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element.
418             Handles \'set\' magic. See C.
419              
420             void PUSHi(IV iv)','name' => 'PUSHi'},'hv_exists_ent' => {'text' => 'Returns a boolean indicating whether the specified hash key exists. C
421             can be a valid precomputed hash value, or 0 to ask for it to be
422             computed.
423              
424             bool hv_exists_ent(HV* tb, SV* key, U32 hash)','name' => 'hv_exists_ent'},'SvNIOK' => {'text' => 'Returns a boolean indicating whether the SV contains a number, integer or
425             double.
426              
427             bool SvNIOK(SV* sv)','name' => 'SvNIOK'},'SvTAINTED_off' => {'text' => 'Untaints an SV. Be I careful with this routine, as it short-circuits
428             some of Perl\'s fundamental security features. XS module authors should not
429             use this function unless they fully understand all the implications of
430             unconditionally untainting the value. Untainting should be done in the
431             standard perl fashion, via a carefully crafted regexp, rather than directly
432             untainting variables.
433              
434             void SvTAINTED_off(SV* sv)','name' => 'SvTAINTED_off'},'newSVpvf' => {'text' => 'Creates a new SV an initialize it with the string formatted like
435             C.
436              
437             SV* newSVpvf(const char* pat, ...)','name' => 'newSVpvf'},'require_pv' => {'text' => 'Tells Perl to C a module.
438              
439             NOTE: the perl_ form of this function is deprecated.
440              
441             void require_pv(const char* pv)','name' => 'require_pv'},'sv_upgrade' => {'text' => 'Upgrade an SV to a more complex form. Use C. See
442             C.
443              
444             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.
445              
446             bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'hv_store' => {'text' => 'Stores an SV in a hash. The hash key is specified as C and C is
447             the length of the key. The C parameter is the precomputed hash
448             value; if it is zero then Perl will compute it. The return value will be
449             NULL if the operation failed or if the value did not need to be actually
450             stored within the hash (as in the case of tied hashes). Otherwise it can
451             be dereferenced to get the original C. Note that the caller is
452             responsible for suitably incrementing the reference count of C before
453             the call, and decrementing it if the function returned NULL.
454              
455             See L for more
456             information on how to use this function on tied hashes.
457              
458             SV** hv_store(HV* tb, const char* key, U32 klen, SV* val, U32 hash)','name' => 'hv_store'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C.
459              
460             void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'SvIVX' => {'text' => 'Returns the integer which is stored in the SV, assuming SvIOK is
461             true.
462              
463             IV SvIVX(SV* sv)','name' => 'SvIVX'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L.
464              
465             void perl_destruct(PerlInterpreter* interp)','name' => 'perl_destruct'},'isUPPER' => {'text' => 'Returns a boolean indicating whether the C C is an uppercase
466             character.
467              
468             bool isUPPER(char ch)','name' => 'isUPPER'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV.
469              
470             void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C on the
471             stack.
472              
473             void XST_mYES(int pos)','name' => 'XST_mYES'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C into the destination SV C.
474             The source SV may be destroyed if it is mortal. Does not handle \'set\'
475             magic. See the macro forms C, C and
476             C.
477              
478             void sv_setsv(SV* dsv, SV* ssv)','name' => 'sv_setsv'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV.
479              
480             void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'POPs' => {'text' => 'Pops an SV off the stack.
481              
482             SV* POPs','name' => 'POPs'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it.
483              
484             NV SvNV(SV* sv)','name' => 'SvNV'},'SvUTF8' => {'text' => 'Returns a boolean indicating whether the SV contains UTF-8 encoded data.
485              
486             void SvUTF8(SV* sv)','name' => 'SvUTF8'},'gv_fetchmethod_autoload' => {'text' => 'Returns the glob which contains the subroutine to call to invoke the method
487             on the C. In fact in the presence of autoloading this may be the
488             glob for "AUTOLOAD". In this case the corresponding variable $AUTOLOAD is
489             already setup.
490              
491             The third parameter of C determines whether
492             AUTOLOAD lookup is performed if the given method is not present: non-zero
493             means yes, look for AUTOLOAD; zero means no, don\'t look for AUTOLOAD.
494             Calling C is equivalent to calling C
495             with a non-zero C parameter.
496              
497             These functions grant C<"SUPER"> token as a prefix of the method name. Note
498             that if you want to keep the returned glob for a long time, you need to
499             check for it being "AUTOLOAD", since at the later time the call may load a
500             different subroutine due to $AUTOLOAD changing its value. Use the glob
501             created via a side effect to do this.
502              
503             These functions have the same side-effects and as C with
504             C. C should be writable if contains C<\':\'> or C<\'
505             \'\'>. The warning against passing the GV returned by C to
506             C apply equally to these functions.
507              
508             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.
509              
510             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.
511             C must be a valid precomputed hash number for the given C, or 0
512             if you want the function to compute it. IF C is set then the fetch
513             will be part of a store. Make sure the return value is non-null before
514             accessing it. The return value when C is a tied hash is a pointer to a
515             static location, so be sure to make a copy of the structure if you need to
516             store it somewhere.
517              
518             See L for more
519             information on how to use this function on tied hashes.
520              
521             HE* hv_fetch_ent(HV* tb, SV* key, I32 lval, U32 hash)','name' => 'hv_fetch_ent'},'ENTER' => {'text' => 'Opening bracket on a callback. See C and L.
522              
523             ENTER;','name' => 'ENTER'},'isLOWER' => {'text' => 'Returns a boolean indicating whether the C C is a lowercase
524             character.
525              
526             bool isLOWER(char ch)','name' => 'isLOWER'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are
527             identical.
528              
529             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
530             not.
531              
532             bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'PL_sv_no' => {'text' => 'This is the C SV. See C. Always refer to this as
533             C<&PL_sv_no>.
534              
535             SV PL_sv_no','name' => 'PL_sv_no'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See
536             C.
537              
538             char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'SvNOKp' => {'text' => 'Returns a boolean indicating whether the SV contains a double. Checks the
539             B setting. Use C.
540              
541             bool SvNOKp(SV* sv)','name' => 'SvNOKp'},'ix' => {'text' => 'Variable which is setup by C to indicate which of an
542             XSUB\'s aliases was used to invoke it. See L.
543              
544             I32 ix','name' => 'ix'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another.
545              
546             void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'PUSHs' => {'text' => 'Push an SV onto the stack. The stack must have room for this element.
547             Does not handle \'set\' magic. See C.
548              
549             void PUSHs(SV* sv)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV. Does not handle \'set\' magic.
550             See C.
551              
552             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
553             perform the upgrade if necessary. See C.
554              
555             void SvUPGRADE(SV* sv, svtype type)','name' => 'SvUPGRADE'},'bytes_to_utf8' => {'text' => 'Converts a string C of length C from ASCII into UTF8 encoding.
556             Returns a pointer to the newly-created string, and sets C to
557             reflect the new length.
558              
559             NOTE: this function is experimental and may change or be
560             removed without notice.
561              
562             U8* bytes_to_utf8(U8 *s, STRLEN *len)','name' => 'bytes_to_utf8'},'items' => {'text' => 'Variable which is setup by C to indicate the number of
563             items on the stack. See L.
564              
565             I32 items','name' => 'items'},'XST_mPV' => {'text' => 'Place a copy of a string into the specified position C on the stack.
566             The value is stored in a new mortal SV.
567              
568             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
569             handled automatically by C.
570              
571             dXSI32;','name' => 'dXSI32'},'sv_setref_iv' => {'text' => 'Copies an integer into a new SV, optionally blessing the SV. The C
572             argument will be upgraded to an RV. That RV will be modified to point to
573             the new SV. The C argument indicates the package for the
574             blessing. Set C to C to avoid the blessing. The new SV
575             will be returned and will have a reference count of 1.
576              
577             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.
578             SvPOK(sv) must be true and the C must be a pointer to somewhere inside
579             the string buffer. The C becomes the first character of the adjusted
580             string.
581              
582             void sv_chop(SV* sv, char* ptr)','name' => 'sv_chop'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary.
583             See C.
584              
585             void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. This will use C and will
586             upgrade the SV to C. Returns a pointer to the character buffer.
587             Use C.
588              
589             char* sv_grow(SV* sv, STRLEN newlen)','name' => 'sv_grow'},'sv_setuv_mg' => {'text' => 'Like C, but also handles \'set\' magic.
590              
591             void sv_setuv_mg(SV *sv, UV u)','name' => 'sv_setuv_mg'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually
592             handled automatically by C. See C.','name' => 'XS_VERSION'},'newSVnv' => {'text' => 'Creates a new SV and copies a floating point value into it.
593             The reference count for the SV is set to 1.
594              
595             SV* newSVnv(NV n)','name' => 'newSVnv'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not
596             handle \'set\' magic. See C.
597              
598             void XPUSHs(SV* sv)','name' => 'XPUSHs'},'HeVAL' => {'text' => 'Returns the value slot (type C) stored in the hash entry.
599              
600             SV* HeVAL(HE* he)','name' => 'HeVAL'},'HePV' => {'text' => 'Returns the key slot of the hash entry as a C value, doing any
601             necessary dereferencing of possibly C keys. The length of the string
602             is placed in C (this is a macro, so do I use C<&len>). If you do
603             not care about what the length of the key is, you may use the global
604             variable C, though this is rather less efficient than using a local
605             variable. Remember though, that hash keys in perl are free to contain
606             embedded nulls, so using C or similar is not a good way to find
607             the length of hash keys. This is very similar to the C macro
608             described elsewhere in this document.
609              
610             char* HePV(HE* he, STRLEN len)','name' => 'HePV'},'PL_na' => {'text' => 'A convenience variable which is typically used with C when one
611             doesn\'t care about the length of the string. It is usually more efficient
612             to either declare a local variable and use that instead or to use the
613             C macro.
614              
615             STRLEN PL_na','name' => 'PL_na'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the
616             SV is set to 1.
617              
618             SV* newSViv(IV i)','name' => 'newSViv'},'sv_setpv' => {'text' => 'Copies a string into an SV. The string must be null-terminated. Does not
619             handle \'set\' magic. See C.
620              
621             void sv_setpv(SV* sv, const char* ptr)','name' => 'sv_setpv'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See C.','name' => 'SVt_PVHV'},'uv_to_utf8' => {'text' => 'Adds the UTF8 representation of the Unicode codepoint C to the end
622             of the string C; C should be have at least C free
623             bytes available. The return value is the pointer to the byte after the
624             end of the new character. In other words,
625              
626             d = uv_to_utf8(d, uv);
627              
628             is the recommended Unicode-aware way of saying
629              
630             *(d++) = uv;
631              
632             NOTE: this function is experimental and may change or be
633             removed without notice.
634              
635             U8* uv_to_utf8(U8 *d, UV uv)','name' => 'uv_to_utf8'},'gv_fetchmethod' => {'text' => 'See L.
636              
637             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
638             argument more than once.
639              
640             void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'SvGROW' => {'text' => 'Expands the character buffer in the SV so that it has room for the
641             indicated number of bytes (remember to reserve space for an extra trailing
642             NUL character). Calls C to perform the expansion if necessary.
643             Returns a pointer to the character buffer.
644              
645             void SvGROW(SV* sv, STRLEN len)','name' => 'SvGROW'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV.
646              
647             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
648             stored inside the SV but sv_usepvn allows the SV to use an outside string.
649             The C should point to memory that was allocated by C. The
650             string length, C, must be supplied. This function will realloc the
651             memory pointed to by C, so that pointer should not be freed or used by
652             the programmer after giving it to sv_usepvn. Does not handle \'set\' magic.
653             See C.
654              
655             void sv_usepvn(SV* sv, char* ptr, STRLEN len)','name' => 'sv_usepvn'},'sv_catpv' => {'text' => 'Concatenates the string onto the end of the string which is in the SV.
656             Handles \'get\' magic, but not \'set\' magic. See C.
657              
658             void sv_catpv(SV* sv, const char* ptr)','name' => 'sv_catpv'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count.
659              
660             U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'sv_len' => {'text' => 'Returns the length of the string in the SV. See also C.
661              
662             STRLEN sv_len(SV* sv)','name' => 'sv_len'},'warn' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function. Use this
663             function the same way you use the C C function. See
664             C.
665              
666             void warn(const char* pat, ...)','name' => 'warn'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C and L.
667              
668             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
669             hash and returned to the caller. The C is the length of the key.
670             The C value will normally be zero; if set to G_DISCARD then NULL
671             will be returned.
672              
673             SV* hv_delete(HV* tb, const char* key, U32 klen, I32 flags)','name' => 'hv_delete'},'hv_undef' => {'text' => 'Undefines the hash.
674              
675             void hv_undef(HV* tb)','name' => 'hv_undef'},'hv_delete_ent' => {'text' => 'Deletes a key/value pair in the hash. The value SV is removed from the
676             hash and returned to the caller. The C value will normally be zero;
677             if set to G_DISCARD then NULL will be returned. C can be a valid
678             precomputed hash value, or 0 to ask for it to be computed.
679              
680             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
681             class name for a C++ XS constructor. This is always a C. See C.
682              
683             char* CLASS','name' => 'CLASS'},'sv_isobject' => {'text' => 'Returns a boolean indicating whether the SV is an RV pointing to a blessed
684             object. If the SV is not an RV, or if the object is not blessed, then this
685             will return false.
686              
687             int sv_isobject(SV* sv)','name' => 'sv_isobject'},'Newc' => {'text' => 'The XSUB-writer\'s interface to the C C function, with
688             cast.
689              
690             void Newc(int id, void* ptr, int nitems, type, cast)','name' => 'Newc'},'HeKLEN' => {'text' => 'If this is negative, and amounts to C, it indicates the entry
691             holds an C key. Otherwise, holds the actual length of the key. Can
692             be assigned to. The C macro is usually preferable for finding key
693             lengths.
694              
695             STRLEN HeKLEN(HE* he)','name' => 'HeKLEN'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element.
696             Handles \'set\' magic. See C.
697              
698             void PUSHn(NV nv)','name' => 'PUSHn'},'sv_setiv' => {'text' => 'Copies an integer into the given SV. Does not handle \'set\' magic. See
699             C.
700              
701             void sv_setiv(SV* sv, IV num)','name' => 'sv_setiv'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it.
702              
703             IV SvIV(SV* sv)','name' => 'SvIV'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once
704             used, guarantees that there is room for at least C to be pushed
705             onto the stack.
706              
707             void EXTEND(SP, int nitems)','name' => 'EXTEND'},'PL_sv_yes' => {'text' => 'This is the C SV. See C. Always refer to this as
708             C<&PL_sv_yes>.
709              
710             SV PL_sv_yes','name' => 'PL_sv_yes'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it.
711             The reference count for the SV is set to 1.
712              
713             SV* newSVuv(UV u)','name' => 'newSVuv'},'SvNVX' => {'text' => 'Returns the double which is stored in the SV, assuming SvNOK is
714             true.
715              
716             NV SvNVX(SV* sv)','name' => 'SvNVX'},'gv_fetchmeth' => {'text' => 'Returns the glob with the given C and a defined subroutine or
717             C. The glob lives in the given C, or in the stashes
718             accessible via @ISA and @UNIVERSAL.
719              
720             The argument C should be either 0 or -1. If C, as a
721             side-effect creates a glob with the given C in the given C
722             which in the case of success contains an alias for the subroutine, and sets
723             up caching info for this glob. Similarly for all the searched stashes.
724              
725             This function grants C<"SUPER"> token as a postfix of the stash name. The
726             GV returned from C may be a method cache entry, which is not
727             visible to Perl code. So when calling C, you should not use
728             the GV directly; instead, you should use the method\'s CV, which can be
729             obtained from the GV with the C macro.
730              
731             GV* gv_fetchmeth(HV* stash, const char* name, STRLEN len, I32 level)','name' => 'gv_fetchmeth'},'SvUTF8_off' => {'text' => 'Unsets the UTF8 status of an SV.
732              
733             void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'looks_like_number' => {'text' => 'Test if an the content of an SV looks like a number (or is a
734             number).
735              
736             I32 looks_like_number(SV* sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C, but also handles \'set\' magic.
737              
738             void sv_catpv_mg(SV *sv, const char *ptr)','name' => 'sv_catpv_mg'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately.
739              
740             XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry.
741              
742             U32 HeHASH(HE* he)','name' => 'HeHASH'},'SvIOK' => {'text' => 'Returns a boolean indicating whether the SV contains an integer.
743              
744             bool SvIOK(SV* sv)','name' => 'SvIOK'},'newSVpv' => {'text' => 'Creates a new SV and copies a string into it. The reference count for the
745             SV is set to 1. If C is zero, Perl will compute the length using
746             strlen(). For efficiency, consider using C instead.
747              
748             SV* newSVpv(const char* s, STRLEN len)','name' => 'newSVpv'},'fbm_instr' => {'text' => 'Returns the location of the SV in the string delimited by C and
749             C. It returns C if the string can\'t be found. The C
750             does not have to be fbm_compiled, but the search will not be as fast
751             then.
752              
753             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
754             output. Does not handle \'set\' magic. See C.
755              
756             void sv_setpvf(SV* sv, const char* pat, ...)','name' => 'sv_setpvf'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles
757             \'set\' magic. See C.
758              
759             void XPUSHn(NV nv)','name' => 'XPUSHn'},'SvPV_force' => {'text' => 'Like but will force the SV into becoming a string (SvPOK). You want
760             force if you are going to update the SvPVX directly.
761              
762             char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part
763             attributable to C. See C.
764              
765             STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'call_sv' => {'text' => 'Performs a callback to the Perl sub whose name is in the SV. See
766             L.
767              
768             NOTE: the perl_ form of this function is deprecated.
769              
770             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,
771             C. Returns true or false.
772              
773             bool strGT(char* s1, char* s2)','name' => 'strGT'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a UTF8 string (do not use frivolously)
774             and disables all other OK bits.
775            
776             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.
777              
778             int mg_get(SV* sv)','name' => 'mg_get'},'SvTRUE' => {'text' => 'Returns a boolean indicating whether Perl would evaluate the SV as true or
779             false, defined or undefined. Does not handle \'get\' magic.
780              
781             bool SvTRUE(SV* sv)','name' => 'SvTRUE'},'HeSVKEY_set' => {'text' => 'Sets the key to a given C, taking care to set the appropriate flags to
782             indicate the presence of an C key, and returns the same
783             C.
784              
785             SV* HeSVKEY_set(HE* he, SV* sv)','name' => 'HeSVKEY_set'},'POPl' => {'text' => 'Pops a long off the stack.
786              
787             long POPl','name' => 'POPl'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L.
788              
789             SPAGAIN;','name' => 'SPAGAIN'},'call_method' => {'text' => 'Performs a callback to the specified Perl method. The blessed object must
790             be on the stack. See L.
791              
792             NOTE: the perl_ form of this function is deprecated.
793              
794             I32 call_method(const char* methname, I32 flags)','name' => 'call_method'},'sv_vsetpvfn' => {'text' => 'Works like C but copies the text into the SV instead of
795             appending it.
796              
797             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
798             the Perl subroutine does not exist then it will be declared (which has the
799             same effect as saying C). If C is not set and the
800             subroutine does not exist then NULL is returned.
801              
802             NOTE: the perl_ form of this function is deprecated.
803              
804             CV* get_cv(const char* name, I32 create)','name' => 'get_cv'},'SvIOKp' => {'text' => 'Returns a boolean indicating whether the SV contains an integer. Checks
805             the B setting. Use C.
806              
807             bool SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C on the
808             stack.
809              
810             void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'perl_parse' => {'text' => 'Tells a Perl interpreter to parse a Perl script. See L.
811              
812             int perl_parse(PerlInterpreter* interp, XSINIT_t xsinit, int argc, char** argv, char** env)','name' => 'perl_parse'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory used by the
813             array itself.
814              
815             void av_clear(AV* ar)','name' => 'av_clear'},'av_unshift' => {'text' => 'Unshift the given number of C values onto the beginning of the
816             array. The array will grow automatically to accommodate the addition. You
817             must then use C to assign values to these new elements.
818              
819             void av_unshift(AV* ar, I32 num)','name' => 'av_unshift'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C.
820              
821             int mg_set(SV* sv)','name' => 'mg_set'},'sv_mortalcopy' => {'text' => 'Creates a new SV which is a copy of the original SV. The new SV is marked
822             as mortal.
823              
824             SV* sv_mortalcopy(SV* oldsv)','name' => 'sv_mortalcopy'},'G_NOARGS' => {'text' => 'Indicates that no arguments are being sent to a callback. See
825             L.','name' => 'G_NOARGS'},'SvUVX' => {'text' => 'Returns the unsigned integer which is stored in the SV, assuming SvIOK is
826             true.
827              
828             UV SvUVX(SV* sv)','name' => 'SvUVX'},'Newz' => {'text' => 'The XSUB-writer\'s interface to the C C function. The allocated
829             memory is zeroed with C.
830              
831             void Newz(int id, void* ptr, int nitems, type)','name' => 'Newz'},'savepvn' => {'text' => 'Copy a string to a safe spot. The C indicates number of bytes to
832             copy. This does not use an SV.
833              
834             char* savepvn(const char* sv, I32 len)','name' => 'savepvn'},'eval_sv' => {'text' => 'Tells Perl to C the string in the SV.
835              
836             NOTE: the perl_ form of this function is deprecated.
837              
838             I32 eval_sv(SV* sv, I32 flags)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C and
839             L.
840              
841             FREETMPS;','name' => 'FREETMPS'},'av_exists' => {'text' => 'Returns true if the element indexed by C has been initialized.
842              
843             This relies on the fact that uninitialized array elements are set to
844             C<&PL_sv_undef>.
845              
846             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.
847              
848             STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'Move' => {'text' => 'The XSUB-writer\'s interface to the C C function. The C is the
849             source, C is the destination, C is the number of items, and C is
850             the type. Can do overlapping moves. See also C.
851              
852             void Move(void* src, void* dest, int nitems, type)','name' => 'Move'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow.
853              
854             char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'GIMME' => {'text' => 'A backward-compatible version of C which can only return
855             C or C; in a void context, it returns C.
856             Deprecated. Use C instead.
857              
858             U32 GIMME','name' => 'GIMME'},'NEWSV' => {'text' => 'Creates a new SV. A non-zero C parameter indicates the number of
859             bytes of preallocated string space the SV should have. An extra byte for a
860             tailing NUL is also reserved. (SvPOK is not set for the SV even if string
861             space is allocated.) The reference count for the new SV is set to 1.
862             C is an integer id between 0 and 1299 (used to identify leaks).
863              
864             SV* NEWSV(int id, STRLEN len)','name' => 'NEWSV'},'sv_bless' => {'text' => 'Blesses an SV into a specified package. The SV must be an RV. The package
865             must be designated by its stash (see C). The reference count
866             of the SV is unaffected.
867              
868             SV* sv_bless(SV* sv, HV* stash)','name' => 'sv_bless'},'sv_isa' => {'text' => 'Returns a boolean indicating whether the SV is blessed into the specified
869             class. This does not check for subtypes; use C to verify
870             an inheritance relationship.
871              
872             int sv_isa(SV* sv, const char* name)','name' => 'sv_isa'},'newXS' => {'text' => 'Used by C to hook up XSUBs as Perl subs.','name' => 'newXS'},'isALNUM' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphanumeric
873             character (including underscore) or digit.
874              
875             bool isALNUM(char ch)','name' => 'isALNUM'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer.
876              
877             void SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'sv_catpvf' => {'text' => 'Processes its arguments like C and appends the formatted output
878             to an SV. Handles \'get\' magic, but not \'set\' magic. C must
879             typically be called after calling this function to handle \'set\' magic.
880              
881             void sv_catpvf(SV* sv, const char* pat, ...)','name' => 'sv_catpvf'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C.
882              
883             void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII alphabetic
884             character.
885              
886             bool isALPHA(char ch)','name' => 'isALPHA'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L.
887              
888             PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'Nullhv' => {'text' => 'Null HV pointer.','name' => 'Nullhv'},'av_fill' => {'text' => 'Ensure than an array has a given number of elements, equivalent to
889             Perl\'s C<$#array = $fill;>.
890              
891             void av_fill(AV* ar, I32 fill)','name' => 'av_fill'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV.
892              
893             SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L.
894              
895             void perl_construct(PerlInterpreter* interp)','name' => 'perl_construct'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C.
896              
897             svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits.
898              
899             void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV.
900              
901             void sv_dec(SV* sv)','name' => 'sv_dec'},'strLE' => {'text' => 'Test two strings to see if the first, C, is less than or equal to the
902             second, C. Returns true or false.
903              
904             bool strLE(char* s1, char* s2)','name' => 'strLE'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV.
905              
906             void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C function.
907              
908             void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L.
909              
910             void perl_free(PerlInterpreter* interp)','name' => 'perl_free'},'SvOK' => {'text' => 'Returns a boolean indicating whether the value is an SV.
911              
912             bool SvOK(SV* sv)','name' => 'SvOK'},'sv_setref_nv' => {'text' => 'Copies a double into a new SV, optionally blessing the SV. The C
913             argument will be upgraded to an RV. That RV will be modified to point to
914             the new SV. The C argument indicates the package for the
915             blessing. Set C to C to avoid the blessing. The new SV
916             will be returned and will have a reference count of 1.
917              
918             SV* sv_setref_nv(SV* rv, const char* classname, NV nv)','name' => 'sv_setref_nv'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C.
919              
920             MAGIC* mg_find(SV* sv, int type)','name' => 'mg_find'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the C C is an ASCII
921             digit.
922              
923             bool isDIGIT(char ch)','name' => 'isDIGIT'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double.
924              
925             void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'eval_pv' => {'text' => 'Tells Perl to C the given string and return an SV* result.
926              
927             NOTE: the perl_ form of this function is deprecated.
928              
929             SV* eval_pv(const char* p, I32 croak_on_error)','name' => 'eval_pv'},'sv_setpvf_mg' => {'text' => 'Like C, but also handles \'set\' magic.
930              
931             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.
932             Checks the B setting. Use C.
933              
934             bool SvPOKp(SV* sv)','name' => 'SvPOKp'},'sv_free' => {'text' => 'Free the memory used by an SV.
935              
936             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
937             C indicates number of bytes to copy. Handles \'get\' magic, but not
938             \'set\' magic. See C.
939              
940             void sv_catpvn(SV* sv, const char* ptr, STRLEN len)','name' => 'sv_catpvn'},'newCONSTSUB' => {'text' => 'Creates a constant sub equivalent to Perl C which is
941             eligible for inlining at compile-time.
942              
943             void newCONSTSUB(HV* stash, char* name, SV* sv)','name' => 'newCONSTSUB'},'sv_setref_pv' => {'text' => 'Copies a pointer into a new SV, optionally blessing the SV. The C
944             argument will be upgraded to an RV. That RV will be modified to point to
945             the new SV. If the C argument is NULL then C will be placed
946             into the SV. The C argument indicates the package for the
947             blessing. Set C to C to avoid the blessing. The new SV
948             will be returned and will have a reference count of 1.
949              
950             Do not use with other Perl types such as HV, AV, SV, CV, because those
951             objects will become corrupted by the pointer copy process.
952              
953             Note that C copies the string while this copies the pointer.
954              
955             SV* sv_setref_pv(SV* rv, const char* classname, void* pv)','name' => 'sv_setref_pv'},'fbm_compile' => {'text' => 'Analyses the string in order to make fast searches on it using fbm_instr()
956             -- the Boyer-Moore algorithm.
957              
958             void fbm_compile(SV* sv, U32 flags)','name' => 'fbm_compile'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array
959             is empty.
960              
961             SV* av_pop(AV* ar)','name' => 'av_pop'},'sv_utf8_downgrade' => {'text' => 'Attempt to convert the PV of an SV from UTF8-encoded to byte encoding.
962             This may not be possible if the PV contains non-byte encoding characters;
963             if this is the case, either returns false or, if C is not
964             true, croaks.
965              
966             NOTE: this function is experimental and may change or be
967             removed without notice.
968              
969             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
970             double. Checks the B setting. Use C.
971              
972             bool SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'croak' => {'text' => 'This is the XSUB-writer\'s interface to Perl\'s C function.
973             Normally use this function the same way you use the C C
974             function. See C.
975              
976             If you want to throw an exception object, assign the object to
977             C<$@> and then pass C to croak():
978              
979             errsv = get_sv("@", TRUE);
980             sv_setsv(errsv, exception_object);
981             croak(Nullch);
982              
983             void croak(const char* pat, ...)','name' => 'croak'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C displaced by C characters, either
984             forward or backward.
985              
986             WARNING: do not use the following unless you *know* C is within
987             the UTF-8 data pointed to by C *and* that on entry C is aligned
988             on the first byte of character or just after the last byte of a character.
989              
990             NOTE: this function is experimental and may change or be
991             removed without notice.
992              
993             U8* utf8_hop(U8 *s, I32 off)','name' => 'utf8_hop'},'THIS' => {'text' => 'Variable which is setup by C to designate the object in a C++
994             XSUB. This is always the proper type for the C++ object. See C and
995             L.
996              
997             (whatever) THIS','name' => 'THIS'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide
998             UTF8 bytes as a single character.
999              
1000             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
1001             handled by C.
1002              
1003             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
1004             string must be specified with C. The C argument will be upgraded to
1005             an RV. That RV will be modified to point to the new SV. The C
1006             argument indicates the package for the blessing. Set C to
1007             C to avoid the blessing. The new SV will be returned and will have
1008             a reference count of 1.
1009              
1010             Note that C copies the pointer while this copies the string.
1011              
1012             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.
1013             The C indicates the length of the string. Handles \'set\' magic. See
1014             C.
1015              
1016             void PUSHp(char* str, STRLEN len)','name' => 'PUSHp'},'Nullcv' => {'text' => 'Null CV pointer.','name' => 'Nullcv'},'get_av' => {'text' => 'Returns the AV of the specified Perl array. If C is set and the
1017             Perl variable does not exist then it will be created. If C is not
1018             set and the variable does not exist then NULL is returned.
1019              
1020             NOTE: the perl_ form of this function is deprecated.
1021              
1022             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>.
1023              
1024             SV PL_sv_undef','name' => 'PL_sv_undef'},'hv_iterkeysv' => {'text' => 'Returns the key as an C from the current position of the hash
1025             iterator. The return value will always be a mortal copy of the key. Also
1026             see C.
1027              
1028             SV* hv_iterkeysv(HE* entry)','name' => 'hv_iterkeysv'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C on the
1029             stack.
1030              
1031             void XST_mNO(int pos)','name' => 'XST_mNO'},'toUPPER' => {'text' => 'Converts the specified character to uppercase.
1032              
1033             char toUPPER(char ch)','name' => 'toUPPER'},'av_delete' => {'text' => 'Deletes the element indexed by C from the array. Returns the
1034             deleted element. C is currently ignored.
1035              
1036             SV* av_delete(AV* ar, I32 key, I32 flags)','name' => 'av_delete'},'utf8_distance' => {'text' => 'Returns the number of UTF8 characters between the UTF-8 pointers C
1037             and C.
1038              
1039             WARNING: use only if you *know* that the pointers point inside the
1040             same UTF-8 buffer.
1041              
1042             NOTE: this function is experimental and may change or be
1043             removed without notice.
1044              
1045             IV utf8_distance(U8 *a, U8 *b)','name' => 'utf8_distance'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C and
1046             L.
1047              
1048             SAVETMPS;','name' => 'SAVETMPS'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally
1049             appending to the currently-stored string.
1050              
1051             char* sv_gets(SV* sv, PerlIO* fp, I32 append)','name' => 'sv_gets'},'AvFILL' => {'text' => 'Same as C. Deprecated, use C instead.
1052              
1053             int AvFILL(AV* av)','name' => 'AvFILL'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C.','name' => 'ORIGMARK'},'SP' => {'text' => 'Stack pointer. This is usually handled by C. See C and
1054             C.','name' => 'SP'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits.
1055              
1056             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
1057             ssv. May evaluate arguments more than once.
1058              
1059             void SvSetSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetSV_nosteal'},'sv_catpvn_mg' => {'text' => 'Like C, but also handles \'set\' magic.
1060              
1061             void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)','name' => 'sv_catpvn_mg'},'sv_usepvn_mg' => {'text' => 'Like C, but also handles \'set\' magic.
1062              
1063             void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'Zero' => {'text' => 'The XSUB-writer\'s interface to the C C function. The C is the
1064             destination, C is the number of items, and C is the type.
1065              
1066             void Zero(void* dest, int nitems, type)','name' => 'Zero'},'hv_fetch' => {'text' => 'Returns the SV which corresponds to the specified key in the hash. The
1067             C is the length of the key. If C is set then the fetch will be
1068             part of a store. Check that the return value is non-null before
1069             dereferencing it to a C.
1070              
1071             See L for more
1072             information on how to use this function on tied hashes.
1073              
1074             SV** hv_fetch(HV* tb, const char* key, U32 klen, I32 lval)','name' => 'hv_fetch'},'SvSTASH' => {'text' => 'Returns the stash of the SV.
1075              
1076             HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'PL_modglobal' => {'text' => 'C is a general purpose, interpreter global HV for use by
1077             extensions that need to keep information on a per-interpreter basis.
1078             In a pinch, it can also be used as a symbol table for extensions
1079             to share data among each other. It is a good idea to use keys
1080             prefixed by the package name of the extension that owns the data.
1081              
1082             HV* PL_modglobal','name' => 'PL_modglobal'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C.
1083              
1084             XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'SvRV' => {'text' => 'Dereferences an RV to return the SV.
1085              
1086             SV* SvRV(SV* sv)','name' => 'SvRV'},'Nullch' => {'text' => 'Null character pointer.','name' => 'Nullch'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C.
1087              
1088             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
1089             C if the hash entry contains only a C key.
1090              
1091             SV* HeSVKEY_force(HE* he)','name' => 'HeSVKEY_force'},'sv_rvweaken' => {'text' => 'Weaken a reference.
1092              
1093             SV* sv_rvweaken(SV *sv)','name' => 'sv_rvweaken'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C.','name' => 'MARK'},'newSVpvn' => {'text' => 'Creates a new SV and copies a string into it. The reference count for the
1094             SV is set to 1. Note that if C is zero, Perl will create a zero length
1095             string. You are responsible for ensuring that the source string is at least
1096             C bytes long.
1097              
1098             SV* newSVpvn(const char* s, STRLEN len)','name' => 'newSVpvn'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is
1099             incremented.
1100              
1101             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
1102             to accommodate the addition.
1103              
1104             void av_push(AV* ar, SV* val)','name' => 'av_push'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C.
1105              
1106             XSRETURN_NO;','name' => 'XSRETURN_NO'},'POPn' => {'text' => 'Pops a double off the stack.
1107              
1108             NV POPn','name' => 'POPn'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original
1109             SV is B incremented.
1110              
1111             SV* newRV_noinc(SV *sv)','name' => 'newRV_noinc'},'av_extend' => {'text' => 'Pre-extend an array. The C is the index to which the array should be
1112             extended.
1113              
1114             void av_extend(AV* ar, I32 key)','name' => 'av_extend'},'sv_setpviv_mg' => {'text' => 'Like C, but also handles \'set\' magic.
1115              
1116             void sv_setpviv_mg(SV *sv, IV iv)','name' => 'sv_setpviv_mg'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV.
1117              
1118             void SvROK_on(SV* sv)','name' => 'SvROK_on'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C.
1119              
1120             HE* hv_iternext(HV* tb)','name' => 'hv_iternext'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C.
1121              
1122             dORIGMARK;','name' => 'dORIGMARK'},'G_VOID' => {'text' => 'Used to indicate void context. See C and L.','name' => 'G_VOID'},'sv_newmortal' => {'text' => 'Creates a new SV which is mortal. The reference count of the SV is set to 1.
1123              
1124             SV* sv_newmortal()','name' => 'sv_newmortal'},'hv_iterinit' => {'text' => 'Prepares a starting point to traverse a hash table. Returns the number of
1125             keys in the hash (i.e. the same as C). The return value is
1126             currently only meaningful for hashes without tie magic.
1127              
1128             NOTE: Before version 5.004_65, C used to return the number of
1129             hash buckets that happen to be in use. If you still need that esoteric
1130             value, you can get it through the macro C.
1131              
1132             I32 hv_iterinit(HV* tb)','name' => 'hv_iterinit'},'sv_clear' => {'text' => 'Clear an SV, making it empty. Does not free the memory used by the SV
1133             itself.
1134              
1135             void sv_clear(SV* sv)','name' => 'sv_clear'}};};
1136              
1137 1         19 my $self = bless({
1138             'index' => $VAR1,
1139             perl_version => '5.006002',
1140             } => $class);
1141 1         190 return $self;
1142             }
1143              
1144             1;