blib/lib/Perl/APIReference/V5_018_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_018_000; | ||||||
2 | 1 | 1 | 5 | use strict; | |||
1 | 1 | ||||||
1 | 46 | ||||||
3 | 1 | 1 | 5 | use warnings; | |||
1 | 1 | ||||||
1 | 32 | ||||||
4 | 1 | 1 | 4 | use parent 'Perl::APIReference'; | |||
1 | 2 | ||||||
1 | 7 | ||||||
5 | |||||||
6 | sub new { | ||||||
7 | 4 | 4 | 1 | 8 | my $class = shift; | ||
8 | 4 | 5 | my $VAR1; | ||||
9 | |||||||
10 | 4 | 6 | do{$VAR1 = {'newBINOP' => {'text' => 'Constructs, checks, and returns an op of any binary type. I |
||||
4 | 6648 | ||||||
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 | Note that there is no guarantee that the return value of C |
||||||
28 | equal to C |
||||||
29 | successive calls to C | ||||||
30 | time. This is due to the way that things like overloading and | ||||||
31 | Copy-On-Write are handled. In these cases, the return value may point to | ||||||
32 | a temporary buffer or similar. If you absolutely need the SvPVX field to | ||||||
33 | be valid (for example, if you intend to write to it), then see | ||||||
34 | L. | ||||||
35 | |||||||
36 | char* SvPV(SV* sv, STRLEN len)','name' => 'SvPV'},'sv_vsetpvf_mg' => {'text' => 'Like C |
||||||
37 | |||||||
38 | Usually used via its frontend C |
||||||
39 | |||||||
40 | void sv_vsetpvf_mg(SV *const sv, | ||||||
41 | const char *const pat, | ||||||
42 | va_list *const args)','name' => 'sv_vsetpvf_mg'},'SvPVutf8' => {'text' => 'Like C |
||||||
43 | |||||||
44 | char* SvPVutf8(SV* sv, STRLEN len)','name' => 'SvPVutf8'},'sortsv_flags' => {'text' => 'Sort an array, with various options. | ||||||
45 | |||||||
46 | void sortsv_flags(SV** array, size_t num_elts, | ||||||
47 | SVCOMPARE_t cmp, U32 flags)','name' => 'sortsv_flags'},'vwarn' => {'text' => 'This is an XS interface to Perl\'s C |
||||||
48 | |||||||
49 | C |
||||||
50 | argument list. These are used to generate a string message. If the | ||||||
51 | message does not end with a newline, then it will be extended with | ||||||
52 | some indication of the current location in the code, as described for | ||||||
53 | L. | ||||||
54 | |||||||
55 | The error message or object will by default be written to standard error, | ||||||
56 | but this is subject to modification by a C<$SIG{__WARN__}> handler. | ||||||
57 | |||||||
58 | Unlike with L, C |
||||||
59 | |||||||
60 | void vwarn(const char *pat, va_list *args)','name' => 'vwarn'},'scan_oct' => {'text' => 'For backwards compatibility. Use C |
||||||
61 | |||||||
62 | NV scan_oct(const char* start, STRLEN len, | ||||||
63 | 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 | ||||||
64 | embedded reference to a GV. I |
||||||
65 | eight bits of C |
||||||
66 | reference; calling this function does not transfer ownership of any | ||||||
67 | reference to it. | ||||||
68 | |||||||
69 | OP * newGVOP(I32 type, I32 flags, GV *gv)','name' => 'newGVOP'},'XopDISABLE' => {'text' => 'Temporarily disable a member of the XOP, by clearing the appropriate flag. | ||||||
70 | |||||||
71 | void XopDISABLE(XOP *xop, which)','name' => 'XopDISABLE'},'hv_rand_set' => {'text' => '','name' => 'hv_rand_set'},'find_runcv' => {'text' => 'Locate the CV corresponding to the currently executing sub or eval. | ||||||
72 | If db_seqp is non_null, skip CVs that are in the DB package and populate | ||||||
73 | *db_seqp with the cop sequence number at the point that the DB:: code was | ||||||
74 | entered. (allows debuggers to eval in the scope of the breakpoint rather | ||||||
75 | than in the scope of the debugger itself). | ||||||
76 | |||||||
77 | CV* find_runcv(U32 *db_seqp)','name' => 'find_runcv'},'utf8n_to_uvuni' => {'text' => 'Bottom level UTF-8 decode routine. | ||||||
78 | Returns the code point value of the first character in the string C |
||||||
79 | which is assumed to be in UTF-8 (or UTF-EBCDIC) encoding, and no longer than | ||||||
80 | C |
||||||
81 | the length, in bytes, of that character. | ||||||
82 | |||||||
83 | The value of C |
||||||
84 | well-formed UTF-8 character. If C |
||||||
85 | zero is returned and C<*retlen> is set so that (S |
||||||
86 | next possible position in C |
||||||
87 | Also, if UTF-8 warnings haven\'t been lexically disabled, a warning is raised. | ||||||
88 | |||||||
89 | Various ALLOW flags can be set in C |
||||||
90 | individual types of malformations, such as the sequence being overlong (that | ||||||
91 | is, when there is a shorter sequence that can express the same code point; | ||||||
92 | overlong sequences are expressly forbidden in the UTF-8 standard due to | ||||||
93 | potential security issues). Another malformation example is the first byte of | ||||||
94 | a character not being a legal first byte. See F |
||||||
95 | flags. For allowed 0 length strings, this function returns 0; for allowed | ||||||
96 | overlong sequences, the computed code point is returned; for all other allowed | ||||||
97 | malformations, the Unicode REPLACEMENT CHARACTER is returned, as these have no | ||||||
98 | determinable reasonable value. | ||||||
99 | |||||||
100 | The UTF8_CHECK_ONLY flag overrides the behavior when a non-allowed (by other | ||||||
101 | flags) malformation is found. If this flag is set, the routine assumes that | ||||||
102 | the caller will raise a warning, and this function will silently just set | ||||||
103 | C |
||||||
104 | |||||||
105 | Note that this API requires disambiguation between successful decoding a NUL | ||||||
106 | character, and an error return (unless the UTF8_CHECK_ONLY flag is set), as | ||||||
107 | in both cases, 0 is returned. To disambiguate, upon a zero return, see if the | ||||||
108 | first byte of C |
||||||
109 | had an error. | ||||||
110 | |||||||
111 | Certain code points are considered problematic. These are Unicode surrogates, | ||||||
112 | Unicode non-characters, and code points above the Unicode maximum of 0x10FFFF. | ||||||
113 | By default these are considered regular code points, but certain situations | ||||||
114 | warrant special handling for them. If C |
||||||
115 | UTF8_DISALLOW_ILLEGAL_INTERCHANGE, all three classes are treated as | ||||||
116 | malformations and handled as such. The flags UTF8_DISALLOW_SURROGATE, | ||||||
117 | UTF8_DISALLOW_NONCHAR, and UTF8_DISALLOW_SUPER (meaning above the legal Unicode | ||||||
118 | maximum) can be set to disallow these categories individually. | ||||||
119 | |||||||
120 | The flags UTF8_WARN_ILLEGAL_INTERCHANGE, UTF8_WARN_SURROGATE, | ||||||
121 | UTF8_WARN_NONCHAR, and UTF8_WARN_SUPER will cause warning messages to be raised | ||||||
122 | for their respective categories, but otherwise the code points are considered | ||||||
123 | valid (not malformations). To get a category to both be treated as a | ||||||
124 | malformation and raise a warning, specify both the WARN and DISALLOW flags. | ||||||
125 | (But note that warnings are not raised if lexically disabled nor if | ||||||
126 | UTF8_CHECK_ONLY is also specified.) | ||||||
127 | |||||||
128 | Very large code points (above 0x7FFF_FFFF) are considered more problematic than | ||||||
129 | the others that are above the Unicode legal maximum. There are several | ||||||
130 | reasons: they requre at least 32 bits to represent them on ASCII platforms, are | ||||||
131 | not representable at all on EBCDIC platforms, and the original UTF-8 | ||||||
132 | specification never went above this number (the current 0x10FFFF limit was | ||||||
133 | imposed later). (The smaller ones, those that fit into 32 bits, are | ||||||
134 | representable by a UV on ASCII platforms, but not by an IV, which means that | ||||||
135 | the number of operations that can be performed on them is quite restricted.) | ||||||
136 | The UTF-8 encoding on ASCII platforms for these large code points begins with a | ||||||
137 | byte containing 0xFE or 0xFF. The UTF8_DISALLOW_FE_FF flag will cause them to | ||||||
138 | be treated as malformations, while allowing smaller above-Unicode code points. | ||||||
139 | (Of course UTF8_DISALLOW_SUPER will treat all above-Unicode code points, | ||||||
140 | including these, as malformations.) Similarly, UTF8_WARN_FE_FF acts just like | ||||||
141 | the other WARN flags, but applies just to these code points. | ||||||
142 | |||||||
143 | All other code points corresponding to Unicode characters, including private | ||||||
144 | use and those yet to be assigned, are never considered malformed and never | ||||||
145 | warn. | ||||||
146 | |||||||
147 | Most code should use L() rather than call this directly. | ||||||
148 | |||||||
149 | UV utf8n_to_uvuni(const U8 *s, STRLEN curlen, | ||||||
150 | 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 | ||||||
151 | C |
||||||
152 | |||||||
153 | SV* newSVpvn_utf8(NULLOK const char* s, STRLEN len, | ||||||
154 | U32 utf8)','name' => 'newSVpvn_utf8'},'dMARK' => {'text' => 'Declare a stack marker variable, C, for the XSUB. See C and | ||||||
155 | C |
||||||
156 | |||||||
157 | 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 | ||||||
158 | of an SV instead of a string/length pair. | ||||||
159 | |||||||
160 | GV* gv_fetchmeth_sv_autoload(HV* stash, SV* namesv, | ||||||
161 | 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, | ||||||
162 | up to I |
||||||
163 | all pointers into the buffer updated appropriately. I |
||||||
164 | be later in the buffer than the position of Lbufptr>: | ||||||
165 | it is not permitted to discard text that has yet to be lexed. | ||||||
166 | |||||||
167 | Normally it is not necessarily to do this directly, because it suffices to | ||||||
168 | use the implicit discarding behaviour of L and things | ||||||
169 | based on it. However, if a token stretches across multiple lines, | ||||||
170 | and the lexing code has kept multiple lines of text in the buffer for | ||||||
171 | that purpose, then after completion of the token it would be wise to | ||||||
172 | explicitly discard the now-unneeded earlier lines, to avoid future | ||||||
173 | multi-line tokens growing the buffer without bound. | ||||||
174 | |||||||
175 | NOTE: this function is experimental and may change or be | ||||||
176 | removed without notice. | ||||||
177 | |||||||
178 | 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 |
||||||
179 | Specifically, the function is applied to an C |
||||||
180 | subroutine call, not marked with C<&>, where the callee can be identified | ||||||
181 | at compile time as I |
||||||
182 | |||||||
183 | The C-level function pointer is returned in I<*ckfun_p>, and an SV | ||||||
184 | argument for it is returned in I<*ckobj_p>. The function is intended | ||||||
185 | to be called in this manner: | ||||||
186 | |||||||
187 | entersubop = (*ckfun_p)(aTHX_ entersubop, namegv, (*ckobj_p)); | ||||||
188 | |||||||
189 | In this call, I |
||||||
190 | which may be replaced by the check function, and I |
||||||
191 | supplying the name that should be used by the check function to refer | ||||||
192 | to the callee of the C |
||||||
193 | It is permitted to apply the check function in non-standard situations, | ||||||
194 | such as to a call to a different subroutine or to a method call. | ||||||
195 | |||||||
196 | By default, the function is | ||||||
197 | L |
||||||
198 | and the SV parameter is I |
||||||
199 | prototype processing. It can be changed, for a particular subroutine, | ||||||
200 | by L. | ||||||
201 | |||||||
202 | void cv_get_call_checker(CV *cv, | ||||||
203 | Perl_call_checker *ckfun_p, | ||||||
204 | SV **ckobj_p)','name' => 'cv_get_call_checker'},'mXPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C |
||||||
205 | indicates the length of the string. Does not use C |
||||||
206 | C |
||||||
207 | |||||||
208 | void mXPUSHp(char* str, STRLEN len)','name' => 'mXPUSHp'},'lex_stuff_sv' => {'text' => 'Insert characters into the lexer buffer (Llinestr>), | ||||||
209 | immediately after the current lexing point (Lbufptr>), | ||||||
210 | reallocating the buffer if necessary. This means that lexing code that | ||||||
211 | runs later will see the characters as if they had appeared in the input. | ||||||
212 | It is not recommended to do this as part of normal parsing, and most | ||||||
213 | uses of this facility run the risk of the inserted characters being | ||||||
214 | interpreted in an unintended manner. | ||||||
215 | |||||||
216 | The string to be inserted is the string value of I |
||||||
217 | are recoded for the lexer buffer, according to how the buffer is currently | ||||||
218 | being interpreted (L). If a string to be inserted is | ||||||
219 | not already a Perl scalar, the L function avoids the | ||||||
220 | need to construct a scalar. | ||||||
221 | |||||||
222 | NOTE: this function is experimental and may change or be | ||||||
223 | removed without notice. | ||||||
224 | |||||||
225 | void lex_stuff_sv(SV *sv, U32 flags)','name' => 'lex_stuff_sv'},'ibcmp_utf8' => {'text' => 'This is a synonym for (! foldEQ_utf8()) | ||||||
226 | |||||||
227 | I32 ibcmp_utf8(const char *s1, char **pe1, UV l1, | ||||||
228 | bool u1, const char *s2, char **pe2, | ||||||
229 | UV l2, bool u2)','name' => 'ibcmp_utf8'},'CvSTASH' => {'text' => 'Returns the stash of the CV. A stash is the symbol table hash, containing | ||||||
230 | the package-scoped variables in the package where the subroutine was defined. | ||||||
231 | For more information, see L |
||||||
232 | |||||||
233 | This also has a special use with XS AUTOLOAD subs. | ||||||
234 | See L |
||||||
235 | |||||||
236 | HV* CvSTASH(CV* cv)','name' => 'CvSTASH'},'gv_const_sv' => {'text' => 'If C |
||||||
237 | inlining, or C |
||||||
238 | a typeglob, then returns the value returned by the sub. Otherwise, returns | ||||||
239 | NULL. | ||||||
240 | |||||||
241 | 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. | ||||||
242 | The target SV physically takes over ownership of the body of the source SV | ||||||
243 | and inherits its flags; however, the target keeps any magic it owns, | ||||||
244 | and any magic in the source is discarded. | ||||||
245 | Note that this is a rather specialist SV copying operation; most of the | ||||||
246 | time you\'ll want to use C |
||||||
247 | |||||||
248 | 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 | ||||||
249 | C |
||||||
250 | which is assumed to be in UTF-8 encoding; C |
||||||
251 | length, in bytes, of that character. | ||||||
252 | |||||||
253 | C |
||||||
254 | |||||||
255 | UV utf8n_to_uvchr(const U8 *s, STRLEN curlen, | ||||||
256 | STRLEN *retlen, U32 flags)','name' => 'utf8n_to_uvchr'},'G_ARRAY' => {'text' => 'Used to indicate list context. See C |
||||||
257 | L |
||||||
258 | module\'s C |
||||||
259 | C |
||||||
260 | |||||||
261 | XS_VERSION_BOOTCHECK;','name' => 'XS_VERSION_BOOTCHECK'},'pad_compname_type' => {'text' => 'Looks up the type of the lexical variable at position I |
||||||
262 | currently-compiling pad. If the variable is typed, the stash of the | ||||||
263 | class to which it is typed is returned. If not, C |
||||||
264 | |||||||
265 | HV * pad_compname_type(PADOFFSET po)','name' => 'pad_compname_type'},'mXPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. | ||||||
266 | Does not use C |
||||||
267 | |||||||
268 | void mXPUSHn(NV nv)','name' => 'mXPUSHn'},'SvSETMAGIC' => {'text' => 'Invokes C |
||||||
269 | after modifying a scalar, in case it is a magical variable like C<$|> | ||||||
270 | or a tied variable (it calls C |
||||||
271 | argument more than once. | ||||||
272 | |||||||
273 | void SvSETMAGIC(SV* sv)','name' => 'SvSETMAGIC'},'G_EVAL' => {'text' => 'Used to force a Perl C |
||||||
274 | L |
||||||
275 | |||||||
276 | 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 | ||||||
277 | with C |
||||||
278 | |||||||
279 | Approximate Perl equivalent: C<&{"$sub_name"}(@$argv)>. | ||||||
280 | |||||||
281 | NOTE: the perl_ form of this function is deprecated. | ||||||
282 | |||||||
283 | I32 call_argv(const char* sub_name, I32 flags, | ||||||
284 | char** argv)','name' => 'call_argv'},'save_freeop' => {'text' => '','name' => 'save_freeop'},'SvPV_nolen' => {'text' => 'Like C |
||||||
285 | |||||||
286 | char* SvPV_nolen(SV* sv)','name' => 'SvPV_nolen'},'alloccopstash' => {'text' => 'Available only under threaded builds, this function allocates an entry in | ||||||
287 | C |
||||||
288 | |||||||
289 | NOTE: this function is experimental and may change or be | ||||||
290 | removed without notice. | ||||||
291 | |||||||
292 | PADOFFSET alloccopstash(HV *hv)','name' => 'alloccopstash'},'perl_clone' => {'text' => 'Create and return a new interpreter by cloning the current one. | ||||||
293 | |||||||
294 | perl_clone takes these flags as parameters: | ||||||
295 | |||||||
296 | CLONEf_COPY_STACKS - is used to, well, copy the stacks also, | ||||||
297 | without it we only clone the data and zero the stacks, | ||||||
298 | with it we copy the stacks and the new perl interpreter is | ||||||
299 | ready to run at the exact same point as the previous one. | ||||||
300 | The pseudo-fork code uses COPY_STACKS while the | ||||||
301 | threads->create doesn\'t. | ||||||
302 | |||||||
303 | CLONEf_KEEP_PTR_TABLE - | ||||||
304 | perl_clone keeps a ptr_table with the pointer of the old | ||||||
305 | variable as a key and the new variable as a value, | ||||||
306 | this allows it to check if something has been cloned and not | ||||||
307 | clone it again but rather just use the value and increase the | ||||||
308 | refcount. If KEEP_PTR_TABLE is not set then perl_clone will kill | ||||||
309 | the ptr_table using the function | ||||||
310 | C |
||||||
311 | reason to keep it around is if you want to dup some of your own | ||||||
312 | variable who are outside the graph perl scans, example of this | ||||||
313 | code is in threads.xs create. | ||||||
314 | |||||||
315 | CLONEf_CLONE_HOST - | ||||||
316 | This is a win32 thing, it is ignored on unix, it tells perls | ||||||
317 | win32host code (which is c++) to clone itself, this is needed on | ||||||
318 | win32 if you want to run two threads at the same time, | ||||||
319 | if you just want to do some stuff in a separate perl interpreter | ||||||
320 | and then throw it away and return to the original one, | ||||||
321 | you don\'t need to do anything. | ||||||
322 | |||||||
323 | PerlInterpreter* perl_clone( | ||||||
324 | PerlInterpreter *proto_perl, | ||||||
325 | UV flags | ||||||
326 | )','name' => 'perl_clone'},'save_alloc' => {'text' => '','name' => 'save_alloc'},'SvSetSV' => {'text' => 'Calls C |
||||||
327 | more than once. | ||||||
328 | |||||||
329 | 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 | ||||||
330 | currently-compiling pad. | ||||||
331 | I |
||||||
332 | I |
||||||
333 | If it is not in the current pad but appears in the pad of any lexically | ||||||
334 | enclosing scope, then a pseudo-entry for it is added in the current pad. | ||||||
335 | Returns the offset in the current pad, | ||||||
336 | or C |
||||||
337 | |||||||
338 | PADOFFSET pad_findmy_pvn(const char *namepv, | ||||||
339 | STRLEN namelen, U32 flags)','name' => 'pad_findmy_pvn'},'hv_fetchs' => {'text' => 'Like C |
||||||
340 | |||||||
341 | 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 |
||||||
342 | indicates the number of bytes to compare. Returns true or false. (A | ||||||
343 | wrapper for C |
||||||
344 | |||||||
345 | bool strnNE(char* s1, char* s2, STRLEN len)','name' => 'strnNE'},'cophh_store_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of | ||||||
346 | a string/length pair. | ||||||
347 | |||||||
348 | NOTE: this function is experimental and may change or be | ||||||
349 | removed without notice. | ||||||
350 | |||||||
351 | COPHH * cophh_store_pv(const COPHH *cophh, | ||||||
352 | const char *key, U32 hash, | ||||||
353 | SV *value, U32 flags)','name' => 'cophh_store_pv'},'savepv' => {'text' => 'Perl\'s version of C |
||||||
354 | string which is a duplicate of C |
||||||
355 | determined by C |
||||||
356 | be freed with the C |
||||||
357 | |||||||
358 | 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 |
||||||
359 | See C |
||||||
360 | |||||||
361 | char* HvNAME(HV* stash)','name' => 'HvNAME'},'sv_recode_to_utf8' => {'text' => 'The encoding is assumed to be an Encode object, on entry the PV | ||||||
362 | of the sv is assumed to be octets in that encoding, and the sv | ||||||
363 | will be converted into Unicode (and UTF-8). | ||||||
364 | |||||||
365 | If the sv already is UTF-8 (or if it is not POK), or if the encoding | ||||||
366 | is not a reference, nothing is done to the sv. If the encoding is not | ||||||
367 | an C |
||||||
368 | (See F |
||||||
369 | |||||||
370 | The PV of the sv is returned. | ||||||
371 | |||||||
372 | 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 | ||||||
373 | run Perl interpreters. This should be called only once, before creating | ||||||
374 | any Perl interpreters. | ||||||
375 | |||||||
376 | void PERL_SYS_INIT(int *argc, char*** argv)','name' => 'PERL_SYS_INIT'},'vstringify' => {'text' => 'In order to maintain maximum compatibility with earlier versions | ||||||
377 | of Perl, this function will return either the floating point | ||||||
378 | notation or the multiple dotted notation, depending on whether | ||||||
379 | the original version contained 1 or more dots, respectively. | ||||||
380 | |||||||
381 | The SV returned has a refcount of 1. | ||||||
382 | |||||||
383 | SV* vstringify(SV *vs)','name' => 'vstringify'},'sv_catsv_flags' => {'text' => 'Concatenates the string from SV C |
||||||
384 | C |
||||||
385 | If C |
||||||
386 | appropriate. If C |
||||||
387 | the modified SV afterward, if appropriate. C |
||||||
388 | and C |
||||||
389 | |||||||
390 | void sv_catsv_flags(SV *const dsv, SV *const ssv, | ||||||
391 | const I32 flags)','name' => 'sv_catsv_flags'},'str_to_version' => {'text' => '','name' => 'str_to_version'},'sv_derived_from' => {'text' => 'Exactly like L, but doesn\'t take a C |
||||||
392 | |||||||
393 | 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. | ||||||
394 | |||||||
395 | 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 | ||||||
396 | \'use bytes\' aware, handles get magic, and will coerce its args to strings | ||||||
397 | if necessary. See also C |
||||||
398 | |||||||
399 | I32 sv_cmp_locale(SV *const sv1, SV *const sv2)','name' => 'sv_cmp_locale'},'sv_catpvs' => {'text' => 'Like C |
||||||
400 | |||||||
401 | 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 | ||||||
402 | the C |
||||||
403 | |||||||
404 | dSP;','name' => 'dSP'},'Nullsv' => {'text' => 'Null SV pointer. (No longer available when C |
||||||
405 | case-insensitively; false otherwise. Uppercase and lowercase ASCII range bytes | ||||||
406 | match themselves and their opposite case counterparts. Non-cased and non-ASCII | ||||||
407 | range bytes match only themselves. | ||||||
408 | |||||||
409 | 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 | ||||||
410 | string. Prior to 5.9.3 it is not safe to execute this macro unless the SV\'s | ||||||
411 | type >= SVt_PV. | ||||||
412 | |||||||
413 | This is also used to store the name of an autoloaded subroutine in an XS | ||||||
414 | AUTOLOAD routine. See L |
||||||
415 | |||||||
416 | char* SvPVX(SV* sv)','name' => 'SvPVX'},'av_top_index' => {'text' => 'Returns the highest index in the array. The number of elements in the | ||||||
417 | array is C |
||||||
418 | |||||||
419 | The Perl equivalent for this is C<$#myarray>. | ||||||
420 | |||||||
421 | (A slightly shorter form is C |
||||||
422 | |||||||
423 | I32 av_top_index(AV *av)','name' => 'av_top_index'},'XPUSHi' => {'text' => 'Push an integer onto the stack, extending the stack if necessary. Handles | ||||||
424 | \'set\' magic. Uses C |
||||||
425 | declare it. Do not call multiple C |
||||||
426 | from XSUB\'s - see C |
||||||
427 | |||||||
428 | void XPUSHi(IV iv)','name' => 'XPUSHi'},'debop' => {'text' => '','name' => 'debop'},'ref' => {'text' => '','name' => 'ref'},'sv_does_sv' => {'text' => 'Returns a boolean indicating whether the SV performs a specific, named role. | ||||||
429 | The SV can be a Perl object or the name of a Perl class. | ||||||
430 | |||||||
431 | bool sv_does_sv(SV* sv, SV* namesv, U32 flags)','name' => 'sv_does_sv'},'SvOOK_offset' => {'text' => 'Reads into I |
||||||
432 | allocated buffer, which will be non-zero if C |
||||||
433 | efficiently remove characters from start of the buffer. Implemented as a | ||||||
434 | macro, which takes the address of I |
||||||
435 | Evaluates I |
||||||
436 | |||||||
437 | void SvOOK_offset(NN SV*sv, STRLEN len)','name' => 'SvOOK_offset'},'save_list' => {'text' => '','name' => 'save_list'},'SvTAINTED_on' => {'text' => 'Marks an SV as tainted if tainting is enabled. | ||||||
438 | |||||||
439 | void SvTAINTED_on(SV* sv)','name' => 'SvTAINTED_on'},'newGIVENOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C |
||||||
440 | I |
||||||
441 | variable, and I |
||||||
442 | are consumed by this function and become part of the constructed op tree. | ||||||
443 | I |
||||||
444 | be affected. If it is 0, the global $_ will be used. | ||||||
445 | |||||||
446 | OP * newGIVENOP(OP *cond, OP *block, | ||||||
447 | PADOFFSET defsv_off)','name' => 'newGIVENOP'},'sv_nolocking' => {'text' => 'Dummy routine which "locks" an SV when there is no locking module present. | ||||||
448 | Exists to avoid test for a NULL function pointer and because it could | ||||||
449 | potentially warn under some level of strict-ness. | ||||||
450 | |||||||
451 | "Superseded" by sv_nosharing(). | ||||||
452 | |||||||
453 | void sv_nolocking(SV *sv)','name' => 'sv_nolocking'},'parse_listexpr' => {'text' => 'Parse a Perl list expression. This may contain operators of precedence | ||||||
454 | down to the comma operator. The expression must be followed (and thus | ||||||
455 | terminated) either by a low-precedence logic operator such as C |
||||||
456 | something that would normally terminate an expression such as semicolon. | ||||||
457 | If I |
||||||
458 | otherwise it is mandatory. It is up to the caller to ensure that the | ||||||
459 | dynamic parser state (L et al) is correctly set to reflect | ||||||
460 | the source of the code to be parsed and the lexical context for the | ||||||
461 | expression. | ||||||
462 | |||||||
463 | The op tree representing the expression is returned. If an optional | ||||||
464 | expression is absent, a null pointer is returned, otherwise the pointer | ||||||
465 | will be non-null. | ||||||
466 | |||||||
467 | If an error occurs in parsing or compilation, in most cases a valid op | ||||||
468 | tree is returned anyway. The error is reflected in the parser state, | ||||||
469 | normally resulting in a single exception at the top level of parsing | ||||||
470 | which covers all the compilation errors that occurred. Some compilation | ||||||
471 | errors, however, will throw an exception immediately. | ||||||
472 | |||||||
473 | NOTE: this function is experimental and may change or be | ||||||
474 | removed without notice. | ||||||
475 | |||||||
476 | OP * parse_listexpr(U32 flags)','name' => 'parse_listexpr'},'ibcmp' => {'text' => 'This is a synonym for (! foldEQ()) | ||||||
477 | |||||||
478 | I32 ibcmp(const char* a, const char* b, I32 len)','name' => 'ibcmp'},'isWORDCHAR' => {'text' => 'Returns a boolean indicating whether the specified character is a character | ||||||
479 | that is a word character, analogous to what C |
||||||
480 | in a regular expression. A word character is an alphabetic character, a | ||||||
481 | decimal digit, a connecting punctuation character (such as an underscore), or | ||||||
482 | a "mark" character that attaches to one of those (like some sort of accent). | ||||||
483 | C |
||||||
484 | word character includes more than the standard C language meaning of | ||||||
485 | alphanumeric. | ||||||
486 | See the L |
||||||
487 | C |
||||||
488 | C |
||||||
489 | |||||||
490 | bool isWORDCHAR(char ch)','name' => 'isWORDCHAR'},'strLT' => {'text' => 'Test two strings to see if the first, C |
||||||
491 | C |
||||||
492 | |||||||
493 | bool strLT(char* s1, char* s2)','name' => 'strLT'},'save_pushptr' => {'text' => '','name' => 'save_pushptr'},'save_clearsv' => {'text' => '','name' => 'save_clearsv'},'av_shift' => {'text' => 'Shifts an SV off the beginning of the | ||||||
494 | array. Returns C<&PL_sv_undef> if the | ||||||
495 | array is empty. | ||||||
496 | |||||||
497 | Perl equivalent: C |
||||||
498 | |||||||
499 | 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. | ||||||
500 | |||||||
501 | unsigned char HvENAMEUTF8(HV *stash)','name' => 'HvENAMEUTF8'},'sv_nounlocking' => {'text' => 'Dummy routine which "unlocks" an SV when there is no locking module present. | ||||||
502 | Exists to avoid test for a NULL function pointer and because it could | ||||||
503 | potentially warn under some level of strict-ness. | ||||||
504 | |||||||
505 | "Superseded" by sv_nosharing(). | ||||||
506 | |||||||
507 | 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 | ||||||
508 | I |
||||||
509 | This hides the discarded text from any lexing code that runs later, | ||||||
510 | as if the text had never appeared. | ||||||
511 | |||||||
512 | This is not the normal way to consume lexed text. For that, use | ||||||
513 | L. | ||||||
514 | |||||||
515 | NOTE: this function is experimental and may change or be | ||||||
516 | removed without notice. | ||||||
517 | |||||||
518 | 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 |
||||||
519 | |||||||
520 | 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 |
||||||
521 | memory which is shared between threads. | ||||||
522 | |||||||
523 | char* savesharedsvpv(SV *sv)','name' => 'savesharedsvpv'},'CopyD' => {'text' => 'Like C |
||||||
524 | optimise. | ||||||
525 | |||||||
526 | void * CopyD(void* src, void* dest, int nitems, type)','name' => 'CopyD'},'sv_setiv_mg' => {'text' => 'Like C |
||||||
527 | |||||||
528 | 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. | ||||||
529 | |||||||
530 | bool sv_does_pvn(SV* sv, const char *const name, | ||||||
531 | const STRLEN len, U32 flags)','name' => 'sv_does_pvn'},'newFOROP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C |
||||||
532 | loop (iteration through a list of values). This is a heavyweight loop, | ||||||
533 | with structure that allows exiting the loop by C |
||||||
534 | |||||||
535 | I |
||||||
536 | item in turn; if null, it defaults to C<$_> (either lexical or global). | ||||||
537 | I |
||||||
538 | the main body of the loop, and I |
||||||
539 | block that operates as a second half of the body. All of these optree | ||||||
540 | inputs are consumed by this function and become part of the constructed | ||||||
541 | op tree. | ||||||
542 | |||||||
543 | I |
||||||
544 | op and, shifted up eight bits, the eight bits of C |
||||||
545 | the C |
||||||
546 | automatically. | ||||||
547 | |||||||
548 | OP * newFOROP(I32 flags, OP *sv, OP *expr, OP *block, | ||||||
549 | OP *cont)','name' => 'newFOROP'},'HvENAME' => {'text' => 'Returns the effective name of a stash, or NULL if there is none. The | ||||||
550 | effective name represents a location in the symbol table where this stash | ||||||
551 | resides. It is updated automatically when packages are aliased or deleted. | ||||||
552 | A stash that is no longer in the symbol table has no effective name. This | ||||||
553 | name is preferable to C |
||||||
554 | caches. | ||||||
555 | |||||||
556 | char* HvENAME(HV* stash)','name' => 'HvENAME'},'save_generic_svref' => {'text' => '','name' => 'save_generic_svref'},'savesharedpvn' => {'text' => 'A version of C |
||||||
557 | which is shared between threads. (With the specific difference that a NULL | ||||||
558 | pointer is not acceptable) | ||||||
559 | |||||||
560 | char* savesharedpvn(const char *const pv, | ||||||
561 | const STRLEN len)','name' => 'savesharedpvn'},'utf8_to_uvchr_buf' => {'text' => 'Returns the native code point of the first character in the string C |
||||||
562 | is assumed to be in UTF-8 encoding; C |
||||||
563 | C<*retlen> will be set to the length, in bytes, of that character. | ||||||
564 | |||||||
565 | If C |
||||||
566 | enabled, zero is returned and C<*retlen> is set (if C |
||||||
567 | NULL) to -1. If those warnings are off, the computed value, if well-defined | ||||||
568 | (or the Unicode REPLACEMENT CHARACTER if not), is silently returned, and | ||||||
569 | C<*retlen> is set (if C |
||||||
570 | the next possible position in C |
||||||
571 | See L for details on when the REPLACEMENT CHARACTER is | ||||||
572 | returned. | ||||||
573 | |||||||
574 | UV utf8_to_uvchr_buf(const U8 *s, const U8 *send, | ||||||
575 | STRLEN *retlen)','name' => 'utf8_to_uvchr_buf'},'SvCUR_set' => {'text' => 'Set the current length of the string which is in the SV. See C |
||||||
576 | and C |
||||||
577 | |||||||
578 | void SvCUR_set(SV* sv, STRLEN len)','name' => 'SvCUR_set'},'SVt_NULL' => {'text' => 'Type flag for scalars. See L.','name' => 'SVt_NULL'},'sv_2pv' => {'text' => '','name' => 'sv_2pv'},'SvNOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a double. | ||||||
579 | |||||||
580 | U32 SvNOK(SV* sv)','name' => 'SvNOK'},'mPUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. | ||||||
581 | Does not use C |
||||||
582 | |||||||
583 | void mPUSHn(NV nv)','name' => 'mPUSHn'},'pad_setsv' => {'text' => 'Set the value at offset I |
||||||
584 | Use the macro PAD_SETSV() rather than calling this function directly. | ||||||
585 | |||||||
586 | void pad_setsv(PADOFFSET po, SV *sv)','name' => 'pad_setsv'},'sv_reset' => {'text' => 'Underlying implementation for the C |
||||||
587 | Note that the perl-level function is vaguely deprecated. | ||||||
588 | |||||||
589 | 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 | ||||||
590 | a string/length pair. | ||||||
591 | |||||||
592 | NOTE: this function is experimental and may change or be | ||||||
593 | removed without notice. | ||||||
594 | |||||||
595 | COPHH * cophh_delete_pv(const COPHH *cophh, | ||||||
596 | const char *key, U32 hash, | ||||||
597 | 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. | ||||||
598 | If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a | ||||||
599 | string if necessary. Normally invoked via the C |
||||||
600 | C |
||||||
601 | |||||||
602 | char* sv_2pv_flags(SV *const sv, STRLEN *const lp, | ||||||
603 | 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. | ||||||
604 | Guarantees to evaluate C |
||||||
605 | this if C |
||||||
606 | otherwise use the more efficient C |
||||||
607 | |||||||
608 | NV SvNVx(SV* sv)','name' => 'SvNVx'},'setdefout' => {'text' => 'Sets PL_defoutgv, the default file handle for output, to the passed in | ||||||
609 | typeglob. As PL_defoutgv "owns" a reference on its typeglob, the reference | ||||||
610 | count of the passed in typeglob is increased by one, and the reference count | ||||||
611 | of the typeglob that PL_defoutgv points to is decreased by one. | ||||||
612 | |||||||
613 | 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 |
||||||
614 | absolute value of C |
||||||
615 | negative the key is assumed to be in UTF-8-encoded Unicode. The | ||||||
616 | C |
||||||
617 | Perl will compute it. | ||||||
618 | |||||||
619 | The return value will be | ||||||
620 | NULL if the operation failed or if the value did not need to be actually | ||||||
621 | stored within the hash (as in the case of tied hashes). Otherwise it can | ||||||
622 | be dereferenced to get the original C |
||||||
623 | responsible for suitably incrementing the reference count of C |
||||||
624 | the call, and decrementing it if the function returned NULL. Effectively | ||||||
625 | a successful hv_store takes ownership of one reference to C |
||||||
626 | usually what you want; a newly created SV has a reference count of one, so | ||||||
627 | if all your code does is create SVs then store them in a hash, hv_store | ||||||
628 | will own the only reference to the new SV, and your code doesn\'t need to do | ||||||
629 | anything further to tidy up. hv_store is not implemented as a call to | ||||||
630 | hv_store_ent, and does not create a temporary SV for the key, so if your | ||||||
631 | key data is not already in SV form then use hv_store in preference to | ||||||
632 | hv_store_ent. | ||||||
633 | |||||||
634 | See L |
||||||
635 | information on how to use this function on tied hashes. | ||||||
636 | |||||||
637 | SV** hv_store(HV *hv, const char *key, I32 klen, | ||||||
638 | 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 | ||||||
639 | string/length pair. | ||||||
640 | |||||||
641 | SV * cop_hints_fetch_sv(const COP *cop, SV *key, | ||||||
642 | 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 |
||||||
643 | based on a subroutine prototype or using default list-context processing. | ||||||
644 | This is the standard treatment used on a subroutine call, not marked | ||||||
645 | with C<&>, where the callee can be identified at compile time. | ||||||
646 | |||||||
647 | I |
||||||
648 | or indicates that there is no prototype. It may be a normal scalar, | ||||||
649 | in which case if it is defined then the string value will be used | ||||||
650 | as a prototype, and if it is undefined then there is no prototype. | ||||||
651 | Alternatively, for convenience, it may be a subroutine object (a C |
||||||
652 | that has been cast to C |
||||||
653 | has one. The prototype (or lack thereof) supplied, in whichever form, | ||||||
654 | does not need to match the actual callee referenced by the op tree. | ||||||
655 | |||||||
656 | If the argument ops disagree with the prototype, for example by having | ||||||
657 | an unacceptable number of arguments, a valid op tree is returned anyway. | ||||||
658 | The error is reflected in the parser state, normally resulting in a single | ||||||
659 | exception at the top level of parsing which covers all the compilation | ||||||
660 | errors that occurred. In the error message, the callee is referred to | ||||||
661 | by the name defined by the I |
||||||
662 | |||||||
663 | OP * ck_entersub_args_proto_or_list(OP *entersubop, | ||||||
664 | GV *namegv, | ||||||
665 | 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. | ||||||
666 | C |
||||||
667 | if you want the function to compute it. IF C |
||||||
668 | will be part of a store. Make sure the return value is non-null before | ||||||
669 | accessing it. The return value when C |
||||||
670 | static location, so be sure to make a copy of the structure if you need to | ||||||
671 | store it somewhere. | ||||||
672 | |||||||
673 | See L |
||||||
674 | information on how to use this function on tied hashes. | ||||||
675 | |||||||
676 | HE* hv_fetch_ent(HV *hv, SV *keysv, I32 lval, | ||||||
677 | U32 hash)','name' => 'hv_fetch_ent'},'gv_fetchpvn_flags' => {'text' => '','name' => 'gv_fetchpvn_flags'},'ENTER' => {'text' => 'Opening bracket on a callback. See C |
||||||
678 | |||||||
679 | ENTER;','name' => 'ENTER'},'PL_sv_no' => {'text' => 'This is the C |
||||||
680 | C<&PL_sv_no>. | ||||||
681 | |||||||
682 | SV PL_sv_no','name' => 'PL_sv_no'},'Newx' => {'text' => 'The XSUB-writer\'s interface to the C C |
||||||
683 | |||||||
684 | In 5.9.3, Newx() and friends replace the older New() API, and drops | ||||||
685 | the first parameter, I |
||||||
686 | themselves. This aid has been superseded by a new build option, | ||||||
687 | PERL_MEM_LOG (see L |
||||||
688 | there for use in XS modules supporting older perls. | ||||||
689 | |||||||
690 | 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. | ||||||
691 | Does not handle \'set\' magic. Does not use C |
||||||
692 | C |
||||||
693 | |||||||
694 | void PUSHs(SV* sv)','name' => 'PUSHs'},'sv_setuv' => {'text' => 'Copies an unsigned integer into the given SV, upgrading first if necessary. | ||||||
695 | Does not handle \'set\' magic. See also C |
||||||
696 | |||||||
697 | 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 |
||||||
698 | perform the upgrade if necessary. See C |
||||||
699 | |||||||
700 | void SvUPGRADE(SV* sv, svtype type)','name' => 'SvUPGRADE'},'cv_clone' => {'text' => 'Clone a CV, making a lexical closure. I |
||||||
701 | of the function: its code, pad structure, and other attributes. | ||||||
702 | The prototype is combined with a capture of outer lexicals to which the | ||||||
703 | code refers, which are taken from the currently-executing instance of | ||||||
704 | the immediately surrounding code. | ||||||
705 | |||||||
706 | CV * cv_clone(CV *proto)','name' => 'cv_clone'},'do_aspawn' => {'text' => '','name' => 'do_aspawn'},'sv_pvn' => {'text' => 'A private implementation of the C |
||||||
707 | cope with complex macro expressions. Always use the macro instead. | ||||||
708 | |||||||
709 | 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 | ||||||
710 | type. This is the preferred way to manipulate the L array. | ||||||
711 | I |
||||||
712 | is a pointer to the C function that is to be added to that opcode\'s | ||||||
713 | check chain, and I |
||||||
714 | pointer to the next function in the chain will be stored. The value of | ||||||
715 | I |
||||||
716 | previously stored there is written to I<*old_checker_p>. | ||||||
717 | |||||||
718 | L is global to an entire process, and a module wishing to | ||||||
719 | hook op checking may find itself invoked more than once per process, | ||||||
720 | typically in different threads. To handle that situation, this function | ||||||
721 | is idempotent. The location I<*old_checker_p> must initially (once | ||||||
722 | per process) contain a null pointer. A C variable of static duration | ||||||
723 | (declared at file scope, typically also marked C |
||||||
724 | it internal linkage) will be implicitly initialised appropriately, | ||||||
725 | if it does not have an explicit initialiser. This function will only | ||||||
726 | actually modify the check chain if it finds I<*old_checker_p> to be null. | ||||||
727 | This function is also thread safe on the small scale. It uses appropriate | ||||||
728 | locking to avoid race conditions in accessing L. | ||||||
729 | |||||||
730 | When this function is called, the function referenced by I |
||||||
731 | must be ready to be called, except for I<*old_checker_p> being unfilled. | ||||||
732 | In a threading situation, I |
||||||
733 | even before this function has returned. I<*old_checker_p> will always | ||||||
734 | be appropriately set before I |
||||||
735 | decides not to do anything special with an op that it is given (which | ||||||
736 | is the usual case for most uses of op check hooking), it must chain the | ||||||
737 | check function referenced by I<*old_checker_p>. | ||||||
738 | |||||||
739 | If you want to influence compilation of calls to a specific subroutine, | ||||||
740 | then use L rather than hooking checking of all | ||||||
741 | C |
||||||
742 | |||||||
743 | void wrap_op_checker(Optype opcode, | ||||||
744 | Perl_check_t new_checker, | ||||||
745 | 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 |
||||||
746 | argument will be upgraded to an RV. That RV will be modified to point to | ||||||
747 | the new SV. The C |
||||||
748 | blessing. Set C |
||||||
749 | will have a reference count of 1, and the RV will be returned. | ||||||
750 | |||||||
751 | SV* sv_setref_iv(SV *const rv, | ||||||
752 | const char *const classname, | ||||||
753 | const IV iv)','name' => 'sv_setref_iv'},'sv_chop' => {'text' => 'Efficient removal of characters from the beginning of the string buffer. | ||||||
754 | SvPOK(sv), or at least SvPOKp(sv), must be true and the C |
||||||
755 | pointer to somewhere inside the string buffer. The C |
||||||
756 | character of the adjusted string. Uses the "OOK hack". On return, only | ||||||
757 | SvPOK(sv) and SvPOKp(sv) among the OK flags will be true. | ||||||
758 | |||||||
759 | Beware: after this function returns, C |
||||||
760 | refer to the same chunk of data. | ||||||
761 | |||||||
762 | The unfortunate similarity of this function\'s name to that of Perl\'s C |
||||||
763 | operator is strictly coincidental. This function works from the left; | ||||||
764 | C |
||||||
765 | |||||||
766 | 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 |
||||||
767 | wrapper instead. | ||||||
768 | |||||||
769 | 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. | ||||||
770 | Handles \'set\' magic. Uses C |
||||||
771 | called to declare it. Do not call multiple C |
||||||
772 | return lists from XSUB\'s - see C |
||||||
773 | C |
||||||
774 | |||||||
775 | void XPUSHu(UV uv)','name' => 'XPUSHu'},'sv_pvn_nomg' => {'text' => '','name' => 'sv_pvn_nomg'},'GvHV' => {'text' => 'Return the HV from the GV. | ||||||
776 | |||||||
777 | HV* GvHV(GV* gv)','name' => 'GvHV'},'stack_grow' => {'text' => '','name' => 'stack_grow'},'dump_mstats' => {'text' => '','name' => 'dump_mstats'},'newLOOPEX' => {'text' => 'Constructs, checks, and returns a loop-exiting op (such as C |
||||||
778 | or C |
||||||
779 | determining the target of the op; it is consumed by this function and | ||||||
780 | becomes part of the constructed op tree. | ||||||
781 | |||||||
782 | 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 |
||||||
783 | doesn\'t care about the length of the string. It is usually more efficient | ||||||
784 | to either declare a local variable and use that instead or to use the | ||||||
785 | C |
||||||
786 | |||||||
787 | STRLEN PL_na','name' => 'PL_na'},'newSViv' => {'text' => 'Creates a new SV and copies an integer into it. The reference count for the | ||||||
788 | SV is set to 1. | ||||||
789 | |||||||
790 | SV* newSViv(const IV i)','name' => 'newSViv'},'gv_name_set' => {'text' => '','name' => 'gv_name_set'},'sv_untaint' => {'text' => 'Untaint an SV. Use C |
||||||
791 | |||||||
792 | void sv_untaint(SV *const sv)','name' => 'sv_untaint'},'Newxz' => {'text' => 'The XSUB-writer\'s interface to the C C |
||||||
793 | memory is zeroed with C |
||||||
794 | |||||||
795 | void Newxz(void* ptr, int nitems, type)','name' => 'Newxz'},'SVt_PVHV' => {'text' => 'Type flag for hashes. See L.','name' => 'SVt_PVHV'},'reentrant_init' => {'text' => '','name' => 'reentrant_init'},'save_pushptrptr' => {'text' => '','name' => 'save_pushptrptr'},'save_gp' => {'text' => '','name' => 'save_gp'},'parse_block' => {'text' => 'Parse a single complete Perl code block. This consists of an opening | ||||||
796 | brace, a sequence of statements, and a closing brace. The block | ||||||
797 | constitutes a lexical scope, so C |
||||||
798 | effects can be contained within it. It is up to the caller to ensure | ||||||
799 | that the dynamic parser state (L et al) is correctly set to | ||||||
800 | reflect the source of the code to be parsed and the lexical context for | ||||||
801 | the statement. | ||||||
802 | |||||||
803 | The op tree representing the code block is returned. This is always a | ||||||
804 | real op, never a null pointer. It will normally be a C |
||||||
805 | including C |
||||||
806 | of runtime scope are included by virtue of it being a block. | ||||||
807 | |||||||
808 | If an error occurs in parsing or compilation, in most cases a valid op | ||||||
809 | tree (most likely null) is returned anyway. The error is reflected in | ||||||
810 | the parser state, normally resulting in a single exception at the top | ||||||
811 | level of parsing which covers all the compilation errors that occurred. | ||||||
812 | Some compilation errors, however, will throw an exception immediately. | ||||||
813 | |||||||
814 | The I |
||||||
815 | be zero. | ||||||
816 | |||||||
817 | NOTE: this function is experimental and may change or be | ||||||
818 | removed without notice. | ||||||
819 | |||||||
820 | OP * parse_block(U32 flags)','name' => 'parse_block'},'SvRX' => {'text' => 'Convenience macro to get the REGEXP from a SV. This is approximately | ||||||
821 | equivalent to the following snippet: | ||||||
822 | |||||||
823 | if (SvMAGICAL(sv)) | ||||||
824 | mg_get(sv); | ||||||
825 | if (SvROK(sv)) | ||||||
826 | sv = MUTABLE_SV(SvRV(sv)); | ||||||
827 | if (SvTYPE(sv) == SVt_REGEXP) | ||||||
828 | return (REGEXP*) sv; | ||||||
829 | |||||||
830 | NULL will be returned if a REGEXP* is not found. | ||||||
831 | |||||||
832 | REGEXP * SvRX(SV *sv)','name' => 'SvRX'},'newASSIGNOP' => {'text' => 'Constructs, checks, and returns an assignment op. I |
||||||
833 | supply the parameters of the assignment; they are consumed by this | ||||||
834 | function and become part of the constructed op tree. | ||||||
835 | |||||||
836 | If I |
||||||
837 | a suitable conditional optree is constructed. If I |
||||||
838 | of a binary operator, such as C |
||||||
839 | performs the binary operation and assigns the result to the left argument. | ||||||
840 | Either way, if I |
||||||
841 | |||||||
842 | If I |
||||||
843 | constructed. Which type of assignment it is is automatically determined. | ||||||
844 | I |
||||||
845 | will be set automatically, and, shifted up eight bits, the eight bits | ||||||
846 | of C |
||||||
847 | set as required. | ||||||
848 | |||||||
849 | OP * newASSIGNOP(I32 flags, OP *left, I32 optype, | ||||||
850 | OP *right)','name' => 'newASSIGNOP'},'SvSetMagicSV_nosteal' => {'text' => 'Like C |
||||||
851 | |||||||
852 | void SvSetMagicSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetMagicSV_nosteal'},'hv_undef' => {'text' => 'Undefines the hash. The XS equivalent of C |
||||||
853 | |||||||
854 | As well as freeing all the elements of the hash (like hv_clear()), this | ||||||
855 | also frees any auxiliary data and storage associated with the hash. | ||||||
856 | |||||||
857 | If any destructors are triggered as a result, the hv itself may | ||||||
858 | be freed. | ||||||
859 | |||||||
860 | See also L. | ||||||
861 | |||||||
862 | 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 | ||||||
863 | object. If the SV is not an RV, or if the object is not blessed, then this | ||||||
864 | will return false. | ||||||
865 | |||||||
866 | int sv_isobject(SV* sv)','name' => 'sv_isobject'},'cop_hints_fetch_pvn' => {'text' => 'Look up the hint entry in the cop I |
||||||
867 | I |
||||||
868 | the key octets are interpreted as UTF-8, otherwise they are interpreted | ||||||
869 | as Latin-1. I |
||||||
870 | it has not been precomputed. Returns a mortal scalar copy of the value | ||||||
871 | associated with the key, or C<&PL_sv_placeholder> if there is no value | ||||||
872 | associated with the key. | ||||||
873 | |||||||
874 | SV * cop_hints_fetch_pvn(const COP *cop, | ||||||
875 | const char *keypv, | ||||||
876 | STRLEN keylen, U32 hash, | ||||||
877 | 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 |
||||||
878 | version which guarantees to evaluate sv only once. | ||||||
879 | |||||||
880 | IV SvIV(SV* sv)','name' => 'SvIV'},'isASCII' => {'text' => 'Returns a boolean indicating whether the specified character is one of the 128 | ||||||
881 | characters in the ASCII character set, analogous to C |
||||||
882 | On non-ASCII platforms, it returns TRUE iff this | ||||||
883 | character corresponds to an ASCII character. Variants C |
||||||
884 | C |
||||||
885 | See the L |
||||||
886 | C |
||||||
887 | C |
||||||
888 | library routine C |
||||||
889 | C |
||||||
890 | |||||||
891 | 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 | ||||||
892 | hint entries in the cop I |
||||||
893 | be zero. | ||||||
894 | |||||||
895 | 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 | ||||||
896 | flags contain SV_GMAGIC, it handles get-magic. | ||||||
897 | |||||||
898 | Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the | ||||||
899 | scalar data of the variable, but transformed to such a format that a normal | ||||||
900 | memory comparison can be used to compare the data according to the locale | ||||||
901 | settings. | ||||||
902 | |||||||
903 | char* sv_collxfrm_flags(SV *const sv, | ||||||
904 | STRLEN *const nxp, | ||||||
905 | I32 const flags)','name' => 'sv_collxfrm_flags'},'sv_copypv_flags' => {'text' => 'Implementation of sv_copypv and sv_copypv_nomg. Calls get magic iff flags | ||||||
906 | include SV_GMAGIC. | ||||||
907 | |||||||
908 | void sv_copypv_flags(SV *const dsv, SV *const ssv, | ||||||
909 | const I32 flags)','name' => 'sv_copypv_flags'},'sv_setref_uv' => {'text' => 'Copies an unsigned integer into a new SV, optionally blessing the SV. The C |
||||||
910 | argument will be upgraded to an RV. That RV will be modified to point to | ||||||
911 | the new SV. The C |
||||||
912 | blessing. Set C |
||||||
913 | will have a reference count of 1, and the RV will be returned. | ||||||
914 | |||||||
915 | SV* sv_setref_uv(SV *const rv, | ||||||
916 | const char *const classname, | ||||||
917 | 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 |
||||||
918 | based on a subroutine prototype. This makes various modifications to | ||||||
919 | the argument ops, from applying context up to inserting C |
||||||
920 | and checking the number and syntactic types of arguments, as directed by | ||||||
921 | the prototype. This is the standard treatment used on a subroutine call, | ||||||
922 | not marked with C<&>, where the callee can be identified at compile time | ||||||
923 | and has a prototype. | ||||||
924 | |||||||
925 | I |
||||||
926 | It may be a normal defined scalar, of which the string value will be used. | ||||||
927 | Alternatively, for convenience, it may be a subroutine object (a C |
||||||
928 | that has been cast to C |
||||||
929 | supplied, in whichever form, does not need to match the actual callee | ||||||
930 | referenced by the op tree. | ||||||
931 | |||||||
932 | If the argument ops disagree with the prototype, for example by having | ||||||
933 | an unacceptable number of arguments, a valid op tree is returned anyway. | ||||||
934 | The error is reflected in the parser state, normally resulting in a single | ||||||
935 | exception at the top level of parsing which covers all the compilation | ||||||
936 | errors that occurred. In the error message, the callee is referred to | ||||||
937 | by the name defined by the I |
||||||
938 | |||||||
939 | OP * ck_entersub_args_proto(OP *entersubop, | ||||||
940 | GV *namegv, SV *protosv)','name' => 'ck_entersub_args_proto'},'getcwd_sv' => {'text' => 'Fill the sv with current working directory | ||||||
941 | |||||||
942 | int getcwd_sv(SV* sv)','name' => 'getcwd_sv'},'newSVpvs_share' => {'text' => 'Like C |
||||||
943 | pair and omits the hash parameter. | ||||||
944 | |||||||
945 | 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 | ||||||
946 | SV is set to 1. If C |
||||||
947 | strlen(). For efficiency, consider using C |
||||||
948 | |||||||
949 | 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 | ||||||
950 | to its length. May cause the SV to be downgraded from UTF-8 as a | ||||||
951 | side-effect. | ||||||
952 | |||||||
953 | Usually accessed via the C |
||||||
954 | |||||||
955 | char* sv_2pvbyte(SV *sv, STRLEN *const lp)','name' => 'sv_2pvbyte'},'fbm_instr' => {'text' => 'Returns the location of the SV in the string delimited by C and | ||||||
956 | C |
||||||
957 | does not have to be fbm_compiled, but the search will not be as fast | ||||||
958 | then. | ||||||
959 | |||||||
960 | char* fbm_instr(unsigned char* big, | ||||||
961 | unsigned char* bigend, SV* littlestr, | ||||||
962 | U32 flags)','name' => 'fbm_instr'},'XPUSHn' => {'text' => 'Push a double onto the stack, extending the stack if necessary. Handles | ||||||
963 | \'set\' magic. Uses C |
||||||
964 | declare it. Do not call multiple C |
||||||
965 | from XSUB\'s - see C |
||||||
966 | |||||||
967 | void XPUSHn(NV nv)','name' => 'XPUSHn'},'PL_opfreehook' => {'text' => 'When non-C |
||||||
968 | This allows extensions to free any extra attribute they have locally attached to an OP. | ||||||
969 | It is also assured to first fire for the parent OP and then for its kids. | ||||||
970 | |||||||
971 | 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. | ||||||
972 | |||||||
973 | Perl_ophook_t PL_opfreehook','name' => 'PL_opfreehook'},'PadlistARRAY' => {'text' => 'The C array of a padlist, containing the pads. Only subscript it with | ||||||
974 | numbers >= 1, as the 0th entry is not guaranteed to remain usable. | ||||||
975 | |||||||
976 | NOTE: this function is experimental and may change or be | ||||||
977 | removed without notice. | ||||||
978 | |||||||
979 | PAD ** PadlistARRAY(PADLIST padlist)','name' => 'PadlistARRAY'},'dump_all' => {'text' => '','name' => 'dump_all'},'ninstr' => {'text' => '','name' => 'ninstr'},'sv_vcatpvf' => {'text' => 'Processes its arguments like C |
||||||
980 | to an SV. Does not handle \'set\' magic. See C |
||||||
981 | |||||||
982 | Usually used via its frontend C |
||||||
983 | |||||||
984 | void sv_vcatpvf(SV *const sv, const char *const pat, | ||||||
985 | 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 | ||||||
986 | the start of the string, to a count of the equivalent number of bytes; if | ||||||
987 | lenp is non-zero, it does the same to lenp, but this time starting from | ||||||
988 | the offset, rather than from the start of the string. Handles magic and | ||||||
989 | type coercion. | ||||||
990 | |||||||
991 | Use C |
||||||
992 | than 2Gb. | ||||||
993 | |||||||
994 | void sv_pos_u2b(SV *const sv, I32 *const offsetp, | ||||||
995 | 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. | ||||||
996 | |||||||
997 | See also C |
||||||
998 | |||||||
999 | SV * boolSV(bool b)','name' => 'boolSV'},'upg_version' => {'text' => 'In-place upgrade of the supplied SV to a version object. | ||||||
1000 | |||||||
1001 | SV *sv = upg_version(SV *sv, bool qv); | ||||||
1002 | |||||||
1003 | Returns a pointer to the upgraded SV. Set the boolean qv if you want | ||||||
1004 | to force this SV to be interpreted as an "extended" version. | ||||||
1005 | |||||||
1006 | 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 | ||||||
1007 | run Perl interpreters. This should be called only once, before creating | ||||||
1008 | any Perl interpreters. | ||||||
1009 | |||||||
1010 | void PERL_SYS_INIT3(int *argc, char*** argv, | ||||||
1011 | char*** env)','name' => 'PERL_SYS_INIT3'},'HeSVKEY_set' => {'text' => 'Sets the key to a given C |
||||||
1012 | indicate the presence of an C |
||||||
1013 | C |
||||||
1014 | |||||||
1015 | SV* HeSVKEY_set(HE* he, SV* sv)','name' => 'HeSVKEY_set'},'sv_derived_from_sv' => {'text' => 'Exactly like L, but takes the name string in the form | ||||||
1016 | of an SV instead of a string/length pair. | ||||||
1017 | |||||||
1018 | bool sv_derived_from_sv(SV* sv, SV *namesv, | ||||||
1019 | U32 flags)','name' => 'sv_derived_from_sv'},'SPAGAIN' => {'text' => 'Refetch the stack pointer. Used after a callback. See L |
||||||
1020 | |||||||
1021 | 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 | ||||||
1022 | char * and length parameters. C |
||||||
1023 | |||||||
1024 | void gv_init_sv(GV* gv, HV* stash, SV* namesv, | ||||||
1025 | U32 flags)','name' => 'gv_init_sv'},'my_bcopy' => {'text' => '','name' => 'my_bcopy'},'PL_parser-E |
||||||
1026 | Characters around this point may be freely examined, within | ||||||
1027 | the range delimited by C |
||||||
1028 | Lbufend>. The octets of the buffer may be intended to be | ||||||
1029 | interpreted as either UTF-8 or Latin-1, as indicated by L. | ||||||
1030 | |||||||
1031 | Lexing code (whether in the Perl core or not) moves this pointer past | ||||||
1032 | the characters that it consumes. It is also expected to perform some | ||||||
1033 | bookkeeping whenever a newline character is consumed. This movement | ||||||
1034 | can be more conveniently performed by the function L, | ||||||
1035 | which handles newlines appropriately. | ||||||
1036 | |||||||
1037 | Interpretation of the buffer\'s octets can be abstracted out by | ||||||
1038 | using the slightly higher-level functions L and | ||||||
1039 | L. | ||||||
1040 | |||||||
1041 | NOTE: this function is experimental and may change or be | ||||||
1042 | removed without notice.','name' => 'PL_parser-E |
||||||
1043 | L |
||||||
1044 | a context in which to lex and parse from a new source of Perl code. | ||||||
1045 | A pointer to the new state object is placed in L. An entry | ||||||
1046 | is made on the save stack so that upon unwinding the new state object | ||||||
1047 | will be destroyed and the former value of L will be restored. | ||||||
1048 | Nothing else need be done to clean up the parsing context. | ||||||
1049 | |||||||
1050 | The code to be parsed comes from I |
||||||
1051 | non-null, provides a string (in SV form) containing code to be parsed. | ||||||
1052 | A copy of the string is made, so subsequent modification of I |
||||||
1053 | does not affect parsing. I |
||||||
1054 | from which code will be read to be parsed. If both are non-null, the | ||||||
1055 | code in I |
||||||
1056 | and I |
||||||
1057 | |||||||
1058 | The I |
||||||
1059 | used by perl internally, so extensions should always pass zero. | ||||||
1060 | |||||||
1061 | NOTE: this function is experimental and may change or be | ||||||
1062 | removed without notice. | ||||||
1063 | |||||||
1064 | void lex_start(SV *line, PerlIO *rsfp, U32 flags)','name' => 'lex_start'},'hv_riter_set' => {'text' => '','name' => 'hv_riter_set'},'gv_autoload_pvn' => {'text' => '','name' => 'gv_autoload_pvn'},'gv_autoload_pv' => {'text' => '','name' => 'gv_autoload_pv'},'dounwind' => {'text' => '','name' => 'dounwind'},'ptr_table_clear' => {'text' => '','name' => 'ptr_table_clear'},'uvchr_to_utf8_flags' => {'text' => '','name' => 'uvchr_to_utf8_flags'},'save_hash' => {'text' => '','name' => 'save_hash'},'sv_isa' => {'text' => 'Returns a boolean indicating whether the SV is blessed into the specified | ||||||
1065 | class. This does not check for subtypes; use C |
||||||
1066 | an inheritance relationship. | ||||||
1067 | |||||||
1068 | int sv_isa(SV* sv, const char *const name)','name' => 'sv_isa'},'cophh_free' => {'text' => 'Discard the cop hints hash I |
||||||
1069 | with it. | ||||||
1070 | |||||||
1071 | NOTE: this function is experimental and may change or be | ||||||
1072 | removed without notice. | ||||||
1073 | |||||||
1074 | void cophh_free(COPHH *cophh)','name' => 'cophh_free'},'isXDIGIT' => {'text' => 'Returns a boolean indicating whether the specified character is a hexadecimal | ||||||
1075 | digit. In the ASCII range these are C<[0-9A-Fa-f]>. Variants C |
||||||
1076 | and C |
||||||
1077 | See the L |
||||||
1078 | C |
||||||
1079 | C |
||||||
1080 | |||||||
1081 | bool isXDIGIT(char ch)','name' => 'isXDIGIT'},'sv_catpvf' => {'text' => 'Processes its arguments like C |
||||||
1082 | output to an SV. If the appended data contains "wide" characters | ||||||
1083 | (including, but not limited to, SVs with a UTF-8 PV formatted with %s, | ||||||
1084 | and characters >255 formatted with %c), the original SV might get | ||||||
1085 | upgraded to UTF-8. Handles \'get\' magic, but not \'set\' magic. See | ||||||
1086 | C |
||||||
1087 | valid UTF-8; if the original SV was bytes, the pattern should be too. | ||||||
1088 | |||||||
1089 | void sv_catpvf(SV *const sv, const char *const pat, | ||||||
1090 | ...)','name' => 'sv_catpvf'},'cop_fetch_label' => {'text' => 'Returns the label attached to a cop. | ||||||
1091 | The flags pointer may be set to C |
||||||
1092 | |||||||
1093 | NOTE: this function is experimental and may change or be | ||||||
1094 | removed without notice. | ||||||
1095 | |||||||
1096 | const char * cop_fetch_label(COP *const cop, | ||||||
1097 | STRLEN *len, U32 *flags)','name' => 'cop_fetch_label'},'XSRETURN_PV' => {'text' => 'Return a copy of a string from an XSUB immediately. Uses C |
||||||
1098 | |||||||
1099 | void XSRETURN_PV(char* str)','name' => 'XSRETURN_PV'},'utf8_to_uvuni' => {'text' => 'DEPRECATED! | ||||||
1100 | |||||||
1101 | Returns the Unicode code point of the first character in the string C |
||||||
1102 | which is assumed to be in UTF-8 encoding; C |
||||||
1103 | length, in bytes, of that character. | ||||||
1104 | |||||||
1105 | This function should only be used when the returned UV is considered | ||||||
1106 | an index into the Unicode semantic tables (e.g. swashes). | ||||||
1107 | |||||||
1108 | Some, but not all, UTF-8 malformations are detected, and in fact, some | ||||||
1109 | malformed input could cause reading beyond the end of the input buffer, which | ||||||
1110 | is why this function is deprecated. Use L instead. | ||||||
1111 | |||||||
1112 | If C |
||||||
1113 | enabled, zero is returned and C<*retlen> is set (if C |
||||||
1114 | NULL) to -1. If those warnings are off, the computed value if well-defined (or | ||||||
1115 | the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen> | ||||||
1116 | is set (if C |
||||||
1117 | next possible position in C |
||||||
1118 | See L for details on when the REPLACEMENT CHARACTER is returned. | ||||||
1119 | |||||||
1120 | UV utf8_to_uvuni(const U8 *s, STRLEN *retlen)','name' => 'utf8_to_uvuni'},'pad_alloc' => {'text' => 'Allocates a place in the currently-compiling pad, | ||||||
1121 | returning the offset of the allocated pad slot. | ||||||
1122 | No name is initially attached to the pad slot. | ||||||
1123 | I |
||||||
1124 | which will be set in the value SV for the allocated pad entry: | ||||||
1125 | |||||||
1126 | SVs_PADMY named lexical variable ("my", "our", "state") | ||||||
1127 | SVs_PADTMP unnamed temporary store | ||||||
1128 | |||||||
1129 | I |
||||||
1130 | pad entry is to support. This doesn\'t affect operational semantics, | ||||||
1131 | but is used for debugging. | ||||||
1132 | |||||||
1133 | NOTE: this function is experimental and may change or be | ||||||
1134 | removed without notice. | ||||||
1135 | |||||||
1136 | 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 | ||||||
1137 | Perl\'s C<$#array = $fill;>. | ||||||
1138 | |||||||
1139 | The number of elements in the an array will be C |
||||||
1140 | av_fill() returns. If the array was previously shorter, then the | ||||||
1141 | additional elements appended are set to C |
||||||
1142 | was longer, then the excess elements are freed. C |
||||||
1143 | the same as C |
||||||
1144 | |||||||
1145 | void av_fill(AV *av, I32 fill)','name' => 'av_fill'},'croak_sv' => {'text' => 'This is an XS interface to Perl\'s C |
||||||
1146 | |||||||
1147 | C |
||||||
1148 | will be used as-is. Otherwise it is used as a string, and if it does | ||||||
1149 | not end with a newline then it will be extended with some indication of | ||||||
1150 | the current location in the code, as described for L. | ||||||
1151 | |||||||
1152 | The error message or object will be used as an exception, by default | ||||||
1153 | returning control to the nearest enclosing C |
||||||
1154 | modification by a C<$SIG{__DIE__}> handler. In any case, the C |
||||||
1155 | function never returns normally. | ||||||
1156 | |||||||
1157 | To die with a simple string message, the L function may be | ||||||
1158 | more convenient. | ||||||
1159 | |||||||
1160 | 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. | ||||||
1161 | |||||||
1162 | void SvIOK_only(SV* sv)','name' => 'SvIOK_only'},'MoveD' => {'text' => 'Like C |
||||||
1163 | optimise. | ||||||
1164 | |||||||
1165 | 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. | ||||||
1166 | |||||||
1167 | On entry I |
||||||
1168 | conversion flags, and I |
||||||
1169 | The scan stops at the end of the string, or the first invalid character. | ||||||
1170 | Unless C |
||||||
1171 | invalid character will also trigger a warning. | ||||||
1172 | On return I<*len> is set to the length of the scanned string, | ||||||
1173 | and I<*flags> gives output flags. | ||||||
1174 | |||||||
1175 | If the value is <= C |
||||||
1176 | and nothing is written to I<*result>. If the value is > UV_MAX C |
||||||
1177 | returns UV_MAX, sets C |
||||||
1178 | and writes the value to I<*result> (or the value is discarded if I |
||||||
1179 | is NULL). | ||||||
1180 | |||||||
1181 | The binary number may optionally be prefixed with "0b" or "b" unless | ||||||
1182 | C |
||||||
1183 | C |
||||||
1184 | number may use \'_\' characters to separate digits. | ||||||
1185 | |||||||
1186 | UV grok_bin(const char* start, STRLEN* len_p, | ||||||
1187 | I32* flags, NV *result)','name' => 'grok_bin'},'parse_barestmt' => {'text' => 'Parse a single unadorned Perl statement. This may be a normal imperative | ||||||
1188 | statement or a declaration that has compile-time effect. It does not | ||||||
1189 | include any label or other affixture. It is up to the caller to ensure | ||||||
1190 | that the dynamic parser state (L et al) is correctly set to | ||||||
1191 | reflect the source of the code to be parsed and the lexical context for | ||||||
1192 | the statement. | ||||||
1193 | |||||||
1194 | The op tree representing the statement is returned. This may be a | ||||||
1195 | null pointer if the statement is null, for example if it was actually | ||||||
1196 | a subroutine definition (which has compile-time side effects). If not | ||||||
1197 | null, it will be ops directly implementing the statement, suitable to | ||||||
1198 | pass to L. It will not normally include a C |
||||||
1199 | equivalent op (except for those embedded in a scope contained entirely | ||||||
1200 | within the statement). | ||||||
1201 | |||||||
1202 | If an error occurs in parsing or compilation, in most cases a valid op | ||||||
1203 | tree (most likely null) is returned anyway. The error is reflected in | ||||||
1204 | the parser state, normally resulting in a single exception at the top | ||||||
1205 | level of parsing which covers all the compilation errors that occurred. | ||||||
1206 | Some compilation errors, however, will throw an exception immediately. | ||||||
1207 | |||||||
1208 | The I |
||||||
1209 | be zero. | ||||||
1210 | |||||||
1211 | NOTE: this function is experimental and may change or be | ||||||
1212 | removed without notice. | ||||||
1213 | |||||||
1214 | OP * parse_barestmt(U32 flags)','name' => 'parse_barestmt'},'cast_uv' => {'text' => '','name' => 'cast_uv'},'perl_free' => {'text' => 'Releases a Perl interpreter. See L |
||||||
1215 | |||||||
1216 | void perl_free(PerlInterpreter *my_perl)','name' => 'perl_free'},'mg_find' => {'text' => 'Finds the magic pointer for type matching the SV. See C |
||||||
1217 | |||||||
1218 | MAGIC* mg_find(const SV* sv, int type)','name' => 'mg_find'},'safesysfree' => {'text' => '','name' => 'safesysfree'},'PL_parser-E |
||||||
1219 | text currently being lexed. This is always a plain string scalar (for | ||||||
1220 | which C |
||||||
1221 | normal scalar means; instead refer to the buffer directly by the pointer | ||||||
1222 | variables described below. | ||||||
1223 | |||||||
1224 | The lexer maintains various C |
||||||
1225 | C |
||||||
1226 | reallocated, all of these pointers must be updated. Don\'t attempt to | ||||||
1227 | do this manually, but rather use L if you need to | ||||||
1228 | reallocate the buffer. | ||||||
1229 | |||||||
1230 | The content of the text chunk in the buffer is commonly exactly one | ||||||
1231 | complete line of input, up to and including a newline terminator, | ||||||
1232 | but there are situations where it is otherwise. The octets of the | ||||||
1233 | buffer may be intended to be interpreted as either UTF-8 or Latin-1. | ||||||
1234 | The function L tells you which. Do not use the C |
||||||
1235 | flag on this scalar, which may disagree with it. | ||||||
1236 | |||||||
1237 | For direct examination of the buffer, the variable | ||||||
1238 | Lbufend> points to the end of the buffer. The current | ||||||
1239 | lexing position is pointed to by Lbufptr>. Direct use | ||||||
1240 | of these pointers is usually preferable to examination of the scalar | ||||||
1241 | through normal scalar means. | ||||||
1242 | |||||||
1243 | NOTE: this function is experimental and may change or be | ||||||
1244 | removed without notice.','name' => 'PL_parser-E |
||||||
1245 | valid. I |
||||||
1246 | The type of I |
||||||
1247 | |||||||
1248 | NOTE: this function is experimental and may change or be | ||||||
1249 | removed without notice. | ||||||
1250 | |||||||
1251 | void BhkENTRY_set(BHK *hk, which, void *ptr)','name' => 'BhkENTRY_set'},'hv_riter_p' => {'text' => '','name' => 'hv_riter_p'},'newSVpvn_share' => {'text' => 'Creates a new SV with its SvPVX_const pointing to a shared string in the string | ||||||
1252 | table. If the string does not already exist in the table, it is | ||||||
1253 | created first. Turns on the SvIsCOW flag (or READONLY | ||||||
1254 | and FAKE in 5.16 and earlier). If the C |
||||||
1255 | is non-zero, that value is used; otherwise the hash is computed. | ||||||
1256 | The string\'s hash can later be retrieved from the SV | ||||||
1257 | with the C |
||||||
1258 | that as the string table is used for shared hash keys these strings will have | ||||||
1259 | SvPVX_const == HeKEY and hash lookup will avoid string compare. | ||||||
1260 | |||||||
1261 | 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. | ||||||
1262 | Checks the B |
||||||
1263 | |||||||
1264 | 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 | ||||||
1265 | C |
||||||
1266 | status set, then the bytes appended should be valid UTF-8. | ||||||
1267 | Handles \'get\' magic, but not \'set\' magic. See C |
||||||
1268 | |||||||
1269 | 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 | ||||||
1270 | at compile time. See L |
||||||
1271 | |||||||
1272 | NOTE: this function is experimental and may change or be | ||||||
1273 | removed without notice. | ||||||
1274 | |||||||
1275 | NOTE: this function must be explicitly called as Perl_blockhook_register with an aTHX_ parameter. | ||||||
1276 | |||||||
1277 | 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 | ||||||
1278 | of the currently-executing function. This may be a lexical C<$_>, | ||||||
1279 | or will otherwise be the global one. | ||||||
1280 | |||||||
1281 | SV * find_rundefsv()','name' => 'find_rundefsv'},'sv_utf8_downgrade' => {'text' => 'Attempts to convert the PV of an SV from characters to bytes. | ||||||
1282 | If the PV contains a character that cannot fit | ||||||
1283 | in a byte, this conversion will fail; | ||||||
1284 | in this case, either returns false or, if C |
||||||
1285 | true, croaks. | ||||||
1286 | |||||||
1287 | This is not a general purpose Unicode to byte encoding interface: | ||||||
1288 | use the Encode extension for that. | ||||||
1289 | |||||||
1290 | NOTE: this function is experimental and may change or be | ||||||
1291 | removed without notice. | ||||||
1292 | |||||||
1293 | bool sv_utf8_downgrade(SV *const sv, | ||||||
1294 | const bool fail_ok)','name' => 'sv_utf8_downgrade'},'utf8_hop' => {'text' => 'Return the UTF-8 pointer C |
||||||
1295 | forward or backward. | ||||||
1296 | |||||||
1297 | WARNING: do not use the following unless you *know* C |
||||||
1298 | the UTF-8 data pointed to by C |
||||||
1299 | on the first byte of character or just after the last byte of a character. | ||||||
1300 | |||||||
1301 | 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 | ||||||
1302 | string must be specified with C |
||||||
1303 | an RV. That RV will be modified to point to the new SV. The C |
||||||
1304 | argument indicates the package for the blessing. Set C |
||||||
1305 | C |
||||||
1306 | of 1, and the RV will be returned. | ||||||
1307 | |||||||
1308 | Note that C |
||||||
1309 | |||||||
1310 | SV* sv_setref_pvn(SV *const rv, | ||||||
1311 | const char *const classname, | ||||||
1312 | const char *const pv, | ||||||
1313 | const STRLEN n)','name' => 'sv_setref_pvn'},'SVt_PVMG' => {'text' => 'Type flag for scalars. See L.','name' => 'SVt_PVMG'},'gv_fetchsv' => {'text' => '','name' => 'gv_fetchsv'},'PUSHp' => {'text' => 'Push a string onto the stack. The stack must have room for this element. | ||||||
1314 | The C |
||||||
1315 | C |
||||||
1316 | call multiple C |
||||||
1317 | C |
||||||
1318 | |||||||
1319 | 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. | ||||||
1320 | Does not use C |
||||||
1321 | |||||||
1322 | void mXPUSHi(IV iv)','name' => 'mXPUSHi'},'PL_sv_undef' => {'text' => 'This is the C |
||||||
1323 | |||||||
1324 | SV PL_sv_undef','name' => 'PL_sv_undef'},'hv_iterkeysv' => {'text' => 'Returns the key as an C |
||||||
1325 | iterator. The return value will always be a mortal copy of the key. Also | ||||||
1326 | see C |
||||||
1327 | |||||||
1328 | 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. | ||||||
1329 | If the SV has the UTF-8 status set, then the bytes appended should | ||||||
1330 | be valid UTF-8. If C |
||||||
1331 | on the modified SV if appropriate. | ||||||
1332 | |||||||
1333 | void sv_catpv_flags(SV *dstr, const char *sstr, | ||||||
1334 | const I32 flags)','name' => 'sv_catpv_flags'},'mPUSHp' => {'text' => 'Push a string onto the stack. The stack must have room for this element. | ||||||
1335 | The C |
||||||
1336 | See also C |
||||||
1337 | |||||||
1338 | void mPUSHp(char* str, STRLEN len)','name' => 'mPUSHp'},'lex_stuff_pv' => {'text' => 'Insert characters into the lexer buffer (Llinestr>), | ||||||
1339 | immediately after the current lexing point (Lbufptr>), | ||||||
1340 | reallocating the buffer if necessary. This means that lexing code that | ||||||
1341 | runs later will see the characters as if they had appeared in the input. | ||||||
1342 | It is not recommended to do this as part of normal parsing, and most | ||||||
1343 | uses of this facility run the risk of the inserted characters being | ||||||
1344 | interpreted in an unintended manner. | ||||||
1345 | |||||||
1346 | The string to be inserted is represented by octets starting at I |
||||||
1347 | and continuing to the first nul. These octets are interpreted as either | ||||||
1348 | UTF-8 or Latin-1, according to whether the C |
||||||
1349 | in I |
||||||
1350 | to how the buffer is currently being interpreted (L). | ||||||
1351 | If it is not convenient to nul-terminate a string to be inserted, the | ||||||
1352 | L function is more appropriate. | ||||||
1353 | |||||||
1354 | NOTE: this function is experimental and may change or be | ||||||
1355 | removed without notice. | ||||||
1356 | |||||||
1357 | void lex_stuff_pv(const char *pv, U32 flags)','name' => 'lex_stuff_pv'},'av_delete' => {'text' => 'Deletes the element indexed by C |
||||||
1358 | and returns it. If C |
||||||
1359 | is returned. Perl equivalent: C |
||||||
1360 | non-C |
||||||
1361 | C |
||||||
1362 | |||||||
1363 | 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 | ||||||
1364 | and C. | ||||||
1365 | |||||||
1366 | WARNING: use only if you *know* that the pointers point inside the | ||||||
1367 | same UTF-8 buffer. | ||||||
1368 | |||||||
1369 | IV utf8_distance(const U8 *a, const U8 *b)','name' => 'utf8_distance'},'SvPV_nomg' => {'text' => 'Like C |
||||||
1370 | |||||||
1371 | char* SvPV_nomg(SV* sv, STRLEN len)','name' => 'SvPV_nomg'},'parser_dup' => {'text' => '','name' => 'parser_dup'},'SVt_PVLV' => {'text' => 'Type flag for scalars. See L.','name' => 'SVt_PVLV'},'do_sprintf' => {'text' => '','name' => 'do_sprintf'},'SvUV_nomg' => {'text' => 'Like C |
||||||
1372 | |||||||
1373 | UV SvUV_nomg(SV* sv)','name' => 'SvUV_nomg'},'save_I32' => {'text' => '','name' => 'save_I32'},'gv_autoload4' => {'text' => '','name' => 'gv_autoload4'},'POPpx' => {'text' => 'Pops a string off the stack. Identical to POPp. There are two names for | ||||||
1374 | historical reasons. | ||||||
1375 | |||||||
1376 | char* POPpx','name' => 'POPpx'},'PL_modglobal' => {'text' => 'C |
||||||
1377 | extensions that need to keep information on a per-interpreter basis. | ||||||
1378 | In a pinch, it can also be used as a symbol table for extensions | ||||||
1379 | to share data among each other. It is a good idea to use keys | ||||||
1380 | prefixed by the package name of the extension that owns the data. | ||||||
1381 | |||||||
1382 | HV* PL_modglobal','name' => 'PL_modglobal'},'newCONDOP' => {'text' => 'Constructs, checks, and returns a conditional-expression (C |
||||||
1383 | op. I |
||||||
1384 | will be set automatically, and, shifted up eight bits, the eight bits of | ||||||
1385 | C |
||||||
1386 | I |
||||||
1387 | and I |
||||||
1388 | this function and become part of the constructed op tree. | ||||||
1389 | |||||||
1390 | OP * newCONDOP(I32 flags, OP *first, OP *trueop, | ||||||
1391 | OP *falseop)','name' => 'newCONDOP'},'save_pushi32ptr' => {'text' => '','name' => 'save_pushi32ptr'},'sv_setpvs' => {'text' => 'Like C |
||||||
1392 | |||||||
1393 | void sv_setpvs(SV* sv, const char* s)','name' => 'sv_setpvs'},'cxinc' => {'text' => '','name' => 'cxinc'},'SvUVx' => {'text' => 'Coerces the given SV to an unsigned integer and | ||||||
1394 | returns it. Guarantees to evaluate C |
||||||
1395 | use this if C |
||||||
1396 | otherwise use the more efficient C |
||||||
1397 | |||||||
1398 | UV SvUVx(SV* sv)','name' => 'SvUVx'},'SvROK_on' => {'text' => 'Tells an SV that it is an RV. | ||||||
1399 | |||||||
1400 | void SvROK_on(SV* sv)','name' => 'SvROK_on'},'G_VOID' => {'text' => 'Used to indicate void context. See C |
||||||
1401 | and free the body itself. The SV\'s head is I |
||||||
1402 | its type is set to all 1\'s so that it won\'t inadvertently be assumed | ||||||
1403 | to be live during global destruction etc. | ||||||
1404 | This function should only be called when REFCNT is zero. Most of the time | ||||||
1405 | you\'ll want to call C |
||||||
1406 | instead. | ||||||
1407 | |||||||
1408 | 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 | ||||||
1409 | lexed. The spaces may include ordinary whitespace characters and | ||||||
1410 | Perl-style comments. C<#line> directives are processed if encountered. | ||||||
1411 | Lbufptr> is moved past the spaces, so that it points | ||||||
1412 | at a non-space character (or the end of the input text). | ||||||
1413 | |||||||
1414 | If spaces extend into the next chunk of input text, the next chunk will | ||||||
1415 | be read in. Normally the current chunk will be discarded at the same | ||||||
1416 | time, but if I |
||||||
1417 | chunk will not be discarded. | ||||||
1418 | |||||||
1419 | NOTE: this function is experimental and may change or be | ||||||
1420 | removed without notice. | ||||||
1421 | |||||||
1422 | void lex_read_space(U32 flags)','name' => 'lex_read_space'},'SvGAMAGIC' => {'text' => 'Returns true if the SV has get magic or | ||||||
1423 | overloading. If either is true then | ||||||
1424 | the scalar is active data, and has the potential to return a new value every | ||||||
1425 | time it is accessed. Hence you must be careful to | ||||||
1426 | only read it once per user logical operation and work | ||||||
1427 | with that returned value. If neither is true then | ||||||
1428 | the scalar\'s value cannot change unless written to. | ||||||
1429 | |||||||
1430 | U32 SvGAMAGIC(SV* sv)','name' => 'SvGAMAGIC'},'XSRETURN_NV' => {'text' => 'Return a double from an XSUB immediately. Uses C |
||||||
1431 | |||||||
1432 | void XSRETURN_NV(NV nv)','name' => 'XSRETURN_NV'},'svtype' => {'text' => 'An enum of flags for Perl types. These are found in the file B |
||||||
1433 | in the C |
||||||
1434 | |||||||
1435 | The types are: | ||||||
1436 | |||||||
1437 | SVt_NULL | ||||||
1438 | SVt_BIND (unused) | ||||||
1439 | SVt_IV | ||||||
1440 | SVt_NV | ||||||
1441 | SVt_RV | ||||||
1442 | SVt_PV | ||||||
1443 | SVt_PVIV | ||||||
1444 | SVt_PVNV | ||||||
1445 | SVt_PVMG | ||||||
1446 | SVt_REGEXP | ||||||
1447 | SVt_PVGV | ||||||
1448 | SVt_PVLV | ||||||
1449 | SVt_PVAV | ||||||
1450 | SVt_PVHV | ||||||
1451 | SVt_PVCV | ||||||
1452 | SVt_PVFM | ||||||
1453 | SVt_PVIO | ||||||
1454 | |||||||
1455 | These are most easily explained from the bottom up. | ||||||
1456 | |||||||
1457 | SVt_PVIO is for I/O objects, SVt_PVFM for formats, SVt_PVCV for | ||||||
1458 | subroutines, SVt_PVHV for hashes and SVt_PVAV for arrays. | ||||||
1459 | |||||||
1460 | All the others are scalar types, that is, things that can be bound to a | ||||||
1461 | C<$> variable. For these, the internal types are mostly orthogonal to | ||||||
1462 | types in the Perl language. | ||||||
1463 | |||||||
1464 | Hence, checking C<< SvTYPE(sv) < SVt_PVAV >> is the best way to see whether | ||||||
1465 | something is a scalar. | ||||||
1466 | |||||||
1467 | SVt_PVGV represents a typeglob. If !SvFAKE(sv), then it is a real, | ||||||
1468 | incoercible typeglob. If SvFAKE(sv), then it is a scalar to which a | ||||||
1469 | typeglob has been assigned. Assigning to it again will stop it from being | ||||||
1470 | a typeglob. SVt_PVLV represents a scalar that delegates to another scalar | ||||||
1471 | behind the scenes. It is used, e.g., for the return value of C |
||||||
1472 | for tied hash and array elements. It can hold any scalar value, including | ||||||
1473 | a typeglob. SVt_REGEXP is for regular expressions. | ||||||
1474 | |||||||
1475 | SVt_PVMG represents a "normal" scalar (not a typeglob, regular expression, | ||||||
1476 | or delegate). Since most scalars do not need all the internal fields of a | ||||||
1477 | PVMG, we save memory by allocating smaller structs when possible. All the | ||||||
1478 | other types are just simpler forms of SVt_PVMG, with fewer internal fields. | ||||||
1479 | SVt_NULL can only hold undef. SVt_IV can hold undef, an integer, or a | ||||||
1480 | reference. (SVt_RV is an alias for SVt_IV, which exists for backward | ||||||
1481 | compatibility.) SVt_NV can hold any of those or a double. SVt_PV can only | ||||||
1482 | hold undef or a string. SVt_PVIV is a superset of SVt_PV and SVt_IV. | ||||||
1483 | SVt_PVNV is similar. SVt_PVMG can hold anything SVt_PVNV can hold, but it | ||||||
1484 | can, but does not have to, be blessed or magical.','name' => 'svtype'},'hv_placeholders_get' => {'text' => '','name' => 'hv_placeholders_get'},'load_module' => {'text' => 'Loads the module whose name is pointed to by the string part of name. | ||||||
1485 | Note that the actual module name, not its filename, should be given. | ||||||
1486 | Eg, "Foo::Bar" instead of "Foo/Bar.pm". flags can be any of | ||||||
1487 | PERL_LOADMOD_DENY, PERL_LOADMOD_NOIMPORT, or PERL_LOADMOD_IMPORT_OPS | ||||||
1488 | (or 0 for no flags). ver, if specified and not NULL, provides version semantics | ||||||
1489 | similar to C | ||||||
1490 | arguments can be used to specify arguments to the module\'s import() | ||||||
1491 | method, similar to C | ||||||
1492 | terminated with a final NULL pointer. Note that this list can only | ||||||
1493 | be omitted when the PERL_LOADMOD_NOIMPORT flag has been used. | ||||||
1494 | Otherwise at least a single NULL pointer to designate the default | ||||||
1495 | import list is required. | ||||||
1496 | |||||||
1497 | The reference count for each specified C |
||||||
1498 | |||||||
1499 | 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. | ||||||
1500 | |||||||
1501 | void Poison(void* dest, int nitems, type)','name' => 'Poison'},'sv_catpvf_mg' => {'text' => 'Like C |
||||||
1502 | |||||||
1503 | void sv_catpvf_mg(SV *const sv, | ||||||
1504 | const char *const pat, ...)','name' => 'sv_catpvf_mg'},'get_sv' => {'text' => 'Returns the SV of the specified Perl scalar. C |
||||||
1505 | C |
||||||
1506 | Perl variable does not exist then it will be created. If C |
||||||
1507 | and the variable does not exist then NULL is returned. | ||||||
1508 | |||||||
1509 | NOTE: the perl_ form of this function is deprecated. | ||||||
1510 | |||||||
1511 | SV* get_sv(const char *name, I32 flags)','name' => 'get_sv'},'warn_sv' => {'text' => 'This is an XS interface to Perl\'s C |
||||||
1512 | |||||||
1513 | C |
||||||
1514 | will be used as-is. Otherwise it is used as a string, and if it does | ||||||
1515 | not end with a newline then it will be extended with some indication of | ||||||
1516 | the current location in the code, as described for L. | ||||||
1517 | |||||||
1518 | The error message or object will by default be written to standard error, | ||||||
1519 | but this is subject to modification by a C<$SIG{__WARN__}> handler. | ||||||
1520 | |||||||
1521 | To warn with a simple string message, the L function may be | ||||||
1522 | more convenient. | ||||||
1523 | |||||||
1524 | 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 |
||||||
1525 | |||||||
1526 | 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 | ||||||
1527 | Llinestr>. This should be called when lexing code has | ||||||
1528 | looked to the end of the current chunk and wants to know more. It is | ||||||
1529 | usual, but not necessary, for lexing to have consumed the entirety of | ||||||
1530 | the current chunk at this time. | ||||||
1531 | |||||||
1532 | If Lbufptr> is pointing to the very end of the current | ||||||
1533 | chunk (i.e., the current chunk has been entirely consumed), normally the | ||||||
1534 | current chunk will be discarded at the same time that the new chunk is | ||||||
1535 | read in. If I |
||||||
1536 | will not be discarded. If the current chunk has not been entirely | ||||||
1537 | consumed, then it will not be discarded regardless of the flag. | ||||||
1538 | |||||||
1539 | Returns true if some new text was added to the buffer, or false if the | ||||||
1540 | buffer has reached the end of the input text. | ||||||
1541 | |||||||
1542 | NOTE: this function is experimental and may change or be | ||||||
1543 | removed without notice. | ||||||
1544 | |||||||
1545 | 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 | ||||||
1546 | by an explicit call to FREETMPS, or by an implicit call at places such as | ||||||
1547 | statement boundaries. SvTEMP() is turned on which means that the SV\'s | ||||||
1548 | string buffer can be "stolen" if this SV is copied. See also C |
||||||
1549 | and C |
||||||
1550 | |||||||
1551 | 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 | ||||||
1552 | the latter\'s argument is neither SvPOK, SvIOK nor SvNOK. If the flags | ||||||
1553 | contain SV_GMAGIC, then it does an mg_get() first. | ||||||
1554 | |||||||
1555 | |||||||
1556 | bool sv_2bool_flags(SV *const sv, const I32 flags)','name' => 'sv_2bool_flags'},'malloc' => {'text' => '','name' => 'malloc'},'av_undef' => {'text' => 'Undefines the array. Frees the memory used by the av to store its list of | ||||||
1557 | scalars. If any destructors are triggered as a result, the av itself may | ||||||
1558 | be freed. | ||||||
1559 | |||||||
1560 | void av_undef(AV *av)','name' => 'av_undef'},'parse_label' => {'text' => 'Parse a single label, possibly optional, of the type that may prefix a | ||||||
1561 | Perl statement. It is up to the caller to ensure that the dynamic parser | ||||||
1562 | state (L et al) is correctly set to reflect the source of | ||||||
1563 | the code to be parsed. If I |
||||||
1564 | label is optional, otherwise it is mandatory. | ||||||
1565 | |||||||
1566 | The name of the label is returned in the form of a fresh scalar. If an | ||||||
1567 | optional label is absent, a null pointer is returned. | ||||||
1568 | |||||||
1569 | If an error occurs in parsing, which can only occur if the label is | ||||||
1570 | mandatory, a valid label is returned anyway. The error is reflected in | ||||||
1571 | the parser state, normally resulting in a single exception at the top | ||||||
1572 | level of parsing which covers all the compilation errors that occurred. | ||||||
1573 | |||||||
1574 | NOTE: this function is experimental and may change or be | ||||||
1575 | removed without notice. | ||||||
1576 | |||||||
1577 | SV * parse_label(U32 flags)','name' => 'parse_label'},'PL_check' => {'text' => 'Array, indexed by opcode, of functions that will be called for the "check" | ||||||
1578 | phase of optree building during compilation of Perl code. For most (but | ||||||
1579 | not all) types of op, once the op has been initially built and populated | ||||||
1580 | with child ops it will be filtered through the check function referenced | ||||||
1581 | by the appropriate element of this array. The new op is passed in as the | ||||||
1582 | sole argument to the check function, and the check function returns the | ||||||
1583 | completed op. The check function may (as the name suggests) check the op | ||||||
1584 | for validity and signal errors. It may also initialise or modify parts of | ||||||
1585 | the ops, or perform more radical surgery such as adding or removing child | ||||||
1586 | ops, or even throw the op away and return a different op in its place. | ||||||
1587 | |||||||
1588 | This array of function pointers is a convenient place to hook into the | ||||||
1589 | compilation process. An XS module can put its own custom check function | ||||||
1590 | in place of any of the standard ones, to influence the compilation of a | ||||||
1591 | particular type of op. However, a custom check function must never fully | ||||||
1592 | replace a standard check function (or even a custom check function from | ||||||
1593 | another module). A module modifying checking must instead B |
||||||
1594 | preexisting check function. A custom check function must be selective | ||||||
1595 | about when to apply its custom behaviour. In the usual case where | ||||||
1596 | it decides not to do anything special with an op, it must chain the | ||||||
1597 | preexisting op function. Check functions are thus linked in a chain, | ||||||
1598 | with the core\'s base checker at the end. | ||||||
1599 | |||||||
1600 | For thread safety, modules should not write directly to this array. | ||||||
1601 | Instead, use the function L.','name' => 'PL_check'},'pack_cat' => {'text' => 'The engine implementing pack() Perl function. Note: parameters next_in_list and | ||||||
1602 | flags are not used. This call should not be used; use packlist instead. | ||||||
1603 | |||||||
1604 | void pack_cat(SV *cat, const char *pat, | ||||||
1605 | const char *patend, SV **beglist, | ||||||
1606 | SV **endlist, SV ***next_in_list, | ||||||
1607 | 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 | ||||||
1608 | string in C |
||||||
1609 | C |
||||||
1610 | coerce its args to strings if necessary. See also C |
||||||
1611 | |||||||
1612 | 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 |
||||||
1613 | |||||||
1614 | int mg_free(SV* sv)','name' => 'mg_free'},'sv_force_normal_flags' => {'text' => 'Undo various types of fakery on an SV, where fakery means | ||||||
1615 | "more than" a string: if the PV is a shared string, make | ||||||
1616 | a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to | ||||||
1617 | an xpvmg; if we\'re a copy-on-write scalar, this is the on-write time when | ||||||
1618 | we do the copy, and is also used locally; if this is a | ||||||
1619 | vstring, drop the vstring magic. If C |
||||||
1620 | then a copy-on-write scalar drops its PV buffer (if any) and becomes | ||||||
1621 | SvPOK_off rather than making a copy. (Used where this | ||||||
1622 | scalar is about to be set to some other value.) In addition, | ||||||
1623 | the C |
||||||
1624 | when unreffing. C |
||||||
1625 | with flags set to 0. | ||||||
1626 | |||||||
1627 | void sv_force_normal_flags(SV *const sv, | ||||||
1628 | const U32 flags)','name' => 'sv_force_normal_flags'},'cophh_fetch_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of | ||||||
1629 | a string/length pair. | ||||||
1630 | |||||||
1631 | NOTE: this function is experimental and may change or be | ||||||
1632 | removed without notice. | ||||||
1633 | |||||||
1634 | SV * cophh_fetch_pv(const COPHH *cophh, | ||||||
1635 | const char *key, U32 hash, | ||||||
1636 | U32 flags)','name' => 'cophh_fetch_pv'},'tmps_grow' => {'text' => '','name' => 'tmps_grow'},'is_utf8_char' => {'text' => 'DEPRECATED! | ||||||
1637 | |||||||
1638 | Tests if some arbitrary number of bytes begins in a valid UTF-8 | ||||||
1639 | character. Note that an INVARIANT (i.e. ASCII on non-EBCDIC machines) | ||||||
1640 | character is a valid UTF-8 character. The actual number of bytes in the UTF-8 | ||||||
1641 | character will be returned if it is valid, otherwise 0. | ||||||
1642 | |||||||
1643 | This function is deprecated due to the possibility that malformed input could | ||||||
1644 | cause reading beyond the end of the input buffer. Use L | ||||||
1645 | instead. | ||||||
1646 | |||||||
1647 | 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. | ||||||
1648 | |||||||
1649 | void SvNOK_off(SV* sv)','name' => 'SvNOK_off'},'gv_fetchmeth_pv_autoload' => {'text' => 'Exactly like L, but takes a nul-terminated string | ||||||
1650 | instead of a string/length pair. | ||||||
1651 | |||||||
1652 | GV* gv_fetchmeth_pv_autoload(HV* stash, | ||||||
1653 | const char* name, | ||||||
1654 | 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. | ||||||
1655 | Forces the SV to string form if it is not already. | ||||||
1656 | Will C |
||||||
1657 | Always sets the SvUTF8 flag to avoid future validity checks even | ||||||
1658 | if the whole string is the same in UTF-8 as not. | ||||||
1659 | Returns the number of bytes in the converted string | ||||||
1660 | |||||||
1661 | This is not a general purpose byte encoding to Unicode interface: | ||||||
1662 | use the Encode extension for that. | ||||||
1663 | |||||||
1664 | 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. | ||||||
1665 | Sets up the C |
||||||
1666 | This is usually handled automatically by C |
||||||
1667 | |||||||
1668 | dXSARGS;','name' => 'dXSARGS'},'savesharedpv' => {'text' => 'A version of C |
||||||
1669 | which is shared between threads. | ||||||
1670 | |||||||
1671 | char* savesharedpv(const char* pv)','name' => 'savesharedpv'},'isSPACE' => {'text' => 'Returns a boolean indicating whether the specified character is a | ||||||
1672 | whitespace character. This is analogous | ||||||
1673 | to what C |
||||||
1674 | (experimentally), this also matches what C |
||||||
1675 | ("Experimentally" means that this change may be backed out in 5.20 or 5.22 if | ||||||
1676 | field experience indicates that it was unwise.) Prior to 5.18, only the | ||||||
1677 | locale forms of this macro (the ones with C |
||||||
1678 | precisely what C |
||||||
1679 | in the non-locale variants, was that C |
||||||
1680 | (See L for a macro that matches a vertical tab in all releases.) | ||||||
1681 | See the L |
||||||
1682 | C |
||||||
1683 | C |
||||||
1684 | |||||||
1685 | bool isSPACE(char ch)','name' => 'isSPACE'},'Safefree' => {'text' => 'The XSUB-writer\'s interface to the C C |
||||||
1686 | |||||||
1687 | void Safefree(void* ptr)','name' => 'Safefree'},'custom_op_desc' => {'text' => 'Return the description of a given custom op. This was once used by the | ||||||
1688 | OP_DESC macro, but is no longer: it has only been kept for | ||||||
1689 | compatibility, and should not be used. | ||||||
1690 | |||||||
1691 | 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 |
||||||
1692 | parameter indicates the length of the C |
||||||
1693 | to C |
||||||
1694 | created if it does not already exist. If the package does not exist and | ||||||
1695 | C |
||||||
1696 | is returned. | ||||||
1697 | |||||||
1698 | Flags may be one of: | ||||||
1699 | |||||||
1700 | GV_ADD | ||||||
1701 | SVf_UTF8 | ||||||
1702 | GV_NOADD_NOINIT | ||||||
1703 | GV_NOINIT | ||||||
1704 | GV_NOEXPAND | ||||||
1705 | GV_ADDMG | ||||||
1706 | |||||||
1707 | The most important of which are probably GV_ADD and SVf_UTF8. | ||||||
1708 | |||||||
1709 | HV* gv_stashpvn(const char* name, U32 namelen, | ||||||
1710 | I32 flags)','name' => 'gv_stashpvn'},'vmess' => {'text' => 'C |
||||||
1711 | argument list. These are used to generate a string message. If the | ||||||
1712 | message does not end with a newline, then it will be extended with | ||||||
1713 | some indication of the current location in the code, as described for | ||||||
1714 | L. | ||||||
1715 | |||||||
1716 | Normally, the resulting message is returned in a new mortal SV. | ||||||
1717 | During global destruction a single SV may be shared between uses of | ||||||
1718 | this function. | ||||||
1719 | |||||||
1720 | SV * vmess(const char *pat, va_list *args)','name' => 'vmess'},'new_collate' => {'text' => '','name' => 'new_collate'},'my_stat' => {'text' => '','name' => 'my_stat'},'my_setenv' => {'text' => '','name' => 'my_setenv'},'newSV_type' => {'text' => 'Creates a new SV, of the type specified. The reference count for the new SV | ||||||
1721 | is set to 1. | ||||||
1722 | |||||||
1723 | 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 | ||||||
1724 | value, and you know that I |
||||||
1725 | to return a meaningful value, or check for NULLness, so it\'s smaller | ||||||
1726 | and faster. | ||||||
1727 | |||||||
1728 | 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 | ||||||
1729 | it is not. | ||||||
1730 | |||||||
1731 | If Configure detects this system has a signbit() that will work with | ||||||
1732 | our NVs, then we just use it via the #define in perl.h. Otherwise, | ||||||
1733 | fall back on this implementation. As a first pass, this gets everything | ||||||
1734 | right except -0.0. Alas, catching -0.0 is the main use for this function, | ||||||
1735 | so this is not too helpful yet. Still, at least we have the scaffolding | ||||||
1736 | in place to support other systems, should that prove useful. | ||||||
1737 | |||||||
1738 | |||||||
1739 | Configure notes: This function is called \'Perl_signbit\' instead of a | ||||||
1740 | plain \'signbit\' because it is easy to imagine a system having a signbit() | ||||||
1741 | function or macro that doesn\'t happen to work with our particular choice | ||||||
1742 | of NVs. We shouldn\'t just re-#define signbit as Perl_signbit and expect | ||||||
1743 | the standard system headers to be happy. Also, this is a no-context | ||||||
1744 | function (no pTHX_) because Perl_signbit() is usually re-#defined in | ||||||
1745 | perl.h as a simple macro call to the system\'s signbit(). | ||||||
1746 | Users should just always call Perl_signbit(). | ||||||
1747 | |||||||
1748 | NOTE: this function is experimental and may change or be | ||||||
1749 | removed without notice. | ||||||
1750 | |||||||
1751 | int Perl_signbit(NV f)','name' => 'Perl_signbit'},'PUSH_MULTICALL' => {'text' => 'Opening bracket for a lightweight callback. | ||||||
1752 | See L |
||||||
1753 | |||||||
1754 | PUSH_MULTICALL;','name' => 'PUSH_MULTICALL'},'new_ctype' => {'text' => '','name' => 'new_ctype'},'save_svref' => {'text' => '','name' => 'save_svref'},'newNULLLIST' => {'text' => 'Constructs, checks, and returns a new C |
||||||
1755 | empty list expression. | ||||||
1756 | |||||||
1757 | OP * newNULLLIST()','name' => 'newNULLLIST'},'sv_pos_u2b_flags' => {'text' => 'Converts the value pointed to by offsetp from a count of UTF-8 chars from | ||||||
1758 | the start of the string, to a count of the equivalent number of bytes; if | ||||||
1759 | lenp is non-zero, it does the same to lenp, but this time starting from | ||||||
1760 | the offset, rather than from the start | ||||||
1761 | of the string. Handles type coercion. | ||||||
1762 | I |
||||||
1763 | C |
||||||
1764 | |||||||
1765 | STRLEN sv_pos_u2b_flags(SV *const sv, STRLEN uoffset, | ||||||
1766 | 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 |
||||||
1767 | This is a heavyweight loop, with structure that allows exiting the loop | ||||||
1768 | by C |
||||||
1769 | |||||||
1770 | I |
||||||
1771 | loop; if it is null then a suitable op will be constructed automatically. | ||||||
1772 | I |
||||||
1773 | main body of the loop, and I |
||||||
1774 | that operates as a second half of the body. All of these optree inputs | ||||||
1775 | are consumed by this function and become part of the constructed op tree. | ||||||
1776 | |||||||
1777 | I |
||||||
1778 | op and, shifted up eight bits, the eight bits of C |
||||||
1779 | the C |
||||||
1780 | automatically. I |
||||||
1781 | I |
||||||
1782 | loop body to be enclosed in its own scope. | ||||||
1783 | |||||||
1784 | OP * newWHILEOP(I32 flags, I32 debuggable, | ||||||
1785 | LOOP *loop, OP *expr, OP *block, | ||||||
1786 | OP *cont, I32 has_my)','name' => 'newWHILEOP'},'Gv_AMupdate' => {'text' => '','name' => 'Gv_AMupdate'},'filter_del' => {'text' => '','name' => 'filter_del'},'SvIV_nomg' => {'text' => 'Like C |
||||||
1787 | |||||||
1788 | IV SvIV_nomg(SV* sv)','name' => 'SvIV_nomg'},'POPp' => {'text' => 'Pops a string off the stack. | ||||||
1789 | |||||||
1790 | char* POPp','name' => 'POPp'},'RETVAL' => {'text' => 'Variable which is setup by C |
||||||
1791 | XSUB. This is always the proper type for the XSUB. See | ||||||
1792 | L |
||||||
1793 | |||||||
1794 | (whatever) RETVAL','name' => 'RETVAL'},'HeSVKEY' => {'text' => 'Returns the key as an C |
||||||
1795 | contain an C |
||||||
1796 | |||||||
1797 | SV* HeSVKEY(HE* he)','name' => 'HeSVKEY'},'newANONLIST' => {'text' => '','name' => 'newANONLIST'},'mg_findext' => {'text' => 'Finds the magic pointer of C |
||||||
1798 | C |
||||||
1799 | |||||||
1800 | MAGIC* mg_findext(const SV* sv, int type, | ||||||
1801 | 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 | ||||||
1802 | string in C |
||||||
1803 | C |
||||||
1804 | if necessary. If the flags include SV_GMAGIC, it handles get magic. See | ||||||
1805 | also C |
||||||
1806 | |||||||
1807 | I32 sv_cmp_flags(SV *const sv1, SV *const sv2, | ||||||
1808 | const U32 flags)','name' => 'sv_cmp_flags'},'hv_iternextsv' => {'text' => 'Performs an C |
||||||
1809 | operation. | ||||||
1810 | |||||||
1811 | 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 | ||||||
1812 | to I |
||||||
1813 | performing the correct bookkeeping whenever a newline character is passed. | ||||||
1814 | This is the normal way to consume lexed text. | ||||||
1815 | |||||||
1816 | Interpretation of the buffer\'s octets can be abstracted out by | ||||||
1817 | using the slightly higher-level functions L and | ||||||
1818 | L. | ||||||
1819 | |||||||
1820 | NOTE: this function is experimental and may change or be | ||||||
1821 | removed without notice. | ||||||
1822 | |||||||
1823 | void lex_read_to(char *ptr)','name' => 'lex_read_to'},'sv_pvbyten_force' => {'text' => 'The backend for the C |
||||||
1824 | instead. | ||||||
1825 | |||||||
1826 | 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()) | ||||||
1827 | |||||||
1828 | I32 ibcmp_locale(const char* a, const char* b, | ||||||
1829 | I32 len)','name' => 'ibcmp_locale'},'XST_mIV' => {'text' => 'Place an integer into the specified position C |
||||||
1830 | value is stored in a new mortal SV. | ||||||
1831 | |||||||
1832 | 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 | ||||||
1833 | for this element. Does not use C |
||||||
1834 | |||||||
1835 | void mPUSHs(SV* sv)','name' => 'mPUSHs'},'dump_packsubs' => {'text' => '','name' => 'dump_packsubs'},'GvSV' => {'text' => 'Return the SV from the GV. | ||||||
1836 | |||||||
1837 | SV* GvSV(GV* gv)','name' => 'GvSV'},'isPRINT' => {'text' => 'Returns a boolean indicating whether the specified character is a | ||||||
1838 | printable character, analogous to C |
||||||
1839 | See the L |
||||||
1840 | C |
||||||
1841 | C |
||||||
1842 | |||||||
1843 | bool isPRINT(char ch)','name' => 'isPRINT'},'init_i18nl10n' => {'text' => '','name' => 'init_i18nl10n'},'vform' => {'text' => '','name' => 'vform'},'get_op_descs' => {'text' => '','name' => 'get_op_descs'},'safesyscalloc' => {'text' => '','name' => 'safesyscalloc'},'PL_curpad' => {'text' => 'Points directly to the body of the L array. | ||||||
1844 | (I.e., this is C |
||||||
1845 | |||||||
1846 | NOTE: this function is experimental and may change or be | ||||||
1847 | removed without notice.','name' => 'PL_curpad'},'POPi' => {'text' => 'Pops an integer off the stack. | ||||||
1848 | |||||||
1849 | IV POPi','name' => 'POPi'},'parse_stmtseq' => {'text' => 'Parse a sequence of zero or more Perl statements. These may be normal | ||||||
1850 | imperative statements, including optional labels, or declarations | ||||||
1851 | that have compile-time effect, or any mixture thereof. The statement | ||||||
1852 | sequence ends when a closing brace or end-of-file is encountered in a | ||||||
1853 | place where a new statement could have validly started. It is up to | ||||||
1854 | the caller to ensure that the dynamic parser state (L et al) | ||||||
1855 | is correctly set to reflect the source of the code to be parsed and the | ||||||
1856 | lexical context for the statements. | ||||||
1857 | |||||||
1858 | The op tree representing the statement sequence is returned. This may | ||||||
1859 | be a null pointer if the statements were all null, for example if there | ||||||
1860 | were no statements or if there were only subroutine definitions (which | ||||||
1861 | have compile-time side effects). If not null, it will be a C |
||||||
1862 | list, normally including C |
||||||
1863 | |||||||
1864 | If an error occurs in parsing or compilation, in most cases a valid op | ||||||
1865 | tree is returned anyway. The error is reflected in the parser state, | ||||||
1866 | normally resulting in a single exception at the top level of parsing | ||||||
1867 | which covers all the compilation errors that occurred. Some compilation | ||||||
1868 | errors, however, will throw an exception immediately. | ||||||
1869 | |||||||
1870 | The I |
||||||
1871 | be zero. | ||||||
1872 | |||||||
1873 | NOTE: this function is experimental and may change or be | ||||||
1874 | removed without notice. | ||||||
1875 | |||||||
1876 | OP * parse_stmtseq(U32 flags)','name' => 'parse_stmtseq'},'sv_2pvutf8_nolen' => {'text' => 'Return a pointer to the UTF-8-encoded representation of the SV. | ||||||
1877 | May cause the SV to be upgraded to UTF-8 as a side-effect. | ||||||
1878 | |||||||
1879 | Usually accessed via the C |
||||||
1880 | |||||||
1881 | 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 | ||||||
1882 | considered internal to OP_NAME and the other access macros: use them instead. | ||||||
1883 | |||||||
1884 | NOTE: this function must be explicitly called as Perl_custom_op_xop with an aTHX_ parameter. | ||||||
1885 | |||||||
1886 | 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 | ||||||
1887 | will be whatever C |
||||||
1888 | other MRO is in effect for the stash. The return value is a | ||||||
1889 | read-only AV*. | ||||||
1890 | |||||||
1891 | You are responsible for C |
||||||
1892 | return value if you plan to store it anywhere | ||||||
1893 | semi-permanently (otherwise it might be deleted | ||||||
1894 | out from under you the next time the cache is | ||||||
1895 | invalidated). | ||||||
1896 | |||||||
1897 | AV* mro_get_linear_isa(HV* stash)','name' => 'mro_get_linear_isa'},'SvPVbytex' => {'text' => 'Like C |
||||||
1898 | Guarantees to evaluate sv only once; use the more efficient C |
||||||
1899 | otherwise. | ||||||
1900 | |||||||
1901 | char* SvPVbytex(SV* sv, STRLEN len)','name' => 'SvPVbytex'},'av_store' => {'text' => 'Stores an SV in an array. The array index is specified as C |
||||||
1902 | return value will be NULL if the operation failed or if the value did not | ||||||
1903 | need to be actually stored within the array (as in the case of tied | ||||||
1904 | arrays). Otherwise, it can be dereferenced | ||||||
1905 | to get the C |
||||||
1906 | there (= C |
||||||
1907 | |||||||
1908 | Note that the caller is responsible for suitably incrementing the reference | ||||||
1909 | count of C |
||||||
1910 | returned NULL. | ||||||
1911 | |||||||
1912 | Approximate Perl equivalent: C<$myarray[$key] = $val;>. | ||||||
1913 | |||||||
1914 | See L |
||||||
1915 | more information on how to use this function on tied arrays. | ||||||
1916 | |||||||
1917 | 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 |
||||||
1918 | index. If lval is true, you are guaranteed to get a real SV back (in case | ||||||
1919 | it wasn\'t real before), which you can then modify. Check that the return | ||||||
1920 | value is non-null before dereferencing it to a C |
||||||
1921 | |||||||
1922 | See L |
||||||
1923 | more information on how to use this function on tied arrays. | ||||||
1924 | |||||||
1925 | The rough perl equivalent is C<$myarray[$idx]>. | ||||||
1926 | |||||||
1927 | 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. | ||||||
1928 | |||||||
1929 | void SvNOK_only(SV* sv)','name' => 'SvNOK_only'},'hv_iterval' => {'text' => 'Returns the value from the current position of the hash iterator. See | ||||||
1930 | C |
||||||
1931 | |||||||
1932 | SV* hv_iterval(HV *hv, HE *entry)','name' => 'hv_iterval'},'sv_reftype' => {'text' => 'Returns a string describing what the SV is a reference to. | ||||||
1933 | |||||||
1934 | 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 | ||||||
1935 | case-insensitively in the current locale; false otherwise. | ||||||
1936 | |||||||
1937 | I32 foldEQ_locale(const char* a, const char* b, | ||||||
1938 | I32 len)','name' => 'foldEQ_locale'},'cophh_2hv' => {'text' => 'Generates and returns a standard Perl hash representing the full set of | ||||||
1939 | key/value pairs in the cop hints hash I |
||||||
1940 | unused and must be zero. | ||||||
1941 | |||||||
1942 | NOTE: this function is experimental and may change or be | ||||||
1943 | removed without notice. | ||||||
1944 | |||||||
1945 | 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 | ||||||
1946 | value, and you know that I |
||||||
1947 | to return a meaningful value, or check for NULLness, so it\'s smaller | ||||||
1948 | and faster. | ||||||
1949 | |||||||
1950 | void SvREFCNT_inc_simple_void_NN(SV* sv)','name' => 'SvREFCNT_inc_simple_void_NN'},'rsignal_state' => {'text' => '','name' => 'rsignal_state'},'av_len' => {'text' => 'Same as L. Returns the highest index in the array. Note that the | ||||||
1951 | return value is +1 what its name implies it returns; and hence differs in | ||||||
1952 | meaning from what the similarly named L returns. | ||||||
1953 | |||||||
1954 | I32 av_len(AV *av)','name' => 'av_len'},'sv_unmagic' => {'text' => 'Removes all magic of type C |
||||||
1955 | |||||||
1956 | 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 | ||||||
1957 | expression is tainted--usually a variable, but possibly also implicit | ||||||
1958 | inputs such as locale settings. C |
||||||
1959 | the outputs of an expression in a pessimistic fashion; i.e., without paying | ||||||
1960 | attention to precisely which outputs are influenced by which inputs. | ||||||
1961 | |||||||
1962 | void SvTAINT(SV* sv)','name' => 'SvTAINT'},'mg_clear' => {'text' => 'Clear something magical that the SV represents. See C |
||||||
1963 | |||||||
1964 | int mg_clear(SV* sv)','name' => 'mg_clear'},'my_sprintf' => {'text' => 'The C library C |
||||||
1965 | the length of the string written to the buffer. Only rare pre-ANSI systems | ||||||
1966 | need the wrapper function - usually this is a direct call to C |
||||||
1967 | |||||||
1968 | 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 |
||||||
1969 | store that in UTF-8 in C |
||||||
1970 | that the C |
||||||
1971 | foldcase version may be longer than the original character (up to | ||||||
1972 | three characters). | ||||||
1973 | |||||||
1974 | The first character of the foldcased version is returned | ||||||
1975 | (but note, as explained above, that there may be more.) | ||||||
1976 | |||||||
1977 | The character at C is assumed by this routine to be well-formed. |
||||||
1978 | |||||||
1979 | UV to_utf8_fold(const U8 *p, U8* ustrp, | ||||||
1980 | 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 |
||||||
1981 | determine the length of C |
||||||
1982 | |||||||
1983 | 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 | ||||||
1984 | \'use bytes\' aware and will coerce its args to strings if necessary. If the | ||||||
1985 | flags contain SV_GMAGIC, it handles get magic. See also C |
||||||
1986 | |||||||
1987 | I32 sv_cmp_locale_flags(SV *const sv1, | ||||||
1988 | SV *const sv2, | ||||||
1989 | const U32 flags)','name' => 'sv_cmp_locale_flags'},'sv_vcatpvf_mg' => {'text' => 'Like C |
||||||
1990 | |||||||
1991 | Usually used via its frontend C |
||||||
1992 | |||||||
1993 | void sv_vcatpvf_mg(SV *const sv, | ||||||
1994 | const char *const pat, | ||||||
1995 | va_list *const args)','name' => 'sv_vcatpvf_mg'},'mXPUSHu' => {'text' => 'Push an unsigned integer onto the stack, extending the stack if necessary. | ||||||
1996 | Does not use C |
||||||
1997 | |||||||
1998 | void mXPUSHu(UV uv)','name' => 'mXPUSHu'},'hv_exists_ent' => {'text' => 'Returns a boolean indicating whether | ||||||
1999 | the specified hash key exists. C |
||||||
2000 | can be a valid precomputed hash value, or 0 to ask for it to be | ||||||
2001 | computed. | ||||||
2002 | |||||||
2003 | 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 | ||||||
2004 | part of the pad for the currently-compiling code. (At runtime a CV may | ||||||
2005 | have many such value arrays; at compile time just one is constructed.) | ||||||
2006 | At runtime, this points to the array containing the currently-relevant | ||||||
2007 | values for the pad for the currently-executing code. | ||||||
2008 | |||||||
2009 | NOTE: this function is experimental and may change or be | ||||||
2010 | 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 | ||||||
2011 | double. | ||||||
2012 | |||||||
2013 | U32 SvNIOK(SV* sv)','name' => 'SvNIOK'},'save_long' => {'text' => '','name' => 'save_long'},'mro_method_changed_in' => {'text' => 'Invalidates method caching on any child classes | ||||||
2014 | of the given stash, so that they might notice | ||||||
2015 | the changes in this one. | ||||||
2016 | |||||||
2017 | Ideally, all instances of C |
||||||
2018 | perl source outside of F |
||||||
2019 | replaced by calls to this. | ||||||
2020 | |||||||
2021 | Perl automatically handles most of the common | ||||||
2022 | ways a method might be redefined. However, there | ||||||
2023 | are a few ways you could change a method in a stash | ||||||
2024 | without the cache code noticing, in which case you | ||||||
2025 | need to call this method afterwards: | ||||||
2026 | |||||||
2027 | 1) Directly manipulating the stash HV entries from | ||||||
2028 | XS code. | ||||||
2029 | |||||||
2030 | 2) Assigning a reference to a readonly scalar | ||||||
2031 | constant into a stash entry in order to create | ||||||
2032 | a constant subroutine (like constant.pm | ||||||
2033 | does). | ||||||
2034 | |||||||
2035 | This same method is available from pure perl | ||||||
2036 | via, C |
||||||
2037 | |||||||
2038 | 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 | ||||||
2039 | and ocnt are not used. This call should not be used, use unpackstring instead. | ||||||
2040 | |||||||
2041 | I32 unpack_str(const char *pat, const char *patend, | ||||||
2042 | const char *s, const char *strbeg, | ||||||
2043 | const char *strend, char **new_s, | ||||||
2044 | I32 ocnt, U32 flags)','name' => 'unpack_str'},'my_fflush_all' => {'text' => '','name' => 'my_fflush_all'},'sv_newref' => {'text' => 'Increment an SV\'s reference count. Use the C |
||||||
2045 | instead. | ||||||
2046 | |||||||
2047 | SV* sv_newref(SV *const sv)','name' => 'sv_newref'},'cop_hints_fetch_pv' => {'text' => 'Like L, but takes a nul-terminated string instead | ||||||
2048 | of a string/length pair. | ||||||
2049 | |||||||
2050 | SV * cop_hints_fetch_pv(const COP *cop, | ||||||
2051 | const char *key, U32 hash, | ||||||
2052 | U32 flags)','name' => 'cop_hints_fetch_pv'},'XSRETURN_IV' => {'text' => 'Return an integer from an XSUB immediately. Uses C |
||||||
2053 | |||||||
2054 | void XSRETURN_IV(IV iv)','name' => 'XSRETURN_IV'},'sv_uni_display' => {'text' => 'Build to the scalar C |
||||||
2055 | the displayable version being at most C |
||||||
2056 | (if longer, the rest is truncated and "..." will be appended). | ||||||
2057 | |||||||
2058 | The C |
||||||
2059 | |||||||
2060 | The pointer to the PV of the C |
||||||
2061 | |||||||
2062 | char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim, | ||||||
2063 | UV flags)','name' => 'sv_uni_display'},'sv_unmagicext' => {'text' => 'Removes all magic of type C |
||||||
2064 | |||||||
2065 | int sv_unmagicext(SV *const sv, const int type, | ||||||
2066 | MGVTBL *vtbl)','name' => 'sv_unmagicext'},'newSVpvs' => {'text' => 'Like C |
||||||
2067 | |||||||
2068 | SV* newSVpvs(const char* s)','name' => 'newSVpvs'},'SvREFCNT_dec' => {'text' => 'Decrements the reference count of the given SV. I |
||||||
2069 | |||||||
2070 | void SvREFCNT_dec(SV* sv)','name' => 'SvREFCNT_dec'},'realloc' => {'text' => '','name' => 'realloc'},'POPs' => {'text' => 'Pops an SV off the stack. | ||||||
2071 | |||||||
2072 | SV* POPs','name' => 'POPs'},'SvNV' => {'text' => 'Coerce the given SV to a double and return it. See C |
||||||
2073 | which guarantees to evaluate sv only once. | ||||||
2074 | |||||||
2075 | NV SvNV(SV* sv)','name' => 'SvNV'},'packlist' => {'text' => 'The engine implementing pack() Perl function. | ||||||
2076 | |||||||
2077 | void packlist(SV *cat, const char *pat, | ||||||
2078 | const char *patend, SV **beglist, | ||||||
2079 | SV **endlist)','name' => 'packlist'},'SvUTF8' => {'text' => 'Returns a U32 value indicating the UTF-8 status of an SV. If things are set-up | ||||||
2080 | properly, this indicates whether or not the SV contains UTF-8 encoded data. | ||||||
2081 | You should use this I |
||||||
2082 | case any call to string overloading updates the internal flag. | ||||||
2083 | |||||||
2084 | U32 SvUTF8(SV* sv)','name' => 'SvUTF8'},'gv_fetchmethod_autoload' => {'text' => 'Returns the glob which contains the subroutine to call to invoke the method | ||||||
2085 | on the C |
||||||
2086 | glob for "AUTOLOAD". In this case the corresponding variable $AUTOLOAD is | ||||||
2087 | already setup. | ||||||
2088 | |||||||
2089 | The third parameter of C |
||||||
2090 | AUTOLOAD lookup is performed if the given method is not present: non-zero | ||||||
2091 | means yes, look for AUTOLOAD; zero means no, don\'t look for AUTOLOAD. | ||||||
2092 | Calling C |
||||||
2093 | with a non-zero C |
||||||
2094 | |||||||
2095 | These functions grant C<"SUPER"> token as a prefix of the method name. Note | ||||||
2096 | that if you want to keep the returned glob for a long time, you need to | ||||||
2097 | check for it being "AUTOLOAD", since at the later time the call may load a | ||||||
2098 | different subroutine due to $AUTOLOAD changing its value. Use the glob | ||||||
2099 | created via a side effect to do this. | ||||||
2100 | |||||||
2101 | These functions have the same side-effects and as C |
||||||
2102 | C |
||||||
2103 | \'\'>. The warning against passing the GV returned by C |
||||||
2104 | C |
||||||
2105 | |||||||
2106 | GV* gv_fetchmethod_autoload(HV* stash, | ||||||
2107 | const char* name, | ||||||
2108 | 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 | ||||||
2109 | identical. Is UTF-8 and \'use bytes\' aware, handles get magic, and will | ||||||
2110 | coerce its args to strings if necessary. | ||||||
2111 | |||||||
2112 | 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 | ||||||
2113 | not. | ||||||
2114 | |||||||
2115 | 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 | ||||||
2116 | by an explicit C |
||||||
2117 | In the former case, we keep the CvOUTSIDE pointer, so that any anonymous | ||||||
2118 | children can still follow the full lexical scope chain. | ||||||
2119 | |||||||
2120 | void cv_undef(CV* cv)','name' => 'cv_undef'},'StructCopy' => {'text' => 'This is an architecture-independent macro to copy one structure to another. | ||||||
2121 | |||||||
2122 | 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 | ||||||
2123 | string/length pair, and no precomputed hash. | ||||||
2124 | |||||||
2125 | NOTE: this function is experimental and may change or be | ||||||
2126 | removed without notice. | ||||||
2127 | |||||||
2128 | COPHH * cophh_delete_pvs(const COPHH *cophh, | ||||||
2129 | const char *key, U32 flags)','name' => 'cophh_delete_pvs'},'GvCV' => {'text' => 'Return the CV from the GV. | ||||||
2130 | |||||||
2131 | CV* GvCV(GV* gv)','name' => 'GvCV'},'get_cvn_flags' => {'text' => 'Returns the CV of the specified Perl subroutine. C |
||||||
2132 | C |
||||||
2133 | exist then it will be declared (which has the same effect as saying | ||||||
2134 | C). If C |
||||||
2135 | then NULL is returned. | ||||||
2136 | |||||||
2137 | NOTE: the perl_ form of this function is deprecated. | ||||||
2138 | |||||||
2139 | CV* get_cvn_flags(const char* name, STRLEN len, | ||||||
2140 | I32 flags)','name' => 'get_cvn_flags'},'XopENTRY_set' => {'text' => 'Set a member of the XOP structure. I |
||||||
2141 | which entry to set. See L |
||||||
2142 | the available members and how they are used. | ||||||
2143 | |||||||
2144 | void XopENTRY_set(XOP *xop, which, value)','name' => 'XopENTRY_set'},'reentrant_free' => {'text' => '','name' => 'reentrant_free'},'items' => {'text' => 'Variable which is setup by C |
||||||
2145 | items on the stack. See L |
||||||
2146 | |||||||
2147 | I32 items','name' => 'items'},'XST_mPV' => {'text' => 'Place a copy of a string into the specified position C |
||||||
2148 | The value is stored in a new mortal SV. | ||||||
2149 | |||||||
2150 | void XST_mPV(int pos, char* str)','name' => 'XST_mPV'},'dump_vindent' => {'text' => '','name' => 'dump_vindent'},'SvPVx' => {'text' => 'A version of C |
||||||
2151 | Only use this if C |
||||||
2152 | more efficient C |
||||||
2153 | |||||||
2154 | 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 |
||||||
2155 | upgrades the SV to C |
||||||
2156 | Use the C |
||||||
2157 | |||||||
2158 | char* sv_grow(SV *const sv, STRLEN newlen)','name' => 'sv_grow'},'vnormal' => {'text' => 'Accepts a version object and returns the normalized string | ||||||
2159 | representation. Call like: | ||||||
2160 | |||||||
2161 | sv = vnormal(rv); | ||||||
2162 | |||||||
2163 | NOTE: you can pass either the object directly or the SV | ||||||
2164 | contained within the RV. | ||||||
2165 | |||||||
2166 | The SV returned has a refcount of 1. | ||||||
2167 | |||||||
2168 | 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 | ||||||
2169 | embedded C-level pointer (PV). I |
||||||
2170 | the eight bits of C |
||||||
2171 | must have been allocated using L; the memory will | ||||||
2172 | be freed when the op is destroyed. | ||||||
2173 | |||||||
2174 | 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 | ||||||
2175 | handle \'set\' magic. Does not use C |
||||||
2176 | C |
||||||
2177 | |||||||
2178 | void XPUSHs(SV* sv)','name' => 'XPUSHs'},'set_numeric_radix' => {'text' => '','name' => 'set_numeric_radix'},'newIO' => {'text' => '','name' => 'newIO'},'PadnameUTF8' => {'text' => 'Whether PadnamePV is in UTF8. | ||||||
2179 | |||||||
2180 | NOTE: this function is experimental and may change or be | ||||||
2181 | removed without notice. | ||||||
2182 | |||||||
2183 | bool PadnameUTF8(PADNAME pn)','name' => 'PadnameUTF8'},'do_join' => {'text' => '','name' => 'do_join'},'save_helem' => {'text' => '','name' => 'save_helem'},'die' => {'text' => 'Behaves the same as L, except for the return type. | ||||||
2184 | It should be used only where the C |
||||||
2185 | The function never actually returns. | ||||||
2186 | |||||||
2187 | OP * die(const char *pat, ...)','name' => 'die'},'sv_usepvn' => {'text' => 'Tells an SV to use C |
||||||
2188 | calling C |
||||||
2189 | magic. See C |
||||||
2190 | |||||||
2191 | void sv_usepvn(SV* sv, char* ptr, STRLEN len)','name' => 'sv_usepvn'},'SvREFCNT' => {'text' => 'Returns the value of the object\'s reference count. | ||||||
2192 | |||||||
2193 | U32 SvREFCNT(SV* sv)','name' => 'SvREFCNT'},'newCONSTSUB_flags' => {'text' => 'Creates a constant sub equivalent to Perl C which is | ||||||
2194 | eligible for inlining at compile-time. | ||||||
2195 | |||||||
2196 | Currently, the only useful value for C |
||||||
2197 | |||||||
2198 | The newly created subroutine takes ownership of a reference to the passed in | ||||||
2199 | SV. | ||||||
2200 | |||||||
2201 | Passing NULL for SV creates a constant sub equivalent to C, | ||||||
2202 | which won\'t be called if used as a destructor, but will suppress the overhead | ||||||
2203 | of a call to C |
||||||
2204 | compile time.) | ||||||
2205 | |||||||
2206 | CV* newCONSTSUB_flags(HV* stash, const char* name, | ||||||
2207 | 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 |
||||||
2208 | |||||||
2209 | Take a sprintf-style format pattern and argument list. These are used to | ||||||
2210 | generate a string message. If the message does not end with a newline, | ||||||
2211 | then it will be extended with some indication of the current location | ||||||
2212 | in the code, as described for L. | ||||||
2213 | |||||||
2214 | The error message or object will by default be written to standard error, | ||||||
2215 | but this is subject to modification by a C<$SIG{__WARN__}> handler. | ||||||
2216 | |||||||
2217 | Unlike with L, C |
||||||
2218 | |||||||
2219 | void warn(const char *pat, ...)','name' => 'warn'},'PerlIO_get_bufsiz' => {'text' => '','name' => 'PerlIO_get_bufsiz'},'fp_dup' => {'text' => '','name' => 'fp_dup'},'hek_dup' => {'text' => '','name' => 'hek_dup'},'pmop_dump' => {'text' => '','name' => 'pmop_dump'},'newANONATTRSUB' => {'text' => '','name' => 'newANONATTRSUB'},'CvPADLIST' => {'text' => 'CV\'s can have CvPADLIST(cv) set to point to a PADLIST. This is the CV\'s | ||||||
2220 | scratchpad, which stores lexical variables and opcode temporary and | ||||||
2221 | per-thread values. | ||||||
2222 | |||||||
2223 | For these purposes "formats" are a kind-of CV; eval""s are too (except they\'re | ||||||
2224 | not callable at will and are always thrown away after the eval"" is done | ||||||
2225 | executing). Require\'d files are simply evals without any outer lexical | ||||||
2226 | scope. | ||||||
2227 | |||||||
2228 | XSUBs don\'t have CvPADLIST set - dXSTARG fetches values from PL_curpad, | ||||||
2229 | but that is really the callers pad (a slot of which is allocated by | ||||||
2230 | every entersub). | ||||||
2231 | |||||||
2232 | The PADLIST has a C array where pads are stored. | ||||||
2233 | |||||||
2234 | The 0th entry of the PADLIST is a PADNAMELIST (which is actually just an | ||||||
2235 | AV, but that may change) which represents the "names" or rather | ||||||
2236 | the "static type information" for lexicals. The individual elements of a | ||||||
2237 | PADNAMELIST are PADNAMEs (just SVs; but, again, that may change). Future | ||||||
2238 | refactorings might stop the PADNAMELIST from being stored in the PADLIST\'s | ||||||
2239 | array, so don\'t rely on it. See L. | ||||||
2240 | |||||||
2241 | The CvDEPTH\'th entry of a PADLIST is a PAD (an AV) which is the stack frame | ||||||
2242 | at that depth of recursion into the CV. The 0th slot of a frame AV is an | ||||||
2243 | AV which is @_. Other entries are storage for variables and op targets. | ||||||
2244 | |||||||
2245 | Iterating over the PADNAMELIST iterates over all possible pad | ||||||
2246 | items. Pad slots that are SVs_PADTMP (targets/GVs/constants) end up having | ||||||
2247 | &PL_sv_undef "names" (see pad_alloc()). | ||||||
2248 | |||||||
2249 | Only my/our variable (SvPADMY/PADNAME_isOUR) slots get valid names. | ||||||
2250 | The rest are op targets/GVs/constants which are statically allocated | ||||||
2251 | or resolved at compile time. These don\'t have names by which they | ||||||
2252 | can be looked up from Perl code at run time through eval"" the way | ||||||
2253 | my/our variables can be. Since they can\'t be looked up by "name" | ||||||
2254 | but only by their index allocated at compile time (which is usually | ||||||
2255 | in PL_op->op_targ), wasting a name SV for them doesn\'t make sense. | ||||||
2256 | |||||||
2257 | The SVs in the names AV have their PV being the name of the variable. | ||||||
2258 | xlow+1..xhigh inclusive in the NV union is a range of cop_seq numbers for | ||||||
2259 | which the name is valid (accessed through the macros COP_SEQ_RANGE_LOW and | ||||||
2260 | _HIGH). During compilation, these fields may hold the special value | ||||||
2261 | PERL_PADSEQ_INTRO to indicate various stages: | ||||||
2262 | |||||||
2263 | COP_SEQ_RANGE_LOW _HIGH | ||||||
2264 | ----------------- ----- | ||||||
2265 | PERL_PADSEQ_INTRO 0 variable not yet introduced: { my ($x | ||||||
2266 | valid-seq# PERL_PADSEQ_INTRO variable in scope: { my ($x) | ||||||
2267 | valid-seq# valid-seq# compilation of scope complete: { my ($x) } | ||||||
2268 | |||||||
2269 | For typed lexicals name SV is SVt_PVMG and SvSTASH | ||||||
2270 | points at the type. For C |
||||||
2271 | SvOURSTASH slot pointing at the stash of the associated global (so that | ||||||
2272 | duplicate C |
||||||
2273 | sometimes hijacked to store the generation number during compilation. | ||||||
2274 | |||||||
2275 | If PADNAME_OUTER (SvFAKE) is set on the | ||||||
2276 | name SV, then that slot in the frame AV is | ||||||
2277 | a REFCNT\'ed reference to a lexical from "outside". In this case, | ||||||
2278 | the name SV does not use xlow and xhigh to store a cop_seq range, since it is | ||||||
2279 | in scope throughout. Instead xhigh stores some flags containing info about | ||||||
2280 | the real lexical (is it declared in an anon, and is it capable of being | ||||||
2281 | instantiated multiple times?), and for fake ANONs, xlow contains the index | ||||||
2282 | within the parent\'s pad where the lexical\'s value is stored, to make | ||||||
2283 | cloning quicker. | ||||||
2284 | |||||||
2285 | If the \'name\' is \'&\' the corresponding entry in the PAD | ||||||
2286 | is a CV representing a possible closure. | ||||||
2287 | (PADNAME_OUTER and name of \'&\' is not a | ||||||
2288 | meaningful combination currently but could | ||||||
2289 | become so if C |
||||||
2290 | |||||||
2291 | Note that formats are treated as anon subs, and are cloned each time | ||||||
2292 | write is called (if necessary). | ||||||
2293 | |||||||
2294 | The flag SVs_PADSTALE is cleared on lexicals each time the my() is executed, | ||||||
2295 | and set on scope exit. This allows the | ||||||
2296 | \'Variable $x is not available\' warning | ||||||
2297 | to be generated in evals, such as | ||||||
2298 | |||||||
2299 | { my $x = 1; sub f { eval \'$x\'} } f(); | ||||||
2300 | |||||||
2301 | For state vars, SVs_PADSTALE is overloaded to mean \'not yet initialised\'. | ||||||
2302 | |||||||
2303 | NOTE: this function is experimental and may change or be | ||||||
2304 | removed without notice. | ||||||
2305 | |||||||
2306 | PADLIST * CvPADLIST(CV *cv)','name' => 'CvPADLIST'},'HvNAMEUTF8' => {'text' => 'Returns true if the name is in UTF8 encoding. | ||||||
2307 | |||||||
2308 | unsigned char HvNAMEUTF8(HV *stash)','name' => 'HvNAMEUTF8'},'SVt_PVGV' => {'text' => 'Type flag for typeglobs. See L.','name' => 'SVt_PVGV'},'sv_catpvf_mg_nocontext' => {'text' => '','name' => 'sv_catpvf_mg_nocontext'},'reg_named_buff_all' => {'text' => '','name' => 'reg_named_buff_all'},'PerlIO_close' => {'text' => '','name' => 'PerlIO_close'},'EXTEND' => {'text' => 'Used to extend the argument stack for an XSUB\'s return values. Once | ||||||
2309 | used, guarantees that there is room for at least C |
||||||
2310 | onto the stack. | ||||||
2311 | |||||||
2312 | void EXTEND(SP, int nitems)','name' => 'EXTEND'},'newOP' => {'text' => 'Constructs, checks, and returns an op of any base type (any type that | ||||||
2313 | has no extra fields). I |
||||||
2314 | eight bits of C |
||||||
2315 | of C |
||||||
2316 | |||||||
2317 | OP * newOP(I32 type, I32 flags)','name' => 'newOP'},'newSVuv' => {'text' => 'Creates a new SV and copies an unsigned integer into it. | ||||||
2318 | The reference count for the SV is set to 1. | ||||||
2319 | |||||||
2320 | SV* newSVuv(const UV u)','name' => 'newSVuv'},'gv_fetchmeth' => {'text' => 'Like L, but lacks a flags parameter. | ||||||
2321 | |||||||
2322 | GV* gv_fetchmeth(HV* stash, const char* name, | ||||||
2323 | 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. | ||||||
2324 | Returns a glob for the subroutine. | ||||||
2325 | |||||||
2326 | For an autoloaded subroutine without a GV, will create a GV even | ||||||
2327 | if C |
||||||
2328 | of the result may be zero. | ||||||
2329 | |||||||
2330 | Currently, the only significant value for C |
||||||
2331 | |||||||
2332 | GV* gv_fetchmeth_pvn_autoload(HV* stash, | ||||||
2333 | const char* name, | ||||||
2334 | STRLEN len, I32 level, | ||||||
2335 | U32 flags)','name' => 'gv_fetchmeth_pvn_autoload'},'newGVgen' => {'text' => '','name' => 'newGVgen'},'sv_does' => {'text' => 'Like L, but doesn\'t take a C |
||||||
2336 | |||||||
2337 | 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 | ||||||
2338 | only a loop in the control flow through the op tree; it does not have | ||||||
2339 | the heavyweight loop structure that allows exiting the loop by C |
||||||
2340 | and suchlike. I |
||||||
2341 | top-level op, except that some bits will be set automatically as required. | ||||||
2342 | I |
||||||
2343 | supplies the body of the loop; they are consumed by this function and | ||||||
2344 | become part of the constructed op tree. I |
||||||
2345 | unused and should always be 1. | ||||||
2346 | |||||||
2347 | OP * newLOOPOP(I32 flags, I32 debuggable, OP *expr, | ||||||
2348 | 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 | ||||||
2349 | attributable to C |
||||||
2350 | |||||||
2351 | 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, | ||||||
2352 | and leaves the UTF-8 status as it was. | ||||||
2353 | |||||||
2354 | void SvPOK_only_UTF8(SV* sv)','name' => 'SvPOK_only_UTF8'},'mg_get' => {'text' => 'Do magic before a value is retrieved from the SV. The type of SV must | ||||||
2355 | be >= SVt_PVMG. See C |
||||||
2356 | |||||||
2357 | int mg_get(SV* sv)','name' => 'mg_get'},'SvTRUE' => {'text' => 'Returns a boolean indicating whether Perl would evaluate the SV as true or | ||||||
2358 | false. See SvOK() for a defined/undefined test. Handles \'get\' magic | ||||||
2359 | unless the scalar is already SvPOK, SvIOK or SvNOK (the public, not the | ||||||
2360 | private flags). | ||||||
2361 | |||||||
2362 | 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 |
||||||
2363 | The C |
||||||
2364 | set the placeholders keys (for restricted hashes) will be returned in addition | ||||||
2365 | to normal keys. By default placeholders are automatically skipped over. | ||||||
2366 | Currently a placeholder is implemented with a value that is | ||||||
2367 | C<&PL_sv_placeholder>. Note that the implementation of placeholders and | ||||||
2368 | restricted hashes may change, and the implementation currently is | ||||||
2369 | insufficiently abstracted for any change to be tidy. | ||||||
2370 | |||||||
2371 | NOTE: this function is experimental and may change or be | ||||||
2372 | removed without notice. | ||||||
2373 | |||||||
2374 | 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 | ||||||
2375 | case of "utf8ness failure") or the location C |
||||||
2376 | "utf8ness success") in the C |
||||||
2377 | encoded characters in the C |
||||||
2378 | |||||||
2379 | See also L() and L(). | ||||||
2380 | |||||||
2381 | bool is_utf8_string_loclen(const U8 *s, STRLEN len, | ||||||
2382 | 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 | ||||||
2383 | be on the stack. See L |
||||||
2384 | |||||||
2385 | NOTE: the perl_ form of this function is deprecated. | ||||||
2386 | |||||||
2387 | 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 | ||||||
2388 | flag. I |
||||||
2389 | This will assert (under -DDEBUGGING) if the entry doesn\'t contain a valid | ||||||
2390 | pointer. | ||||||
2391 | |||||||
2392 | NOTE: this function is experimental and may change or be | ||||||
2393 | removed without notice. | ||||||
2394 | |||||||
2395 | 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 |
||||||
2396 | |||||||
2397 | int perl_parse(PerlInterpreter *my_perl, | ||||||
2398 | XSINIT_t xsinit, int argc, | ||||||
2399 | 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 | ||||||
2400 | store its list of scalars. If any destructors are triggered as a result, | ||||||
2401 | the av itself may be freed when this function returns. | ||||||
2402 | |||||||
2403 | Perl equivalent: C<@myarray = ();>. | ||||||
2404 | |||||||
2405 | 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 | ||||||
2406 | a private copy; if we\'re a ref, stop refing; if we\'re a glob, downgrade to | ||||||
2407 | an xpvmg. See also C |
||||||
2408 | |||||||
2409 | void sv_force_normal(SV *sv)','name' => 'sv_force_normal'},'av_unshift' => {'text' => 'Unshift the given number of C |
||||||
2410 | array. The array will grow automatically to accommodate the addition. You | ||||||
2411 | must then use C |
||||||
2412 | |||||||
2413 | Perl equivalent: C |
||||||
2414 | |||||||
2415 | 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 |
||||||
2416 | is not NULL. Since we don\'t have to check the NULLness, it\'s faster | ||||||
2417 | and smaller. | ||||||
2418 | |||||||
2419 | SV* SvREFCNT_inc_NN(SV* sv)','name' => 'SvREFCNT_inc_NN'},'sys_term' => {'text' => '','name' => 'sys_term'},'re_intuit_start' => {'text' => '','name' => 're_intuit_start'},'SvUVX' => {'text' => 'Returns the raw value in the SV\'s UV slot, without checks or conversions. | ||||||
2420 | Only use when you are sure SvIOK is true. See also C |
||||||
2421 | |||||||
2422 | UV SvUVX(SV* sv)','name' => 'SvUVX'},'hv_copy_hints_hv' => {'text' => 'A specialised version of L for copying C<%^H>. I |
||||||
2423 | a pointer to a hash (which may have C<%^H> magic, but should be generally | ||||||
2424 | non-magical), or C |
||||||
2425 | of I |
||||||
2426 | added to it. A pointer to the new hash is returned. | ||||||
2427 | |||||||
2428 | 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 | ||||||
2429 | and contains a multiple-byte character, the C |
||||||
2430 | so that it looks like a character. If the PV contains only single-byte | ||||||
2431 | characters, the C |
||||||
2432 | Scans PV for validity and returns false if the PV is invalid UTF-8. | ||||||
2433 | |||||||
2434 | NOTE: this function is experimental and may change or be | ||||||
2435 | removed without notice. | ||||||
2436 | |||||||
2437 | bool sv_utf8_decode(SV *const sv)','name' => 'sv_utf8_decode'},'op_refcnt_unlock' => {'text' => '','name' => 'op_refcnt_unlock'},'hv_stores' => {'text' => 'Like C |
||||||
2438 | and omits the hash parameter. | ||||||
2439 | |||||||
2440 | SV** hv_stores(HV* tb, const char* key, | ||||||
2441 | NULLOK SV* val)','name' => 'hv_stores'},'SvNV_nomg' => {'text' => 'Like C |
||||||
2442 | |||||||
2443 | NV SvNV_nomg(SV* sv)','name' => 'SvNV_nomg'},'eval_sv' => {'text' => 'Tells Perl to C |
||||||
2444 | as C |
||||||
2445 | |||||||
2446 | NOTE: the perl_ form of this function is deprecated. | ||||||
2447 | |||||||
2448 | I32 eval_sv(SV* sv, I32 flags)','name' => 'eval_sv'},'FREETMPS' => {'text' => 'Closing bracket for temporaries on a callback. See C |
||||||
2449 | L |
||||||
2450 | |||||||
2451 | FREETMPS;','name' => 'FREETMPS'},'sv_utf8_upgrade_nomg' => {'text' => 'Like sv_utf8_upgrade, but doesn\'t do magic on C |
||||||
2452 | |||||||
2453 | 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. | ||||||
2454 | A private implementation of the C |
||||||
2455 | can\'t cope with complex macro expressions. Always use the macro instead. | ||||||
2456 | |||||||
2457 | char* sv_pvn_force(SV* sv, STRLEN* lp)','name' => 'sv_pvn_force'},'GIMME' => {'text' => 'A backward-compatible version of C |
||||||
2458 | C |
||||||
2459 | Deprecated. Use C |
||||||
2460 | |||||||
2461 | U32 GIMME','name' => 'GIMME'},'SvIOK_UV' => {'text' => 'Returns a boolean indicating whether the SV contains an integer that must be | ||||||
2462 | interpreted as unsigned. A non-negative integer whose value is within the | ||||||
2463 | range of both an IV and a UV may be be flagged as either SvUOK or SVIOK. | ||||||
2464 | |||||||
2465 | bool SvIOK_UV(SV* sv)','name' => 'SvIOK_UV'},'my_snprintf' => {'text' => 'The C library C |
||||||
2466 | standards-compliant (uses C |
||||||
2467 | C |
||||||
2468 | C |
||||||
2469 | but that may be too late). Consider using C |
||||||
2470 | getting C |
||||||
2471 | |||||||
2472 | int my_snprintf(char *buffer, const Size_t len, | ||||||
2473 | const char *format, ...)','name' => 'my_snprintf'},'newLOGOP' => {'text' => 'Constructs, checks, and returns a logical (flow control) op. I |
||||||
2474 | is the opcode. I |
||||||
2475 | that C |
||||||
2476 | the eight bits of C |
||||||
2477 | automatically set. I |
||||||
2478 | flow, and I |
||||||
2479 | consumed by this function and become part of the constructed op tree. | ||||||
2480 | |||||||
2481 | OP * newLOGOP(I32 type, I32 flags, OP *first, | ||||||
2482 | OP *other)','name' => 'newLOGOP'},'gp_ref' => {'text' => '','name' => 'gp_ref'},'save_op' => {'text' => '','name' => 'save_op'},'perl_construct' => {'text' => 'Initializes a new Perl interpreter. See L |
||||||
2483 | |||||||
2484 | void perl_construct(PerlInterpreter *my_perl)','name' => 'perl_construct'},'SvUOK' => {'text' => 'Returns a boolean indicating whether the SV contains an integer that must be | ||||||
2485 | interpreted as unsigned. A non-negative integer whose value is within the | ||||||
2486 | range of both an IV and a UV may be be flagged as either SvUOK or SVIOK. | ||||||
2487 | |||||||
2488 | bool SvUOK(SV* sv)','name' => 'SvUOK'},'newWHENOP' => {'text' => 'Constructs, checks, and returns an op tree expressing a C |
||||||
2489 | I |
||||||
2490 | that will be executed if the test evaluates to true; they are consumed | ||||||
2491 | by this function and become part of the constructed op tree. I |
||||||
2492 | will be interpreted DWIMically, often as a comparison against C<$_>, | ||||||
2493 | and may be null to generate a C |
||||||
2494 | |||||||
2495 | OP * newWHENOP(OP *cond, OP *block)','name' => 'newWHENOP'},'sv_dec' => {'text' => 'Auto-decrement of the value in the SV, doing string to numeric conversion | ||||||
2496 | if necessary. Handles \'get\' magic and operator overloading. | ||||||
2497 | |||||||
2498 | void sv_dec(SV *const sv)','name' => 'sv_dec'},'pv_display' => {'text' => 'Similar to | ||||||
2499 | |||||||
2500 | pv_escape(dsv,pv,cur,pvlim,PERL_PV_ESCAPE_QUOTE); | ||||||
2501 | |||||||
2502 | except that an additional "\\0" will be appended to the string when | ||||||
2503 | len > cur and pv[cur] is "\\0". | ||||||
2504 | |||||||
2505 | Note that the final string may be up to 7 chars longer than pvlim. | ||||||
2506 | |||||||
2507 | char* pv_display(SV *dsv, const char *pv, STRLEN cur, | ||||||
2508 | 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. | ||||||
2509 | May cause the SV to be downgraded from UTF-8 as a side-effect. | ||||||
2510 | |||||||
2511 | Usually accessed via the C |
||||||
2512 | |||||||
2513 | char* sv_2pvbyte_nolen(SV* sv)','name' => 'sv_2pvbyte_nolen'},'PadlistMAX' => {'text' => 'The index of the last pad in the padlist. | ||||||
2514 | |||||||
2515 | NOTE: this function is experimental and may change or be | ||||||
2516 | removed without notice. | ||||||
2517 | |||||||
2518 | SSize_t PadlistMAX(PADLIST padlist)','name' => 'PadlistMAX'},'PerlIO_fileno' => {'text' => '','name' => 'PerlIO_fileno'},'uvchr_to_utf8' => {'text' => 'Adds the UTF-8 representation of the Native code point C |
||||||
2519 | of the string C |
||||||
2520 | bytes available. The return value is the pointer to the byte after the | ||||||
2521 | end of the new character. In other words, | ||||||
2522 | |||||||
2523 | d = uvchr_to_utf8(d, uv); | ||||||
2524 | |||||||
2525 | is the recommended wide native character-aware way of saying | ||||||
2526 | |||||||
2527 | *(d++) = uv; | ||||||
2528 | |||||||
2529 | U8* uvchr_to_utf8(U8 *d, UV uv)','name' => 'uvchr_to_utf8'},'isDIGIT' => {'text' => 'Returns a boolean indicating whether the specified character is a | ||||||
2530 | digit, analogous to C |
||||||
2531 | Variants C |
||||||
2532 | See the L |
||||||
2533 | C |
||||||
2534 | C |
||||||
2535 | |||||||
2536 | bool isDIGIT(char ch)','name' => 'isDIGIT'},'call_atexit' => {'text' => '','name' => 'call_atexit'},'my_bzero' => {'text' => '','name' => 'my_bzero'},'newCONSTSUB' => {'text' => 'See L. | ||||||
2537 | |||||||
2538 | 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 | ||||||
2539 | has been loaded. | ||||||
2540 | |||||||
2541 | void SvSHARE(SV* sv)','name' => 'SvSHARE'},'vwarner' => {'text' => '','name' => 'vwarner'},'sortsv' => {'text' => 'Sort an array. Here is an example: | ||||||
2542 | |||||||
2543 | sortsv(AvARRAY(av), av_top_index(av)+1, Perl_sv_cmp_locale); | ||||||
2544 | |||||||
2545 | Currently this always uses mergesort. See sortsv_flags for a more | ||||||
2546 | flexible routine. | ||||||
2547 | |||||||
2548 | void sortsv(SV** array, size_t num_elts, | ||||||
2549 | SVCOMPARE_t cmp)','name' => 'sortsv'},'av_tindex' => {'text' => 'Same as C |
||||||
2550 | |||||||
2551 | int av_tindex(AV* av)','name' => 'av_tindex'},'cophh_store_pvs' => {'text' => 'Like L, but takes a literal string instead of a | ||||||
2552 | string/length pair, and no precomputed hash. | ||||||
2553 | |||||||
2554 | NOTE: this function is experimental and may change or be | ||||||
2555 | removed without notice. | ||||||
2556 | |||||||
2557 | COPHH * cophh_store_pvs(const COPHH *cophh, | ||||||
2558 | const char *key, SV *value, | ||||||
2559 | 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 |
||||||
2560 | |||||||
2561 | NV scan_bin(const char* start, STRLEN len, | ||||||
2562 | STRLEN* retlen)','name' => 'scan_bin'},'Nullcv' => {'text' => 'Null CV pointer. | ||||||
2563 | |||||||
2564 | (deprecated - use C<(CV *)NULL> instead)','name' => 'Nullcv'},'PadlistREFCNT' => {'text' => 'The reference count of the padlist. Currently this is always 1. | ||||||
2565 | |||||||
2566 | NOTE: this function is experimental and may change or be | ||||||
2567 | removed without notice. | ||||||
2568 | |||||||
2569 | U32 PadlistREFCNT(PADLIST padlist)','name' => 'PadlistREFCNT'},'sv_catpvs_nomg' => {'text' => 'Like C |
||||||
2570 | string/length pair. | ||||||
2571 | |||||||
2572 | void sv_catpvs_nomg(SV* sv, const char* s)','name' => 'sv_catpvs_nomg'},'lex_bufutf8' => {'text' => 'Indicates whether the octets in the lexer buffer | ||||||
2573 | (Llinestr>) should be interpreted as the UTF-8 encoding | ||||||
2574 | of Unicode characters. If not, they should be interpreted as Latin-1 | ||||||
2575 | characters. This is analogous to the C |
||||||
2576 | |||||||
2577 | In UTF-8 mode, it is not guaranteed that the lexer buffer actually | ||||||
2578 | contains valid UTF-8. Lexing code must be robust in the face of invalid | ||||||
2579 | encoding. | ||||||
2580 | |||||||
2581 | The actual C |
||||||
2582 | is significant, but not the whole story regarding the input character | ||||||
2583 | encoding. Normally, when a file is being read, the scalar contains octets | ||||||
2584 | and its C |
||||||
2585 | UTF-8 if the C | ||||||
2586 | however, the scalar may have the C |
||||||
2587 | octets should be interpreted as UTF-8 unless the C | ||||||
2588 | is in effect. This logic may change in the future; use this function | ||||||
2589 | instead of implementing the logic yourself. | ||||||
2590 | |||||||
2591 | NOTE: this function is experimental and may change or be | ||||||
2592 | removed without notice. | ||||||
2593 | |||||||
2594 | bool lex_bufutf8()','name' => 'lex_bufutf8'},'MULTICALL' => {'text' => 'Make a lightweight callback. See L |
||||||
2595 | |||||||
2596 | MULTICALL;','name' => 'MULTICALL'},'debprofdump' => {'text' => '','name' => 'debprofdump'},'SvPVbyte' => {'text' => 'Like C |
||||||
2597 | |||||||
2598 | char* SvPVbyte(SV* sv, STRLEN len)','name' => 'SvPVbyte'},'savesharedpvs' => {'text' => 'A version of C |
||||||
2599 | which is shared between threads. | ||||||
2600 | |||||||
2601 | 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 | ||||||
2602 | instead of a string/length pair. | ||||||
2603 | |||||||
2604 | GV* gv_fetchmeth_pv(HV* stash, const char* name, | ||||||
2605 | 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. | ||||||
2606 | This is handled by C |
||||||
2607 | symbols unnecessarily.','name' => 'XS_INTERNAL'},'SAVETMPS' => {'text' => 'Opening bracket for temporaries on a callback. See C |
||||||
2608 | L |
||||||
2609 | |||||||
2610 | SAVETMPS;','name' => 'SAVETMPS'},'AvFILL' => {'text' => 'Same as C |
||||||
2611 | |||||||
2612 | int AvFILL(AV* av)','name' => 'AvFILL'},'SvPVutf8x' => {'text' => 'Like C |
||||||
2613 | Guarantees to evaluate sv only once; use the more efficient C |
||||||
2614 | otherwise. | ||||||
2615 | |||||||
2616 | char* SvPVutf8x(SV* sv, STRLEN len)','name' => 'SvPVutf8x'},'ORIGMARK' => {'text' => 'The original stack mark for the XSUB. See C |
||||||
2617 | possible to set C<*st> and C<*gvp> to the stash and GV associated with it. | ||||||
2618 | The flags in C |
||||||
2619 | |||||||
2620 | CV* sv_2cv(SV* sv, HV **const st, GV **const gvp, | ||||||
2621 | const I32 lref)','name' => 'sv_2cv'},'gp_free' => {'text' => '','name' => 'gp_free'},'SvPV_force_nomg' => {'text' => 'Like C |
||||||
2622 | |||||||
2623 | 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. | ||||||
2624 | Will also turn off the UTF-8 status. | ||||||
2625 | |||||||
2626 | void SvPOK_only(SV* sv)','name' => 'SvPOK_only'},'save_destructor_x' => {'text' => '','name' => 'save_destructor_x'},'sv_usepvn_mg' => {'text' => 'Like C |
||||||
2627 | |||||||
2628 | 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. | ||||||
2629 | The absolute value of C |
||||||
2630 | negative the key is assumed to be in UTF-8-encoded Unicode. If | ||||||
2631 | C |
||||||
2632 | there is no value in the hash associated with the given key, then one is | ||||||
2633 | created and a pointer to it is returned. The C |
||||||
2634 | assigned to. But always check that the | ||||||
2635 | return value is non-null before dereferencing it to an C |
||||||
2636 | |||||||
2637 | See L |
||||||
2638 | information on how to use this function on tied hashes. | ||||||
2639 | |||||||
2640 | SV** hv_fetch(HV *hv, const char *key, I32 klen, | ||||||
2641 | I32 lval)','name' => 'hv_fetch'},'sv_pvbyte' => {'text' => 'Use C |
||||||
2642 | |||||||
2643 | char* sv_pvbyte(SV *sv)','name' => 'sv_pvbyte'},'XCPT_TRY_START' => {'text' => 'Starts a try block. See L |
||||||
2644 | whatever was being referenced by the RV. This can almost be thought of | ||||||
2645 | as a reversal of C |
||||||
2646 | C |
||||||
2647 | (otherwise the decrementing is conditional on the reference count being | ||||||
2648 | different from one or the reference being a readonly SV). | ||||||
2649 | See C |
||||||
2650 | |||||||
2651 | void sv_unref_flags(SV *const ref, const U32 flags)','name' => 'sv_unref_flags'},'isPSXSPC' => {'text' => '(short for Posix Space) | ||||||
2652 | Starting in 5.18, this is identical (experimentally) in all its forms to the | ||||||
2653 | corresponding C |
||||||
2654 | may be backed out in 5.20 or 5.22 if field experience indicates that it | ||||||
2655 | was unwise.) | ||||||
2656 | The locale forms of this macro are identical to their corresponding | ||||||
2657 | C |
||||||
2658 | non-locale forms differ from their C |
||||||
2659 | C |
||||||
2660 | Otherwise they are identical. Thus this macro is analogous to what | ||||||
2661 | C |
||||||
2662 | See the L |
||||||
2663 | C |
||||||
2664 | C |
||||||
2665 | |||||||
2666 | bool isPSXSPC(char ch)','name' => 'isPSXSPC'},'SvRV' => {'text' => 'Dereferences an RV to return the SV. | ||||||
2667 | |||||||
2668 | 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. | ||||||
2669 | |||||||
2670 | SV* hv_scalar(HV *hv)','name' => 'hv_scalar'},'mg_copy' => {'text' => 'Copies the magic from one SV to another. See C |
||||||
2671 | |||||||
2672 | int mg_copy(SV *sv, SV *nsv, const char *key, | ||||||
2673 | I32 klen)','name' => 'mg_copy'},'save_I16' => {'text' => '','name' => 'save_I16'},'sv_rvweaken' => {'text' => 'Weaken a reference: set the C |
||||||
2674 | referred-to SV C |
||||||
2675 | push a back-reference to this RV onto the array of backreferences | ||||||
2676 | associated with that magic. If the RV is magical, set magic will be | ||||||
2677 | called after the RV is cleared. | ||||||
2678 | |||||||
2679 | SV* sv_rvweaken(SV *const sv)','name' => 'sv_rvweaken'},'grok_oct' => {'text' => 'converts a string representing an octal number to numeric form. | ||||||
2680 | |||||||
2681 | On entry I |
||||||
2682 | conversion flags, and I |
||||||
2683 | The scan stops at the end of the string, or the first invalid character. | ||||||
2684 | Unless C |
||||||
2685 | 8 or 9 will also trigger a warning. | ||||||
2686 | On return I<*len> is set to the length of the scanned string, | ||||||
2687 | and I<*flags> gives output flags. | ||||||
2688 | |||||||
2689 | If the value is <= UV_MAX it is returned as a UV, the output flags are clear, | ||||||
2690 | and nothing is written to I<*result>. If the value is > UV_MAX C |
||||||
2691 | returns UV_MAX, sets C |
||||||
2692 | and writes the value to I<*result> (or the value is discarded if I |
||||||
2693 | is NULL). | ||||||
2694 | |||||||
2695 | If C |
||||||
2696 | number may use \'_\' characters to separate digits. | ||||||
2697 | |||||||
2698 | UV grok_oct(const char* start, STRLEN* len_p, | ||||||
2699 | I32* flags, NV *result)','name' => 'grok_oct'},'MARK' => {'text' => 'Stack marker variable for the XSUB. See C |
||||||
2700 | (C<\\0>) and other binary data. The reference count for the SV is set to 1. | ||||||
2701 | Note that if C |
||||||
2702 | are responsible for ensuring that the source buffer is at least | ||||||
2703 | C |
||||||
2704 | undefined. | ||||||
2705 | |||||||
2706 | SV* newSVpvn(const char *const s, const STRLEN len)','name' => 'newSVpvn'},'scan_hex' => {'text' => 'For backwards compatibility. Use C |
||||||
2707 | |||||||
2708 | NV scan_hex(const char* start, STRLEN len, | ||||||
2709 | STRLEN* retlen)','name' => 'scan_hex'},'unpackstring' => {'text' => 'The engine implementing the unpack() Perl function. | ||||||
2710 | |||||||
2711 | Using the template pat..patend, this function unpacks the string | ||||||
2712 | s..strend into a number of mortal SVs, which it pushes onto the perl | ||||||
2713 | argument (@_) stack (so you will need to issue a C |
||||||
2714 | C |
||||||
2715 | pushed elements. | ||||||
2716 | |||||||
2717 | The strend and patend pointers should point to the byte following the last | ||||||
2718 | character of each string. | ||||||
2719 | |||||||
2720 | Although this function returns its values on the perl argument stack, it | ||||||
2721 | doesn\'t take any parameters from that stack (and thus in particular | ||||||
2722 | there\'s no need to do a PUSHMARK before calling it, unlike L for | ||||||
2723 | example). | ||||||
2724 | |||||||
2725 | I32 unpackstring(const char *pat, | ||||||
2726 | const char *patend, const char *s, | ||||||
2727 | const char *strend, U32 flags)','name' => 'unpackstring'},'av_extend' => {'text' => 'Pre-extend an array. The C |
||||||
2728 | extended. | ||||||
2729 | |||||||
2730 | 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 |
||||||
2731 | |||||||
2732 | You may call C |
||||||
2733 | iterator currently points to, without losing your place or invalidating your | ||||||
2734 | iterator. Note that in this case the current entry is deleted from the hash | ||||||
2735 | with your iterator holding the last reference to it. Your iterator is flagged | ||||||
2736 | to free the entry on the next call to C |
||||||
2737 | your iterator immediately else the entry will leak - call C |
||||||
2738 | trigger the resource deallocation. | ||||||
2739 | |||||||
2740 | HE* hv_iternext(HV *hv)','name' => 'hv_iternext'},'SVt_REGEXP' => {'text' => 'Type flag for regular expressions. See L.','name' => 'SVt_REGEXP'},'hv_store_ent' => {'text' => 'Stores C |
||||||
2741 | parameter is the precomputed hash value; if it is zero then Perl will | ||||||
2742 | compute it. The return value is the new hash entry so created. It will be | ||||||
2743 | NULL if the operation failed or if the value did not need to be actually | ||||||
2744 | stored within the hash (as in the case of tied hashes). Otherwise the | ||||||
2745 | contents of the return value can be accessed using the C |
||||||
2746 | described here. Note that the caller is responsible for suitably | ||||||
2747 | incrementing the reference count of C |
||||||
2748 | decrementing it if the function returned NULL. Effectively a successful | ||||||
2749 | hv_store_ent takes ownership of one reference to C |
||||||
2750 | usually what you want; a newly created SV has a reference count of one, so | ||||||
2751 | if all your code does is create SVs then store them in a hash, hv_store | ||||||
2752 | will own the only reference to the new SV, and your code doesn\'t need to do | ||||||
2753 | anything further to tidy up. Note that hv_store_ent only reads the C |
||||||
2754 | unlike C |
||||||
2755 | reference count on C |
||||||
2756 | is not implemented as a call to hv_store_ent, and does not create a temporary | ||||||
2757 | SV for the key, so if your key data is not already in SV form then use | ||||||
2758 | hv_store in preference to hv_store_ent. | ||||||
2759 | |||||||
2760 | See L |
||||||
2761 | information on how to use this function on tied hashes. | ||||||
2762 | |||||||
2763 | 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 |
||||||
2764 | |||||||
2765 | HV* gv_stashsv(SV* sv, I32 flags)','name' => 'gv_stashsv'},'newXSproto' => {'text' => 'Used by C |
||||||
2766 | the subs.','name' => 'newXSproto'},'form' => {'text' => 'Takes a sprintf-style format pattern and conventional | ||||||
2767 | (non-SV) arguments and returns the formatted string. | ||||||
2768 | |||||||
2769 | (char *) Perl_form(pTHX_ const char* pat, ...) | ||||||
2770 | |||||||
2771 | can be used any place a string (char *) is required: | ||||||
2772 | |||||||
2773 | char * s = Perl_form("%d.%d",major,minor); | ||||||
2774 | |||||||
2775 | Uses a single private buffer so if you want to format several strings you | ||||||
2776 | must explicitly copy the earlier strings away (and free the copies when you | ||||||
2777 | are done). | ||||||
2778 | |||||||
2779 | 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 |
||||||
2780 | UTF-8 string, false otherwise. If C |
||||||
2781 | using C |
||||||
2782 | terminating NUL byte). Note that all characters being ASCII constitute \'a | ||||||
2783 | valid UTF-8 string\'. | ||||||
2784 | |||||||
2785 | See also L(), L(), and L(). | ||||||
2786 | |||||||
2787 | bool is_utf8_string(const U8 *s, STRLEN len)','name' => 'is_utf8_string'},'PadnamelistARRAY' => {'text' => 'The C array of pad names. | ||||||
2788 | |||||||
2789 | NOTE: this function is experimental and may change or be | ||||||
2790 | removed without notice. | ||||||
2791 | |||||||
2792 | PADNAME ** PadnamelistARRAY(PADNAMELIST pnl)','name' => 'PadnamelistARRAY'},'croak_xs_usage' => {'text' => 'A specialised variant of C |
||||||
2793 | |||||||
2794 | croak_xs_usage(cv, "eee_yow"); | ||||||
2795 | |||||||
2796 | works out the package name and subroutine name from C |
||||||
2797 | C |
||||||
2798 | |||||||
2799 | Perl_croak(aTHX_ "Usage: %"SVf"::%"SVf"(%s)", "ouch" "awk", "eee_yow"); | ||||||
2800 | |||||||
2801 | void croak_xs_usage(const CV *const cv, | ||||||
2802 | const char *const params)','name' => 'croak_xs_usage'},'sv_insert' => {'text' => 'Inserts a string at the specified offset/length within the SV. Similar to | ||||||
2803 | the Perl substr() function. Handles get magic. | ||||||
2804 | |||||||
2805 | void sv_insert(SV *const bigstr, const STRLEN offset, | ||||||
2806 | const STRLEN len, | ||||||
2807 | const char *const little, | ||||||
2808 | const STRLEN littlelen)','name' => 'sv_insert'},'SvPOK' => {'text' => 'Returns a U32 value indicating whether the SV contains a character | ||||||
2809 | string. | ||||||
2810 | |||||||
2811 | U32 SvPOK(SV* sv)','name' => 'SvPOK'},'sv_destroyable' => {'text' => 'Dummy routine which reports that object can be destroyed when there is no | ||||||
2812 | sharing module present. It ignores its single SV argument, and returns | ||||||
2813 | \'true\'. Exists to avoid test for a NULL function pointer and because it | ||||||
2814 | could potentially warn under some level of strict-ness. | ||||||
2815 | |||||||
2816 | bool sv_destroyable(SV *sv)','name' => 'sv_destroyable'},'save_aelem_flags' => {'text' => '','name' => 'save_aelem_flags'},'PadlistNAMES' => {'text' => 'The names associated with pad entries. | ||||||
2817 | |||||||
2818 | NOTE: this function is experimental and may change or be | ||||||
2819 | removed without notice. | ||||||
2820 | |||||||
2821 | PADNAMELIST * PadlistNAMES(PADLIST padlist)','name' => 'PadlistNAMES'},'XS' => {'text' => 'Macro to declare an XSUB and its C parameter list. This is handled by | ||||||
2822 | C |
||||||
2823 | bytes to be copied. If the C |
||||||
2824 | undefined. Does not handle \'set\' magic. See C |
||||||
2825 | |||||||
2826 | void sv_setpvn(SV *const sv, const char *const ptr, | ||||||
2827 | const STRLEN len)','name' => 'sv_setpvn'},'mg_magical' => {'text' => 'Turns on the magical status of an SV. See C |
||||||
2828 | |||||||
2829 | void mg_magical(SV* sv)','name' => 'mg_magical'},'op_linklist' => {'text' => 'This function is the implementation of the L macro. It should | ||||||
2830 | not be called directly. | ||||||
2831 | |||||||
2832 | OP* op_linklist(OP *o)','name' => 'op_linklist'},'newSVrv' => {'text' => 'Creates a new SV for the existing RV, C |
||||||
2833 | RV then it will be upgraded to one. If C |
||||||
2834 | SV will be blessed in the specified package. The new SV is returned and its | ||||||
2835 | reference count is 1. The reference count 1 is owned by C |
||||||
2836 | |||||||
2837 | SV* newSVrv(SV *const rv, | ||||||
2838 | const char *const classname)','name' => 'newSVrv'},'cast_i32' => {'text' => '','name' => 'cast_i32'},'strnEQ' => {'text' => 'Test two strings to see if they are equal. The C |
||||||
2839 | the number of bytes to compare. Returns true or false. (A wrapper for | ||||||
2840 | C |
||||||
2841 | |||||||
2842 | bool strnEQ(char* s1, char* s2, STRLEN len)','name' => 'strnEQ'},'sv_dup_inc' => {'text' => '','name' => 'sv_dup_inc'},'newMYSUB' => {'text' => '','name' => 'newMYSUB'},'PoisonWith' => {'text' => 'Fill up memory with a byte pattern (a byte repeated over and over | ||||||
2843 | again) that hopefully catches attempts to access uninitialized memory. | ||||||
2844 | |||||||
2845 | void PoisonWith(void* dest, int nitems, type, | ||||||
2846 | U8 byte)','name' => 'PoisonWith'},'av_create_and_unshift_one' => {'text' => 'Unshifts an SV onto the beginning of the array, creating the array if | ||||||
2847 | necessary. | ||||||
2848 | A small internal helper function to remove a commonly duplicated idiom. | ||||||
2849 | |||||||
2850 | NOTE: this function is experimental and may change or be | ||||||
2851 | removed without notice. | ||||||
2852 | |||||||
2853 | SV** av_create_and_unshift_one(AV **const avp, | ||||||
2854 | SV *const val)','name' => 'av_create_and_unshift_one'},'SvNIOK_off' => {'text' => 'Unsets the NV/IV status of an SV. | ||||||
2855 | |||||||
2856 | void SvNIOK_off(SV* sv)','name' => 'SvNIOK_off'},'bytes_cmp_utf8' => {'text' => 'Compares the sequence of characters (stored as octets) in C, C |
||||||
2857 | sequence of characters (stored as UTF-8) in C, C |
||||||
2858 | equal, -1 or -2 if the first string is less than the second string, +1 or +2 | ||||||
2859 | if the first string is greater than the second string. | ||||||
2860 | |||||||
2861 | -1 or +1 is returned if the shorter string was identical to the start of the | ||||||
2862 | longer string. -2 or +2 is returned if the was a difference between characters | ||||||
2863 | within the strings. | ||||||
2864 | |||||||
2865 | int bytes_cmp_utf8(const U8 *b, STRLEN blen, | ||||||
2866 | 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 | ||||||
2867 | of a string/length pair. | ||||||
2868 | |||||||
2869 | PADOFFSET pad_findmy_pvs(const char *name, U32 flags)','name' => 'pad_findmy_pvs'},'sv_magic' => {'text' => 'Adds magic to an SV. First upgrades C |
||||||
2870 | necessary, then adds a new magic item of type C |
||||||
2871 | magic list. | ||||||
2872 | |||||||
2873 | See C |
||||||
2874 | handling of the C |
||||||
2875 | |||||||
2876 | You need to use C |
||||||
2877 | to add more than one instance of the same \'how\'. | ||||||
2878 | |||||||
2879 | void sv_magic(SV *const sv, SV *const obj, | ||||||
2880 | const int how, const char *const name, | ||||||
2881 | const I32 namlen)','name' => 'sv_magic'},'sv_utf8_upgrade_flags' => {'text' => 'Converts the PV of an SV to its UTF-8-encoded form. | ||||||
2882 | Forces the SV to string form if it is not already. | ||||||
2883 | Always sets the SvUTF8 flag to avoid future validity checks even | ||||||
2884 | if all the bytes are invariant in UTF-8. | ||||||
2885 | If C |
||||||
2886 | will C |
||||||
2887 | Returns the number of bytes in the converted string | ||||||
2888 | C |
||||||
2889 | C |
||||||
2890 | |||||||
2891 | This is not a general purpose byte encoding to Unicode interface: | ||||||
2892 | use the Encode extension for that. | ||||||
2893 | |||||||
2894 | STRLEN sv_utf8_upgrade_flags(SV *const sv, | ||||||
2895 | 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 |
||||||
2896 | string/length pair. | ||||||
2897 | |||||||
2898 | void sv_catpvs_mg(SV* sv, const char* s)','name' => 'sv_catpvs_mg'},'sv_setpvs_mg' => {'text' => 'Like C |
||||||
2899 | string/length pair. | ||||||
2900 | |||||||
2901 | 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 | ||||||
2902 | return value. The macro doesn\'t need to return a meaningful value. | ||||||
2903 | |||||||
2904 | 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 |
||||||
2905 | but will be a C |
||||||
2906 | code. The state op is populated from L (or L). | ||||||
2907 | If I | ||||||
2908 | the state op; this function takes ownership of the memory pointed at by | ||||||
2909 | I | ||||||
2910 | for the state op. | ||||||
2911 | |||||||
2912 | If I |
||||||
2913 | combined with I |
||||||
2914 | is consumed by this function and becomes part of the returned op tree. | ||||||
2915 | |||||||
2916 | OP * newSTATEOP(I32 flags, char *label, OP *o)','name' => 'newSTATEOP'},'my_fork' => {'text' => '','name' => 'my_fork'},'isBLANK' => {'text' => 'Returns a boolean indicating whether the specified character is a | ||||||
2917 | character considered to be a blank, analogous to C |
||||||
2918 | See the L |
||||||
2919 | C |
||||||
2920 | C |
||||||
2921 | platforms do not have the C library routine C |
||||||
2922 | variants whose names contain C |
||||||
2923 | without. | ||||||
2924 | |||||||
2925 | bool isBLANK(char ch)','name' => 'isBLANK'},'SvROK' => {'text' => 'Tests if the SV is an RV. | ||||||
2926 | |||||||
2927 | U32 SvROK(SV* sv)','name' => 'SvROK'},'sv_unref' => {'text' => 'Unsets the RV status of the SV, and decrements the reference count of | ||||||
2928 | whatever was being referenced by the RV. This can almost be thought of | ||||||
2929 | as a reversal of C |
||||||
2930 | being zero. See C |
||||||
2931 | |||||||
2932 | 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 | ||||||
2933 | string/length pair, and no precomputed hash. | ||||||
2934 | |||||||
2935 | NOTE: this function is experimental and may change or be | ||||||
2936 | removed without notice. | ||||||
2937 | |||||||
2938 | SV * cophh_fetch_pvs(const COPHH *cophh, | ||||||
2939 | 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. | ||||||
2940 | Does not handle \'set\' magic. See also C |
||||||
2941 | |||||||
2942 | void sv_setnv(SV *const sv, const NV num)','name' => 'sv_setnv'},'SvREFCNT_inc_simple_NN' => {'text' => 'Same as SvREFCNT_inc_simple, but can only be used if you know I |
||||||
2943 | is not NULL. Since we don\'t have to check the NULLness, it\'s faster | ||||||
2944 | and smaller. | ||||||
2945 | |||||||
2946 | 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. | ||||||
2947 | |||||||
2948 | HV* newHV()','name' => 'newHV'},'SVt_PVFM' => {'text' => 'Type flag for formats. See L.','name' => 'SVt_PVFM'},'gv_dump' => {'text' => '','name' => 'gv_dump'},'strNE' => {'text' => 'Test two strings to see if they are different. Returns true or | ||||||
2949 | false. | ||||||
2950 | |||||||
2951 | 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 |
||||||
2952 | returned C |
||||||
2953 | information returned to Perl by C |
||||||
2954 | stack frame, so C |
||||||
2955 | immediately-surrounding Perl code. | ||||||
2956 | |||||||
2957 | This function skips over the automatic calls to C<&DB::sub> made on the | ||||||
2958 | behalf of the debugger. If the stack frame requested was a sub called by | ||||||
2959 | C |
||||||
2960 | C |
||||||
2961 | site. If I |
||||||
2962 | frame for the sub call itself. | ||||||
2963 | |||||||
2964 | const PERL_CONTEXT * caller_cx( | ||||||
2965 | I32 level, | ||||||
2966 | const PERL_CONTEXT **dbcxp | ||||||
2967 | )','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 |
||||||
2968 | |||||||
2969 | NOTE: this function is experimental and may change or be | ||||||
2970 | removed without notice. | ||||||
2971 | |||||||
2972 | COPHH * cophh_copy(COPHH *cophh)','name' => 'cophh_copy'},'sv_pvutf8n_force' => {'text' => 'The backend for the C |
||||||
2973 | instead. | ||||||
2974 | |||||||
2975 | 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 |
||||||
2976 | |||||||
2977 | void SvNV_set(SV* sv, NV val)','name' => 'SvNV_set'},'die_sv' => {'text' => 'Behaves the same as L, except for the return type. | ||||||
2978 | It should be used only where the C |
||||||
2979 | The function never actually returns. | ||||||
2980 | |||||||
2981 | OP * die_sv(SV *baseex)','name' => 'die_sv'},'newAV' => {'text' => 'Creates a new AV. The reference count is set to 1. | ||||||
2982 | |||||||
2983 | Perl equivalent: C |
||||||
2984 | |||||||
2985 | AV* newAV()','name' => 'newAV'},'bytes_from_utf8' => {'text' => 'Converts a string C |
||||||
2986 | Unlike L but like L, returns a pointer to | ||||||
2987 | the newly-created string, and updates C |
||||||
2988 | length. Returns the original string if no conversion occurs, C |
||||||
2989 | is unchanged. Do nothing if C |
||||||
2990 | 0 if C |
||||||
2991 | in utf8 (i.e., US-ASCII on non-EBCDIC machines). | ||||||
2992 | |||||||
2993 | NOTE: this function is experimental and may change or be | ||||||
2994 | removed without notice. | ||||||
2995 | |||||||
2996 | U8* bytes_from_utf8(const U8 *s, STRLEN *len, | ||||||
2997 | bool *is_utf8)','name' => 'bytes_from_utf8'},'SvPV_nomg_nolen' => {'text' => 'Like C |
||||||
2998 | |||||||
2999 | 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 | ||||||
3000 | into the array, so they may be freed after the call to av_make. The new AV | ||||||
3001 | will have a reference count of 1. | ||||||
3002 | |||||||
3003 | Perl equivalent: C |
||||||
3004 | |||||||
3005 | 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 |
||||||
3006 | for a version which guarantees to evaluate sv only once. | ||||||
3007 | |||||||
3008 | 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 |
||||||
3009 | and returns the modified hash. The returned hash pointer is in general | ||||||
3010 | not the same as the hash pointer that was passed in. The input hash is | ||||||
3011 | consumed by the function, and the pointer to it must not be subsequently | ||||||
3012 | used. Use L if you need both hashes. | ||||||
3013 | |||||||
3014 | The key is specified by I |
||||||
3015 | C |
||||||
3016 | otherwise they are interpreted as Latin-1. I |
||||||
3017 | hash of the key string, or zero if it has not been precomputed. | ||||||
3018 | |||||||
3019 | I |
||||||
3020 | by this function, which thus does not take ownership of any reference | ||||||
3021 | to it, and later changes to the scalar will not be reflected in the | ||||||
3022 | value visible in the cop hints hash. Complex types of scalar will not | ||||||
3023 | be stored with referential integrity, but will be coerced to strings. | ||||||
3024 | |||||||
3025 | NOTE: this function is experimental and may change or be | ||||||
3026 | removed without notice. | ||||||
3027 | |||||||
3028 | COPHH * cophh_store_pvn(COPHH *cophh, const char *keypv, | ||||||
3029 | STRLEN keylen, U32 hash, | ||||||
3030 | SV *value, U32 flags)','name' => 'cophh_store_pvn'},'perl_run' => {'text' => 'Tells a Perl interpreter to run. See L |
||||||
3031 | |||||||
3032 | int perl_run(PerlInterpreter *my_perl)','name' => 'perl_run'},'mess_nocontext' => {'text' => '','name' => 'mess_nocontext'},'sv_insert_flags' => {'text' => 'Same as C |
||||||
3033 | C |
||||||
3034 | |||||||
3035 | void sv_insert_flags(SV *const bigstr, | ||||||
3036 | const STRLEN offset, | ||||||
3037 | const STRLEN len, | ||||||
3038 | const char *const little, | ||||||
3039 | const STRLEN littlelen, | ||||||
3040 | const U32 flags)','name' => 'sv_insert_flags'},'OP_CLASS' => {'text' => 'Return the class of the provided OP: that is, which of the *OP | ||||||
3041 | structures it uses. For core ops this currently gets the information out | ||||||
3042 | of PL_opargs, which does not always accurately reflect the type used. | ||||||
3043 | For custom ops the type is returned from the registration, and it is up | ||||||
3044 | to the registree to ensure it is accurate. The value returned will be | ||||||
3045 | one of the OA_* constants from op.h. | ||||||
3046 | |||||||
3047 | U32 OP_CLASS(OP *o)','name' => 'OP_CLASS'},'SvPVutf8_nolen' => {'text' => 'Like C |
||||||
3048 | |||||||
3049 | char* SvPVutf8_nolen(SV* sv)','name' => 'SvPVutf8_nolen'},'SvRXOK' => {'text' => 'Returns a boolean indicating whether the SV (or the one it references) | ||||||
3050 | is a REGEXP. | ||||||
3051 | |||||||
3052 | If you want to do something with the REGEXP* later use SvRX instead | ||||||
3053 | and check for NULL. | ||||||
3054 | |||||||
3055 | 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. | ||||||
3056 | Does not handle \'set\' magic. See C |
||||||
3057 | |||||||
3058 | 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. | ||||||
3059 | Use the C |
||||||
3060 | instead use an in-line version. | ||||||
3061 | |||||||
3062 | 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 | ||||||
3063 | absolute value of C |
||||||
3064 | negative the key is assumed to be in UTF-8-encoded Unicode. | ||||||
3065 | |||||||
3066 | bool hv_exists(HV *hv, const char *key, I32 klen)','name' => 'hv_exists'},'my_popen' => {'text' => '','name' => 'my_popen'},'mg_length' => {'text' => 'This function is deprecated. | ||||||
3067 | |||||||
3068 | It reports on the SV\'s length in bytes, calling length magic if available, | ||||||
3069 | but does not set the UTF8 flag on the sv. It will fall back to \'get\' | ||||||
3070 | magic if there is no \'length\' magic, but with no indication as to | ||||||
3071 | whether it called \'get\' magic. It assumes the sv is a PVMG or | ||||||
3072 | higher. Use sv_len() instead. | ||||||
3073 | |||||||
3074 | 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 |
||||||
3075 | the opcode. I |
||||||
3076 | C |
||||||
3077 | bits, the eight bits of C |
||||||
3078 | is automatically set. I |
||||||
3079 | child of the unary op; it is consumed by this function and become part | ||||||
3080 | of the constructed op tree. | ||||||
3081 | |||||||
3082 | 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, | ||||||
3083 | specifies the structure contains an C |
||||||
3084 | 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 | ||||||
3085 | reference to a pad element. I |
||||||
3086 | eight bits of C |
||||||
3087 | is populated with I |
||||||
3088 | to it. | ||||||
3089 | |||||||
3090 | This function only exists if Perl has been compiled to use ithreads. | ||||||
3091 | |||||||
3092 | OP * newPADOP(I32 type, I32 flags, SV *sv)','name' => 'newPADOP'},'utf8_length' => {'text' => 'Return the length of the UTF-8 char encoded string C |
||||||
3093 | Stops at C |
||||||
3094 | up past C |
||||||
3095 | |||||||
3096 | STRLEN utf8_length(const U8* s, const U8 *e)','name' => 'utf8_length'},'dowantarray' => {'text' => '','name' => 'dowantarray'},'my_cxt_init' => {'text' => '','name' => 'my_cxt_init'},'SvIOK_only_UV' => {'text' => 'Tells an SV that it is an unsigned integer and disables all other OK bits. | ||||||
3097 | |||||||
3098 | 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' => 'void sv_vcatpvfn(SV *const sv, const char *const pat, | ||||||
3099 | const STRLEN patlen, | ||||||
3100 | va_list *const args, | ||||||
3101 | SV **const svargs, const I32 svmax, | ||||||
3102 | bool *const maybe_tainted)','name' => 'sv_vcatpvfn'},'BhkDISABLE' => {'text' => 'Temporarily disable an entry in this BHK structure, by clearing the | ||||||
3103 | appropriate flag. I |
||||||
3104 | entry to disable. | ||||||
3105 | |||||||
3106 | NOTE: this function is experimental and may change or be | ||||||
3107 | removed without notice. | ||||||
3108 | |||||||
3109 | void BhkDISABLE(BHK *hk, which)','name' => 'BhkDISABLE'},'croak_no_modify' => {'text' => 'Exactly equivalent to C |
||||||
3110 | terser object code than using C |
||||||
3111 | paths reduces CPU cache pressure. | ||||||
3112 | |||||||
3113 | 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 |
||||||
3114 | which can\'t cope with complex macro expressions. Always use the macro | ||||||
3115 | instead. | ||||||
3116 | |||||||
3117 | 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 |
||||||
3118 | bytes of preallocated string space the SV should have. An extra byte for a | ||||||
3119 | trailing NUL is also reserved. (SvPOK is not set for the SV even if string | ||||||
3120 | space is allocated.) The reference count for the new SV is set to 1. | ||||||
3121 | |||||||
3122 | In 5.9.3, newSV() replaces the older NEWSV() API, and drops the first | ||||||
3123 | parameter, I |
||||||
3124 | This aid has been superseded by a new build option, PERL_MEM_LOG (see | ||||||
3125 | L |
||||||
3126 | modules supporting older perls. | ||||||
3127 | |||||||
3128 | 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 | ||||||
3129 | to its length. May cause the SV to be upgraded to UTF-8 as a side-effect. | ||||||
3130 | |||||||
3131 | Usually accessed via the C |
||||||
3132 | |||||||
3133 | char* sv_2pvutf8(SV *sv, STRLEN *const lp)','name' => 'sv_2pvutf8'},'dITEMS' => {'text' => 'Sets up the C |
||||||
3134 | This is usually handled automatically by C |
||||||
3135 | |||||||
3136 | dITEMS;','name' => 'dITEMS'},'save_scalar' => {'text' => '','name' => 'save_scalar'},'newSUB' => {'text' => '','name' => 'newSUB'},'isGRAPH' => {'text' => 'Returns a boolean indicating whether the specified character is a | ||||||
3137 | graphic character, analogous to C |
||||||
3138 | See the L |
||||||
3139 | C |
||||||
3140 | C |
||||||
3141 | |||||||
3142 | bool isGRAPH(char ch)','name' => 'isGRAPH'},'pad_findmy_pv' => {'text' => 'Exactly like L, but takes a nul-terminated string | ||||||
3143 | instead of a string/length pair. | ||||||
3144 | |||||||
3145 | 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 |
||||||
3146 | See C |
||||||
3147 | |||||||
3148 | PUTBACK;','name' => 'PUTBACK'},'dAXMARK' => {'text' => 'Sets up the C |
||||||
3149 | This is usually handled automatically by C |
||||||
3150 | |||||||
3151 | dAXMARK;','name' => 'dAXMARK'},'sv_2uv_flags' => {'text' => 'Return the unsigned integer value of an SV, doing any necessary string | ||||||
3152 | conversion. If flags includes SV_GMAGIC, does an mg_get() first. | ||||||
3153 | Normally used via the C |
||||||
3154 | |||||||
3155 | UV sv_2uv_flags(SV *const sv, const I32 flags)','name' => 'sv_2uv_flags'},'G_SCALAR' => {'text' => 'Used to indicate scalar context. See C |
||||||
3156 | L |
||||||
3157 | currently-compiling padlist to point to the new padlist. The following | ||||||
3158 | flags can be OR\'ed together: | ||||||
3159 | |||||||
3160 | padnew_CLONE this pad is for a cloned CV | ||||||
3161 | padnew_SAVE save old globals on the save stack | ||||||
3162 | padnew_SAVESUB also save extra stuff for start of sub | ||||||
3163 | |||||||
3164 | PADLIST * pad_new(int flags)','name' => 'pad_new'},'SvTAINTED_off' => {'text' => 'Untaints an SV. Be I |
||||||
3165 | some of Perl\'s fundamental security features. XS module authors should not | ||||||
3166 | use this function unless they fully understand all the implications of | ||||||
3167 | unconditionally untainting the value. Untainting should be done in the | ||||||
3168 | standard perl fashion, via a carefully crafted regexp, rather than directly | ||||||
3169 | untainting variables. | ||||||
3170 | |||||||
3171 | void SvTAINTED_off(SV* sv)','name' => 'SvTAINTED_off'},'require_pv' => {'text' => 'Tells Perl to C |
||||||
3172 | analogous to the Perl code C |
||||||
3173 | implemented that way; consider using load_module instead. | ||||||
3174 | |||||||
3175 | NOTE: the perl_ form of this function is deprecated. | ||||||
3176 | |||||||
3177 | 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. | ||||||
3178 | |||||||
3179 | 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 | ||||||
3180 | SV, then copies across as much information as possible from the old body. | ||||||
3181 | It croaks if the SV is already in a more complex form than requested. You | ||||||
3182 | generally want to use the C |
||||||
3183 | before calling C |
||||||
3184 | C |
||||||
3185 | |||||||
3186 | 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 | ||||||
3187 | uppercase character, analogous to C |
||||||
3188 | See the L |
||||||
3189 | C |
||||||
3190 | C |
||||||
3191 | |||||||
3192 | bool isUPPER(char ch)','name' => 'isUPPER'},'XopENABLE' => {'text' => 'Reenable a member of the XOP which has been disabled. | ||||||
3193 | |||||||
3194 | void XopENABLE(XOP *xop, which)','name' => 'XopENABLE'},'lex_peek_unichar' => {'text' => 'Looks ahead one (Unicode) character in the text currently being lexed. | ||||||
3195 | Returns the codepoint (unsigned integer value) of the next character, | ||||||
3196 | or -1 if lexing has reached the end of the input text. To consume the | ||||||
3197 | peeked character, use L. | ||||||
3198 | |||||||
3199 | If the next character is in (or extends into) the next chunk of input | ||||||
3200 | text, the next chunk will be read in. Normally the current chunk will be | ||||||
3201 | discarded at the same time, but if I |
||||||
3202 | then the current chunk will not be discarded. | ||||||
3203 | |||||||
3204 | If the input is being interpreted as UTF-8 and a UTF-8 encoding error | ||||||
3205 | is encountered, an exception is generated. | ||||||
3206 | |||||||
3207 | NOTE: this function is experimental and may change or be | ||||||
3208 | removed without notice. | ||||||
3209 | |||||||
3210 | I32 lex_peek_unichar(U32 flags)','name' => 'lex_peek_unichar'},'sv_setsv_mg' => {'text' => 'Like C |
||||||
3211 | |||||||
3212 | 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 | ||||||
3213 | lowercase character, analogous to C |
||||||
3214 | See the L |
||||||
3215 | C |
||||||
3216 | C |
||||||
3217 | |||||||
3218 | bool isLOWER(char ch)','name' => 'isLOWER'},'hv_iterkey' => {'text' => 'Returns the key from the current position of the hash iterator. See | ||||||
3219 | C |
||||||
3220 | |||||||
3221 | 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 | ||||||
3222 | B |
||||||
3223 | |||||||
3224 | U32 SvNOKp(SV* sv)','name' => 'SvNOKp'},'PadnamePV' => {'text' => 'The name stored in the pad name struct. This returns NULL for a target or | ||||||
3225 | GV slot. | ||||||
3226 | |||||||
3227 | NOTE: this function is experimental and may change or be | ||||||
3228 | removed without notice. | ||||||
3229 | |||||||
3230 | char * PadnamePV(PADNAME pn)','name' => 'PadnamePV'},'nothreadhook' => {'text' => 'Stub that provides thread hook for perl_destruct when there are | ||||||
3231 | no threads. | ||||||
3232 | |||||||
3233 | int nothreadhook()','name' => 'nothreadhook'},'utf8_to_uvchr' => {'text' => 'DEPRECATED! | ||||||
3234 | |||||||
3235 | Returns the native code point of the first character in the string C |
||||||
3236 | which is assumed to be in UTF-8 encoding; C |
||||||
3237 | length, in bytes, of that character. | ||||||
3238 | |||||||
3239 | Some, but not all, UTF-8 malformations are detected, and in fact, some | ||||||
3240 | malformed input could cause reading beyond the end of the input buffer, which | ||||||
3241 | is why this function is deprecated. Use L instead. | ||||||
3242 | |||||||
3243 | If C |
||||||
3244 | enabled, zero is returned and C<*retlen> is set (if C |
||||||
3245 | NULL) to -1. If those warnings are off, the computed value if well-defined (or | ||||||
3246 | the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen> | ||||||
3247 | is set (if C |
||||||
3248 | next possible position in C |
||||||
3249 | See L for details on when the REPLACEMENT CHARACTER is returned. | ||||||
3250 | |||||||
3251 | UV utf8_to_uvchr(const U8 *s, STRLEN *retlen)','name' => 'utf8_to_uvchr'},'bytes_to_utf8' => {'text' => 'Converts a string C |
||||||
3252 | UTF-8. | ||||||
3253 | Returns a pointer to the newly-created string, and sets C |
||||||
3254 | reflect the new length in bytes. | ||||||
3255 | |||||||
3256 | A NUL character will be written after the end of the string. | ||||||
3257 | |||||||
3258 | If you want to convert to UTF-8 from encodings other than | ||||||
3259 | the native (Latin1 or EBCDIC), | ||||||
3260 | see L(). | ||||||
3261 | |||||||
3262 | NOTE: this function is experimental and may change or be | ||||||
3263 | removed without notice. | ||||||
3264 | |||||||
3265 | U8* bytes_to_utf8(const U8 *s, STRLEN *len)','name' => 'bytes_to_utf8'},'HvENAMELEN' => {'text' => 'Returns the length of the stash\'s effective name. | ||||||
3266 | |||||||
3267 | STRLEN HvENAMELEN(HV *stash)','name' => 'HvENAMELEN'},'SvIsCOW_shared_hash' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write shared hash key | ||||||
3268 | scalar. | ||||||
3269 | |||||||
3270 | bool SvIsCOW_shared_hash(SV* sv)','name' => 'SvIsCOW_shared_hash'},'start_subparse' => {'text' => '','name' => 'start_subparse'},'mg_size' => {'text' => '','name' => 'mg_size'},'PadnamelistMAX' => {'text' => 'The index of the last pad name. | ||||||
3271 | |||||||
3272 | NOTE: this function is experimental and may change or be | ||||||
3273 | removed without notice. | ||||||
3274 | |||||||
3275 | SSize_t PadnamelistMAX(PADNAMELIST pnl)','name' => 'PadnamelistMAX'},'mg_free_type' => {'text' => 'Remove any magic of type I |
||||||
3276 | |||||||
3277 | void mg_free_type(SV *sv, int how)','name' => 'mg_free_type'},'sv_catsv_nomg' => {'text' => 'Like C |
||||||
3278 | |||||||
3279 | void sv_catsv_nomg(SV* dsv, SV* ssv)','name' => 'sv_catsv_nomg'},'sv_setuv_mg' => {'text' => 'Like C |
||||||
3280 | |||||||
3281 | 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 | ||||||
3282 | handled automatically by C |
||||||
3283 | currently-executing function. Returns the offset in the current pad, | ||||||
3284 | or C |
||||||
3285 | the global one should be used instead). | ||||||
3286 | L is likely to be more convenient. | ||||||
3287 | |||||||
3288 | NOTE: the perl_ form of this function is deprecated. | ||||||
3289 | |||||||
3290 | PADOFFSET find_rundefsvoffset()','name' => 'find_rundefsvoffset'},'sv_setpv' => {'text' => 'Copies a string into an SV. The string must be null-terminated. Does not | ||||||
3291 | handle \'set\' magic. See C |
||||||
3292 | |||||||
3293 | 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 | ||||||
3294 | statement or a declaration that has compile-time effect, and may include | ||||||
3295 | optional labels. It is up to the caller to ensure that the dynamic | ||||||
3296 | parser state (L et al) is correctly set to reflect the source | ||||||
3297 | of the code to be parsed and the lexical context for the statement. | ||||||
3298 | |||||||
3299 | The op tree representing the statement is returned. This may be a | ||||||
3300 | null pointer if the statement is null, for example if it was actually | ||||||
3301 | a subroutine definition (which has compile-time side effects). If not | ||||||
3302 | null, it will be the result of a L call, normally including | ||||||
3303 | a C |
||||||
3304 | |||||||
3305 | If an error occurs in parsing or compilation, in most cases a valid op | ||||||
3306 | tree (most likely null) is returned anyway. The error is reflected in | ||||||
3307 | the parser state, normally resulting in a single exception at the top | ||||||
3308 | level of parsing which covers all the compilation errors that occurred. | ||||||
3309 | Some compilation errors, however, will throw an exception immediately. | ||||||
3310 | |||||||
3311 | The I |
||||||
3312 | be zero. | ||||||
3313 | |||||||
3314 | NOTE: this function is experimental and may change or be | ||||||
3315 | removed without notice. | ||||||
3316 | |||||||
3317 | OP * parse_fullstmt(U32 flags)','name' => 'parse_fullstmt'},'atfork_lock' => {'text' => '','name' => 'atfork_lock'},'gv_fetchmethod' => {'text' => 'See L. | ||||||
3318 | |||||||
3319 | 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 | ||||||
3320 | indicated number of bytes (remember to reserve space for an extra trailing | ||||||
3321 | NUL character). Calls C |
||||||
3322 | Returns a pointer to the character buffer. SV must be of type >= SVt_PV. One | ||||||
3323 | alternative is to call C |
||||||
3324 | |||||||
3325 | char * SvGROW(SV* sv, STRLEN len)','name' => 'SvGROW'},'dMULTICALL' => {'text' => 'Declare local variables for a multicall. See L |
||||||
3326 | |||||||
3327 | dMULTICALL;','name' => 'dMULTICALL'},'isIDFIRST' => {'text' => 'Returns a boolean indicating whether the specified character can be the first | ||||||
3328 | character of an identifier. This is very close to, but not quite the same as | ||||||
3329 | the official Unicode property C |
||||||
3330 | returns true only if the input character also matches L. | ||||||
3331 | See the L |
||||||
3332 | C |
||||||
3333 | C |
||||||
3334 | |||||||
3335 | bool isIDFIRST(char ch)','name' => 'isIDFIRST'},'sv_catpv' => {'text' => 'Concatenates the string onto the end of the string which is in the SV. | ||||||
3336 | If the SV has the UTF-8 status set, then the bytes appended should be | ||||||
3337 | valid UTF-8. Handles \'get\' magic, but not \'set\' magic. See C |
||||||
3338 | |||||||
3339 | 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 | ||||||
3340 | coercion and sets the UTF8 flag appropriately. See also C |
||||||
3341 | gives raw access to the xpv_cur slot. | ||||||
3342 | |||||||
3343 | STRLEN sv_len(SV *const sv)','name' => 'sv_len'},'PerlIO_stderr' => {'text' => '','name' => 'PerlIO_stderr'},'sv_pvutf8' => {'text' => 'Use the C |
||||||
3344 | |||||||
3345 | char* sv_pvutf8(SV *sv)','name' => 'sv_pvutf8'},'SvPVbyte_nolen' => {'text' => 'Like C |
||||||
3346 | |||||||
3347 | char* SvPVbyte_nolen(SV* sv)','name' => 'SvPVbyte_nolen'},'LEAVE' => {'text' => 'Closing bracket on a callback. See C |
||||||
3348 | |||||||
3349 | LEAVE;','name' => 'LEAVE'},'mess' => {'text' => 'Take a sprintf-style format pattern and argument list. These are used to | ||||||
3350 | generate a string message. If the message does not end with a newline, | ||||||
3351 | then it will be extended with some indication of the current location | ||||||
3352 | in the code, as described for L. | ||||||
3353 | |||||||
3354 | Normally, the resulting message is returned in a new mortal SV. | ||||||
3355 | During global destruction a single SV may be shared between uses of | ||||||
3356 | this function. | ||||||
3357 | |||||||
3358 | SV * mess(const char *pat, ...)','name' => 'mess'},'SVt_PVAV' => {'text' => 'Type flag for arrays. See L.','name' => 'SVt_PVAV'},'hv_delete_ent' => {'text' => 'Deletes a key/value pair in the hash. The value SV is removed from the hash, | ||||||
3359 | made mortal, and returned to the caller. The C |
||||||
3360 | zero; if set to G_DISCARD then NULL will be returned. NULL will also be | ||||||
3361 | returned if the key is not found. C |
||||||
3362 | value, or 0 to ask for it to be computed. | ||||||
3363 | |||||||
3364 | SV* hv_delete_ent(HV *hv, SV *keysv, I32 flags, | ||||||
3365 | U32 hash)','name' => 'hv_delete_ent'},'PL_keyword_plugin' => {'text' => 'Function pointer, pointing at a function used to handle extended keywords. | ||||||
3366 | The function should be declared as | ||||||
3367 | |||||||
3368 | int keyword_plugin_function(pTHX_ | ||||||
3369 | char *keyword_ptr, STRLEN keyword_len, | ||||||
3370 | OP **op_ptr) | ||||||
3371 | |||||||
3372 | The function is called from the tokeniser, whenever a possible keyword | ||||||
3373 | is seen. C |
||||||
3374 | buffer, and C |
||||||
3375 | The function is expected to examine the word, and possibly other state | ||||||
3376 | such as L<%^H|perlvar/%^H>, to decide whether it wants to handle it | ||||||
3377 | as an extended keyword. If it does not, the function should return | ||||||
3378 | C |
||||||
3379 | |||||||
3380 | If the function wants to handle the keyword, it first must | ||||||
3381 | parse anything following the keyword that is part of the syntax | ||||||
3382 | introduced by the keyword. See L for details. | ||||||
3383 | |||||||
3384 | When a keyword is being handled, the plugin function must build | ||||||
3385 | a tree of C |
||||||
3386 | The root of the tree must be stored in C<*op_ptr>. The function then | ||||||
3387 | returns a constant indicating the syntactic role of the construct that | ||||||
3388 | it has parsed: C |
||||||
3389 | C |
||||||
3390 | construct cannot be used inside an expression (except via C |
||||||
3391 | and similar), and an expression is not a complete statement (it requires | ||||||
3392 | at least a terminating semicolon). | ||||||
3393 | |||||||
3394 | When a keyword is handled, the plugin function may also have | ||||||
3395 | (compile-time) side effects. It may modify C<%^H>, define functions, and | ||||||
3396 | so on. Typically, if side effects are the main purpose of a handler, | ||||||
3397 | it does not wish to generate any ops to be included in the normal | ||||||
3398 | compilation. In this case it is still required to supply an op tree, | ||||||
3399 | but it suffices to generate a single null op. | ||||||
3400 | |||||||
3401 | That\'s how the C<*PL_keyword_plugin> function needs to behave overall. | ||||||
3402 | Conventionally, however, one does not completely replace the existing | ||||||
3403 | handler function. Instead, take a copy of C |
||||||
3404 | assigning your own function pointer to it. Your handler function should | ||||||
3405 | look for keywords that it is interested in and handle those. Where it | ||||||
3406 | is not interested, it should call the saved plugin function, passing on | ||||||
3407 | the arguments it received. Thus C |
||||||
3408 | at a chain of handler functions, all of which have an opportunity to | ||||||
3409 | handle keywords, and only the last function in the chain (built into | ||||||
3410 | the Perl core) will normally return C |
||||||
3411 | |||||||
3412 | NOTE: this function is experimental and may change or be | ||||||
3413 | removed without notice.','name' => 'PL_keyword_plugin'},'LINKLIST' => {'text' => 'Given the root of an optree, link the tree in execution order using the | ||||||
3414 | C |
||||||
3415 | already been done, it will not be redone, and C<< o->op_next >> will be | ||||||
3416 | returned. If C<< o->op_next >> is not already set, I |
||||||
3417 | least an C |
||||||
3418 | |||||||
3419 | OP* LINKLIST(OP *o)','name' => 'LINKLIST'},'utf8_to_uvuni_buf' => {'text' => 'Returns the Unicode code point of the first character in the string C |
||||||
3420 | is assumed to be in UTF-8 encoding; C |
||||||
3421 | C |
||||||
3422 | |||||||
3423 | This function should only be used when the returned UV is considered | ||||||
3424 | an index into the Unicode semantic tables (e.g. swashes). | ||||||
3425 | |||||||
3426 | If C |
||||||
3427 | enabled, zero is returned and C<*retlen> is set (if C |
||||||
3428 | NULL) to -1. If those warnings are off, the computed value if well-defined (or | ||||||
3429 | the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen> | ||||||
3430 | is set (if C |
||||||
3431 | next possible position in C |
||||||
3432 | See L for details on when the REPLACEMENT CHARACTER is returned. | ||||||
3433 | |||||||
3434 | UV utf8_to_uvuni_buf(const U8 *s, const U8 *send, | ||||||
3435 | STRLEN *retlen)','name' => 'utf8_to_uvuni_buf'},'cast_iv' => {'text' => '','name' => 'cast_iv'},'savesvpv' => {'text' => 'A version of C |
||||||
3436 | the passed in SV using C |
||||||
3437 | |||||||
3438 | char* savesvpv(SV* sv)','name' => 'savesvpv'},'CLASS' => {'text' => 'Variable which is setup by C |
||||||
3439 | class name for a C++ XS constructor. This is always a C |
||||||
3440 | |||||||
3441 | char* CLASS','name' => 'CLASS'},'foldEQ_latin1' => {'text' => '','name' => 'foldEQ_latin1'},'newAVREF' => {'text' => '','name' => 'newAVREF'},'HeKLEN' => {'text' => 'If this is negative, and amounts to C |
||||||
3442 | holds an C |
||||||
3443 | be assigned to. The C |
||||||
3444 | lengths. | ||||||
3445 | |||||||
3446 | STRLEN HeKLEN(HE* he)','name' => 'HeKLEN'},'sv_pvn_force_flags' => {'text' => 'Get a sensible string out of the SV somehow. | ||||||
3447 | If C |
||||||
3448 | appropriate, else not. C |
||||||
3449 | implemented in terms of this function. | ||||||
3450 | You normally want to use the various wrapper macros instead: see | ||||||
3451 | C |
||||||
3452 | |||||||
3453 | char* sv_pvn_force_flags(SV *const sv, | ||||||
3454 | STRLEN *const lp, | ||||||
3455 | 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 | ||||||
3456 | down to the assignment operators. The expression must be followed (and thus | ||||||
3457 | terminated) either by a comma or lower-precedence operator or by | ||||||
3458 | something that would normally terminate an expression such as semicolon. | ||||||
3459 | If I |
||||||
3460 | otherwise it is mandatory. It is up to the caller to ensure that the | ||||||
3461 | dynamic parser state (L et al) is correctly set to reflect | ||||||
3462 | the source of the code to be parsed and the lexical context for the | ||||||
3463 | expression. | ||||||
3464 | |||||||
3465 | The op tree representing the expression is returned. If an optional | ||||||
3466 | expression is absent, a null pointer is returned, otherwise the pointer | ||||||
3467 | will be non-null. | ||||||
3468 | |||||||
3469 | If an error occurs in parsing or compilation, in most cases a valid op | ||||||
3470 | tree is returned anyway. The error is reflected in the parser state, | ||||||
3471 | normally resulting in a single exception at the top level of parsing | ||||||
3472 | which covers all the compilation errors that occurred. Some compilation | ||||||
3473 | errors, however, will throw an exception immediately. | ||||||
3474 | |||||||
3475 | NOTE: this function is experimental and may change or be | ||||||
3476 | removed without notice. | ||||||
3477 | |||||||
3478 | OP * parse_termexpr(U32 flags)','name' => 'parse_termexpr'},'mPUSHi' => {'text' => 'Push an integer onto the stack. The stack must have room for this element. | ||||||
3479 | Does not use C |
||||||
3480 | |||||||
3481 | void mPUSHi(IV iv)','name' => 'mPUSHi'},'PUSHn' => {'text' => 'Push a double onto the stack. The stack must have room for this element. | ||||||
3482 | Handles \'set\' magic. Uses C |
||||||
3483 | called to declare it. Do not call multiple C |
||||||
3484 | return lists from XSUB\'s - see C |
||||||
3485 | C |
||||||
3486 | |||||||
3487 | void PUSHn(NV nv)','name' => 'PUSHn'},'to_utf8_title' => {'text' => 'Convert the UTF-8 encoded character at C to its titlecase version and |
||||||
3488 | store that in UTF-8 in C |
||||||
3489 | that the C |
||||||
3490 | titlecase version may be longer than the original character. | ||||||
3491 | |||||||
3492 | The first character of the titlecased version is returned | ||||||
3493 | (but note, as explained above, that there may be more.) | ||||||
3494 | |||||||
3495 | The character at C is assumed by this routine to be well-formed. |
||||||
3496 | |||||||
3497 | UV to_utf8_title(const U8 *p, U8* ustrp, | ||||||
3498 | STRLEN *lenp)','name' => 'to_utf8_title'},'PerlIO_unread' => {'text' => '','name' => 'PerlIO_unread'},'PadMAX' => {'text' => 'The index of the last pad entry. | ||||||
3499 | |||||||
3500 | NOTE: this function is experimental and may change or be | ||||||
3501 | removed without notice. | ||||||
3502 | |||||||
3503 | SSize_t PadMAX(PAD pad)','name' => 'PadMAX'},'gv_fullname' => {'text' => '','name' => 'gv_fullname'},'PL_sv_yes' => {'text' => 'This is the C |
||||||
3504 | C<&PL_sv_yes>. | ||||||
3505 | |||||||
3506 | 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. | ||||||
3507 | Or "locks" it. Or "unlocks" it. In other words, ignores its single SV argument. | ||||||
3508 | Exists to avoid test for a NULL function pointer and because it could | ||||||
3509 | potentially warn under some level of strict-ness. | ||||||
3510 | |||||||
3511 | void sv_nosharing(SV *sv)','name' => 'sv_nosharing'},'ck_entersub_args_list' => {'text' => 'Performs the default fixup of the arguments part of an C |
||||||
3512 | op tree. This consists of applying list context to each of the | ||||||
3513 | argument ops. This is the standard treatment used on a call marked | ||||||
3514 | with C<&>, or a method call, or a call through a subroutine reference, | ||||||
3515 | or any other call where the callee can\'t be identified at compile time, | ||||||
3516 | or a call where the callee has no prototype. | ||||||
3517 | |||||||
3518 | 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 |
||||||
3519 | or not the string is encoded in UTF-8 (or UTF-EBCDIC on EBCDIC machines). That | ||||||
3520 | is, if they are invariant. On ASCII-ish machines, only ASCII characters | ||||||
3521 | fit this definition, hence the function\'s name. | ||||||
3522 | |||||||
3523 | If C |
||||||
3524 | |||||||
3525 | See also L(), L(), and L(). | ||||||
3526 | |||||||
3527 | 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). | ||||||
3528 | Do not use frivolously. | ||||||
3529 | |||||||
3530 | 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 | ||||||
3531 | if necessary. Handles operator overloading. Skips handling \'get\' magic. | ||||||
3532 | |||||||
3533 | 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). | ||||||
3534 | C |
||||||
3535 | non-numeric warning), even if your atof() doesn\'t grok them. Get-magic is | ||||||
3536 | ignored. | ||||||
3537 | |||||||
3538 | I32 looks_like_number(SV *const sv)','name' => 'looks_like_number'},'sv_catpv_mg' => {'text' => 'Like C |
||||||
3539 | |||||||
3540 | 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 | ||||||
3541 | from the op_type; for custom ops from the op_ppaddr. | ||||||
3542 | |||||||
3543 | const char * OP_NAME(OP *o)','name' => 'OP_NAME'},'XSRETURN_EMPTY' => {'text' => 'Return an empty list from an XSUB immediately. | ||||||
3544 | |||||||
3545 | XSRETURN_EMPTY;','name' => 'XSRETURN_EMPTY'},'SvREFCNT_dec_NN' => {'text' => 'Same as SvREFCNT_dec, but can only be used if you know I |
||||||
3546 | is not NULL. Since we don\'t have to check the NULLness, it\'s faster | ||||||
3547 | and smaller. | ||||||
3548 | |||||||
3549 | void SvREFCNT_dec_NN(SV* sv)','name' => 'SvREFCNT_dec_NN'},'mro_get_private_data' => {'text' => '','name' => 'mro_get_private_data'},'XS_APIVERSION_BOOTCHECK' => {'text' => 'Macro to verify that the perl api version an XS module has been compiled against | ||||||
3550 | matches the api version of the perl interpreter it\'s being loaded into. | ||||||
3551 | |||||||
3552 | XS_APIVERSION_BOOTCHECK;','name' => 'XS_APIVERSION_BOOTCHECK'},'hv_delayfree_ent' => {'text' => '','name' => 'hv_delayfree_ent'},'sv_setpvf' => {'text' => 'Works like C |
||||||
3553 | appending it. Does not handle \'set\' magic. See C |
||||||
3554 | |||||||
3555 | void sv_setpvf(SV *const sv, const char *const pat, | ||||||
3556 | ...)','name' => 'sv_setpvf'},'custom_op_register' => {'text' => 'Register a custom op. See L |
||||||
3557 | |||||||
3558 | NOTE: this function must be explicitly called as Perl_custom_op_register with an aTHX_ parameter. | ||||||
3559 | |||||||
3560 | void Perl_custom_op_register(pTHX_ | ||||||
3561 | Perl_ppaddr_t ppaddr, | ||||||
3562 | 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 | ||||||
3563 | L |
||||||
3564 | |||||||
3565 | NOTE: the perl_ form of this function is deprecated. | ||||||
3566 | |||||||
3567 | I32 call_sv(SV* sv, VOL I32 flags)','name' => 'call_sv'},'SVt_PV' => {'text' => 'Type flag for scalars. See L.','name' => 'SVt_PV'},'strGT' => {'text' => 'Test two strings to see if the first, C |
||||||
3568 | C |
||||||
3569 | |||||||
3570 | bool strGT(char* s1, char* s2)','name' => 'strGT'},'mXPUSHs' => {'text' => 'Push an SV onto the stack, extending the stack if necessary and mortalizes | ||||||
3571 | the SV. Does not use C |
||||||
3572 | |||||||
3573 | void mXPUSHs(SV* sv)','name' => 'mXPUSHs'},'POPl' => {'text' => 'Pops a long off the stack. | ||||||
3574 | |||||||
3575 | long POPl','name' => 'POPl'},'init_i18nl14n' => {'text' => '','name' => 'init_i18nl14n'},'scan_version' => {'text' => 'Returns a pointer to the next character after the parsed | ||||||
3576 | version string, as well as upgrading the passed in SV to | ||||||
3577 | an RV. | ||||||
3578 | |||||||
3579 | Function must be called with an already existing SV like | ||||||
3580 | |||||||
3581 | sv = newSV(0); | ||||||
3582 | s = scan_version(s, SV *sv, bool qv); | ||||||
3583 | |||||||
3584 | Performs some preprocessing to the string to ensure that | ||||||
3585 | it has the correct characteristics of a version. Flags the | ||||||
3586 | object if it contains an underscore (which denotes this | ||||||
3587 | is an alpha version). The boolean qv denotes that the version | ||||||
3588 | should be interpreted as if it had multiple decimals, even if | ||||||
3589 | it doesn\'t. | ||||||
3590 | |||||||
3591 | 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 |
||||||
3592 | |||||||
3593 | NOTE: the perl_ form of this function is deprecated. | ||||||
3594 | |||||||
3595 | CV* get_cv(const char* name, I32 flags)','name' => 'get_cv'},'vnumify' => {'text' => 'Accepts a version object and returns the normalized floating | ||||||
3596 | point representation. Call like: | ||||||
3597 | |||||||
3598 | sv = vnumify(rv); | ||||||
3599 | |||||||
3600 | NOTE: you can pass either the object directly or the SV | ||||||
3601 | contained within the RV. | ||||||
3602 | |||||||
3603 | The SV returned has a refcount of 1. | ||||||
3604 | |||||||
3605 | SV* vnumify(SV *vs)','name' => 'vnumify'},'SvIOKp' => {'text' => 'Returns a U32 value indicating whether the SV contains an integer. Checks | ||||||
3606 | the B |
||||||
3607 | |||||||
3608 | U32 SvIOKp(SV* sv)','name' => 'SvIOKp'},'XST_mUNDEF' => {'text' => 'Place C<&PL_sv_undef> into the specified position C |
||||||
3609 | stack. | ||||||
3610 | |||||||
3611 | void XST_mUNDEF(int pos)','name' => 'XST_mUNDEF'},'ptr_table_free' => {'text' => '','name' => 'ptr_table_free'},'SVt_PVIV' => {'text' => 'Type flag for scalars. See L.','name' => 'SVt_PVIV'},'SvUNLOCK' => {'text' => 'Releases a mutual exclusion lock on sv if a suitable module | ||||||
3612 | has been loaded. | ||||||
3613 | |||||||
3614 | void SvUNLOCK(SV* sv)','name' => 'SvUNLOCK'},'mg_set' => {'text' => 'Do magic after a value is assigned to the SV. See C |
||||||
3615 | |||||||
3616 | 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 |
||||||
3617 | The new SV is marked as mortal. It will be destroyed "soon", either by an | ||||||
3618 | explicit call to FREETMPS, or by an implicit call at places such as | ||||||
3619 | statement boundaries. See also C |
||||||
3620 | |||||||
3621 | SV* sv_mortalcopy(SV *const oldsv)','name' => 'sv_mortalcopy'},'cophh_fetch_sv' => {'text' => 'Like L, but takes a Perl scalar instead of a | ||||||
3622 | string/length pair. | ||||||
3623 | |||||||
3624 | NOTE: this function is experimental and may change or be | ||||||
3625 | removed without notice. | ||||||
3626 | |||||||
3627 | SV * cophh_fetch_sv(const COPHH *cophh, SV *key, | ||||||
3628 | U32 hash, U32 flags)','name' => 'cophh_fetch_sv'},'PadARRAY' => {'text' => 'The C array of pad entries. | ||||||
3629 | |||||||
3630 | NOTE: this function is experimental and may change or be | ||||||
3631 | removed without notice. | ||||||
3632 | |||||||
3633 | SV ** PadARRAY(PAD pad)','name' => 'PadARRAY'},'sv_catpvn_nomg' => {'text' => 'Like C |
||||||
3634 | |||||||
3635 | void sv_catpvn_nomg(SV* sv, const char* ptr, | ||||||
3636 | STRLEN len)','name' => 'sv_catpvn_nomg'},'newHVhv' => {'text' => '','name' => 'newHVhv'},'newSVpvs_flags' => {'text' => 'Like C |
||||||
3637 | pair. | ||||||
3638 | |||||||
3639 | SV* newSVpvs_flags(const char* s, U32 flags)','name' => 'newSVpvs_flags'},'savepvn' => {'text' => 'Perl\'s version of what C |
||||||
3640 | pointer to a newly allocated string which is a duplicate of the first | ||||||
3641 | C |
||||||
3642 | the new string can be freed with the C |
||||||
3643 | |||||||
3644 | char* savepvn(const char* pv, I32 len)','name' => 'savepvn'},'pad_findmy_sv' => {'text' => 'Exactly like L, but takes the name string in the form | ||||||
3645 | of an SV instead of a string/length pair. | ||||||
3646 | |||||||
3647 | PADOFFSET pad_findmy_sv(SV *name, U32 flags)','name' => 'pad_findmy_sv'},'cophh_delete_sv' => {'text' => 'Like L, but takes a Perl scalar instead of a | ||||||
3648 | string/length pair. | ||||||
3649 | |||||||
3650 | NOTE: this function is experimental and may change or be | ||||||
3651 | removed without notice. | ||||||
3652 | |||||||
3653 | COPHH * cophh_delete_sv(const COPHH *cophh, SV *key, | ||||||
3654 | U32 hash, U32 flags)','name' => 'cophh_delete_sv'},'av_exists' => {'text' => 'Returns true if the element indexed by C |
||||||
3655 | |||||||
3656 | This relies on the fact that uninitialized array elements are set to | ||||||
3657 | C<&PL_sv_undef>. | ||||||
3658 | |||||||
3659 | Perl equivalent: C |
||||||
3660 | |||||||
3661 | bool av_exists(AV *av, I32 key)','name' => 'av_exists'},'SvCUR' => {'text' => 'Returns the length of the string which is in the SV. See C |
||||||
3662 | |||||||
3663 | STRLEN SvCUR(SV* sv)','name' => 'SvCUR'},'sv_2nv_flags' => {'text' => 'Return the num value of an SV, doing any necessary string or integer | ||||||
3664 | conversion. If flags includes SV_GMAGIC, does an mg_get() first. | ||||||
3665 | Normally used via the C |
||||||
3666 | |||||||
3667 | 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 | ||||||
3668 | has no flags parameter. If the C |
||||||
3669 | GV_ADDMULTI flag will be passed to gv_init_pvn(). | ||||||
3670 | |||||||
3671 | void gv_init(GV* gv, HV* stash, const char* name, | ||||||
3672 | 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 | ||||||
3673 | must be designated by its stash (see C |
||||||
3674 | of the SV is unaffected. | ||||||
3675 | |||||||
3676 | 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 |
||||||
3677 | Specifically, the function is applied to an C |
||||||
3678 | subroutine call, not marked with C<&>, where the callee can be identified | ||||||
3679 | at compile time as I |
||||||
3680 | |||||||
3681 | The C-level function pointer is supplied in I |
||||||
3682 | for it is supplied in I |
||||||
3683 | in this manner: | ||||||
3684 | |||||||
3685 | entersubop = ckfun(aTHX_ entersubop, namegv, ckobj); | ||||||
3686 | |||||||
3687 | In this call, I |
||||||
3688 | which may be replaced by the check function, and I |
||||||
3689 | supplying the name that should be used by the check function to refer | ||||||
3690 | to the callee of the C |
||||||
3691 | It is permitted to apply the check function in non-standard situations, | ||||||
3692 | such as to a call to a different subroutine or to a method call. | ||||||
3693 | |||||||
3694 | The current setting for a particular CV can be retrieved by | ||||||
3695 | L. | ||||||
3696 | |||||||
3697 | void cv_set_call_checker(CV *cv, | ||||||
3698 | Perl_call_checker ckfun, | ||||||
3699 | 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 | ||||||
3700 | GV; or the recursive result if we\'re an RV; or the IO slot of the symbol | ||||||
3701 | named after the PV if we\'re a string. | ||||||
3702 | |||||||
3703 | \'Get\' magic is ignored on the sv passed in, but will be called on | ||||||
3704 | C |
||||||
3705 | |||||||
3706 | 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 |
||||||
3707 | |||||||
3708 | void SvMAGIC_set(SV* sv, MAGIC* val)','name' => 'SvMAGIC_set'},'isALPHA' => {'text' => 'Returns a boolean indicating whether the specified character is an | ||||||
3709 | alphabetic character, analogous to C |
||||||
3710 | See the L |
||||||
3711 | C |
||||||
3712 | C |
||||||
3713 | |||||||
3714 | bool isALPHA(char ch)','name' => 'isALPHA'},'newSVhek' => {'text' => 'Creates a new SV from the hash key structure. It will generate scalars that | ||||||
3715 | point to the shared string table where possible. Returns a new (undefined) | ||||||
3716 | SV if the hek is NULL. | ||||||
3717 | |||||||
3718 | SV* newSVhek(const HEK *const hek)','name' => 'newSVhek'},'taint_env' => {'text' => '','name' => 'taint_env'},'Nullhv' => {'text' => 'Null HV pointer. | ||||||
3719 | |||||||
3720 | (deprecated - use C<(HV *)NULL> instead)','name' => 'Nullhv'},'SvREFCNT_inc' => {'text' => 'Increments the reference count of the given SV, returning the SV. | ||||||
3721 | |||||||
3722 | All of the following SvREFCNT_inc* macros are optimized versions of | ||||||
3723 | SvREFCNT_inc, and can be replaced with SvREFCNT_inc. | ||||||
3724 | |||||||
3725 | SV* SvREFCNT_inc(SV* sv)','name' => 'SvREFCNT_inc'},'newGVgen_flags' => {'text' => '','name' => 'newGVgen_flags'},'SvTYPE' => {'text' => 'Returns the type of the SV. See C |
||||||
3726 | |||||||
3727 | svtype SvTYPE(SV* sv)','name' => 'SvTYPE'},'block_gimme' => {'text' => '','name' => 'block_gimme'},'SvROK_off' => {'text' => 'Unsets the RV status of an SV. | ||||||
3728 | |||||||
3729 | void SvROK_off(SV* sv)','name' => 'SvROK_off'},'Renew' => {'text' => 'The XSUB-writer\'s interface to the C C |
||||||
3730 | |||||||
3731 | void Renew(void* ptr, int nitems, type)','name' => 'Renew'},'XPUSHmortal' => {'text' => 'Push a new mortal SV onto the stack, extending the stack if necessary. | ||||||
3732 | Does not use C |
||||||
3733 | |||||||
3734 | void XPUSHmortal()','name' => 'XPUSHmortal'},'SvNOK_on' => {'text' => 'Tells an SV that it is a double. | ||||||
3735 | |||||||
3736 | void SvNOK_on(SV* sv)','name' => 'SvNOK_on'},'SvVOK' => {'text' => 'Returns a boolean indicating whether the SV contains a v-string. | ||||||
3737 | |||||||
3738 | bool SvVOK(SV* sv)','name' => 'SvVOK'},'whichsig_pvn' => {'text' => '','name' => 'whichsig_pvn'},'sv_setpvf_mg' => {'text' => 'Like C |
||||||
3739 | |||||||
3740 | void sv_setpvf_mg(SV *const sv, | ||||||
3741 | 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 |
||||||
3742 | the opcode. I |
||||||
3743 | C |
||||||
3744 | supply up to two ops to be direct children of the list op; they are | ||||||
3745 | consumed by this function and become part of the constructed op tree. | ||||||
3746 | |||||||
3747 | OP * newLISTOP(I32 type, I32 flags, OP *first, | ||||||
3748 | OP *last)','name' => 'newLISTOP'},'sv_setref_pv' => {'text' => 'Copies a pointer into a new SV, optionally blessing the SV. The C |
||||||
3749 | argument will be upgraded to an RV. That RV will be modified to point to | ||||||
3750 | the new SV. If the C |
||||||
3751 | into the SV. The C |
||||||
3752 | blessing. Set C |
||||||
3753 | will have a reference count of 1, and the RV will be returned. | ||||||
3754 | |||||||
3755 | Do not use with other Perl types such as HV, AV, SV, CV, because those | ||||||
3756 | objects will become corrupted by the pointer copy process. | ||||||
3757 | |||||||
3758 | Note that C |
||||||
3759 | |||||||
3760 | SV* sv_setref_pv(SV *const rv, | ||||||
3761 | const char *const classname, | ||||||
3762 | void *const pv)','name' => 'sv_setref_pv'},'fbm_compile' => {'text' => 'Analyses the string in order to make fast searches on it using fbm_instr() | ||||||
3763 | -- the Boyer-Moore algorithm. | ||||||
3764 | |||||||
3765 | 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 | ||||||
3766 | double. Checks the B |
||||||
3767 | |||||||
3768 | U32 SvNIOKp(SV* sv)','name' => 'SvNIOKp'},'PERL_SYS_TERM' => {'text' => 'Provides system-specific clean up of the C runtime environment after | ||||||
3769 | running Perl interpreters. This should be called only once, after | ||||||
3770 | freeing any remaining Perl interpreters. | ||||||
3771 | |||||||
3772 | void PERL_SYS_TERM()','name' => 'PERL_SYS_TERM'},'mro_register' => {'text' => 'Registers a custom mro plugin. See L |
||||||
3773 | |||||||
3774 | 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, | ||||||
3775 | and attempts to determine at compile time which subroutine it identifies. | ||||||
3776 | This is normally used during Perl compilation to determine whether | ||||||
3777 | a prototype can be applied to a function call. I |
||||||
3778 | being considered, normally an C |
||||||
3779 | subroutine is returned, if it could be determined statically, and a null | ||||||
3780 | pointer is returned if it was not possible to determine statically. | ||||||
3781 | |||||||
3782 | Currently, the subroutine can be identified statically if the RV that the | ||||||
3783 | C |
||||||
3784 | A C |
||||||
3785 | suitable if the constant value must be an RV pointing to a CV. Details of | ||||||
3786 | this process may change in future versions of Perl. If the C |
||||||
3787 | has the C |
||||||
3788 | the subroutine statically: this flag is used to suppress compile-time | ||||||
3789 | magic on a subroutine call, forcing it to use default runtime behaviour. | ||||||
3790 | |||||||
3791 | If I |
||||||
3792 | of a GV reference is modified. If a GV was examined and its CV slot was | ||||||
3793 | found to be empty, then the C |
||||||
3794 | If the op is not optimised away, and the CV slot is later populated with | ||||||
3795 | a subroutine having a prototype, that flag eventually triggers the warning | ||||||
3796 | "called too early to check prototype". | ||||||
3797 | |||||||
3798 | If I |
||||||
3799 | of returning a pointer to the subroutine it returns a pointer to the | ||||||
3800 | GV giving the most appropriate name for the subroutine in this context. | ||||||
3801 | Normally this is just the C |
||||||
3802 | (C |
||||||
3803 | referencing GV. The resulting C |
||||||
3804 | A null pointer is returned as usual if there is no statically-determinable | ||||||
3805 | subroutine. | ||||||
3806 | |||||||
3807 | 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 | ||||||
3808 | UTF-8 bytes as a single character. Handles magic and type coercion. | ||||||
3809 | |||||||
3810 | 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 | ||||||
3811 | return value. The macro doesn\'t need to return a meaningful value. | ||||||
3812 | |||||||
3813 | 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 | ||||||
3814 | marked as readonly and the key is subsequently deleted, the key is not actually | ||||||
3815 | deleted but is marked by assigning it a value of &PL_sv_placeholder. This tags | ||||||
3816 | it so it will be ignored by future operations such as iterating over the hash, | ||||||
3817 | but will still allow the hash to have a value reassigned to the key at some | ||||||
3818 | future point. This function clears any such placeholder keys from the hash. | ||||||
3819 | See Hash::Util::lock_keys() for an example of its use. | ||||||
3820 | |||||||
3821 | void hv_clear_placeholders(HV *hv)','name' => 'hv_clear_placeholders'},'dAX' => {'text' => 'Sets up the C |
||||||
3822 | This is usually handled automatically by C |
||||||
3823 | |||||||
3824 | dAX;','name' => 'dAX'},'SvRV_set' => {'text' => 'Set the value of the RV pointer in sv to val. See C |
||||||
3825 | |||||||
3826 | 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 | ||||||
3827 | (0 if unrecognised), otherwise it is a bit-ORed combination of | ||||||
3828 | IS_NUMBER_IN_UV, IS_NUMBER_GREATER_THAN_UV_MAX, IS_NUMBER_NOT_INT, | ||||||
3829 | IS_NUMBER_NEG, IS_NUMBER_INFINITY, IS_NUMBER_NAN (defined in perl.h). | ||||||
3830 | |||||||
3831 | If the value of the number can fit an in UV, it is returned in the *valuep | ||||||
3832 | IS_NUMBER_IN_UV will be set to indicate that *valuep is valid, IS_NUMBER_IN_UV | ||||||
3833 | will never be set unless *valuep is valid, but *valuep may have been assigned | ||||||
3834 | to during processing even though IS_NUMBER_IN_UV is not set on return. | ||||||
3835 | If valuep is NULL, IS_NUMBER_IN_UV will be set for the same cases as when | ||||||
3836 | valuep is non-NULL, but no actual assignment (or SEGV) will occur. | ||||||
3837 | |||||||
3838 | IS_NUMBER_NOT_INT will be set with IS_NUMBER_IN_UV if trailing decimals were | ||||||
3839 | seen (in which case *valuep gives the true value truncated to an integer), and | ||||||
3840 | IS_NUMBER_NEG if the number is negative (in which case *valuep holds the | ||||||
3841 | absolute value). IS_NUMBER_IN_UV is not set if e notation was used or the | ||||||
3842 | number is larger than a UV. | ||||||
3843 | |||||||
3844 | int grok_number(const char *pv, STRLEN len, | ||||||
3845 | UV *valuep)','name' => 'grok_number'},'csighandler' => {'text' => '','name' => 'csighandler'},'SvIVx' => {'text' => 'Coerces the given SV to an integer and returns it. | ||||||
3846 | Guarantees to evaluate C |
||||||
3847 | this if C |
||||||
3848 | otherwise use the more efficient C |
||||||
3849 | |||||||
3850 | IV SvIVx(SV* sv)','name' => 'SvIVx'},'grok_numeric_radix' => {'text' => 'Scan and skip for a numeric decimal separator (radix). | ||||||
3851 | |||||||
3852 | bool grok_numeric_radix(const char **sp, | ||||||
3853 | const char *send)','name' => 'grok_numeric_radix'},'XST_mNO' => {'text' => 'Place C<&PL_sv_no> into the specified position C |
||||||
3854 | stack. | ||||||
3855 | |||||||
3856 | 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 | ||||||
3857 | instead of a string/length pair. | ||||||
3858 | |||||||
3859 | bool sv_derived_from_pv(SV* sv, | ||||||
3860 | const char *const name, | ||||||
3861 | U32 flags)','name' => 'sv_derived_from_pv'},'savepvs' => {'text' => 'Like C |
||||||
3862 | |||||||
3863 | char* savepvs(const char* s)','name' => 'savepvs'},'SvSTASH_set' => {'text' => 'Set the value of the STASH pointer in sv to val. See C |
||||||
3864 | |||||||
3865 | void SvSTASH_set(SV* sv, HV* val)','name' => 'SvSTASH_set'},'sv_catpv_nomg' => {'text' => 'Like C |
||||||
3866 | |||||||
3867 | void sv_catpv_nomg(SV* sv, const char* ptr)','name' => 'sv_catpv_nomg'},'ZeroD' => {'text' => 'Like C |
||||||
3868 | optimise. | ||||||
3869 | |||||||
3870 | void * ZeroD(void* dest, int nitems, type)','name' => 'ZeroD'},'sv_collxfrm' => {'text' => 'This calls C |
||||||
3871 | C |
||||||
3872 | |||||||
3873 | 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 |
||||||
3874 | C |
||||||
3875 | |||||||
3876 | void sv_catpvn_mg(SV *sv, const char *ptr, | ||||||
3877 | STRLEN len)','name' => 'sv_catpvn_mg'},'op_lvalue' => {'text' => 'Propagate lvalue ("modifiable") context to an op and its children. | ||||||
3878 | I |
||||||
3879 | would do the modifying, although C |
||||||
3880 | because it has no op type of its own (it is signalled by a flag on | ||||||
3881 | the lvalue op). | ||||||
3882 | |||||||
3883 | This function detects things that can\'t be modified, such as C<$x+1>, and | ||||||
3884 | generates errors for them. For example, C<$x+1 = 2> would cause it to be | ||||||
3885 | called with an op of type OP_ADD and a C |
||||||
3886 | |||||||
3887 | It also flags things that need to behave specially in an lvalue context, | ||||||
3888 | such as C<$$x = 5> which might have to vivify a reference in C<$x>. | ||||||
3889 | |||||||
3890 | NOTE: this function is experimental and may change or be | ||||||
3891 | removed without notice. | ||||||
3892 | |||||||
3893 | OP * op_lvalue(OP *o, I32 type)','name' => 'op_lvalue'},'dirp_dup' => {'text' => '','name' => 'dirp_dup'},'gv_stashpvs' => {'text' => 'Like C |
||||||
3894 | |||||||
3895 | HV* gv_stashpvs(const char* name, I32 create)','name' => 'gv_stashpvs'},'Zero' => {'text' => 'The XSUB-writer\'s interface to the C C |
||||||
3896 | destination, C |
||||||
3897 | |||||||
3898 | void Zero(void* dest, int nitems, type)','name' => 'Zero'},'vcmp' => {'text' => 'Version object aware cmp. Both operands must already have been | ||||||
3899 | converted into version objects. | ||||||
3900 | |||||||
3901 | int vcmp(SV *lhv, SV *rhv)','name' => 'vcmp'},'SvSTASH' => {'text' => 'Returns the stash of the SV. | ||||||
3902 | |||||||
3903 | HV* SvSTASH(SV* sv)','name' => 'SvSTASH'},'XSRETURN_UNDEF' => {'text' => 'Return C<&PL_sv_undef> from an XSUB immediately. Uses C |
||||||
3904 | |||||||
3905 | XSRETURN_UNDEF;','name' => 'XSRETURN_UNDEF'},'sv_iv' => {'text' => 'A private implementation of the C |
||||||
3906 | cope with complex macro expressions. Always use the macro instead. | ||||||
3907 | |||||||
3908 | IV sv_iv(SV* sv)','name' => 'sv_iv'},'PL_parser-E |
||||||
3909 | end of the lexer buffer. This is equal to C |
||||||
3910 | + SvCUR(PL_parser-E |
||||||
3911 | always located at the end of the buffer, and does not count as part of | ||||||
3912 | the buffer\'s contents. | ||||||
3913 | |||||||
3914 | NOTE: this function is experimental and may change or be | ||||||
3915 | removed without notice.','name' => 'PL_parser-E |
||||||
3916 | dsv such that the size of the escaped string will not exceed "max" chars | ||||||
3917 | and will not contain any incomplete escape sequences. | ||||||
3918 | |||||||
3919 | If flags contains PERL_PV_ESCAPE_QUOTE then any double quotes in the string | ||||||
3920 | will also be escaped. | ||||||
3921 | |||||||
3922 | Normally the SV will be cleared before the escaped string is prepared, | ||||||
3923 | but when PERL_PV_ESCAPE_NOCLEAR is set this will not occur. | ||||||
3924 | |||||||
3925 | If PERL_PV_ESCAPE_UNI is set then the input string is treated as Unicode, | ||||||
3926 | if PERL_PV_ESCAPE_UNI_DETECT is set then the input string is scanned | ||||||
3927 | using C |
||||||
3928 | |||||||
3929 | If PERL_PV_ESCAPE_ALL is set then all input chars will be output | ||||||
3930 | using C<\\x01F1> style escapes, otherwise if PERL_PV_ESCAPE_NONASCII is set, only | ||||||
3931 | chars above 127 will be escaped using this style; otherwise, only chars above | ||||||
3932 | 255 will be so escaped; other non printable chars will use octal or | ||||||
3933 | common escaped patterns like C<\\n>. Otherwise, if PERL_PV_ESCAPE_NOBACKSLASH | ||||||
3934 | then all chars below 255 will be treated as printable and | ||||||
3935 | will be output as literals. | ||||||
3936 | |||||||
3937 | If PERL_PV_ESCAPE_FIRSTCHAR is set then only the first char of the | ||||||
3938 | string will be escaped, regardless of max. If the output is to be in hex, | ||||||
3939 | then it will be returned as a plain hex | ||||||
3940 | sequence. Thus the output will either be a single char, | ||||||
3941 | an octal escape sequence, a special escape like C<\\n> or a hex value. | ||||||
3942 | |||||||
3943 | If PERL_PV_ESCAPE_RE is set then the escape char used will be a \'%\' and | ||||||
3944 | not a \'\\\\\'. This is because regexes very often contain backslashed | ||||||
3945 | sequences, whereas \'%\' is not a particularly common character in patterns. | ||||||
3946 | |||||||
3947 | Returns a pointer to the escaped text as held by dsv. | ||||||
3948 | |||||||
3949 | char* pv_escape(SV *dsv, char const * const str, | ||||||
3950 | const STRLEN count, const STRLEN max, | ||||||
3951 | STRLEN * const escaped, | ||||||
3952 | const U32 flags)','name' => 'pv_escape'},'HeSVKEY_force' => {'text' => 'Returns the key as an C |
||||||
3953 | C |
||||||
3954 | |||||||
3955 | 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 | ||||||
3956 | incremented. | ||||||
3957 | |||||||
3958 | SV* newRV_inc(SV* sv)','name' => 'newRV_inc'},'isPUNCT' => {'text' => 'Returns a boolean indicating whether the specified character is a | ||||||
3959 | punctuation character, analogous to C |
||||||
3960 | Note that the definition of what is punctuation isn\'t as | ||||||
3961 | straightforward as one might desire. See L | ||||||
3962 | Classes> for details. | ||||||
3963 | See the L |
||||||
3964 | C |
||||||
3965 | C |
||||||
3966 | |||||||
3967 | bool isPUNCT(char ch)','name' => 'isPUNCT'},'SVt_PVCV' => {'text' => 'Type flag for subroutines. See L.','name' => 'SVt_PVCV'},'ss_dup' => {'text' => '','name' => 'ss_dup'},'gv_handler' => {'text' => '','name' => 'gv_handler'},'sv_setpviv_mg' => {'text' => 'Like C |
||||||
3968 | |||||||
3969 | 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 | ||||||
3970 | the latter\'s argument is neither SvPOK, SvIOK nor SvNOK. | ||||||
3971 | It calls sv_2bool_flags with the SV_GMAGIC flag. | ||||||
3972 | |||||||
3973 | bool sv_2bool(SV *const sv)','name' => 'sv_2bool'},'lex_grow_linestr' => {'text' => 'Reallocates the lexer buffer (Llinestr>) to accommodate | ||||||
3974 | at least I |
||||||
3975 | pointer to the reallocated buffer. This is necessary before making | ||||||
3976 | any direct modification of the buffer that would increase its length. | ||||||
3977 | L provides a more convenient way to insert text into | ||||||
3978 | the buffer. | ||||||
3979 | |||||||
3980 | Do not use C |
||||||
3981 | this function updates all of the lexer\'s variables that point directly | ||||||
3982 | into the buffer. | ||||||
3983 | |||||||
3984 | NOTE: this function is experimental and may change or be | ||||||
3985 | removed without notice. | ||||||
3986 | |||||||
3987 | char * lex_grow_linestr(STRLEN len)','name' => 'lex_grow_linestr'},'dORIGMARK' => {'text' => 'Saves the original stack mark for the XSUB. See C |
||||||
3988 | |||||||
3989 | dORIGMARK;','name' => 'dORIGMARK'},'sv_inc_nomg' => {'text' => 'Auto-increment of the value in the SV, doing string to numeric conversion | ||||||
3990 | if necessary. Handles operator overloading. Skips handling \'get\' magic. | ||||||
3991 | |||||||
3992 | 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 | ||||||
3993 | set to 1. It will be destroyed "soon", either by an explicit call to | ||||||
3994 | FREETMPS, or by an implicit call at places such as statement boundaries. | ||||||
3995 | See also C |
||||||
3996 | |||||||
3997 | SV* sv_newmortal()','name' => 'sv_newmortal'},'SvOOK' => {'text' => 'Returns a U32 indicating whether the pointer to the string buffer is offset. | ||||||
3998 | This hack is used internally to speed up removal of characters from the | ||||||
3999 | beginning of a SvPV. When SvOOK is true, then the start of the | ||||||
4000 | allocated string buffer is actually C |
||||||
4001 | This offset used to be stored in SvIVX, but is now stored within the spare | ||||||
4002 | part of the buffer. | ||||||
4003 | |||||||
4004 | U32 SvOOK(SV* sv)','name' => 'SvOOK'},'SvPV_set' => {'text' => 'Set the value of the PV pointer in sv to val. See also C |
||||||
4005 | |||||||
4006 | Beware that the existing pointer may be involved in copy-on-write or other | ||||||
4007 | mischief, so do C |
||||||
4008 | C |
||||||
4009 | modification is safe. | ||||||
4010 | |||||||
4011 | 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 | ||||||
4012 | the current location in the code, if the message does not already appear | ||||||
4013 | to be complete. | ||||||
4014 | |||||||
4015 | C |
||||||
4016 | will be used as-is and will be the result of this function. Otherwise it | ||||||
4017 | is used as a string, and if it already ends with a newline, it is taken | ||||||
4018 | to be complete, and the result of this function will be the same string. | ||||||
4019 | If the message does not end with a newline, then a segment such as C | ||||||
4020 | foo.pl line 37> will be appended, and possibly other clauses indicating | ||||||
4021 | the current state of execution. The resulting message will end with a | ||||||
4022 | dot and a newline. | ||||||
4023 | |||||||
4024 | Normally, the resulting message is returned in a new mortal SV. | ||||||
4025 | During global destruction a single SV may be shared between uses of this | ||||||
4026 | function. If C |
||||||
4027 | required) to modify and return C |
||||||
4028 | |||||||
4029 | SV * mess_sv(SV *basemsg, bool consume)','name' => 'mess_sv'},'hv_clear' => {'text' => 'Frees the all the elements of a hash, leaving it empty. | ||||||
4030 | The XS equivalent of C<%hash = ()>. See also L. | ||||||
4031 | |||||||
4032 | If any destructors are triggered as a result, the hv itself may | ||||||
4033 | be freed. | ||||||
4034 | |||||||
4035 | void hv_clear(HV *hv)','name' => 'hv_clear'},'get_hv' => {'text' => 'Returns the HV of the specified Perl hash. C |
||||||
4036 | C |
||||||
4037 | Perl variable does not exist then it will be created. If C |
||||||
4038 | and the variable does not exist then NULL is returned. | ||||||
4039 | |||||||
4040 | NOTE: the perl_ form of this function is deprecated. | ||||||
4041 | |||||||
4042 | 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 |
||||||
4043 | |||||||
4044 | XSRETURN_YES;','name' => 'XSRETURN_YES'},'PoisonNew' => {'text' => 'PoisonWith(0xAB) for catching access to allocated but uninitialized memory. | ||||||
4045 | |||||||
4046 | 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 | ||||||
4047 | scope will be created. The original ops run in the new dynamic scope, | ||||||
4048 | and then, provided that they exit normally, the scope will be unwound. | ||||||
4049 | The additional ops used to create and unwind the dynamic scope will | ||||||
4050 | normally be an C |
||||||
4051 | instead if the ops are simple enough to not need the full dynamic scope | ||||||
4052 | structure. | ||||||
4053 | |||||||
4054 | NOTE: this function is experimental and may change or be | ||||||
4055 | removed without notice. | ||||||
4056 | |||||||
4057 | OP * op_scope(OP *o)','name' => 'op_scope'},'Renewc' => {'text' => 'The XSUB-writer\'s interface to the C C |
||||||
4058 | cast. | ||||||
4059 | |||||||
4060 | void Renewc(void* ptr, int nitems, type, cast)','name' => 'Renewc'},'sv_nv' => {'text' => 'A private implementation of the C |
||||||
4061 | cope with complex macro expressions. Always use the macro instead. | ||||||
4062 | |||||||
4063 | NV sv_nv(SV* sv)','name' => 'sv_nv'},'PUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this | ||||||
4064 | element. Handles \'set\' magic. Uses C |
||||||
4065 | should be called to declare it. Do not call multiple C |
||||||
4066 | macros to return lists from XSUB\'s - see C |
||||||
4067 | C |
||||||
4068 | |||||||
4069 | void PUSHu(UV uv)','name' => 'PUSHu'},'SvPOK_off' => {'text' => 'Unsets the PV status of an SV. | ||||||
4070 | |||||||
4071 | void SvPOK_off(SV* sv)','name' => 'SvPOK_off'},'newSVsv' => {'text' => 'Creates a new SV which is an exact duplicate of the original SV. | ||||||
4072 | (Uses C |
||||||
4073 | |||||||
4074 | SV* newSVsv(SV *const old)','name' => 'newSVsv'},'hv_magic' => {'text' => 'Adds magic to a hash. See C |
||||||
4075 | |||||||
4076 | void hv_magic(HV *hv, GV *gv, int how)','name' => 'hv_magic'},'deb_nocontext' => {'text' => '','name' => 'deb_nocontext'},'new_stackinfo' => {'text' => '','name' => 'new_stackinfo'},'save_aelem' => {'text' => '','name' => 'save_aelem'},'PerlIO_clearerr' => {'text' => '','name' => 'PerlIO_clearerr'},'cx_dump' => {'text' => '','name' => 'cx_dump'},'SVt_PVIO' => {'text' => 'Type flag for I/O objects. See L.','name' => 'SVt_PVIO'},'hv_placeholders_p' => {'text' => '','name' => 'hv_placeholders_p'},'XCPT_TRY_END' => {'text' => 'Ends a try block. See L |
||||||
4077 | pointer may be either C |
||||||
4078 | C |
||||||
4079 | usually preferable for finding the value of a key. | ||||||
4080 | |||||||
4081 | void* HeKEY(HE* he)','name' => 'HeKEY'},'SvEND' => {'text' => 'Returns a pointer to the spot just after the last character in | ||||||
4082 | the string which is in the SV, where there is usually a trailing | ||||||
4083 | null (even though Perl scalars do not strictly require it). | ||||||
4084 | See C |
||||||
4085 | |||||||
4086 | Warning: If C |
||||||
4087 | unallocated memory. | ||||||
4088 | |||||||
4089 | char* SvEND(SV* sv)','name' => 'SvEND'},'save_delete' => {'text' => '','name' => 'save_delete'},'GIMME_V' => {'text' => 'The XSUB-writer\'s equivalent to Perl\'s C |
||||||
4090 | C |
||||||
4091 | respectively. See L |
||||||
4092 | |||||||
4093 | U32 GIMME_V','name' => 'GIMME_V'},'re_compile' => {'text' => '','name' => 're_compile'},'sv_setsv_flags' => {'text' => 'Copies the contents of the source SV C |
||||||
4094 | C |
||||||
4095 | function if the source SV needs to be reused. Does not handle \'set\' magic. | ||||||
4096 | Loosely speaking, it performs a copy-by-value, obliterating any previous | ||||||
4097 | content of the destination. | ||||||
4098 | If the C |
||||||
4099 | C |
||||||
4100 | parameter has the C |
||||||
4101 | buffers of temps will not be stolen. |
||||||
4102 | and C |
||||||
4103 | |||||||
4104 | You probably want to use one of the assortment of wrappers, such as | ||||||
4105 | C |
||||||
4106 | C |
||||||
4107 | |||||||
4108 | This is the primary function for copying scalars, and most other | ||||||
4109 | copy-ish functions and macros use this underneath. | ||||||
4110 | |||||||
4111 | void sv_setsv_flags(SV *dstr, SV *sstr, | ||||||
4112 | const I32 flags)','name' => 'sv_setsv_flags'},'gv_init_pvn' => {'text' => 'Converts a scalar into a typeglob. This is an incoercible typeglob; | ||||||
4113 | assigning a reference to it will assign to one of its slots, instead of | ||||||
4114 | overwriting it as happens with typeglobs created by SvSetSV. Converting | ||||||
4115 | any scalar that is SvOK() may produce unpredictable results and is reserved | ||||||
4116 | for perl\'s internal use. | ||||||
4117 | |||||||
4118 | C |
||||||
4119 | |||||||
4120 | C |
||||||
4121 | |||||||
4122 | C |
||||||
4123 | that is, it must not include the package name. If C |
||||||
4124 | stash element, it is the caller\'s responsibility to ensure that the name | ||||||
4125 | passed to this function matches the name of the element. If it does not | ||||||
4126 | match, perl\'s internal bookkeeping will get out of sync. | ||||||
4127 | |||||||
4128 | C |
||||||
4129 | the return value of SvUTF8(sv). It can also take the | ||||||
4130 | GV_ADDMULTI flag, which means to pretend that the GV has been | ||||||
4131 | seen before (i.e., suppress "Used once" warnings). | ||||||
4132 | |||||||
4133 | void gv_init_pvn(GV* gv, HV* stash, const char* name, | ||||||
4134 | STRLEN len, U32 flags)','name' => 'gv_init_pvn'},'gv_fetchmeth_sv' => {'text' => 'Exactly like L, but takes the name string in the form | ||||||
4135 | of an SV instead of a string/length pair. | ||||||
4136 | |||||||
4137 | GV* gv_fetchmeth_sv(HV* stash, SV* namesv, | ||||||
4138 | I32 level, U32 flags)','name' => 'gv_fetchmeth_sv'},'newATTRSUB' => {'text' => '','name' => 'newATTRSUB'},'Copy' => {'text' => 'The XSUB-writer\'s interface to the C C |
||||||
4139 | source, C |
||||||
4140 | C |
||||||
4141 | |||||||
4142 | void Copy(void* src, void* dest, int nitems, type)','name' => 'Copy'},'newSVpv_share' => {'text' => 'Like C |
||||||
4143 | string/length pair. | ||||||
4144 | |||||||
4145 | SV* newSVpv_share(const char* s, U32 hash)','name' => 'newSVpv_share'},'sv_taint' => {'text' => 'Taint an SV. Use C |
||||||
4146 | |||||||
4147 | 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. | ||||||
4148 | |||||||
4149 | bool SvIOK_notUV(SV* sv)','name' => 'SvIOK_notUV'},'deb' => {'text' => '','name' => 'deb'},'PL_parser-E |
||||||
4150 | This is useful for indicating at which column an error occurred, and | ||||||
4151 | not much else. This must be updated by any lexing code that consumes | ||||||
4152 | a newline; the function L handles this detail. | ||||||
4153 | |||||||
4154 | NOTE: this function is experimental and may change or be | ||||||
4155 | removed without notice.','name' => 'PL_parser-E |
||||||
4156 | variable. Stores the name and other metadata in the name part of the | ||||||
4157 | pad, and makes preparations to manage the variable\'s lexical scoping. | ||||||
4158 | Returns the offset of the allocated pad slot. | ||||||
4159 | |||||||
4160 | I |
||||||
4161 | If I |
||||||
4162 | identifies the type. If I |
||||||
4163 | to a package variable, and this identifies the package. The following | ||||||
4164 | flags can be OR\'ed together: | ||||||
4165 | |||||||
4166 | padadd_OUR redundantly specifies if it\'s a package var | ||||||
4167 | padadd_STATE variable will retain value persistently | ||||||
4168 | padadd_NO_DUP_CHECK skip check for lexical shadowing | ||||||
4169 | |||||||
4170 | PADOFFSET pad_add_name_pvn(const char *namepv, | ||||||
4171 | STRLEN namelen, U32 flags, | ||||||
4172 | HV *typestash, HV *ourstash)','name' => 'pad_add_name_pvn'},'he_dup' => {'text' => '','name' => 'he_dup'},'gv_fullname3' => {'text' => '','name' => 'gv_fullname3'},'SVt_PVNV' => {'text' => 'Type flag for scalars. See L.','name' => 'SVt_PVNV'},'mPUSHu' => {'text' => 'Push an unsigned integer onto the stack. The stack must have room for this | ||||||
4173 | element. Does not use C |
||||||
4174 | |||||||
4175 | void mPUSHu(UV uv)','name' => 'mPUSHu'},'gv_fetchmeth_pvn' => {'text' => 'Returns the glob with the given C |
||||||
4176 | C |
||||||
4177 | accessible via @ISA and UNIVERSAL::. | ||||||
4178 | |||||||
4179 | The argument C |
||||||
4180 | side-effect creates a glob with the given C |
||||||
4181 | which in the case of success contains an alias for the subroutine, and sets | ||||||
4182 | up caching info for this glob. | ||||||
4183 | |||||||
4184 | The only significant values for C |
||||||
4185 | |||||||
4186 | GV_SUPER indicates that we want to look up the method in the superclasses | ||||||
4187 | of the C |
||||||
4188 | |||||||
4189 | The | ||||||
4190 | GV returned from C |
||||||
4191 | visible to Perl code. So when calling C |
||||||
4192 | the GV directly; instead, you should use the method\'s CV, which can be | ||||||
4193 | obtained from the GV with the C |
||||||
4194 | |||||||
4195 | GV* gv_fetchmeth_pvn(HV* stash, const char* name, | ||||||
4196 | STRLEN len, I32 level, | ||||||
4197 | U32 flags)','name' => 'gv_fetchmeth_pvn'},'cophh_new_empty' => {'text' => 'Generate and return a fresh cop hints hash containing no entries. | ||||||
4198 | |||||||
4199 | NOTE: this function is experimental and may change or be | ||||||
4200 | removed without notice. | ||||||
4201 | |||||||
4202 | 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 | ||||||
4203 | I |
||||||
4204 | normal Perl method. | ||||||
4205 | |||||||
4206 | Currently, the only significant value for C |
||||||
4207 | |||||||
4208 | bool sv_derived_from_pvn(SV* sv, | ||||||
4209 | const char *const name, | ||||||
4210 | 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, | ||||||
4211 | returning the combined list. I |
||||||
4212 | to concatenate. I |
||||||
4213 | If either I |
||||||
4214 | it will be upgraded into one. If either I |
||||||
4215 | the other is returned unchanged. | ||||||
4216 | |||||||
4217 | 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 |
||||||
4218 | |||||||
4219 | 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. | ||||||
4220 | |||||||
4221 | STRLEN HvNAMELEN(HV *stash)','name' => 'HvNAMELEN'},'XPUSHp' => {'text' => 'Push a string onto the stack, extending the stack if necessary. The C |
||||||
4222 | indicates the length of the string. Handles \'set\' magic. Uses C |
||||||
4223 | C |
||||||
4224 | multiple C |
||||||
4225 | C |
||||||
4226 | |||||||
4227 | 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. | ||||||
4228 | A small internal helper function to remove a commonly duplicated idiom. | ||||||
4229 | |||||||
4230 | NOTE: this function is experimental and may change or be | ||||||
4231 | removed without notice. | ||||||
4232 | |||||||
4233 | void av_create_and_push(AV **const avp, | ||||||
4234 | 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 |
||||||
4235 | flag off so that it looks like octets again. | ||||||
4236 | |||||||
4237 | 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). | ||||||
4238 | Do not use frivolously. | ||||||
4239 | |||||||
4240 | void SvUTF8_on(SV *sv)','name' => 'SvUTF8_on'},'sv_does_pv' => {'text' => 'Like L, but takes a nul-terminated string instead of an SV. | ||||||
4241 | |||||||
4242 | bool sv_does_pv(SV* sv, const char *const name, | ||||||
4243 | U32 flags)','name' => 'sv_does_pv'},'sv_setpvn_mg' => {'text' => 'Like C |
||||||
4244 | |||||||
4245 | void sv_setpvn_mg(SV *const sv, | ||||||
4246 | const char *const ptr, | ||||||
4247 | const STRLEN len)','name' => 'sv_setpvn_mg'},'toLOWER' => {'text' => 'Converts the specified character to lowercase, if possible; otherwise returns | ||||||
4248 | the input character itself. | ||||||
4249 | |||||||
4250 | char toLOWER(char ch)','name' => 'toLOWER'},'PadlistNAMESMAX' => {'text' => 'The index of the last pad name. | ||||||
4251 | |||||||
4252 | NOTE: this function is experimental and may change or be | ||||||
4253 | removed without notice. | ||||||
4254 | |||||||
4255 | SSize_t PadlistNAMESMAX(PADLIST padlist)','name' => 'PadlistNAMESMAX'},'av_iter_p' => {'text' => '','name' => 'av_iter_p'},'prescan_version' => {'text' => 'Validate that a given string can be parsed as a version object, but doesn\'t | ||||||
4256 | actually perform the parsing. Can use either strict or lax validation rules. | ||||||
4257 | Can optionally set a number of hint variables to save the parsing code | ||||||
4258 | some time when tokenizing. | ||||||
4259 | |||||||
4260 | const char* prescan_version(const char *s, bool strict, | ||||||
4261 | const char** errstr, | ||||||
4262 | bool *sqv, | ||||||
4263 | int *ssaw_decimal, | ||||||
4264 | 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: | ||||||
4265 | |||||||
4266 | SV *sv = new_version(SV *ver); | ||||||
4267 | |||||||
4268 | Does not alter the passed in ver SV. See "upg_version" if you | ||||||
4269 | want to upgrade the SV. | ||||||
4270 | |||||||
4271 | 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 | ||||||
4272 | down to the bit shift operators. The expression must be followed (and thus | ||||||
4273 | terminated) either by a comparison or lower-precedence operator or by | ||||||
4274 | something that would normally terminate an expression such as semicolon. | ||||||
4275 | If I |
||||||
4276 | otherwise it is mandatory. It is up to the caller to ensure that the | ||||||
4277 | dynamic parser state (L et al) is correctly set to reflect | ||||||
4278 | the source of the code to be parsed and the lexical context for the | ||||||
4279 | expression. | ||||||
4280 | |||||||
4281 | The op tree representing the expression is returned. If an optional | ||||||
4282 | expression is absent, a null pointer is returned, otherwise the pointer | ||||||
4283 | will be non-null. | ||||||
4284 | |||||||
4285 | If an error occurs in parsing or compilation, in most cases a valid op | ||||||
4286 | tree is returned anyway. The error is reflected in the parser state, | ||||||
4287 | normally resulting in a single exception at the top level of parsing | ||||||
4288 | which covers all the compilation errors that occurred. Some compilation | ||||||
4289 | errors, however, will throw an exception immediately. | ||||||
4290 | |||||||
4291 | NOTE: this function is experimental and may change or be | ||||||
4292 | removed without notice. | ||||||
4293 | |||||||
4294 | OP * parse_arithexpr(U32 flags)','name' => 'parse_arithexpr'},'Nullav' => {'text' => 'Null AV pointer. | ||||||
4295 | |||||||
4296 | (deprecated - use C<(AV *)NULL> instead)','name' => 'Nullav'},'sv_pvbyten' => {'text' => 'A private implementation of the C |
||||||
4297 | which can\'t cope with complex macro expressions. Always use the macro | ||||||
4298 | instead. | ||||||
4299 | |||||||
4300 | char* sv_pvbyten(SV *sv, STRLEN *lp)','name' => 'sv_pvbyten'},'isOCTAL' => {'text' => 'Returns a boolean indicating whether the specified character is an | ||||||
4301 | octal digit, [0-7]. | ||||||
4302 | The only two variants are C |
||||||
4303 | C |
||||||
4304 | |||||||
4305 | bool isOCTAL(char ch)','name' => 'isOCTAL'},'rsignal' => {'text' => '','name' => 'rsignal'},'sv_pv' => {'text' => 'Use the C |
||||||
4306 | |||||||
4307 | char* sv_pv(SV *sv)','name' => 'sv_pv'},'perl_alloc_using' => {'text' => '','name' => 'perl_alloc_using'},'pv_pretty' => {'text' => 'Converts a string into something presentable, handling escaping via | ||||||
4308 | pv_escape() and supporting quoting and ellipses. | ||||||
4309 | |||||||
4310 | If the PERL_PV_PRETTY_QUOTE flag is set then the result will be | ||||||
4311 | double quoted with any double quotes in the string escaped. Otherwise | ||||||
4312 | if the PERL_PV_PRETTY_LTGT flag is set then the result be wrapped in | ||||||
4313 | angle brackets. | ||||||
4314 | |||||||
4315 | If the PERL_PV_PRETTY_ELLIPSES flag is set and not all characters in | ||||||
4316 | string were output then an ellipsis C<...> will be appended to the | ||||||
4317 | string. Note that this happens AFTER it has been quoted. | ||||||
4318 | |||||||
4319 | If start_color is non-null then it will be inserted after the opening | ||||||
4320 | quote (if there is one) but before the escaped text. If end_color | ||||||
4321 | is non-null then it will be inserted after the escaped text but before | ||||||
4322 | any quotes or ellipses. | ||||||
4323 | |||||||
4324 | Returns a pointer to the prettified text as held by dsv. | ||||||
4325 | |||||||
4326 | char* pv_pretty(SV *dsv, char const * const str, | ||||||
4327 | const STRLEN count, const STRLEN max, | ||||||
4328 | char const * const start_color, | ||||||
4329 | char const * const end_color, | ||||||
4330 | const U32 flags)','name' => 'pv_pretty'},'sv_setnv_mg' => {'text' => 'Like C |
||||||
4331 | |||||||
4332 | void sv_setnv_mg(SV *const sv, const NV num)','name' => 'sv_setnv_mg'},'utf8_to_bytes' => {'text' => 'Converts a string C |
||||||
4333 | Unlike L, this over-writes the original string, and | ||||||
4334 | updates C |
||||||
4335 | Returns zero on failure, setting C |
||||||
4336 | |||||||
4337 | If you need a copy of the string, see L. | ||||||
4338 | |||||||
4339 | NOTE: this function is experimental and may change or be | ||||||
4340 | removed without notice. | ||||||
4341 | |||||||
4342 | U8* utf8_to_bytes(U8 *s, STRLEN *len)','name' => 'utf8_to_bytes'},'sv_setref_pvs' => {'text' => 'Like C |
||||||
4343 | string/length pair. | ||||||
4344 | |||||||
4345 | SV * sv_setref_pvs(const char* s)','name' => 'sv_setref_pvs'},'re_dup_guts' => {'text' => '','name' => 're_dup_guts'},'si_dup' => {'text' => '','name' => 'si_dup'},'uvuni_to_utf8_flags' => {'text' => 'Adds the UTF-8 representation of the Unicode code point C |
||||||
4346 | of the string C |
||||||
4347 | bytes available. The return value is the pointer to the byte after the | ||||||
4348 | end of the new character. In other words, | ||||||
4349 | |||||||
4350 | d = uvuni_to_utf8_flags(d, uv, flags); | ||||||
4351 | |||||||
4352 | or, in most cases, | ||||||
4353 | |||||||
4354 | d = uvuni_to_utf8(d, uv); | ||||||
4355 | |||||||
4356 | (which is equivalent to) | ||||||
4357 | |||||||
4358 | d = uvuni_to_utf8_flags(d, uv, 0); | ||||||
4359 | |||||||
4360 | This is the recommended Unicode-aware way of saying | ||||||
4361 | |||||||
4362 | *(d++) = uv; | ||||||
4363 | |||||||
4364 | where uv is a code point expressed in Latin-1 or above, not the platform\'s | ||||||
4365 | native character set. B |
||||||
4366 | or L>. | ||||||
4367 | |||||||
4368 | This function will convert to UTF-8 (and not warn) even code points that aren\'t | ||||||
4369 | legal Unicode or are problematic, unless C |
||||||
4370 | following flags: | ||||||
4371 | |||||||
4372 | If C |
||||||
4373 | the function will raise a warning, provided UTF8 warnings are enabled. If instead | ||||||
4374 | UNICODE_DISALLOW_SURROGATE is set, the function will fail and return NULL. | ||||||
4375 | If both flags are set, the function will both warn and return NULL. | ||||||
4376 | |||||||
4377 | The UNICODE_WARN_NONCHAR and UNICODE_DISALLOW_NONCHAR flags correspondingly | ||||||
4378 | affect how the function handles a Unicode non-character. And likewise, the | ||||||
4379 | UNICODE_WARN_SUPER and UNICODE_DISALLOW_SUPER flags, affect the handling of | ||||||
4380 | code points that are | ||||||
4381 | above the Unicode maximum of 0x10FFFF. Code points above 0x7FFF_FFFF (which are | ||||||
4382 | even less portable) can be warned and/or disallowed even if other above-Unicode | ||||||
4383 | code points are accepted by the UNICODE_WARN_FE_FF and UNICODE_DISALLOW_FE_FF | ||||||
4384 | flags. | ||||||
4385 | |||||||
4386 | And finally, the flag UNICODE_WARN_ILLEGAL_INTERCHANGE selects all four of the | ||||||
4387 | above WARN flags; and UNICODE_DISALLOW_ILLEGAL_INTERCHANGE selects all four | ||||||
4388 | DISALLOW flags. | ||||||
4389 | |||||||
4390 | |||||||
4391 | 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 | ||||||
4392 | that gets called at the end of compilation of a Perl subroutine (or | ||||||
4393 | equivalently independent piece of Perl code) to perform fixups of some | ||||||
4394 | ops and to perform small-scale optimisations. The function is called | ||||||
4395 | once for each chain of ops linked through their C |
||||||
4396 | it is recursively called to handle each side chain. It is passed, as | ||||||
4397 | sole parameter, a pointer to the op that is at the head of the chain. | ||||||
4398 | It modifies the op tree in place. | ||||||
4399 | |||||||
4400 | The peephole optimiser should never be completely replaced. Rather, | ||||||
4401 | add code to it by wrapping the existing optimiser. The basic way to do | ||||||
4402 | this can be seen in L |
||||||
4403 | If the new code wishes to operate only on ops at a subroutine\'s top level, | ||||||
4404 | rather than throughout the structure, it is likely to be more convenient | ||||||
4405 | to wrap the L hook. | ||||||
4406 | |||||||
4407 | peep_t PL_rpeepp','name' => 'PL_rpeepp'},'G_DISCARD' => {'text' => 'Indicates that arguments returned from a callback should be discarded. See | ||||||
4408 | L |
||||||
4409 | is stored in a new mortal SV. | ||||||
4410 | |||||||
4411 | void XST_mNV(int pos, NV nv)','name' => 'XST_mNV'},'UNDERBAR' => {'text' => 'The SV* corresponding to the $_ variable. Works even if there | ||||||
4412 | is a lexical $_ in scope.','name' => 'UNDERBAR'},'newSVOP' => {'text' => 'Constructs, checks, and returns an op of any type that involves an | ||||||
4413 | embedded SV. I |
||||||
4414 | of C |
||||||
4415 | takes ownership of one reference to it. | ||||||
4416 | |||||||
4417 | OP * newSVOP(I32 type, I32 flags, SV *sv)','name' => 'newSVOP'},'cophh_fetch_pvn' => {'text' => 'Look up the entry in the cop hints hash I |
||||||
4418 | I |
||||||
4419 | the key octets are interpreted as UTF-8, otherwise they are interpreted | ||||||
4420 | as Latin-1. I |
||||||
4421 | it has not been precomputed. Returns a mortal scalar copy of the value | ||||||
4422 | associated with the key, or C<&PL_sv_placeholder> if there is no value | ||||||
4423 | associated with the key. | ||||||
4424 | |||||||
4425 | NOTE: this function is experimental and may change or be | ||||||
4426 | removed without notice. | ||||||
4427 | |||||||
4428 | SV * cophh_fetch_pvn(const COPHH *cophh, | ||||||
4429 | const char *keypv, | ||||||
4430 | STRLEN keylen, U32 hash, | ||||||
4431 | U32 flags)','name' => 'cophh_fetch_pvn'},'pad_sv' => {'text' => 'Get the value at offset I |
||||||
4432 | Use macro PAD_SV instead of calling this function directly. | ||||||
4433 | |||||||
4434 | SV * pad_sv(PADOFFSET po)','name' => 'pad_sv'},'amagic_call' => {'text' => '','name' => 'amagic_call'},'op_free' => {'text' => '','name' => 'op_free'},'PadnameLEN' => {'text' => 'The length of the name. | ||||||
4435 | |||||||
4436 | NOTE: this function is experimental and may change or be | ||||||
4437 | removed without notice. | ||||||
4438 | |||||||
4439 | STRLEN PadnameLEN(PADNAME pn)','name' => 'PadnameLEN'},'SvPVutf8_force' => {'text' => 'Like C |
||||||
4440 | |||||||
4441 | char* SvPVutf8_force(SV* sv, STRLEN len)','name' => 'SvPVutf8_force'},'gv_AVadd' => {'text' => '','name' => 'gv_AVadd'},'pop_scope' => {'text' => '','name' => 'pop_scope'},'SVt_NV' => {'text' => 'Type flag for scalars. See L.','name' => 'SVt_NV'},'my_popen_list' => {'text' => '','name' => 'my_popen_list'},'sv_2uv' => {'text' => '','name' => 'sv_2uv'},'PUSHMARK' => {'text' => 'Opening bracket for arguments on a callback. See C |
||||||
4442 | L |
||||||
4443 | |||||||
4444 | 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. | ||||||
4445 | |||||||
4446 | SV* ST(int ix)','name' => 'ST'},'call_pv' => {'text' => 'Performs a callback to the specified Perl sub. See L |
||||||
4447 | |||||||
4448 | NOTE: the perl_ form of this function is deprecated. | ||||||
4449 | |||||||
4450 | 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 | ||||||
4451 | parameter. | ||||||
4452 | |||||||
4453 | GV* gv_fetchmeth_autoload(HV* stash, | ||||||
4454 | const char* name, | ||||||
4455 | 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 | ||||||
4456 | start of the string, to a count of the equivalent number of UTF-8 chars. | ||||||
4457 | Handles magic and type coercion. | ||||||
4458 | |||||||
4459 | void sv_pos_b2u(SV *const sv, I32 *const offsetp)','name' => 'sv_pos_b2u'},'sv_utf8_upgrade_flags_grow' => {'text' => '','name' => 'sv_utf8_upgrade_flags_grow'},'SVt_IV' => {'text' => 'Type flag for scalars. See L.','name' => 'SVt_IV'},'SvIsCOW' => {'text' => 'Returns a boolean indicating whether the SV is Copy-On-Write (either shared | ||||||
4460 | hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for | ||||||
4461 | COW). | ||||||
4462 | |||||||
4463 | 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 |
||||||
4464 | C |
||||||
4465 | Handles \'get\' magic on both SVs, but no \'set\' magic. See C |
||||||
4466 | C |
||||||
4467 | |||||||
4468 | void sv_catsv(SV *dstr, SV *sstr)','name' => 'sv_catsv'},'SvPOK_on' => {'text' => 'Tells an SV that it is a string. | ||||||
4469 | |||||||
4470 | void SvPOK_on(SV* sv)','name' => 'SvPOK_on'},'ax' => {'text' => 'Variable which is setup by C |
||||||
4471 | used by the C |
||||||
4472 | must be called prior to setup the C variable. | ||||||
4473 | |||||||
4474 | 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 | ||||||
4475 | of an SV instead of a string/length pair. | ||||||
4476 | |||||||
4477 | PADOFFSET pad_add_name_sv(SV *name, U32 flags, | ||||||
4478 | 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 |
||||||
4479 | store that in UTF-8 in C |
||||||
4480 | that the ustrp needs to be at least UTF8_MAXBYTES_CASE+1 bytes since | ||||||
4481 | the uppercase version may be longer than the original character. | ||||||
4482 | |||||||
4483 | The first character of the uppercased version is returned | ||||||
4484 | (but note, as explained above, that there may be more.) | ||||||
4485 | |||||||
4486 | The character at C is assumed by this routine to be well-formed. |
||||||
4487 | |||||||
4488 | UV to_utf8_upper(const U8 *p, U8* ustrp, | ||||||
4489 | STRLEN *lenp)','name' => 'to_utf8_upper'},'newSVpadname' => {'text' => 'Creates a new SV containing the pad name. This is currently identical | ||||||
4490 | to C |
||||||
4491 | C |
||||||
4492 | |||||||
4493 | NOTE: this function is experimental and may change or be | ||||||
4494 | removed without notice. | ||||||
4495 | |||||||
4496 | SV* newSVpadname(PADNAME *pn)','name' => 'newSVpadname'},'SvPVutf8x_force' => {'text' => 'Like C |
||||||
4497 | Guarantees to evaluate sv only once; use the more efficient C |
||||||
4498 | otherwise. | ||||||
4499 | |||||||
4500 | 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 | ||||||
4501 | identical. Is UTF-8 and \'use bytes\' aware and coerces its args to strings | ||||||
4502 | if necessary. If the flags include SV_GMAGIC, it handles get-magic, too. | ||||||
4503 | |||||||
4504 | 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. | ||||||
4505 | Handles \'set\' magic. Uses C |
||||||
4506 | called to declare it. Do not call multiple C |
||||||
4507 | return lists from XSUB\'s - see C |
||||||
4508 | C |
||||||
4509 | |||||||
4510 | void PUSHi(IV iv)','name' => 'PUSHi'},'SvLEN_set' => {'text' => 'Set the actual length of the string which is in the SV. See C |
||||||
4511 | |||||||
4512 | 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 |
||||||
4513 | store that in UTF-8 in ustrp and its length in bytes in C |
||||||
4514 | that the C |
||||||
4515 | lowercase version may be longer than the original character. | ||||||
4516 | |||||||
4517 | The first character of the lowercased version is returned | ||||||
4518 | (but note, as explained above, that there may be more.) | ||||||
4519 | |||||||
4520 | The character at C is assumed by this routine to be well-formed. |
||||||
4521 | |||||||
4522 | UV to_utf8_lower(const U8 *p, U8* ustrp, | ||||||
4523 | STRLEN *lenp)','name' => 'to_utf8_lower'},'gv_init_pv' => {'text' => 'Same as gv_init_pvn(), but takes a nul-terminated string for the name | ||||||
4524 | instead of separate char * and length parameters. | ||||||
4525 | |||||||
4526 | void gv_init_pv(GV* gv, HV* stash, const char* name, | ||||||
4527 | U32 flags)','name' => 'gv_init_pv'},'newSVpvf' => {'text' => 'Creates a new SV and initializes it with the string formatted like | ||||||
4528 | C |
||||||
4529 | |||||||
4530 | 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 |
||||||
4531 | cast. See also C |
||||||
4532 | |||||||
4533 | void Newxc(void* ptr, int nitems, type, cast)','name' => 'Newxc'},'lex_stuff_pvs' => {'text' => 'Like L, but takes a literal string instead of a | ||||||
4534 | string/length pair. | ||||||
4535 | |||||||
4536 | NOTE: this function is experimental and may change or be | ||||||
4537 | removed without notice. | ||||||
4538 | |||||||
4539 | void lex_stuff_pvs(const char *pv, U32 flags)','name' => 'lex_stuff_pvs'},'perl_destruct' => {'text' => 'Shuts down a Perl interpreter. See L |
||||||
4540 | |||||||
4541 | int perl_destruct(PerlInterpreter *my_perl)','name' => 'perl_destruct'},'SvIVX' => {'text' => 'Returns the raw value in the SV\'s IV slot, without checks or conversions. | ||||||
4542 | Only use when you are sure SvIOK is true. See also C |
||||||
4543 | |||||||
4544 | IV SvIVX(SV* sv)','name' => 'SvIVX'},'custom_op_name' => {'text' => 'Return the name for a given custom op. This was once used by the OP_NAME | ||||||
4545 | macro, but is no longer: it has only been kept for compatibility, and | ||||||
4546 | should not be used. | ||||||
4547 | |||||||
4548 | const char * custom_op_name(const OP *o)','name' => 'custom_op_name'},'sv_vsetpvf' => {'text' => 'Works like C |
||||||
4549 | appending it. Does not handle \'set\' magic. See C |
||||||
4550 | |||||||
4551 | Usually used via its frontend C |
||||||
4552 | |||||||
4553 | void sv_vsetpvf(SV *const sv, const char *const pat, | ||||||
4554 | va_list *const args)','name' => 'sv_vsetpvf'},'any_dup' => {'text' => '','name' => 'any_dup'},'XCPT_CATCH' => {'text' => 'Introduces a catch block. See L |
||||||
4555 | stack. | ||||||
4556 | |||||||
4557 | void XST_mYES(int pos)','name' => 'XST_mYES'},'SvIOK_off' => {'text' => 'Unsets the IV status of an SV. | ||||||
4558 | |||||||
4559 | void SvIOK_off(SV* sv)','name' => 'SvIOK_off'},'sv_setsv' => {'text' => 'Copies the contents of the source SV C |
||||||
4560 | C |
||||||
4561 | function if the source SV needs to be reused. Does not handle \'set\' magic. | ||||||
4562 | Loosely speaking, it performs a copy-by-value, obliterating any previous | ||||||
4563 | content of the destination. | ||||||
4564 | |||||||
4565 | You probably want to use one of the assortment of wrappers, such as | ||||||
4566 | C |
||||||
4567 | C |
||||||
4568 | |||||||
4569 | void sv_setsv(SV *dstr, SV *sstr)','name' => 'sv_setsv'},'PerlIO_stdin' => {'text' => '','name' => 'PerlIO_stdin'},'READ_XDIGIT' => {'text' => 'Returns the value of an ASCII-range hex digit and advances the string pointer. | ||||||
4570 | Behaviour is only well defined when isXDIGIT(*str) is true. | ||||||
4571 | |||||||
4572 | U8 READ_XDIGIT(char str*)','name' => 'READ_XDIGIT'},'ix' => {'text' => 'Variable which is setup by C |
||||||
4573 | XSUB\'s aliases was used to invoke it. See L |
||||||
4574 | |||||||
4575 | I32 ix','name' => 'ix'},'XSRETURN_UV' => {'text' => 'Return an integer from an XSUB immediately. Uses C |
||||||
4576 | |||||||
4577 | 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 | ||||||
4578 | effects. Since we don\'t have to store a temporary value, it\'s faster. | ||||||
4579 | |||||||
4580 | 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 | ||||||
4581 | of the pad for the currently-compiling code. | ||||||
4582 | |||||||
4583 | NOTE: this function is experimental and may change or be | ||||||
4584 | removed without notice.','name' => 'PL_comppad_name'},'SvTRUE_nomg' => {'text' => 'Returns a boolean indicating whether Perl would evaluate the SV as true or | ||||||
4585 | false. See SvOK() for a defined/undefined test. Does not handle \'get\' magic. | ||||||
4586 | |||||||
4587 | bool SvTRUE_nomg(SV* sv)','name' => 'SvTRUE_nomg'},'vverify' => {'text' => 'Validates that the SV contains valid internal structure for a version object. | ||||||
4588 | It may be passed either the version object (RV) or the hash itself (HV). If | ||||||
4589 | the structure is valid, it returns the HV. If the structure is invalid, | ||||||
4590 | it returns NULL. | ||||||
4591 | |||||||
4592 | SV *hv = vverify(sv); | ||||||
4593 | |||||||
4594 | Note that it only confirms the bare minimum structure (so as not to get | ||||||
4595 | confused by derived classes which may contain additional hash entries): | ||||||
4596 | |||||||
4597 | SV* vverify(SV *vs)','name' => 'vverify'},'dXSI32' => {'text' => 'Sets up the C |
||||||
4598 | handled automatically by C |
||||||
4599 | |||||||
4600 | dXSI32;','name' => 'dXSI32'},'dXCPT' => {'text' => 'Set up necessary local variables for exception handling. | ||||||
4601 | See L |
||||||
4602 | |||||||
4603 | dXCPT;','name' => 'dXCPT'},'sv_tainted' => {'text' => 'Test an SV for taintedness. Use C |
||||||
4604 | |||||||
4605 | 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 | ||||||
4606 | wrapped by the macro C |
||||||
4607 | |||||||
4608 | Previously this value was stored in the HV structure, rather than being | ||||||
4609 | calculated on demand. | ||||||
4610 | |||||||
4611 | STRLEN hv_fill(HV const *const hv)','name' => 'hv_fill'},'cv_const_sv' => {'text' => 'If C |
||||||
4612 | value returned by the sub. Otherwise, returns NULL. | ||||||
4613 | |||||||
4614 | Constant subs can be created with C |
||||||
4615 | L |
||||||
4616 | |||||||
4617 | 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 | ||||||
4618 | of a string/length pair. | ||||||
4619 | |||||||
4620 | PADOFFSET pad_add_name_pvs(const char *name, U32 flags, | ||||||
4621 | HV *typestash, HV *ourstash)','name' => 'pad_add_name_pvs'},'newSVnv' => {'text' => 'Creates a new SV and copies a floating point value into it. | ||||||
4622 | The reference count for the SV is set to 1. | ||||||
4623 | |||||||
4624 | SV* newSVnv(const NV n)','name' => 'newSVnv'},'HeVAL' => {'text' => 'Returns the value slot (type C |
||||||
4625 | to. | ||||||
4626 | |||||||
4627 | SV *foo= HeVAL(hv); | ||||||
4628 | HeVAL(hv)= sv; | ||||||
4629 | |||||||
4630 | |||||||
4631 | SV* HeVAL(HE* he)','name' => 'HeVAL'},'HePV' => {'text' => 'Returns the key slot of the hash entry as a C |
||||||
4632 | necessary dereferencing of possibly C |
||||||
4633 | is placed in C |
||||||
4634 | not care about what the length of the key is, you may use the global | ||||||
4635 | variable C |
||||||
4636 | variable. Remember though, that hash keys in perl are free to contain | ||||||
4637 | embedded nulls, so using C |
||||||
4638 | the length of hash keys. This is very similar to the C |
||||||
4639 | described elsewhere in this document. See also C |
||||||
4640 | |||||||
4641 | If you are using C |
||||||
4642 | new SV, you should consider using C |
||||||
4643 | efficient. | ||||||
4644 | |||||||
4645 | char* HePV(HE* he, STRLEN len)','name' => 'HePV'},'hv_free_ent' => {'text' => '','name' => 'hv_free_ent'},'isIDCONT' => {'text' => 'Returns a boolean indicating whether the specified character can be the | ||||||
4646 | second or succeeding character of an identifier. This is very close to, but | ||||||
4647 | not quite the same as the official Unicode property C |
||||||
4648 | difference is that this returns true only if the input character also matches | ||||||
4649 | L. See the L |
||||||
4650 | explanation of variants C |
||||||
4651 | C |
||||||
4652 | C |
||||||
4653 | |||||||
4654 | bool isIDCONT(char ch)','name' => 'isIDCONT'},'SvGETMAGIC' => {'text' => 'Invokes C |
||||||
4655 | will call C |
||||||
4656 | argument more than once. | ||||||
4657 | |||||||
4658 | void SvGETMAGIC(SV* sv)','name' => 'SvGETMAGIC'},'PL_parser' => {'text' => 'Pointer to a structure encapsulating the state of the parsing operation | ||||||
4659 | currently in progress. The pointer can be locally changed to perform | ||||||
4660 | a nested parse without interfering with the state of an outer parse. | ||||||
4661 | Individual members of C |
||||||
4662 | length C |
||||||
4663 | (if longer, the rest is truncated and "..." will be appended). | ||||||
4664 | |||||||
4665 | The C |
||||||
4666 | isPRINT()able characters as themselves, UNI_DISPLAY_BACKSLASH | ||||||
4667 | to display the \\\\[nrfta\\\\] as the backslashed versions (like \'\\n\') | ||||||
4668 | (UNI_DISPLAY_BACKSLASH is preferred over UNI_DISPLAY_ISPRINT for \\\\). | ||||||
4669 | UNI_DISPLAY_QQ (and its alias UNI_DISPLAY_REGEX) have both | ||||||
4670 | UNI_DISPLAY_BACKSLASH and UNI_DISPLAY_ISPRINT turned on. | ||||||
4671 | |||||||
4672 | The pointer to the PV of the C |
||||||
4673 | |||||||
4674 | char* pv_uni_display(SV *dsv, const U8 *spv, | ||||||
4675 | STRLEN len, STRLEN pvlim, | ||||||
4676 | 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 | ||||||
4677 | if necessary. Handles \'get\' magic and operator overloading. | ||||||
4678 | |||||||
4679 | void sv_inc(SV *const sv)','name' => 'sv_inc'},'SvPVbytex_force' => {'text' => 'Like C |
||||||
4680 | Guarantees to evaluate sv only once; use the more efficient C |
||||||
4681 | otherwise. | ||||||
4682 | |||||||
4683 | 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 | ||||||
4684 | op, returning the lengthened list. I |
||||||
4685 | list, and I |
||||||
4686 | opcode for the list. If I |
||||||
4687 | it will be upgraded into one. If either I |
||||||
4688 | the other is returned unchanged. | ||||||
4689 | |||||||
4690 | 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 | ||||||
4691 | the hash, made mortal, and returned to the caller. The absolute | ||||||
4692 | value of C |
||||||
4693 | key is assumed to be in UTF-8-encoded Unicode. The C |
||||||
4694 | will normally be zero; if set to G_DISCARD then NULL will be returned. | ||||||
4695 | NULL will also be returned if the key is not found. | ||||||
4696 | |||||||
4697 | SV* hv_delete(HV *hv, const char *key, I32 klen, | ||||||
4698 | I32 flags)','name' => 'hv_delete'},'pad_add_name_pv' => {'text' => 'Exactly like L, but takes a nul-terminated string | ||||||
4699 | instead of a string/length pair. | ||||||
4700 | |||||||
4701 | PADOFFSET pad_add_name_pv(const char *name, U32 flags, | ||||||
4702 | HV *typestash, HV *ourstash)','name' => 'pad_add_name_pv'},'POP_MULTICALL' => {'text' => 'Closing bracket for a lightweight callback. | ||||||
4703 | See L |
||||||
4704 | |||||||
4705 | POP_MULTICALL;','name' => 'POP_MULTICALL'},'sv_cat_decode' => {'text' => 'The encoding is assumed to be an Encode object, the PV of the ssv is | ||||||
4706 | assumed to be octets in that encoding and decoding the input starts | ||||||
4707 | from the position which (PV + *offset) pointed to. The dsv will be | ||||||
4708 | concatenated the decoded UTF-8 string from ssv. Decoding will terminate | ||||||
4709 | when the string tstr appears in decoding output or the input ends on | ||||||
4710 | the PV of the ssv. The value which the offset points will be modified | ||||||
4711 | to the last input position on the ssv. | ||||||
4712 | |||||||
4713 | Returns TRUE if the terminator was found, else returns FALSE. | ||||||
4714 | |||||||
4715 | bool sv_cat_decode(SV* dsv, SV *encoding, SV *ssv, | ||||||
4716 | 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 | ||||||
4717 | the same function of this macro with an lvalue assignment to C |
||||||
4718 | With future Perls, however, it will be more efficient to use | ||||||
4719 | C |
||||||
4720 | |||||||
4721 | void SvIV_set(SV* sv, IV val)','name' => 'SvIV_set'},'sv_setiv' => {'text' => 'Copies an integer into the given SV, upgrading first if necessary. | ||||||
4722 | Does not handle \'set\' magic. See also C |
||||||
4723 | |||||||
4724 | 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). | ||||||
4725 | |||||||
4726 | void sv_report_used()','name' => 'sv_report_used'},'save_sptr' => {'text' => '','name' => 'save_sptr'},'sv_vcatpvfn_flags' => {'text' => 'Processes its arguments like C |
||||||
4727 | to an SV. Uses an array of SVs if the C style variable argument list is | ||||||
4728 | missing (NULL). When running with taint checks enabled, indicates via | ||||||
4729 | C |
||||||
4730 | locales). | ||||||
4731 | |||||||
4732 | If called as C |
||||||
4733 | |||||||
4734 | Usually used via one of its frontends C |
||||||
4735 | |||||||
4736 | void sv_vcatpvfn_flags(SV *const sv, | ||||||
4737 | const char *const pat, | ||||||
4738 | const STRLEN patlen, | ||||||
4739 | va_list *const args, | ||||||
4740 | SV **const svargs, | ||||||
4741 | const I32 svmax, | ||||||
4742 | bool *const maybe_tainted, | ||||||
4743 | const U32 flags)','name' => 'sv_vcatpvfn_flags'},'SvNVX' => {'text' => 'Returns the raw value in the SV\'s NV slot, without checks or conversions. | ||||||
4744 | Only use when you are sure SvNOK is true. See also C |
||||||
4745 | |||||||
4746 | 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. | ||||||
4747 | |||||||
4748 | U32 HeHASH(HE* he)','name' => 'HeHASH'},'SvIOK' => {'text' => 'Returns a U32 value indicating whether the SV contains an integer. | ||||||
4749 | |||||||
4750 | U32 SvIOK(SV* sv)','name' => 'SvIOK'},'newANONHASH' => {'text' => '','name' => 'newANONHASH'},'PadnameSV' => {'text' => 'Returns the pad name as an SV. This is currently just C |
||||||
4751 | begin returning a new mortal SV if pad names ever stop being SVs. | ||||||
4752 | |||||||
4753 | NOTE: this function is experimental and may change or be | ||||||
4754 | removed without notice. | ||||||
4755 | |||||||
4756 | SV * PadnameSV(PADNAME pn)','name' => 'PadnameSV'},'is_utf8_char_buf' => {'text' => 'Returns the number of bytes that comprise the first UTF-8 encoded character in | ||||||
4757 | buffer C |
||||||
4758 | buffer. 0 is returned if C |
||||||
4759 | encoded character. | ||||||
4760 | |||||||
4761 | Note that an INVARIANT character (i.e. ASCII on non-EBCDIC | ||||||
4762 | machines) is a valid UTF-8 character. | ||||||
4763 | |||||||
4764 | STRLEN is_utf8_char_buf(const U8 *buf, | ||||||
4765 | const U8 *buf_end)','name' => 'is_utf8_char_buf'},'SvPV_force' => {'text' => 'Like C |
||||||
4766 | only a string (C |
||||||
4767 | going to update the C |
||||||
4768 | |||||||
4769 | Note that coercing an arbitrary scalar into a plain PV will potentially | ||||||
4770 | strip useful data from it. For example if the SV was C |
||||||
4771 | referent will have its reference count decremented, and the SV itself may | ||||||
4772 | be converted to an C |
||||||
4773 | such as C<"ARRAY(0x1234)">. | ||||||
4774 | |||||||
4775 | char* SvPV_force(SV* sv, STRLEN len)','name' => 'SvPV_force'},'HeUTF8' => {'text' => 'Returns whether the C |
||||||
4776 | doing any necessary dereferencing of possibly C |
||||||
4777 | will be 0 or non-0, not necessarily 1 (or even a value with any low bits set), | ||||||
4778 | so B |
||||||
4779 | typedef for C |
||||||
4780 | |||||||
4781 | char* HeUTF8(HE* he)','name' => 'HeUTF8'},'newRANGE' => {'text' => 'Constructs and returns a C |
||||||
4782 | C |
||||||
4783 | C |
||||||
4784 | for both the C |
||||||
4785 | 1 is automatically set. I |
||||||
4786 | controlling the endpoints of the range; they are consumed by this function | ||||||
4787 | and become part of the constructed op tree. | ||||||
4788 | |||||||
4789 | OP * newRANGE(I32 flags, OP *left, OP *right)','name' => 'newRANGE'},'isCNTRL' => {'text' => 'Returns a boolean indicating whether the specified character is a | ||||||
4790 | control character, analogous to C |
||||||
4791 | See the L |
||||||
4792 | C |
||||||
4793 | C |
||||||
4794 | On EBCDIC platforms, you almost always want to use the C |
||||||
4795 | |||||||
4796 | bool isCNTRL(char ch)','name' => 'isCNTRL'},'PadlistNAMESARRAY' => {'text' => 'The C array of pad names. | ||||||
4797 | |||||||
4798 | NOTE: this function is experimental and may change or be | ||||||
4799 | removed without notice. | ||||||
4800 | |||||||
4801 | PADNAME ** PadlistNAMESARRAY(PADLIST padlist)','name' => 'PadlistNAMESARRAY'},'cophh_delete_pvn' => {'text' => 'Delete a key and its associated value from the cop hints hash I |
||||||
4802 | and returns the modified hash. The returned hash pointer is in general | ||||||
4803 | not the same as the hash pointer that was passed in. The input hash is | ||||||
4804 | consumed by the function, and the pointer to it must not be subsequently | ||||||
4805 | used. Use L if you need both hashes. | ||||||
4806 | |||||||
4807 | The key is specified by I |
||||||
4808 | C |
||||||
4809 | otherwise they are interpreted as Latin-1. I |
||||||
4810 | hash of the key string, or zero if it has not been precomputed. | ||||||
4811 | |||||||
4812 | NOTE: this function is experimental and may change or be | ||||||
4813 | removed without notice. | ||||||
4814 | |||||||
4815 | COPHH * cophh_delete_pvn(COPHH *cophh, | ||||||
4816 | const char *keypv, | ||||||
4817 | STRLEN keylen, U32 hash, | ||||||
4818 | U32 flags)','name' => 'cophh_delete_pvn'},'grok_hex' => {'text' => 'converts a string representing a hex number to numeric form. | ||||||
4819 | |||||||
4820 | On entry I |
||||||
4821 | conversion flags, and I |
||||||
4822 | The scan stops at the end of the string, or the first invalid character. | ||||||
4823 | Unless C |
||||||
4824 | invalid character will also trigger a warning. | ||||||
4825 | On return I<*len> is set to the length of the scanned string, | ||||||
4826 | and I<*flags> gives output flags. | ||||||
4827 | |||||||
4828 | If the value is <= UV_MAX it is returned as a UV, the output flags are clear, | ||||||
4829 | and nothing is written to I<*result>. If the value is > UV_MAX C |
||||||
4830 | returns UV_MAX, sets C |
||||||
4831 | and writes the value to I<*result> (or the value is discarded if I |
||||||
4832 | is NULL). | ||||||
4833 | |||||||
4834 | The hex number may optionally be prefixed with "0x" or "x" unless | ||||||
4835 | C |
||||||
4836 | C |
||||||
4837 | number may use \'_\' characters to separate digits. | ||||||
4838 | |||||||
4839 | UV grok_hex(const char* start, STRLEN* len_p, | ||||||
4840 | 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 | ||||||
4841 | has been loaded. | ||||||
4842 | |||||||
4843 | void SvLOCK(SV* sv)','name' => 'SvLOCK'},'gv_fetchfile' => {'text' => '','name' => 'gv_fetchfile'},'sv_vsetpvfn' => {'text' => 'Works like C |
||||||
4844 | appending it. | ||||||
4845 | |||||||
4846 | Usually used via one of its frontends C |
||||||
4847 | |||||||
4848 | void sv_vsetpvfn(SV *const sv, const char *const pat, | ||||||
4849 | const STRLEN patlen, | ||||||
4850 | va_list *const args, | ||||||
4851 | SV **const svargs, const I32 svmax, | ||||||
4852 | 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 |
||||||
4853 | the character that is being converted. This routine assumes that the character | ||||||
4854 | at C is well-formed. |
||||||
4855 | |||||||
4856 | The C |
||||||
4857 | conversion result to. The C |
||||||
4858 | of the result. | ||||||
4859 | |||||||
4860 | The C |
||||||
4861 | |||||||
4862 | Both the special and normal mappings are stored in F |
||||||
4863 | and loaded by SWASHNEW, using F |
||||||
4864 | but not always, a multicharacter mapping), is tried first. | ||||||
4865 | |||||||
4866 | The C |
||||||
4867 | hash %utf8::ToSpecLower. The access to the hash is through | ||||||
4868 | Perl_to_utf8_case(). | ||||||
4869 | |||||||
4870 | The C |
||||||
4871 | %utf8::ToLower. | ||||||
4872 | |||||||
4873 | UV to_utf8_case(const U8 *p, U8* ustrp, | ||||||
4874 | STRLEN *lenp, SV **swashp, | ||||||
4875 | const char *normal, | ||||||
4876 | const char *special)','name' => 'to_utf8_case'},'set_numeric_local' => {'text' => '','name' => 'set_numeric_local'},'calloc' => {'text' => '','name' => 'calloc'},'POPpbytex' => {'text' => 'Pops a string off the stack which must consist of bytes i.e. characters < 256. | ||||||
4877 | |||||||
4878 | char* POPpbytex','name' => 'POPpbytex'},'cophh_store_sv' => {'text' => 'Like L, but takes a Perl scalar instead of a | ||||||
4879 | string/length pair. | ||||||
4880 | |||||||
4881 | NOTE: this function is experimental and may change or be | ||||||
4882 | removed without notice. | ||||||
4883 | |||||||
4884 | COPHH * cophh_store_sv(const COPHH *cophh, SV *key, | ||||||
4885 | U32 hash, SV *value, U32 flags)','name' => 'cophh_store_sv'},'newPMOP' => {'text' => 'Constructs, checks, and returns an op of any pattern matching type. | ||||||
4886 | I |
||||||
4887 | and, shifted up eight bits, the eight bits of C |
||||||
4888 | |||||||
4889 | OP * newPMOP(I32 type, I32 flags)','name' => 'newPMOP'},'PL_peepp' => {'text' => 'Pointer to the per-subroutine peephole optimiser. This is a function | ||||||
4890 | that gets called at the end of compilation of a Perl subroutine (or | ||||||
4891 | equivalently independent piece of Perl code) to perform fixups of | ||||||
4892 | some ops and to perform small-scale optimisations. The function is | ||||||
4893 | called once for each subroutine that is compiled, and is passed, as sole | ||||||
4894 | parameter, a pointer to the op that is the entry point to the subroutine. | ||||||
4895 | It modifies the op tree in place. | ||||||
4896 | |||||||
4897 | The peephole optimiser should never be completely replaced. Rather, | ||||||
4898 | add code to it by wrapping the existing optimiser. The basic way to do | ||||||
4899 | this can be seen in L |
||||||
4900 | If the new code wishes to operate on ops throughout the subroutine\'s | ||||||
4901 | structure, rather than just at the top level, it is likely to be more | ||||||
4902 | convenient to wrap the L hook. | ||||||
4903 | |||||||
4904 | peep_t PL_peepp','name' => 'PL_peepp'},'SvSetMagicSV' => {'text' => 'Like C |
||||||
4905 | |||||||
4906 | void SvSetMagicSV(SV* dsb, SV* ssv)','name' => 'SvSetMagicSV'},'isALPHANUMERIC' => {'text' => 'Returns a boolean indicating whether the specified character is a either an | ||||||
4907 | alphabetic character or decimal digit, analogous to C |
||||||
4908 | See the L |
||||||
4909 | C |
||||||
4910 | C |
||||||
4911 | C |
||||||
4912 | |||||||
4913 | bool isALPHANUMERIC(char ch)','name' => 'isALPHANUMERIC'},'Move' => {'text' => 'The XSUB-writer\'s interface to the C C |
||||||
4914 | source, C |
||||||
4915 | C |
||||||
4916 | |||||||
4917 | 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 | ||||||
4918 | C |
||||||
4919 | status set, then the bytes appended should be valid UTF-8. | ||||||
4920 | If C |
||||||
4921 | C |
||||||
4922 | C |
||||||
4923 | in terms of this function. | ||||||
4924 | |||||||
4925 | void sv_catpvn_flags(SV *const dstr, | ||||||
4926 | const char *sstr, | ||||||
4927 | const STRLEN len, | ||||||
4928 | 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 | ||||||
4929 | conversion. If flags includes SV_GMAGIC, does an mg_get() first. | ||||||
4930 | Normally used via the C |
||||||
4931 | |||||||
4932 | 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 |
||||||
4933 | 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 |
||||||
4934 | |||||||
4935 | 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 | ||||||
4936 | string/length pair, and no precomputed hash. | ||||||
4937 | |||||||
4938 | SV * cop_hints_fetch_pvs(const COP *cop, | ||||||
4939 | const char *key, U32 flags)','name' => 'cop_hints_fetch_pvs'},'cop_store_label' => {'text' => 'Save a label into a C |
||||||
4940 | for a utf-8 label. | ||||||
4941 | |||||||
4942 | NOTE: this function is experimental and may change or be | ||||||
4943 | removed without notice. | ||||||
4944 | |||||||
4945 | void cop_store_label(COP *const cop, | ||||||
4946 | const char *label, STRLEN len, | ||||||
4947 | U32 flags)','name' => 'cop_store_label'},'PUSHmortal' => {'text' => 'Push a new mortal SV onto the stack. The stack must have room for this | ||||||
4948 | element. Does not use C |
||||||
4949 | |||||||
4950 | 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 |
||||||
4951 | |||||||
4952 | 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. | ||||||
4953 | Jobs performed here are: remove most stuff from the pads of anonsub | ||||||
4954 | prototypes; give it a @_; mark temporaries as such. I |
||||||
4955 | the kind of subroutine: | ||||||
4956 | |||||||
4957 | padtidy_SUB ordinary subroutine | ||||||
4958 | padtidy_SUBCLONE prototype for lexical closure | ||||||
4959 | padtidy_FORMAT format | ||||||
4960 | |||||||
4961 | NOTE: this function is experimental and may change or be | ||||||
4962 | removed without notice. | ||||||
4963 | |||||||
4964 | void pad_tidy(padtidy_type type)','name' => 'pad_tidy'},'OP_DESC' => {'text' => 'Return a short description of the provided OP. | ||||||
4965 | |||||||
4966 | const char * OP_DESC(OP *o)','name' => 'OP_DESC'},'strLE' => {'text' => 'Test two strings to see if the first, C |
||||||
4967 | second, C |
||||||
4968 | |||||||
4969 | 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 | ||||||
4970 | SV is set to 1. Note that if C |
||||||
4971 | string. You are responsible for ensuring that the source string is at least | ||||||
4972 | C |
||||||
4973 | Currently the only flag bits accepted are C |
||||||
4974 | If C |
||||||
4975 | returning. If C |
||||||
4976 | is considered to be in UTF-8 and the | ||||||
4977 | C |
||||||
4978 | C |
||||||
4979 | |||||||
4980 | #define newSVpvn_utf8(s, len, u) \\ | ||||||
4981 | newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0) | ||||||
4982 | |||||||
4983 | SV* newSVpvn_flags(const char *const s, | ||||||
4984 | const STRLEN len, | ||||||
4985 | const U32 flags)','name' => 'newSVpvn_flags'},'XopFLAGS' => {'text' => 'Return the XOP\'s flags. | ||||||
4986 | |||||||
4987 | U32 XopFLAGS(XOP *xop)','name' => 'XopFLAGS'},'SvOK' => {'text' => 'Returns a U32 value indicating whether the value is defined. This is | ||||||
4988 | only meaningful for scalars. | ||||||
4989 | |||||||
4990 | U32 SvOK(SV* sv)','name' => 'SvOK'},'sv_setref_nv' => {'text' => 'Copies a double into a new SV, optionally blessing the SV. The C |
||||||
4991 | argument will be upgraded to an RV. That RV will be modified to point to | ||||||
4992 | the new SV. The C |
||||||
4993 | blessing. Set C |
||||||
4994 | will have a reference count of 1, and the RV will be returned. | ||||||
4995 | |||||||
4996 | SV* sv_setref_nv(SV *const rv, | ||||||
4997 | const char *const classname, | ||||||
4998 | const NV nv)','name' => 'sv_setref_nv'},'eval_pv' => {'text' => 'Tells Perl to C |
||||||
4999 | |||||||
5000 | NOTE: the perl_ form of this function is deprecated. | ||||||
5001 | |||||||
5002 | SV* eval_pv(const char* p, I32 croak_on_error)','name' => 'eval_pv'},'lex_stuff_pvn' => {'text' => 'Insert characters into the lexer buffer (Llinestr>), | ||||||
5003 | immediately after the current lexing point (Lbufptr>), | ||||||
5004 | reallocating the buffer if necessary. This means that lexing code that | ||||||
5005 | runs later will see the characters as if they had appeared in the input. | ||||||
5006 | It is not recommended to do this as part of normal parsing, and most | ||||||
5007 | uses of this facility run the risk of the inserted characters being | ||||||
5008 | interpreted in an unintended manner. | ||||||
5009 | |||||||
5010 | The string to be inserted is represented by I |
||||||
5011 | at I |
||||||
5012 | according to whether the C |
||||||
5013 | The characters are recoded for the lexer buffer, according to how the | ||||||
5014 | buffer is currently being interpreted (L). If a string | ||||||
5015 | to be inserted is available as a Perl scalar, the L | ||||||
5016 | function is more convenient. | ||||||
5017 | |||||||
5018 | NOTE: this function is experimental and may change or be | ||||||
5019 | removed without notice. | ||||||
5020 | |||||||
5021 | void lex_stuff_pvn(const char *pv, STRLEN len, | ||||||
5022 | U32 flags)','name' => 'lex_stuff_pvn'},'sv_usepvn_flags' => {'text' => 'Tells an SV to use C |
||||||
5023 | string is stored inside the SV but sv_usepvn allows the SV to use an | ||||||
5024 | outside string. The C |
||||||
5025 | by C |
||||||
5026 | of memory, and not a pointer to the middle of it. The | ||||||
5027 | string length, C |
||||||
5028 | this function will realloc (i.e. move) the memory pointed to by C |
||||||
5029 | so that pointer should not be freed or used by the programmer after | ||||||
5030 | giving it to sv_usepvn, and neither should any pointers from "behind" | ||||||
5031 | that pointer (e.g. ptr + 1) be used. | ||||||
5032 | |||||||
5033 | If C |
||||||
5034 | SV_HAS_TRAILING_NUL is true, then C |
||||||
5035 | will be skipped (i.e. the buffer is actually at least 1 byte longer than | ||||||
5036 | C |
||||||
5037 | |||||||
5038 | void sv_usepvn_flags(SV *const sv, char* ptr, | ||||||
5039 | const STRLEN len, | ||||||
5040 | const U32 flags)','name' => 'sv_usepvn_flags'},'hv_assert' => {'text' => 'Check that a hash is in an internally consistent state. | ||||||
5041 | |||||||
5042 | void hv_assert(HV *hv)','name' => 'hv_assert'},'my_vsnprintf' => {'text' => 'The C library C |
||||||
5043 | However, if if the C |
||||||
5044 | use the unsafe C |
||||||
5045 | overrun check, but that may be too late). Consider using | ||||||
5046 | C |
||||||
5047 | |||||||
5048 | int my_vsnprintf(char *buffer, const Size_t len, | ||||||
5049 | 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 | ||||||
5050 | C |
||||||
5051 | the body; finally, deallocate the SV\'s head itself. | ||||||
5052 | Normally called via a wrapper macro C |
||||||
5053 | |||||||
5054 | 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 |
||||||
5055 | |||||||
5056 | char* SvPVbyte_force(SV* sv, STRLEN len)','name' => 'SvPVbyte_force'},'av_pop' => {'text' => 'Removes one SV from the end of the array, reducing its size by one and | ||||||
5057 | returning the SV (transferring control of one reference count) to the | ||||||
5058 | caller. Returns C<&PL_sv_undef> if the array is empty. | ||||||
5059 | |||||||
5060 | Perl equivalent: C |
||||||
5061 | |||||||
5062 | 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 |
||||||
5063 | |||||||
5064 | Take a sprintf-style format pattern and argument list. These are used to | ||||||
5065 | generate a string message. If the message does not end with a newline, | ||||||
5066 | then it will be extended with some indication of the current location | ||||||
5067 | in the code, as described for L. | ||||||
5068 | |||||||
5069 | The error message will be used as an exception, by default | ||||||
5070 | returning control to the nearest enclosing C |
||||||
5071 | modification by a C<$SIG{__DIE__}> handler. In any case, the C |
||||||
5072 | function never returns normally. | ||||||
5073 | |||||||
5074 | For historical reasons, if C |
||||||
5075 | (C<$@>) will be used as an error message or object instead of building an | ||||||
5076 | error message from arguments. If you want to throw a non-string object, | ||||||
5077 | or build an error message in an SV yourself, it is preferable to use | ||||||
5078 | the L function, which does not involve clobbering C |
||||||
5079 | |||||||
5080 | void croak(const char *pat, ...)','name' => 'croak'},'save_freepv' => {'text' => '','name' => 'save_freepv'},'THIS' => {'text' => 'Variable which is setup by C |
||||||
5081 | XSUB. This is always the proper type for the C++ object. See C |
||||||
5082 | L |
||||||
5083 | |||||||
5084 | (whatever) THIS','name' => 'THIS'},'XSRETURN' => {'text' => 'Return from XSUB, indicating number of items on the stack. This is usually | ||||||
5085 | handled by C |
||||||
5086 | |||||||
5087 | 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 | ||||||
5088 | op, returning the lengthened list. I |
||||||
5089 | and I |
||||||
5090 | intended opcode for the list. If I |
||||||
5091 | right type, it will be upgraded into one. If either I |
||||||
5092 | is null, the other is returned unchanged. | ||||||
5093 | |||||||
5094 | 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. | ||||||
5095 | Returns the codepoint (unsigned integer value) of the character read, | ||||||
5096 | and moves Lbufptr> past the character, or returns -1 | ||||||
5097 | if lexing has reached the end of the input text. To non-destructively | ||||||
5098 | examine the next character, use L instead. | ||||||
5099 | |||||||
5100 | If the next character is in (or extends into) the next chunk of input | ||||||
5101 | text, the next chunk will be read in. Normally the current chunk will be | ||||||
5102 | discarded at the same time, but if I |
||||||
5103 | then the current chunk will not be discarded. | ||||||
5104 | |||||||
5105 | If the input is being interpreted as UTF-8 and a UTF-8 encoding error | ||||||
5106 | is encountered, an exception is generated. | ||||||
5107 | |||||||
5108 | NOTE: this function is experimental and may change or be | ||||||
5109 | removed without notice. | ||||||
5110 | |||||||
5111 | I32 lex_read_unichar(U32 flags)','name' => 'lex_read_unichar'},'reginitcolors' => {'text' => '','name' => 'reginitcolors'},'get_av' => {'text' => 'Returns the AV of the specified Perl global or package array with the given | ||||||
5112 | name (so it won\'t work on lexical variables). C |
||||||
5113 | to C |
||||||
5114 | Perl variable does not exist then it will be created. If C |
||||||
5115 | and the variable does not exist then NULL is returned. | ||||||
5116 | |||||||
5117 | Perl equivalent: C<@{"$name"}>. | ||||||
5118 | |||||||
5119 | NOTE: the perl_ form of this function is deprecated. | ||||||
5120 | |||||||
5121 | AV* get_av(const char *name, I32 flags)','name' => 'get_av'},'sv_2pv_nolen' => {'text' => 'Like C |
||||||
5122 | use the macro wrapper C |
||||||
5123 | |||||||
5124 | char* sv_2pv_nolen(SV* sv)','name' => 'sv_2pv_nolen'},'op_contextualize' => {'text' => 'Applies a syntactic context to an op tree representing an expression. | ||||||
5125 | I |
||||||
5126 | or C |
||||||
5127 | is returned. | ||||||
5128 | |||||||
5129 | OP * op_contextualize(OP *o, I32 context)','name' => 'op_contextualize'},'PoisonFree' => {'text' => 'PoisonWith(0xEF) for catching access to freed memory. | ||||||
5130 | |||||||
5131 | 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 |
||||||
5132 | which entry to return. If the member is not set this will return a | ||||||
5133 | default value. The return type depends on I |
||||||
5134 | |||||||
5135 | XopENTRY(XOP *xop, which)','name' => 'XopENTRY'},'newSVREF' => {'text' => '','name' => 'newSVREF'},'toUPPER' => {'text' => 'Converts the specified character to uppercase, if possible; otherwise returns | ||||||
5136 | the input character itself. | ||||||
5137 | |||||||
5138 | char toUPPER(char ch)','name' => 'toUPPER'},'sv_catpvs_flags' => {'text' => 'Like C |
||||||
5139 | string/length pair. | ||||||
5140 | |||||||
5141 | void sv_catpvs_flags(SV* sv, const char* s, | ||||||
5142 | 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 | ||||||
5143 | case of "utf8ness failure") or the location C |
||||||
5144 | "utf8ness success") in the C |
||||||
5145 | |||||||
5146 | See also L() and L(). | ||||||
5147 | |||||||
5148 | bool is_utf8_string_loc(const U8 *s, STRLEN len, | ||||||
5149 | const U8 **ep)','name' => 'is_utf8_string_loc'},'sv_gets' => {'text' => 'Get a line from the filehandle and store it into the SV, optionally | ||||||
5150 | appending to the currently-stored string. If C |
||||||
5151 | line is appended to the SV instead of overwriting it. C |
||||||
5152 | be set to the byte offset that the appended string should start at | ||||||
5153 | in the SV (typically, C |
||||||
5154 | |||||||
5155 | char* sv_gets(SV *const sv, PerlIO *const fp, | ||||||
5156 | I32 append)','name' => 'sv_gets'},'GvAV' => {'text' => 'Return the AV from the GV. | ||||||
5157 | |||||||
5158 | AV* GvAV(GV* gv)','name' => 'GvAV'},'SvSetSV_nosteal' => {'text' => 'Calls a non-destructive version of C |
||||||
5159 | ssv. May evaluate arguments more than once. | ||||||
5160 | |||||||
5161 | void SvSetSV_nosteal(SV* dsv, SV* ssv)','name' => 'SvSetSV_nosteal'},'pad_add_anon' => {'text' => 'Allocates a place in the currently-compiling pad (via L) | ||||||
5162 | for an anonymous function that is lexically scoped inside the | ||||||
5163 | currently-compiling function. | ||||||
5164 | The function I |
||||||
5165 | to the outer scope is weakened to avoid a reference loop. | ||||||
5166 | |||||||
5167 | One reference count is stolen, so you may need to do C |
||||||
5168 | |||||||
5169 | I |
||||||
5170 | pad entry is to support. This doesn\'t affect operational semantics, | ||||||
5171 | but is used for debugging. | ||||||
5172 | |||||||
5173 | PADOFFSET pad_add_anon(CV *func, I32 optype)','name' => 'pad_add_anon'},'dUNDERBAR' => {'text' => 'Sets up any variable needed by the C |
||||||
5174 | C |
||||||
5175 | to still use it for ensuring past and future compatibility. | ||||||
5176 | |||||||
5177 | dUNDERBAR;','name' => 'dUNDERBAR'},'sv_uv' => {'text' => 'A private implementation of the C |
||||||
5178 | cope with complex macro expressions. Always use the macro instead. | ||||||
5179 | |||||||
5180 | 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 |
||||||
5181 | of which may be in UTF-8) are the same case-insensitively; false otherwise. | ||||||
5182 | How far into the strings to compare is determined by other input parameters. | ||||||
5183 | |||||||
5184 | If C |
||||||
5185 | otherwise it is assumed to be in native 8-bit encoding. Correspondingly for C |
||||||
5186 | with respect to C |
||||||
5187 | |||||||
5188 | If the byte length C |
||||||
5189 | equality. In other words, C |
||||||
5190 | scan will not be considered to be a match unless the goal is reached, and | ||||||
5191 | scanning won\'t continue past that goal. Correspondingly for C |
||||||
5192 | C |
||||||
5193 | |||||||
5194 | If C |
||||||
5195 | considered an end pointer to the position 1 byte past the maximum point | ||||||
5196 | in C |
||||||
5197 | (This routine assumes that UTF-8 encoded input strings are not malformed; | ||||||
5198 | malformed input can cause it to read past C |
||||||
5199 | This means that if both C |
||||||
5200 | is less than C |
||||||
5201 | never | ||||||
5202 | get as far as its goal (and in fact is asserted against). Correspondingly for | ||||||
5203 | C |
||||||
5204 | |||||||
5205 | At least one of C |
||||||
5206 | C |
||||||
5207 | reached for a successful match. Also, if the fold of a character is multiple | ||||||
5208 | characters, all of them must be matched (see tr21 reference below for | ||||||
5209 | \'folding\'). | ||||||
5210 | |||||||
5211 | Upon a successful match, if C |
||||||
5212 | it will be set to point to the beginning of the I |
||||||
5213 | beyond what was matched. Correspondingly for C |
||||||
5214 | |||||||
5215 | For case-insensitiveness, the "casefolding" of Unicode is used | ||||||
5216 | instead of upper/lowercasing both the characters, see | ||||||
5217 | L |
||||||
5218 | |||||||
5219 | I32 foldEQ_utf8(const char *s1, char **pe1, UV l1, | ||||||
5220 | bool u1, const char *s2, char **pe2, | ||||||
5221 | UV l2, bool u2)','name' => 'foldEQ_utf8'},'Nullch' => {'text' => 'Null character pointer. (No longer available when C |
||||||
5222 | |||||||
5223 | void sv_copypv_nomg(SV *const dsv, SV *const ssv)','name' => 'sv_copypv_nomg'},'get_context' => {'text' => '','name' => 'get_context'},'vcroak' => {'text' => 'This is an XS interface to Perl\'s C |
||||||
5224 | |||||||
5225 | C |
||||||
5226 | argument list. These are used to generate a string message. If the | ||||||
5227 | message does not end with a newline, then it will be extended with | ||||||
5228 | some indication of the current location in the code, as described for | ||||||
5229 | L. | ||||||
5230 | |||||||
5231 | The error message will be used as an exception, by default | ||||||
5232 | returning control to the nearest enclosing C |
||||||
5233 | modification by a C<$SIG{__DIE__}> handler. In any case, the C |
||||||
5234 | function never returns normally. | ||||||
5235 | |||||||
5236 | For historical reasons, if C |
||||||
5237 | (C<$@>) will be used as an error message or object instead of building an | ||||||
5238 | error message from arguments. If you want to throw a non-string object, | ||||||
5239 | or build an error message in an SV yourself, it is preferable to use | ||||||
5240 | the L function, which does not involve clobbering C |
||||||
5241 | |||||||
5242 | void vcroak(const char *pat, va_list *args)','name' => 'vcroak'},'parse_fullexpr' => {'text' => 'Parse a single complete Perl expression. This allows the full | ||||||
5243 | expression grammar, including the lowest-precedence operators such | ||||||
5244 | as C |
||||||
5245 | token that an expression would normally be terminated by: end-of-file, | ||||||
5246 | closing bracketing punctuation, semicolon, or one of the keywords that | ||||||
5247 | signals a postfix expression-statement modifier. If I |
||||||
5248 | C |
||||||
5249 | mandatory. It is up to the caller to ensure that the dynamic parser | ||||||
5250 | state (L et al) is correctly set to reflect the source of | ||||||
5251 | the code to be parsed and the lexical context for the expression. | ||||||
5252 | |||||||
5253 | The op tree representing the expression is returned. If an optional | ||||||
5254 | expression is absent, a null pointer is returned, otherwise the pointer | ||||||
5255 | will be non-null. | ||||||
5256 | |||||||
5257 | If an error occurs in parsing or compilation, in most cases a valid op | ||||||
5258 | tree is returned anyway. The error is reflected in the parser state, | ||||||
5259 | normally resulting in a single exception at the top level of parsing | ||||||
5260 | which covers all the compilation errors that occurred. Some compilation | ||||||
5261 | errors, however, will throw an exception immediately. | ||||||
5262 | |||||||
5263 | NOTE: this function is experimental and may change or be | ||||||
5264 | removed without notice. | ||||||
5265 | |||||||
5266 | OP * parse_fullexpr(U32 flags)','name' => 'parse_fullexpr'},'sv_magicext' => {'text' => 'Adds magic to an SV, upgrading it if necessary. Applies the | ||||||
5267 | supplied vtable and returns a pointer to the magic added. | ||||||
5268 | |||||||
5269 | Note that C |
||||||
5270 | In particular, you can add magic to SvREADONLY SVs, and add more than | ||||||
5271 | one instance of the same \'how\'. | ||||||
5272 | |||||||
5273 | If C |
||||||
5274 | stored, if C |
||||||
5275 | special case - if C<(name && namlen == HEf_SVKEY)> then C |
||||||
5276 | to contain an C |
||||||
5277 | |||||||
5278 | (This is now used as a subroutine by C |
||||||
5279 | |||||||
5280 | MAGIC * sv_magicext(SV *const sv, SV *const obj, | ||||||
5281 | const int how, | ||||||
5282 | const MGVTBL *const vtbl, | ||||||
5283 | const char *const name, | ||||||
5284 | const I32 namlen)','name' => 'sv_magicext'},'gv_fullname4' => {'text' => '','name' => 'gv_fullname4'},'av_push' => {'text' => 'Pushes an SV onto the end of the array. The array will grow automatically | ||||||
5285 | to accommodate the addition. This takes ownership of one reference count. | ||||||
5286 | |||||||
5287 | Perl equivalent: C |
||||||
5288 | |||||||
5289 | void av_push(AV *av, SV *val)','name' => 'av_push'},'XSRETURN_NO' => {'text' => 'Return C<&PL_sv_no> from an XSUB immediately. Uses C |
||||||
5290 | |||||||
5291 | XSRETURN_NO;','name' => 'XSRETURN_NO'},'POPn' => {'text' => 'Pops a double off the stack. | ||||||
5292 | |||||||
5293 | NV POPn','name' => 'POPn'},'newRV_noinc' => {'text' => 'Creates an RV wrapper for an SV. The reference count for the original | ||||||
5294 | SV is B |
||||||
5295 | |||||||
5296 | 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 |
||||||
5297 | gives the eight bits of C |
||||||
5298 | be set automatically, and, shifted up eight bits, the eight bits of | ||||||
5299 | C |
||||||
5300 | set as required. I |
||||||
5301 | the slice; they are consumed by this function and become part of the | ||||||
5302 | constructed op tree. | ||||||
5303 | |||||||
5304 | OP * newSLICEOP(I32 flags, OP *subscript, | ||||||
5305 | 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 | ||||||
5306 | keys in the hash (i.e. the same as C |
||||||
5307 | currently only meaningful for hashes without tie magic. | ||||||
5308 | |||||||
5309 | NOTE: Before version 5.004_65, C |
||||||
5310 | hash buckets that happen to be in use. If you still need that esoteric | ||||||
5311 | value, you can get it through the macro C |
||||||
5312 | |||||||
5313 | |||||||
5314 | I32 hv_iterinit(HV *hv)','name' => 'hv_iterinit'}};}; | ||||||
5315 | |||||||
5316 | 4 | 127 | my $self = bless({ | ||||
5317 | 'index' => $VAR1, | ||||||
5318 | perl_version => '5.018000', | ||||||
5319 | } => $class); | ||||||
5320 | 4 | 1382 | return $self; | ||||
5321 | } | ||||||
5322 | |||||||
5323 | 1; |