blib/lib/Perl/APIReference/V5_016_000.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_016_000; | ||||||
2 | 1 | 1 | 5 | use strict; | |||
1 | 1 | ||||||
1 | 35 | ||||||
3 | 1 | 1 | 4 | use warnings; | |||
1 | 1 | ||||||
1 | 24 | ||||||
4 | 1 | 1 | 4 | use parent 'Perl::APIReference'; | |||
1 | 1 | ||||||
1 | 4 | ||||||
5 | |||||||
6 | sub new { | ||||||
7 | 5 | 5 | 1 | 10 | my $class = shift; | ||
8 | 5 | 9 | my $VAR1; | ||||
9 | |||||||
10 | 5 | 6 | do{$VAR1 = {'newBINOP' => {'text' => 'Constructs, checks, and returns an op of any binary type. I |
||||
5 | 10131 | ||||||
11 | is the opcode. I |
||||||
12 | that C |
||||||
13 | the eight bits of C |
||||||
14 | 2 is automatically set as required. I |
||||||
15 | two ops to be the direct children of the binary op; they are consumed | ||||||
16 | by this function and become part of the constructed op tree. | ||||||
17 | |||||||
18 | OP * newBINOP(I32 type, I32 flags, OP *first, | ||||||
19 | OP *last)','name' => 'newBINOP'},'strGE' => {'text' => 'Test two strings to see if the first, C |
||||||
20 | the second, C |
||||||
21 | |||||||
22 | bool strGE(char* s1, char* s2)','name' => 'strGE'},'SvPV' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of | ||||||
23 | the SV if the SV does not contain a string. The SV may cache the | ||||||
24 | stringified version becoming C |
||||||
25 | C |
||||||
26 | |||||||
27 | char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'sv_vsetpvf_mg' => {'text' => 'Like C |
||||||
28 | |||||||
29 | Usually used via its frontend C |
||||||
30 | |||||||
31 | void sv_vsetpvf_mg(SV *const sv, | ||||||
32 | const char *const pat, | ||||||
33 | va_list *const args)','name' => 'sv_vsetpvf_mg'},'SvPVutf8' => {'text' => 'Like C |
||||||
34 | |||||||
35 | char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'sortsv_flags' => {'text' => 'Sort an array, with various options. | ||||||
36 | |||||||
37 | void sortsv_flags(SV** array, size_t num_elts, | ||||||
38 | SVCOMPARE_t cmp, U32 flags)','name' => 'sortsv_flags'},'vwarn' => {'text' => 'This is an XS interface to Perl\'s C |
||||||
39 | |||||||
40 | C |
||||||
41 | argument list. These are used to generate a string message. If the | ||||||
42 | message does not end with a newline, then it will be extended with | ||||||
43 | some indication of the current location in the code, as described for | ||||||
44 | L. | ||||||
45 | |||||||
46 | The error message or object will by default be written to standard error, | ||||||
47 | but this is subject to modification by a C<$SIG{__WARN__}> handler. | ||||||
48 | |||||||
49 | Unlike with L, C |
||||||
50 | |||||||
51 | void vwarn(const char *pat, va_list *args)','name' => 'vwarn'},'scan_oct' => {'text' => 'For backwards compatibility. Use C |
||||||
52 | |||||||
53 | NV scan_oct(const char* start, STRLEN len, | ||||||
54 | STRLEN* retlen)','name' => 'scan_oct'},'my_strlcat' => {'text' => '','name' => 'my_strlcat'},'av_arylen_p' => {'text' => '','name' => 'av_arylen_p'},'gv_add_by_type' => {'text' => '','name' => 'gv_add_by_type'},'newGVOP' => {'text' => 'Constructs, checks, and returns an op of any type that involves an | ||||||
55 | embedded reference to a GV. I |
||||||
56 | eight bits of C |
||||||
57 | reference; calling this function does not transfer ownership of any | ||||||
58 | reference to it. | ||||||
59 | |||||||
60 | OP * newGVOP(I32 type, I32 flags, GV *gv)','name' => 'newGVOP'},'XopDISABLE' => {'text' => 'Temporarily disable a member of the XOP, by clearing the appropriate flag. | ||||||
61 | |||||||
62 | void XopDISABLE(XOP *xop, which)','name' => 'XopDISABLE'},'is_uni_ascii' => {'text' => '','name' => 'is_uni_ascii'},'find_runcv' => {'text' => 'Locate the CV corresponding to the currently executing sub or eval. | ||||||
63 | If db_seqp is non_null, skip CVs that are in the DB package and populate | ||||||
64 | *db_seqp with the cop sequence number at the point that the DB:: code was | ||||||
65 | entered. (allows debuggers to eval in the scope of the breakpoint rather | ||||||
66 | than in the scope of the debugger itself). | ||||||
67 | |||||||
68 | CV* find_runcv(U32 *db_seqp)','name' => 'find_runcv'},'utf8n_to_uvuni' => {'text' => 'Bottom level UTF-8 decode routine. | ||||||
69 | Returns the code point value of the first character in the string C |
||||||
70 | which is assumed to be in UTF-8 (or UTF-EBCDIC) encoding, and no longer than | ||||||
71 | C |
||||||
72 | the length, in bytes, of that character. | ||||||
73 | |||||||
74 | The value of C |
||||||
75 | well-formed UTF-8 character. If C |
||||||
76 | zero is returned and C<*retlen> is set so that (S |
||||||
77 | next possible position in C |
||||||
78 | Also, if UTF-8 warnings haven\'t been lexically disabled, a warning is raised. | ||||||
79 | |||||||
80 | Various ALLOW flags can be set in C |
||||||
81 | individual types of malformations, such as the sequence being overlong (that | ||||||
82 | is, when there is a shorter sequence that can express the same code point; | ||||||
83 | overlong sequences are expressly forbidden in the UTF-8 standard due to | ||||||
84 | potential security issues). Another malformation example is the first byte of | ||||||
85 | a character not being a legal first byte. See F |
||||||
86 | flags. For allowed 0 length strings, this function returns 0; for allowed | ||||||
87 | overlong sequences, the computed code point is returned; for all other allowed | ||||||
88 | malformations, the Unicode REPLACEMENT CHARACTER is returned, as these have no | ||||||
89 | determinable reasonable value. | ||||||
90 | |||||||
91 | The UTF8_CHECK_ONLY flag overrides the behavior when a non-allowed (by other | ||||||
92 | flags) malformation is found. If this flag is set, the routine assumes that | ||||||
93 | the caller will raise a warning, and this function will silently just set | ||||||
94 | C |
||||||
95 | |||||||
96 | Certain code points are considered problematic. These are Unicode surrogates, | ||||||
97 | Unicode non-characters, and code points above the Unicode maximum of 0x10FFFF. | ||||||
98 | By default these are considered regular code points, but certain situations | ||||||
99 | warrant special handling for them. If C |
||||||
100 | UTF8_DISALLOW_ILLEGAL_INTERCHANGE, all three classes are treated as | ||||||
101 | malformations and handled as such. The flags UTF8_DISALLOW_SURROGATE, | ||||||
102 | UTF8_DISALLOW_NONCHAR, and UTF8_DISALLOW_SUPER (meaning above the legal Unicode | ||||||
103 | maximum) can be set to disallow these categories individually. | ||||||
104 | |||||||
105 | The flags UTF8_WARN_ILLEGAL_INTERCHANGE, UTF8_WARN_SURROGATE, | ||||||
106 | UTF8_WARN_NONCHAR, and UTF8_WARN_SUPER will cause warning messages to be raised | ||||||
107 | for their respective categories, but otherwise the code points are considered | ||||||
108 | valid (not malformations). To get a category to both be treated as a | ||||||
109 | malformation and raise a warning, specify both the WARN and DISALLOW flags. | ||||||
110 | (But note that warnings are not raised if lexically disabled nor if | ||||||
111 | UTF8_CHECK_ONLY is also specified.) | ||||||
112 | |||||||
113 | Very large code points (above 0x7FFF_FFFF) are considered more problematic than | ||||||
114 | the others that are above the Unicode legal maximum. There are several | ||||||
115 | reasons: they requre at least 32 bits to represent them on ASCII platforms, are | ||||||
116 | not representable at all on EBCDIC platforms, and the original UTF-8 | ||||||
117 | specification never went above this number (the current 0x10FFFF limit was | ||||||
118 | imposed later). (The smaller ones, those that fit into 32 bits, are | ||||||
119 | representable by a UV on ASCII platforms, but not by an IV, which means that | ||||||
120 | the number of operations that can be performed on them is quite restricted.) | ||||||
121 | The UTF-8 encoding on ASCII platforms for these large code points begins with a | ||||||
122 | byte containing 0xFE or 0xFF. The UTF8_DISALLOW_FE_FF flag will cause them to | ||||||
123 | be treated as malformations, while allowing smaller above-Unicode code points. | ||||||
124 | (Of course UTF8_DISALLOW_SUPER will treat all above-Unicode code points, | ||||||
125 | including these, as malformations.) Similarly, UTF8_WARN_FE_FF acts just like | ||||||
126 | the other WARN flags, but applies just to these code points. | ||||||
127 | |||||||
128 | All other code points corresponding to Unicode characters, including private | ||||||
129 | use and those yet to be assigned, are never considered malformed and never | ||||||
130 | warn. | ||||||
131 | |||||||
132 | Most code should use L() rather than call this directly. | ||||||
133 | |||||||
134 | UV utf8n_to_uvuni(const U8 *s, STRLEN curlen, | ||||||
135 | STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvuni'},'newSVpvn_utf8' => {'text' => 'Creates a new SV and copies a string into it. If utf8 is true, calls | ||||||
136 | C |
||||||
137 | |||||||
138 | SV* newSVpvn_utf8(NULLOK const char* s, STRLEN len, | ||||||
139 | U32 utf8)','name' => 'newSVpvn_utf8'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and | ||||||
140 | C |
||||||
141 | |||||||
142 | dMARK;','name' => 'dMARK'},'whichsig_pv' => {'text' => '','name' => 'whichsig_pv'},'gv_fetchmeth_sv_autoload' => {'text' => 'Exactly like L, but takes the name string in the form | ||||||
143 | of an SV instead of a string/length pair. | ||||||
144 | |||||||
145 | GV* gv_fetchmeth_sv_autoload(HV* stash, SV* namesv, | ||||||
146 | I32 level, U32 flags)','name' => 'gv_fetchmeth_sv_autoload'},'pregcomp' => {'text' => '','name' => 'pregcomp'},'my_cxt_index' => {'text' => '','name' => 'my_cxt_index'},'lex_discard_to' => {'text' => 'Discards the first part of the Llinestr> buffer, | ||||||
147 | up to I |
||||||
148 | all pointers into the buffer updated appropriately. I |
||||||
149 | be later in the buffer than the position of Lbufptr>: | ||||||
150 | it is not permitted to discard text that has yet to be lexed. | ||||||
151 | |||||||
152 | Normally it is not necessarily to do this directly, because it suffices to | ||||||
153 | use the implicit discarding behaviour of L and things | ||||||
154 | based on it. However, if a token stretches across multiple lines, | ||||||
155 | and the lexing code has kept multiple lines of text in the buffer for | ||||||
156 | that purpose, then after completion of the token it would be wise to | ||||||
157 | explicitly discard the now-unneeded earlier lines, to avoid future | ||||||
158 | multi-line tokens growing the buffer without bound. | ||||||
159 | |||||||
160 | NOTE: this function is experimental and may change or be | ||||||
161 | removed without notice. | ||||||
162 | |||||||
163 | void lex_discard_to(char *ptr)','name' => 'lex_discard_to'},'markstack_grow' => {'text' => '','name' => 'markstack_grow'},'cv_get_call_checker' => {'text' => 'Retrieves the function that will be used to fix up a call to I |
||||||
164 | Specifically, the function is applied to an C |
||||||
165 | subroutine call, not marked with C<&>, where the callee can be identified | ||||||
166 | at compile time as I |
||||||
167 | |||||||
168 | The C-level function pointer is returned in I<*ckfun_p>, and an SV | ||||||
169 | argument for it is returned in I<*ckobj_p>. The function is intended | ||||||
170 | to be called in this manner: | ||||||
171 | |||||||
172 | entersubop = (*ckfun_p)(aTHX_ entersubop, namegv, (*ckobj_p)); | ||||||
173 | |||||||
174 | In this call, I |
||||||
175 | which may be replaced by the check function, and I |
||||||
176 | supplying the name that should be used by the check function to refer | ||||||
177 | to the callee of the C |
||||||
178 | It is permitted to apply the check function in non-standard situations, | ||||||
179 | such as to a call to a different subroutine or to a method call. | ||||||
180 | |||||||
181 | By default, the function is | ||||||
182 | L |
||||||
183 | and the SV parameter is I |
||||||
184 | prototype processing. It can be changed, for a particular subroutine, | ||||||
185 | by L. | ||||||
186 | |||||||
187 | void cv_get_call_checker(CV *cv, | ||||||
188 | Perl_call_checker *ckfun_p, | ||||||
189 | SV **ckobj_p)','name' => 'cv_get_call_checker'},'mXPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C |
||||||
190 | indicates the length of the string. Does not use C |
||||||
191 | C |
||||||
192 | |||||||
193 | void mXPUSHp(char* str, STRLEN len)','name' => 'mXPUSHp'},'lex_stuff_sv' => {'text' => 'Insert characters into the lexer buffer (Llinestr>), | ||||||
194 | immediately after the current lexing point (Lbufptr>), | ||||||
195 | reallocating the buffer if necessary. This means that lexing code that | ||||||
196 | runs later will see the characters as if they had appeared in the input. | ||||||
197 | It is not recommended to do this as part of normal parsing, and most | ||||||
198 | uses of this facility run the risk of the inserted characters being | ||||||
199 | interpreted in an unintended manner. | ||||||
200 | |||||||
201 | The string to be inserted is the string value of I |
||||||
202 | are recoded for the lexer buffer, according to how the buffer is currently | ||||||
203 | being interpreted (L). If a string to be inserted is | ||||||
204 | not already a Perl scalar, the L function avoids the | ||||||
205 | need to construct a scalar. | ||||||
206 | |||||||
207 | NOTE: this function is experimental and may change or be | ||||||
208 | removed without notice. | ||||||
209 | |||||||
210 | void lex_stuff_sv(SV *sv, U32 flags)','name' => 'lex_stuff_sv'},'ibcmp_utf8' => {'text' => 'This is a synonym for (! foldEQ_utf8()) | ||||||
211 | |||||||
212 | I32 ibcmp_utf8(const char *s1, char **pe1, UV l1, | ||||||
213 | bool u1, const char *s2, char **pe2, | ||||||
214 | UV l2, bool u2)','name' => 'ibcmp_utf8'},'CvSTASH' => {'text' => 'Returns the stash of the CV. A stash is the symbol table hash, containing | ||||||
215 | the package-scoped variables in the package where the subroutine was defined. | ||||||
216 | For more information, see L |
||||||
217 | |||||||
218 | This also has a special use with XS AUTOLOAD subs. | ||||||
219 | See L |
||||||
220 | |||||||
221 | HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'gv_const_sv' => {'text' => 'If C |
||||||
222 | inlining, or C |
||||||
223 | a typeglob, then returns the value returned by the sub. Otherwise, returns | ||||||
224 | NULL. | ||||||
225 | |||||||
226 | SV* gv_const_sv(GV* gv)','name' => 'gv_const_sv'},'sv_replace' => {'text' => 'Make the first argument a copy of the second, then delete the original. | ||||||
227 | The target SV physically takes over ownership of the body of the source SV | ||||||
228 | and inherits its flags; however, the target keeps any magic it owns, | ||||||
229 | and any magic in the source is discarded. | ||||||
230 | Note that this is a rather specialist SV copying operation; most of the | ||||||
231 | time you\'ll want to use C |
||||||
232 | |||||||
233 | void sv_replace(SV *const sv, SV *const nsv)','name' => 'sv_replace'},'utf8n_to_uvchr' => {'text' => 'Returns the native character value of the first character in the string | ||||||
234 | C |
||||||
235 | which is assumed to be in UTF-8 encoding; C |
||||||
236 | length, in bytes, of that character. | ||||||
237 | |||||||
238 | C |
||||||
239 | |||||||
240 | UV utf8n_to_uvchr(const U8 *s, STRLEN curlen, | ||||||
241 | STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvchr'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C |
||||||
242 | L |
||||||
243 | module\'s C |
||||||
244 | C |
||||||
245 | |||||||
246 | XS_VERSION_BOOTCHECK;','name' => 'XS_VERSION_BOOTCHECK'},'pad_compname_type' => {'text' => 'Looks up the type of the lexical variable at position I |
||||||
247 | currently-compiling pad. If the variable is typed, the stash of the | ||||||
248 | class to which it is typed is returned. If not, C |
||||||
249 | |||||||
250 | HV * pad_compname_type(PADOFFSET po)','name' => 'pad_compname_type'},'mXPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. | ||||||
251 | Does not use C |
||||||
252 | |||||||
253 | void mXPUSHn(NV nv)','name' => 'mXPUSHn'},'SvSETMAGIC' => {'text' => 'Invokes C |
||||||
254 | argument more than once. | ||||||
255 | |||||||
256 | void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C |
||||||
257 | L |
||||||
258 | |||||||
259 | void sv_catsv_mg(SV *dsv, SV *ssv)','name' => 'sv_catsv_mg'},'call_argv' => {'text' => 'Performs a callback to the specified named and package-scoped Perl subroutine | ||||||
260 | with C |
||||||
261 | |||||||
262 | Approximate Perl equivalent: C<&{"$sub_name"}(@$argv)>. | ||||||
263 | |||||||
264 | NOTE: the perl_ form of this function is deprecated. | ||||||
265 | |||||||
266 | I32 call_argv(const char* sub_name, I32 flags, | ||||||
267 | char** argv)','name' => 'call_argv'},'save_freeop' => {'text' => '','name' => 'save_freeop'},'SvPV_nolen' => {'text' => 'Returns a pointer to the string in the SV, or a stringified form of | ||||||
268 | the SV if the SV does not contain a string. The SV may cache the | ||||||
269 | stringified form becoming C |
||||||
270 | |||||||
271 | char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'perl_clone' => {'text' => 'Create and return a new interpreter by cloning the current one. | ||||||
272 | |||||||
273 | perl_clone takes these flags as parameters: | ||||||
274 | |||||||
275 | CLONEf_COPY_STACKS - is used to, well, copy the stacks also, | ||||||
276 | without it we only clone the data and zero the stacks, | ||||||
277 | with it we copy the stacks and the new perl interpreter is | ||||||
278 | ready to run at the exact same point as the previous one. | ||||||
279 | The pseudo-fork code uses COPY_STACKS while the | ||||||
280 | threads->create doesn\'t. | ||||||
281 | |||||||
282 | CLONEf_KEEP_PTR_TABLE - | ||||||
283 | perl_clone keeps a ptr_table with the pointer of the old | ||||||
284 | variable as a key and the new variable as a value, | ||||||
285 | this allows it to check if something has been cloned and not | ||||||
286 | clone it again but rather just use the value and increase the | ||||||
287 | refcount. If KEEP_PTR_TABLE is not set then perl_clone will kill | ||||||
288 | the ptr_table using the function | ||||||
289 | C |
||||||
290 | reason to keep it around is if you want to dup some of your own | ||||||
291 | variable who are outside the graph perl scans, example of this | ||||||
292 | code is in threads.xs create. | ||||||
293 | |||||||
294 | CLONEf_CLONE_HOST - | ||||||
295 | This is a win32 thing, it is ignored on unix, it tells perls | ||||||
296 | win32host code (which is c++) to clone itself, this is needed on | ||||||
297 | win32 if you want to run two threads at the same time, | ||||||
298 | if you just want to do some stuff in a separate perl interpreter | ||||||
299 | and then throw it away and return to the original one, | ||||||
300 | you don\'t need to do anything. | ||||||
301 | |||||||
302 | PerlInterpreter* perl_clone( | ||||||
303 | PerlInterpreter *proto_perl, | ||||||
304 | UV flags | ||||||
305 | )','name' => 'perl_clone'},'save_alloc' => {'text' => '','name' => 'save_alloc'},'SvSetSV' => {'text' => 'Calls C |
||||||
306 | more than once. | ||||||
307 | |||||||
308 | void SvSetSV(SV* dsb, SV* ssv)','name' => 'SvSetSV'},'rninstr' => {'text' => '','name' => 'rninstr'},'pad_findmy_pvn' => {'text' => 'Given the name of a lexical variable, find its position in the | ||||||
309 | currently-compiling pad. | ||||||
310 | I |
||||||
311 | I |
||||||
312 | If it is not in the current pad but appears in the pad of any lexically | ||||||
313 | enclosing scope, then a pseudo-entry for it is added in the current pad. | ||||||
314 | Returns the offset in the current pad, | ||||||
315 | or C |
||||||
316 | |||||||
317 | PADOFFSET pad_findmy_pvn(const char *namepv, | ||||||
318 | STRLEN namelen, U32 flags)','name' => 'pad_findmy_pvn'},'hv_fetchs' => {'text' => 'Like C |
||||||
319 | |||||||
320 | SV** hv_fetchs(HV* tb, const char* key, I32 lval)','name' => 'hv_fetchs'},'strnNE' => {'text' => 'Test two strings to see if they are different. The C |
||||||
321 | indicates the number of bytes to compare. Returns true or false. (A | ||||||
322 | wrapper for C |
||||||
323 | |||||||
324 | bool strnNE(char* s1, char* s2, STRLEN len)','name' => 'strnNE'},'cophh_store_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of | ||||||
325 | a string/length pair. | ||||||
326 | |||||||
327 | NOTE: this function is experimental and may change or be | ||||||
328 | removed without notice. | ||||||
329 | |||||||
330 | COPHH * cophh_store_pv(const COPHH *cophh, | ||||||
331 | const char *key, U32 hash, | ||||||
332 | SV *value, U32 flags)','name' => 'cophh_store_pv'},'savepv' => {'text' => 'Perl\'s version of C |
||||||
333 | string which is a duplicate of C |
||||||
334 | determined by C |
||||||
335 | be freed with the C |
||||||
336 | |||||||
337 | char* savepv(const char* pv)','name' => 'savepv'},'save_iv' => {'text' => '','name' => 'save_iv'},'HvNAME' => {'text' => 'Returns the package name of a stash, or NULL if C |
||||||
338 | See C |
||||||
339 | |||||||
340 | char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV | ||||||
341 | of the sv is assumed to be octets in that encoding, and the sv | ||||||
342 | will be converted into Unicode (and UTF-8). | ||||||
343 | |||||||
344 | If the sv already is UTF-8 (or if it is not POK), or if the encoding | ||||||
345 | is not a reference, nothing is done to the sv. If the encoding is not | ||||||
346 | an C |
||||||
347 | (See F |
||||||
348 | |||||||
349 | The PV of the sv is returned. | ||||||
350 | |||||||
351 | char* sv_recode_to_utf8(SV* sv, SV *encoding)','name' => 'sv_recode_to_utf8'},'save_hptr' => {'text' => '','name' => 'save_hptr'},'runops_debug' => {'text' => '','name' => 'runops_debug'},'do_gvgv_dump' => {'text' => '','name' => 'do_gvgv_dump'},'PERL_SYS_INIT' => {'text' => 'Provides system-specific tune up of the C runtime environment necessary to | ||||||
352 | run Perl interpreters. This should be called only once, before creating | ||||||
353 | any Perl interpreters. | ||||||
354 | |||||||
355 | void PERL_SYS_INIT(int argc, char** argv)','name' => 'PERL_SYS_INIT'},'vstringify' => {'text' => 'In order to maintain maximum compatibility with earlier versions | ||||||
356 | of Perl, this function will return either the floating point | ||||||
357 | notation or the multiple dotted notation, depending on whether | ||||||
358 | the original version contained 1 or more dots, respectively. | ||||||
359 | |||||||
360 | The SV returned has a refcount of 1. | ||||||
361 | |||||||
362 | SV* vstringify(SV *vs)','name' => 'vstringify'},'sv_catsv_flags' => {'text' => 'Concatenates the string from SV C |
||||||
363 | SV C |
||||||
364 | bit set, will C |
||||||
365 | reading it. If the C |
||||||
366 | called on the modified SV afterward, if appropriate. C |
||||||
367 | and C |
||||||
368 | |||||||
369 | void sv_catsv_flags(SV *const dsv, SV *const ssv, | ||||||
370 | const I32 flags)','name' => 'sv_catsv_flags'},'is_uni_alpha' => {'text' => '','name' => 'is_uni_alpha'},'str_to_version' => {'text' => '','name' => 'str_to_version'},'sv_derived_from' => {'text' => 'Exactly like L, but doesn\'t take a C |
||||||
371 | |||||||
372 | bool sv_derived_from(SV* sv, const char *const name)','name' => 'sv_derived_from'},'SvIOK_on' => {'text' => 'Tells an SV that it is an integer. | ||||||
373 | |||||||
374 | 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 | ||||||
375 | \'use bytes\' aware, handles get magic, and will coerce its args to strings | ||||||
376 | if necessary. See also C |
||||||
377 | |||||||
378 | I32 sv_cmp_locale(SV *const sv1, SV *const sv2)','name' => 'sv_cmp_locale'},'sv_catpvs' => {'text' => 'Like C |
||||||
379 | |||||||
380 | void sv_catpvs(SV* sv, const char* s)','name' => 'sv_catpvs'},'set_numeric_standard' => {'text' => '','name' => 'set_numeric_standard'},'dSP' => {'text' => 'Declares a local copy of perl\'s stack pointer for the XSUB, available via | ||||||
381 | the C |
||||||
382 | |||||||
383 | dSP;','name' => 'dSP'},'Nullsv' => {'text' => 'Null SV pointer. (No longer available when C |
||||||
384 | case-insensitively; false otherwise. Uppercase and lowercase ASCII range bytes | ||||||
385 | match themselves and their opposite case counterparts. Non-cased and non-ASCII | ||||||
386 | range bytes match only themselves. | ||||||
387 | |||||||
388 | I32 foldEQ(const char* a, const char* b, I32 len)','name' => 'foldEQ'},'PerlIO_get_base' => {'text' => '','name' => 'PerlIO_get_base'},'SvPVX' => {'text' => 'Returns a pointer to the physical string in the SV. The SV must contain a | ||||||
389 | string. | ||||||
390 | |||||||
391 | This is also used to store the name of an autoloaded subroutine in an XS | ||||||
392 | AUTOLOAD routine. See L |
||||||
393 | |||||||
394 | char* SvPVX(SV* sv)','name' => 'SvPVX'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles | ||||||
395 | \'set\' magic. Uses C |
||||||
396 | declare it. Do not call multiple C |
||||||
397 | from XSUB\'s - see C |
||||||
398 | |||||||
399 | void XPUSHi(IV iv)','name' => 'XPUSHi'},'is_utf8_perl_word' => {'text' => '','name' => 'is_utf8_perl_word'},'debop' => {'text' => '','name' => 'debop'},'ref' => {'text' => '','name' => 'ref'},'is_uni_print_lc' => {'text' => '','name' => 'is_uni_print_lc'},'sv_does_sv' => {'text' => 'Returns a boolean indicating whether the SV performs a specific, named role. | ||||||
400 | The SV can be a Perl object or the name of a Perl class. | ||||||
401 | |||||||
402 | bool sv_does_sv(SV* sv, SV* namesv, U32 flags)','name' => 'sv_does_sv'},'SvOOK_offset' => {'text' => 'Reads into I |
||||||
403 | allocated buffer, which will be non-zero if C |
||||||
404 | efficiently remove characters from start of the buffer. Implemented as a | ||||||
405 | macro, which takes the address of I |
||||||
406 | Evaluates I |
||||||
407 | |||||||
408 | void SvOOK_offset(NN SV*sv, STRLEN len)','name' => 'SvOOK_offset'},'save_list' => {'text' => '','name' => 'save_list'},'is_uni_idfirst_lc' => {'text' => '','name' => 'is_uni_idfirst_lc'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted if tainting is enabled. | ||||||
409 | |||||||
410 | void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'newGIVENOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C |
||||||
411 | I |
||||||
412 | variable, and I |
||||||
413 | are consumed by this function and become part of the constructed op tree. | ||||||
414 | I |
||||||
415 | be affected. | ||||||
416 | |||||||
417 | OP * newGIVENOP(OP *cond, OP *block, | ||||||
418 | PADOFFSET defsv_off)','name' => 'newGIVENOP'},'sv_nolocking' => {'text' => 'Dummy routine which "locks" an SV when there is no locking module present. | ||||||
419 | Exists to avoid test for a NULL function pointer and because it could | ||||||
420 | potentially warn under some level of strict-ness. | ||||||
421 | |||||||
422 | "Superseded" by sv_nosharing(). | ||||||
423 | |||||||
424 | void sv_nolocking(SV *sv)','name' => 'sv_nolocking'},'parse_listexpr' => {'text' => 'Parse a Perl list expression. This may contain operators of precedence | ||||||
425 | down to the comma operator. The expression must be followed (and thus | ||||||
426 | terminated) either by a low-precedence logic operator such as C |
||||||
427 | something that would normally terminate an expression such as semicolon. | ||||||
428 | If I |
||||||
429 | otherwise it is mandatory. It is up to the caller to ensure that the | ||||||
430 | dynamic parser state (L et al) is correctly set to reflect | ||||||
431 | the source of the code to be parsed and the lexical context for the | ||||||
432 | expression. | ||||||
433 | |||||||
434 | The op tree representing the expression is returned. If an optional | ||||||
435 | expression is absent, a null pointer is returned, otherwise the pointer | ||||||
436 | will be non-null. | ||||||
437 | |||||||
438 | If an error occurs in parsing or compilation, in most cases a valid op | ||||||
439 | tree is returned anyway. The error is reflected in the parser state, | ||||||
440 | normally resulting in a single exception at the top level of parsing | ||||||
441 | which covers all the compilation errors that occurred. Some compilation | ||||||
442 | errors, however, will throw an exception immediately. | ||||||
443 | |||||||
444 | NOTE: this function is experimental and may change or be | ||||||
445 | removed without notice. | ||||||
446 | |||||||
447 | OP * parse_listexpr(U32 flags)','name' => 'parse_listexpr'},'ibcmp' => {'text' => 'This is a synonym for (! foldEQ()) | ||||||
448 | |||||||
449 | I32 ibcmp(const char* a, const char* b, I32 len)','name' => 'ibcmp'},'isWORDCHAR' => {'text' => 'Returns a boolean indicating whether the specified character is a | ||||||
450 | character that is any of: alphabetic, numeric, or an underscore. This is the | ||||||
451 | same as what C<\\w> matches in a regular expression. | ||||||
452 | C |
||||||
453 | does not have the standard C language meaning of alphanumeric, since it matches | ||||||
454 | an underscore and the standard meaning does not. | ||||||
455 | See the L |
||||||
456 | C |
||||||
457 | |||||||
458 | bool isWORDCHAR(char ch)','name' => 'isWORDCHAR'},'Slab_Alloc' => {'text' => '','name' => 'Slab_Alloc'},'strLT' => {'text' => 'Test two strings to see if the first, C |
||||||
459 | C |
||||||
460 | |||||||
461 | bool strLT(char* s1, char* s2)','name' => 'strLT'},'save_pushptr' => {'text' => '','name' => 'save_pushptr'},'save_clearsv' => {'text' => '','name' => 'save_clearsv'},'Slab_Free' => {'text' => '','name' => 'Slab_Free'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the | ||||||
462 | array. Returns C<&PL_sv_undef> if the | ||||||
463 | array is empty. | ||||||
464 | |||||||
465 | Perl equivalent: C |
||||||
466 | |||||||
467 | SV* av_shift(AV *av)','name' => 'av_shift'},'sv_setpvf_nocontext' => {'text' => '','name' => 'sv_setpvf_nocontext'},'HvENAMEUTF8' => {'text' => 'Returns true if the effective name is in UTF8 encoding. | ||||||
468 | |||||||
469 | unsigned char HvENAMEUTF8(HV *stash)','name' => 'HvENAMEUTF8'},'sv_nounlocking' => {'text' => 'Dummy routine which "unlocks" an SV when there is no locking module present. | ||||||
470 | Exists to avoid test for a NULL function pointer and because it could | ||||||
471 | potentially warn under some level of strict-ness. | ||||||
472 | |||||||
473 | "Superseded" by sv_nosharing(). | ||||||
474 | |||||||
475 | void sv_nounlocking(SV *sv)','name' => 'sv_nounlocking'},'perl_clone_using' => {'text' => '','name' => 'perl_clone_using'},'PerlIO_context_layers' => {'text' => '','name' => 'PerlIO_context_layers'},'lex_unstuff' => {'text' => 'Discards text about to be lexed, from Lbufptr> up to | ||||||
476 | I |
||||||
477 | This hides the discarded text from any lexing code that runs later, | ||||||
478 | as if the text had never appeared. | ||||||
479 | |||||||
480 | This is not the normal way to consume lexed text. For that, use | ||||||
481 | L. | ||||||
482 | |||||||
483 | NOTE: this function is experimental and may change or be | ||||||
484 | removed without notice. | ||||||
485 | |||||||
486 | void lex_unstuff(char *ptr)','name' => 'lex_unstuff'},'newSVpvf_nocontext' => {'text' => '','name' => 'newSVpvf_nocontext'},'SvUV_set' => {'text' => 'Set the value of the UV pointer in sv to val. See C |
||||||
487 | |||||||
488 | void SvUV_set(SV* sv, UV val)','name' => 'SvUV_set'},'rvpv_dup' => {'text' => '','name' => 'rvpv_dup'},'filter_read' => {'text' => '','name' => 'filter_read'},'ckwarn' => {'text' => '','name' => 'ckwarn'},'warner' => {'text' => '','name' => 'warner'},'savesharedsvpv' => {'text' => 'A version of C |
||||||
489 | memory which is shared between threads. | ||||||
490 | |||||||
491 | char* savesharedsvpv(SV *sv)','name' => 'savesharedsvpv'},'CopyD' => {'text' => 'Like C |
||||||
492 | optimise. | ||||||
493 | |||||||
494 | void * CopyD(void* src, void* dest, int nitems, type)','name' => 'CopyD'},'sv_setiv_mg' => {'text' => 'Like C |
||||||
495 | |||||||
496 | void sv_setiv_mg(SV *const sv, const IV i)','name' => 'sv_setiv_mg'},'sv_does_pvn' => {'text' => 'Like L, but takes a string/length pair instead of an SV. | ||||||
497 | |||||||
498 | bool sv_does_pvn(SV* sv, const char *const name, | ||||||
499 | const STRLEN len, U32 flags)','name' => 'sv_does_pvn'},'newFOROP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C |
||||||
500 | loop (iteration through a list of values). This is a heavyweight loop, | ||||||
501 | with structure that allows exiting the loop by C |
||||||
502 | |||||||
503 | I |
||||||
504 | item in turn; if null, it defaults to C<$_> (either lexical or global). | ||||||
505 | I |
||||||
506 | the main body of the loop, and I |
||||||
507 | block that operates as a second half of the body. All of these optree | ||||||
508 | inputs are consumed by this function and become part of the constructed | ||||||
509 | op tree. | ||||||
510 | |||||||
511 | I |
||||||
512 | op and, shifted up eight bits, the eight bits of C |
||||||
513 | the C |
||||||
514 | automatically. | ||||||
515 | |||||||
516 | OP * newFOROP(I32 flags, OP *sv, OP *expr, OP *block, | ||||||
517 | OP *cont)','name' => 'newFOROP'},'HvENAME' => {'text' => 'Returns the effective name of a stash, or NULL if there is none. The | ||||||
518 | effective name represents a location in the symbol table where this stash | ||||||
519 | resides. It is updated automatically when packages are aliased or deleted. | ||||||
520 | A stash that is no longer in the symbol table has no effective name. This | ||||||
521 | name is preferable to C |
||||||
522 | caches. | ||||||
523 | |||||||
524 | char* HvENAME(HV* stash)','name' => 'HvENAME'},'save_generic_svref' => {'text' => '','name' => 'save_generic_svref'},'savesharedpvn' => {'text' => 'A version of C |
||||||
525 | which is shared between threads. (With the specific difference that a NULL | ||||||
526 | pointer is not acceptable) | ||||||
527 | |||||||
528 | char* savesharedpvn(const char *const pv, | ||||||
529 | const STRLEN len)','name' => 'savesharedpvn'},'utf8_to_uvchr_buf' => {'text' => 'Returns the native code point of the first character in the string C |
||||||
530 | is assumed to be in UTF-8 encoding; C |
||||||
531 | C<*retlen> will be set to the length, in bytes, of that character. | ||||||
532 | |||||||
533 | If C |
||||||
534 | enabled, zero is returned and C<*retlen> is set (if C |
||||||
535 | NULL) to -1. If those warnings are off, the computed value if well-defined (or | ||||||
536 | the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen> | ||||||
537 | is set (if C |
||||||
538 | next possible position in C |
||||||
539 | See L for details on when the REPLACEMENT CHARACTER is returned. | ||||||
540 | |||||||
541 | UV utf8_to_uvchr_buf(const U8 *s, const U8 *send, | ||||||
542 | STRLEN *retlen)','name' => 'utf8_to_uvchr_buf'},'SvCUR_set' => {'text' => 'Set the current length of the string which is in the SV. See C |
||||||
543 | and C |
||||||
544 | |||||||
545 | void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'_is_utf8_quotemeta' => {'text' => '','name' => '_is_utf8_quotemeta'},'sv_2pv' => {'text' => '','name' => 'sv_2pv'},'SvNOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a double. | ||||||
546 | |||||||
547 | U32 SvNOK(SV* sv)','name' => 'SvNOK'},'mPUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. | ||||||
548 | Does not use C |
||||||
549 | |||||||
550 | void mPUSHn(NV nv)','name' => 'mPUSHn'},'is_uni_digit_lc' => {'text' => '','name' => 'is_uni_digit_lc'},'pad_setsv' => {'text' => 'Set the value at offset I |
||||||
551 | Use the macro PAD_SETSV() rather than calling this function directly. | ||||||
552 | |||||||
553 | void pad_setsv(PADOFFSET po, SV *sv)','name' => 'pad_setsv'},'sv_reset' => {'text' => 'Underlying implementation for the C |
||||||
554 | Note that the perl-level function is vaguely deprecated. | ||||||
555 | |||||||
556 | void sv_reset(const char* s, HV *const stash)','name' => 'sv_reset'},'cophh_delete_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of | ||||||
557 | a string/length pair. | ||||||
558 | |||||||
559 | NOTE: this function is experimental and may change or be | ||||||
560 | removed without notice. | ||||||
561 | |||||||
562 | COPHH * cophh_delete_pv(const COPHH *cophh, | ||||||
563 | const char *key, U32 hash, | ||||||
564 | U32 flags)','name' => 'cophh_delete_pv'},'sv_2pv_flags' => {'text' => 'Returns a pointer to the string value of an SV, and sets *lp to its length. | ||||||
565 | If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a | ||||||
566 | string if necessary. Normally invoked via the C |
||||||
567 | C |
||||||
568 | |||||||
569 | char* sv_2pv_flags(SV *const sv, STRLEN *const lp, | ||||||
570 | const I32 flags)','name' => 'sv_2pv_flags'},'push_scope' => {'text' => '','name' => 'push_scope'},'SvNVx' => {'text' => 'Coerces the given SV to a double and returns it. | ||||||
571 | Guarantees to evaluate C |
||||||
572 | this if C |
||||||
573 | otherwise use the more efficient C |
||||||
574 | |||||||
575 | NV SvNVx(SV* sv)','name' => 'SvNVx'},'setdefout' => {'text' => 'Sets PL_defoutgv, the default file handle for output, to the passed in | ||||||
576 | typeglob. As PL_defoutgv "owns" a reference on its typeglob, the reference | ||||||
577 | count of the passed in typeglob is increased by one, and the reference count | ||||||
578 | of the typeglob that PL_defoutgv points to is decreased by one. | ||||||
579 | |||||||
580 | void setdefout(GV* gv)','name' => 'setdefout'},'form_nocontext' => {'text' => '','name' => 'form_nocontext'},'hv_store' => {'text' => 'Stores an SV in a hash. The hash key is specified as C |
||||||
581 | absolute value of C |
||||||
582 | negative the key is assumed to be in UTF-8-encoded Unicode. The | ||||||
583 | C |
||||||
584 | Perl will compute it. | ||||||
585 | |||||||
586 | The return value will be | ||||||
587 | NULL if the operation failed or if the value did not need to be actually | ||||||
588 | stored within the hash (as in the case of tied hashes). Otherwise it can | ||||||
589 | be dereferenced to get the original C |
||||||
590 | responsible for suitably incrementing the reference count of C |
||||||
591 | the call, and decrementing it if the function returned NULL. Effectively | ||||||
592 | a successful hv_store takes ownership of one reference to C |
||||||
593 | usually what you want; a newly created SV has a reference count of one, so | ||||||
594 | if all your code does is create SVs then store them in a hash, hv_store | ||||||
595 | will own the only reference to the new SV, and your code doesn\'t need to do | ||||||
596 | anything further to tidy up. hv_store is not implemented as a call to | ||||||
597 | hv_store_ent, and does not create a temporary SV for the key, so if your | ||||||
598 | key data is not already in SV form then use hv_store in preference to | ||||||
599 | hv_store_ent. | ||||||
600 | |||||||
601 | See L |
||||||
602 | information on how to use this function on tied hashes. | ||||||
603 | |||||||
604 | SV** hv_store(HV *hv, const char *key, I32 klen, | ||||||
605 | SV *val, U32 hash)','name' => 'hv_store'},'sys_intern_dup' => {'text' => '','name' => 'sys_intern_dup'},'do_binmode' => {'text' => '','name' => 'do_binmode'},'get_op_names' => {'text' => '','name' => 'get_op_names'},'cop_hints_fetch_sv' => {'text' => 'Like L, but takes a Perl scalar instead of a | ||||||
606 | string/length pair. | ||||||
607 | |||||||
608 | SV * cop_hints_fetch_sv(const COP *cop, SV *key, | ||||||
609 | U32 hash, U32 flags)','name' => 'cop_hints_fetch_sv'},'ck_entersub_args_proto_or_list' => {'text' => 'Performs the fixup of the arguments part of an C |
||||||
610 | based on a subroutine prototype or using default list-context processing. | ||||||
611 | This is the standard treatment used on a subroutine call, not marked | ||||||
612 | with C<&>, where the callee can be identified at compile time. | ||||||
613 | |||||||
614 | I |
||||||
615 | or indicates that there is no prototype. It may be a normal scalar, | ||||||
616 | in which case if it is defined then the string value will be used | ||||||
617 | as a prototype, and if it is undefined then there is no prototype. | ||||||
618 | Alternatively, for convenience, it may be a subroutine object (a C |
||||||
619 | that has been cast to C |
||||||
620 | has one. The prototype (or lack thereof) supplied, in whichever form, | ||||||
621 | does not need to match the actual callee referenced by the op tree. | ||||||
622 | |||||||
623 | If the argument ops disagree with the prototype, for example by having | ||||||
624 | an unacceptable number of arguments, a valid op tree is returned anyway. | ||||||
625 | The error is reflected in the parser state, normally resulting in a single | ||||||
626 | exception at the top level of parsing which covers all the compilation | ||||||
627 | errors that occurred. In the error message, the callee is referred to | ||||||
628 | by the name defined by the I |
||||||
629 | |||||||
630 | OP * ck_entersub_args_proto_or_list(OP *entersubop, | ||||||
631 | GV *namegv, | ||||||
632 | SV *protosv)','name' => 'ck_entersub_args_proto_or_list'},'op_null' => {'text' => '','name' => 'op_null'},'hv_fetch_ent' => {'text' => 'Returns the hash entry which corresponds to the specified key in the hash. | ||||||
633 | C |
||||||
634 | if you want the function to compute it. IF C |
||||||
635 | will be part of a store. Make sure the return value is non-null before | ||||||
636 | accessing it. The return value when C |
||||||
637 | static location, so be sure to make a copy of the structure if you need to | ||||||
638 | store it somewhere. | ||||||
639 | |||||||
640 | See L |
||||||
641 | information on how to use this function on tied hashes. | ||||||
642 | |||||||
643 | HE* hv_fetch_ent(HV *hv, SV *keysv, I32 lval, | ||||||
644 | U32 hash)','name' => 'hv_fetch_ent'},'gv_fetchpvn_flags' => {'text' => '','name' => 'gv_fetchpvn_flags'},'ENTER' => {'text' => 'Opening bracket on a callback. See C |
||||||
645 | |||||||
646 | ENTER;','name' => 'ENTER'},'PL_sv_no' => {'text' => 'This is the C |
||||||
647 | C<&PL_sv_no>. | ||||||
648 | |||||||
649 | SV PL_sv_no','name' => 'PL_sv_no'},'Newx' => {'text' => 'The XSUB-writer\'s interface to the C C |
||||||
650 | |||||||
651 | In 5.9.3, Newx() and friends replace the older New() API, and drops | ||||||
652 | the first parameter, I |
||||||
653 | themselves. This aid has been superseded by a new build option, | ||||||
654 | PERL_MEM_LOG (see L |
||||||
655 | there for use in XS modules supporting older perls. | ||||||
656 | |||||||
657 | void Newx(void* ptr, int nitems, type)','name' => 'Newx'},'newFORM' => {'text' => '','name' => 'newFORM'},'PUSHs' => {'text' => 'Push an SV onto the stack. The stack must have room for this element. | ||||||
658 | Does not handle \'set\' magic. Does not use C |
||||||
659 | C |
||||||
660 | |||||||
661 | void PUSHs(SV* sv)','name' => 'PUSHs'},'to_uni_upper_lc' => {'text' => '','name' => 'to_uni_upper_lc'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary. | ||||||
662 | Does not handle \'set\' magic. See also C |
||||||
663 | |||||||
664 | void sv_setuv(SV *const sv, const UV num)','name' => 'sv_setuv'},'SvUPGRADE' => {'text' => 'Used to upgrade an SV to a more complex form. Uses C |
||||||
665 | perform the upgrade if necessary. See C |
||||||
666 | |||||||
667 | void SvUPGRADE(SV* sv, svtype type)','name' => 'SvUPGRADE'},'cv_clone' => {'text' => 'Clone a CV, making a lexical closure. I |
||||||
668 | of the function: its code, pad structure, and other attributes. | ||||||
669 | The prototype is combined with a capture of outer lexicals to which the | ||||||
670 | code refers, which are taken from the currently-executing instance of | ||||||
671 | the immediately surrounding code. | ||||||
672 | |||||||
673 | CV * cv_clone(CV *proto)','name' => 'cv_clone'},'is_uni_upper_lc' => {'text' => '','name' => 'is_uni_upper_lc'},'do_aspawn' => {'text' => '','name' => 'do_aspawn'},'sv_pvn' => {'text' => 'A private implementation of the C |
||||||
674 | cope with complex macro expressions. Always use the macro instead. | ||||||
675 | |||||||
676 | char* sv_pvn(SV *sv, STRLEN *lp)','name' => 'sv_pvn'},'do_openn' => {'text' => '','name' => 'do_openn'},'wrap_op_checker' => {'text' => 'Puts a C function into the chain of check functions for a specified op | ||||||
677 | type. This is the preferred way to manipulate the L array. | ||||||
678 | I |
||||||
679 | is a pointer to the C function that is to be added to that opcode\'s | ||||||
680 | check chain, and I |
||||||
681 | pointer to the next function in the chain will be stored. The value of | ||||||
682 | I |
||||||
683 | previously stored there is written to I<*old_checker_p>. | ||||||
684 | |||||||
685 | L is global to an entire process, and a module wishing to | ||||||
686 | hook op checking may find itself invoked more than once per process, | ||||||
687 | typically in different threads. To handle that situation, this function | ||||||
688 | is idempotent. The location I<*old_checker_p> must initially (once | ||||||
689 | per process) contain a null pointer. A C variable of static duration | ||||||
690 | (declared at file scope, typically also marked C |
||||||
691 | it internal linkage) will be implicitly initialised appropriately, | ||||||
692 | if it does not have an explicit initialiser. This function will only | ||||||
693 | actually modify the check chain if it finds I<*old_checker_p> to be null. | ||||||
694 | This function is also thread safe on the small scale. It uses appropriate | ||||||
695 | locking to avoid race conditions in accessing L. | ||||||
696 | |||||||
697 | When this function is called, the function referenced by I |
||||||
698 | must be ready to be called, except for I<*old_checker_p> being unfilled. | ||||||
699 | In a threading situation, I |
||||||
700 | even before this function has returned. I<*old_checker_p> will always | ||||||
701 | be appropriately set before I |
||||||
702 | decides not to do anything special with an op that it is given (which | ||||||
703 | is the usual case for most uses of op check hooking), it must chain the | ||||||
704 | check function referenced by I<*old_checker_p>. | ||||||
705 | |||||||
706 | If you want to influence compilation of calls to a specific subroutine, | ||||||
707 | then use L rather than hooking checking of all | ||||||
708 | C |
||||||
709 | |||||||
710 | void wrap_op_checker(Optype opcode, | ||||||
711 | Perl_check_t new_checker, | ||||||
712 | Perl_check_t *old_checker_p)','name' => 'wrap_op_checker'},'mro_get_from_name' => {'text' => '','name' => 'mro_get_from_name'},'sv_setref_iv' => {'text' => 'Copies an integer into a new SV, optionally blessing the SV. The C |
||||||
713 | argument will be upgraded to an RV. That RV will be modified to point to | ||||||
714 | the new SV. The C |
||||||
715 | blessing. Set C |
||||||
716 | will have a reference count of 1, and the RV will be returned. | ||||||
717 | |||||||
718 | SV* sv_setref_iv(SV *const rv, | ||||||
719 | const char *const classname, | ||||||
720 | const IV iv)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => 'Efficient removal of characters from the beginning of the string buffer. | ||||||
721 | SvPOK(sv) must be true and the C |
||||||
722 | the string buffer. The C |
||||||
723 | string. Uses the "OOK hack". | ||||||
724 | |||||||
725 | Beware: after this function returns, C |
||||||
726 | refer to the same chunk of data. | ||||||
727 | |||||||
728 | The unfortunate similarity of this function\'s name to that of Perl\'s C |
||||||
729 | operator is strictly coincidental. This function works from the left; | ||||||
730 | C |
||||||
731 | |||||||
732 | void sv_chop(SV *const sv, const char *const ptr)','name' => 'sv_chop'},'sv_backoff' => {'text' => 'Remove any string offset. You should normally use the C |
||||||
733 | wrapper instead. | ||||||
734 | |||||||
735 | int sv_backoff(SV *const sv)','name' => 'sv_backoff'},'reentrant_retry' => {'text' => '','name' => 'reentrant_retry'},'XPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. | ||||||
736 | Handles \'set\' magic. Uses C |
||||||
737 | called to declare it. Do not call multiple C |
||||||
738 | return lists from XSUB\'s - see C |
||||||
739 | C |
||||||
740 | |||||||
741 | void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_pvn_nomg' => {'text' => '','name' => 'sv_pvn_nomg'},'is_uni_space_lc' => {'text' => '','name' => 'is_uni_space_lc'},'stack_grow' => {'text' => '','name' => 'stack_grow'},'dump_mstats' => {'text' => '','name' => 'dump_mstats'},'newLOOPEX' => {'text' => 'Constructs, checks, and returns a loop-exiting op (such as C |
||||||
742 | or C |
||||||
743 | determining the target of the op; it is consumed by this function and | ||||||
744 | become part of the constructed op tree. | ||||||
745 | |||||||
746 | OP * newLOOPEX(I32 type, OP *label)','name' => 'newLOOPEX'},'save_shared_pvref' => {'text' => '','name' => 'save_shared_pvref'},'PL_na' => {'text' => 'A convenience variable which is typically used with C |
||||||
747 | doesn\'t care about the length of the string. It is usually more efficient | ||||||
748 | to either declare a local variable and use that instead or to use the | ||||||
749 | C |
||||||
750 | |||||||
751 | STRLEN PL_na','name' => 'PL_na'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the | ||||||
752 | SV is set to 1. | ||||||
753 | |||||||
754 | SV* newSViv(const IV i)','name' => 'newSViv'},'gv_name_set' => {'text' => '','name' => 'gv_name_set'},'sv_untaint' => {'text' => 'Untaint an SV. Use C |
||||||
755 | |||||||
756 | void sv_untaint(SV *const sv)','name' => 'sv_untaint'},'Newxz' => {'text' => 'The XSUB-writer\'s interface to the C C |
||||||
757 | memory is zeroed with C |
||||||
758 | |||||||
759 | void Newxz(void* ptr, int nitems, type)','name' => 'Newxz'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See C |
||||||
760 | brace, a sequence of statements, and a closing brace. The block | ||||||
761 | constitutes a lexical scope, so C |
||||||
762 | effects can be contained within it. It is up to the caller to ensure | ||||||
763 | that the dynamic parser state (L et al) is correctly set to | ||||||
764 | reflect the source of the code to be parsed and the lexical context for | ||||||
765 | the statement. | ||||||
766 | |||||||
767 | The op tree representing the code block is returned. This is always a | ||||||
768 | real op, never a null pointer. It will normally be a C |
||||||
769 | including C |
||||||
770 | of runtime scope are included by virtue of it being a block. | ||||||
771 | |||||||
772 | If an error occurs in parsing or compilation, in most cases a valid op | ||||||
773 | tree (most likely null) is returned anyway. The error is reflected in | ||||||
774 | the parser state, normally resulting in a single exception at the top | ||||||
775 | level of parsing which covers all the compilation errors that occurred. | ||||||
776 | Some compilation errors, however, will throw an exception immediately. | ||||||
777 | |||||||
778 | The I |
||||||
779 | be zero. | ||||||
780 | |||||||
781 | NOTE: this function is experimental and may change or be | ||||||
782 | removed without notice. | ||||||
783 | |||||||
784 | OP * parse_block(U32 flags)','name' => 'parse_block'},'SvRX' => {'text' => 'Convenience macro to get the REGEXP from a SV. This is approximately | ||||||
785 | equivalent to the following snippet: | ||||||
786 | |||||||
787 | if (SvMAGICAL(sv)) | ||||||
788 | mg_get(sv); | ||||||
789 | if (SvROK(sv)) | ||||||
790 | sv = MUTABLE_SV(SvRV(sv)); | ||||||
791 | if (SvTYPE(sv) == SVt_REGEXP) | ||||||
792 | return (REGEXP*) sv; | ||||||
793 | |||||||
794 | NULL will be returned if a REGEXP* is not found. | ||||||
795 | |||||||
796 | REGEXP * SvRX(SV *sv)','name' => 'SvRX'},'newASSIGNOP' => {'text' => 'Constructs, checks, and returns an assignment op. I |
||||||
797 | supply the parameters of the assignment; they are consumed by this | ||||||
798 | function and become part of the constructed op tree. | ||||||
799 | |||||||
800 | If I |
||||||
801 | a suitable conditional optree is constructed. If I |
||||||
802 | of a binary operator, such as C |
||||||
803 | performs the binary operation and assigns the result to the left argument. | ||||||
804 | Either way, if I |
||||||
805 | |||||||
806 | If I |
||||||
807 | constructed. Which type of assignment it is is automatically determined. | ||||||
808 | I |
||||||
809 | will be set automatically, and, shifted up eight bits, the eight bits | ||||||
810 | of C |
||||||
811 | set as required. | ||||||
812 | |||||||
813 | OP * newASSIGNOP(I32 flags, OP *left, I32 optype, | ||||||
814 | OP *right)','name' => 'newASSIGNOP'},'SvSetMagicSV_nosteal' => {'text' => 'Like C |
||||||
815 | |||||||
816 | void SvSetMagicSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetMagicSV_nosteal'},'hv_undef' => {'text' => 'Undefines the hash. The XS equivalent of C |
||||||
817 | |||||||
818 | As well as freeing all the elements of the hash (like hv_clear()), this | ||||||
819 | also frees any auxiliary data and storage associated with the hash. | ||||||
820 | |||||||
821 | If any destructors are triggered as a result, the hv itself may | ||||||
822 | be freed. | ||||||
823 | |||||||
824 | See also L. | ||||||
825 | |||||||
826 | void hv_undef(HV *hv)','name' => 'hv_undef'},'clone_params_del' => {'text' => '','name' => 'clone_params_del'},'sv_isobject' => {'text' => 'Returns a boolean indicating whether the SV is an RV pointing to a blessed | ||||||
827 | object. If the SV is not an RV, or if the object is not blessed, then this | ||||||
828 | will return false. | ||||||
829 | |||||||
830 | int sv_isobject(SV* sv)','name' => 'sv_isobject'},'cop_hints_fetch_pvn' => {'text' => 'Look up the hint entry in the cop I |
||||||
831 | I |
||||||
832 | the key octets are interpreted as UTF-8, otherwise they are interpreted | ||||||
833 | as Latin-1. I |
||||||
834 | it has not been precomputed. Returns a mortal scalar copy of the value | ||||||
835 | associated with the key, or C<&PL_sv_placeholder> if there is no value | ||||||
836 | associated with the key. | ||||||
837 | |||||||
838 | SV * cop_hints_fetch_pvn(const COP *cop, | ||||||
839 | const char *keypv, | ||||||
840 | STRLEN keylen, U32 hash, | ||||||
841 | U32 flags)','name' => 'cop_hints_fetch_pvn'},'gv_efullname4' => {'text' => '','name' => 'gv_efullname4'},'SvIV' => {'text' => 'Coerces the given SV to an integer and returns it. See C |
||||||
842 | version which guarantees to evaluate sv only once. | ||||||
843 | |||||||
844 | IV SvIV(SV* sv)','name' => 'SvIV'},'isASCII' => {'text' => 'Returns a boolean indicating whether the specified character is one of the 128 | ||||||
845 | characters in the ASCII character set. On non-ASCII platforms, it is if this | ||||||
846 | character corresponds to an ASCII character. Variants C |
||||||
847 | C |
||||||
848 | |||||||
849 | bool isASCII(char ch)','name' => 'isASCII'},'PerlIO_eof' => {'text' => '','name' => 'PerlIO_eof'},'cop_hints_2hv' => {'text' => 'Generates and returns a standard Perl hash representing the full set of | ||||||
850 | hint entries in the cop I |
||||||
851 | be zero. | ||||||
852 | |||||||
853 | HV * cop_hints_2hv(const COP *cop, U32 flags)','name' => 'cop_hints_2hv'},'sv_collxfrm_flags' => {'text' => 'Add Collate Transform magic to an SV if it doesn\'t already have it. If the | ||||||
854 | flags contain SV_GMAGIC, it handles get-magic. | ||||||
855 | |||||||
856 | Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the | ||||||
857 | scalar data of the variable, but transformed to such a format that a normal | ||||||
858 | memory comparison can be used to compare the data according to the locale | ||||||
859 | settings. | ||||||
860 | |||||||
861 | char* sv_collxfrm_flags(SV *const sv, | ||||||
862 | STRLEN *const nxp, | ||||||
863 | I32 const flags)','name' => 'sv_collxfrm_flags'},'sv_setref_uv' => {'text' => 'Copies an unsigned integer into a new SV, optionally blessing the SV. The C |
||||||
864 | argument will be upgraded to an RV. That RV will be modified to point to | ||||||
865 | the new SV. The C |
||||||
866 | blessing. Set C |
||||||
867 | will have a reference count of 1, and the RV will be returned. | ||||||
868 | |||||||
869 | SV* sv_setref_uv(SV *const rv, | ||||||
870 | const char *const classname, | ||||||
871 | const UV uv)','name' => 'sv_setref_uv'},'get_ppaddr' => {'text' => '','name' => 'get_ppaddr'},'ck_entersub_args_proto' => {'text' => 'Performs the fixup of the arguments part of an C |
||||||
872 | based on a subroutine prototype. This makes various modifications to | ||||||
873 | the argument ops, from applying context up to inserting C |
||||||
874 | and checking the number and syntactic types of arguments, as directed by | ||||||
875 | the prototype. This is the standard treatment used on a subroutine call, | ||||||
876 | not marked with C<&>, where the callee can be identified at compile time | ||||||
877 | and has a prototype. | ||||||
878 | |||||||
879 | I |
||||||
880 | It may be a normal defined scalar, of which the string value will be used. | ||||||
881 | Alternatively, for convenience, it may be a subroutine object (a C |
||||||
882 | that has been cast to C |
||||||
883 | supplied, in whichever form, does not need to match the actual callee | ||||||
884 | referenced by the op tree. | ||||||
885 | |||||||
886 | If the argument ops disagree with the prototype, for example by having | ||||||
887 | an unacceptable number of arguments, a valid op tree is returned anyway. | ||||||
888 | The error is reflected in the parser state, normally resulting in a single | ||||||
889 | exception at the top level of parsing which covers all the compilation | ||||||
890 | errors that occurred. In the error message, the callee is referred to | ||||||
891 | by the name defined by the I |
||||||
892 | |||||||
893 | OP * ck_entersub_args_proto(OP *entersubop, | ||||||
894 | GV *namegv, SV *protosv)','name' => 'ck_entersub_args_proto'},'getcwd_sv' => {'text' => 'Fill the sv with current working directory | ||||||
895 | |||||||
896 | int getcwd_sv(SV* sv)','name' => 'getcwd_sv'},'newSVpvs_share' => {'text' => 'Like C |
||||||
897 | pair and omits the hash parameter. | ||||||
898 | |||||||
899 | SV* newSVpvs_share(const char* s)','name' => 'newSVpvs_share'},'newSVpv' => {'text' => 'Creates a new SV and copies a string into it. The reference count for the | ||||||
900 | SV is set to 1. If C |
||||||
901 | strlen(). For efficiency, consider using C |
||||||
902 | |||||||
903 | SV* newSVpv(const char *const s, const STRLEN len)','name' => 'newSVpv'},'sv_2pvbyte' => {'text' => 'Return a pointer to the byte-encoded representation of the SV, and set *lp | ||||||
904 | to its length. May cause the SV to be downgraded from UTF-8 as a | ||||||
905 | side-effect. | ||||||
906 | |||||||
907 | Usually accessed via the C |
||||||
908 | |||||||
909 | char* sv_2pvbyte(SV *sv, STRLEN *const lp)','name' => 'sv_2pvbyte'},'fbm_instr' => {'text' => 'Returns the location of the SV in the string delimited by C |
||||||
910 | C |
||||||
911 | does not have to be fbm_compiled, but the search will not be as fast | ||||||
912 | then. | ||||||
913 | |||||||
914 | char* fbm_instr(unsigned char* big, | ||||||
915 | unsigned char* bigend, SV* littlestr, | ||||||
916 | U32 flags)','name' => 'fbm_instr'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles | ||||||
917 | \'set\' magic. Uses C |
||||||
918 | declare it. Do not call multiple C |
||||||
919 | from XSUB\'s - see C |
||||||
920 | |||||||
921 | void XPUSHn(NV nv)','name' => 'XPUSHn'},'PL_opfreehook' => {'text' => 'When non-C |
||||||
922 | This allows extensions to free any extra attribute they have locally attached to an OP. | ||||||
923 | It is also assured to first fire for the parent OP and then for its kids. | ||||||
924 | |||||||
925 | When you replace this variable, it is considered a good practice to store the possibly previously installed hook and that you recall it inside your own. | ||||||
926 | |||||||
927 | Perl_ophook_t PL_opfreehook','name' => 'PL_opfreehook'},'dump_all' => {'text' => '','name' => 'dump_all'},'ninstr' => {'text' => '','name' => 'ninstr'},'sv_vcatpvf' => {'text' => 'Processes its arguments like C |
||||||
928 | to an SV. Does not handle \'set\' magic. See C |
||||||
929 | |||||||
930 | Usually used via its frontend C |
||||||
931 | |||||||
932 | void sv_vcatpvf(SV *const sv, const char *const pat, | ||||||
933 | va_list *const args)','name' => 'sv_vcatpvf'},'sv_pos_u2b' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from | ||||||
934 | the start of the string, to a count of the equivalent number of bytes; if | ||||||
935 | lenp is non-zero, it does the same to lenp, but this time starting from | ||||||
936 | the offset, rather than from the start of the string. Handles magic and | ||||||
937 | type coercion. | ||||||
938 | |||||||
939 | Use C |
||||||
940 | than 2Gb. | ||||||
941 | |||||||
942 | void sv_pos_u2b(SV *const sv, I32 *const offsetp, | ||||||
943 | I32 *const lenp)','name' => 'sv_pos_u2b'},'boolSV' => {'text' => 'Returns a true SV if C is a true value, or a false SV if C is 0. | ||||||
944 | |||||||
945 | See also C |
||||||
946 | |||||||
947 | SV * boolSV(bool b)','name' => 'boolSV'},'is_utf8_xdigit' => {'text' => '','name' => 'is_utf8_xdigit'},'upg_version' => {'text' => 'In-place upgrade of the supplied SV to a version object. | ||||||
948 | |||||||
949 | SV *sv = upg_version(SV *sv, bool qv); | ||||||
950 | |||||||
951 | Returns a pointer to the upgraded SV. Set the boolean qv if you want | ||||||
952 | to force this SV to be interpreted as an "extended" version. | ||||||
953 | |||||||
954 | SV* upg_version(SV *ver, bool qv)','name' => 'upg_version'},'PERL_SYS_INIT3' => {'text' => 'Provides system-specific tune up of the C runtime environment necessary to | ||||||
955 | run Perl interpreters. This should be called only once, before creating | ||||||
956 | any Perl interpreters. | ||||||
957 | |||||||
958 | void PERL_SYS_INIT3(int argc, char** argv, | ||||||
959 | char** env)','name' => 'PERL_SYS_INIT3'},'HeSVKEY_set' => {'text' => 'Sets the key to a given C |
||||||
960 | indicate the presence of an C |
||||||
961 | C |
||||||
962 | |||||||
963 | SV* HeSVKEY_set(HE* he, SV* sv)','name' => 'HeSVKEY_set'},'is_utf8_perl_space' => {'text' => '','name' => 'is_utf8_perl_space'},'sv_derived_from_sv' => {'text' => 'Exactly like L, but takes the name string in the form | ||||||
964 | of an SV instead of a string/length pair. | ||||||
965 | |||||||
966 | bool sv_derived_from_sv(SV* sv, SV *namesv, | ||||||
967 | U32 flags)','name' => 'sv_derived_from_sv'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L |
||||||
968 | |||||||
969 | SPAGAIN;','name' => 'SPAGAIN'},'newCVREF' => {'text' => '','name' => 'newCVREF'},'gv_init_sv' => {'text' => 'Same as gv_init_pvn(), but takes an SV * for the name instead of separate | ||||||
970 | char * and length parameters. C |
||||||
971 | |||||||
972 | void gv_init_sv(GV* gv, HV* stash, SV* namesv, | ||||||
973 | U32 flags)','name' => 'gv_init_sv'},'my_bcopy' => {'text' => '','name' => 'my_bcopy'},'PL_parser-E |
||||||
974 | Characters around this point may be freely examined, within | ||||||
975 | the range delimited by C |
||||||
976 | Lbufend>. The octets of the buffer may be intended to be | ||||||
977 | interpreted as either UTF-8 or Latin-1, as indicated by L. | ||||||
978 | |||||||
979 | Lexing code (whether in the Perl core or not) moves this pointer past | ||||||
980 | the characters that it consumes. It is also expected to perform some | ||||||
981 | bookkeeping whenever a newline character is consumed. This movement | ||||||
982 | can be more conveniently performed by the function L, | ||||||
983 | which handles newlines appropriately. | ||||||
984 | |||||||
985 | Interpretation of the buffer\'s octets can be abstracted out by | ||||||
986 | using the slightly higher-level functions L and | ||||||
987 | L. | ||||||
988 | |||||||
989 | NOTE: this function is experimental and may change or be | ||||||
990 | removed without notice.','name' => 'PL_parser-E |
||||||
991 | L |
||||||
992 | a context in which to lex and parse from a new source of Perl code. | ||||||
993 | A pointer to the new state object is placed in L. An entry | ||||||
994 | is made on the save stack so that upon unwinding the new state object | ||||||
995 | will be destroyed and the former value of L will be restored. | ||||||
996 | Nothing else need be done to clean up the parsing context. | ||||||
997 | |||||||
998 | The code to be parsed comes from I |
||||||
999 | non-null, provides a string (in SV form) containing code to be parsed. | ||||||
1000 | A copy of the string is made, so subsequent modification of I |
||||||
1001 | does not affect parsing. I |
||||||
1002 | from which code will be read to be parsed. If both are non-null, the | ||||||
1003 | code in I |
||||||
1004 | and I |
||||||
1005 | |||||||
1006 | The I |
||||||
1007 | used by perl internally, so extensions should always pass zero. | ||||||
1008 | |||||||
1009 | NOTE: this function is experimental and may change or be | ||||||
1010 | removed without notice. | ||||||
1011 | |||||||
1012 | void lex_start(SV *line, PerlIO *rsfp, U32 flags)','name' => 'lex_start'},'hv_riter_set' => {'text' => '','name' => 'hv_riter_set'},'gv_autoload_pvn' => {'text' => '','name' => 'gv_autoload_pvn'},'to_uni_lower' => {'text' => '','name' => 'to_uni_lower'},'gv_autoload_pv' => {'text' => '','name' => 'gv_autoload_pv'},'dounwind' => {'text' => '','name' => 'dounwind'},'ptr_table_clear' => {'text' => '','name' => 'ptr_table_clear'},'uvchr_to_utf8_flags' => {'text' => '','name' => 'uvchr_to_utf8_flags'},'save_hash' => {'text' => '','name' => 'save_hash'},'sv_isa' => {'text' => 'Returns a boolean indicating whether the SV is blessed into the specified | ||||||
1013 | class. This does not check for subtypes; use C |
||||||
1014 | an inheritance relationship. | ||||||
1015 | |||||||
1016 | int sv_isa(SV* sv, const char *const name)','name' => 'sv_isa'},'cophh_free' => {'text' => 'Discard the cop hints hash I |
||||||
1017 | with it. | ||||||
1018 | |||||||
1019 | NOTE: this function is experimental and may change or be | ||||||
1020 | removed without notice. | ||||||
1021 | |||||||
1022 | void cophh_free(COPHH *cophh)','name' => 'cophh_free'},'isXDIGIT' => {'text' => 'Returns a boolean indicating whether the specified character is a hexadecimal | ||||||
1023 | digit, [0-9A-Fa-f]. Variants C |
||||||
1024 | identical to C |
||||||
1025 | |||||||
1026 | bool isXDIGIT(char ch)','name' => 'isXDIGIT'},'sv_catpvf' => {'text' => 'Processes its arguments like C |
||||||
1027 | output to an SV. If the appended data contains "wide" characters | ||||||
1028 | (including, but not limited to, SVs with a UTF-8 PV formatted with %s, | ||||||
1029 | and characters >255 formatted with %c), the original SV might get | ||||||
1030 | upgraded to UTF-8. Handles \'get\' magic, but not \'set\' magic. See | ||||||
1031 | C |
||||||
1032 | valid UTF-8; if the original SV was bytes, the pattern should be too. | ||||||
1033 | |||||||
1034 | void sv_catpvf(SV *const sv, const char *const pat, | ||||||
1035 | ...)','name' => 'sv_catpvf'},'cop_fetch_label' => {'text' => 'Returns the label attached to a cop. | ||||||
1036 | The flags pointer may be set to C |
||||||
1037 | |||||||
1038 | NOTE: this function is experimental and may change or be | ||||||
1039 | removed without notice. | ||||||
1040 | |||||||
1041 | const char * cop_fetch_label(COP *const cop, | ||||||
1042 | STRLEN *len, U32 *flags)','name' => 'cop_fetch_label'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C |
||||||
1043 | |||||||
1044 | void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'utf8_to_uvuni' => {'text' => 'DEPRECATED! | ||||||
1045 | |||||||
1046 | Returns the Unicode code point of the first character in the string C |
||||||
1047 | which is assumed to be in UTF-8 encoding; C |
||||||
1048 | length, in bytes, of that character. | ||||||
1049 | |||||||
1050 | This function should only be used when the returned UV is considered | ||||||
1051 | an index into the Unicode semantic tables (e.g. swashes). | ||||||
1052 | |||||||
1053 | Some, but not all, UTF-8 malformations are detected, and in fact, some | ||||||
1054 | malformed input could cause reading beyond the end of the input buffer, which | ||||||
1055 | is why this function is deprecated. Use L instead. | ||||||
1056 | |||||||
1057 | If C |
||||||
1058 | enabled, zero is returned and C<*retlen> is set (if C |
||||||
1059 | NULL) to -1. If those warnings are off, the computed value if well-defined (or | ||||||
1060 | the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen> | ||||||
1061 | is set (if C |
||||||
1062 | next possible position in C |
||||||
1063 | See L for details on when the REPLACEMENT CHARACTER is returned. | ||||||
1064 | |||||||
1065 | UV utf8_to_uvuni(const U8 *s, STRLEN *retlen)','name' => 'utf8_to_uvuni'},'is_utf8_idcont' => {'text' => '','name' => 'is_utf8_idcont'},'pad_alloc' => {'text' => 'Allocates a place in the currently-compiling pad, | ||||||
1066 | returning the offset of the allocated pad slot. | ||||||
1067 | No name is initially attached to the pad slot. | ||||||
1068 | I |
||||||
1069 | which will be set in the value SV for the allocated pad entry: | ||||||
1070 | |||||||
1071 | SVs_PADMY named lexical variable ("my", "our", "state") | ||||||
1072 | SVs_PADTMP unnamed temporary store | ||||||
1073 | |||||||
1074 | I |
||||||
1075 | pad entry is to support. This doesn\'t affect operational semantics, | ||||||
1076 | but is used for debugging. | ||||||
1077 | |||||||
1078 | NOTE: this function is experimental and may change or be | ||||||
1079 | removed without notice. | ||||||
1080 | |||||||
1081 | PADOFFSET pad_alloc(I32 optype, U32 tmptype)','name' => 'pad_alloc'},'av_fill' => {'text' => 'Set the highest index in the array to the given number, equivalent to | ||||||
1082 | Perl\'s C<$#array = $fill;>. | ||||||
1083 | |||||||
1084 | The number of elements in the an array will be C |
||||||
1085 | av_fill() returns. If the array was previously shorter, then the | ||||||
1086 | additional elements appended are set to C |
||||||
1087 | was longer, then the excess elements are freed. C |
||||||
1088 | the same as C |
||||||
1089 | |||||||
1090 | void av_fill(AV *av, I32 fill)','name' => 'av_fill'},'croak_sv' => {'text' => 'This is an XS interface to Perl\'s C |
||||||
1091 | |||||||
1092 | C |
||||||
1093 | will be used as-is. Otherwise it is used as a string, and if it does | ||||||
1094 | not end with a newline then it will be extended with some indication of | ||||||
1095 | the current location in the code, as described for L. | ||||||
1096 | |||||||
1097 | The error message or object will be used as an exception, by default | ||||||
1098 | returning control to the nearest enclosing C |
||||||
1099 | modification by a C<$SIG{__DIE__}> handler. In any case, the C |
||||||
1100 | function never returns normally. | ||||||
1101 | |||||||
1102 | To die with a simple string message, the L function may be | ||||||
1103 | more convenient. | ||||||
1104 | |||||||
1105 | void croak_sv(SV *baseex)','name' => 'croak_sv'},'warn_nocontext' => {'text' => '','name' => 'warn_nocontext'},'my_swap' => {'text' => '','name' => 'my_swap'},'SvIOK_only' => {'text' => 'Tells an SV that it is an integer and disables all other OK bits. | ||||||
1106 | |||||||
1107 | void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'MoveD' => {'text' => 'Like C |
||||||
1108 | optimise. | ||||||
1109 | |||||||
1110 | void * MoveD(void* src, void* dest, int nitems, type)','name' => 'MoveD'},'gv_IOadd' => {'text' => '','name' => 'gv_IOadd'},'grok_bin' => {'text' => 'converts a string representing a binary number to numeric form. | ||||||
1111 | |||||||
1112 | On entry I |
||||||
1113 | conversion flags, and I |
||||||
1114 | The scan stops at the end of the string, or the first invalid character. | ||||||
1115 | Unless C |
||||||
1116 | invalid character will also trigger a warning. | ||||||
1117 | On return I<*len> is set to the length of the scanned string, | ||||||
1118 | and I<*flags> gives output flags. | ||||||
1119 | |||||||
1120 | If the value is <= C |
||||||
1121 | and nothing is written to I<*result>. If the value is > UV_MAX C |
||||||
1122 | returns UV_MAX, sets C |
||||||
1123 | and writes the value to I<*result> (or the value is discarded if I |
||||||
1124 | is NULL). | ||||||
1125 | |||||||
1126 | The binary number may optionally be prefixed with "0b" or "b" unless | ||||||
1127 | C |
||||||
1128 | C |
||||||
1129 | number may use \'_\' characters to separate digits. | ||||||
1130 | |||||||
1131 | UV grok_bin(const char* start, STRLEN* len_p, | ||||||
1132 | I32* flags, NV *result)','name' => 'grok_bin'},'parse_barestmt' => {'text' => 'Parse a single unadorned Perl statement. This may be a normal imperative | ||||||
1133 | statement or a declaration that has compile-time effect. It does not | ||||||
1134 | include any label or other affixture. It is up to the caller to ensure | ||||||
1135 | that the dynamic parser state (L et al) is correctly set to | ||||||
1136 | reflect the source of the code to be parsed and the lexical context for | ||||||
1137 | the statement. | ||||||
1138 | |||||||
1139 | The op tree representing the statement is returned. This may be a | ||||||
1140 | null pointer if the statement is null, for example if it was actually | ||||||
1141 | a subroutine definition (which has compile-time side effects). If not | ||||||
1142 | null, it will be ops directly implementing the statement, suitable to | ||||||
1143 | pass to L. It will not normally include a C |
||||||
1144 | equivalent op (except for those embedded in a scope contained entirely | ||||||
1145 | within the statement). | ||||||
1146 | |||||||
1147 | If an error occurs in parsing or compilation, in most cases a valid op | ||||||
1148 | tree (most likely null) is returned anyway. The error is reflected in | ||||||
1149 | the parser state, normally resulting in a single exception at the top | ||||||
1150 | level of parsing which covers all the compilation errors that occurred. | ||||||
1151 | Some compilation errors, however, will throw an exception immediately. | ||||||
1152 | |||||||
1153 | The I |
||||||
1154 | be zero. | ||||||
1155 | |||||||
1156 | NOTE: this function is experimental and may change or be | ||||||
1157 | removed without notice. | ||||||
1158 | |||||||
1159 | OP * parse_barestmt(U32 flags)','name' => 'parse_barestmt'},'cast_uv' => {'text' => '','name' => 'cast_uv'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L |
||||||
1160 | |||||||
1161 | void perl_free(PerlInterpreter *my_perl)','name' => 'perl_free'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C |
||||||
1162 | |||||||
1163 | MAGIC* mg_find(const SV* sv, int type)','name' => 'mg_find'},'safesysfree' => {'text' => '','name' => 'safesysfree'},'BhkENTRY_set' => {'text' => 'Set an entry in the BHK structure, and set the flags to indicate it is | ||||||
1164 | valid. I |
||||||
1165 | The type of I |
||||||
1166 | |||||||
1167 | NOTE: this function is experimental and may change or be | ||||||
1168 | removed without notice. | ||||||
1169 | |||||||
1170 | void BhkENTRY_set(BHK *hk, which, void *ptr)','name' => 'BhkENTRY_set'},'PL_parser-E |
||||||
1171 | text currently being lexed. This is always a plain string scalar (for | ||||||
1172 | which C |
||||||
1173 | normal scalar means; instead refer to the buffer directly by the pointer | ||||||
1174 | variables described below. | ||||||
1175 | |||||||
1176 | The lexer maintains various C |
||||||
1177 | C |
||||||
1178 | reallocated, all of these pointers must be updated. Don\'t attempt to | ||||||
1179 | do this manually, but rather use L if you need to | ||||||
1180 | reallocate the buffer. | ||||||
1181 | |||||||
1182 | The content of the text chunk in the buffer is commonly exactly one | ||||||
1183 | complete line of input, up to and including a newline terminator, | ||||||
1184 | but there are situations where it is otherwise. The octets of the | ||||||
1185 | buffer may be intended to be interpreted as either UTF-8 or Latin-1. | ||||||
1186 | The function L tells you which. Do not use the C |
||||||
1187 | flag on this scalar, which may disagree with it. | ||||||
1188 | |||||||
1189 | For direct examination of the buffer, the variable | ||||||
1190 | Lbufend> points to the end of the buffer. The current | ||||||
1191 | lexing position is pointed to by Lbufptr>. Direct use | ||||||
1192 | of these pointers is usually preferable to examination of the scalar | ||||||
1193 | through normal scalar means. | ||||||
1194 | |||||||
1195 | NOTE: this function is experimental and may change or be | ||||||
1196 | removed without notice.','name' => 'PL_parser-E |
||||||
1197 | table. If the string does not already exist in the table, it is | ||||||
1198 | created first. Turns on READONLY and FAKE. If the C |
||||||
1199 | is non-zero, that value is used; otherwise the hash is computed. | ||||||
1200 | The string\'s hash can later be retrieved from the SV | ||||||
1201 | with the C |
||||||
1202 | that as the string table is used for shared hash keys these strings will have | ||||||
1203 | SvPVX_const == HeKEY and hash lookup will avoid string compare. | ||||||
1204 | |||||||
1205 | SV* newSVpvn_share(const char* s, I32 len, U32 hash)','name' => 'newSVpvn_share'},'mro_set_mro' => {'text' => '','name' => 'mro_set_mro'},'SvPOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a character string. | ||||||
1206 | Checks the B |
||||||
1207 | |||||||
1208 | U32 SvPOKp(SV* sv)','name' => 'SvPOKp'},'pregfree2' => {'text' => '','name' => 'pregfree2'},'sv_catpvn' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The | ||||||
1209 | C |
||||||
1210 | status set, then the bytes appended should be valid UTF-8. | ||||||
1211 | Handles \'get\' magic, but not \'set\' magic. See C |
||||||
1212 | |||||||
1213 | void sv_catpvn(SV *dsv, const char *sstr, STRLEN len)','name' => 'sv_catpvn'},'my_socketpair' => {'text' => '','name' => 'my_socketpair'},'blockhook_register' => {'text' => 'Register a set of hooks to be called when the Perl lexical scope changes | ||||||
1214 | at compile time. See L |
||||||
1215 | |||||||
1216 | NOTE: this function is experimental and may change or be | ||||||
1217 | removed without notice. | ||||||
1218 | |||||||
1219 | NOTE: this function must be explicitly called as Perl_blockhook_register with an aTHX_ parameter. | ||||||
1220 | |||||||
1221 | void Perl_blockhook_register(pTHX_ BHK *hk)','name' => 'blockhook_register'},'init_global_struct' => {'text' => '','name' => 'init_global_struct'},'find_rundefsv' => {'text' => 'Find and return the variable that is named C<$_> in the lexical scope | ||||||
1222 | of the currently-executing function. This may be a lexical C<$_>, | ||||||
1223 | or will otherwise be the global one. | ||||||
1224 | |||||||
1225 | SV * find_rundefsv()','name' => 'find_rundefsv'},'sv_utf8_downgrade' => {'text' => 'Attempts to convert the PV of an SV from characters to bytes. | ||||||
1226 | If the PV contains a character that cannot fit | ||||||
1227 | in a byte, this conversion will fail; | ||||||
1228 | in this case, either returns false or, if C |
||||||
1229 | true, croaks. | ||||||
1230 | |||||||
1231 | This is not as a general purpose Unicode to byte encoding interface: | ||||||
1232 | use the Encode extension for that. | ||||||
1233 | |||||||
1234 | NOTE: this function is experimental and may change or be | ||||||
1235 | removed without notice. | ||||||
1236 | |||||||
1237 | bool sv_utf8_downgrade(SV *const sv, | ||||||
1238 | const bool fail_ok)','name' => 'sv_utf8_downgrade'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C |
||||||
1239 | forward or backward. | ||||||
1240 | |||||||
1241 | WARNING: do not use the following unless you *know* C |
||||||
1242 | the UTF-8 data pointed to by C |
||||||
1243 | on the first byte of character or just after the last byte of a character. | ||||||
1244 | |||||||
1245 | U8* utf8_hop(const U8 *s, I32 off)','name' => 'utf8_hop'},'newPROG' => {'text' => '','name' => 'newPROG'},'sv_setref_pvn' => {'text' => 'Copies a string into a new SV, optionally blessing the SV. The length of the | ||||||
1246 | string must be specified with C |
||||||
1247 | an RV. That RV will be modified to point to the new SV. The C |
||||||
1248 | argument indicates the package for the blessing. Set C |
||||||
1249 | C |
||||||
1250 | of 1, and the RV will be returned. | ||||||
1251 | |||||||
1252 | Note that C |
||||||
1253 | |||||||
1254 | SV* sv_setref_pvn(SV *const rv, | ||||||
1255 | const char *const classname, | ||||||
1256 | const char *const pv, | ||||||
1257 | const STRLEN n)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for blessed scalars. See C |
||||||
1258 | The C |
||||||
1259 | C |
||||||
1260 | call multiple C |
||||||
1261 | C |
||||||
1262 | |||||||
1263 | void PUSHp(char* str, STRLEN len)','name' => 'PUSHp'},'my_strftime' => {'text' => '','name' => 'my_strftime'},'mXPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. | ||||||
1264 | Does not use C |
||||||
1265 | |||||||
1266 | void mXPUSHi(IV iv)','name' => 'mXPUSHi'},'PL_sv_undef' => {'text' => 'This is the C |
||||||
1267 | |||||||
1268 | SV PL_sv_undef','name' => 'PL_sv_undef'},'hv_iterkeysv' => {'text' => 'Returns the key as an C |
||||||
1269 | iterator. The return value will always be a mortal copy of the key. Also | ||||||
1270 | see C |
||||||
1271 | |||||||
1272 | SV* hv_iterkeysv(HE* entry)','name' => 'hv_iterkeysv'},'sv_catpv_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. | ||||||
1273 | If the SV has the UTF-8 status set, then the bytes appended should | ||||||
1274 | be valid UTF-8. If C |
||||||
1275 | on the modified SV if appropriate. | ||||||
1276 | |||||||
1277 | void sv_catpv_flags(SV *dstr, const char *sstr, | ||||||
1278 | const I32 flags)','name' => 'sv_catpv_flags'},'mPUSHp' => {'text' => 'Push a string onto the stack. The stack must have room for this element. | ||||||
1279 | The C |
||||||
1280 | See also C |
||||||
1281 | |||||||
1282 | void mPUSHp(char* str, STRLEN len)','name' => 'mPUSHp'},'lex_stuff_pv' => {'text' => 'Insert characters into the lexer buffer (Llinestr>), | ||||||
1283 | immediately after the current lexing point (Lbufptr>), | ||||||
1284 | reallocating the buffer if necessary. This means that lexing code that | ||||||
1285 | runs later will see the characters as if they had appeared in the input. | ||||||
1286 | It is not recommended to do this as part of normal parsing, and most | ||||||
1287 | uses of this facility run the risk of the inserted characters being | ||||||
1288 | interpreted in an unintended manner. | ||||||
1289 | |||||||
1290 | The string to be inserted is represented by octets starting at I |
||||||
1291 | and continuing to the first nul. These octets are interpreted as either | ||||||
1292 | UTF-8 or Latin-1, according to whether the C |
||||||
1293 | in I |
||||||
1294 | to how the buffer is currently being interpreted (L). | ||||||
1295 | If it is not convenient to nul-terminate a string to be inserted, the | ||||||
1296 | L function is more appropriate. | ||||||
1297 | |||||||
1298 | NOTE: this function is experimental and may change or be | ||||||
1299 | removed without notice. | ||||||
1300 | |||||||
1301 | void lex_stuff_pv(const char *pv, U32 flags)','name' => 'lex_stuff_pv'},'av_delete' => {'text' => 'Deletes the element indexed by C |
||||||
1302 | and returns it. If C |
||||||
1303 | is returned. Perl equivalent: C |
||||||
1304 | non-C |
||||||
1305 | C |
||||||
1306 | |||||||
1307 | SV* av_delete(AV *av, I32 key, I32 flags)','name' => 'av_delete'},'utf8_distance' => {'text' => 'Returns the number of UTF-8 characters between the UTF-8 pointers C | ||||||
1308 | and C. | ||||||
1309 | |||||||
1310 | WARNING: use only if you *know* that the pointers point inside the | ||||||
1311 | same UTF-8 buffer. | ||||||
1312 | |||||||
1313 | IV utf8_distance(const U8 *a, const U8 *b)','name' => 'utf8_distance'},'SvPV_nomg' => {'text' => 'Like C |
||||||
1314 | |||||||
1315 | char* SvPV_nomg(SV* sv, STRLEN len)','name' => 'SvPV_nomg'},'parser_dup' => {'text' => '','name' => 'parser_dup'},'do_sprintf' => {'text' => '','name' => 'do_sprintf'},'SvUV_nomg' => {'text' => 'Like C |
||||||
1316 | |||||||
1317 | UV SvUV_nomg(SV* sv)','name' => 'SvUV_nomg'},'save_I32' => {'text' => '','name' => 'save_I32'},'gv_autoload4' => {'text' => '','name' => 'gv_autoload4'},'POPpx' => {'text' => 'Pops a string off the stack. | ||||||
1318 | |||||||
1319 | char* POPpx','name' => 'POPpx'},'PL_modglobal' => {'text' => 'C |
||||||
1320 | extensions that need to keep information on a per-interpreter basis. | ||||||
1321 | In a pinch, it can also be used as a symbol table for extensions | ||||||
1322 | to share data among each other. It is a good idea to use keys | ||||||
1323 | prefixed by the package name of the extension that owns the data. | ||||||
1324 | |||||||
1325 | HV* PL_modglobal','name' => 'PL_modglobal'},'newCONDOP' => {'text' => 'Constructs, checks, and returns a conditional-expression (C |
||||||
1326 | op. I |
||||||
1327 | will be set automatically, and, shifted up eight bits, the eight bits of | ||||||
1328 | C |
||||||
1329 | I |
||||||
1330 | and I |
||||||
1331 | this function and become part of the constructed op tree. | ||||||
1332 | |||||||
1333 | OP * newCONDOP(I32 flags, OP *first, OP *trueop, | ||||||
1334 | OP *falseop)','name' => 'newCONDOP'},'save_pushi32ptr' => {'text' => '','name' => 'save_pushi32ptr'},'sv_setpvs' => {'text' => 'Like C |
||||||
1335 | |||||||
1336 | void sv_setpvs(SV* sv, const char* s)','name' => 'sv_setpvs'},'is_uni_punct_lc' => {'text' => '','name' => 'is_uni_punct_lc'},'cxinc' => {'text' => '','name' => 'cxinc'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and | ||||||
1337 | returns it. Guarantees to C |
||||||
1338 | use this if C |
||||||
1339 | otherwise use the more efficient C |
||||||
1340 | |||||||
1341 | UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. | ||||||
1342 | |||||||
1343 | void SvROK_on(SV* sv)','name' => 'SvROK_on'},'G_VOID' => {'text' => 'Used to indicate void context. See C |
||||||
1344 | and free the body itself. The SV\'s head is I |
||||||
1345 | its type is set to all 1\'s so that it won\'t inadvertently be assumed | ||||||
1346 | to be live during global destruction etc. | ||||||
1347 | This function should only be called when REFCNT is zero. Most of the time | ||||||
1348 | you\'ll want to call C |
||||||
1349 | instead. | ||||||
1350 | |||||||
1351 | void sv_clear(SV *const orig_sv)','name' => 'sv_clear'},'lex_read_space' => {'text' => 'Reads optional spaces, in Perl style, in the text currently being | ||||||
1352 | lexed. The spaces may include ordinary whitespace characters and | ||||||
1353 | Perl-style comments. C<#line> directives are processed if encountered. | ||||||
1354 | Lbufptr> is moved past the spaces, so that it points | ||||||
1355 | at a non-space character (or the end of the input text). | ||||||
1356 | |||||||
1357 | If spaces extend into the next chunk of input text, the next chunk will | ||||||
1358 | be read in. Normally the current chunk will be discarded at the same | ||||||
1359 | time, but if I |
||||||
1360 | chunk will not be discarded. | ||||||
1361 | |||||||
1362 | NOTE: this function is experimental and may change or be | ||||||
1363 | removed without notice. | ||||||
1364 | |||||||
1365 | void lex_read_space(U32 flags)','name' => 'lex_read_space'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C |
||||||
1366 | |||||||
1367 | void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'SvGAMAGIC' => {'text' => 'Returns true if the SV has get magic or | ||||||
1368 | overloading. If either is true then | ||||||
1369 | the scalar is active data, and has the potential to return a new value every | ||||||
1370 | time it is accessed. Hence you must be careful to | ||||||
1371 | only read it once per user logical operation and work | ||||||
1372 | with that returned value. If neither is true then | ||||||
1373 | the scalar\'s value cannot change unless written to. | ||||||
1374 | |||||||
1375 | U32 SvGAMAGIC(SV* sv)','name' => 'SvGAMAGIC'},'svtype' => {'text' => 'An enum of flags for Perl types. These are found in the file B |
||||||
1376 | in the C |
||||||
1377 | Note that the actual module name, not its filename, should be given. | ||||||
1378 | Eg, "Foo::Bar" instead of "Foo/Bar.pm". flags can be any of | ||||||
1379 | PERL_LOADMOD_DENY, PERL_LOADMOD_NOIMPORT, or PERL_LOADMOD_IMPORT_OPS | ||||||
1380 | (or 0 for no flags). ver, if specified and not NULL, provides version semantics | ||||||
1381 | similar to C | ||||||
1382 | arguments can be used to specify arguments to the module\'s import() | ||||||
1383 | method, similar to C | ||||||
1384 | terminated with a final NULL pointer. Note that this list can only | ||||||
1385 | be omitted when the PERL_LOADMOD_NOIMPORT flag has been used. | ||||||
1386 | Otherwise at least a single NULL pointer to designate the default | ||||||
1387 | import list is required. | ||||||
1388 | |||||||
1389 | The reference count for each specified C |
||||||
1390 | |||||||
1391 | void load_module(U32 flags, SV* name, SV* ver, ...)','name' => 'load_module'},'dump_eval' => {'text' => '','name' => 'dump_eval'},'Poison' => {'text' => 'PoisonWith(0xEF) for catching access to freed memory. | ||||||
1392 | |||||||
1393 | void Poison(void* dest, int nitems, type)','name' => 'Poison'},'is_uni_alpha_lc' => {'text' => '','name' => 'is_uni_alpha_lc'},'sv_catpvf_mg' => {'text' => 'Like C |
||||||
1394 | |||||||
1395 | void sv_catpvf_mg(SV *const sv, | ||||||
1396 | const char *const pat, ...)','name' => 'sv_catpvf_mg'},'get_sv' => {'text' => 'Returns the SV of the specified Perl scalar. C |
||||||
1397 | C |
||||||
1398 | Perl variable does not exist then it will be created. If C |
||||||
1399 | and the variable does not exist then NULL is returned. | ||||||
1400 | |||||||
1401 | NOTE: the perl_ form of this function is deprecated. | ||||||
1402 | |||||||
1403 | SV* get_sv(const char *name, I32 flags)','name' => 'get_sv'},'warn_sv' => {'text' => 'This is an XS interface to Perl\'s C |
||||||
1404 | |||||||
1405 | C |
||||||
1406 | will be used as-is. Otherwise it is used as a string, and if it does | ||||||
1407 | not end with a newline then it will be extended with some indication of | ||||||
1408 | the current location in the code, as described for L. | ||||||
1409 | |||||||
1410 | The error message or object will by default be written to standard error, | ||||||
1411 | but this is subject to modification by a C<$SIG{__WARN__}> handler. | ||||||
1412 | |||||||
1413 | To warn with a simple string message, the L function may be | ||||||
1414 | more convenient. | ||||||
1415 | |||||||
1416 | void warn_sv(SV *baseex)','name' => 'warn_sv'},'GetVars' => {'text' => '','name' => 'GetVars'},'do_hv_dump' => {'text' => '','name' => 'do_hv_dump'},'sv_setpv_mg' => {'text' => 'Like C |
||||||
1417 | |||||||
1418 | void sv_setpv_mg(SV *const sv, const char *const ptr)','name' => 'sv_setpv_mg'},'whichsig' => {'text' => '','name' => 'whichsig'},'lex_next_chunk' => {'text' => 'Reads in the next chunk of text to be lexed, appending it to | ||||||
1419 | Llinestr>. This should be called when lexing code has | ||||||
1420 | looked to the end of the current chunk and wants to know more. It is | ||||||
1421 | usual, but not necessary, for lexing to have consumed the entirety of | ||||||
1422 | the current chunk at this time. | ||||||
1423 | |||||||
1424 | If Lbufptr> is pointing to the very end of the current | ||||||
1425 | chunk (i.e., the current chunk has been entirely consumed), normally the | ||||||
1426 | current chunk will be discarded at the same time that the new chunk is | ||||||
1427 | read in. If I |
||||||
1428 | will not be discarded. If the current chunk has not been entirely | ||||||
1429 | consumed, then it will not be discarded regardless of the flag. | ||||||
1430 | |||||||
1431 | Returns true if some new text was added to the buffer, or false if the | ||||||
1432 | buffer has reached the end of the input text. | ||||||
1433 | |||||||
1434 | NOTE: this function is experimental and may change or be | ||||||
1435 | removed without notice. | ||||||
1436 | |||||||
1437 | bool lex_next_chunk(U32 flags)','name' => 'lex_next_chunk'},'sv_2mortal' => {'text' => 'Marks an existing SV as mortal. The SV will be destroyed "soon", either | ||||||
1438 | by an explicit call to FREETMPS, or by an implicit call at places such as | ||||||
1439 | statement boundaries. SvTEMP() is turned on which means that the SV\'s | ||||||
1440 | string buffer can be "stolen" if this SV is copied. See also C |
||||||
1441 | and C |
||||||
1442 | |||||||
1443 | SV* sv_2mortal(SV *const sv)','name' => 'sv_2mortal'},'sv_2bool_flags' => {'text' => 'This function is only used by sv_true() and friends, and only if | ||||||
1444 | the latter\'s argument is neither SvPOK, SvIOK nor SvNOK. If the flags | ||||||
1445 | contain SV_GMAGIC, then it does an mg_get() first. | ||||||
1446 | |||||||
1447 | |||||||
1448 | bool sv_2bool_flags(SV *const sv, const I32 flags)','name' => 'sv_2bool_flags'},'is_uni_graph' => {'text' => '','name' => 'is_uni_graph'},'malloc' => {'text' => '','name' => 'malloc'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the av to store its list of | ||||||
1449 | scalars. If any destructors are triggered as a result, the av itself may | ||||||
1450 | be freed. | ||||||
1451 | |||||||
1452 | void av_undef(AV *av)','name' => 'av_undef'},'parse_label' => {'text' => 'Parse a single label, possibly optional, of the type that may prefix a | ||||||
1453 | Perl statement. It is up to the caller to ensure that the dynamic parser | ||||||
1454 | state (L et al) is correctly set to reflect the source of | ||||||
1455 | the code to be parsed. If I |
||||||
1456 | label is optional, otherwise it is mandatory. | ||||||
1457 | |||||||
1458 | The name of the label is returned in the form of a fresh scalar. If an | ||||||
1459 | optional label is absent, a null pointer is returned. | ||||||
1460 | |||||||
1461 | If an error occurs in parsing, which can only occur if the label is | ||||||
1462 | mandatory, a valid label is returned anyway. The error is reflected in | ||||||
1463 | the parser state, normally resulting in a single exception at the top | ||||||
1464 | level of parsing which covers all the compilation errors that occurred. | ||||||
1465 | |||||||
1466 | NOTE: this function is experimental and may change or be | ||||||
1467 | removed without notice. | ||||||
1468 | |||||||
1469 | SV * parse_label(U32 flags)','name' => 'parse_label'},'PL_check' => {'text' => 'Array, indexed by opcode, of functions that will be called for the "check" | ||||||
1470 | phase of optree building during compilation of Perl code. For most (but | ||||||
1471 | not all) types of op, once the op has been initially built and populated | ||||||
1472 | with child ops it will be filtered through the check function referenced | ||||||
1473 | by the appropriate element of this array. The new op is passed in as the | ||||||
1474 | sole argument to the check function, and the check function returns the | ||||||
1475 | completed op. The check function may (as the name suggests) check the op | ||||||
1476 | for validity and signal errors. It may also initialise or modify parts of | ||||||
1477 | the ops, or perform more radical surgery such as adding or removing child | ||||||
1478 | ops, or even throw the op away and return a different op in its place. | ||||||
1479 | |||||||
1480 | This array of function pointers is a convenient place to hook into the | ||||||
1481 | compilation process. An XS module can put its own custom check function | ||||||
1482 | in place of any of the standard ones, to influence the compilation of a | ||||||
1483 | particular type of op. However, a custom check function must never fully | ||||||
1484 | replace a standard check function (or even a custom check function from | ||||||
1485 | another module). A module modifying checking must instead B |
||||||
1486 | preexisting check function. A custom check function must be selective | ||||||
1487 | about when to apply its custom behaviour. In the usual case where | ||||||
1488 | it decides not to do anything special with an op, it must chain the | ||||||
1489 | preexisting op function. Check functions are thus linked in a chain, | ||||||
1490 | with the core\'s base checker at the end. | ||||||
1491 | |||||||
1492 | For thread safety, modules should not write directly to this array. | ||||||
1493 | Instead, use the function L.','name' => 'PL_check'},'pack_cat' => {'text' => 'The engine implementing pack() Perl function. Note: parameters next_in_list and | ||||||
1494 | flags are not used. This call should not be used; use packlist instead. | ||||||
1495 | |||||||
1496 | void pack_cat(SV *cat, const char *pat, | ||||||
1497 | const char *patend, SV **beglist, | ||||||
1498 | SV **endlist, SV ***next_in_list, | ||||||
1499 | U32 flags)','name' => 'pack_cat'},'PerlIO_read' => {'text' => '','name' => 'PerlIO_read'},'sv_cmp' => {'text' => 'Compares the strings in two SVs. Returns -1, 0, or 1 indicating whether the | ||||||
1500 | string in C |
||||||
1501 | C |
||||||
1502 | coerce its args to strings if necessary. See also C |
||||||
1503 | |||||||
1504 | I32 sv_cmp(SV *const sv1, SV *const sv2)','name' => 'sv_cmp'},'mg_free' => {'text' => 'Free any magic storage used by the SV. See C |
||||||
1505 | |||||||
1506 | int mg_free(SV* sv)','name' => 'mg_free'},'sv_force_normal_flags' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make | ||||||
1507 | a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to | ||||||
1508 | an xpvmg; if we\'re a copy-on-write scalar, this is the on-write time when | ||||||
1509 | we do the copy, and is also used locally. If C |
||||||
1510 | then a copy-on-write scalar drops its PV buffer (if any) and becomes | ||||||
1511 | SvPOK_off rather than making a copy. (Used where this | ||||||
1512 | scalar is about to be set to some other value.) In addition, | ||||||
1513 | the C |
||||||
1514 | when unreffing. C |
||||||
1515 | with flags set to 0. | ||||||
1516 | |||||||
1517 | void sv_force_normal_flags(SV *const sv, | ||||||
1518 | const U32 flags)','name' => 'sv_force_normal_flags'},'cophh_fetch_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of | ||||||
1519 | a string/length pair. | ||||||
1520 | |||||||
1521 | NOTE: this function is experimental and may change or be | ||||||
1522 | removed without notice. | ||||||
1523 | |||||||
1524 | SV * cophh_fetch_pv(const COPHH *cophh, | ||||||
1525 | const char *key, U32 hash, | ||||||
1526 | U32 flags)','name' => 'cophh_fetch_pv'},'tmps_grow' => {'text' => '','name' => 'tmps_grow'},'is_utf8_char' => {'text' => 'DEPRECATED! | ||||||
1527 | |||||||
1528 | Tests if some arbitrary number of bytes begins in a valid UTF-8 | ||||||
1529 | character. Note that an INVARIANT (i.e. ASCII on non-EBCDIC machines) | ||||||
1530 | character is a valid UTF-8 character. The actual number of bytes in the UTF-8 | ||||||
1531 | character will be returned if it is valid, otherwise 0. | ||||||
1532 | |||||||
1533 | This function is deprecated due to the possibility that malformed input could | ||||||
1534 | cause reading beyond the end of the input buffer. Use L | ||||||
1535 | instead. | ||||||
1536 | |||||||
1537 | STRLEN is_utf8_char(const U8 *s)','name' => 'is_utf8_char'},'get_vtbl' => {'text' => '','name' => 'get_vtbl'},'save_hints' => {'text' => '','name' => 'save_hints'},'SvNOK_off' => {'text' => 'Unsets the NV status of an SV. | ||||||
1538 | |||||||
1539 | void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'gv_fetchmeth_pv_autoload' => {'text' => 'Exactly like L, but takes a nul-terminated string | ||||||
1540 | instead of a string/length pair. | ||||||
1541 | |||||||
1542 | GV* gv_fetchmeth_pv_autoload(HV* stash, | ||||||
1543 | const char* name, | ||||||
1544 | I32 level, U32 flags)','name' => 'gv_fetchmeth_pv_autoload'},'sv_utf8_upgrade' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. | ||||||
1545 | Forces the SV to string form if it is not already. | ||||||
1546 | Will C |
||||||
1547 | Always sets the SvUTF8 flag to avoid future validity checks even | ||||||
1548 | if the whole string is the same in UTF-8 as not. | ||||||
1549 | Returns the number of bytes in the converted string | ||||||
1550 | |||||||
1551 | This is not as a general purpose byte encoding to Unicode interface: | ||||||
1552 | use the Encode extension for that. | ||||||
1553 | |||||||
1554 | STRLEN sv_utf8_upgrade(SV *sv)','name' => 'sv_utf8_upgrade'},'dXSARGS' => {'text' => 'Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. | ||||||
1555 | Sets up the C |
||||||
1556 | This is usually handled automatically by C |
||||||
1557 | |||||||
1558 | dXSARGS;','name' => 'dXSARGS'},'savesharedpv' => {'text' => 'A version of C |
||||||
1559 | which is shared between threads. | ||||||
1560 | |||||||
1561 | char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the specified character is a | ||||||
1562 | whitespace character in the platform\'s native character set. This is the same | ||||||
1563 | as what C<\\s> matches in a regular expression. | ||||||
1564 | See the L |
||||||
1565 | C |
||||||
1566 | |||||||
1567 | bool isSPACE(char ch)','name' => 'isSPACE'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C |
||||||
1568 | |||||||
1569 | void Safefree(void* ptr)','name' => 'Safefree'},'custom_op_desc' => {'text' => 'Return the description of a given custom op. This was once used by the | ||||||
1570 | OP_DESC macro, but is no longer: it has only been kept for | ||||||
1571 | compatibility, and should not be used. | ||||||
1572 | |||||||
1573 | const char * custom_op_desc(const OP *o)','name' => 'custom_op_desc'},'regdupe_internal' => {'text' => '','name' => 'regdupe_internal'},'gv_stashpvn' => {'text' => 'Returns a pointer to the stash for a specified package. The C |
||||||
1574 | parameter indicates the length of the C |
||||||
1575 | to C |
||||||
1576 | created if it does not already exist. If the package does not exist and | ||||||
1577 | C |
||||||
1578 | is returned. | ||||||
1579 | |||||||
1580 | |||||||
1581 | HV* gv_stashpvn(const char* name, U32 namelen, | ||||||
1582 | I32 flags)','name' => 'gv_stashpvn'},'vmess' => {'text' => 'C |
||||||
1583 | argument list. These are used to generate a string message. If the | ||||||
1584 | message does not end with a newline, then it will be extended with | ||||||
1585 | some indication of the current location in the code, as described for | ||||||
1586 | L. | ||||||
1587 | |||||||
1588 | Normally, the resulting message is returned in a new mortal SV. | ||||||
1589 | During global destruction a single SV may be shared between uses of | ||||||
1590 | this function. | ||||||
1591 | |||||||
1592 | SV * vmess(const char *pat, va_list *args)','name' => 'vmess'},'to_uni_fold' => {'text' => '','name' => 'to_uni_fold'},'new_collate' => {'text' => '','name' => 'new_collate'},'my_stat' => {'text' => '','name' => 'my_stat'},'my_setenv' => {'text' => '','name' => 'my_setenv'},'newSV_type' => {'text' => 'Creates a new SV, of the type specified. The reference count for the new SV | ||||||
1593 | is set to 1. | ||||||
1594 | |||||||
1595 | SV* newSV_type(const svtype type)','name' => 'newSV_type'},'SvREFCNT_inc_void_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return | ||||||
1596 | value, and you know that I |
||||||
1597 | to return a meaningful value, or check for NULLness, so it\'s smaller | ||||||
1598 | and faster. | ||||||
1599 | |||||||
1600 | void SvREFCNT_inc_void_NN(SV* sv)','name' => 'SvREFCNT_inc_void_NN'},'Perl_signbit' => {'text' => 'Return a non-zero integer if the sign bit on an NV is set, and 0 if | ||||||
1601 | it is not. | ||||||
1602 | |||||||
1603 | If Configure detects this system has a signbit() that will work with | ||||||
1604 | our NVs, then we just use it via the #define in perl.h. Otherwise, | ||||||
1605 | fall back on this implementation. As a first pass, this gets everything | ||||||
1606 | right except -0.0. Alas, catching -0.0 is the main use for this function, | ||||||
1607 | so this is not too helpful yet. Still, at least we have the scaffolding | ||||||
1608 | in place to support other systems, should that prove useful. | ||||||
1609 | |||||||
1610 | |||||||
1611 | Configure notes: This function is called \'Perl_signbit\' instead of a | ||||||
1612 | plain \'signbit\' because it is easy to imagine a system having a signbit() | ||||||
1613 | function or macro that doesn\'t happen to work with our particular choice | ||||||
1614 | of NVs. We shouldn\'t just re-#define signbit as Perl_signbit and expect | ||||||
1615 | the standard system headers to be happy. Also, this is a no-context | ||||||
1616 | function (no pTHX_) because Perl_signbit() is usually re-#defined in | ||||||
1617 | perl.h as a simple macro call to the system\'s signbit(). | ||||||
1618 | Users should just always call Perl_signbit(). | ||||||
1619 | |||||||
1620 | NOTE: this function is experimental and may change or be | ||||||
1621 | removed without notice. | ||||||
1622 | |||||||
1623 | int Perl_signbit(NV f)','name' => 'Perl_signbit'},'PUSH_MULTICALL' => {'text' => 'Opening bracket for a lightweight callback. | ||||||
1624 | See L |
||||||
1625 | |||||||
1626 | PUSH_MULTICALL;','name' => 'PUSH_MULTICALL'},'new_ctype' => {'text' => '','name' => 'new_ctype'},'save_svref' => {'text' => '','name' => 'save_svref'},'to_uni_upper' => {'text' => '','name' => 'to_uni_upper'},'newNULLLIST' => {'text' => 'Constructs, checks, and returns a new C |
||||||
1627 | empty list expression. | ||||||
1628 | |||||||
1629 | OP * newNULLLIST()','name' => 'newNULLLIST'},'is_uni_cntrl_lc' => {'text' => '','name' => 'is_uni_cntrl_lc'},'is_utf8_lower' => {'text' => '','name' => 'is_utf8_lower'},'sv_pos_u2b_flags' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from | ||||||
1630 | the start of the string, to a count of the equivalent number of bytes; if | ||||||
1631 | lenp is non-zero, it does the same to lenp, but this time starting from | ||||||
1632 | the offset, rather than from the start | ||||||
1633 | of the string. Handles type coercion. | ||||||
1634 | I |
||||||
1635 | C |
||||||
1636 | |||||||
1637 | STRLEN sv_pos_u2b_flags(SV *const sv, STRLEN uoffset, | ||||||
1638 | STRLEN *const lenp, U32 flags)','name' => 'sv_pos_u2b_flags'},'init_tm' => {'text' => '','name' => 'init_tm'},'newWHILEOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C |
||||||
1639 | This is a heavyweight loop, with structure that allows exiting the loop | ||||||
1640 | by C |
||||||
1641 | |||||||
1642 | I |
||||||
1643 | loop; if it is null then a suitable op will be constructed automatically. | ||||||
1644 | I |
||||||
1645 | main body of the loop, and I |
||||||
1646 | that operates as a second half of the body. All of these optree inputs | ||||||
1647 | are consumed by this function and become part of the constructed op tree. | ||||||
1648 | |||||||
1649 | I |
||||||
1650 | op and, shifted up eight bits, the eight bits of C |
||||||
1651 | the C |
||||||
1652 | automatically. I |
||||||
1653 | I |
||||||
1654 | loop body to be enclosed in its own scope. | ||||||
1655 | |||||||
1656 | OP * newWHILEOP(I32 flags, I32 debuggable, | ||||||
1657 | LOOP *loop, OP *expr, OP *block, | ||||||
1658 | OP *cont, I32 has_my)','name' => 'newWHILEOP'},'Gv_AMupdate' => {'text' => '','name' => 'Gv_AMupdate'},'filter_del' => {'text' => '','name' => 'filter_del'},'POPp' => {'text' => 'Pops a string off the stack. Deprecated. New code should use POPpx. | ||||||
1659 | |||||||
1660 | char* POPp','name' => 'POPp'},'SvIV_nomg' => {'text' => 'Like C |
||||||
1661 | |||||||
1662 | IV SvIV_nomg(SV* sv)','name' => 'SvIV_nomg'},'RETVAL' => {'text' => 'Variable which is setup by C |
||||||
1663 | XSUB. This is always the proper type for the XSUB. See | ||||||
1664 | L |
||||||
1665 | |||||||
1666 | (whatever) RETVAL','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C |
||||||
1667 | contain an C |
||||||
1668 | |||||||
1669 | SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'newANONLIST' => {'text' => '','name' => 'newANONLIST'},'mg_findext' => {'text' => 'Finds the magic pointer of C |
||||||
1670 | C |
||||||
1671 | |||||||
1672 | MAGIC* mg_findext(const SV* sv, int type, | ||||||
1673 | const MGVTBL *vtbl)','name' => 'mg_findext'},'my_memset' => {'text' => '','name' => 'my_memset'},'my_atof2' => {'text' => '','name' => 'my_atof2'},'PerlIO_get_ptr' => {'text' => '','name' => 'PerlIO_get_ptr'},'save_destructor' => {'text' => '','name' => 'save_destructor'},'sv_cmp_flags' => {'text' => 'Compares the strings in two SVs. Returns -1, 0, or 1 indicating whether the | ||||||
1674 | string in C |
||||||
1675 | C |
||||||
1676 | if necessary. If the flags include SV_GMAGIC, it handles get magic. See | ||||||
1677 | also C |
||||||
1678 | |||||||
1679 | I32 sv_cmp_flags(SV *const sv1, SV *const sv2, | ||||||
1680 | const U32 flags)','name' => 'sv_cmp_flags'},'hv_iternextsv' => {'text' => 'Performs an C |
||||||
1681 | operation. | ||||||
1682 | |||||||
1683 | SV* hv_iternextsv(HV *hv, char **key, I32 *retlen)','name' => 'hv_iternextsv'},'lex_read_to' => {'text' => 'Consume text in the lexer buffer, from Lbufptr> up | ||||||
1684 | to I |
||||||
1685 | performing the correct bookkeeping whenever a newline character is passed. | ||||||
1686 | This is the normal way to consume lexed text. | ||||||
1687 | |||||||
1688 | Interpretation of the buffer\'s octets can be abstracted out by | ||||||
1689 | using the slightly higher-level functions L and | ||||||
1690 | L. | ||||||
1691 | |||||||
1692 | NOTE: this function is experimental and may change or be | ||||||
1693 | removed without notice. | ||||||
1694 | |||||||
1695 | void lex_read_to(char *ptr)','name' => 'lex_read_to'},'sv_pvbyten_force' => {'text' => 'The backend for the C |
||||||
1696 | instead. | ||||||
1697 | |||||||
1698 | char* sv_pvbyten_force(SV *const sv, STRLEN *const lp)','name' => 'sv_pvbyten_force'},'reg_named_buff_fetch' => {'text' => '','name' => 'reg_named_buff_fetch'},'ibcmp_locale' => {'text' => 'This is a synonym for (! foldEQ_locale()) | ||||||
1699 | |||||||
1700 | I32 ibcmp_locale(const char* a, const char* b, | ||||||
1701 | I32 len)','name' => 'ibcmp_locale'},'XST_mIV' => {'text' => 'Place an integer into the specified position C |
||||||
1702 | value is stored in a new mortal SV. | ||||||
1703 | |||||||
1704 | void XST_mIV(int pos, IV iv)','name' => 'XST_mIV'},'save_pptr' => {'text' => '','name' => 'save_pptr'},'PerlIO_set_ptrcnt' => {'text' => '','name' => 'PerlIO_set_ptrcnt'},'mPUSHs' => {'text' => 'Push an SV onto the stack and mortalizes the SV. The stack must have room | ||||||
1705 | for this element. Does not use C |
||||||
1706 | |||||||
1707 | void mPUSHs(SV* sv)','name' => 'mPUSHs'},'dump_packsubs' => {'text' => '','name' => 'dump_packsubs'},'is_utf8_digit' => {'text' => '','name' => 'is_utf8_digit'},'GvSV' => {'text' => 'Return the SV from the GV. | ||||||
1708 | |||||||
1709 | SV* GvSV(GV* gv)','name' => 'GvSV'},'init_i18nl10n' => {'text' => '','name' => 'init_i18nl10n'},'vform' => {'text' => '','name' => 'vform'},'get_op_descs' => {'text' => '','name' => 'get_op_descs'},'safesyscalloc' => {'text' => '','name' => 'safesyscalloc'},'PL_curpad' => {'text' => 'Points directly to the body of the L array. | ||||||
1710 | (I.e., this is C |
||||||
1711 | |||||||
1712 | NOTE: this function is experimental and may change or be | ||||||
1713 | removed without notice.','name' => 'PL_curpad'},'POPi' => {'text' => 'Pops an integer off the stack. | ||||||
1714 | |||||||
1715 | IV POPi','name' => 'POPi'},'parse_stmtseq' => {'text' => 'Parse a sequence of zero or more Perl statements. These may be normal | ||||||
1716 | imperative statements, including optional labels, or declarations | ||||||
1717 | that have compile-time effect, or any mixture thereof. The statement | ||||||
1718 | sequence ends when a closing brace or end-of-file is encountered in a | ||||||
1719 | place where a new statement could have validly started. It is up to | ||||||
1720 | the caller to ensure that the dynamic parser state (L et al) | ||||||
1721 | is correctly set to reflect the source of the code to be parsed and the | ||||||
1722 | lexical context for the statements. | ||||||
1723 | |||||||
1724 | The op tree representing the statement sequence is returned. This may | ||||||
1725 | be a null pointer if the statements were all null, for example if there | ||||||
1726 | were no statements or if there were only subroutine definitions (which | ||||||
1727 | have compile-time side effects). If not null, it will be a C |
||||||
1728 | list, normally including C |
||||||
1729 | |||||||
1730 | If an error occurs in parsing or compilation, in most cases a valid op | ||||||
1731 | tree is returned anyway. The error is reflected in the parser state, | ||||||
1732 | normally resulting in a single exception at the top level of parsing | ||||||
1733 | which covers all the compilation errors that occurred. Some compilation | ||||||
1734 | errors, however, will throw an exception immediately. | ||||||
1735 | |||||||
1736 | The I |
||||||
1737 | be zero. | ||||||
1738 | |||||||
1739 | NOTE: this function is experimental and may change or be | ||||||
1740 | removed without notice. | ||||||
1741 | |||||||
1742 | OP * parse_stmtseq(U32 flags)','name' => 'parse_stmtseq'},'sv_2pvutf8_nolen' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV. | ||||||
1743 | May cause the SV to be upgraded to UTF-8 as a side-effect. | ||||||
1744 | |||||||
1745 | Usually accessed via the C |
||||||
1746 | |||||||
1747 | char* sv_2pvutf8_nolen(SV* sv)','name' => 'sv_2pvutf8_nolen'},'gv_HVadd' => {'text' => '','name' => 'gv_HVadd'},'custom_op_xop' => {'text' => 'Return the XOP structure for a given custom op. This function should be | ||||||
1748 | considered internal to OP_NAME and the other access macros: use them instead. | ||||||
1749 | |||||||
1750 | NOTE: this function must be explicitly called as Perl_custom_op_xop with an aTHX_ parameter. | ||||||
1751 | |||||||
1752 | const XOP * Perl_custom_op_xop(pTHX_ const OP *o)','name' => 'custom_op_xop'},'mro_get_linear_isa' => {'text' => 'Returns the mro linearisation for the given stash. By default, this | ||||||
1753 | will be whatever C |
||||||
1754 | other MRO is in effect for the stash. The return value is a | ||||||
1755 | read-only AV*. | ||||||
1756 | |||||||
1757 | You are responsible for C |
||||||
1758 | return value if you plan to store it anywhere | ||||||
1759 | semi-permanently (otherwise it might be deleted | ||||||
1760 | out from under you the next time the cache is | ||||||
1761 | invalidated). | ||||||
1762 | |||||||
1763 | AV* mro_get_linear_isa(HV* stash)','name' => 'mro_get_linear_isa'},'SvPVbytex' => {'text' => 'Like C |
||||||
1764 | Guarantees to evaluate sv only once; use the more efficient C |
||||||
1765 | otherwise. | ||||||
1766 | |||||||
1767 | char* SvPVbytex(SV* sv, STRLEN len)','name' => 'SvPVbytex'},'av_store' => {'text' => 'Stores an SV in an array. The array index is specified as C |
||||||
1768 | return value will be NULL if the operation failed or if the value did not | ||||||
1769 | need to be actually stored within the array (as in the case of tied | ||||||
1770 | arrays). Otherwise, it can be dereferenced | ||||||
1771 | to get the C |
||||||
1772 | there (= C |
||||||
1773 | |||||||
1774 | Note that the caller is responsible for suitably incrementing the reference | ||||||
1775 | count of C |
||||||
1776 | returned NULL. | ||||||
1777 | |||||||
1778 | Approximate Perl equivalent: C<$myarray[$key] = $val;>. | ||||||
1779 | |||||||
1780 | See L |
||||||
1781 | more information on how to use this function on tied arrays. | ||||||
1782 | |||||||
1783 | SV** av_store(AV *av, I32 key, SV *val)','name' => 'av_store'},'reg_named_buff_scalar' => {'text' => '','name' => 'reg_named_buff_scalar'},'unlnk' => {'text' => '','name' => 'unlnk'},'av_fetch' => {'text' => 'Returns the SV at the specified index in the array. The C |
||||||
1784 | index. If lval is true, you are guaranteed to get a real SV back (in case | ||||||
1785 | it wasn\'t real before), which you can then modify. Check that the return | ||||||
1786 | value is non-null before dereferencing it to a C |
||||||
1787 | |||||||
1788 | See L |
||||||
1789 | more information on how to use this function on tied arrays. | ||||||
1790 | |||||||
1791 | The rough perl equivalent is C<$myarray[$idx]>. | ||||||
1792 | |||||||
1793 | SV** av_fetch(AV *av, I32 key, I32 lval)','name' => 'av_fetch'},'SvNOK_only' => {'text' => 'Tells an SV that it is a double and disables all other OK bits. | ||||||
1794 | |||||||
1795 | void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See | ||||||
1796 | C |
||||||
1797 | |||||||
1798 | SV* hv_iterval(HV *hv, HE *entry)','name' => 'hv_iterval'},'is_uni_xdigit_lc' => {'text' => '','name' => 'is_uni_xdigit_lc'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. | ||||||
1799 | |||||||
1800 | const char* sv_reftype(const SV *const sv, const int ob)','name' => 'sv_reftype'},'foldEQ_locale' => {'text' => 'Returns true if the leading len bytes of the strings s1 and s2 are the same | ||||||
1801 | case-insensitively in the current locale; false otherwise. | ||||||
1802 | |||||||
1803 | I32 foldEQ_locale(const char* a, const char* b, | ||||||
1804 | I32 len)','name' => 'foldEQ_locale'},'cophh_2hv' => {'text' => 'Generates and returns a standard Perl hash representing the full set of | ||||||
1805 | key/value pairs in the cop hints hash I |
||||||
1806 | unused and must be zero. | ||||||
1807 | |||||||
1808 | NOTE: this function is experimental and may change or be | ||||||
1809 | removed without notice. | ||||||
1810 | |||||||
1811 | HV * cophh_2hv(const COPHH *cophh, U32 flags)','name' => 'cophh_2hv'},'SvREFCNT_inc_simple_void_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the return | ||||||
1812 | value, and you know that I |
||||||
1813 | to return a meaningful value, or check for NULLness, so it\'s smaller | ||||||
1814 | and faster. | ||||||
1815 | |||||||
1816 | void SvREFCNT_inc_simple_void_NN(SV* sv)','name' => 'SvREFCNT_inc_simple_void_NN'},'rsignal_state' => {'text' => '','name' => 'rsignal_state'},'av_len' => {'text' => 'Returns the highest index in the array. The number of elements in the | ||||||
1817 | array is C |
||||||
1818 | |||||||
1819 | The Perl equivalent for this is C<$#myarray>. | ||||||
1820 | |||||||
1821 | I32 av_len(AV *av)','name' => 'av_len'},'sv_unmagic' => {'text' => 'Removes all magic of type C |
||||||
1822 | |||||||
1823 | int sv_unmagic(SV *const sv, const int type)','name' => 'sv_unmagic'},'SvTAINT' => {'text' => 'Taints an SV if tainting is enabled, and if some input to the current | ||||||
1824 | expression is tainted--usually a variable, but possibly also implicit | ||||||
1825 | inputs such as locale settings. C |
||||||
1826 | the outputs of an expression in a pessimistic fashion; i.e., without paying | ||||||
1827 | attention to precisely which outputs are influenced by which inputs. | ||||||
1828 | |||||||
1829 | void SvTAINT(SV* sv)','name' => 'SvTAINT'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C |
||||||
1830 | |||||||
1831 | int mg_clear(SV* sv)','name' => 'mg_clear'},'my_sprintf' => {'text' => 'The C library C |
||||||
1832 | the length of the string written to the buffer. Only rare pre-ANSI systems | ||||||
1833 | need the wrapper function - usually this is a direct call to C |
||||||
1834 | |||||||
1835 | int my_sprintf(char *buffer, const char *pat, ...)','name' => 'my_sprintf'},'to_utf8_fold' => {'text' => 'Convert the UTF-8 encoded character at C to its foldcase version and |
||||||
1836 | store that in UTF-8 in C |
||||||
1837 | that the C |
||||||
1838 | foldcase version may be longer than the original character (up to | ||||||
1839 | three characters). | ||||||
1840 | |||||||
1841 | The first character of the foldcased version is returned | ||||||
1842 | (but note, as explained above, that there may be more.) | ||||||
1843 | |||||||
1844 | The character at C is assumed by this routine to be well-formed. |
||||||
1845 | |||||||
1846 | UV to_utf8_fold(const U8 *p, U8* ustrp, | ||||||
1847 | STRLEN *lenp)','name' => 'to_utf8_fold'},'regfree_internal' => {'text' => '','name' => 'regfree_internal'},'gv_stashpv' => {'text' => 'Returns a pointer to the stash for a specified package. Uses C |
||||||
1848 | determine the length of C |
||||||
1849 | |||||||
1850 | HV* gv_stashpv(const char* name, I32 flags)','name' => 'gv_stashpv'},'sv_cmp_locale_flags' => {'text' => 'Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and | ||||||
1851 | \'use bytes\' aware and will coerce its args to strings if necessary. If the | ||||||
1852 | flags contain SV_GMAGIC, it handles get magic. See also C |
||||||
1853 | |||||||
1854 | I32 sv_cmp_locale_flags(SV *const sv1, | ||||||
1855 | SV *const sv2, | ||||||
1856 | const U32 flags)','name' => 'sv_cmp_locale_flags'},'sv_vcatpvf_mg' => {'text' => 'Like C |
||||||
1857 | |||||||
1858 | Usually used via its frontend C |
||||||
1859 | |||||||
1860 | void sv_vcatpvf_mg(SV *const sv, | ||||||
1861 | const char *const pat, | ||||||
1862 | va_list *const args)','name' => 'sv_vcatpvf_mg'},'mXPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. | ||||||
1863 | Does not use C |
||||||
1864 | |||||||
1865 | void mXPUSHu(UV uv)','name' => 'mXPUSHu'},'hv_exists_ent' => {'text' => 'Returns a boolean indicating whether | ||||||
1866 | the specified hash key exists. C |
||||||
1867 | can be a valid precomputed hash value, or 0 to ask for it to be | ||||||
1868 | computed. | ||||||
1869 | |||||||
1870 | bool hv_exists_ent(HV *hv, SV *keysv, U32 hash)','name' => 'hv_exists_ent'},'PL_comppad' => {'text' => 'During compilation, this points to the array containing the values | ||||||
1871 | part of the pad for the currently-compiling code. (At runtime a CV may | ||||||
1872 | have many such value arrays; at compile time just one is constructed.) | ||||||
1873 | At runtime, this points to the array containing the currently-relevant | ||||||
1874 | values for the pad for the currently-executing code. | ||||||
1875 | |||||||
1876 | NOTE: this function is experimental and may change or be | ||||||
1877 | removed without notice.','name' => 'PL_comppad'},'atfork_unlock' => {'text' => '','name' => 'atfork_unlock'},'SvNIOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a number, integer or | ||||||
1878 | double. | ||||||
1879 | |||||||
1880 | U32 SvNIOK(SV* sv)','name' => 'SvNIOK'},'save_long' => {'text' => '','name' => 'save_long'},'mro_method_changed_in' => {'text' => 'Invalidates method caching on any child classes | ||||||
1881 | of the given stash, so that they might notice | ||||||
1882 | the changes in this one. | ||||||
1883 | |||||||
1884 | Ideally, all instances of C |
||||||
1885 | perl source outside of F |
||||||
1886 | replaced by calls to this. | ||||||
1887 | |||||||
1888 | Perl automatically handles most of the common | ||||||
1889 | ways a method might be redefined. However, there | ||||||
1890 | are a few ways you could change a method in a stash | ||||||
1891 | without the cache code noticing, in which case you | ||||||
1892 | need to call this method afterwards: | ||||||
1893 | |||||||
1894 | 1) Directly manipulating the stash HV entries from | ||||||
1895 | XS code. | ||||||
1896 | |||||||
1897 | 2) Assigning a reference to a readonly scalar | ||||||
1898 | constant into a stash entry in order to create | ||||||
1899 | a constant subroutine (like constant.pm | ||||||
1900 | does). | ||||||
1901 | |||||||
1902 | This same method is available from pure perl | ||||||
1903 | via, C |
||||||
1904 | |||||||
1905 | void mro_method_changed_in(HV* stash)','name' => 'mro_method_changed_in'},'unpack_str' => {'text' => 'The engine implementing unpack() Perl function. Note: parameters strbeg, new_s | ||||||
1906 | and ocnt are not used. This call should not be used, use unpackstring instead. | ||||||
1907 | |||||||
1908 | I32 unpack_str(const char *pat, const char *patend, | ||||||
1909 | const char *s, const char *strbeg, | ||||||
1910 | const char *strend, char **new_s, | ||||||
1911 | I32 ocnt, U32 flags)','name' => 'unpack_str'},'my_fflush_all' => {'text' => '','name' => 'my_fflush_all'},'is_uni_print' => {'text' => '','name' => 'is_uni_print'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C |
||||||
1912 | instead. | ||||||
1913 | |||||||
1914 | SV* sv_newref(SV *const sv)','name' => 'sv_newref'},'cop_hints_fetch_pv' => {'text' => 'Like L, but takes a nul-terminated string instead | ||||||
1915 | of a string/length pair. | ||||||
1916 | |||||||
1917 | SV * cop_hints_fetch_pv(const COP *cop, | ||||||
1918 | const char *key, U32 hash, | ||||||
1919 | U32 flags)','name' => 'cop_hints_fetch_pv'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C |
||||||
1920 | |||||||
1921 | void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'sv_uni_display' => {'text' => 'Build to the scalar C |
||||||
1922 | the displayable version being at most C |
||||||
1923 | (if longer, the rest is truncated and "..." will be appended). | ||||||
1924 | |||||||
1925 | The C |
||||||
1926 | |||||||
1927 | The pointer to the PV of the C |
||||||
1928 | |||||||
1929 | char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim, | ||||||
1930 | UV flags)','name' => 'sv_uni_display'},'sv_unmagicext' => {'text' => 'Removes all magic of type C |
||||||
1931 | |||||||
1932 | int sv_unmagicext(SV *const sv, const int type, | ||||||
1933 | MGVTBL *vtbl)','name' => 'sv_unmagicext'},'newSVpvs' => {'text' => 'Like C |
||||||
1934 | |||||||
1935 | SV* newSVpvs(const char* s)','name' => 'newSVpvs'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. | ||||||
1936 | |||||||
1937 | void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'realloc' => {'text' => '','name' => 'realloc'},'POPs' => {'text' => 'Pops an SV off the stack. | ||||||
1938 | |||||||
1939 | SV* POPs','name' => 'POPs'},'packlist' => {'text' => 'The engine implementing pack() Perl function. | ||||||
1940 | |||||||
1941 | void packlist(SV *cat, const char *pat, | ||||||
1942 | const char *patend, SV **beglist, | ||||||
1943 | SV **endlist)','name' => 'packlist'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C |
||||||
1944 | which guarantees to evaluate sv only once. | ||||||
1945 | |||||||
1946 | NV SvNV(SV* sv)','name' => 'SvNV'},'SvUTF8' => {'text' => 'Returns a U32 value indicating the UTF-8 status of an SV. If things are set-up | ||||||
1947 | properly, this indicates whether or not the SV contains UTF-8 encoded data. | ||||||
1948 | Call this after SvPV() in case any call to string overloading updates the | ||||||
1949 | internal flag. | ||||||
1950 | |||||||
1951 | U32 SvUTF8(SV* sv)','name' => 'SvUTF8'},'gv_fetchmethod_autoload' => {'text' => 'Returns the glob which contains the subroutine to call to invoke the method | ||||||
1952 | on the C |
||||||
1953 | glob for "AUTOLOAD". In this case the corresponding variable $AUTOLOAD is | ||||||
1954 | already setup. | ||||||
1955 | |||||||
1956 | The third parameter of C |
||||||
1957 | AUTOLOAD lookup is performed if the given method is not present: non-zero | ||||||
1958 | means yes, look for AUTOLOAD; zero means no, don\'t look for AUTOLOAD. | ||||||
1959 | Calling C |
||||||
1960 | with a non-zero C |
||||||
1961 | |||||||
1962 | These functions grant C<"SUPER"> token as a prefix of the method name. Note | ||||||
1963 | that if you want to keep the returned glob for a long time, you need to | ||||||
1964 | check for it being "AUTOLOAD", since at the later time the call may load a | ||||||
1965 | different subroutine due to $AUTOLOAD changing its value. Use the glob | ||||||
1966 | created via a side effect to do this. | ||||||
1967 | |||||||
1968 | These functions have the same side-effects and as C |
||||||
1969 | C |
||||||
1970 | \'\'>. The warning against passing the GV returned by C |
||||||
1971 | C |
||||||
1972 | |||||||
1973 | GV* gv_fetchmethod_autoload(HV* stash, | ||||||
1974 | const char* name, | ||||||
1975 | I32 autoload)','name' => 'gv_fetchmethod_autoload'},'op_dump' => {'text' => '','name' => 'op_dump'},'get_mstats' => {'text' => '','name' => 'get_mstats'},'savestack_grow' => {'text' => '','name' => 'savestack_grow'},'debstackptrs' => {'text' => '','name' => 'debstackptrs'},'sv_eq' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are | ||||||
1976 | identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will | ||||||
1977 | coerce its args to strings if necessary. | ||||||
1978 | |||||||
1979 | 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 | ||||||
1980 | not. | ||||||
1981 | |||||||
1982 | bool SvTAINTED(SV* sv)','name' => 'SvTAINTED'},'ptr_table_store' => {'text' => '','name' => 'ptr_table_store'},'cv_undef' => {'text' => 'Clear out all the active components of a CV. This can happen either | ||||||
1983 | by an explicit C |
||||||
1984 | In the former case, we keep the CvOUTSIDE pointer, so that any anonymous | ||||||
1985 | children can still follow the full lexical scope chain. | ||||||
1986 | |||||||
1987 | void cv_undef(CV* cv)','name' => 'cv_undef'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. | ||||||
1988 | |||||||
1989 | void StructCopy(type src, type dest, type)','name' => 'StructCopy'},'sv_catpvf_nocontext' => {'text' => '','name' => 'sv_catpvf_nocontext'},'save_padsv_and_mortalize' => {'text' => '','name' => 'save_padsv_and_mortalize'},'gv_autoload_sv' => {'text' => '','name' => 'gv_autoload_sv'},'cophh_delete_pvs' => {'text' => 'Like L, but takes a literal string instead of a | ||||||
1990 | string/length pair, and no precomputed hash. | ||||||
1991 | |||||||
1992 | NOTE: this function is experimental and may change or be | ||||||
1993 | removed without notice. | ||||||
1994 | |||||||
1995 | COPHH * cophh_delete_pvs(const COPHH *cophh, | ||||||
1996 | const char *key, U32 flags)','name' => 'cophh_delete_pvs'},'get_cvn_flags' => {'text' => 'Returns the CV of the specified Perl subroutine. C |
||||||
1997 | C |
||||||
1998 | exist then it will be declared (which has the same effect as saying | ||||||
1999 | C). If C |
||||||
2000 | then NULL is returned. | ||||||
2001 | |||||||
2002 | NOTE: the perl_ form of this function is deprecated. | ||||||
2003 | |||||||
2004 | CV* get_cvn_flags(const char* name, STRLEN len, | ||||||
2005 | I32 flags)','name' => 'get_cvn_flags'},'XopENTRY_set' => {'text' => 'Set a member of the XOP structure. I |
||||||
2006 | which entry to set. See L |
||||||
2007 | the available members and how they are used. | ||||||
2008 | |||||||
2009 | void XopENTRY_set(XOP *xop, which, value)','name' => 'XopENTRY_set'},'reentrant_free' => {'text' => '','name' => 'reentrant_free'},'items' => {'text' => 'Variable which is setup by C |
||||||
2010 | items on the stack. See L |
||||||
2011 | |||||||
2012 | I32 items','name' => 'items'},'XST_mPV' => {'text' => 'Place a copy of a string into the specified position C |
||||||
2013 | The value is stored in a new mortal SV. | ||||||
2014 | |||||||
2015 | void XST_mPV(int pos, char* str)','name' => 'XST_mPV'},'dump_vindent' => {'text' => '','name' => 'dump_vindent'},'SvPVx' => {'text' => 'A version of C |
||||||
2016 | Only use this if C |
||||||
2017 | more efficient C |
||||||
2018 | |||||||
2019 | char* SvPVx(SV* sv, STRLEN len)','name' => 'SvPVx'},'dump_form' => {'text' => '','name' => 'dump_form'},'sv_grow' => {'text' => 'Expands the character buffer in the SV. If necessary, uses C |
||||||
2020 | upgrades the SV to C |
||||||
2021 | Use the C |
||||||
2022 | |||||||
2023 | char* sv_grow(SV *const sv, STRLEN newlen)','name' => 'sv_grow'},'vnormal' => {'text' => 'Accepts a version object and returns the normalized string | ||||||
2024 | representation. Call like: | ||||||
2025 | |||||||
2026 | sv = vnormal(rv); | ||||||
2027 | |||||||
2028 | NOTE: you can pass either the object directly or the SV | ||||||
2029 | contained within the RV. | ||||||
2030 | |||||||
2031 | The SV returned has a refcount of 1. | ||||||
2032 | |||||||
2033 | SV* vnormal(SV *vs)','name' => 'vnormal'},'filter_add' => {'text' => '','name' => 'filter_add'},'newPVOP' => {'text' => 'Constructs, checks, and returns an op of any type that involves an | ||||||
2034 | embedded C-level pointer (PV). I |
||||||
2035 | the eight bits of C |
||||||
2036 | must have been allocated using L; the memory will | ||||||
2037 | be freed when the op is destroyed. | ||||||
2038 | |||||||
2039 | OP * newPVOP(I32 type, I32 flags, char *pv)','name' => 'newPVOP'},'XPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary. Does not | ||||||
2040 | handle \'set\' magic. Does not use C |
||||||
2041 | C |
||||||
2042 | |||||||
2043 | void XPUSHs(SV* sv)','name' => 'XPUSHs'},'is_uni_graph_lc' => {'text' => '','name' => 'is_uni_graph_lc'},'is_utf8_alnum' => {'text' => '','name' => 'is_utf8_alnum'},'set_numeric_radix' => {'text' => '','name' => 'set_numeric_radix'},'is_utf8_upper' => {'text' => '','name' => 'is_utf8_upper'},'newIO' => {'text' => '','name' => 'newIO'},'do_join' => {'text' => '','name' => 'do_join'},'save_helem' => {'text' => '','name' => 'save_helem'},'die' => {'text' => 'Behaves the same as L, except for the return type. | ||||||
2044 | It should be used only where the C |
||||||
2045 | The function never actually returns. | ||||||
2046 | |||||||
2047 | OP * die(const char *pat, ...)','name' => 'die'},'sv_usepvn' => {'text' => 'Tells an SV to use C |
||||||
2048 | calling C |
||||||
2049 | magic. See C |
||||||
2050 | |||||||
2051 | void sv_usepvn(SV* sv, char* ptr, STRLEN len)','name' => 'sv_usepvn'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. | ||||||
2052 | |||||||
2053 | U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'newCONSTSUB_flags' => {'text' => 'Creates a constant sub equivalent to Perl C which is | ||||||
2054 | eligible for inlining at compile-time. | ||||||
2055 | |||||||
2056 | Currently, the only useful value for C |
||||||
2057 | |||||||
2058 | Passing NULL for SV creates a constant sub equivalent to C, | ||||||
2059 | which won\'t be called if used as a destructor, but will suppress the overhead | ||||||
2060 | of a call to C |
||||||
2061 | compile time.) | ||||||
2062 | |||||||
2063 | CV* newCONSTSUB_flags(HV* stash, const char* name, | ||||||
2064 | STRLEN len, U32 flags, SV* sv)','name' => 'newCONSTSUB_flags'},'swash_init' => {'text' => '','name' => 'swash_init'},'newANONSUB' => {'text' => '','name' => 'newANONSUB'},'warn' => {'text' => 'This is an XS interface to Perl\'s C |
||||||
2065 | |||||||
2066 | Take a sprintf-style format pattern and argument list. These are used to | ||||||
2067 | generate a string message. If the message does not end with a newline, | ||||||
2068 | then it will be extended with some indication of the current location | ||||||
2069 | in the code, as described for L. | ||||||
2070 | |||||||
2071 | The error message or object will by default be written to standard error, | ||||||
2072 | but this is subject to modification by a C<$SIG{__WARN__}> handler. | ||||||
2073 | |||||||
2074 | Unlike with L, C |
||||||
2075 | |||||||
2076 | void warn(const char *pat, ...)','name' => 'warn'},'PerlIO_get_bufsiz' => {'text' => '','name' => 'PerlIO_get_bufsiz'},'to_uni_title_lc' => {'text' => '','name' => 'to_uni_title_lc'},'fp_dup' => {'text' => '','name' => 'fp_dup'},'hek_dup' => {'text' => '','name' => 'hek_dup'},'pmop_dump' => {'text' => '','name' => 'pmop_dump'},'newANONATTRSUB' => {'text' => '','name' => 'newANONATTRSUB'},'CvPADLIST' => {'text' => 'CV\'s can have CvPADLIST(cv) set to point to an AV. This is the CV\'s | ||||||
2077 | scratchpad, which stores lexical variables and opcode temporary and | ||||||
2078 | per-thread values. | ||||||
2079 | |||||||
2080 | For these purposes "forms" are a kind-of CV, eval""s are too (except they\'re | ||||||
2081 | not callable at will and are always thrown away after the eval"" is done | ||||||
2082 | executing). Require\'d files are simply evals without any outer lexical | ||||||
2083 | scope. | ||||||
2084 | |||||||
2085 | XSUBs don\'t have CvPADLIST set - dXSTARG fetches values from PL_curpad, | ||||||
2086 | but that is really the callers pad (a slot of which is allocated by | ||||||
2087 | every entersub). | ||||||
2088 | |||||||
2089 | The CvPADLIST AV has the REFCNT of its component items managed "manually" | ||||||
2090 | (mostly in pad.c) rather than by normal av.c rules. So we turn off AvREAL | ||||||
2091 | just before freeing it, to let av.c know not to touch the entries. | ||||||
2092 | The items in the AV are not SVs as for a normal AV, but other AVs: | ||||||
2093 | |||||||
2094 | 0\'th Entry of the CvPADLIST is an AV which represents the "names" or rather | ||||||
2095 | the "static type information" for lexicals. | ||||||
2096 | |||||||
2097 | The CvDEPTH\'th entry of CvPADLIST AV is an AV which is the stack frame at that | ||||||
2098 | depth of recursion into the CV. | ||||||
2099 | The 0\'th slot of a frame AV is an AV which is @_. | ||||||
2100 | other entries are storage for variables and op targets. | ||||||
2101 | |||||||
2102 | Iterating over the names AV iterates over all possible pad | ||||||
2103 | items. Pad slots that are SVs_PADTMP (targets/GVs/constants) end up having | ||||||
2104 | &PL_sv_undef "names" (see pad_alloc()). | ||||||
2105 | |||||||
2106 | Only my/our variable (SVs_PADMY/SVs_PADOUR) slots get valid names. | ||||||
2107 | The rest are op targets/GVs/constants which are statically allocated | ||||||
2108 | or resolved at compile time. These don\'t have names by which they | ||||||
2109 | can be looked up from Perl code at run time through eval"" like | ||||||
2110 | my/our variables can be. Since they can\'t be looked up by "name" | ||||||
2111 | but only by their index allocated at compile time (which is usually | ||||||
2112 | in PL_op->op_targ), wasting a name SV for them doesn\'t make sense. | ||||||
2113 | |||||||
2114 | The SVs in the names AV have their PV being the name of the variable. | ||||||
2115 | xlow+1..xhigh inclusive in the NV union is a range of cop_seq numbers for | ||||||
2116 | which the name is valid (accessed through the macros COP_SEQ_RANGE_LOW and | ||||||
2117 | _HIGH). During compilation, these fields may hold the special value | ||||||
2118 | PERL_PADSEQ_INTRO to indicate various stages: | ||||||
2119 | |||||||
2120 | COP_SEQ_RANGE_LOW _HIGH | ||||||
2121 | ----------------- ----- | ||||||
2122 | PERL_PADSEQ_INTRO 0 variable not yet introduced: { my ($x | ||||||
2123 | valid-seq# PERL_PADSEQ_INTRO variable in scope: { my ($x) | ||||||
2124 | valid-seq# valid-seq# compilation of scope complete: { my ($x) } | ||||||
2125 | |||||||
2126 | For typed lexicals name SV is SVt_PVMG and SvSTASH | ||||||
2127 | points at the type. For C |
||||||
2128 | SvOURSTASH slot pointing at the stash of the associated global (so that | ||||||
2129 | duplicate C |
||||||
2130 | sometimes hijacked to store the generation number during compilation. | ||||||
2131 | |||||||
2132 | If SvFAKE is set on the name SV, then that slot in the frame AV is | ||||||
2133 | a REFCNT\'ed reference to a lexical from "outside". In this case, | ||||||
2134 | the name SV does not use xlow and xhigh to store a cop_seq range, since it is | ||||||
2135 | in scope throughout. Instead xhigh stores some flags containing info about | ||||||
2136 | the real lexical (is it declared in an anon, and is it capable of being | ||||||
2137 | instantiated multiple times?), and for fake ANONs, xlow contains the index | ||||||
2138 | within the parent\'s pad where the lexical\'s value is stored, to make | ||||||
2139 | cloning quicker. | ||||||
2140 | |||||||
2141 | If the \'name\' is \'&\' the corresponding entry in frame AV | ||||||
2142 | is a CV representing a possible closure. | ||||||
2143 | (SvFAKE and name of \'&\' is not a meaningful combination currently but could | ||||||
2144 | become so if C |
||||||
2145 | |||||||
2146 | Note that formats are treated as anon subs, and are cloned each time | ||||||
2147 | write is called (if necessary). | ||||||
2148 | |||||||
2149 | The flag SVs_PADSTALE is cleared on lexicals each time the my() is executed, | ||||||
2150 | and set on scope exit. This allows the \'Variable $x is not available\' warning | ||||||
2151 | to be generated in evals, such as | ||||||
2152 | |||||||
2153 | { my $x = 1; sub f { eval \'$x\'} } f(); | ||||||
2154 | |||||||
2155 | For state vars, SVs_PADSTALE is overloaded to mean \'not yet initialised\' | ||||||
2156 | |||||||
2157 | NOTE: this function is experimental and may change or be | ||||||
2158 | removed without notice. | ||||||
2159 | |||||||
2160 | PADLIST * CvPADLIST(CV *cv)','name' => 'CvPADLIST'},'HvNAMEUTF8' => {'text' => 'Returns true if the name is in UTF8 encoding. | ||||||
2161 | |||||||
2162 | unsigned char HvNAMEUTF8(HV *stash)','name' => 'HvNAMEUTF8'},'sv_catpvf_mg_nocontext' => {'text' => '','name' => 'sv_catpvf_mg_nocontext'},'reg_named_buff_all' => {'text' => '','name' => 'reg_named_buff_all'},'PerlIO_close' => {'text' => '','name' => 'PerlIO_close'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once | ||||||
2163 | used, guarantees that there is room for at least C |
||||||
2164 | onto the stack. | ||||||
2165 | |||||||
2166 | void EXTEND(SP, int nitems)','name' => 'EXTEND'},'newOP' => {'text' => 'Constructs, checks, and returns an op of any base type (any type that | ||||||
2167 | has no extra fields). I |
||||||
2168 | eight bits of C |
||||||
2169 | of C |
||||||
2170 | |||||||
2171 | OP * newOP(I32 type, I32 flags)','name' => 'newOP'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. | ||||||
2172 | The reference count for the SV is set to 1. | ||||||
2173 | |||||||
2174 | SV* newSVuv(const UV u)','name' => 'newSVuv'},'gv_fetchmeth' => {'text' => 'Like L, but lacks a flags parameter. | ||||||
2175 | |||||||
2176 | GV* gv_fetchmeth(HV* stash, const char* name, | ||||||
2177 | STRLEN len, I32 level)','name' => 'gv_fetchmeth'},'op_refcnt_lock' => {'text' => '','name' => 'op_refcnt_lock'},'gv_fetchmeth_pvn_autoload' => {'text' => 'Same as gv_fetchmeth_pvn(), but looks for autoloaded subroutines too. | ||||||
2178 | Returns a glob for the subroutine. | ||||||
2179 | |||||||
2180 | For an autoloaded subroutine without a GV, will create a GV even | ||||||
2181 | if C |
||||||
2182 | of the result may be zero. | ||||||
2183 | |||||||
2184 | Currently, the only significant value for C |
||||||
2185 | |||||||
2186 | GV* gv_fetchmeth_pvn_autoload(HV* stash, | ||||||
2187 | const char* name, | ||||||
2188 | STRLEN len, I32 level, | ||||||
2189 | U32 flags)','name' => 'gv_fetchmeth_pvn_autoload'},'newGVgen' => {'text' => '','name' => 'newGVgen'},'sv_does' => {'text' => 'Like L, but doesn\'t take a C |
||||||
2190 | |||||||
2191 | bool sv_does(SV* sv, const char *const name)','name' => 'sv_does'},'delimcpy' => {'text' => '','name' => 'delimcpy'},'newLOOPOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a loop. This is | ||||||
2192 | only a loop in the control flow through the op tree; it does not have | ||||||
2193 | the heavyweight loop structure that allows exiting the loop by C |
||||||
2194 | and suchlike. I |
||||||
2195 | top-level op, except that some bits will be set automatically as required. | ||||||
2196 | I |
||||||
2197 | supplies the body of the loop; they are consumed by this function and | ||||||
2198 | become part of the constructed op tree. I |
||||||
2199 | unused and should always be 1. | ||||||
2200 | |||||||
2201 | OP * newLOOPOP(I32 flags, I32 debuggable, OP *expr, | ||||||
2202 | OP *block)','name' => 'newLOOPOP'},'reg_named_buff_firstkey' => {'text' => '','name' => 'reg_named_buff_firstkey'},'free_global_struct' => {'text' => '','name' => 'free_global_struct'},'uvuni_to_utf8' => {'text' => '','name' => 'uvuni_to_utf8'},'SvLEN' => {'text' => 'Returns the size of the string buffer in the SV, not including any part | ||||||
2203 | attributable to C |
||||||
2204 | |||||||
2205 | STRLEN SvLEN(SV* sv)','name' => 'SvLEN'},'PerlIO_tell' => {'text' => '','name' => 'PerlIO_tell'},'SvPOK_only_UTF8' => {'text' => 'Tells an SV that it is a string and disables all other OK bits, | ||||||
2206 | and leaves the UTF-8 status as it was. | ||||||
2207 | |||||||
2208 | 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 |
||||||
2209 | |||||||
2210 | int mg_get(SV* sv)','name' => 'mg_get'},'SvTRUE' => {'text' => 'Returns a boolean indicating whether Perl would evaluate the SV as true or | ||||||
2211 | false. See SvOK() for a defined/undefined test. Handles \'get\' magic | ||||||
2212 | unless the scalar is already SvPOK, SvIOK or SvNOK (the public, not the | ||||||
2213 | private flags). | ||||||
2214 | |||||||
2215 | bool SvTRUE(SV* sv)','name' => 'SvTRUE'},'regdump' => {'text' => '','name' => 'regdump'},'my_pclose' => {'text' => '','name' => 'my_pclose'},'hv_iternext_flags' => {'text' => 'Returns entries from a hash iterator. See C |
||||||
2216 | The C |
||||||
2217 | set the placeholders keys (for restricted hashes) will be returned in addition | ||||||
2218 | to normal keys. By default placeholders are automatically skipped over. | ||||||
2219 | Currently a placeholder is implemented with a value that is | ||||||
2220 | C<&PL_sv_placeholder>. Note that the implementation of placeholders and | ||||||
2221 | restricted hashes may change, and the implementation currently is | ||||||
2222 | insufficiently abstracted for any change to be tidy. | ||||||
2223 | |||||||
2224 | NOTE: this function is experimental and may change or be | ||||||
2225 | removed without notice. | ||||||
2226 | |||||||
2227 | HE* hv_iternext_flags(HV *hv, I32 flags)','name' => 'hv_iternext_flags'},'is_utf8_string_loclen' => {'text' => 'Like L() but stores the location of the failure (in the | ||||||
2228 | case of "utf8ness failure") or the location C |
||||||
2229 | "utf8ness success") in the C |
||||||
2230 | encoded characters in the C |
||||||
2231 | |||||||
2232 | See also L() and L(). | ||||||
2233 | |||||||
2234 | bool is_utf8_string_loclen(const U8 *s, STRLEN len, | ||||||
2235 | const U8 **ep, STRLEN *el)','name' => 'is_utf8_string_loclen'},'call_method' => {'text' => 'Performs a callback to the specified Perl method. The blessed object must | ||||||
2236 | be on the stack. See L |
||||||
2237 | |||||||
2238 | NOTE: the perl_ form of this function is deprecated. | ||||||
2239 | |||||||
2240 | I32 call_method(const char* methname, I32 flags)','name' => 'call_method'},'BhkENABLE' => {'text' => 'Re-enable an entry in this BHK structure, by setting the appropriate | ||||||
2241 | flag. I |
||||||
2242 | This will assert (under -DDEBUGGING) if the entry doesn\'t contain a valid | ||||||
2243 | pointer. | ||||||
2244 | |||||||
2245 | NOTE: this function is experimental and may change or be | ||||||
2246 | removed without notice. | ||||||
2247 | |||||||
2248 | void BhkENABLE(BHK *hk, which)','name' => 'BhkENABLE'},'sys_init' => {'text' => '','name' => 'sys_init'},'perl_parse' => {'text' => 'Tells a Perl interpreter to parse a Perl script. See L |
||||||
2249 | |||||||
2250 | int perl_parse(PerlInterpreter *my_perl, | ||||||
2251 | XSINIT_t xsinit, int argc, | ||||||
2252 | char** argv, char** env)','name' => 'perl_parse'},'av_clear' => {'text' => 'Clears an array, making it empty. Does not free the memory the av uses to | ||||||
2253 | store its list of scalars. If any destructors are triggered as a result, | ||||||
2254 | the av itself may be freed when this function returns. | ||||||
2255 | |||||||
2256 | Perl equivalent: C<@myarray = ();>. | ||||||
2257 | |||||||
2258 | void av_clear(AV *av)','name' => 'av_clear'},'sv_force_normal' => {'text' => 'Undo various types of fakery on an SV: if the PV is a shared string, make | ||||||
2259 | a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to | ||||||
2260 | an xpvmg. See also C |
||||||
2261 | |||||||
2262 | void sv_force_normal(SV *sv)','name' => 'sv_force_normal'},'av_unshift' => {'text' => 'Unshift the given number of C |
||||||
2263 | array. The array will grow automatically to accommodate the addition. You | ||||||
2264 | must then use C |
||||||
2265 | |||||||
2266 | Perl equivalent: C |
||||||
2267 | |||||||
2268 | void av_unshift(AV *av, I32 num)','name' => 'av_unshift'},'save_set_svflags' => {'text' => '','name' => 'save_set_svflags'},'SvREFCNT_inc_NN' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you know I |
||||||
2269 | is not NULL. Since we don\'t have to check the NULLness, it\'s faster | ||||||
2270 | and smaller. | ||||||
2271 | |||||||
2272 | SV* SvREFCNT_inc_NN(SV* sv)','name' => 'SvREFCNT_inc_NN'},'sys_term' => {'text' => '','name' => 'sys_term'},'is_utf8_xidfirst' => {'text' => '','name' => 'is_utf8_xidfirst'},'re_intuit_start' => {'text' => '','name' => 're_intuit_start'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions. | ||||||
2273 | Only use when you are sure SvIOK is true. See also C |
||||||
2274 | |||||||
2275 | UV SvUVX(SV* sv)','name' => 'SvUVX'},'hv_copy_hints_hv' => {'text' => 'A specialised version of L for copying C<%^H>. I |
||||||
2276 | a pointer to a hash (which may have C<%^H> magic, but should be generally | ||||||
2277 | non-magical), or C |
||||||
2278 | of I |
||||||
2279 | added to it. A pointer to the new hash is returned. | ||||||
2280 | |||||||
2281 | HV * hv_copy_hints_hv(HV *ohv)','name' => 'hv_copy_hints_hv'},'do_pmop_dump' => {'text' => '','name' => 'do_pmop_dump'},'sv_utf8_decode' => {'text' => 'If the PV of the SV is an octet sequence in UTF-8 | ||||||
2282 | and contains a multiple-byte character, the C |
||||||
2283 | so that it looks like a character. If the PV contains only single-byte | ||||||
2284 | characters, the C |
||||||
2285 | Scans PV for validity and returns false if the PV is invalid UTF-8. | ||||||
2286 | |||||||
2287 | NOTE: this function is experimental and may change or be | ||||||
2288 | removed without notice. | ||||||
2289 | |||||||
2290 | bool sv_utf8_decode(SV *const sv)','name' => 'sv_utf8_decode'},'op_refcnt_unlock' => {'text' => '','name' => 'op_refcnt_unlock'},'hv_stores' => {'text' => 'Like C |
||||||
2291 | and omits the hash parameter. | ||||||
2292 | |||||||
2293 | SV** hv_stores(HV* tb, const char* key, | ||||||
2294 | NULLOK SV* val)','name' => 'hv_stores'},'eval_sv' => {'text' => 'Tells Perl to C |
||||||
2295 | as C |
||||||
2296 | |||||||
2297 | NOTE: the perl_ form of this function is deprecated. | ||||||
2298 | |||||||
2299 | I32 eval_sv(SV* sv, I32 flags)','name' => 'eval_sv'},'SvNV_nomg' => {'text' => 'Like C |
||||||
2300 | |||||||
2301 | NV SvNV_nomg(SV* sv)','name' => 'SvNV_nomg'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C |
||||||
2302 | L |
||||||
2303 | |||||||
2304 | FREETMPS;','name' => 'FREETMPS'},'sv_utf8_upgrade_nomg' => {'text' => 'Like sv_utf8_upgrade, but doesn\'t do magic on C |
||||||
2305 | |||||||
2306 | STRLEN sv_utf8_upgrade_nomg(SV *sv)','name' => 'sv_utf8_upgrade_nomg'},'sv_pvn_force' => {'text' => 'Get a sensible string out of the SV somehow. | ||||||
2307 | A private implementation of the C |
||||||
2308 | can\'t cope with complex macro expressions. Always use the macro instead. | ||||||
2309 | |||||||
2310 | char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'GIMME' => {'text' => 'A backward-compatible version of C |
||||||
2311 | C |
||||||
2312 | Deprecated. Use C |
||||||
2313 | |||||||
2314 | U32 GIMME','name' => 'GIMME'},'my_snprintf' => {'text' => 'The C library C |
||||||
2315 | standards-compliant (uses C |
||||||
2316 | C |
||||||
2317 | C |
||||||
2318 | but that may be too late). Consider using C |
||||||
2319 | getting C |
||||||
2320 | |||||||
2321 | int my_snprintf(char *buffer, const Size_t len, | ||||||
2322 | const char *format, ...)','name' => 'my_snprintf'},'newLOGOP' => {'text' => 'Constructs, checks, and returns a logical (flow control) op. I |
||||||
2323 | is the opcode. I |
||||||
2324 | that C |
||||||
2325 | the eight bits of C |
||||||
2326 | automatically set. I |
||||||
2327 | flow, and I |
||||||
2328 | consumed by this function and become part of the constructed op tree. | ||||||
2329 | |||||||
2330 | OP * newLOGOP(I32 type, I32 flags, OP *first, | ||||||
2331 | OP *other)','name' => 'newLOGOP'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. | ||||||
2332 | |||||||
2333 | bool SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'gp_ref' => {'text' => '','name' => 'gp_ref'},'save_op' => {'text' => '','name' => 'save_op'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L |
||||||
2334 | |||||||
2335 | void perl_construct(PerlInterpreter *my_perl)','name' => 'perl_construct'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an unsigned integer. | ||||||
2336 | |||||||
2337 | bool SvUOK(SV* sv)','name' => 'SvUOK'},'newWHENOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C |
||||||
2338 | I |
||||||
2339 | that will be executed if the test evaluates to true; they are consumed | ||||||
2340 | by this function and become part of the constructed op tree. I |
||||||
2341 | will be interpreted DWIMically, often as a comparison against C<$_>, | ||||||
2342 | and may be null to generate a C |
||||||
2343 | |||||||
2344 | OP * newWHENOP(OP *cond, OP *block)','name' => 'newWHENOP'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion | ||||||
2345 | if necessary. Handles \'get\' magic and operator overloading. | ||||||
2346 | |||||||
2347 | void sv_dec(SV *const sv)','name' => 'sv_dec'},'pv_display' => {'text' => 'Similar to | ||||||
2348 | |||||||
2349 | pv_escape(dsv,pv,cur,pvlim,PERL_PV_ESCAPE_QUOTE); | ||||||
2350 | |||||||
2351 | except that an additional "\\0" will be appended to the string when | ||||||
2352 | len > cur and pv[cur] is "\\0". | ||||||
2353 | |||||||
2354 | Note that the final string may be up to 7 chars longer than pvlim. | ||||||
2355 | |||||||
2356 | char* pv_display(SV *dsv, const char *pv, STRLEN cur, | ||||||
2357 | STRLEN len, STRLEN pvlim)','name' => 'pv_display'},'newHVREF' => {'text' => '','name' => 'newHVREF'},'sv_2pvbyte_nolen' => {'text' => 'Return a pointer to the byte-encoded representation of the SV. | ||||||
2358 | May cause the SV to be downgraded from UTF-8 as a side-effect. | ||||||
2359 | |||||||
2360 | Usually accessed via the C |
||||||
2361 | |||||||
2362 | char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'is_uni_space' => {'text' => '','name' => 'is_uni_space'},'PerlIO_fileno' => {'text' => '','name' => 'PerlIO_fileno'},'uvchr_to_utf8' => {'text' => 'Adds the UTF-8 representation of the Native code point C |
||||||
2363 | of the string C |
||||||
2364 | bytes available. The return value is the pointer to the byte after the | ||||||
2365 | end of the new character. In other words, | ||||||
2366 | |||||||
2367 | d = uvchr_to_utf8(d, uv); | ||||||
2368 | |||||||
2369 | is the recommended wide native character-aware way of saying | ||||||
2370 | |||||||
2371 | *(d++) = uv; | ||||||
2372 | |||||||
2373 | U8* uvchr_to_utf8(U8 *d, UV uv)','name' => 'uvchr_to_utf8'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the specified character is a | ||||||
2374 | digit in the platform\'s native character set. | ||||||
2375 | Variants C |
||||||
2376 | |||||||
2377 | bool isDIGIT(char ch)','name' => 'isDIGIT'},'call_atexit' => {'text' => '','name' => 'call_atexit'},'is_utf8_alpha' => {'text' => '','name' => 'is_utf8_alpha'},'my_bzero' => {'text' => '','name' => 'my_bzero'},'newCONSTSUB' => {'text' => 'See L. | ||||||
2378 | |||||||
2379 | CV* newCONSTSUB(HV* stash, const char* name, SV* sv)','name' => 'newCONSTSUB'},'SvSHARE' => {'text' => 'Arranges for sv to be shared between threads if a suitable module | ||||||
2380 | has been loaded. | ||||||
2381 | |||||||
2382 | void SvSHARE(SV* sv)','name' => 'SvSHARE'},'vwarner' => {'text' => '','name' => 'vwarner'},'sortsv' => {'text' => 'Sort an array. Here is an example: | ||||||
2383 | |||||||
2384 | sortsv(AvARRAY(av), av_len(av)+1, Perl_sv_cmp_locale); | ||||||
2385 | |||||||
2386 | Currently this always uses mergesort. See sortsv_flags for a more | ||||||
2387 | flexible routine. | ||||||
2388 | |||||||
2389 | void sortsv(SV** array, size_t num_elts, | ||||||
2390 | SVCOMPARE_t cmp)','name' => 'sortsv'},'cophh_store_pvs' => {'text' => 'Like L, but takes a literal string instead of a | ||||||
2391 | string/length pair, and no precomputed hash. | ||||||
2392 | |||||||
2393 | NOTE: this function is experimental and may change or be | ||||||
2394 | removed without notice. | ||||||
2395 | |||||||
2396 | COPHH * cophh_store_pvs(const COPHH *cophh, | ||||||
2397 | const char *key, SV *value, | ||||||
2398 | U32 flags)','name' => 'cophh_store_pvs'},'sys_intern_clear' => {'text' => '','name' => 'sys_intern_clear'},'my_ntohl' => {'text' => '','name' => 'my_ntohl'},'doref' => {'text' => '','name' => 'doref'},'scan_bin' => {'text' => 'For backwards compatibility. Use C |
||||||
2399 | |||||||
2400 | NV scan_bin(const char* start, STRLEN len, | ||||||
2401 | STRLEN* retlen)','name' => 'scan_bin'},'Nullcv' => {'text' => 'Null CV pointer. | ||||||
2402 | |||||||
2403 | (deprecated - use C<(CV *)NULL> instead)','name' => 'Nullcv'},'sv_catpvs_nomg' => {'text' => 'Like C |
||||||
2404 | string/length pair. | ||||||
2405 | |||||||
2406 | void sv_catpvs_nomg(SV* sv, const char* s)','name' => 'sv_catpvs_nomg'},'lex_bufutf8' => {'text' => 'Indicates whether the octets in the lexer buffer | ||||||
2407 | (Llinestr>) should be interpreted as the UTF-8 encoding | ||||||
2408 | of Unicode characters. If not, they should be interpreted as Latin-1 | ||||||
2409 | characters. This is analogous to the C |
||||||
2410 | |||||||
2411 | In UTF-8 mode, it is not guaranteed that the lexer buffer actually | ||||||
2412 | contains valid UTF-8. Lexing code must be robust in the face of invalid | ||||||
2413 | encoding. | ||||||
2414 | |||||||
2415 | The actual C |
||||||
2416 | is significant, but not the whole story regarding the input character | ||||||
2417 | encoding. Normally, when a file is being read, the scalar contains octets | ||||||
2418 | and its C |
||||||
2419 | UTF-8 if the C | ||||||
2420 | however, the scalar may have the C |
||||||
2421 | octets should be interpreted as UTF-8 unless the C | ||||||
2422 | is in effect. This logic may change in the future; use this function | ||||||
2423 | instead of implementing the logic yourself. | ||||||
2424 | |||||||
2425 | NOTE: this function is experimental and may change or be | ||||||
2426 | removed without notice. | ||||||
2427 | |||||||
2428 | bool lex_bufutf8()','name' => 'lex_bufutf8'},'MULTICALL' => {'text' => 'Make a lightweight callback. See L |
||||||
2429 | |||||||
2430 | MULTICALL;','name' => 'MULTICALL'},'debprofdump' => {'text' => '','name' => 'debprofdump'},'SvPVbyte' => {'text' => 'Like C |
||||||
2431 | |||||||
2432 | char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'is_uni_lower' => {'text' => '','name' => 'is_uni_lower'},'savesharedpvs' => {'text' => 'A version of C |
||||||
2433 | which is shared between threads. | ||||||
2434 | |||||||
2435 | char* savesharedpvs(const char* s)','name' => 'savesharedpvs'},'sys_init3' => {'text' => '','name' => 'sys_init3'},'gv_fetchmeth_pv' => {'text' => 'Exactly like L, but takes a nul-terminated string | ||||||
2436 | instead of a string/length pair. | ||||||
2437 | |||||||
2438 | GV* gv_fetchmeth_pv(HV* stash, const char* name, | ||||||
2439 | I32 level, U32 flags)','name' => 'gv_fetchmeth_pv'},'PerlIO_stdout' => {'text' => '','name' => 'PerlIO_stdout'},'XS_INTERNAL' => {'text' => 'Macro to declare an XSUB and its C parameter list without exporting the symbols. | ||||||
2440 | This is handled by C |
||||||
2441 | symbols unnecessarily.','name' => 'XS_INTERNAL'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C |
||||||
2442 | L |
||||||
2443 | |||||||
2444 | SAVETMPS;','name' => 'SAVETMPS'},'AvFILL' => {'text' => 'Same as C |
||||||
2445 | |||||||
2446 | int AvFILL(AV* av)','name' => 'AvFILL'},'SvPVutf8x' => {'text' => 'Like C |
||||||
2447 | Guarantees to evaluate sv only once; use the more efficient C |
||||||
2448 | otherwise. | ||||||
2449 | |||||||
2450 | char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C |
||||||
2451 | possible to set C<*st> and C<*gvp> to the stash and GV associated with it. | ||||||
2452 | The flags in C |
||||||
2453 | |||||||
2454 | CV* sv_2cv(SV* sv, HV **const st, GV **const gvp, | ||||||
2455 | const I32 lref)','name' => 'sv_2cv'},'gp_free' => {'text' => '','name' => 'gp_free'},'SvPV_force_nomg' => {'text' => 'Like C |
||||||
2456 | (C |
||||||
2457 | directly. Doesn\'t process magic. | ||||||
2458 | |||||||
2459 | char* SvPV_force_nomg(SV* sv, STRLEN len)','name' => 'SvPV_force_nomg'},'SvPOK_only' => {'text' => 'Tells an SV that it is a string and disables all other OK bits. | ||||||
2460 | Will also turn off the UTF-8 status. | ||||||
2461 | |||||||
2462 | void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'save_destructor_x' => {'text' => '','name' => 'save_destructor_x'},'sv_usepvn_mg' => {'text' => 'Like C |
||||||
2463 | |||||||
2464 | void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)','name' => 'sv_usepvn_mg'},'hv_fetch' => {'text' => 'Returns the SV which corresponds to the specified key in the hash. | ||||||
2465 | The absolute value of C |
||||||
2466 | negative the key is assumed to be in UTF-8-encoded Unicode. If | ||||||
2467 | C |
||||||
2468 | return value is non-null before dereferencing it to an C |
||||||
2469 | |||||||
2470 | See L |
||||||
2471 | information on how to use this function on tied hashes. | ||||||
2472 | |||||||
2473 | SV** hv_fetch(HV *hv, const char *key, I32 klen, | ||||||
2474 | I32 lval)','name' => 'hv_fetch'},'sv_pvbyte' => {'text' => 'Use C |
||||||
2475 | |||||||
2476 | char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'XCPT_TRY_START' => {'text' => 'Starts a try block. See L |
||||||
2477 | whatever was being referenced by the RV. This can almost be thought of | ||||||
2478 | as a reversal of C |
||||||
2479 | C |
||||||
2480 | (otherwise the decrementing is conditional on the reference count being | ||||||
2481 | different from one or the reference being a readonly SV). | ||||||
2482 | See C |
||||||
2483 | |||||||
2484 | void sv_unref_flags(SV *const ref, const U32 flags)','name' => 'sv_unref_flags'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. | ||||||
2485 | |||||||
2486 | 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. | ||||||
2487 | |||||||
2488 | SV* hv_scalar(HV *hv)','name' => 'hv_scalar'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C |
||||||
2489 | |||||||
2490 | int mg_copy(SV *sv, SV *nsv, const char *key, | ||||||
2491 | I32 klen)','name' => 'mg_copy'},'save_I16' => {'text' => '','name' => 'save_I16'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C |
||||||
2492 | referred-to SV C |
||||||
2493 | push a back-reference to this RV onto the array of backreferences | ||||||
2494 | associated with that magic. If the RV is magical, set magic will be | ||||||
2495 | called after the RV is cleared. | ||||||
2496 | |||||||
2497 | SV* sv_rvweaken(SV *const sv)','name' => 'sv_rvweaken'},'grok_oct' => {'text' => 'converts a string representing an octal number to numeric form. | ||||||
2498 | |||||||
2499 | On entry I |
||||||
2500 | conversion flags, and I |
||||||
2501 | The scan stops at the end of the string, or the first invalid character. | ||||||
2502 | Unless C |
||||||
2503 | 8 or 9 will also trigger a warning. | ||||||
2504 | On return I<*len> is set to the length of the scanned string, | ||||||
2505 | and I<*flags> gives output flags. | ||||||
2506 | |||||||
2507 | If the value is <= UV_MAX it is returned as a UV, the output flags are clear, | ||||||
2508 | and nothing is written to I<*result>. If the value is > UV_MAX C |
||||||
2509 | returns UV_MAX, sets C |
||||||
2510 | and writes the value to I<*result> (or the value is discarded if I |
||||||
2511 | is NULL). | ||||||
2512 | |||||||
2513 | If C |
||||||
2514 | number may use \'_\' characters to separate digits. | ||||||
2515 | |||||||
2516 | UV grok_oct(const char* start, STRLEN* len_p, | ||||||
2517 | I32* flags, NV *result)','name' => 'grok_oct'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C |
||||||
2518 | (C<\\0>) and other binary data. The reference count for the SV is set to 1. | ||||||
2519 | Note that if C |
||||||
2520 | are responsible for ensuring that the source buffer is at least | ||||||
2521 | C |
||||||
2522 | undefined. | ||||||
2523 | |||||||
2524 | SV* newSVpvn(const char *const s, const STRLEN len)','name' => 'newSVpvn'},'scan_hex' => {'text' => 'For backwards compatibility. Use C |
||||||
2525 | |||||||
2526 | NV scan_hex(const char* start, STRLEN len, | ||||||
2527 | STRLEN* retlen)','name' => 'scan_hex'},'unpackstring' => {'text' => 'The engine implementing unpack() Perl function. C |
||||||
2528 | extracted list items on the stack and returns the number of elements. | ||||||
2529 | Issue C |
||||||
2530 | |||||||
2531 | I32 unpackstring(const char *pat, | ||||||
2532 | const char *patend, const char *s, | ||||||
2533 | const char *strend, U32 flags)','name' => 'unpackstring'},'av_extend' => {'text' => 'Pre-extend an array. The C |
||||||
2534 | extended. | ||||||
2535 | |||||||
2536 | void av_extend(AV *av, I32 key)','name' => 'av_extend'},'sv_peek' => {'text' => '','name' => 'sv_peek'},'hv_iternext' => {'text' => 'Returns entries from a hash iterator. See C |
||||||
2537 | |||||||
2538 | You may call C |
||||||
2539 | iterator currently points to, without losing your place or invalidating your | ||||||
2540 | iterator. Note that in this case the current entry is deleted from the hash | ||||||
2541 | with your iterator holding the last reference to it. Your iterator is flagged | ||||||
2542 | to free the entry on the next call to C |
||||||
2543 | your iterator immediately else the entry will leak - call C |
||||||
2544 | trigger the resource deallocation. | ||||||
2545 | |||||||
2546 | HE* hv_iternext(HV *hv)','name' => 'hv_iternext'},'hv_store_ent' => {'text' => 'Stores C |
||||||
2547 | parameter is the precomputed hash value; if it is zero then Perl will | ||||||
2548 | compute it. The return value is the new hash entry so created. It will be | ||||||
2549 | NULL if the operation failed or if the value did not need to be actually | ||||||
2550 | stored within the hash (as in the case of tied hashes). Otherwise the | ||||||
2551 | contents of the return value can be accessed using the C |
||||||
2552 | described here. Note that the caller is responsible for suitably | ||||||
2553 | incrementing the reference count of C |
||||||
2554 | decrementing it if the function returned NULL. Effectively a successful | ||||||
2555 | hv_store_ent takes ownership of one reference to C |
||||||
2556 | usually what you want; a newly created SV has a reference count of one, so | ||||||
2557 | if all your code does is create SVs then store them in a hash, hv_store | ||||||
2558 | will own the only reference to the new SV, and your code doesn\'t need to do | ||||||
2559 | anything further to tidy up. Note that hv_store_ent only reads the C |
||||||
2560 | unlike C |
||||||
2561 | reference count on C |
||||||
2562 | is not implemented as a call to hv_store_ent, and does not create a temporary | ||||||
2563 | SV for the key, so if your key data is not already in SV form then use | ||||||
2564 | hv_store in preference to hv_store_ent. | ||||||
2565 | |||||||
2566 | See L |
||||||
2567 | information on how to use this function on tied hashes. | ||||||
2568 | |||||||
2569 | HE* hv_store_ent(HV *hv, SV *key, SV *val, U32 hash)','name' => 'hv_store_ent'},'hv_eiter_set' => {'text' => '','name' => 'hv_eiter_set'},'gv_stashsv' => {'text' => 'Returns a pointer to the stash for a specified package. See C |
||||||
2570 | |||||||
2571 | HV* gv_stashsv(SV* sv, I32 flags)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C |
||||||
2572 | the subs.','name' => 'newXSproto'},'form' => {'text' => 'Takes a sprintf-style format pattern and conventional | ||||||
2573 | (non-SV) arguments and returns the formatted string. | ||||||
2574 | |||||||
2575 | (char *) Perl_form(pTHX_ const char* pat, ...) | ||||||
2576 | |||||||
2577 | can be used any place a string (char *) is required: | ||||||
2578 | |||||||
2579 | char * s = Perl_form("%d.%d",major,minor); | ||||||
2580 | |||||||
2581 | Uses a single private buffer so if you want to format several strings you | ||||||
2582 | must explicitly copy the earlier strings away (and free the copies when you | ||||||
2583 | are done). | ||||||
2584 | |||||||
2585 | char* form(const char* pat, ...)','name' => 'form'},'instr' => {'text' => '','name' => 'instr'},'pregexec' => {'text' => '','name' => 'pregexec'},'is_utf8_string' => {'text' => 'Returns true if the first C |
||||||
2586 | UTF-8 string, false otherwise. If C |
||||||
2587 | using C |
||||||
2588 | terminating NUL byte). Note that all characters being ASCII constitute \'a | ||||||
2589 | valid UTF-8 string\'. | ||||||
2590 | |||||||
2591 | See also L(), L(), and L(). | ||||||
2592 | |||||||
2593 | bool is_utf8_string(const U8 *s, STRLEN len)','name' => 'is_utf8_string'},'croak_xs_usage' => {'text' => 'A specialised variant of C |
||||||
2594 | |||||||
2595 | croak_xs_usage(cv, "eee_yow"); | ||||||
2596 | |||||||
2597 | works out the package name and subroutine name from C |
||||||
2598 | C |
||||||
2599 | |||||||
2600 | Perl_croak(aTHX_ "Usage: %"SVf"::%"SVf"(%s)", "ouch" "awk", "eee_yow"); | ||||||
2601 | |||||||
2602 | void croak_xs_usage(const CV *const cv, | ||||||
2603 | const char *const params)','name' => 'croak_xs_usage'},'sv_insert' => {'text' => 'Inserts a string at the specified offset/length within the SV. Similar to | ||||||
2604 | the Perl substr() function. Handles get magic. | ||||||
2605 | |||||||
2606 | void sv_insert(SV *const bigstr, const STRLEN offset, | ||||||
2607 | const STRLEN len, | ||||||
2608 | const char *const little, | ||||||
2609 | const STRLEN littlelen)','name' => 'sv_insert'},'SvPOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a character | ||||||
2610 | string. | ||||||
2611 | |||||||
2612 | U32 SvPOK(SV* sv)','name' => 'SvPOK'},'sv_destroyable' => {'text' => 'Dummy routine which reports that object can be destroyed when there is no | ||||||
2613 | sharing module present. It ignores its single SV argument, and returns | ||||||
2614 | \'true\'. Exists to avoid test for a NULL function pointer and because it | ||||||
2615 | could potentially warn under some level of strict-ness. | ||||||
2616 | |||||||
2617 | bool sv_destroyable(SV *sv)','name' => 'sv_destroyable'},'save_aelem_flags' => {'text' => '','name' => 'save_aelem_flags'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by | ||||||
2618 | C |
||||||
2619 | bytes to be copied. If the C |
||||||
2620 | undefined. Does not handle \'set\' magic. See C |
||||||
2621 | |||||||
2622 | void sv_setpvn(SV *const sv, const char *const ptr, | ||||||
2623 | const STRLEN len)','name' => 'sv_setpvn'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C |
||||||
2624 | |||||||
2625 | void mg_magical(SV* sv)','name' => 'mg_magical'},'op_linklist' => {'text' => 'This function is the implementation of the L macro. It should | ||||||
2626 | not be called directly. | ||||||
2627 | |||||||
2628 | OP* op_linklist(OP *o)','name' => 'op_linklist'},'newSVrv' => {'text' => 'Creates a new SV for the RV, C |
||||||
2629 | it will be upgraded to one. If C |
||||||
2630 | be blessed in the specified package. The new SV is returned and its | ||||||
2631 | reference count is 1. | ||||||
2632 | |||||||
2633 | SV* newSVrv(SV *const rv, | ||||||
2634 | const char *const classname)','name' => 'newSVrv'},'cast_i32' => {'text' => '','name' => 'cast_i32'},'is_utf8_posix_digit' => {'text' => '','name' => 'is_utf8_posix_digit'},'strnEQ' => {'text' => 'Test two strings to see if they are equal. The C |
||||||
2635 | the number of bytes to compare. Returns true or false. (A wrapper for | ||||||
2636 | C |
||||||
2637 | |||||||
2638 | bool strnEQ(char* s1, char* s2, STRLEN len)','name' => 'strnEQ'},'stashpv_hvname_match' => {'text' => '','name' => 'stashpv_hvname_match'},'sv_dup_inc' => {'text' => '','name' => 'sv_dup_inc'},'newMYSUB' => {'text' => '','name' => 'newMYSUB'},'PoisonWith' => {'text' => 'Fill up memory with a byte pattern (a byte repeated over and over | ||||||
2639 | again) that hopefully catches attempts to access uninitialized memory. | ||||||
2640 | |||||||
2641 | void PoisonWith(void* dest, int nitems, type, | ||||||
2642 | U8 byte)','name' => 'PoisonWith'},'av_create_and_unshift_one' => {'text' => 'Unshifts an SV onto the beginning of the array, creating the array if | ||||||
2643 | necessary. | ||||||
2644 | A small internal helper function to remove a commonly duplicated idiom. | ||||||
2645 | |||||||
2646 | NOTE: this function is experimental and may change or be | ||||||
2647 | removed without notice. | ||||||
2648 | |||||||
2649 | SV** av_create_and_unshift_one(AV **const avp, | ||||||
2650 | SV *const val)','name' => 'av_create_and_unshift_one'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. | ||||||
2651 | |||||||
2652 | void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'bytes_cmp_utf8' => {'text' => 'Compares the sequence of characters (stored as octets) in C, C |
||||||
2653 | sequence of characters (stored as UTF-8) in C, C |
||||||
2654 | equal, -1 or -2 if the first string is less than the second string, +1 or +2 | ||||||
2655 | if the first string is greater than the second string. | ||||||
2656 | |||||||
2657 | -1 or +1 is returned if the shorter string was identical to the start of the | ||||||
2658 | longer string. -2 or +2 is returned if the was a difference between characters | ||||||
2659 | within the strings. | ||||||
2660 | |||||||
2661 | int bytes_cmp_utf8(const U8 *b, STRLEN blen, | ||||||
2662 | const U8 *u, STRLEN ulen)','name' => 'bytes_cmp_utf8'},'seed' => {'text' => '','name' => 'seed'},'pad_findmy_pvs' => {'text' => 'Exactly like L, but takes a literal string instead | ||||||
2663 | of a string/length pair. | ||||||
2664 | |||||||
2665 | PADOFFSET pad_findmy_pvs(const char *name, U32 flags)','name' => 'pad_findmy_pvs'},'is_uni_lower_lc' => {'text' => '','name' => 'is_uni_lower_lc'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C |
||||||
2666 | necessary, then adds a new magic item of type C |
||||||
2667 | magic list. | ||||||
2668 | |||||||
2669 | See C |
||||||
2670 | handling of the C |
||||||
2671 | |||||||
2672 | You need to use C |
||||||
2673 | to add more than one instance of the same \'how\'. | ||||||
2674 | |||||||
2675 | void sv_magic(SV *const sv, SV *const obj, | ||||||
2676 | const int how, const char *const name, | ||||||
2677 | const I32 namlen)','name' => 'sv_magic'},'sv_utf8_upgrade_flags' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. | ||||||
2678 | Forces the SV to string form if it is not already. | ||||||
2679 | Always sets the SvUTF8 flag to avoid future validity checks even | ||||||
2680 | if all the bytes are invariant in UTF-8. | ||||||
2681 | If C |
||||||
2682 | will C |
||||||
2683 | Returns the number of bytes in the converted string | ||||||
2684 | C |
||||||
2685 | C |
||||||
2686 | |||||||
2687 | This is not as a general purpose byte encoding to Unicode interface: | ||||||
2688 | use the Encode extension for that. | ||||||
2689 | |||||||
2690 | STRLEN sv_utf8_upgrade_flags(SV *const sv, | ||||||
2691 | const I32 flags)','name' => 'sv_utf8_upgrade_flags'},'do_open9' => {'text' => '','name' => 'do_open9'},'magic_dump' => {'text' => '','name' => 'magic_dump'},'sv_catpvs_mg' => {'text' => 'Like C |
||||||
2692 | string/length pair. | ||||||
2693 | |||||||
2694 | void sv_catpvs_mg(SV* sv, const char* s)','name' => 'sv_catpvs_mg'},'sv_setpvs_mg' => {'text' => 'Like C |
||||||
2695 | string/length pair. | ||||||
2696 | |||||||
2697 | void sv_setpvs_mg(SV* sv, const char* s)','name' => 'sv_setpvs_mg'},'gv_fetchfile_flags' => {'text' => '','name' => 'gv_fetchfile_flags'},'SvREFCNT_inc_void' => {'text' => 'Same as SvREFCNT_inc, but can only be used if you don\'t need the | ||||||
2698 | return value. The macro doesn\'t need to return a meaningful value. | ||||||
2699 | |||||||
2700 | void SvREFCNT_inc_void(SV* sv)','name' => 'SvREFCNT_inc_void'},'leave_scope' => {'text' => '','name' => 'leave_scope'},'newSTATEOP' => {'text' => 'Constructs a state op (COP). The state op is normally a C |
||||||
2701 | but will be a C |
||||||
2702 | code. The state op is populated from L (or L). | ||||||
2703 | If I | ||||||
2704 | the state op; this function takes ownership of the memory pointed at by | ||||||
2705 | I | ||||||
2706 | for the state op. | ||||||
2707 | |||||||
2708 | If I |
||||||
2709 | combined with I |
||||||
2710 | is consumed by this function and becomes part of the returned op tree. | ||||||
2711 | |||||||
2712 | OP * newSTATEOP(I32 flags, char *label, OP *o)','name' => 'newSTATEOP'},'my_fork' => {'text' => '','name' => 'my_fork'},'SvROK' => {'text' => 'Tests if the SV is an RV. | ||||||
2713 | |||||||
2714 | U32 SvROK(SV* sv)','name' => 'SvROK'},'sv_unref' => {'text' => 'Unsets the RV status of the SV, and decrements the reference count of | ||||||
2715 | whatever was being referenced by the RV. This can almost be thought of | ||||||
2716 | as a reversal of C |
||||||
2717 | being zero. See C |
||||||
2718 | |||||||
2719 | void sv_unref(SV* sv)','name' => 'sv_unref'},'moreswitches' => {'text' => '','name' => 'moreswitches'},'cophh_fetch_pvs' => {'text' => 'Like L, but takes a literal string instead of a | ||||||
2720 | string/length pair, and no precomputed hash. | ||||||
2721 | |||||||
2722 | NOTE: this function is experimental and may change or be | ||||||
2723 | removed without notice. | ||||||
2724 | |||||||
2725 | SV * cophh_fetch_pvs(const COPHH *cophh, | ||||||
2726 | const char *key, U32 flags)','name' => 'cophh_fetch_pvs'},'ptr_table_fetch' => {'text' => '','name' => 'ptr_table_fetch'},'save_nogv' => {'text' => '','name' => 'save_nogv'},'sv_setnv' => {'text' => 'Copies a double into the given SV, upgrading first if necessary. | ||||||
2727 | Does not handle \'set\' magic. See also C |
||||||
2728 | |||||||
2729 | void sv_setnv(SV *const sv, const NV num)','name' => 'sv_setnv'},'is_utf8_mark' => {'text' => '','name' => 'is_utf8_mark'},'SvREFCNT_inc_simple_NN' => {'text' => 'Same as SvREFCNT_inc_simple, but can only be used if you know I |
||||||
2730 | is not NULL. Since we don\'t have to check the NULLness, it\'s faster | ||||||
2731 | and smaller. | ||||||
2732 | |||||||
2733 | SV* SvREFCNT_inc_simple_NN(SV* sv)','name' => 'SvREFCNT_inc_simple_NN'},'newHV' => {'text' => 'Creates a new HV. The reference count is set to 1. | ||||||
2734 | |||||||
2735 | HV* newHV()','name' => 'newHV'},'gv_dump' => {'text' => '','name' => 'gv_dump'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or | ||||||
2736 | false. | ||||||
2737 | |||||||
2738 | bool strNE(char* s1, char* s2)','name' => 'strNE'},'my_strlcpy' => {'text' => '','name' => 'my_strlcpy'},'PerlIO_fill' => {'text' => '','name' => 'PerlIO_fill'},'caller_cx' => {'text' => 'The XSUB-writer\'s equivalent of L |
||||||
2739 | returned C |
||||||
2740 | information returned to Perl by C |
||||||
2741 | stack frame, so C |
||||||
2742 | immediately-surrounding Perl code. | ||||||
2743 | |||||||
2744 | This function skips over the automatic calls to C<&DB::sub> made on the | ||||||
2745 | behalf of the debugger. If the stack frame requested was a sub called by | ||||||
2746 | C |
||||||
2747 | C |
||||||
2748 | site. If I |
||||||
2749 | frame for the sub call itself. | ||||||
2750 | |||||||
2751 | const PERL_CONTEXT * caller_cx( | ||||||
2752 | I32 level, | ||||||
2753 | const PERL_CONTEXT **dbcxp | ||||||
2754 | )','name' => 'caller_cx'},'my_failure_exit' => {'text' => '','name' => 'my_failure_exit'},'cophh_copy' => {'text' => 'Make and return a complete copy of the cop hints hash I |
||||||
2755 | |||||||
2756 | NOTE: this function is experimental and may change or be | ||||||
2757 | removed without notice. | ||||||
2758 | |||||||
2759 | COPHH * cophh_copy(COPHH *cophh)','name' => 'cophh_copy'},'sv_pvutf8n_force' => {'text' => 'The backend for the C |
||||||
2760 | instead. | ||||||
2761 | |||||||
2762 | char* sv_pvutf8n_force(SV *const sv, STRLEN *const lp)','name' => 'sv_pvutf8n_force'},'do_sv_dump' => {'text' => '','name' => 'do_sv_dump'},'SvNV_set' => {'text' => 'Set the value of the NV pointer in sv to val. See C |
||||||
2763 | |||||||
2764 | void SvNV_set(SV* sv, NV val)','name' => 'SvNV_set'},'die_sv' => {'text' => 'Behaves the same as L, except for the return type. | ||||||
2765 | It should be used only where the C |
||||||
2766 | The function never actually returns. | ||||||
2767 | |||||||
2768 | OP * die_sv(SV *baseex)','name' => 'die_sv'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1. | ||||||
2769 | |||||||
2770 | Perl equivalent: C |
||||||
2771 | |||||||
2772 | AV* newAV()','name' => 'newAV'},'bytes_from_utf8' => {'text' => 'Converts a string C |
||||||
2773 | Unlike L but like L, returns a pointer to | ||||||
2774 | the newly-created string, and updates C |
||||||
2775 | length. Returns the original string if no conversion occurs, C |
||||||
2776 | is unchanged. Do nothing if C |
||||||
2777 | 0 if C |
||||||
2778 | in utf8 (i.e., US-ASCII on non-EBCDIC machines). | ||||||
2779 | |||||||
2780 | NOTE: this function is experimental and may change or be | ||||||
2781 | removed without notice. | ||||||
2782 | |||||||
2783 | U8* bytes_from_utf8(const U8 *s, STRLEN *len, | ||||||
2784 | bool *is_utf8)','name' => 'bytes_from_utf8'},'SvPV_nomg_nolen' => {'text' => 'Like C |
||||||
2785 | |||||||
2786 | char* SvPV_nomg_nolen(SV* sv)','name' => 'SvPV_nomg_nolen'},'dump_sub' => {'text' => '','name' => 'dump_sub'},'vload_module' => {'text' => '','name' => 'vload_module'},'save_adelete' => {'text' => '','name' => 'save_adelete'},'av_make' => {'text' => 'Creates a new AV and populates it with a list of SVs. The SVs are copied | ||||||
2787 | into the array, so they may be freed after the call to av_make. The new AV | ||||||
2788 | will have a reference count of 1. | ||||||
2789 | |||||||
2790 | Perl equivalent: C |
||||||
2791 | |||||||
2792 | AV* av_make(I32 size, SV **strp)','name' => 'av_make'},'SvUV' => {'text' => 'Coerces the given SV to an unsigned integer and returns it. See C |
||||||
2793 | for a version which guarantees to evaluate sv only once. | ||||||
2794 | |||||||
2795 | UV SvUV(SV* sv)','name' => 'SvUV'},'hv_name_set' => {'text' => '','name' => 'hv_name_set'},'cophh_store_pvn' => {'text' => 'Stores a value, associated with a key, in the cop hints hash I |
||||||
2796 | and returns the modified hash. The returned hash pointer is in general | ||||||
2797 | not the same as the hash pointer that was passed in. The input hash is | ||||||
2798 | consumed by the function, and the pointer to it must not be subsequently | ||||||
2799 | used. Use L if you need both hashes. | ||||||
2800 | |||||||
2801 | The key is specified by I |
||||||
2802 | C |
||||||
2803 | otherwise they are interpreted as Latin-1. I |
||||||
2804 | hash of the key string, or zero if it has not been precomputed. | ||||||
2805 | |||||||
2806 | I |
||||||
2807 | by this function, which thus does not take ownership of any reference | ||||||
2808 | to it, and later changes to the scalar will not be reflected in the | ||||||
2809 | value visible in the cop hints hash. Complex types of scalar will not | ||||||
2810 | be stored with referential integrity, but will be coerced to strings. | ||||||
2811 | |||||||
2812 | NOTE: this function is experimental and may change or be | ||||||
2813 | removed without notice. | ||||||
2814 | |||||||
2815 | COPHH * cophh_store_pvn(COPHH *cophh, const char *keypv, | ||||||
2816 | STRLEN keylen, U32 hash, | ||||||
2817 | SV *value, U32 flags)','name' => 'cophh_store_pvn'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L |
||||||
2818 | |||||||
2819 | int perl_run(PerlInterpreter *my_perl)','name' => 'perl_run'},'mess_nocontext' => {'text' => '','name' => 'mess_nocontext'},'sv_insert_flags' => {'text' => 'Same as C |
||||||
2820 | C |
||||||
2821 | |||||||
2822 | void sv_insert_flags(SV *const bigstr, | ||||||
2823 | const STRLEN offset, | ||||||
2824 | const STRLEN len, | ||||||
2825 | const char *const little, | ||||||
2826 | const STRLEN littlelen, | ||||||
2827 | const U32 flags)','name' => 'sv_insert_flags'},'OP_CLASS' => {'text' => 'Return the class of the provided OP: that is, which of the *OP | ||||||
2828 | structures it uses. For core ops this currently gets the information out | ||||||
2829 | of PL_opargs, which does not always accurately reflect the type used. | ||||||
2830 | For custom ops the type is returned from the registration, and it is up | ||||||
2831 | to the registree to ensure it is accurate. The value returned will be | ||||||
2832 | one of the OA_* constants from op.h. | ||||||
2833 | |||||||
2834 | U32 OP_CLASS(OP *o)','name' => 'OP_CLASS'},'SvPVutf8_nolen' => {'text' => 'Like C |
||||||
2835 | |||||||
2836 | char* SvPVutf8_nolen(SV* sv)','name' => 'SvPVutf8_nolen'},'SvRXOK' => {'text' => 'Returns a boolean indicating whether the SV (or the one it references) | ||||||
2837 | is a REGEXP. | ||||||
2838 | |||||||
2839 | If you want to do something with the REGEXP* later use SvRX instead | ||||||
2840 | and check for NULL. | ||||||
2841 | |||||||
2842 | bool SvRXOK(SV* sv)','name' => 'SvRXOK'},'sv_dup' => {'text' => '','name' => 'sv_dup'},'sv_setpviv' => {'text' => 'Copies an integer into the given SV, also updating its string value. | ||||||
2843 | Does not handle \'set\' magic. See C |
||||||
2844 | |||||||
2845 | void sv_setpviv(SV *const sv, const IV num)','name' => 'sv_setpviv'},'sv_true' => {'text' => 'Returns true if the SV has a true value by Perl\'s rules. | ||||||
2846 | Use the C |
||||||
2847 | instead use an in-line version. | ||||||
2848 | |||||||
2849 | I32 sv_true(SV *const sv)','name' => 'sv_true'},'save_aptr' => {'text' => '','name' => 'save_aptr'},'hv_exists' => {'text' => 'Returns a boolean indicating whether the specified hash key exists. The | ||||||
2850 | absolute value of C |
||||||
2851 | negative the key is assumed to be in UTF-8-encoded Unicode. | ||||||
2852 | |||||||
2853 | bool hv_exists(HV *hv, const char *key, I32 klen)','name' => 'hv_exists'},'my_popen' => {'text' => '','name' => 'my_popen'},'mg_length' => {'text' => 'Report on the SV\'s length. See C |
||||||
2854 | |||||||
2855 | U32 mg_length(SV* sv)','name' => 'mg_length'},'vdeb' => {'text' => '','name' => 'vdeb'},'do_close' => {'text' => '','name' => 'do_close'},'newUNOP' => {'text' => 'Constructs, checks, and returns an op of any unary type. I |
||||||
2856 | the opcode. I |
||||||
2857 | C |
||||||
2858 | bits, the eight bits of C |
||||||
2859 | is automatically set. I |
||||||
2860 | child of the unary op; it is consumed by this function and become part | ||||||
2861 | of the constructed op tree. | ||||||
2862 | |||||||
2863 | OP * newUNOP(I32 type, I32 flags, OP *first)','name' => 'newUNOP'},'mini_mktime' => {'text' => '','name' => 'mini_mktime'},'HEf_SVKEY' => {'text' => 'This flag, used in the length slot of hash entries and magic structures, | ||||||
2864 | specifies the structure contains an C |
||||||
2865 | is to be expected. (For information only--not to be used).','name' => 'HEf_SVKEY'},'save_helem_flags' => {'text' => '','name' => 'save_helem_flags'},'newPADOP' => {'text' => 'Constructs, checks, and returns an op of any type that involves a | ||||||
2866 | reference to a pad element. I |
||||||
2867 | eight bits of C |
||||||
2868 | is populated with I |
||||||
2869 | to it. | ||||||
2870 | |||||||
2871 | This function only exists if Perl has been compiled to use ithreads. | ||||||
2872 | |||||||
2873 | OP * newPADOP(I32 type, I32 flags, SV *sv)','name' => 'newPADOP'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C |
||||||
2874 | Stops at C |
||||||
2875 | up past C |
||||||
2876 | |||||||
2877 | STRLEN utf8_length(const U8* s, const U8 *e)','name' => 'utf8_length'},'is_uni_cntrl' => {'text' => '','name' => 'is_uni_cntrl'},'dowantarray' => {'text' => '','name' => 'dowantarray'},'my_cxt_init' => {'text' => '','name' => 'my_cxt_init'},'SvIOK_only_UV' => {'text' => 'Tells and SV that it is an unsigned integer and disables all other OK bits. | ||||||
2878 | |||||||
2879 | void SvIOK_only_UV(SV* sv)','name' => 'SvIOK_only_UV'},'clone_params_new' => {'text' => '','name' => 'clone_params_new'},'dump_fds' => {'text' => '','name' => 'dump_fds'},'sv_vcatpvfn' => {'text' => 'Processes its arguments like C |
||||||
2880 | to an SV. Uses an array of SVs if the C style variable argument list is | ||||||
2881 | missing (NULL). When running with taint checks enabled, indicates via | ||||||
2882 | C |
||||||
2883 | locales). | ||||||
2884 | |||||||
2885 | Usually used via one of its frontends C |
||||||
2886 | |||||||
2887 | void sv_vcatpvfn(SV *const sv, const char *const pat, | ||||||
2888 | const STRLEN patlen, | ||||||
2889 | va_list *const args, | ||||||
2890 | SV **const svargs, const I32 svmax, | ||||||
2891 | bool *const maybe_tainted)','name' => 'sv_vcatpvfn'},'BhkDISABLE' => {'text' => 'Temporarily disable an entry in this BHK structure, by clearing the | ||||||
2892 | appropriate flag. I |
||||||
2893 | entry to disable. | ||||||
2894 | |||||||
2895 | NOTE: this function is experimental and may change or be | ||||||
2896 | removed without notice. | ||||||
2897 | |||||||
2898 | void BhkDISABLE(BHK *hk, which)','name' => 'BhkDISABLE'},'croak_no_modify' => {'text' => 'Exactly equivalent to C |
||||||
2899 | terser object code than using C |
||||||
2900 | paths reduces CPU cache pressure. | ||||||
2901 | |||||||
2902 | void croak_no_modify()','name' => 'croak_no_modify'},'do_spawn' => {'text' => '','name' => 'do_spawn'},'share_hek' => {'text' => '','name' => 'share_hek'},'sv_pvutf8n' => {'text' => 'A private implementation of the C |
||||||
2903 | which can\'t cope with complex macro expressions. Always use the macro | ||||||
2904 | instead. | ||||||
2905 | |||||||
2906 | char* sv_pvutf8n(SV *sv, STRLEN *lp)','name' => 'sv_pvutf8n'},'gv_fetchpv' => {'text' => '','name' => 'gv_fetchpv'},'newSV' => {'text' => 'Creates a new SV. A non-zero C |
||||||
2907 | bytes of preallocated string space the SV should have. An extra byte for a | ||||||
2908 | trailing NUL is also reserved. (SvPOK is not set for the SV even if string | ||||||
2909 | space is allocated.) The reference count for the new SV is set to 1. | ||||||
2910 | |||||||
2911 | In 5.9.3, newSV() replaces the older NEWSV() API, and drops the first | ||||||
2912 | parameter, I |
||||||
2913 | This aid has been superseded by a new build option, PERL_MEM_LOG (see | ||||||
2914 | L |
||||||
2915 | modules supporting older perls. | ||||||
2916 | |||||||
2917 | SV* newSV(const STRLEN len)','name' => 'newSV'},'sv_2pvutf8' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV, and set *lp | ||||||
2918 | to its length. May cause the SV to be upgraded to UTF-8 as a side-effect. | ||||||
2919 | |||||||
2920 | Usually accessed via the C |
||||||
2921 | |||||||
2922 | char* sv_2pvutf8(SV *sv, STRLEN *const lp)','name' => 'sv_2pvutf8'},'dITEMS' => {'text' => 'Sets up the C |
||||||
2923 | This is usually handled automatically by C |
||||||
2924 | |||||||
2925 | dITEMS;','name' => 'dITEMS'},'save_scalar' => {'text' => '','name' => 'save_scalar'},'newSUB' => {'text' => '','name' => 'newSUB'},'pad_findmy_pv' => {'text' => 'Exactly like L, but takes a nul-terminated string | ||||||
2926 | instead of a string/length pair. | ||||||
2927 | |||||||
2928 | PADOFFSET pad_findmy_pv(const char *name, U32 flags)','name' => 'pad_findmy_pv'},'whichsig_sv' => {'text' => '','name' => 'whichsig_sv'},'despatch_signals' => {'text' => '','name' => 'despatch_signals'},'PUTBACK' => {'text' => 'Closing bracket for XSUB arguments. This is usually handled by C |
||||||
2929 | See C |
||||||
2930 | |||||||
2931 | PUTBACK;','name' => 'PUTBACK'},'dAXMARK' => {'text' => 'Sets up the C |
||||||
2932 | This is usually handled automatically by C |
||||||
2933 | |||||||
2934 | dAXMARK;','name' => 'dAXMARK'},'sv_2uv_flags' => {'text' => 'Return the unsigned integer value of an SV, doing any necessary string | ||||||
2935 | conversion. If flags includes SV_GMAGIC, does an mg_get() first. | ||||||
2936 | Normally used via the C |
||||||
2937 | |||||||
2938 | UV sv_2uv_flags(SV *const sv, const I32 flags)','name' => 'sv_2uv_flags'},'is_uni_punct' => {'text' => '','name' => 'is_uni_punct'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C |
||||||
2939 | L |
||||||
2940 | currently-compiling padlist to point to the new padlist. The following | ||||||
2941 | flags can be OR\'ed together: | ||||||
2942 | |||||||
2943 | padnew_CLONE this pad is for a cloned CV | ||||||
2944 | padnew_SAVE save old globals on the save stack | ||||||
2945 | padnew_SAVESUB also save extra stuff for start of sub | ||||||
2946 | |||||||
2947 | PADLIST * pad_new(int flags)','name' => 'pad_new'},'SvTAINTED_off' => {'text' => 'Untaints an SV. Be I |
||||||
2948 | some of Perl\'s fundamental security features. XS module authors should not | ||||||
2949 | use this function unless they fully understand all the implications of | ||||||
2950 | unconditionally untainting the value. Untainting should be done in the | ||||||
2951 | standard perl fashion, via a carefully crafted regexp, rather than directly | ||||||
2952 | untainting variables. | ||||||
2953 | |||||||
2954 | void SvTAINTED_off(SV* sv)','name' => 'SvTAINTED_off'},'require_pv' => {'text' => 'Tells Perl to C |
||||||
2955 | analogous to the Perl code C |
||||||
2956 | implemented that way; consider using load_module instead. | ||||||
2957 | |||||||
2958 | NOTE: the perl_ form of this function is deprecated. | ||||||
2959 | |||||||
2960 | void require_pv(const char* pv)','name' => 'require_pv'},'save_hdelete' => {'text' => '','name' => 'save_hdelete'},'strEQ' => {'text' => 'Test two strings to see if they are equal. Returns true or false. | ||||||
2961 | |||||||
2962 | bool strEQ(char* s1, char* s2)','name' => 'strEQ'},'sv_upgrade' => {'text' => 'Upgrade an SV to a more complex form. Generally adds a new body type to the | ||||||
2963 | SV, then copies across as much information as possible from the old body. | ||||||
2964 | It croaks if the SV is already in a more complex form than requested. You | ||||||
2965 | generally want to use the C |
||||||
2966 | before calling C |
||||||
2967 | C |
||||||
2968 | |||||||
2969 | void sv_upgrade(SV *const sv, svtype new_type)','name' => 'sv_upgrade'},'safesysmalloc' => {'text' => '','name' => 'safesysmalloc'},'save_item' => {'text' => '','name' => 'save_item'},'isUPPER' => {'text' => 'Returns a boolean indicating whether the specified character is an | ||||||
2970 | uppercase character in the platform\'s native character set. | ||||||
2971 | See the L |
||||||
2972 | C |
||||||
2973 | |||||||
2974 | bool isUPPER(char ch)','name' => 'isUPPER'},'XopENABLE' => {'text' => 'Reenable a member of the XOP which has been disabled. | ||||||
2975 | |||||||
2976 | void XopENABLE(XOP *xop, which)','name' => 'XopENABLE'},'lex_peek_unichar' => {'text' => 'Looks ahead one (Unicode) character in the text currently being lexed. | ||||||
2977 | Returns the codepoint (unsigned integer value) of the next character, | ||||||
2978 | or -1 if lexing has reached the end of the input text. To consume the | ||||||
2979 | peeked character, use L. | ||||||
2980 | |||||||
2981 | If the next character is in (or extends into) the next chunk of input | ||||||
2982 | text, the next chunk will be read in. Normally the current chunk will be | ||||||
2983 | discarded at the same time, but if I |
||||||
2984 | then the current chunk will not be discarded. | ||||||
2985 | |||||||
2986 | If the input is being interpreted as UTF-8 and a UTF-8 encoding error | ||||||
2987 | is encountered, an exception is generated. | ||||||
2988 | |||||||
2989 | NOTE: this function is experimental and may change or be | ||||||
2990 | removed without notice. | ||||||
2991 | |||||||
2992 | I32 lex_peek_unichar(U32 flags)','name' => 'lex_peek_unichar'},'sv_setsv_mg' => {'text' => 'Like C |
||||||
2993 | |||||||
2994 | void sv_setsv_mg(SV *const dstr, SV *const sstr)','name' => 'sv_setsv_mg'},'call_list' => {'text' => '','name' => 'call_list'},'croak_nocontext' => {'text' => '','name' => 'croak_nocontext'},'isLOWER' => {'text' => 'Returns a boolean indicating whether the specified character is a | ||||||
2995 | lowercase character in the platform\'s native character set. | ||||||
2996 | See the L |
||||||
2997 | C |
||||||
2998 | |||||||
2999 | bool isLOWER(char ch)','name' => 'isLOWER'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See | ||||||
3000 | C |
||||||
3001 | |||||||
3002 | char* hv_iterkey(HE* entry, I32* retlen)','name' => 'hv_iterkey'},'SvNOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a double. Checks the | ||||||
3003 | B |
||||||
3004 | |||||||
3005 | U32 SvNOKp(SV* sv)','name' => 'SvNOKp'},'nothreadhook' => {'text' => 'Stub that provides thread hook for perl_destruct when there are | ||||||
3006 | no threads. | ||||||
3007 | |||||||
3008 | int nothreadhook()','name' => 'nothreadhook'},'utf8_to_uvchr' => {'text' => 'DEPRECATED! | ||||||
3009 | |||||||
3010 | Returns the native code point of the first character in the string C |
||||||
3011 | which is assumed to be in UTF-8 encoding; C |
||||||
3012 | length, in bytes, of that character. | ||||||
3013 | |||||||
3014 | Some, but not all, UTF-8 malformations are detected, and in fact, some | ||||||
3015 | malformed input could cause reading beyond the end of the input buffer, which | ||||||
3016 | is why this function is deprecated. Use L instead. | ||||||
3017 | |||||||
3018 | If C |
||||||
3019 | enabled, zero is returned and C<*retlen> is set (if C |
||||||
3020 | NULL) to -1. If those warnings are off, the computed value if well-defined (or | ||||||
3021 | the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen> | ||||||
3022 | is set (if C |
||||||
3023 | next possible position in C |
||||||
3024 | See L for details on when the REPLACEMENT CHARACTER is returned. | ||||||
3025 | |||||||
3026 | UV utf8_to_uvchr(const U8 *s, STRLEN *retlen)','name' => 'utf8_to_uvchr'},'bytes_to_utf8' => {'text' => 'Converts a string C |
||||||
3027 | UTF-8. | ||||||
3028 | Returns a pointer to the newly-created string, and sets C |
||||||
3029 | reflect the new length in bytes. | ||||||
3030 | |||||||
3031 | A NUL character will be written after the end of the string. | ||||||
3032 | |||||||
3033 | If you want to convert to UTF-8 from encodings other than | ||||||
3034 | the native (Latin1 or EBCDIC), | ||||||
3035 | see L(). | ||||||
3036 | |||||||
3037 | NOTE: this function is experimental and may change or be | ||||||
3038 | removed without notice. | ||||||
3039 | |||||||
3040 | U8* bytes_to_utf8(const U8 *s, STRLEN *len)','name' => 'bytes_to_utf8'},'HvENAMELEN' => {'text' => 'Returns the length of the stash\'s effective name. | ||||||
3041 | |||||||
3042 | STRLEN HvENAMELEN(HV *stash)','name' => 'HvENAMELEN'},'SvIsCOW_shared_hash' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write shared hash key | ||||||
3043 | scalar. | ||||||
3044 | |||||||
3045 | bool SvIsCOW_shared_hash(SV* sv)','name' => 'SvIsCOW_shared_hash'},'start_subparse' => {'text' => '','name' => 'start_subparse'},'mg_size' => {'text' => '','name' => 'mg_size'},'to_uni_lower_lc' => {'text' => '','name' => 'to_uni_lower_lc'},'mg_free_type' => {'text' => 'Remove any magic of type I |
||||||
3046 | |||||||
3047 | void mg_free_type(SV *sv, int how)','name' => 'mg_free_type'},'sv_catsv_nomg' => {'text' => 'Like C |
||||||
3048 | |||||||
3049 | void sv_catsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_catsv_nomg'},'sv_setuv_mg' => {'text' => 'Like C |
||||||
3050 | |||||||
3051 | void sv_setuv_mg(SV *const sv, const UV u)','name' => 'sv_setuv_mg'},'sys_intern_init' => {'text' => '','name' => 'sys_intern_init'},'XS_VERSION' => {'text' => 'The version identifier for an XS module. This is usually | ||||||
3052 | handled automatically by C |
||||||
3053 | currently-executing function. Returns the offset in the current pad, | ||||||
3054 | or C |
||||||
3055 | the global one should be used instead). | ||||||
3056 | L is likely to be more convenient. | ||||||
3057 | |||||||
3058 | NOTE: the perl_ form of this function is deprecated. | ||||||
3059 | |||||||
3060 | PADOFFSET find_rundefsvoffset()','name' => 'find_rundefsvoffset'},'sv_setpv' => {'text' => 'Copies a string into an SV. The string must be null-terminated. Does not | ||||||
3061 | handle \'set\' magic. See C |
||||||
3062 | |||||||
3063 | void sv_setpv(SV *const sv, const char *const ptr)','name' => 'sv_setpv'},'hv_placeholders_set' => {'text' => '','name' => 'hv_placeholders_set'},'parse_fullstmt' => {'text' => 'Parse a single complete Perl statement. This may be a normal imperative | ||||||
3064 | statement or a declaration that has compile-time effect, and may include | ||||||
3065 | optional labels. It is up to the caller to ensure that the dynamic | ||||||
3066 | parser state (L et al) is correctly set to reflect the source | ||||||
3067 | of the code to be parsed and the lexical context for the statement. | ||||||
3068 | |||||||
3069 | The op tree representing the statement is returned. This may be a | ||||||
3070 | null pointer if the statement is null, for example if it was actually | ||||||
3071 | a subroutine definition (which has compile-time side effects). If not | ||||||
3072 | null, it will be the result of a L call, normally including | ||||||
3073 | a C |
||||||
3074 | |||||||
3075 | If an error occurs in parsing or compilation, in most cases a valid op | ||||||
3076 | tree (most likely null) is returned anyway. The error is reflected in | ||||||
3077 | the parser state, normally resulting in a single exception at the top | ||||||
3078 | level of parsing which covers all the compilation errors that occurred. | ||||||
3079 | Some compilation errors, however, will throw an exception immediately. | ||||||
3080 | |||||||
3081 | The I |
||||||
3082 | be zero. | ||||||
3083 | |||||||
3084 | NOTE: this function is experimental and may change or be | ||||||
3085 | removed without notice. | ||||||
3086 | |||||||
3087 | OP * parse_fullstmt(U32 flags)','name' => 'parse_fullstmt'},'atfork_lock' => {'text' => '','name' => 'atfork_lock'},'gv_fetchmethod' => {'text' => 'See L. | ||||||
3088 | |||||||
3089 | GV* gv_fetchmethod(HV* stash, const char* name)','name' => 'gv_fetchmethod'},'SvGROW' => {'text' => 'Expands the character buffer in the SV so that it has room for the | ||||||
3090 | indicated number of bytes (remember to reserve space for an extra trailing | ||||||
3091 | NUL character). Calls C |
||||||
3092 | Returns a pointer to the character buffer. | ||||||
3093 | |||||||
3094 | char * SvGROW(SV* sv, STRLEN len)','name' => 'SvGROW'},'dMULTICALL' => {'text' => 'Declare local variables for a multicall. See L |
||||||
3095 | |||||||
3096 | dMULTICALL;','name' => 'dMULTICALL'},'sv_catpv' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. | ||||||
3097 | If the SV has the UTF-8 status set, then the bytes appended should be | ||||||
3098 | valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C |
||||||
3099 | |||||||
3100 | void sv_catpv(SV *const sv, const char* ptr)','name' => 'sv_catpv'},'fprintf_nocontext' => {'text' => '','name' => 'fprintf_nocontext'},'sv_len' => {'text' => 'Returns the length of the string in the SV. Handles magic and type | ||||||
3101 | coercion. See also C |
||||||
3102 | |||||||
3103 | STRLEN sv_len(SV *const sv)','name' => 'sv_len'},'PerlIO_stderr' => {'text' => '','name' => 'PerlIO_stderr'},'sv_pvutf8' => {'text' => 'Use the C |
||||||
3104 | |||||||
3105 | char* sv_pvutf8(SV *sv)','name' => 'sv_pvutf8'},'SvPVbyte_nolen' => {'text' => 'Like C |
||||||
3106 | |||||||
3107 | char* SvPVbyte_nolen(SV* sv)','name' => 'SvPVbyte_nolen'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C |
||||||
3108 | |||||||
3109 | LEAVE;','name' => 'LEAVE'},'mess' => {'text' => 'Take a sprintf-style format pattern and argument list. These are used to | ||||||
3110 | generate a string message. If the message does not end with a newline, | ||||||
3111 | then it will be extended with some indication of the current location | ||||||
3112 | in the code, as described for L. | ||||||
3113 | |||||||
3114 | Normally, the resulting message is returned in a new mortal SV. | ||||||
3115 | During global destruction a single SV may be shared between uses of | ||||||
3116 | this function. | ||||||
3117 | |||||||
3118 | SV * mess(const char *pat, ...)','name' => 'mess'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See C |
||||||
3119 | made mortal, and returned to the caller. The C |
||||||
3120 | zero; if set to G_DISCARD then NULL will be returned. NULL will also be | ||||||
3121 | returned if the key is not found. C |
||||||
3122 | value, or 0 to ask for it to be computed. | ||||||
3123 | |||||||
3124 | SV* hv_delete_ent(HV *hv, SV *keysv, I32 flags, | ||||||
3125 | U32 hash)','name' => 'hv_delete_ent'},'PL_keyword_plugin' => {'text' => 'Function pointer, pointing at a function used to handle extended keywords. | ||||||
3126 | The function should be declared as | ||||||
3127 | |||||||
3128 | int keyword_plugin_function(pTHX_ | ||||||
3129 | char *keyword_ptr, STRLEN keyword_len, | ||||||
3130 | OP **op_ptr) | ||||||
3131 | |||||||
3132 | The function is called from the tokeniser, whenever a possible keyword | ||||||
3133 | is seen. C |
||||||
3134 | buffer, and C |
||||||
3135 | The function is expected to examine the word, and possibly other state | ||||||
3136 | such as L<%^H|perlvar/%^H>, to decide whether it wants to handle it | ||||||
3137 | as an extended keyword. If it does not, the function should return | ||||||
3138 | C |
||||||
3139 | |||||||
3140 | If the function wants to handle the keyword, it first must | ||||||
3141 | parse anything following the keyword that is part of the syntax | ||||||
3142 | introduced by the keyword. See L for details. | ||||||
3143 | |||||||
3144 | When a keyword is being handled, the plugin function must build | ||||||
3145 | a tree of C |
||||||
3146 | The root of the tree must be stored in C<*op_ptr>. The function then | ||||||
3147 | returns a constant indicating the syntactic role of the construct that | ||||||
3148 | it has parsed: C |
||||||
3149 | C |
||||||
3150 | construct cannot be used inside an expression (except via C |
||||||
3151 | and similar), and an expression is not a complete statement (it requires | ||||||
3152 | at least a terminating semicolon). | ||||||
3153 | |||||||
3154 | When a keyword is handled, the plugin function may also have | ||||||
3155 | (compile-time) side effects. It may modify C<%^H>, define functions, and | ||||||
3156 | so on. Typically, if side effects are the main purpose of a handler, | ||||||
3157 | it does not wish to generate any ops to be included in the normal | ||||||
3158 | compilation. In this case it is still required to supply an op tree, | ||||||
3159 | but it suffices to generate a single null op. | ||||||
3160 | |||||||
3161 | That\'s how the C<*PL_keyword_plugin> function needs to behave overall. | ||||||
3162 | Conventionally, however, one does not completely replace the existing | ||||||
3163 | handler function. Instead, take a copy of C |
||||||
3164 | assigning your own function pointer to it. Your handler function should | ||||||
3165 | look for keywords that it is interested in and handle those. Where it | ||||||
3166 | is not interested, it should call the saved plugin function, passing on | ||||||
3167 | the arguments it received. Thus C |
||||||
3168 | at a chain of handler functions, all of which have an opportunity to | ||||||
3169 | handle keywords, and only the last function in the chain (built into | ||||||
3170 | the Perl core) will normally return C |
||||||
3171 | |||||||
3172 | NOTE: this function is experimental and may change or be | ||||||
3173 | removed without notice.','name' => 'PL_keyword_plugin'},'LINKLIST' => {'text' => 'Given the root of an optree, link the tree in execution order using the | ||||||
3174 | C |
||||||
3175 | already been done, it will not be redone, and C<< o->op_next >> will be | ||||||
3176 | returned. If C<< o->op_next >> is not already set, I |
||||||
3177 | least an C |
||||||
3178 | |||||||
3179 | OP* LINKLIST(OP *o)','name' => 'LINKLIST'},'utf8_to_uvuni_buf' => {'text' => 'Returns the Unicode code point of the first character in the string C |
||||||
3180 | is assumed to be in UTF-8 encoding; C |
||||||
3181 | C |
||||||
3182 | |||||||
3183 | This function should only be used when the returned UV is considered | ||||||
3184 | an index into the Unicode semantic tables (e.g. swashes). | ||||||
3185 | |||||||
3186 | If C |
||||||
3187 | enabled, zero is returned and C<*retlen> is set (if C |
||||||
3188 | NULL) to -1. If those warnings are off, the computed value if well-defined (or | ||||||
3189 | the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen> | ||||||
3190 | is set (if C |
||||||
3191 | next possible position in C |
||||||
3192 | See L for details on when the REPLACEMENT CHARACTER is returned. | ||||||
3193 | |||||||
3194 | UV utf8_to_uvuni_buf(const U8 *s, const U8 *send, | ||||||
3195 | STRLEN *retlen)','name' => 'utf8_to_uvuni_buf'},'cast_iv' => {'text' => '','name' => 'cast_iv'},'savesvpv' => {'text' => 'A version of C |
||||||
3196 | the passed in SV using C |
||||||
3197 | |||||||
3198 | char* savesvpv(SV* sv)','name' => 'savesvpv'},'CLASS' => {'text' => 'Variable which is setup by C |
||||||
3199 | class name for a C++ XS constructor. This is always a C |
||||||
3200 | |||||||
3201 | char* CLASS','name' => 'CLASS'},'newAVREF' => {'text' => '','name' => 'newAVREF'},'foldEQ_latin1' => {'text' => '','name' => 'foldEQ_latin1'},'HeKLEN' => {'text' => 'If this is negative, and amounts to C |
||||||
3202 | holds an C |
||||||
3203 | be assigned to. The C |
||||||
3204 | lengths. | ||||||
3205 | |||||||
3206 | STRLEN HeKLEN(HE* he)','name' => 'HeKLEN'},'sv_pvn_force_flags' => {'text' => 'Get a sensible string out of the SV somehow. | ||||||
3207 | If C |
||||||
3208 | appropriate, else not. C |
||||||
3209 | implemented in terms of this function. | ||||||
3210 | You normally want to use the various wrapper macros instead: see | ||||||
3211 | C |
||||||
3212 | |||||||
3213 | char* sv_pvn_force_flags(SV *const sv, | ||||||
3214 | STRLEN *const lp, | ||||||
3215 | const I32 flags)','name' => 'sv_pvn_force_flags'},'sv_setpvf_mg_nocontext' => {'text' => '','name' => 'sv_setpvf_mg_nocontext'},'parse_termexpr' => {'text' => 'Parse a Perl term expression. This may contain operators of precedence | ||||||
3216 | down to the assignment operators. The expression must be followed (and thus | ||||||
3217 | terminated) either by a comma or lower-precedence operator or by | ||||||
3218 | something that would normally terminate an expression such as semicolon. | ||||||
3219 | If I |
||||||
3220 | otherwise it is mandatory. It is up to the caller to ensure that the | ||||||
3221 | dynamic parser state (L et al) is correctly set to reflect | ||||||
3222 | the source of the code to be parsed and the lexical context for the | ||||||
3223 | expression. | ||||||
3224 | |||||||
3225 | The op tree representing the expression is returned. If an optional | ||||||
3226 | expression is absent, a null pointer is returned, otherwise the pointer | ||||||
3227 | will be non-null. | ||||||
3228 | |||||||
3229 | If an error occurs in parsing or compilation, in most cases a valid op | ||||||
3230 | tree is returned anyway. The error is reflected in the parser state, | ||||||
3231 | normally resulting in a single exception at the top level of parsing | ||||||
3232 | which covers all the compilation errors that occurred. Some compilation | ||||||
3233 | errors, however, will throw an exception immediately. | ||||||
3234 | |||||||
3235 | NOTE: this function is experimental and may change or be | ||||||
3236 | removed without notice. | ||||||
3237 | |||||||
3238 | OP * parse_termexpr(U32 flags)','name' => 'parse_termexpr'},'mPUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. | ||||||
3239 | Does not use C |
||||||
3240 | |||||||
3241 | void mPUSHi(IV iv)','name' => 'mPUSHi'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. | ||||||
3242 | Handles \'set\' magic. Uses C |
||||||
3243 | called to declare it. Do not call multiple C |
||||||
3244 | return lists from XSUB\'s - see C |
||||||
3245 | C |
||||||
3246 | |||||||
3247 | void PUSHn(NV nv)','name' => 'PUSHn'},'to_utf8_title' => {'text' => 'Convert the UTF-8 encoded character at C to its titlecase version and |
||||||
3248 | store that in UTF-8 in C |
||||||
3249 | that the C |
||||||
3250 | titlecase version may be longer than the original character. | ||||||
3251 | |||||||
3252 | The first character of the titlecased version is returned | ||||||
3253 | (but note, as explained above, that there may be more.) | ||||||
3254 | |||||||
3255 | The character at C is assumed by this routine to be well-formed. |
||||||
3256 | |||||||
3257 | UV to_utf8_title(const U8 *p, U8* ustrp, | ||||||
3258 | STRLEN *lenp)','name' => 'to_utf8_title'},'PerlIO_unread' => {'text' => '','name' => 'PerlIO_unread'},'gv_fullname' => {'text' => '','name' => 'gv_fullname'},'PL_sv_yes' => {'text' => 'This is the C |
||||||
3259 | C<&PL_sv_yes>. | ||||||
3260 | |||||||
3261 | SV PL_sv_yes','name' => 'PL_sv_yes'},'pregfree' => {'text' => '','name' => 'pregfree'},'sv_nosharing' => {'text' => 'Dummy routine which "shares" an SV when there is no sharing module present. | ||||||
3262 | Or "locks" it. Or "unlocks" it. In other words, ignores its single SV argument. | ||||||
3263 | Exists to avoid test for a NULL function pointer and because it could | ||||||
3264 | potentially warn under some level of strict-ness. | ||||||
3265 | |||||||
3266 | void sv_nosharing(SV *sv)','name' => 'sv_nosharing'},'ck_entersub_args_list' => {'text' => 'Performs the default fixup of the arguments part of an C |
||||||
3267 | op tree. This consists of applying list context to each of the | ||||||
3268 | argument ops. This is the standard treatment used on a call marked | ||||||
3269 | with C<&>, or a method call, or a call through a subroutine reference, | ||||||
3270 | or any other call where the callee can\'t be identified at compile time, | ||||||
3271 | or a call where the callee has no prototype. | ||||||
3272 | |||||||
3273 | OP * ck_entersub_args_list(OP *entersubop)','name' => 'ck_entersub_args_list'},'ck_warner' => {'text' => '','name' => 'ck_warner'},'is_ascii_string' => {'text' => 'Returns true if the first C |
||||||
3274 | or not the string is encoded in UTF-8 (or UTF-EBCDIC on EBCDIC machines). That | ||||||
3275 | is, if they are invariant. On ASCII-ish machines, only ASCII characters | ||||||
3276 | fit this definition, hence the function\'s name. | ||||||
3277 | |||||||
3278 | If C |
||||||
3279 | |||||||
3280 | See also L(), L(), and L(). | ||||||
3281 | |||||||
3282 | bool is_ascii_string(const U8 *s, STRLEN len)','name' => 'is_ascii_string'},'SvUTF8_off' => {'text' => 'Unsets the UTF-8 status of an SV (the data is not changed, just the flag). | ||||||
3283 | Do not use frivolously. | ||||||
3284 | |||||||
3285 | void SvUTF8_off(SV *sv)','name' => 'SvUTF8_off'},'sv_dec_nomg' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion | ||||||
3286 | if necessary. Handles operator overloading. Skips handling \'get\' magic. | ||||||
3287 | |||||||
3288 | void sv_dec_nomg(SV *const sv)','name' => 'sv_dec_nomg'},'looks_like_number' => {'text' => 'Test if the content of an SV looks like a number (or is a number). | ||||||
3289 | C |
||||||
3290 | non-numeric warning), even if your atof() doesn\'t grok them. Get-magic is | ||||||
3291 | ignored. | ||||||
3292 | |||||||
3293 | I32 looks_like_number(SV *const sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C |
||||||
3294 | |||||||
3295 | void sv_catpv_mg(SV *const sv, const char *const ptr)','name' => 'sv_catpv_mg'},'save_vptr' => {'text' => '','name' => 'save_vptr'},'OP_NAME' => {'text' => 'Return the name of the provided OP. For core ops this looks up the name | ||||||
3296 | from the op_type; for custom ops from the op_ppaddr. | ||||||
3297 | |||||||
3298 | const char * OP_NAME(OP *o)','name' => 'OP_NAME'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. | ||||||
3299 | |||||||
3300 | XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'mro_get_private_data' => {'text' => '','name' => 'mro_get_private_data'},'XS_APIVERSION_BOOTCHECK' => {'text' => 'Macro to verify that the perl api version an XS module has been compiled against | ||||||
3301 | matches the api version of the perl interpreter it\'s being loaded into. | ||||||
3302 | |||||||
3303 | XS_APIVERSION_BOOTCHECK;','name' => 'XS_APIVERSION_BOOTCHECK'},'hv_delayfree_ent' => {'text' => '','name' => 'hv_delayfree_ent'},'sv_setpvf' => {'text' => 'Works like C |
||||||
3304 | appending it. Does not handle \'set\' magic. See C |
||||||
3305 | |||||||
3306 | void sv_setpvf(SV *const sv, const char *const pat, | ||||||
3307 | ...)','name' => 'sv_setpvf'},'custom_op_register' => {'text' => 'Register a custom op. See L |
||||||
3308 | |||||||
3309 | NOTE: this function must be explicitly called as Perl_custom_op_register with an aTHX_ parameter. | ||||||
3310 | |||||||
3311 | void Perl_custom_op_register(pTHX_ | ||||||
3312 | Perl_ppaddr_t ppaddr, | ||||||
3313 | const XOP *xop)','name' => 'custom_op_register'},'scan_num' => {'text' => '','name' => 'scan_num'},'save_int' => {'text' => '','name' => 'save_int'},'call_sv' => {'text' => 'Performs a callback to the Perl sub whose name is in the SV. See | ||||||
3314 | L |
||||||
3315 | |||||||
3316 | NOTE: the perl_ form of this function is deprecated. | ||||||
3317 | |||||||
3318 | I32 call_sv(SV* sv, VOL I32 flags)','name' => 'call_sv'},'SVt_PV' => {'text' => 'Pointer type flag for scalars. See C |
||||||
3319 | C |
||||||
3320 | |||||||
3321 | bool strGT(char* s1, char* s2)','name' => 'strGT'},'is_uni_alnum' => {'text' => '','name' => 'is_uni_alnum'},'mXPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary and mortalizes | ||||||
3322 | the SV. Does not use C |
||||||
3323 | |||||||
3324 | void mXPUSHs(SV* sv)','name' => 'mXPUSHs'},'POPl' => {'text' => 'Pops a long off the stack. | ||||||
3325 | |||||||
3326 | long POPl','name' => 'POPl'},'init_i18nl14n' => {'text' => '','name' => 'init_i18nl14n'},'scan_version' => {'text' => 'Returns a pointer to the next character after the parsed | ||||||
3327 | version string, as well as upgrading the passed in SV to | ||||||
3328 | an RV. | ||||||
3329 | |||||||
3330 | Function must be called with an already existing SV like | ||||||
3331 | |||||||
3332 | sv = newSV(0); | ||||||
3333 | s = scan_version(s, SV *sv, bool qv); | ||||||
3334 | |||||||
3335 | Performs some preprocessing to the string to ensure that | ||||||
3336 | it has the correct characteristics of a version. Flags the | ||||||
3337 | object if it contains an underscore (which denotes this | ||||||
3338 | is an alpha version). The boolean qv denotes that the version | ||||||
3339 | should be interpreted as if it had multiple decimals, even if | ||||||
3340 | it doesn\'t. | ||||||
3341 | |||||||
3342 | const char* scan_version(const char *s, SV *rv, bool qv)','name' => 'scan_version'},'hv_common_key_len' => {'text' => '','name' => 'hv_common_key_len'},'get_cv' => {'text' => 'Uses C |
||||||
3343 | |||||||
3344 | NOTE: the perl_ form of this function is deprecated. | ||||||
3345 | |||||||
3346 | CV* get_cv(const char* name, I32 flags)','name' => 'get_cv'},'vnumify' => {'text' => 'Accepts a version object and returns the normalized floating | ||||||
3347 | point representation. Call like: | ||||||
3348 | |||||||
3349 | sv = vnumify(rv); | ||||||
3350 | |||||||
3351 | NOTE: you can pass either the object directly or the SV | ||||||
3352 | contained within the RV. | ||||||
3353 | |||||||
3354 | The SV returned has a refcount of 1. | ||||||
3355 | |||||||
3356 | SV* vnumify(SV *vs)','name' => 'vnumify'},'SvIOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains an integer. Checks | ||||||
3357 | the B |
||||||
3358 | |||||||
3359 | U32 SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C |
||||||
3360 | stack. | ||||||
3361 | |||||||
3362 | void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'ptr_table_free' => {'text' => '','name' => 'ptr_table_free'},'SvUNLOCK' => {'text' => 'Releases a mutual exclusion lock on sv if a suitable module | ||||||
3363 | has been loaded. | ||||||
3364 | |||||||
3365 | void SvUNLOCK(SV* sv)','name' => 'SvUNLOCK'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C |
||||||
3366 | |||||||
3367 | 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 |
||||||
3368 | The new SV is marked as mortal. It will be destroyed "soon", either by an | ||||||
3369 | explicit call to FREETMPS, or by an implicit call at places such as | ||||||
3370 | statement boundaries. See also C |
||||||
3371 | |||||||
3372 | SV* sv_mortalcopy(SV *const oldsv)','name' => 'sv_mortalcopy'},'is_utf8_space' => {'text' => '','name' => 'is_utf8_space'},'cophh_fetch_sv' => {'text' => 'Like L, but takes a Perl scalar instead of a | ||||||
3373 | string/length pair. | ||||||
3374 | |||||||
3375 | NOTE: this function is experimental and may change or be | ||||||
3376 | removed without notice. | ||||||
3377 | |||||||
3378 | SV * cophh_fetch_sv(const COPHH *cophh, SV *key, | ||||||
3379 | U32 hash, U32 flags)','name' => 'cophh_fetch_sv'},'sv_catpvn_nomg' => {'text' => 'Like C |
||||||
3380 | |||||||
3381 | void sv_catpvn_nomg(SV* sv, const char* ptr, | ||||||
3382 | STRLEN len)','name' => 'sv_catpvn_nomg'},'newHVhv' => {'text' => '','name' => 'newHVhv'},'newSVpvs_flags' => {'text' => 'Like C |
||||||
3383 | pair. | ||||||
3384 | |||||||
3385 | SV* newSVpvs_flags(const char* s, U32 flags)','name' => 'newSVpvs_flags'},'savepvn' => {'text' => 'Perl\'s version of what C |
||||||
3386 | pointer to a newly allocated string which is a duplicate of the first | ||||||
3387 | C |
||||||
3388 | the new string can be freed with the C |
||||||
3389 | |||||||
3390 | char* savepvn(const char* pv, I32 len)','name' => 'savepvn'},'pad_findmy_sv' => {'text' => 'Exactly like L, but takes the name string in the form | ||||||
3391 | of an SV instead of a string/length pair. | ||||||
3392 | |||||||
3393 | PADOFFSET pad_findmy_sv(SV *name, U32 flags)','name' => 'pad_findmy_sv'},'av_exists' => {'text' => 'Returns true if the element indexed by C |
||||||
3394 | |||||||
3395 | This relies on the fact that uninitialized array elements are set to | ||||||
3396 | C<&PL_sv_undef>. | ||||||
3397 | |||||||
3398 | Perl equivalent: C |
||||||
3399 | |||||||
3400 | bool av_exists(AV *av, I32 key)','name' => 'av_exists'},'cophh_delete_sv' => {'text' => 'Like L, but takes a Perl scalar instead of a | ||||||
3401 | string/length pair. | ||||||
3402 | |||||||
3403 | NOTE: this function is experimental and may change or be | ||||||
3404 | removed without notice. | ||||||
3405 | |||||||
3406 | COPHH * cophh_delete_sv(const COPHH *cophh, SV *key, | ||||||
3407 | U32 hash, U32 flags)','name' => 'cophh_delete_sv'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C |
||||||
3408 | |||||||
3409 | STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'sv_2nv_flags' => {'text' => 'Return the num value of an SV, doing any necessary string or integer | ||||||
3410 | conversion. If flags includes SV_GMAGIC, does an mg_get() first. | ||||||
3411 | Normally used via the C |
||||||
3412 | |||||||
3413 | NV sv_2nv_flags(SV *const sv, const I32 flags)','name' => 'sv_2nv_flags'},'gv_init' => {'text' => 'The old form of gv_init_pvn(). It does not work with UTF8 strings, as it | ||||||
3414 | has no flags parameter. If the C |
||||||
3415 | GV_ADDMULTI flag will be passed to gv_init_pvn(). | ||||||
3416 | |||||||
3417 | void gv_init(GV* gv, HV* stash, const char* name, | ||||||
3418 | STRLEN len, int multi)','name' => 'gv_init'},'sv_bless' => {'text' => 'Blesses an SV into a specified package. The SV must be an RV. The package | ||||||
3419 | must be designated by its stash (see C |
||||||
3420 | of the SV is unaffected. | ||||||
3421 | |||||||
3422 | SV* sv_bless(SV *const sv, HV *const stash)','name' => 'sv_bless'},'cv_set_call_checker' => {'text' => 'Sets the function that will be used to fix up a call to I |
||||||
3423 | Specifically, the function is applied to an C |
||||||
3424 | subroutine call, not marked with C<&>, where the callee can be identified | ||||||
3425 | at compile time as I |
||||||
3426 | |||||||
3427 | The C-level function pointer is supplied in I |
||||||
3428 | for it is supplied in I |
||||||
3429 | in this manner: | ||||||
3430 | |||||||
3431 | entersubop = ckfun(aTHX_ entersubop, namegv, ckobj); | ||||||
3432 | |||||||
3433 | In this call, I |
||||||
3434 | which may be replaced by the check function, and I |
||||||
3435 | supplying the name that should be used by the check function to refer | ||||||
3436 | to the callee of the C |
||||||
3437 | It is permitted to apply the check function in non-standard situations, | ||||||
3438 | such as to a call to a different subroutine or to a method call. | ||||||
3439 | |||||||
3440 | The current setting for a particular CV can be retrieved by | ||||||
3441 | L. | ||||||
3442 | |||||||
3443 | void cv_set_call_checker(CV *cv, | ||||||
3444 | Perl_call_checker ckfun, | ||||||
3445 | SV *ckobj)','name' => 'cv_set_call_checker'},'save_ary' => {'text' => '','name' => 'save_ary'},'sv_2io' => {'text' => 'Using various gambits, try to get an IO from an SV: the IO slot if its a | ||||||
3446 | GV; or the recursive result if we\'re an RV; or the IO slot of the symbol | ||||||
3447 | named after the PV if we\'re a string. | ||||||
3448 | |||||||
3449 | \'Get\' magic is ignored on the sv passed in, but will be called on | ||||||
3450 | C |
||||||
3451 | |||||||
3452 | IO* sv_2io(SV *const sv)','name' => 'sv_2io'},'SvMAGIC_set' => {'text' => 'Set the value of the MAGIC pointer in sv to val. See C |
||||||
3453 | |||||||
3454 | void SvMAGIC_set(SV* sv, MAGIC* val)','name' => 'SvMAGIC_set'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the specified character is an | ||||||
3455 | alphabetic character in the platform\'s native character set. | ||||||
3456 | See the L |
||||||
3457 | C |
||||||
3458 | |||||||
3459 | bool isALPHA(char ch)','name' => 'isALPHA'},'newSVhek' => {'text' => 'Creates a new SV from the hash key structure. It will generate scalars that | ||||||
3460 | point to the shared string table where possible. Returns a new (undefined) | ||||||
3461 | SV if the hek is NULL. | ||||||
3462 | |||||||
3463 | SV* newSVhek(const HEK *const hek)','name' => 'newSVhek'},'taint_env' => {'text' => '','name' => 'taint_env'},'Nullhv' => {'text' => 'Null HV pointer. | ||||||
3464 | |||||||
3465 | (deprecated - use C<(HV *)NULL> instead)','name' => 'Nullhv'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV. | ||||||
3466 | |||||||
3467 | All of the following SvREFCNT_inc* macros are optimized versions of | ||||||
3468 | SvREFCNT_inc, and can be replaced with SvREFCNT_inc. | ||||||
3469 | |||||||
3470 | SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'newGVgen_flags' => {'text' => '','name' => 'newGVgen_flags'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C |
||||||
3471 | |||||||
3472 | svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'block_gimme' => {'text' => '','name' => 'block_gimme'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. | ||||||
3473 | |||||||
3474 | void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C |
||||||
3475 | |||||||
3476 | void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'XPUSHmortal' => {'text' => 'Push a new mortal SV onto the stack, extending the stack if necessary. | ||||||
3477 | Does not use C |
||||||
3478 | |||||||
3479 | void XPUSHmortal()','name' => 'XPUSHmortal'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. | ||||||
3480 | |||||||
3481 | void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'SvVOK' => {'text' => 'Returns a boolean indicating whether the SV contains a v-string. | ||||||
3482 | |||||||
3483 | bool SvVOK(SV* sv)','name' => 'SvVOK'},'whichsig_pvn' => {'text' => '','name' => 'whichsig_pvn'},'sv_setpvf_mg' => {'text' => 'Like C |
||||||
3484 | |||||||
3485 | void sv_setpvf_mg(SV *const sv, | ||||||
3486 | const char *const pat, ...)','name' => 'sv_setpvf_mg'},'my_chsize' => {'text' => '','name' => 'my_chsize'},'newLISTOP' => {'text' => 'Constructs, checks, and returns an op of any list type. I |
||||||
3487 | the opcode. I |
||||||
3488 | C |
||||||
3489 | supply up to two ops to be direct children of the list op; they are | ||||||
3490 | consumed by this function and become part of the constructed op tree. | ||||||
3491 | |||||||
3492 | OP * newLISTOP(I32 type, I32 flags, OP *first, | ||||||
3493 | OP *last)','name' => 'newLISTOP'},'sv_setref_pv' => {'text' => 'Copies a pointer into a new SV, optionally blessing the SV. The C |
||||||
3494 | argument will be upgraded to an RV. That RV will be modified to point to | ||||||
3495 | the new SV. If the C |
||||||
3496 | into the SV. The C |
||||||
3497 | blessing. Set C |
||||||
3498 | will have a reference count of 1, and the RV will be returned. | ||||||
3499 | |||||||
3500 | Do not use with other Perl types such as HV, AV, SV, CV, because those | ||||||
3501 | objects will become corrupted by the pointer copy process. | ||||||
3502 | |||||||
3503 | Note that C |
||||||
3504 | |||||||
3505 | SV* sv_setref_pv(SV *const rv, | ||||||
3506 | const char *const classname, | ||||||
3507 | void *const pv)','name' => 'sv_setref_pv'},'fbm_compile' => {'text' => 'Analyses the string in order to make fast searches on it using fbm_instr() | ||||||
3508 | -- the Boyer-Moore algorithm. | ||||||
3509 | |||||||
3510 | void fbm_compile(SV* sv, U32 flags)','name' => 'fbm_compile'},'SvNIOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains a number, integer or | ||||||
3511 | double. Checks the B |
||||||
3512 | |||||||
3513 | U32 SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'PERL_SYS_TERM' => {'text' => 'Provides system-specific clean up of the C runtime environment after | ||||||
3514 | running Perl interpreters. This should be called only once, after | ||||||
3515 | freeing any remaining Perl interpreters. | ||||||
3516 | |||||||
3517 | void PERL_SYS_TERM()','name' => 'PERL_SYS_TERM'},'is_uni_alnum_lc' => {'text' => '','name' => 'is_uni_alnum_lc'},'mro_register' => {'text' => 'Registers a custom mro plugin. See L |
||||||
3518 | |||||||
3519 | void mro_register(const struct mro_alg *mro)','name' => 'mro_register'},'vnewSVpvf' => {'text' => '','name' => 'vnewSVpvf'},'rv2cv_op_cv' => {'text' => 'Examines an op, which is expected to identify a subroutine at runtime, | ||||||
3520 | and attempts to determine at compile time which subroutine it identifies. | ||||||
3521 | This is normally used during Perl compilation to determine whether | ||||||
3522 | a prototype can be applied to a function call. I |
||||||
3523 | being considered, normally an C |
||||||
3524 | subroutine is returned, if it could be determined statically, and a null | ||||||
3525 | pointer is returned if it was not possible to determine statically. | ||||||
3526 | |||||||
3527 | Currently, the subroutine can be identified statically if the RV that the | ||||||
3528 | C |
||||||
3529 | A C |
||||||
3530 | suitable if the constant value must be an RV pointing to a CV. Details of | ||||||
3531 | this process may change in future versions of Perl. If the C |
||||||
3532 | has the C |
||||||
3533 | the subroutine statically: this flag is used to suppress compile-time | ||||||
3534 | magic on a subroutine call, forcing it to use default runtime behaviour. | ||||||
3535 | |||||||
3536 | If I |
||||||
3537 | of a GV reference is modified. If a GV was examined and its CV slot was | ||||||
3538 | found to be empty, then the C |
||||||
3539 | If the op is not optimised away, and the CV slot is later populated with | ||||||
3540 | a subroutine having a prototype, that flag eventually triggers the warning | ||||||
3541 | "called too early to check prototype". | ||||||
3542 | |||||||
3543 | If I |
||||||
3544 | of returning a pointer to the subroutine it returns a pointer to the | ||||||
3545 | GV giving the most appropriate name for the subroutine in this context. | ||||||
3546 | Normally this is just the C |
||||||
3547 | (C |
||||||
3548 | referencing GV. The resulting C |
||||||
3549 | A null pointer is returned as usual if there is no statically-determinable | ||||||
3550 | subroutine. | ||||||
3551 | |||||||
3552 | CV * rv2cv_op_cv(OP *cvop, U32 flags)','name' => 'rv2cv_op_cv'},'sv_len_utf8' => {'text' => 'Returns the number of characters in the string in an SV, counting wide | ||||||
3553 | UTF-8 bytes as a single character. Handles magic and type coercion. | ||||||
3554 | |||||||
3555 | STRLEN sv_len_utf8(SV *const sv)','name' => 'sv_len_utf8'},'PerlIO_set_cnt' => {'text' => '','name' => 'PerlIO_set_cnt'},'SvREFCNT_inc_simple_void' => {'text' => 'Same as SvREFCNT_inc_simple, but can only be used if you don\'t need the | ||||||
3556 | return value. The macro doesn\'t need to return a meaningful value. | ||||||
3557 | |||||||
3558 | void SvREFCNT_inc_simple_void(SV* sv)','name' => 'SvREFCNT_inc_simple_void'},'cx_dup' => {'text' => '','name' => 'cx_dup'},'hv_clear_placeholders' => {'text' => 'Clears any placeholders from a hash. If a restricted hash has any of its keys | ||||||
3559 | marked as readonly and the key is subsequently deleted, the key is not actually | ||||||
3560 | deleted but is marked by assigning it a value of &PL_sv_placeholder. This tags | ||||||
3561 | it so it will be ignored by future operations such as iterating over the hash, | ||||||
3562 | but will still allow the hash to have a value reassigned to the key at some | ||||||
3563 | future point. This function clears any such placeholder keys from the hash. | ||||||
3564 | See Hash::Util::lock_keys() for an example of its use. | ||||||
3565 | |||||||
3566 | void hv_clear_placeholders(HV *hv)','name' => 'hv_clear_placeholders'},'dAX' => {'text' => 'Sets up the C |
||||||
3567 | This is usually handled automatically by C |
||||||
3568 | |||||||
3569 | dAX;','name' => 'dAX'},'SvRV_set' => {'text' => 'Set the value of the RV pointer in sv to val. See C |
||||||
3570 | |||||||
3571 | void SvRV_set(SV* sv, SV* val)','name' => 'SvRV_set'},'grok_number' => {'text' => 'Recognise (or not) a number. The type of the number is returned | ||||||
3572 | (0 if unrecognised), otherwise it is a bit-ORed combination of | ||||||
3573 | IS_NUMBER_IN_UV, IS_NUMBER_GREATER_THAN_UV_MAX, IS_NUMBER_NOT_INT, | ||||||
3574 | IS_NUMBER_NEG, IS_NUMBER_INFINITY, IS_NUMBER_NAN (defined in perl.h). | ||||||
3575 | |||||||
3576 | If the value of the number can fit an in UV, it is returned in the *valuep | ||||||
3577 | IS_NUMBER_IN_UV will be set to indicate that *valuep is valid, IS_NUMBER_IN_UV | ||||||
3578 | will never be set unless *valuep is valid, but *valuep may have been assigned | ||||||
3579 | to during processing even though IS_NUMBER_IN_UV is not set on return. | ||||||
3580 | If valuep is NULL, IS_NUMBER_IN_UV will be set for the same cases as when | ||||||
3581 | valuep is non-NULL, but no actual assignment (or SEGV) will occur. | ||||||
3582 | |||||||
3583 | IS_NUMBER_NOT_INT will be set with IS_NUMBER_IN_UV if trailing decimals were | ||||||
3584 | seen (in which case *valuep gives the true value truncated to an integer), and | ||||||
3585 | IS_NUMBER_NEG if the number is negative (in which case *valuep holds the | ||||||
3586 | absolute value). IS_NUMBER_IN_UV is not set if e notation was used or the | ||||||
3587 | number is larger than a UV. | ||||||
3588 | |||||||
3589 | int grok_number(const char *pv, STRLEN len, | ||||||
3590 | UV *valuep)','name' => 'grok_number'},'csighandler' => {'text' => '','name' => 'csighandler'},'SvIVx' => {'text' => 'Coerces the given SV to an integer and returns it. | ||||||
3591 | Guarantees to evaluate C |
||||||
3592 | this if C |
||||||
3593 | otherwise use the more efficient C |
||||||
3594 | |||||||
3595 | IV SvIVx(SV* sv)','name' => 'SvIVx'},'grok_numeric_radix' => {'text' => 'Scan and skip for a numeric decimal separator (radix). | ||||||
3596 | |||||||
3597 | bool grok_numeric_radix(const char **sp, | ||||||
3598 | const char *send)','name' => 'grok_numeric_radix'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C |
||||||
3599 | stack. | ||||||
3600 | |||||||
3601 | void XST_mNO(int pos)','name' => 'XST_mNO'},'gp_dup' => {'text' => '','name' => 'gp_dup'},'sv_derived_from_pv' => {'text' => 'Exactly like L, but takes a nul-terminated string | ||||||
3602 | instead of a string/length pair. | ||||||
3603 | |||||||
3604 | bool sv_derived_from_pv(SV* sv, | ||||||
3605 | const char *const name, | ||||||
3606 | U32 flags)','name' => 'sv_derived_from_pv'},'savepvs' => {'text' => 'Like C |
||||||
3607 | |||||||
3608 | char* savepvs(const char* s)','name' => 'savepvs'},'SvSTASH_set' => {'text' => 'Set the value of the STASH pointer in sv to val. See C |
||||||
3609 | |||||||
3610 | void SvSTASH_set(SV* sv, HV* val)','name' => 'SvSTASH_set'},'sv_catpv_nomg' => {'text' => 'Like C |
||||||
3611 | |||||||
3612 | void sv_catpv_nomg(SV* sv, const char* ptr)','name' => 'sv_catpv_nomg'},'ZeroD' => {'text' => 'Like C |
||||||
3613 | optimise. | ||||||
3614 | |||||||
3615 | void * ZeroD(void* dest, int nitems, type)','name' => 'ZeroD'},'sv_collxfrm' => {'text' => 'This calls C |
||||||
3616 | C |
||||||
3617 | |||||||
3618 | char* sv_collxfrm(SV *const sv, STRLEN *const nxp)','name' => 'sv_collxfrm'},'swash_fetch' => {'text' => '','name' => 'swash_fetch'},'SP' => {'text' => 'Stack pointer. This is usually handled by C |
||||||
3619 | C |
||||||
3620 | |||||||
3621 | void sv_catpvn_mg(SV *sv, const char *ptr, | ||||||
3622 | STRLEN len)','name' => 'sv_catpvn_mg'},'op_lvalue' => {'text' => 'Propagate lvalue ("modifiable") context to an op and its children. | ||||||
3623 | I |
||||||
3624 | would do the modifying, although C |
||||||
3625 | because it has no op type of its own (it is signalled by a flag on | ||||||
3626 | the lvalue op). | ||||||
3627 | |||||||
3628 | This function detects things that can\'t be modified, such as C<$x+1>, and | ||||||
3629 | generates errors for them. For example, C<$x+1 = 2> would cause it to be | ||||||
3630 | called with an op of type OP_ADD and a C |
||||||
3631 | |||||||
3632 | It also flags things that need to behave specially in an lvalue context, | ||||||
3633 | such as C<$$x = 5> which might have to vivify a reference in C<$x>. | ||||||
3634 | |||||||
3635 | NOTE: this function is experimental and may change or be | ||||||
3636 | removed without notice. | ||||||
3637 | |||||||
3638 | OP * op_lvalue(OP *o, I32 type)','name' => 'op_lvalue'},'dirp_dup' => {'text' => '','name' => 'dirp_dup'},'is_uni_upper' => {'text' => '','name' => 'is_uni_upper'},'gv_stashpvs' => {'text' => 'Like C |
||||||
3639 | |||||||
3640 | HV* gv_stashpvs(const char* name, I32 create)','name' => 'gv_stashpvs'},'Zero' => {'text' => 'The XSUB-writer\'s interface to the C C |
||||||
3641 | destination, C |
||||||
3642 | |||||||
3643 | void Zero(void* dest, int nitems, type)','name' => 'Zero'},'vcmp' => {'text' => 'Version object aware cmp. Both operands must already have been | ||||||
3644 | converted into version objects. | ||||||
3645 | |||||||
3646 | int vcmp(SV *lhv, SV *rhv)','name' => 'vcmp'},'SvSTASH' => {'text' => 'Returns the stash of the SV. | ||||||
3647 | |||||||
3648 | HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C |
||||||
3649 | |||||||
3650 | XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_iv' => {'text' => 'A private implementation of the C |
||||||
3651 | cope with complex macro expressions. Always use the macro instead. | ||||||
3652 | |||||||
3653 | IV sv_iv(SV* sv)','name' => 'sv_iv'},'PL_parser-E |
||||||
3654 | end of the lexer buffer. This is equal to C |
||||||
3655 | + SvCUR(PL_parser-E |
||||||
3656 | always located at the end of the buffer, and does not count as part of | ||||||
3657 | the buffer\'s contents. | ||||||
3658 | |||||||
3659 | NOTE: this function is experimental and may change or be | ||||||
3660 | removed without notice.','name' => 'PL_parser-E |
||||||
3661 | dsv such that the size of the escaped string will not exceed "max" chars | ||||||
3662 | and will not contain any incomplete escape sequences. | ||||||
3663 | |||||||
3664 | If flags contains PERL_PV_ESCAPE_QUOTE then any double quotes in the string | ||||||
3665 | will also be escaped. | ||||||
3666 | |||||||
3667 | Normally the SV will be cleared before the escaped string is prepared, | ||||||
3668 | but when PERL_PV_ESCAPE_NOCLEAR is set this will not occur. | ||||||
3669 | |||||||
3670 | If PERL_PV_ESCAPE_UNI is set then the input string is treated as Unicode, | ||||||
3671 | if PERL_PV_ESCAPE_UNI_DETECT is set then the input string is scanned | ||||||
3672 | using C |
||||||
3673 | |||||||
3674 | If PERL_PV_ESCAPE_ALL is set then all input chars will be output | ||||||
3675 | using C<\\x01F1> style escapes, otherwise if PERL_PV_ESCAPE_NONASCII is set, only | ||||||
3676 | chars above 127 will be escaped using this style; otherwise, only chars above | ||||||
3677 | 255 will be so escaped; other non printable chars will use octal or | ||||||
3678 | common escaped patterns like C<\\n>. Otherwise, if PERL_PV_ESCAPE_NOBACKSLASH | ||||||
3679 | then all chars below 255 will be treated as printable and | ||||||
3680 | will be output as literals. | ||||||
3681 | |||||||
3682 | If PERL_PV_ESCAPE_FIRSTCHAR is set then only the first char of the | ||||||
3683 | string will be escaped, regardless of max. If the output is to be in hex, | ||||||
3684 | then it will be returned as a plain hex | ||||||
3685 | sequence. Thus the output will either be a single char, | ||||||
3686 | an octal escape sequence, a special escape like C<\\n> or a hex value. | ||||||
3687 | |||||||
3688 | If PERL_PV_ESCAPE_RE is set then the escape char used will be a \'%\' and | ||||||
3689 | not a \'\\\\\'. This is because regexes very often contain backslashed | ||||||
3690 | sequences, whereas \'%\' is not a particularly common character in patterns. | ||||||
3691 | |||||||
3692 | Returns a pointer to the escaped text as held by dsv. | ||||||
3693 | |||||||
3694 | char* pv_escape(SV *dsv, char const * const str, | ||||||
3695 | const STRLEN count, const STRLEN max, | ||||||
3696 | STRLEN * const escaped, | ||||||
3697 | const U32 flags)','name' => 'pv_escape'},'HeSVKEY_force' => {'text' => 'Returns the key as an C |
||||||
3698 | C |
||||||
3699 | |||||||
3700 | SV* HeSVKEY_force(HE* he)','name' => 'HeSVKEY_force'},'my_exit' => {'text' => '','name' => 'my_exit'},'newRV_inc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original SV is | ||||||
3701 | incremented. | ||||||
3702 | |||||||
3703 | SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'SVt_PVCV' => {'text' => 'Type flag for code refs. See C |
||||||
3704 | |||||||
3705 | void sv_setpviv_mg(SV *const sv, const IV iv)','name' => 'sv_setpviv_mg'},'debstack' => {'text' => '','name' => 'debstack'},'sv_2bool' => {'text' => 'This macro is only used by sv_true() or its macro equivalent, and only if | ||||||
3706 | the latter\'s argument is neither SvPOK, SvIOK nor SvNOK. | ||||||
3707 | It calls sv_2bool_flags with the SV_GMAGIC flag. | ||||||
3708 | |||||||
3709 | bool sv_2bool(SV *const sv)','name' => 'sv_2bool'},'lex_grow_linestr' => {'text' => 'Reallocates the lexer buffer (Llinestr>) to accommodate | ||||||
3710 | at least I |
||||||
3711 | pointer to the reallocated buffer. This is necessary before making | ||||||
3712 | any direct modification of the buffer that would increase its length. | ||||||
3713 | L provides a more convenient way to insert text into | ||||||
3714 | the buffer. | ||||||
3715 | |||||||
3716 | Do not use C |
||||||
3717 | this function updates all of the lexer\'s variables that point directly | ||||||
3718 | into the buffer. | ||||||
3719 | |||||||
3720 | NOTE: this function is experimental and may change or be | ||||||
3721 | removed without notice. | ||||||
3722 | |||||||
3723 | char * lex_grow_linestr(STRLEN len)','name' => 'lex_grow_linestr'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C |
||||||
3724 | |||||||
3725 | dORIGMARK;','name' => 'dORIGMARK'},'sv_inc_nomg' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion | ||||||
3726 | if necessary. Handles operator overloading. Skips handling \'get\' magic. | ||||||
3727 | |||||||
3728 | void sv_inc_nomg(SV *const sv)','name' => 'sv_inc_nomg'},'sv_newmortal' => {'text' => 'Creates a new null SV which is mortal. The reference count of the SV is | ||||||
3729 | set to 1. It will be destroyed "soon", either by an explicit call to | ||||||
3730 | FREETMPS, or by an implicit call at places such as statement boundaries. | ||||||
3731 | See also C |
||||||
3732 | |||||||
3733 | SV* sv_newmortal()','name' => 'sv_newmortal'},'is_utf8_cntrl' => {'text' => '','name' => 'is_utf8_cntrl'},'SvOOK' => {'text' => 'Returns a U32 indicating whether the pointer to the string buffer is offset. | ||||||
3734 | This hack is used internally to speed up removal of characters from the | ||||||
3735 | beginning of a SvPV. When SvOOK is true, then the start of the | ||||||
3736 | allocated string buffer is actually C |
||||||
3737 | This offset used to be stored in SvIVX, but is now stored within the spare | ||||||
3738 | part of the buffer. | ||||||
3739 | |||||||
3740 | U32 SvOOK(SV* sv)','name' => 'SvOOK'},'SvPV_set' => {'text' => 'Set the value of the PV pointer in sv to val. See C |
||||||
3741 | |||||||
3742 | void SvPV_set(SV* sv, char* val)','name' => 'SvPV_set'},'mess_sv' => {'text' => 'Expands a message, intended for the user, to include an indication of | ||||||
3743 | the current location in the code, if the message does not already appear | ||||||
3744 | to be complete. | ||||||
3745 | |||||||
3746 | C |
||||||
3747 | will be used as-is and will be the result of this function. Otherwise it | ||||||
3748 | is used as a string, and if it already ends with a newline, it is taken | ||||||
3749 | to be complete, and the result of this function will be the same string. | ||||||
3750 | If the message does not end with a newline, then a segment such as C | ||||||
3751 | foo.pl line 37> will be appended, and possibly other clauses indicating | ||||||
3752 | the current state of execution. The resulting message will end with a | ||||||
3753 | dot and a newline. | ||||||
3754 | |||||||
3755 | Normally, the resulting message is returned in a new mortal SV. | ||||||
3756 | During global destruction a single SV may be shared between uses of this | ||||||
3757 | function. If C |
||||||
3758 | required) to modify and return C |
||||||
3759 | |||||||
3760 | SV * mess_sv(SV *basemsg, bool consume)','name' => 'mess_sv'},'is_utf8_xidcont' => {'text' => '','name' => 'is_utf8_xidcont'},'hv_clear' => {'text' => 'Frees the all the elements of a hash, leaving it empty. | ||||||
3761 | The XS equivalent of C<%hash = ()>. See also L. | ||||||
3762 | |||||||
3763 | If any destructors are triggered as a result, the hv itself may | ||||||
3764 | be freed. | ||||||
3765 | |||||||
3766 | void hv_clear(HV *hv)','name' => 'hv_clear'},'get_hv' => {'text' => 'Returns the HV of the specified Perl hash. C |
||||||
3767 | C |
||||||
3768 | Perl variable does not exist then it will be created. If C |
||||||
3769 | and the variable does not exist then NULL is returned. | ||||||
3770 | |||||||
3771 | NOTE: the perl_ form of this function is deprecated. | ||||||
3772 | |||||||
3773 | HV* get_hv(const char *name, I32 flags)','name' => 'get_hv'},'safesysrealloc' => {'text' => '','name' => 'safesysrealloc'},'XSRETURN_YES' => {'text' => 'Return C<&PL_sv_yes> from an XSUB immediately. Uses C |
||||||
3774 | |||||||
3775 | XSRETURN_YES;','name' => 'XSRETURN_YES'},'PoisonNew' => {'text' => 'PoisonWith(0xAB) for catching access to allocated but uninitialized memory. | ||||||
3776 | |||||||
3777 | void PoisonNew(void* dest, int nitems, type)','name' => 'PoisonNew'},'op_scope' => {'text' => 'Wraps up an op tree with some additional ops so that at runtime a dynamic | ||||||
3778 | scope will be created. The original ops run in the new dynamic scope, | ||||||
3779 | and then, provided that they exit normally, the scope will be unwound. | ||||||
3780 | The additional ops used to create and unwind the dynamic scope will | ||||||
3781 | normally be an C |
||||||
3782 | instead if the ops are simple enough to not need the full dynamic scope | ||||||
3783 | structure. | ||||||
3784 | |||||||
3785 | NOTE: this function is experimental and may change or be | ||||||
3786 | removed without notice. | ||||||
3787 | |||||||
3788 | OP * op_scope(OP *o)','name' => 'op_scope'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C |
||||||
3789 | cast. | ||||||
3790 | |||||||
3791 | void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'sv_nv' => {'text' => 'A private implementation of the C |
||||||
3792 | cope with complex macro expressions. Always use the macro instead. | ||||||
3793 | |||||||
3794 | NV sv_nv(SV* sv)','name' => 'sv_nv'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this | ||||||
3795 | element. Handles \'set\' magic. Uses C |
||||||
3796 | should be called to declare it. Do not call multiple C |
||||||
3797 | macros to return lists from XSUB\'s - see C |
||||||
3798 | C |
||||||
3799 | |||||||
3800 | void PUSHu(UV uv)','name' => 'PUSHu'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. | ||||||
3801 | |||||||
3802 | void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. | ||||||
3803 | (Uses C |
||||||
3804 | |||||||
3805 | SV* newSVsv(SV *const old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C |
||||||
3806 | |||||||
3807 | void hv_magic(HV *hv, GV *gv, int how)','name' => 'hv_magic'},'deb_nocontext' => {'text' => '','name' => 'deb_nocontext'},'new_stackinfo' => {'text' => '','name' => 'new_stackinfo'},'save_aelem' => {'text' => '','name' => 'save_aelem'},'PerlIO_clearerr' => {'text' => '','name' => 'PerlIO_clearerr'},'cx_dump' => {'text' => '','name' => 'cx_dump'},'hv_placeholders_p' => {'text' => '','name' => 'hv_placeholders_p'},'XCPT_TRY_END' => {'text' => 'Ends a try block. See L |
||||||
3808 | pointer may be either C |
||||||
3809 | C |
||||||
3810 | usually preferable for finding the value of a key. | ||||||
3811 | |||||||
3812 | void* HeKEY(HE* he)','name' => 'HeKEY'},'SvEND' => {'text' => 'Returns a pointer to the spot just after the last character in | ||||||
3813 | the string which is in the SV, where there is usually a trailing | ||||||
3814 | null (even though Perl scalars do not strictly require it). | ||||||
3815 | See C |
||||||
3816 | |||||||
3817 | Warning: If C |
||||||
3818 | unallocated memory. | ||||||
3819 | |||||||
3820 | char* SvEND(SV* sv)','name' => 'SvEND'},'save_delete' => {'text' => '','name' => 'save_delete'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C |
||||||
3821 | C |
||||||
3822 | respectively. See L |
||||||
3823 | |||||||
3824 | U32 GIMME_V','name' => 'GIMME_V'},'re_compile' => {'text' => '','name' => 're_compile'},'sv_setsv_flags' => {'text' => 'Copies the contents of the source SV C |
||||||
3825 | C |
||||||
3826 | function if the source SV needs to be reused. Does not handle \'set\' magic. | ||||||
3827 | Loosely speaking, it performs a copy-by-value, obliterating any previous | ||||||
3828 | content of the destination. | ||||||
3829 | If the C |
||||||
3830 | C |
||||||
3831 | parameter has the C |
||||||
3832 | buffers of temps will not be stolen. |
||||||
3833 | and C |
||||||
3834 | |||||||
3835 | You probably want to use one of the assortment of wrappers, such as | ||||||
3836 | C |
||||||
3837 | C |
||||||
3838 | |||||||
3839 | This is the primary function for copying scalars, and most other | ||||||
3840 | copy-ish functions and macros use this underneath. | ||||||
3841 | |||||||
3842 | void sv_setsv_flags(SV *dstr, SV *sstr, | ||||||
3843 | const I32 flags)','name' => 'sv_setsv_flags'},'gv_init_pvn' => {'text' => 'Converts a scalar into a typeglob. This is an incoercible typeglob; | ||||||
3844 | assigning a reference to it will assign to one of its slots, instead of | ||||||
3845 | overwriting it as happens with typeglobs created by SvSetSV. Converting | ||||||
3846 | any scalar that is SvOK() may produce unpredictable results and is reserved | ||||||
3847 | for perl\'s internal use. | ||||||
3848 | |||||||
3849 | C |
||||||
3850 | |||||||
3851 | C |
||||||
3852 | |||||||
3853 | C |
||||||
3854 | that is, it must not include the package name. If C |
||||||
3855 | stash element, it is the caller\'s responsibility to ensure that the name | ||||||
3856 | passed to this function matches the name of the element. If it does not | ||||||
3857 | match, perl\'s internal bookkeeping will get out of sync. | ||||||
3858 | |||||||
3859 | C |
||||||
3860 | the return value of SvUTF8(sv). It can also take the | ||||||
3861 | GV_ADDMULTI flag, which means to pretend that the GV has been | ||||||
3862 | seen before (i.e., suppress "Used once" warnings). | ||||||
3863 | |||||||
3864 | void gv_init_pvn(GV* gv, HV* stash, const char* name, | ||||||
3865 | STRLEN len, U32 flags)','name' => 'gv_init_pvn'},'newATTRSUB' => {'text' => '','name' => 'newATTRSUB'},'gv_fetchmeth_sv' => {'text' => 'Exactly like L, but takes the name string in the form | ||||||
3866 | of an SV instead of a string/length pair. | ||||||
3867 | |||||||
3868 | GV* gv_fetchmeth_sv(HV* stash, SV* namesv, | ||||||
3869 | I32 level, U32 flags)','name' => 'gv_fetchmeth_sv'},'Copy' => {'text' => 'The XSUB-writer\'s interface to the C C |
||||||
3870 | source, C |
||||||
3871 | the type. May fail on overlapping copies. See also C |
||||||
3872 | |||||||
3873 | void Copy(void* src, void* dest, int nitems, type)','name' => 'Copy'},'newSVpv_share' => {'text' => 'Like C |
||||||
3874 | string/length pair. | ||||||
3875 | |||||||
3876 | SV* newSVpv_share(const char* s, U32 hash)','name' => 'newSVpv_share'},'sv_taint' => {'text' => 'Taint an SV. Use C |
||||||
3877 | |||||||
3878 | void sv_taint(SV* sv)','name' => 'sv_taint'},'utf16_to_utf8' => {'text' => '','name' => 'utf16_to_utf8'},'SvIOK_notUV' => {'text' => 'Returns a boolean indicating whether the SV contains a signed integer. | ||||||
3879 | |||||||
3880 | bool SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'deb' => {'text' => '','name' => 'deb'},'PL_parser-E |
||||||
3881 | This is useful for indicating at which column an error occurred, and | ||||||
3882 | not much else. This must be updated by any lexing code that consumes | ||||||
3883 | a newline; the function L handles this detail. | ||||||
3884 | |||||||
3885 | NOTE: this function is experimental and may change or be | ||||||
3886 | removed without notice.','name' => 'PL_parser-E |
||||||
3887 | variable. Stores the name and other metadata in the name part of the | ||||||
3888 | pad, and makes preparations to manage the variable\'s lexical scoping. | ||||||
3889 | Returns the offset of the allocated pad slot. | ||||||
3890 | |||||||
3891 | I |
||||||
3892 | If I |
||||||
3893 | identifies the type. If I |
||||||
3894 | to a package variable, and this identifies the package. The following | ||||||
3895 | flags can be OR\'ed together: | ||||||
3896 | |||||||
3897 | padadd_OUR redundantly specifies if it\'s a package var | ||||||
3898 | padadd_STATE variable will retain value persistently | ||||||
3899 | padadd_NO_DUP_CHECK skip check for lexical shadowing | ||||||
3900 | |||||||
3901 | PADOFFSET pad_add_name_pvn(const char *namepv, | ||||||
3902 | STRLEN namelen, U32 flags, | ||||||
3903 | HV *typestash, HV *ourstash)','name' => 'pad_add_name_pvn'},'he_dup' => {'text' => '','name' => 'he_dup'},'gv_fullname3' => {'text' => '','name' => 'gv_fullname3'},'mPUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this | ||||||
3904 | element. Does not use C |
||||||
3905 | |||||||
3906 | void mPUSHu(UV uv)','name' => 'mPUSHu'},'gv_fetchmeth_pvn' => {'text' => 'Returns the glob with the given C |
||||||
3907 | C |
||||||
3908 | accessible via @ISA and UNIVERSAL::. | ||||||
3909 | |||||||
3910 | The argument C |
||||||
3911 | side-effect creates a glob with the given C |
||||||
3912 | which in the case of success contains an alias for the subroutine, and sets | ||||||
3913 | up caching info for this glob. | ||||||
3914 | |||||||
3915 | Currently, the only significant value for C |
||||||
3916 | |||||||
3917 | This function grants C<"SUPER"> token as a postfix of the stash name. The | ||||||
3918 | GV returned from C |
||||||
3919 | visible to Perl code. So when calling C |
||||||
3920 | the GV directly; instead, you should use the method\'s CV, which can be | ||||||
3921 | obtained from the GV with the C |
||||||
3922 | |||||||
3923 | GV* gv_fetchmeth_pvn(HV* stash, const char* name, | ||||||
3924 | STRLEN len, I32 level, | ||||||
3925 | U32 flags)','name' => 'gv_fetchmeth_pvn'},'cophh_new_empty' => {'text' => 'Generate and return a fresh cop hints hash containing no entries. | ||||||
3926 | |||||||
3927 | NOTE: this function is experimental and may change or be | ||||||
3928 | removed without notice. | ||||||
3929 | |||||||
3930 | COPHH * cophh_new_empty()','name' => 'cophh_new_empty'},'sv_derived_from_pvn' => {'text' => 'Returns a boolean indicating whether the SV is derived from the specified class | ||||||
3931 | I |
||||||
3932 | normal Perl method. | ||||||
3933 | |||||||
3934 | Currently, the only significant value for C |
||||||
3935 | |||||||
3936 | bool sv_derived_from_pvn(SV* sv, | ||||||
3937 | const char *const name, | ||||||
3938 | const STRLEN len, U32 flags)','name' => 'sv_derived_from_pvn'},'op_append_list' => {'text' => 'Concatenate the lists of ops contained directly within two list-type ops, | ||||||
3939 | returning the combined list. I |
||||||
3940 | to concatenate. I |
||||||
3941 | If either I |
||||||
3942 | it will be upgraded into one. If either I |
||||||
3943 | the other is returned unchanged. | ||||||
3944 | |||||||
3945 | OP * op_append_list(I32 optype, OP *first, OP *last)','name' => 'op_append_list'},'repeatcpy' => {'text' => '','name' => 'repeatcpy'},'do_spawn_nowait' => {'text' => '','name' => 'do_spawn_nowait'},'sv_setsv_nomg' => {'text' => 'Like C |
||||||
3946 | |||||||
3947 | void sv_setsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_setsv_nomg'},'load_module_nocontext' => {'text' => '','name' => 'load_module_nocontext'},'re_intuit_string' => {'text' => '','name' => 're_intuit_string'},'do_magic_dump' => {'text' => '','name' => 'do_magic_dump'},'HvNAMELEN' => {'text' => 'Returns the length of the stash\'s name. | ||||||
3948 | |||||||
3949 | STRLEN HvNAMELEN(HV *stash)','name' => 'HvNAMELEN'},'XPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C |
||||||
3950 | indicates the length of the string. Handles \'set\' magic. Uses C |
||||||
3951 | C |
||||||
3952 | multiple C |
||||||
3953 | C |
||||||
3954 | |||||||
3955 | void XPUSHp(char* str, STRLEN len)','name' => 'XPUSHp'},'av_create_and_push' => {'text' => 'Push an SV onto the end of the array, creating the array if necessary. | ||||||
3956 | A small internal helper function to remove a commonly duplicated idiom. | ||||||
3957 | |||||||
3958 | NOTE: this function is experimental and may change or be | ||||||
3959 | removed without notice. | ||||||
3960 | |||||||
3961 | void av_create_and_push(AV **const avp, | ||||||
3962 | SV *const val)','name' => 'av_create_and_push'},'sv_utf8_encode' => {'text' => 'Converts the PV of an SV to UTF-8, but then turns the C |
||||||
3963 | flag off so that it looks like octets again. | ||||||
3964 | |||||||
3965 | void sv_utf8_encode(SV *const sv)','name' => 'sv_utf8_encode'},'SvUTF8_on' => {'text' => 'Turn on the UTF-8 status of an SV (the data is not changed, just the flag). | ||||||
3966 | Do not use frivolously. | ||||||
3967 | |||||||
3968 | void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_does_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of an SV. | ||||||
3969 | |||||||
3970 | bool sv_does_pv(SV* sv, const char *const name, | ||||||
3971 | U32 flags)','name' => 'sv_does_pv'},'sv_setpvn_mg' => {'text' => 'Like C |
||||||
3972 | |||||||
3973 | void sv_setpvn_mg(SV *const sv, | ||||||
3974 | const char *const ptr, | ||||||
3975 | const STRLEN len)','name' => 'sv_setpvn_mg'},'toLOWER' => {'text' => 'Converts the specified character to lowercase in the platform\'s native | ||||||
3976 | character set, if possible; otherwise returns the input character itself. | ||||||
3977 | |||||||
3978 | char toLOWER(char ch)','name' => 'toLOWER'},'av_iter_p' => {'text' => '','name' => 'av_iter_p'},'prescan_version' => {'text' => 'Validate that a given string can be parsed as a version object, but doesn\'t | ||||||
3979 | actually perform the parsing. Can use either strict or lax validation rules. | ||||||
3980 | Can optionally set a number of hint variables to save the parsing code | ||||||
3981 | some time when tokenizing. | ||||||
3982 | |||||||
3983 | const char* prescan_version(const char *s, bool strict, | ||||||
3984 | const char** errstr, | ||||||
3985 | bool *sqv, | ||||||
3986 | int *ssaw_decimal, | ||||||
3987 | int *swidth, bool *salpha)','name' => 'prescan_version'},'PerlIO_write' => {'text' => '','name' => 'PerlIO_write'},'hv_ksplit' => {'text' => '','name' => 'hv_ksplit'},'new_version' => {'text' => 'Returns a new version object based on the passed in SV: | ||||||
3988 | |||||||
3989 | SV *sv = new_version(SV *ver); | ||||||
3990 | |||||||
3991 | Does not alter the passed in ver SV. See "upg_version" if you | ||||||
3992 | want to upgrade the SV. | ||||||
3993 | |||||||
3994 | SV* new_version(SV *ver)','name' => 'new_version'},'PerlIO_seek' => {'text' => '','name' => 'PerlIO_seek'},'free_tmps' => {'text' => '','name' => 'free_tmps'},'parse_arithexpr' => {'text' => 'Parse a Perl arithmetic expression. This may contain operators of precedence | ||||||
3995 | down to the bit shift operators. The expression must be followed (and thus | ||||||
3996 | terminated) either by a comparison or lower-precedence operator or by | ||||||
3997 | something that would normally terminate an expression such as semicolon. | ||||||
3998 | If I |
||||||
3999 | otherwise it is mandatory. It is up to the caller to ensure that the | ||||||
4000 | dynamic parser state (L et al) is correctly set to reflect | ||||||
4001 | the source of the code to be parsed and the lexical context for the | ||||||
4002 | expression. | ||||||
4003 | |||||||
4004 | The op tree representing the expression is returned. If an optional | ||||||
4005 | expression is absent, a null pointer is returned, otherwise the pointer | ||||||
4006 | will be non-null. | ||||||
4007 | |||||||
4008 | If an error occurs in parsing or compilation, in most cases a valid op | ||||||
4009 | tree is returned anyway. The error is reflected in the parser state, | ||||||
4010 | normally resulting in a single exception at the top level of parsing | ||||||
4011 | which covers all the compilation errors that occurred. Some compilation | ||||||
4012 | errors, however, will throw an exception immediately. | ||||||
4013 | |||||||
4014 | NOTE: this function is experimental and may change or be | ||||||
4015 | removed without notice. | ||||||
4016 | |||||||
4017 | OP * parse_arithexpr(U32 flags)','name' => 'parse_arithexpr'},'Nullav' => {'text' => 'Null AV pointer. | ||||||
4018 | |||||||
4019 | (deprecated - use C<(AV *)NULL> instead)','name' => 'Nullav'},'sv_pvbyten' => {'text' => 'A private implementation of the C |
||||||
4020 | which can\'t cope with complex macro expressions. Always use the macro | ||||||
4021 | instead. | ||||||
4022 | |||||||
4023 | char* sv_pvbyten(SV *sv, STRLEN *lp)','name' => 'sv_pvbyten'},'isOCTAL' => {'text' => 'Returns a boolean indicating whether the specified character is an | ||||||
4024 | octal digit, [0-7] in the platform\'s native character set. | ||||||
4025 | Variants C |
||||||
4026 | |||||||
4027 | bool isOCTAL(char ch)','name' => 'isOCTAL'},'sv_copypv' => {'text' => 'Copies a stringified representation of the source SV into the | ||||||
4028 | destination SV. Automatically performs any necessary mg_get and | ||||||
4029 | coercion of numeric values into strings. Guaranteed to preserve | ||||||
4030 | UTF8 flag even from overloaded objects. Similar in nature to | ||||||
4031 | sv_2pv[_flags] but operates directly on an SV instead of just the | ||||||
4032 | string. Mostly uses sv_2pv_flags to do its work, except when that | ||||||
4033 | would lose the UTF-8\'ness of the PV. | ||||||
4034 | |||||||
4035 | void sv_copypv(SV *const dsv, SV *const ssv)','name' => 'sv_copypv'},'rsignal' => {'text' => '','name' => 'rsignal'},'sv_pv' => {'text' => 'Use the C |
||||||
4036 | |||||||
4037 | char* sv_pv(SV *sv)','name' => 'sv_pv'},'is_uni_xdigit' => {'text' => '','name' => 'is_uni_xdigit'},'perl_alloc_using' => {'text' => '','name' => 'perl_alloc_using'},'pv_pretty' => {'text' => 'Converts a string into something presentable, handling escaping via | ||||||
4038 | pv_escape() and supporting quoting and ellipses. | ||||||
4039 | |||||||
4040 | If the PERL_PV_PRETTY_QUOTE flag is set then the result will be | ||||||
4041 | double quoted with any double quotes in the string escaped. Otherwise | ||||||
4042 | if the PERL_PV_PRETTY_LTGT flag is set then the result be wrapped in | ||||||
4043 | angle brackets. | ||||||
4044 | |||||||
4045 | If the PERL_PV_PRETTY_ELLIPSES flag is set and not all characters in | ||||||
4046 | string were output then an ellipsis C<...> will be appended to the | ||||||
4047 | string. Note that this happens AFTER it has been quoted. | ||||||
4048 | |||||||
4049 | If start_color is non-null then it will be inserted after the opening | ||||||
4050 | quote (if there is one) but before the escaped text. If end_color | ||||||
4051 | is non-null then it will be inserted after the escaped text but before | ||||||
4052 | any quotes or ellipses. | ||||||
4053 | |||||||
4054 | Returns a pointer to the prettified text as held by dsv. | ||||||
4055 | |||||||
4056 | char* pv_pretty(SV *dsv, char const * const str, | ||||||
4057 | const STRLEN count, const STRLEN max, | ||||||
4058 | char const * const start_color, | ||||||
4059 | char const * const end_color, | ||||||
4060 | const U32 flags)','name' => 'pv_pretty'},'sv_setnv_mg' => {'text' => 'Like C |
||||||
4061 | |||||||
4062 | void sv_setnv_mg(SV *const sv, const NV num)','name' => 'sv_setnv_mg'},'utf8_to_bytes' => {'text' => 'Converts a string C |
||||||
4063 | Unlike L, this over-writes the original string, and | ||||||
4064 | updates C |
||||||
4065 | Returns zero on failure, setting C |
||||||
4066 | |||||||
4067 | If you need a copy of the string, see L. | ||||||
4068 | |||||||
4069 | NOTE: this function is experimental and may change or be | ||||||
4070 | removed without notice. | ||||||
4071 | |||||||
4072 | U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_setref_pvs' => {'text' => 'Like C |
||||||
4073 | string/length pair. | ||||||
4074 | |||||||
4075 | SV * sv_setref_pvs(const char* s)','name' => 'sv_setref_pvs'},'re_dup_guts' => {'text' => '','name' => 're_dup_guts'},'si_dup' => {'text' => '','name' => 'si_dup'},'uvuni_to_utf8_flags' => {'text' => 'Adds the UTF-8 representation of the code point C |
||||||
4076 | of the string C |
||||||
4077 | bytes available. The return value is the pointer to the byte after the | ||||||
4078 | end of the new character. In other words, | ||||||
4079 | |||||||
4080 | d = uvuni_to_utf8_flags(d, uv, flags); | ||||||
4081 | |||||||
4082 | or, in most cases, | ||||||
4083 | |||||||
4084 | d = uvuni_to_utf8(d, uv); | ||||||
4085 | |||||||
4086 | (which is equivalent to) | ||||||
4087 | |||||||
4088 | d = uvuni_to_utf8_flags(d, uv, 0); | ||||||
4089 | |||||||
4090 | This is the recommended Unicode-aware way of saying | ||||||
4091 | |||||||
4092 | *(d++) = uv; | ||||||
4093 | |||||||
4094 | This function will convert to UTF-8 (and not warn) even code points that aren\'t | ||||||
4095 | legal Unicode or are problematic, unless C |
||||||
4096 | following flags: | ||||||
4097 | |||||||
4098 | If C |
||||||
4099 | the function will raise a warning, provided UTF8 warnings are enabled. If instead | ||||||
4100 | UNICODE_DISALLOW_SURROGATE is set, the function will fail and return NULL. | ||||||
4101 | If both flags are set, the function will both warn and return NULL. | ||||||
4102 | |||||||
4103 | The UNICODE_WARN_NONCHAR and UNICODE_DISALLOW_NONCHAR flags correspondingly | ||||||
4104 | affect how the function handles a Unicode non-character. And, likewise for the | ||||||
4105 | UNICODE_WARN_SUPER and UNICODE_DISALLOW_SUPER flags, and code points that are | ||||||
4106 | above the Unicode maximum of 0x10FFFF. Code points above 0x7FFF_FFFF (which are | ||||||
4107 | even less portable) can be warned and/or disallowed even if other above-Unicode | ||||||
4108 | code points are accepted by the UNICODE_WARN_FE_FF and UNICODE_DISALLOW_FE_FF | ||||||
4109 | flags. | ||||||
4110 | |||||||
4111 | And finally, the flag UNICODE_WARN_ILLEGAL_INTERCHANGE selects all four of the | ||||||
4112 | above WARN flags; and UNICODE_DISALLOW_ILLEGAL_INTERCHANGE selects all four | ||||||
4113 | DISALLOW flags. | ||||||
4114 | |||||||
4115 | |||||||
4116 | U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)','name' => 'uvuni_to_utf8_flags'},'PL_rpeepp' => {'text' => 'Pointer to the recursive peephole optimiser. This is a function | ||||||
4117 | that gets called at the end of compilation of a Perl subroutine (or | ||||||
4118 | equivalently independent piece of Perl code) to perform fixups of some | ||||||
4119 | ops and to perform small-scale optimisations. The function is called | ||||||
4120 | once for each chain of ops linked through their C |
||||||
4121 | it is recursively called to handle each side chain. It is passed, as | ||||||
4122 | sole parameter, a pointer to the op that is at the head of the chain. | ||||||
4123 | It modifies the op tree in place. | ||||||
4124 | |||||||
4125 | The peephole optimiser should never be completely replaced. Rather, | ||||||
4126 | add code to it by wrapping the existing optimiser. The basic way to do | ||||||
4127 | this can be seen in L |
||||||
4128 | If the new code wishes to operate only on ops at a subroutine\'s top level, | ||||||
4129 | rather than throughout the structure, it is likely to be more convenient | ||||||
4130 | to wrap the L hook. | ||||||
4131 | |||||||
4132 | peep_t PL_rpeepp','name' => 'PL_rpeepp'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See | ||||||
4133 | L |
||||||
4134 | is stored in a new mortal SV. | ||||||
4135 | |||||||
4136 | void XST_mNV(int pos, NV nv)','name' => 'XST_mNV'},'UNDERBAR' => {'text' => 'The SV* corresponding to the $_ variable. Works even if there | ||||||
4137 | is a lexical $_ in scope.','name' => 'UNDERBAR'},'newSVOP' => {'text' => 'Constructs, checks, and returns an op of any type that involves an | ||||||
4138 | embedded SV. I |
||||||
4139 | of C |
||||||
4140 | takes ownership of one reference to it. | ||||||
4141 | |||||||
4142 | OP * newSVOP(I32 type, I32 flags, SV *sv)','name' => 'newSVOP'},'cophh_fetch_pvn' => {'text' => 'Look up the entry in the cop hints hash I |
||||||
4143 | I |
||||||
4144 | the key octets are interpreted as UTF-8, otherwise they are interpreted | ||||||
4145 | as Latin-1. I |
||||||
4146 | it has not been precomputed. Returns a mortal scalar copy of the value | ||||||
4147 | associated with the key, or C<&PL_sv_placeholder> if there is no value | ||||||
4148 | associated with the key. | ||||||
4149 | |||||||
4150 | NOTE: this function is experimental and may change or be | ||||||
4151 | removed without notice. | ||||||
4152 | |||||||
4153 | SV * cophh_fetch_pvn(const COPHH *cophh, | ||||||
4154 | const char *keypv, | ||||||
4155 | STRLEN keylen, U32 hash, | ||||||
4156 | U32 flags)','name' => 'cophh_fetch_pvn'},'pad_sv' => {'text' => 'Get the value at offset I |
||||||
4157 | Use macro PAD_SV instead of calling this function directly. | ||||||
4158 | |||||||
4159 | SV * pad_sv(PADOFFSET po)','name' => 'pad_sv'},'amagic_call' => {'text' => '','name' => 'amagic_call'},'op_free' => {'text' => '','name' => 'op_free'},'SvPVutf8_force' => {'text' => 'Like C |
||||||
4160 | |||||||
4161 | char* SvPVutf8_force(SV* sv, STRLEN len)','name' => 'SvPVutf8_force'},'gv_AVadd' => {'text' => '','name' => 'gv_AVadd'},'pop_scope' => {'text' => '','name' => 'pop_scope'},'SVt_NV' => {'text' => 'Double type flag for scalars. See C |
||||||
4162 | L |
||||||
4163 | |||||||
4164 | void PUSHMARK(SP)','name' => 'PUSHMARK'},'taint_proper' => {'text' => '','name' => 'taint_proper'},'save_generic_pvref' => {'text' => '','name' => 'save_generic_pvref'},'ST' => {'text' => 'Used to access elements on the XSUB\'s stack. | ||||||
4165 | |||||||
4166 | SV* ST(int ix)','name' => 'ST'},'call_pv' => {'text' => 'Performs a callback to the specified Perl sub. See L |
||||||
4167 | |||||||
4168 | NOTE: the perl_ form of this function is deprecated. | ||||||
4169 | |||||||
4170 | I32 call_pv(const char* sub_name, I32 flags)','name' => 'call_pv'},'gv_fetchmeth_autoload' => {'text' => 'This is the old form of L, which has no flags | ||||||
4171 | parameter. | ||||||
4172 | |||||||
4173 | GV* gv_fetchmeth_autoload(HV* stash, | ||||||
4174 | const char* name, | ||||||
4175 | STRLEN len, I32 level)','name' => 'gv_fetchmeth_autoload'},'save_mortalizesv' => {'text' => '','name' => 'save_mortalizesv'},'sv_pos_b2u' => {'text' => 'Converts the value pointed to by offsetp from a count of bytes from the | ||||||
4176 | start of the string, to a count of the equivalent number of UTF-8 chars. | ||||||
4177 | Handles magic and type coercion. | ||||||
4178 | |||||||
4179 | void sv_pos_b2u(SV *const sv, I32 *const offsetp)','name' => 'sv_pos_b2u'},'sv_utf8_upgrade_flags_grow' => {'text' => '','name' => 'sv_utf8_upgrade_flags_grow'},'SVt_IV' => {'text' => 'Integer type flag for scalars. See C |
||||||
4180 | hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for | ||||||
4181 | COW). | ||||||
4182 | |||||||
4183 | bool SvIsCOW(SV* sv)','name' => 'SvIsCOW'},'reentrant_size' => {'text' => '','name' => 'reentrant_size'},'printf_nocontext' => {'text' => '','name' => 'printf_nocontext'},'save_freesv' => {'text' => '','name' => 'save_freesv'},'sv_catsv' => {'text' => 'Concatenates the string from SV C |
||||||
4184 | SV C |
||||||
4185 | not \'set\' magic. See C |
||||||
4186 | |||||||
4187 | void sv_catsv(SV *dstr, SV *sstr)','name' => 'sv_catsv'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. | ||||||
4188 | |||||||
4189 | void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'ax' => {'text' => 'Variable which is setup by C |
||||||
4190 | used by the C |
||||||
4191 | must be called prior to setup the C variable. | ||||||
4192 | |||||||
4193 | I32 ax','name' => 'ax'},'regexec_flags' => {'text' => '','name' => 'regexec_flags'},'pad_add_name_sv' => {'text' => 'Exactly like L, but takes the name string in the form | ||||||
4194 | of an SV instead of a string/length pair. | ||||||
4195 | |||||||
4196 | PADOFFSET pad_add_name_sv(SV *name, U32 flags, | ||||||
4197 | HV *typestash, HV *ourstash)','name' => 'pad_add_name_sv'},'to_utf8_upper' => {'text' => 'Convert the UTF-8 encoded character at C to its uppercase version and |
||||||
4198 | store that in UTF-8 in C |
||||||
4199 | that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since | ||||||
4200 | the uppercase version may be longer than the original character. | ||||||
4201 | |||||||
4202 | The first character of the uppercased version is returned | ||||||
4203 | (but note, as explained above, that there may be more.) | ||||||
4204 | |||||||
4205 | The character at C is assumed by this routine to be well-formed. |
||||||
4206 | |||||||
4207 | UV to_utf8_upper(const U8 *p, U8* ustrp, | ||||||
4208 | STRLEN *lenp)','name' => 'to_utf8_upper'},'SvPVutf8x_force' => {'text' => 'Like C |
||||||
4209 | Guarantees to evaluate sv only once; use the more efficient C |
||||||
4210 | otherwise. | ||||||
4211 | |||||||
4212 | char* SvPVutf8x_force(SV* sv, STRLEN len)','name' => 'SvPVutf8x_force'},'warner_nocontext' => {'text' => '','name' => 'warner_nocontext'},'sv_eq_flags' => {'text' => 'Returns a boolean indicating whether the strings in the two SVs are | ||||||
4213 | identical. Is UTF-8 and \'use bytes\' aware and coerces its args to strings | ||||||
4214 | if necessary. If the flags include SV_GMAGIC, it handles get-magic, too. | ||||||
4215 | |||||||
4216 | I32 sv_eq_flags(SV* sv1, SV* sv2, const U32 flags)','name' => 'sv_eq_flags'},'my_htonl' => {'text' => '','name' => 'my_htonl'},'PUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. | ||||||
4217 | Handles \'set\' magic. Uses C |
||||||
4218 | called to declare it. Do not call multiple C |
||||||
4219 | return lists from XSUB\'s - see C |
||||||
4220 | C |
||||||
4221 | |||||||
4222 | void PUSHi(IV iv)','name' => 'PUSHi'},'is_uni_digit' => {'text' => '','name' => 'is_uni_digit'},'SvLEN_set' => {'text' => 'Set the actual length of the string which is in the SV. See C |
||||||
4223 | |||||||
4224 | void SvLEN_set(SV* sv, STRLEN len)','name' => 'SvLEN_set'},'new_numeric' => {'text' => '','name' => 'new_numeric'},'to_utf8_lower' => {'text' => 'Convert the UTF-8 encoded character at C to its lowercase version and |
||||||
4225 | store that in UTF-8 in ustrp and its length in bytes in C |
||||||
4226 | that the C |
||||||
4227 | lowercase version may be longer than the original character. | ||||||
4228 | |||||||
4229 | The first character of the lowercased version is returned | ||||||
4230 | (but note, as explained above, that there may be more.) | ||||||
4231 | |||||||
4232 | The character at C is assumed by this routine to be well-formed. |
||||||
4233 | |||||||
4234 | UV to_utf8_lower(const U8 *p, U8* ustrp, | ||||||
4235 | STRLEN *lenp)','name' => 'to_utf8_lower'},'gv_init_pv' => {'text' => 'Same as gv_init_pvn(), but takes a nul-terminated string for the name | ||||||
4236 | instead of separate char * and length parameters. | ||||||
4237 | |||||||
4238 | void gv_init_pv(GV* gv, HV* stash, const char* name, | ||||||
4239 | U32 flags)','name' => 'gv_init_pv'},'newSVpvf' => {'text' => 'Creates a new SV and initializes it with the string formatted like | ||||||
4240 | C |
||||||
4241 | |||||||
4242 | SV* newSVpvf(const char *const pat, ...)','name' => 'newSVpvf'},'doing_taint' => {'text' => '','name' => 'doing_taint'},'save_I8' => {'text' => '','name' => 'save_I8'},'Newxc' => {'text' => 'The XSUB-writer\'s interface to the C C |
||||||
4243 | cast. See also C |
||||||
4244 | |||||||
4245 | void Newxc(void* ptr, int nitems, type, cast)','name' => 'Newxc'},'SvIVX' => {'text' => 'Returns the raw value in the SV\'s IV slot, without checks or conversions. | ||||||
4246 | Only use when you are sure SvIOK is true. See also C |
||||||
4247 | |||||||
4248 | IV SvIVX(SV* sv)','name' => 'SvIVX'},'lex_stuff_pvs' => {'text' => 'Like L, but takes a literal string instead of a | ||||||
4249 | string/length pair. | ||||||
4250 | |||||||
4251 | NOTE: this function is experimental and may change or be | ||||||
4252 | removed without notice. | ||||||
4253 | |||||||
4254 | void lex_stuff_pvs(const char *pv, U32 flags)','name' => 'lex_stuff_pvs'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L |
||||||
4255 | |||||||
4256 | int perl_destruct(PerlInterpreter *my_perl)','name' => 'perl_destruct'},'is_utf8_idfirst' => {'text' => '','name' => 'is_utf8_idfirst'},'custom_op_name' => {'text' => 'Return the name for a given custom op. This was once used by the OP_NAME | ||||||
4257 | macro, but is no longer: it has only been kept for compatibility, and | ||||||
4258 | should not be used. | ||||||
4259 | |||||||
4260 | const char * custom_op_name(const OP *o)','name' => 'custom_op_name'},'sv_vsetpvf' => {'text' => 'Works like C |
||||||
4261 | appending it. Does not handle \'set\' magic. See C |
||||||
4262 | |||||||
4263 | Usually used via its frontend C |
||||||
4264 | |||||||
4265 | void sv_vsetpvf(SV *const sv, const char *const pat, | ||||||
4266 | va_list *const args)','name' => 'sv_vsetpvf'},'any_dup' => {'text' => '','name' => 'any_dup'},'XCPT_CATCH' => {'text' => 'Introduces a catch block. See L |
||||||
4267 | |||||||
4268 | void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'XST_mYES' => {'text' => 'Place C<&PL_sv_yes> into the specified position C |
||||||
4269 | stack. | ||||||
4270 | |||||||
4271 | void XST_mYES(int pos)','name' => 'XST_mYES'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C |
||||||
4272 | C |
||||||
4273 | function if the source SV needs to be reused. Does not handle \'set\' magic. | ||||||
4274 | Loosely speaking, it performs a copy-by-value, obliterating any previous | ||||||
4275 | content of the destination. | ||||||
4276 | |||||||
4277 | You probably want to use one of the assortment of wrappers, such as | ||||||
4278 | C |
||||||
4279 | C |
||||||
4280 | |||||||
4281 | void sv_setsv(SV *dstr, SV *sstr)','name' => 'sv_setsv'},'PerlIO_stdin' => {'text' => '','name' => 'PerlIO_stdin'},'ix' => {'text' => 'Variable which is setup by C |
||||||
4282 | XSUB\'s aliases was used to invoke it. See L |
||||||
4283 | |||||||
4284 | I32 ix','name' => 'ix'},'XSRETURN_UV' => {'text' => 'Return an integer from an XSUB immediately. Uses C |
||||||
4285 | |||||||
4286 | void XSRETURN_UV(IV uv)','name' => 'XSRETURN_UV'},'SvREFCNT_inc_simple' => {'text' => 'Same as SvREFCNT_inc, but can only be used with expressions without side | ||||||
4287 | effects. Since we don\'t have to store a temporary value, it\'s faster. | ||||||
4288 | |||||||
4289 | SV* SvREFCNT_inc_simple(SV* sv)','name' => 'SvREFCNT_inc_simple'},'my_lstat' => {'text' => '','name' => 'my_lstat'},'my_atof' => {'text' => '','name' => 'my_atof'},'savestack_grow_cnt' => {'text' => '','name' => 'savestack_grow_cnt'},'PL_comppad_name' => {'text' => 'During compilation, this points to the array containing the names part | ||||||
4290 | of the pad for the currently-compiling code. | ||||||
4291 | |||||||
4292 | NOTE: this function is experimental and may change or be | ||||||
4293 | removed without notice.','name' => 'PL_comppad_name'},'SvTRUE_nomg' => {'text' => 'Returns a boolean indicating whether Perl would evaluate the SV as true or | ||||||
4294 | false. See SvOK() for a defined/undefined test. Does not handle \'get\' magic. | ||||||
4295 | |||||||
4296 | bool SvTRUE_nomg(SV* sv)','name' => 'SvTRUE_nomg'},'vverify' => {'text' => 'Validates that the SV contains valid internal structure for a version object. | ||||||
4297 | It may be passed either the version object (RV) or the hash itself (HV). If | ||||||
4298 | the structure is valid, it returns the HV. If the structure is invalid, | ||||||
4299 | it returns NULL. | ||||||
4300 | |||||||
4301 | SV *hv = vverify(sv); | ||||||
4302 | |||||||
4303 | Note that it only confirms the bare minimum structure (so as not to get | ||||||
4304 | confused by derived classes which may contain additional hash entries): | ||||||
4305 | |||||||
4306 | SV* vverify(SV *vs)','name' => 'vverify'},'dXSI32' => {'text' => 'Sets up the C |
||||||
4307 | handled automatically by C |
||||||
4308 | |||||||
4309 | dXSI32;','name' => 'dXSI32'},'dXCPT' => {'text' => 'Set up necessary local variables for exception handling. | ||||||
4310 | See L |
||||||
4311 | |||||||
4312 | dXCPT;','name' => 'dXCPT'},'sv_tainted' => {'text' => 'Test an SV for taintedness. Use C |
||||||
4313 | |||||||
4314 | bool sv_tainted(SV *const sv)','name' => 'sv_tainted'},'mro_set_private_data' => {'text' => '','name' => 'mro_set_private_data'},'do_gv_dump' => {'text' => '','name' => 'do_gv_dump'},'reg_named_buff_nextkey' => {'text' => '','name' => 'reg_named_buff_nextkey'},'hv_fill' => {'text' => 'Returns the number of hash buckets that happen to be in use. This function is | ||||||
4315 | wrapped by the macro C |
||||||
4316 | |||||||
4317 | Previously this value was stored in the HV structure, rather than being | ||||||
4318 | calculated on demand. | ||||||
4319 | |||||||
4320 | STRLEN hv_fill(HV const *const hv)','name' => 'hv_fill'},'cv_const_sv' => {'text' => 'If C |
||||||
4321 | value returned by the sub. Otherwise, returns NULL. | ||||||
4322 | |||||||
4323 | Constant subs can be created with C |
||||||
4324 | L |
||||||
4325 | |||||||
4326 | SV* cv_const_sv(const CV *const cv)','name' => 'cv_const_sv'},'pad_add_name_pvs' => {'text' => 'Exactly like L, but takes a literal string instead | ||||||
4327 | of a string/length pair. | ||||||
4328 | |||||||
4329 | PADOFFSET pad_add_name_pvs(const char *name, U32 flags, | ||||||
4330 | HV *typestash, HV *ourstash)','name' => 'pad_add_name_pvs'},'newSVnv' => {'text' => 'Creates a new SV and copies a floating point value into it. | ||||||
4331 | The reference count for the SV is set to 1. | ||||||
4332 | |||||||
4333 | SV* newSVnv(const NV n)','name' => 'newSVnv'},'HeVAL' => {'text' => 'Returns the value slot (type C |
||||||
4334 | |||||||
4335 | SV* HeVAL(HE* he)','name' => 'HeVAL'},'HePV' => {'text' => 'Returns the key slot of the hash entry as a C |
||||||
4336 | necessary dereferencing of possibly C |
||||||
4337 | is placed in C |
||||||
4338 | not care about what the length of the key is, you may use the global | ||||||
4339 | variable C |
||||||
4340 | variable. Remember though, that hash keys in perl are free to contain | ||||||
4341 | embedded nulls, so using C |
||||||
4342 | the length of hash keys. This is very similar to the C |
||||||
4343 | described elsewhere in this document. See also C |
||||||
4344 | |||||||
4345 | If you are using C |
||||||
4346 | new SV, you should consider using C |
||||||
4347 | efficient. | ||||||
4348 | |||||||
4349 | char* HePV(HE* he, STRLEN len)','name' => 'HePV'},'hv_free_ent' => {'text' => '','name' => 'hv_free_ent'},'SvGETMAGIC' => {'text' => 'Invokes C |
||||||
4350 | argument more than once. | ||||||
4351 | |||||||
4352 | void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'PL_parser' => {'text' => 'Pointer to a structure encapsulating the state of the parsing operation | ||||||
4353 | currently in progress. The pointer can be locally changed to perform | ||||||
4354 | a nested parse without interfering with the state of an outer parse. | ||||||
4355 | Individual members of C |
||||||
4356 | length C |
||||||
4357 | (if longer, the rest is truncated and "..." will be appended). | ||||||
4358 | |||||||
4359 | The C |
||||||
4360 | isPRINT()able characters as themselves, UNI_DISPLAY_BACKSLASH | ||||||
4361 | to display the \\\\[nrfta\\\\] as the backslashed versions (like \'\\n\') | ||||||
4362 | (UNI_DISPLAY_BACKSLASH is preferred over UNI_DISPLAY_ISPRINT for \\\\). | ||||||
4363 | UNI_DISPLAY_QQ (and its alias UNI_DISPLAY_REGEX) have both | ||||||
4364 | UNI_DISPLAY_BACKSLASH and UNI_DISPLAY_ISPRINT turned on. | ||||||
4365 | |||||||
4366 | The pointer to the PV of the C |
||||||
4367 | |||||||
4368 | char* pv_uni_display(SV *dsv, const U8 *spv, | ||||||
4369 | STRLEN len, STRLEN pvlim, | ||||||
4370 | UV flags)','name' => 'pv_uni_display'},'init_stacks' => {'text' => '','name' => 'init_stacks'},'sv_inc' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion | ||||||
4371 | if necessary. Handles \'get\' magic and operator overloading. | ||||||
4372 | |||||||
4373 | void sv_inc(SV *const sv)','name' => 'sv_inc'},'SvPVbytex_force' => {'text' => 'Like C |
||||||
4374 | Guarantees to evaluate sv only once; use the more efficient C |
||||||
4375 | otherwise. | ||||||
4376 | |||||||
4377 | char* SvPVbytex_force(SV* sv, STRLEN len)','name' => 'SvPVbytex_force'},'op_prepend_elem' => {'text' => 'Prepend an item to the list of ops contained directly within a list-type | ||||||
4378 | op, returning the lengthened list. I |
||||||
4379 | list, and I |
||||||
4380 | opcode for the list. If I |
||||||
4381 | it will be upgraded into one. If either I |
||||||
4382 | the other is returned unchanged. | ||||||
4383 | |||||||
4384 | OP * op_prepend_elem(I32 optype, OP *first, OP *last)','name' => 'op_prepend_elem'},'hv_delete' => {'text' => 'Deletes a key/value pair in the hash. The value\'s SV is removed from | ||||||
4385 | the hash, made mortal, and returned to the caller. The absolute | ||||||
4386 | value of C |
||||||
4387 | key is assumed to be in UTF-8-encoded Unicode. The C |
||||||
4388 | will normally be zero; if set to G_DISCARD then NULL will be returned. | ||||||
4389 | NULL will also be returned if the key is not found. | ||||||
4390 | |||||||
4391 | SV* hv_delete(HV *hv, const char *key, I32 klen, | ||||||
4392 | I32 flags)','name' => 'hv_delete'},'pad_add_name_pv' => {'text' => 'Exactly like L, but takes a nul-terminated string | ||||||
4393 | instead of a string/length pair. | ||||||
4394 | |||||||
4395 | PADOFFSET pad_add_name_pv(const char *name, U32 flags, | ||||||
4396 | HV *typestash, HV *ourstash)','name' => 'pad_add_name_pv'},'POP_MULTICALL' => {'text' => 'Closing bracket for a lightweight callback. | ||||||
4397 | See L |
||||||
4398 | |||||||
4399 | POP_MULTICALL;','name' => 'POP_MULTICALL'},'sv_cat_decode' => {'text' => 'The encoding is assumed to be an Encode object, the PV of the ssv is | ||||||
4400 | assumed to be octets in that encoding and decoding the input starts | ||||||
4401 | from the position which (PV + *offset) pointed to. The dsv will be | ||||||
4402 | concatenated the decoded UTF-8 string from ssv. Decoding will terminate | ||||||
4403 | when the string tstr appears in decoding output or the input ends on | ||||||
4404 | the PV of the ssv. The value which the offset points will be modified | ||||||
4405 | to the last input position on the ssv. | ||||||
4406 | |||||||
4407 | Returns TRUE if the terminator was found, else returns FALSE. | ||||||
4408 | |||||||
4409 | bool sv_cat_decode(SV* dsv, SV *encoding, SV *ssv, | ||||||
4410 | int *offset, char* tstr, int tlen)','name' => 'sv_cat_decode'},'SvIV_set' => {'text' => 'Set the value of the IV pointer in sv to val. It is possible to perform | ||||||
4411 | the same function of this macro with an lvalue assignment to C |
||||||
4412 | With future Perls, however, it will be more efficient to use | ||||||
4413 | C |
||||||
4414 | |||||||
4415 | void SvIV_set(SV* sv, IV val)','name' => 'SvIV_set'},'sv_setiv' => {'text' => 'Copies an integer into the given SV, upgrading first if necessary. | ||||||
4416 | Does not handle \'set\' magic. See also C |
||||||
4417 | |||||||
4418 | void sv_setiv(SV *const sv, const IV num)','name' => 'sv_setiv'},'gv_efullname' => {'text' => '','name' => 'gv_efullname'},'sv_report_used' => {'text' => 'Dump the contents of all SVs not yet freed (debugging aid). | ||||||
4419 | |||||||
4420 | void sv_report_used()','name' => 'sv_report_used'},'save_sptr' => {'text' => '','name' => 'save_sptr'},'SvNVX' => {'text' => 'Returns the raw value in the SV\'s NV slot, without checks or conversions. | ||||||
4421 | Only use when you are sure SvNOK is true. See also C |
||||||
4422 | |||||||
4423 | NV SvNVX(SV* sv)','name' => 'SvNVX'},'do_open' => {'text' => '','name' => 'do_open'},'regnext' => {'text' => '','name' => 'regnext'},'HeHASH' => {'text' => 'Returns the computed hash stored in the hash entry. | ||||||
4424 | |||||||
4425 | U32 HeHASH(HE* he)','name' => 'HeHASH'},'SvIOK' => {'text' => 'Returns a U32 value indicating whether the SV contains an integer. | ||||||
4426 | |||||||
4427 | U32 SvIOK(SV* sv)','name' => 'SvIOK'},'newANONHASH' => {'text' => '','name' => 'newANONHASH'},'is_utf8_char_buf' => {'text' => 'Returns the number of bytes that comprise the first UTF-8 encoded character in | ||||||
4428 | buffer C |
||||||
4429 | buffer. 0 is returned if C |
||||||
4430 | encoded character. | ||||||
4431 | |||||||
4432 | Note that an INVARIANT character (i.e. ASCII on non-EBCDIC | ||||||
4433 | machines) is a valid UTF-8 character. | ||||||
4434 | |||||||
4435 | STRLEN is_utf8_char_buf(const U8 *buf, | ||||||
4436 | const U8 *buf_end)','name' => 'is_utf8_char_buf'},'SvPV_force' => {'text' => 'Like C |
||||||
4437 | (C |
||||||
4438 | directly. | ||||||
4439 | |||||||
4440 | char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'HeUTF8' => {'text' => 'Returns whether the C |
||||||
4441 | doing any necessary dereferencing of possibly C |
||||||
4442 | will be 0 or non-0, not necessarily 1 (or even a value with any low bits set), | ||||||
4443 | so B |
||||||
4444 | typedef for C |
||||||
4445 | |||||||
4446 | char* HeUTF8(HE* he)','name' => 'HeUTF8'},'newRANGE' => {'text' => 'Constructs and returns a C |
||||||
4447 | C |
||||||
4448 | C |
||||||
4449 | for both the C |
||||||
4450 | 1 is automatically set. I |
||||||
4451 | controlling the endpoints of the range; they are consumed by this function | ||||||
4452 | and become part of the constructed op tree. | ||||||
4453 | |||||||
4454 | OP * newRANGE(I32 flags, OP *left, OP *right)','name' => 'newRANGE'},'cophh_delete_pvn' => {'text' => 'Delete a key and its associated value from the cop hints hash I |
||||||
4455 | and returns the modified hash. The returned hash pointer is in general | ||||||
4456 | not the same as the hash pointer that was passed in. The input hash is | ||||||
4457 | consumed by the function, and the pointer to it must not be subsequently | ||||||
4458 | used. Use L if you need both hashes. | ||||||
4459 | |||||||
4460 | The key is specified by I |
||||||
4461 | C |
||||||
4462 | otherwise they are interpreted as Latin-1. I |
||||||
4463 | hash of the key string, or zero if it has not been precomputed. | ||||||
4464 | |||||||
4465 | NOTE: this function is experimental and may change or be | ||||||
4466 | removed without notice. | ||||||
4467 | |||||||
4468 | COPHH * cophh_delete_pvn(COPHH *cophh, | ||||||
4469 | const char *keypv, | ||||||
4470 | STRLEN keylen, U32 hash, | ||||||
4471 | U32 flags)','name' => 'cophh_delete_pvn'},'grok_hex' => {'text' => 'converts a string representing a hex number to numeric form. | ||||||
4472 | |||||||
4473 | On entry I |
||||||
4474 | conversion flags, and I |
||||||
4475 | The scan stops at the end of the string, or the first invalid character. | ||||||
4476 | Unless C |
||||||
4477 | invalid character will also trigger a warning. | ||||||
4478 | On return I<*len> is set to the length of the scanned string, | ||||||
4479 | and I<*flags> gives output flags. | ||||||
4480 | |||||||
4481 | If the value is <= UV_MAX it is returned as a UV, the output flags are clear, | ||||||
4482 | and nothing is written to I<*result>. If the value is > UV_MAX C |
||||||
4483 | returns UV_MAX, sets C |
||||||
4484 | and writes the value to I<*result> (or the value is discarded if I |
||||||
4485 | is NULL). | ||||||
4486 | |||||||
4487 | The hex number may optionally be prefixed with "0x" or "x" unless | ||||||
4488 | C |
||||||
4489 | C |
||||||
4490 | number may use \'_\' characters to separate digits. | ||||||
4491 | |||||||
4492 | UV grok_hex(const char* start, STRLEN* len_p, | ||||||
4493 | I32* flags, NV *result)','name' => 'grok_hex'},'newRV' => {'text' => '','name' => 'newRV'},'SvLOCK' => {'text' => 'Arranges for a mutual exclusion lock to be obtained on sv if a suitable module | ||||||
4494 | has been loaded. | ||||||
4495 | |||||||
4496 | void SvLOCK(SV* sv)','name' => 'SvLOCK'},'gv_fetchfile' => {'text' => '','name' => 'gv_fetchfile'},'sv_vsetpvfn' => {'text' => 'Works like C |
||||||
4497 | appending it. | ||||||
4498 | |||||||
4499 | Usually used via one of its frontends C |
||||||
4500 | |||||||
4501 | void sv_vsetpvfn(SV *const sv, const char *const pat, | ||||||
4502 | const STRLEN patlen, | ||||||
4503 | va_list *const args, | ||||||
4504 | SV **const svargs, const I32 svmax, | ||||||
4505 | bool *const maybe_tainted)','name' => 'sv_vsetpvfn'},'PerlIO_get_cnt' => {'text' => '','name' => 'PerlIO_get_cnt'},'PerlIO_setlinebuf' => {'text' => '','name' => 'PerlIO_setlinebuf'},'utf16_to_utf8_reversed' => {'text' => '','name' => 'utf16_to_utf8_reversed'},'cast_ulong' => {'text' => '','name' => 'cast_ulong'},'to_utf8_case' => {'text' => 'The C contains the pointer to the UTF-8 string encoding |
||||||
4506 | the character that is being converted. This routine assumes that the character | ||||||
4507 | at C is well-formed. |
||||||
4508 | |||||||
4509 | The C |
||||||
4510 | conversion result to. The C |
||||||
4511 | of the result. | ||||||
4512 | |||||||
4513 | The C |
||||||
4514 | |||||||
4515 | Both the special and normal mappings are stored in F |
||||||
4516 | and loaded by SWASHNEW, using F |
||||||
4517 | but not always, a multicharacter mapping), is tried first. | ||||||
4518 | |||||||
4519 | The C |
||||||
4520 | hash %utf8::ToSpecLower. The access to the hash is through | ||||||
4521 | Perl_to_utf8_case(). | ||||||
4522 | |||||||
4523 | The C |
||||||
4524 | %utf8::ToLower. | ||||||
4525 | |||||||
4526 | UV to_utf8_case(const U8 *p, U8* ustrp, | ||||||
4527 | STRLEN *lenp, SV **swashp, | ||||||
4528 | const char *normal, | ||||||
4529 | const char *special)','name' => 'to_utf8_case'},'set_numeric_local' => {'text' => '','name' => 'set_numeric_local'},'is_utf8_print' => {'text' => '','name' => 'is_utf8_print'},'calloc' => {'text' => '','name' => 'calloc'},'POPpbytex' => {'text' => 'Pops a string off the stack which must consist of bytes i.e. characters < 256. | ||||||
4530 | |||||||
4531 | char* POPpbytex','name' => 'POPpbytex'},'cophh_store_sv' => {'text' => 'Like L, but takes a Perl scalar instead of a | ||||||
4532 | string/length pair. | ||||||
4533 | |||||||
4534 | NOTE: this function is experimental and may change or be | ||||||
4535 | removed without notice. | ||||||
4536 | |||||||
4537 | COPHH * cophh_store_sv(const COPHH *cophh, SV *key, | ||||||
4538 | U32 hash, SV *value, U32 flags)','name' => 'cophh_store_sv'},'newPMOP' => {'text' => 'Constructs, checks, and returns an op of any pattern matching type. | ||||||
4539 | I |
||||||
4540 | and, shifted up eight bits, the eight bits of C |
||||||
4541 | |||||||
4542 | OP * newPMOP(I32 type, I32 flags)','name' => 'newPMOP'},'PL_peepp' => {'text' => 'Pointer to the per-subroutine peephole optimiser. This is a function | ||||||
4543 | that gets called at the end of compilation of a Perl subroutine (or | ||||||
4544 | equivalently independent piece of Perl code) to perform fixups of | ||||||
4545 | some ops and to perform small-scale optimisations. The function is | ||||||
4546 | called once for each subroutine that is compiled, and is passed, as sole | ||||||
4547 | parameter, a pointer to the op that is the entry point to the subroutine. | ||||||
4548 | It modifies the op tree in place. | ||||||
4549 | |||||||
4550 | The peephole optimiser should never be completely replaced. Rather, | ||||||
4551 | add code to it by wrapping the existing optimiser. The basic way to do | ||||||
4552 | this can be seen in L |
||||||
4553 | If the new code wishes to operate on ops throughout the subroutine\'s | ||||||
4554 | structure, rather than just at the top level, it is likely to be more | ||||||
4555 | convenient to wrap the L hook. | ||||||
4556 | |||||||
4557 | peep_t PL_peepp','name' => 'PL_peepp'},'SvSetMagicSV' => {'text' => 'Like C |
||||||
4558 | |||||||
4559 | void SvSetMagicSV(SV* dsb, SV* ssv)','name' => 'SvSetMagicSV'},'Move' => {'text' => 'The XSUB-writer\'s interface to the C C |
||||||
4560 | source, C |
||||||
4561 | the type. Can do overlapping moves. See also C |
||||||
4562 | |||||||
4563 | void Move(void* src, void* dest, int nitems, type)','name' => 'Move'},'set_context' => {'text' => '','name' => 'set_context'},'sv_catpvn_flags' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. The | ||||||
4564 | C |
||||||
4565 | status set, then the bytes appended should be valid UTF-8. | ||||||
4566 | If C |
||||||
4567 | C |
||||||
4568 | C |
||||||
4569 | in terms of this function. | ||||||
4570 | |||||||
4571 | void sv_catpvn_flags(SV *const dstr, | ||||||
4572 | const char *sstr, | ||||||
4573 | const STRLEN len, | ||||||
4574 | const I32 flags)','name' => 'sv_catpvn_flags'},'PerlIO_flush' => {'text' => '','name' => 'PerlIO_flush'},'sv_2iv_flags' => {'text' => 'Return the integer value of an SV, doing any necessary string | ||||||
4575 | conversion. If flags includes SV_GMAGIC, does an mg_get() first. | ||||||
4576 | Normally used via the C |
||||||
4577 | |||||||
4578 | IV sv_2iv_flags(SV *const sv, const I32 flags)','name' => 'sv_2iv_flags'},'runops_standard' => {'text' => '','name' => 'runops_standard'},'gv_efullname3' => {'text' => '','name' => 'gv_efullname3'},'newXS' => {'text' => 'Used by C |
||||||
4579 | static storage, as it is used directly as CvFILE(), without a copy being made.','name' => 'newXS'},'XCPT_RETHROW' => {'text' => 'Rethrows a previously caught exception. See L |
||||||
4580 | |||||||
4581 | XCPT_RETHROW;','name' => 'XCPT_RETHROW'},'mg_dup' => {'text' => '','name' => 'mg_dup'},'cop_hints_fetch_pvs' => {'text' => 'Like L, but takes a literal string instead of a | ||||||
4582 | string/length pair, and no precomputed hash. | ||||||
4583 | |||||||
4584 | SV * cop_hints_fetch_pvs(const COP *cop, | ||||||
4585 | const char *key, U32 flags)','name' => 'cop_hints_fetch_pvs'},'cop_store_label' => {'text' => 'Save a label into a C |
||||||
4586 | for a utf-8 label. | ||||||
4587 | |||||||
4588 | NOTE: this function is experimental and may change or be | ||||||
4589 | removed without notice. | ||||||
4590 | |||||||
4591 | void cop_store_label(COP *const cop, | ||||||
4592 | const char *label, STRLEN len, | ||||||
4593 | U32 flags)','name' => 'cop_store_label'},'PUSHmortal' => {'text' => 'Push a new mortal SV onto the stack. The stack must have room for this | ||||||
4594 | element. Does not use C |
||||||
4595 | |||||||
4596 | void PUSHmortal()','name' => 'PUSHmortal'},'XS_EXTERNAL' => {'text' => 'Macro to declare an XSUB and its C parameter list explicitly exporting the symbols.','name' => 'XS_EXTERNAL'},'perl_alloc' => {'text' => 'Allocates a new Perl interpreter. See L |
||||||
4597 | |||||||
4598 | PerlInterpreter* perl_alloc()','name' => 'perl_alloc'},'sv_dump' => {'text' => '','name' => 'sv_dump'},'pad_tidy' => {'text' => 'Tidy up a pad at the end of compilation of the code to which it belongs. | ||||||
4599 | Jobs performed here are: remove most stuff from the pads of anonsub | ||||||
4600 | prototypes; give it a @_; mark temporaries as such. I |
||||||
4601 | the kind of subroutine: | ||||||
4602 | |||||||
4603 | padtidy_SUB ordinary subroutine | ||||||
4604 | padtidy_SUBCLONE prototype for lexical closure | ||||||
4605 | padtidy_FORMAT format | ||||||
4606 | |||||||
4607 | NOTE: this function is experimental and may change or be | ||||||
4608 | removed without notice. | ||||||
4609 | |||||||
4610 | void pad_tidy(padtidy_type type)','name' => 'pad_tidy'},'OP_DESC' => {'text' => 'Return a short description of the provided OP. | ||||||
4611 | |||||||
4612 | const char * OP_DESC(OP *o)','name' => 'OP_DESC'},'strLE' => {'text' => 'Test two strings to see if the first, C |
||||||
4613 | second, C |
||||||
4614 | |||||||
4615 | bool strLE(char* s1, char* s2)','name' => 'strLE'},'newSVpvn_flags' => {'text' => 'Creates a new SV and copies a string into it. The reference count for the | ||||||
4616 | SV is set to 1. Note that if C |
||||||
4617 | string. You are responsible for ensuring that the source string is at least | ||||||
4618 | C |
||||||
4619 | Currently the only flag bits accepted are C |
||||||
4620 | If C |
||||||
4621 | returning. If C |
||||||
4622 | is considered to be in UTF-8 and the | ||||||
4623 | C |
||||||
4624 | C |
||||||
4625 | |||||||
4626 | #define newSVpvn_utf8(s, len, u) \\ | ||||||
4627 | newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0) | ||||||
4628 | |||||||
4629 | SV* newSVpvn_flags(const char *const s, | ||||||
4630 | const STRLEN len, | ||||||
4631 | const U32 flags)','name' => 'newSVpvn_flags'},'XopFLAGS' => {'text' => 'Return the XOP\'s flags. | ||||||
4632 | |||||||
4633 | U32 XopFLAGS(XOP *xop)','name' => 'XopFLAGS'},'sv_compile_2op' => {'text' => '','name' => 'sv_compile_2op'},'SvOK' => {'text' => 'Returns a U32 value indicating whether the value is defined. This is | ||||||
4634 | only meaningful for scalars. | ||||||
4635 | |||||||
4636 | U32 SvOK(SV* sv)','name' => 'SvOK'},'sv_setref_nv' => {'text' => 'Copies a double into a new SV, optionally blessing the SV. The C |
||||||
4637 | argument will be upgraded to an RV. That RV will be modified to point to | ||||||
4638 | the new SV. The C |
||||||
4639 | blessing. Set C |
||||||
4640 | will have a reference count of 1, and the RV will be returned. | ||||||
4641 | |||||||
4642 | SV* sv_setref_nv(SV *const rv, | ||||||
4643 | const char *const classname, | ||||||
4644 | const NV nv)','name' => 'sv_setref_nv'},'eval_pv' => {'text' => 'Tells Perl to C |
||||||
4645 | |||||||
4646 | NOTE: the perl_ form of this function is deprecated. | ||||||
4647 | |||||||
4648 | SV* eval_pv(const char* p, I32 croak_on_error)','name' => 'eval_pv'},'lex_stuff_pvn' => {'text' => 'Insert characters into the lexer buffer (Llinestr>), | ||||||
4649 | immediately after the current lexing point (Lbufptr>), | ||||||
4650 | reallocating the buffer if necessary. This means that lexing code that | ||||||
4651 | runs later will see the characters as if they had appeared in the input. | ||||||
4652 | It is not recommended to do this as part of normal parsing, and most | ||||||
4653 | uses of this facility run the risk of the inserted characters being | ||||||
4654 | interpreted in an unintended manner. | ||||||
4655 | |||||||
4656 | The string to be inserted is represented by I |
||||||
4657 | at I |
||||||
4658 | according to whether the C |
||||||
4659 | The characters are recoded for the lexer buffer, according to how the | ||||||
4660 | buffer is currently being interpreted (L). If a string | ||||||
4661 | to be inserted is available as a Perl scalar, the L | ||||||
4662 | function is more convenient. | ||||||
4663 | |||||||
4664 | NOTE: this function is experimental and may change or be | ||||||
4665 | removed without notice. | ||||||
4666 | |||||||
4667 | void lex_stuff_pvn(const char *pv, STRLEN len, | ||||||
4668 | U32 flags)','name' => 'lex_stuff_pvn'},'sv_usepvn_flags' => {'text' => 'Tells an SV to use C |
||||||
4669 | string is stored inside the SV but sv_usepvn allows the SV to use an | ||||||
4670 | outside string. The C |
||||||
4671 | by C |
||||||
4672 | of memory, and not a pointer to the middle of it. The | ||||||
4673 | string length, C |
||||||
4674 | this function will realloc (i.e. move) the memory pointed to by C |
||||||
4675 | so that pointer should not be freed or used by the programmer after | ||||||
4676 | giving it to sv_usepvn, and neither should any pointers from "behind" | ||||||
4677 | that pointer (e.g. ptr + 1) be used. | ||||||
4678 | |||||||
4679 | If C |
||||||
4680 | SV_HAS_TRAILING_NUL is true, then C |
||||||
4681 | will be skipped (i.e. the buffer is actually at least 1 byte longer than | ||||||
4682 | C |
||||||
4683 | |||||||
4684 | void sv_usepvn_flags(SV *const sv, char* ptr, | ||||||
4685 | const STRLEN len, | ||||||
4686 | const U32 flags)','name' => 'sv_usepvn_flags'},'hv_assert' => {'text' => 'Check that a hash is in an internally consistent state. | ||||||
4687 | |||||||
4688 | void hv_assert(HV *hv)','name' => 'hv_assert'},'my_vsnprintf' => {'text' => 'The C library C |
||||||
4689 | However, if if the C |
||||||
4690 | use the unsafe C |
||||||
4691 | overrun check, but that may be too late). Consider using | ||||||
4692 | C |
||||||
4693 | |||||||
4694 | int my_vsnprintf(char *buffer, const Size_t len, | ||||||
4695 | const char *format, va_list ap)','name' => 'my_vsnprintf'},'sv_free' => {'text' => 'Decrement an SV\'s reference count, and if it drops to zero, call | ||||||
4696 | C |
||||||
4697 | the body; finally, deallocate the SV\'s head itself. | ||||||
4698 | Normally called via a wrapper macro C |
||||||
4699 | |||||||
4700 | void sv_free(SV *const sv)','name' => 'sv_free'},'die_nocontext' => {'text' => '','name' => 'die_nocontext'},'hv_eiter_p' => {'text' => '','name' => 'hv_eiter_p'},'SvPVbyte_force' => {'text' => 'Like C |
||||||
4701 | |||||||
4702 | char* SvPVbyte_force(SV* sv, STRLEN len)','name' => 'SvPVbyte_force'},'is_utf8_ascii' => {'text' => '','name' => 'is_utf8_ascii'},'av_pop' => {'text' => 'Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array | ||||||
4703 | is empty. | ||||||
4704 | |||||||
4705 | Perl equivalent: C |
||||||
4706 | |||||||
4707 | SV* av_pop(AV *av)','name' => 'av_pop'},'reg_named_buff_exists' => {'text' => '','name' => 'reg_named_buff_exists'},'save_bool' => {'text' => '','name' => 'save_bool'},'ckwarn_d' => {'text' => '','name' => 'ckwarn_d'},'croak' => {'text' => 'This is an XS interface to Perl\'s C |
||||||
4708 | |||||||
4709 | Take a sprintf-style format pattern and argument list. These are used to | ||||||
4710 | generate a string message. If the message does not end with a newline, | ||||||
4711 | then it will be extended with some indication of the current location | ||||||
4712 | in the code, as described for L. | ||||||
4713 | |||||||
4714 | The error message will be used as an exception, by default | ||||||
4715 | returning control to the nearest enclosing C |
||||||
4716 | modification by a C<$SIG{__DIE__}> handler. In any case, the C |
||||||
4717 | function never returns normally. | ||||||
4718 | |||||||
4719 | For historical reasons, if C |
||||||
4720 | (C<$@>) will be used as an error message or object instead of building an | ||||||
4721 | error message from arguments. If you want to throw a non-string object, | ||||||
4722 | or build an error message in an SV yourself, it is preferable to use | ||||||
4723 | the L function, which does not involve clobbering C |
||||||
4724 | |||||||
4725 | void croak(const char *pat, ...)','name' => 'croak'},'save_freepv' => {'text' => '','name' => 'save_freepv'},'THIS' => {'text' => 'Variable which is setup by C |
||||||
4726 | XSUB. This is always the proper type for the C++ object. See C |
||||||
4727 | L |
||||||
4728 | |||||||
4729 | (whatever) THIS','name' => 'THIS'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually | ||||||
4730 | handled by C |
||||||
4731 | |||||||
4732 | void XSRETURN(int nitems)','name' => 'XSRETURN'},'dump_indent' => {'text' => '','name' => 'dump_indent'},'screaminstr' => {'text' => '','name' => 'screaminstr'},'op_append_elem' => {'text' => 'Append an item to the list of ops contained directly within a list-type | ||||||
4733 | op, returning the lengthened list. I |
||||||
4734 | and I |
||||||
4735 | intended opcode for the list. If I |
||||||
4736 | right type, it will be upgraded into one. If either I |
||||||
4737 | is null, the other is returned unchanged. | ||||||
4738 | |||||||
4739 | OP * op_append_elem(I32 optype, OP *first, OP *last)','name' => 'op_append_elem'},'lex_read_unichar' => {'text' => 'Reads the next (Unicode) character in the text currently being lexed. | ||||||
4740 | Returns the codepoint (unsigned integer value) of the character read, | ||||||
4741 | and moves Lbufptr> past the character, or returns -1 | ||||||
4742 | if lexing has reached the end of the input text. To non-destructively | ||||||
4743 | examine the next character, use L instead. | ||||||
4744 | |||||||
4745 | If the next character is in (or extends into) the next chunk of input | ||||||
4746 | text, the next chunk will be read in. Normally the current chunk will be | ||||||
4747 | discarded at the same time, but if I |
||||||
4748 | then the current chunk will not be discarded. | ||||||
4749 | |||||||
4750 | If the input is being interpreted as UTF-8 and a UTF-8 encoding error | ||||||
4751 | is encountered, an exception is generated. | ||||||
4752 | |||||||
4753 | NOTE: this function is experimental and may change or be | ||||||
4754 | removed without notice. | ||||||
4755 | |||||||
4756 | I32 lex_read_unichar(U32 flags)','name' => 'lex_read_unichar'},'reginitcolors' => {'text' => '','name' => 'reginitcolors'},'sv_2pv_nolen' => {'text' => 'Like C |
||||||
4757 | use the macro wrapper C |
||||||
4758 | |||||||
4759 | char* sv_2pv_nolen(SV* sv)','name' => 'sv_2pv_nolen'},'get_av' => {'text' => 'Returns the AV of the specified Perl global or package array with the given | ||||||
4760 | name (so it won\'t work on lexical variables). C |
||||||
4761 | to C |
||||||
4762 | Perl variable does not exist then it will be created. If C |
||||||
4763 | and the variable does not exist then NULL is returned. | ||||||
4764 | |||||||
4765 | Perl equivalent: C<@{"$name"}>. | ||||||
4766 | |||||||
4767 | NOTE: the perl_ form of this function is deprecated. | ||||||
4768 | |||||||
4769 | AV* get_av(const char *name, I32 flags)','name' => 'get_av'},'op_contextualize' => {'text' => 'Applies a syntactic context to an op tree representing an expression. | ||||||
4770 | I |
||||||
4771 | or C |
||||||
4772 | is returned. | ||||||
4773 | |||||||
4774 | OP * op_contextualize(OP *o, I32 context)','name' => 'op_contextualize'},'PoisonFree' => {'text' => 'PoisonWith(0xEF) for catching access to freed memory. | ||||||
4775 | |||||||
4776 | void PoisonFree(void* dest, int nitems, type)','name' => 'PoisonFree'},'gv_SVadd' => {'text' => '','name' => 'gv_SVadd'},'hv_common' => {'text' => '','name' => 'hv_common'},'XopENTRY' => {'text' => 'Return a member of the XOP structure. I |
||||||
4777 | which entry to return. If the member is not set this will return a | ||||||
4778 | default value. The return type depends on I |
||||||
4779 | |||||||
4780 | XopENTRY(XOP *xop, which)','name' => 'XopENTRY'},'newSVREF' => {'text' => '','name' => 'newSVREF'},'toUPPER' => {'text' => 'Converts the specified character to uppercase in the platform\'s native | ||||||
4781 | character set, if possible; otherwise returns the input character itself. | ||||||
4782 | |||||||
4783 | char toUPPER(char ch)','name' => 'toUPPER'},'sv_catpvs_flags' => {'text' => 'Like C |
||||||
4784 | string/length pair. | ||||||
4785 | |||||||
4786 | void sv_catpvs_flags(SV* sv, const char* s, | ||||||
4787 | I32 flags)','name' => 'sv_catpvs_flags'},'is_lvalue_sub' => {'text' => '','name' => 'is_lvalue_sub'},'is_utf8_string_loc' => {'text' => 'Like L but stores the location of the failure (in the | ||||||
4788 | case of "utf8ness failure") or the location C |
||||||
4789 | "utf8ness success") in the C |
||||||
4790 | |||||||
4791 | See also L() and L(). | ||||||
4792 | |||||||
4793 | bool is_utf8_string_loc(const U8 *s, STRLEN len, | ||||||
4794 | const U8 **p)','name' => 'is_utf8_string_loc'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally | ||||||
4795 | appending to the currently-stored string. | ||||||
4796 | |||||||
4797 | char* sv_gets(SV *const sv, PerlIO *const fp, | ||||||
4798 | I32 append)','name' => 'sv_gets'},'SvSetSV_nosteal' => {'text' => 'Calls a non-destructive version of C |
||||||
4799 | ssv. May evaluate arguments more than once. | ||||||
4800 | |||||||
4801 | void SvSetSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetSV_nosteal'},'pad_add_anon' => {'text' => 'Allocates a place in the currently-compiling pad (via L) | ||||||
4802 | for an anonymous function that is lexically scoped inside the | ||||||
4803 | currently-compiling function. | ||||||
4804 | The function I |
||||||
4805 | to the outer scope is weakened to avoid a reference loop. | ||||||
4806 | |||||||
4807 | I |
||||||
4808 | pad entry is to support. This doesn\'t affect operational semantics, | ||||||
4809 | but is used for debugging. | ||||||
4810 | |||||||
4811 | PADOFFSET pad_add_anon(CV *func, I32 optype)','name' => 'pad_add_anon'},'dUNDERBAR' => {'text' => 'Sets up any variable needed by the C |
||||||
4812 | C |
||||||
4813 | to still use it for ensuring past and future compatibility. | ||||||
4814 | |||||||
4815 | dUNDERBAR;','name' => 'dUNDERBAR'},'sv_uv' => {'text' => 'A private implementation of the C |
||||||
4816 | cope with complex macro expressions. Always use the macro instead. | ||||||
4817 | |||||||
4818 | UV sv_uv(SV* sv)','name' => 'sv_uv'},'ptr_table_split' => {'text' => '','name' => 'ptr_table_split'},'foldEQ_utf8' => {'text' => 'Returns true if the leading portions of the strings C |
||||||
4819 | of which may be in UTF-8) are the same case-insensitively; false otherwise. | ||||||
4820 | How far into the strings to compare is determined by other input parameters. | ||||||
4821 | |||||||
4822 | If C |
||||||
4823 | otherwise it is assumed to be in native 8-bit encoding. Correspondingly for C |
||||||
4824 | with respect to C |
||||||
4825 | |||||||
4826 | If the byte length C |
||||||
4827 | equality. In other words, C |
||||||
4828 | scan will not be considered to be a match unless the goal is reached, and | ||||||
4829 | scanning won\'t continue past that goal. Correspondingly for C |
||||||
4830 | C |
||||||
4831 | |||||||
4832 | If C |
||||||
4833 | considered an end pointer beyond which scanning of C |
||||||
4834 | any circumstances. This means that if both C |
||||||
4835 | C |
||||||
4836 | is less than C |
||||||
4837 | never | ||||||
4838 | get as far as its goal (and in fact is asserted against). Correspondingly for | ||||||
4839 | C |
||||||
4840 | |||||||
4841 | At least one of C |
||||||
4842 | C |
||||||
4843 | reached for a successful match. Also, if the fold of a character is multiple | ||||||
4844 | characters, all of them must be matched (see tr21 reference below for | ||||||
4845 | \'folding\'). | ||||||
4846 | |||||||
4847 | Upon a successful match, if C |
||||||
4848 | it will be set to point to the beginning of the I |
||||||
4849 | beyond what was matched. Correspondingly for C |
||||||
4850 | |||||||
4851 | For case-insensitiveness, the "casefolding" of Unicode is used | ||||||
4852 | instead of upper/lowercasing both the characters, see | ||||||
4853 | L |
||||||
4854 | |||||||
4855 | I32 foldEQ_utf8(const char *s1, char **pe1, UV l1, | ||||||
4856 | bool u1, const char *s2, char **pe2, | ||||||
4857 | UV l2, bool u2)','name' => 'foldEQ_utf8'},'Nullch' => {'text' => 'Null character pointer. (No longer available when C |
||||||
4858 | |||||||
4859 | C |
||||||
4860 | argument list. These are used to generate a string message. If the | ||||||
4861 | message does not end with a newline, then it will be extended with | ||||||
4862 | some indication of the current location in the code, as described for | ||||||
4863 | L. | ||||||
4864 | |||||||
4865 | The error message will be used as an exception, by default | ||||||
4866 | returning control to the nearest enclosing C |
||||||
4867 | modification by a C<$SIG{__DIE__}> handler. In any case, the C |
||||||
4868 | function never returns normally. | ||||||
4869 | |||||||
4870 | For historical reasons, if C |
||||||
4871 | (C<$@>) will be used as an error message or object instead of building an | ||||||
4872 | error message from arguments. If you want to throw a non-string object, | ||||||
4873 | or build an error message in an SV yourself, it is preferable to use | ||||||
4874 | the L function, which does not involve clobbering C |
||||||
4875 | |||||||
4876 | void vcroak(const char *pat, va_list *args)','name' => 'vcroak'},'parse_fullexpr' => {'text' => 'Parse a single complete Perl expression. This allows the full | ||||||
4877 | expression grammar, including the lowest-precedence operators such | ||||||
4878 | as C |
||||||
4879 | token that an expression would normally be terminated by: end-of-file, | ||||||
4880 | closing bracketing punctuation, semicolon, or one of the keywords that | ||||||
4881 | signals a postfix expression-statement modifier. If I |
||||||
4882 | C |
||||||
4883 | mandatory. It is up to the caller to ensure that the dynamic parser | ||||||
4884 | state (L et al) is correctly set to reflect the source of | ||||||
4885 | the code to be parsed and the lexical context for the expression. | ||||||
4886 | |||||||
4887 | The op tree representing the expression is returned. If an optional | ||||||
4888 | expression is absent, a null pointer is returned, otherwise the pointer | ||||||
4889 | will be non-null. | ||||||
4890 | |||||||
4891 | If an error occurs in parsing or compilation, in most cases a valid op | ||||||
4892 | tree is returned anyway. The error is reflected in the parser state, | ||||||
4893 | normally resulting in a single exception at the top level of parsing | ||||||
4894 | which covers all the compilation errors that occurred. Some compilation | ||||||
4895 | errors, however, will throw an exception immediately. | ||||||
4896 | |||||||
4897 | NOTE: this function is experimental and may change or be | ||||||
4898 | removed without notice. | ||||||
4899 | |||||||
4900 | OP * parse_fullexpr(U32 flags)','name' => 'parse_fullexpr'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the | ||||||
4901 | supplied vtable and returns a pointer to the magic added. | ||||||
4902 | |||||||
4903 | Note that C |
||||||
4904 | In particular, you can add magic to SvREADONLY SVs, and add more than | ||||||
4905 | one instance of the same \'how\'. | ||||||
4906 | |||||||
4907 | If C |
||||||
4908 | stored, if C |
||||||
4909 | special case - if C<(name && namlen == HEf_SVKEY)> then C |
||||||
4910 | to contain an C |
||||||
4911 | |||||||
4912 | (This is now used as a subroutine by C |
||||||
4913 | |||||||
4914 | MAGIC * sv_magicext(SV *const sv, SV *const obj, | ||||||
4915 | const int how, | ||||||
4916 | const MGVTBL *const vtbl, | ||||||
4917 | const char *const name, | ||||||
4918 | const I32 namlen)','name' => 'sv_magicext'},'to_uni_title' => {'text' => '','name' => 'to_uni_title'},'gv_fullname4' => {'text' => '','name' => 'gv_fullname4'},'is_uni_idfirst' => {'text' => '','name' => 'is_uni_idfirst'},'av_push' => {'text' => 'Pushes an SV onto the end of the array. The array will grow automatically | ||||||
4919 | to accommodate the addition. This takes ownership of one reference count. | ||||||
4920 | |||||||
4921 | Perl equivalent: C |
||||||
4922 | |||||||
4923 | void av_push(AV *av, SV *val)','name' => 'av_push'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C |
||||||
4924 | |||||||
4925 | XSRETURN_NO;','name' => 'XSRETURN_NO'},'POPn' => {'text' => 'Pops a double off the stack. | ||||||
4926 | |||||||
4927 | NV POPn','name' => 'POPn'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original | ||||||
4928 | SV is B |
||||||
4929 | |||||||
4930 | SV* newRV_noinc(SV *const sv)','name' => 'newRV_noinc'},'unsharepvn' => {'text' => '','name' => 'unsharepvn'},'my_memcmp' => {'text' => '','name' => 'my_memcmp'},'newSLICEOP' => {'text' => 'Constructs, checks, and returns an C |
||||||
4931 | gives the eight bits of C |
||||||
4932 | be set automatically, and, shifted up eight bits, the eight bits of | ||||||
4933 | C |
||||||
4934 | set as required. I |
||||||
4935 | the slice; they are consumed by this function and become part of the | ||||||
4936 | constructed op tree. | ||||||
4937 | |||||||
4938 | OP * newSLICEOP(I32 flags, OP *subscript, | ||||||
4939 | OP *listval)','name' => 'newSLICEOP'},'mfree' => {'text' => '','name' => 'mfree'},'save_re_context' => {'text' => '','name' => 'save_re_context'},'hv_iterinit' => {'text' => 'Prepares a starting point to traverse a hash table. Returns the number of | ||||||
4940 | keys in the hash (i.e. the same as C |
||||||
4941 | currently only meaningful for hashes without tie magic. | ||||||
4942 | |||||||
4943 | NOTE: Before version 5.004_65, C |
||||||
4944 | hash buckets that happen to be in use. If you still need that esoteric | ||||||
4945 | value, you can get it through the macro C |
||||||
4946 | |||||||
4947 | |||||||
4948 | I32 hv_iterinit(HV *hv)','name' => 'hv_iterinit'}};}; | ||||||
4949 | |||||||
4950 | 5 | 203 | my $self = bless({ | ||||
4951 | 'index' => $VAR1, | ||||||
4952 | perl_version => '5.016000', | ||||||
4953 | } => $class); | ||||||
4954 | 5 | 1207 | return $self; | ||||
4955 | } | ||||||
4956 | |||||||
4957 | 1; |