1PERLINTERN(1) Perl Programmers Reference Guide PERLINTERN(1)
2
6 perlintern - autogenerated documentation of purely internal
7 Perl functions
8
10 This file is the autogenerated documentation of functions in the Perl
11 interpreter that are documented using Perl's internal documentation
12 format but are not marked as part of the Perl API. In other words,
13 they are not for use in extensions!
14
16 BhkENTRY
17 NOTE: this function is experimental and may change or be
18 removed without notice.
19 Return an entry from the BHK structure. "which" is a
21 preprocessor token indicating which entry to return. If the
22 appropriate flag is not set this will return "NULL". The type
23 of the return value depends on which entry you ask for.
24 void * BhkENTRY(BHK *hk, which)
26 BhkFLAGS
28 NOTE: this function is experimental and may change or be
29 removed without notice.
30 Return the BHK's flags.
32 U32 BhkFLAGS(BHK *hk)
34 CALL_BLOCK_HOOKS
36 NOTE: this function is experimental and may change or be
37 removed without notice.
38 Call all the registered block hooks for type "which". "which"
40 is a preprocessing token; the type of "arg" depends on "which".
41 void CALL_BLOCK_HOOKS(which, arg)
43
45 core_prototype
46 This function assigns the prototype of the named core function
47 to "sv", or to a new mortal SV if "sv" is "NULL". It returns
48 the modified "sv", or "NULL" if the core function has no
49 prototype. "code" is a code as returned by "keyword()". It
50 must not be equal to 0.
51 SV * core_prototype(SV *sv, const char *name,
53 const int code,
54 int * const opnum)
55
57 docatch Check for the cases 0 or 3 of cur_env.je_ret, only used inside
58 an eval context.
59 0 is used as continue inside eval,
61 3 is used for a die caught by an inner eval - continue inner
63 loop
64 See cop.h: je_mustcatch, when set at any runlevel to TRUE,
66 means eval ops must establish a local jmpenv to handle
67 exception traps.
68 OP* docatch(Perl_ppaddr_t firstpp)
70
72 CvWEAKOUTSIDE
73 Each CV has a pointer, "CvOUTSIDE()", to its lexically
74 enclosing CV (if any). Because pointers to anonymous sub
75 prototypes are stored in "&" pad slots, it is a possible to get
76 a circular reference, with the parent pointing to the child and
77 vice-versa. To avoid the ensuing memory leak, we do not
78 increment the reference count of the CV pointed to by
79 "CvOUTSIDE" in the one specific instance that the parent has a
80 "&" pad slot pointing back to us. In this case, we set the
81 "CvWEAKOUTSIDE" flag in the child. This allows us to determine
82 under what circumstances we should decrement the refcount of
83 the parent when freeing the child.
84 There is a further complication with non-closure anonymous subs
86 (i.e. those that do not refer to any lexicals outside that
87 sub). In this case, the anonymous prototype is shared rather
88 than being cloned. This has the consequence that the parent
89 may be freed while there are still active children, e.g.,
90 BEGIN { $a = sub { eval '$x' } }
92 In this case, the BEGIN is freed immediately after execution
94 since there are no active references to it: the anon sub
95 prototype has "CvWEAKOUTSIDE" set since it's not a closure, and
96 $a points to the same CV, so it doesn't contribute to BEGIN's
97 refcount either. When $a is executed, the "eval '$x'" causes
98 the chain of "CvOUTSIDE"s to be followed, and the freed BEGIN
99 is accessed.
100 To avoid this, whenever a CV and its associated pad is freed,
102 any "&" entries in the pad are explicitly removed from the pad,
103 and if the refcount of the pointed-to anon sub is still
104 positive, then that child's "CvOUTSIDE" is set to point to its
105 grandparent. This will only occur in the single specific case
106 of a non-closure anon prototype having one or more active
107 references (such as $a above).
108 One other thing to consider is that a CV may be merely
110 undefined rather than freed, eg "undef &foo". In this case,
111 its refcount may not have reached zero, but we still delete its
112 pad and its "CvROOT" etc. Since various children may still
113 have their "CvOUTSIDE" pointing at this undefined CV, we keep
114 its own "CvOUTSIDE" for the time being, so that the chain of
115 lexical scopes is unbroken. For example, the following should
116 print 123:
117 my $x = 123;
119 sub tmp { sub { eval '$x' } }
120 my $a = tmp();
121 undef &tmp;
122 print $a->();
123 bool CvWEAKOUTSIDE(CV *cv)
125
127 cv_dump dump the contents of a CV
128 void cv_dump(CV *cv, const char *title)
130 cv_forget_slab
132 When a CV has a reference count on its slab ("CvSLABBED"), it
133 is responsible for making sure it is freed. (Hence, no two CVs
134 should ever have a reference count on the same slab.) The CV
135 only needs to reference the slab during compilation. Once it
136 is compiled and "CvROOT" attached, it has finished its job, so
137 it can forget the slab.
138 void cv_forget_slab(CV *cv)
140 do_dump_pad
142 Dump the contents of a padlist
143 void do_dump_pad(I32 level, PerlIO *file,
145 PADLIST *padlist, int full)
146 pad_alloc_name
148 Allocates a place in the currently-compiling pad (via
149 "pad_alloc" in perlapi) and then stores a name for that entry.
150 "name" is adopted and becomes the name entry; it must already
151 contain the name string. "typestash" and "ourstash" and the
152 "padadd_STATE" flag get added to "name". None of the other
153 processing of "pad_add_name_pvn" in perlapi is done. Returns
154 the offset of the allocated pad slot.
155 PADOFFSET pad_alloc_name(PADNAME *name, U32 flags,
157 HV *typestash, HV *ourstash)
158 pad_block_start
160 Update the pad compilation state variables on entry to a new
161 block.
162 void pad_block_start(int full)
164 pad_check_dup
166 Check for duplicate declarations: report any of:
167 * a 'my' in the current scope with the same name;
169 * an 'our' (anywhere in the pad) with the same name and the
170 same stash as 'ourstash'
171 "is_our" indicates that the name to check is an "our"
173 declaration.
174 void pad_check_dup(PADNAME *name, U32 flags,
176 const HV *ourstash)
177 pad_findlex
179 Find a named lexical anywhere in a chain of nested pads. Add
180 fake entries in the inner pads if it's found in an outer one.
181 Returns the offset in the bottom pad of the lex or the fake
183 lex. "cv" is the CV in which to start the search, and seq is
184 the current "cop_seq" to match against. If "warn" is true,
185 print appropriate warnings. The "out_"* vars return values,
186 and so are pointers to where the returned values should be
187 stored. "out_capture", if non-null, requests that the
188 innermost instance of the lexical is captured; "out_name" is
189 set to the innermost matched pad name or fake pad name;
190 "out_flags" returns the flags normally associated with the
191 "PARENT_FAKELEX_FLAGS" field of a fake pad name.
192 Note that "pad_findlex()" is recursive; it recurses up the
194 chain of CVs, then comes back down, adding fake entries as it
195 goes. It has to be this way because fake names in anon
196 protoypes have to store in "xpadn_low" the index into the
197 parent pad.
198 PADOFFSET pad_findlex(const char *namepv,
200 STRLEN namelen, U32 flags,
201 const CV* cv, U32 seq, int warn,
202 SV** out_capture,
203 PADNAME** out_name,
204 int *out_flags)
205 pad_fixup_inner_anons
207 For any anon CVs in the pad, change "CvOUTSIDE" of that CV from
208 "old_cv" to "new_cv" if necessary. Needed when a newly-
209 compiled CV has to be moved to a pre-existing CV struct.
210 void pad_fixup_inner_anons(PADLIST *padlist,
212 CV *old_cv, CV *new_cv)
213 pad_free
215 Free the SV at offset po in the current pad.
216 void pad_free(PADOFFSET po)
218 pad_leavemy
220 Cleanup at end of scope during compilation: set the max seq
221 number for lexicals in this scope and warn of any lexicals that
222 never got introduced.
223 void pad_leavemy()
225 padlist_dup
227 Duplicates a pad.
228 PADLIST * padlist_dup(PADLIST *srcpad,
230 CLONE_PARAMS *param)
231 padname_dup
233 Duplicates a pad name.
234 PADNAME * padname_dup(PADNAME *src, CLONE_PARAMS *param)
236 padnamelist_dup
238 Duplicates a pad name list.
239 PADNAMELIST * padnamelist_dup(PADNAMELIST *srcpad,
241 CLONE_PARAMS *param)
242 pad_push
244 Push a new pad frame onto the padlist, unless there's already a
245 pad at this depth, in which case don't bother creating a new
246 one. Then give the new pad an @_ in slot zero.
247 void pad_push(PADLIST *padlist, int depth)
249 pad_reset
251 Mark all the current temporaries for reuse
252 void pad_reset()
254 pad_swipe
256 Abandon the tmp in the current pad at offset "po" and replace
257 with a new one.
258 void pad_swipe(PADOFFSET po, bool refadjust)
260
262 gv_try_downgrade
263 NOTE: this function is experimental and may change or be
264 removed without notice.
265 If the typeglob "gv" can be expressed more succinctly, by
267 having something other than a real GV in its place in the
268 stash, replace it with the optimised form. Basic requirements
269 for this are that "gv" is a real typeglob, is sufficiently
270 ordinary, and is only referenced from its package. This
271 function is meant to be used when a GV has been looked up in
272 part to see what was there, causing upgrading, but based on
273 what was found it turns out that the real GV isn't required
274 after all.
275 If "gv" is a completely empty typeglob, it is deleted from the
277 stash.
278 If "gv" is a typeglob containing only a sufficiently-ordinary
280 constant sub, the typeglob is replaced with a scalar-reference
281 placeholder that more compactly represents the same thing.
282 void gv_try_downgrade(GV* gv)
284
286 hv_ename_add
287 Adds a name to a stash's internal list of effective names. See
288 "hv_ename_delete".
289 This is called when a stash is assigned to a new location in
291 the symbol table.
292 void hv_ename_add(HV *hv, const char *name, U32 len,
294 U32 flags)
295 hv_ename_delete
297 Removes a name from a stash's internal list of effective names.
298 If this is the name returned by "HvENAME", then another name in
299 the list will take its place ("HvENAME" will use it).
300 This is called when a stash is deleted from the symbol table.
302 void hv_ename_delete(HV *hv, const char *name,
304 U32 len, U32 flags)
305 refcounted_he_chain_2hv
307 Generates and returns a "HV *" representing the content of a
308 "refcounted_he" chain. "flags" is currently unused and must be
309 zero.
310 HV * refcounted_he_chain_2hv(
312 const struct refcounted_he *c, U32 flags
313 )
314 refcounted_he_fetch_pv
316 Like "refcounted_he_fetch_pvn", but takes a nul-terminated
317 string instead of a string/length pair.
318 SV * refcounted_he_fetch_pv(
320 const struct refcounted_he *chain,
321 const char *key, U32 hash, U32 flags
322 )
323 refcounted_he_fetch_pvn
325 Search along a "refcounted_he" chain for an entry with the key
326 specified by "keypv" and "keylen". If "flags" has the
327 "REFCOUNTED_HE_KEY_UTF8" bit set, the key octets are
328 interpreted as UTF-8, otherwise they are interpreted as
329 Latin-1. "hash" is a precomputed hash of the key string, or
330 zero if it has not been precomputed. Returns a mortal scalar
331 representing the value associated with the key, or
332 &PL_sv_placeholder if there is no value associated with the
333 key.
334 SV * refcounted_he_fetch_pvn(
336 const struct refcounted_he *chain,
337 const char *keypv, STRLEN keylen, U32 hash,
338 U32 flags
339 )
340 refcounted_he_fetch_pvs
342 Like "refcounted_he_fetch_pvn", but takes a literal string
343 instead of a string/length pair, and no precomputed hash.
344 SV * refcounted_he_fetch_pvs(
346 const struct refcounted_he *chain,
347 "literal string" key, U32 flags
348 )
349 refcounted_he_fetch_sv
351 Like "refcounted_he_fetch_pvn", but takes a Perl scalar instead
352 of a string/length pair.
353 SV * refcounted_he_fetch_sv(
355 const struct refcounted_he *chain, SV *key,
356 U32 hash, U32 flags
357 )
358 refcounted_he_free
360 Decrements the reference count of a "refcounted_he" by one. If
361 the reference count reaches zero the structure's memory is
362 freed, which (recursively) causes a reduction of its parent
363 "refcounted_he"'s reference count. It is safe to pass a null
364 pointer to this function: no action occurs in this case.
365 void refcounted_he_free(struct refcounted_he *he)
367 refcounted_he_inc
369 Increment the reference count of a "refcounted_he". The
370 pointer to the "refcounted_he" is also returned. It is safe to
371 pass a null pointer to this function: no action occurs and a
372 null pointer is returned.
373 struct refcounted_he * refcounted_he_inc(
375 struct refcounted_he *he
376 )
377 refcounted_he_new_pv
379 Like "refcounted_he_new_pvn", but takes a nul-terminated string
380 instead of a string/length pair.
381 struct refcounted_he * refcounted_he_new_pv(
383 struct refcounted_he *parent,
384 const char *key, U32 hash,
385 SV *value, U32 flags
386 )
387 refcounted_he_new_pvn
389 Creates a new "refcounted_he". This consists of a single
390 key/value pair and a reference to an existing "refcounted_he"
391 chain (which may be empty), and thus forms a longer chain.
392 When using the longer chain, the new key/value pair takes
393 precedence over any entry for the same key further along the
394 chain.
395 The new key is specified by "keypv" and "keylen". If "flags"
397 has the "REFCOUNTED_HE_KEY_UTF8" bit set, the key octets are
398 interpreted as UTF-8, otherwise they are interpreted as
399 Latin-1. "hash" is a precomputed hash of the key string, or
400 zero if it has not been precomputed.
401 "value" is the scalar value to store for this key. "value" is
403 copied by this function, which thus does not take ownership of
404 any reference to it, and later changes to the scalar will not
405 be reflected in the value visible in the "refcounted_he".
406 Complex types of scalar will not be stored with referential
407 integrity, but will be coerced to strings. "value" may be
408 either null or &PL_sv_placeholder to indicate that no value is
409 to be associated with the key; this, as with any non-null
410 value, takes precedence over the existence of a value for the
411 key further along the chain.
412 "parent" points to the rest of the "refcounted_he" chain to be
414 attached to the new "refcounted_he". This function takes
415 ownership of one reference to "parent", and returns one
416 reference to the new "refcounted_he".
417 struct refcounted_he * refcounted_he_new_pvn(
419 struct refcounted_he *parent,
420 const char *keypv,
421 STRLEN keylen, U32 hash,
422 SV *value, U32 flags
423 )
424 refcounted_he_new_pvs
426 Like "refcounted_he_new_pvn", but takes a literal string
427 instead of a string/length pair, and no precomputed hash.
428 struct refcounted_he * refcounted_he_new_pvs(
430 struct refcounted_he *parent,
431 "literal string" key,
432 SV *value, U32 flags
433 )
434 refcounted_he_new_sv
436 Like "refcounted_he_new_pvn", but takes a Perl scalar instead
437 of a string/length pair.
438 struct refcounted_he * refcounted_he_new_sv(
440 struct refcounted_he *parent,
441 SV *key, U32 hash, SV *value,
442 U32 flags
443 )
444
446 start_glob
447 NOTE: this function is experimental and may change or be
448 removed without notice.
449 Function called by "do_readline" to spawn a glob (or do the
451 glob inside perl on VMS). This code used to be inline, but now
452 perl uses "File::Glob" this glob starter is only used by
453 miniperl during the build process, or when PERL_EXTERNAL_GLOB
454 is defined. Moving it away shrinks pp_hot.c; shrinking
455 pp_hot.c helps speed perl up.
456 PerlIO* start_glob(SV *tmpglob, IO *io)
458
460 validate_proto
461 NOTE: this function is experimental and may change or be
462 removed without notice.
463 This function performs syntax checking on a prototype, "proto".
465 If "warn" is true, any illegal characters or mismatched
466 brackets will trigger illegalproto warnings, declaring that
467 they were detected in the prototype for "name".
468 The return value is "true" if this is a valid prototype, and
470 "false" if it is not, regardless of whether "warn" was "true"
471 or "false".
472 Note that "NULL" is a valid "proto" and will always return
474 "true".
475 NOTE: the perl_ form of this function is deprecated.
477 bool validate_proto(SV *name, SV *proto, bool warn,
479 bool curstash)
480
482 magic_clearhint
483 Triggered by a delete from "%^H", records the key to
484 "PL_compiling.cop_hints_hash".
485 int magic_clearhint(SV* sv, MAGIC* mg)
487 magic_clearhints
489 Triggered by clearing "%^H", resets
490 "PL_compiling.cop_hints_hash".
491 int magic_clearhints(SV* sv, MAGIC* mg)
493 magic_methcall
495 Invoke a magic method (like FETCH).
496 "sv" and "mg" are the tied thingy and the tie magic.
498 "meth" is the name of the method to call.
500 "argc" is the number of args (in addition to $self) to pass to
502 the method.
503 The "flags" can be:
505 G_DISCARD invoke method with G_DISCARD flag and don't
507 return a value
508 G_UNDEF_FILL fill the stack with argc pointers to
509 PL_sv_undef
510 The arguments themselves are any values following the "flags"
512 argument.
513 Returns the SV (if any) returned by the method, or "NULL" on
515 failure.
516 SV* magic_methcall(SV *sv, const MAGIC *mg,
518 SV *meth, U32 flags, U32 argc,
519 ...)
520 magic_sethint
522 Triggered by a store to "%^H", records the key/value pair to
523 "PL_compiling.cop_hints_hash". It is assumed that hints aren't
524 storing anything that would need a deep copy. Maybe we should
525 warn if we find a reference.
526 int magic_sethint(SV* sv, MAGIC* mg)
528 mg_localize
530 Copy some of the magic from an existing SV to new localized
531 version of that SV. Container magic (e.g., %ENV, $1, "tie")
532 gets copied, value magic doesn't (e.g., "taint", "pos").
533 If "setmagic" is false then no set magic will be called on the
535 new (empty) SV. This typically means that assignment will soon
536 follow (e.g. 'local $x = $y'), and that will handle the magic.
537 void mg_localize(SV* sv, SV* nsv, bool setmagic)
539
541 free_c_backtrace
542 Deallocates a backtrace received from get_c_bracktrace.
543 void free_c_backtrace(Perl_c_backtrace* bt)
545 get_c_backtrace
547 Collects the backtrace (aka "stacktrace") into a single linear
548 malloced buffer, which the caller must
549 "Perl_free_c_backtrace()".
550 Scans the frames back by "depth + skip", then drops the "skip"
552 innermost, returning at most "depth" frames.
553 Perl_c_backtrace* get_c_backtrace(int max_depth,
555 int skip)
556
558 mro_get_linear_isa_dfs
559 Returns the Depth-First Search linearization of @ISA the given
560 stash. The return value is a read-only AV*. "level" should be
561 0 (it is used internally in this function's recursion).
562 You are responsible for "SvREFCNT_inc()" on the return value if
564 you plan to store it anywhere semi-permanently (otherwise it
565 might be deleted out from under you the next time the cache is
566 invalidated).
567 AV* mro_get_linear_isa_dfs(HV* stash, U32 level)
569 mro_isa_changed_in
571 Takes the necessary steps (cache invalidations, mostly) when
572 the @ISA of the given package has changed. Invoked by the
573 "setisa" magic, should not need to invoke directly.
574 void mro_isa_changed_in(HV* stash)
576 mro_package_moved
578 Call this function to signal to a stash that it has been
579 assigned to another spot in the stash hierarchy. "stash" is
580 the stash that has been assigned. "oldstash" is the stash it
581 replaces, if any. "gv" is the glob that is actually being
582 assigned to.
583 This can also be called with a null first argument to indicate
585 that "oldstash" has been deleted.
586 This function invalidates isa caches on the old stash, on all
588 subpackages nested inside it, and on the subclasses of all
589 those, including non-existent packages that have corresponding
590 entries in "stash".
591 It also sets the effective names ("HvENAME") on all the stashes
593 as appropriate.
594 If the "gv" is present and is not in the symbol table, then
596 this function simply returns. This checked will be skipped if
597 "flags & 1".
598 void mro_package_moved(HV * const stash,
600 HV * const oldstash,
601 const GV * const gv,
602 U32 flags)
603
605 finalize_optree
606 This function finalizes the optree. Should be called directly
607 after the complete optree is built. It does some additional
608 checking which can't be done in the normal "ck_"xxx functions
609 and makes the tree thread-safe.
610 void finalize_optree(OP* o)
612 newATTRSUB_x
614 Construct a Perl subroutine, also performing some surrounding
615 jobs.
616 This function is expected to be called in a Perl compilation
618 context, and some aspects of the subroutine are taken from
619 global variables associated with compilation. In particular,
620 "PL_compcv" represents the subroutine that is currently being
621 compiled. It must be non-null when this function is called,
622 and some aspects of the subroutine being constructed are taken
623 from it. The constructed subroutine may actually be a reuse of
624 the "PL_compcv" object, but will not necessarily be so.
625 If "block" is null then the subroutine will have no body, and
627 for the time being it will be an error to call it. This
628 represents a forward subroutine declaration such as
629 "sub foo ($$);". If "block" is non-null then it provides the
630 Perl code of the subroutine body, which will be executed when
631 the subroutine is called. This body includes any argument
632 unwrapping code resulting from a subroutine signature or
633 similar. The pad use of the code must correspond to the pad
634 attached to "PL_compcv". The code is not expected to include a
635 "leavesub" or "leavesublv" op; this function will add such an
636 op. "block" is consumed by this function and will become part
637 of the constructed subroutine.
638 "proto" specifies the subroutine's prototype, unless one is
640 supplied as an attribute (see below). If "proto" is null, then
641 the subroutine will not have a prototype. If "proto" is non-
642 null, it must point to a "const" op whose value is a string,
643 and the subroutine will have that string as its prototype. If
644 a prototype is supplied as an attribute, the attribute takes
645 precedence over "proto", but in that case "proto" should
646 preferably be null. In any case, "proto" is consumed by this
647 function.
648 "attrs" supplies attributes to be applied the subroutine. A
650 handful of attributes take effect by built-in means, being
651 applied to "PL_compcv" immediately when seen. Other attributes
652 are collected up and attached to the subroutine by this route.
653 "attrs" may be null to supply no attributes, or point to a
654 "const" op for a single attribute, or point to a "list" op
655 whose children apart from the "pushmark" are "const" ops for
656 one or more attributes. Each "const" op must be a string,
657 giving the attribute name optionally followed by parenthesised
658 arguments, in the manner in which attributes appear in Perl
659 source. The attributes will be applied to the sub by this
660 function. "attrs" is consumed by this function.
661 If "o_is_gv" is false and "o" is null, then the subroutine will
663 be anonymous. If "o_is_gv" is false and "o" is non-null, then
664 "o" must point to a "const" op, which will be consumed by this
665 function, and its string value supplies a name for the
666 subroutine. The name may be qualified or unqualified, and if
667 it is unqualified then a default stash will be selected in some
668 manner. If "o_is_gv" is true, then "o" doesn't point to an
669 "OP" at all, but is instead a cast pointer to a "GV" by which
670 the subroutine will be named.
671 If there is already a subroutine of the specified name, then
673 the new sub will either replace the existing one in the glob or
674 be merged with the existing one. A warning may be generated
675 about redefinition.
676 If the subroutine has one of a few special names, such as
678 "BEGIN" or "END", then it will be claimed by the appropriate
679 queue for automatic running of phase-related subroutines. In
680 this case the relevant glob will be left not containing any
681 subroutine, even if it did contain one before. In the case of
682 "BEGIN", the subroutine will be executed and the reference to
683 it disposed of before this function returns.
684 The function returns a pointer to the constructed subroutine.
686 If the sub is anonymous then ownership of one counted reference
687 to the subroutine is transferred to the caller. If the sub is
688 named then the caller does not get ownership of a reference.
689 In most such cases, where the sub has a non-phase name, the sub
690 will be alive at the point it is returned by virtue of being
691 contained in the glob that names it. A phase-named subroutine
692 will usually be alive by virtue of the reference owned by the
693 phase's automatic run queue. But a "BEGIN" subroutine, having
694 already been executed, will quite likely have been destroyed
695 already by the time this function returns, making it erroneous
696 for the caller to make any use of the returned pointer. It is
697 the caller's responsibility to ensure that it knows which of
698 these situations applies.
699 CV * newATTRSUB_x(I32 floor, OP *o, OP *proto,
701 OP *attrs, OP *block, bool o_is_gv)
702 newXS_len_flags
704 Construct an XS subroutine, also performing some surrounding
705 jobs.
706 The subroutine will have the entry point "subaddr". It will
708 have the prototype specified by the nul-terminated string
709 "proto", or no prototype if "proto" is null. The prototype
710 string is copied; the caller can mutate the supplied string
711 afterwards. If "filename" is non-null, it must be a nul-
712 terminated filename, and the subroutine will have its "CvFILE"
713 set accordingly. By default "CvFILE" is set to point directly
714 to the supplied string, which must be static. If "flags" has
715 the "XS_DYNAMIC_FILENAME" bit set, then a copy of the string
716 will be taken instead.
717 Other aspects of the subroutine will be left in their default
719 state. If anything else needs to be done to the subroutine for
720 it to function correctly, it is the caller's responsibility to
721 do that after this function has constructed it. However,
722 beware of the subroutine potentially being destroyed before
723 this function returns, as described below.
724 If "name" is null then the subroutine will be anonymous, with
726 its "CvGV" referring to an "__ANON__" glob. If "name" is non-
727 null then the subroutine will be named accordingly, referenced
728 by the appropriate glob. "name" is a string of length "len"
729 bytes giving a sigilless symbol name, in UTF-8 if "flags" has
730 the "SVf_UTF8" bit set and in Latin-1 otherwise. The name may
731 be either qualified or unqualified, with the stash defaulting
732 in the same manner as for "gv_fetchpvn_flags". "flags" may
733 contain flag bits understood by "gv_fetchpvn_flags" with the
734 same meaning as they have there, such as "GV_ADDWARN". The
735 symbol is always added to the stash if necessary, with
736 "GV_ADDMULTI" semantics.
737 If there is already a subroutine of the specified name, then
739 the new sub will replace the existing one in the glob. A
740 warning may be generated about the redefinition. If the old
741 subroutine was "CvCONST" then the decision about whether to
742 warn is influenced by an expectation about whether the new
743 subroutine will become a constant of similar value. That
744 expectation is determined by "const_svp". (Note that the call
745 to this function doesn't make the new subroutine "CvCONST" in
746 any case; that is left to the caller.) If "const_svp" is null
747 then it indicates that the new subroutine will not become a
748 constant. If "const_svp" is non-null then it indicates that
749 the new subroutine will become a constant, and it points to an
750 "SV*" that provides the constant value that the subroutine will
751 have.
752 If the subroutine has one of a few special names, such as
754 "BEGIN" or "END", then it will be claimed by the appropriate
755 queue for automatic running of phase-related subroutines. In
756 this case the relevant glob will be left not containing any
757 subroutine, even if it did contain one before. In the case of
758 "BEGIN", the subroutine will be executed and the reference to
759 it disposed of before this function returns, and also before
760 its prototype is set. If a "BEGIN" subroutine would not be
761 sufficiently constructed by this function to be ready for
762 execution then the caller must prevent this happening by giving
763 the subroutine a different name.
764 The function returns a pointer to the constructed subroutine.
766 If the sub is anonymous then ownership of one counted reference
767 to the subroutine is transferred to the caller. If the sub is
768 named then the caller does not get ownership of a reference.
769 In most such cases, where the sub has a non-phase name, the sub
770 will be alive at the point it is returned by virtue of being
771 contained in the glob that names it. A phase-named subroutine
772 will usually be alive by virtue of the reference owned by the
773 phase's automatic run queue. But a "BEGIN" subroutine, having
774 already been executed, will quite likely have been destroyed
775 already by the time this function returns, making it erroneous
776 for the caller to make any use of the returned pointer. It is
777 the caller's responsibility to ensure that it knows which of
778 these situations applies.
779 CV * newXS_len_flags(const char *name, STRLEN len,
781 XSUBADDR_t subaddr,
782 const char *const filename,
783 const char *const proto,
784 SV **const_svp, U32 flags)
785 optimize_optree
787 This function applies some optimisations to the optree in top-
788 down order. It is called before the peephole optimizer, which
789 processes ops in execution order. Note that finalize_optree()
790 also does a top-down scan, but is called *after* the peephole
791 optimizer.
792 void optimize_optree(OP* o)
794
796 CX_CURPAD_SAVE
797 Save the current pad in the given context block structure.
798 void CX_CURPAD_SAVE(struct context)
800 CX_CURPAD_SV
802 Access the SV at offset "po" in the saved current pad in the
803 given context block structure (can be used as an lvalue).
804 SV * CX_CURPAD_SV(struct context, PADOFFSET po)
806 PAD_BASE_SV
808 Get the value from slot "po" in the base (DEPTH=1) pad of a
809 padlist
810 SV * PAD_BASE_SV(PADLIST padlist, PADOFFSET po)
812 PAD_CLONE_VARS
814 Clone the state variables associated with running and compiling
815 pads.
816 void PAD_CLONE_VARS(PerlInterpreter *proto_perl,
818 CLONE_PARAMS* param)
819 PAD_COMPNAME_FLAGS
821 Return the flags for the current compiling pad name at offset
822 "po". Assumes a valid slot entry.
823 U32 PAD_COMPNAME_FLAGS(PADOFFSET po)
825 PAD_COMPNAME_GEN
827 The generation number of the name at offset "po" in the current
828 compiling pad (lvalue).
829 STRLEN PAD_COMPNAME_GEN(PADOFFSET po)
831 PAD_COMPNAME_GEN_set
833 Sets the generation number of the name at offset "po" in the
834 current ling pad (lvalue) to "gen".
835 STRLEN PAD_COMPNAME_GEN_set(PADOFFSET po, int gen)
836 PAD_COMPNAME_OURSTASH
838 Return the stash associated with an "our" variable. Assumes
839 the slot entry is a valid "our" lexical.
840 HV * PAD_COMPNAME_OURSTASH(PADOFFSET po)
842 PAD_COMPNAME_PV
844 Return the name of the current compiling pad name at offset
845 "po". Assumes a valid slot entry.
846 char * PAD_COMPNAME_PV(PADOFFSET po)
848 PAD_COMPNAME_TYPE
850 Return the type (stash) of the current compiling pad name at
851 offset "po". Must be a valid name. Returns null if not typed.
852 HV * PAD_COMPNAME_TYPE(PADOFFSET po)
854 PadnameIsOUR
856 Whether this is an "our" variable.
857 bool PadnameIsOUR(PADNAME pn)
859 PadnameIsSTATE
861 Whether this is a "state" variable.
862 bool PadnameIsSTATE(PADNAME pn)
864 PadnameOURSTASH
866 The stash in which this "our" variable was declared.
867 HV * PadnameOURSTASH()
869 PadnameOUTER
871 Whether this entry belongs to an outer pad. Entries for which
872 this is true are often referred to as 'fake'.
873 bool PadnameOUTER(PADNAME pn)
875 PadnameTYPE
877 The stash associated with a typed lexical. This returns the
878 %Foo:: hash for "my Foo $bar".
879 HV * PadnameTYPE(PADNAME pn)
881 PAD_RESTORE_LOCAL
883 Restore the old pad saved into the local variable "opad" by
884 "PAD_SAVE_LOCAL()"
885 void PAD_RESTORE_LOCAL(PAD *opad)
887 PAD_SAVE_LOCAL
889 Save the current pad to the local variable "opad", then make
890 the current pad equal to "npad"
891 void PAD_SAVE_LOCAL(PAD *opad, PAD *npad)
893 PAD_SAVE_SETNULLPAD
895 Save the current pad then set it to null.
896 void PAD_SAVE_SETNULLPAD()
898 PAD_SETSV
900 Set the slot at offset "po" in the current pad to "sv"
901 SV * PAD_SETSV(PADOFFSET po, SV* sv)
903 PAD_SET_CUR
905 Set the current pad to be pad "n" in the padlist, saving the
906 previous current pad. NB currently this macro expands to a
907 string too long for some compilers, so it's best to replace it
908 with
909 SAVECOMPPAD();
911 PAD_SET_CUR_NOSAVE(padlist,n);
912 void PAD_SET_CUR(PADLIST padlist, I32 n)
915 PAD_SET_CUR_NOSAVE
917 like PAD_SET_CUR, but without the save
918 void PAD_SET_CUR_NOSAVE(PADLIST padlist, I32 n)
920 PAD_SV Get the value at offset "po" in the current pad
922 SV * PAD_SV(PADOFFSET po)
924 PAD_SVl Lightweight and lvalue version of "PAD_SV". Get or set the
926 value at offset "po" in the current pad. Unlike "PAD_SV", does
927 not print diagnostics with -DX. For internal use only.
928 SV * PAD_SVl(PADOFFSET po)
930 SAVECLEARSV
932 Clear the pointed to pad value on scope exit. (i.e. the
933 runtime action of "my")
934 void SAVECLEARSV(SV **svp)
936 SAVECOMPPAD
938 save "PL_comppad" and "PL_curpad"
939 void SAVECOMPPAD()
941 SAVEPADSV
943 Save a pad slot (used to restore after an iteration)
944 XXX DAPM it would make more sense to make the arg a PADOFFSET
946 void SAVEPADSV(PADOFFSET po)
947
949 PL_DBsingle
950 When Perl is run in debugging mode, with the -d switch, this SV
951 is a boolean which indicates whether subs are being single-
952 stepped. Single-stepping is automatically turned on after
953 every step. This is the C variable which corresponds to Perl's
954 $DB::single variable. See "PL_DBsub".
955 SV * PL_DBsingle
957 PL_DBsub
959 When Perl is run in debugging mode, with the -d switch, this GV
960 contains the SV which holds the name of the sub being debugged.
961 This is the C variable which corresponds to Perl's $DB::sub
962 variable. See "PL_DBsingle".
963 GV * PL_DBsub
965 PL_DBtrace
967 Trace variable used when Perl is run in debugging mode, with
968 the -d switch. This is the C variable which corresponds to
969 Perl's $DB::trace variable. See "PL_DBsingle".
970 SV * PL_DBtrace
972 PL_dowarn
974 The C variable that roughly corresponds to Perl's $^W warning
975 variable. However, $^W is treated as a boolean, whereas
976 "PL_dowarn" is a collection of flag bits.
977 U8 PL_dowarn
979 PL_last_in_gv
981 The GV which was last used for a filehandle input operation.
982 ("<FH>")
983 GV* PL_last_in_gv
985 PL_ofsgv
987 The glob containing the output field separator - "*," in Perl
988 space.
989 GV* PL_ofsgv
991 PL_rs The input record separator - $/ in Perl space.
993 SV* PL_rs
995
997 djSP Declare Just "SP". This is actually identical to "dSP", and
998 declares a local copy of perl's stack pointer, available via
999 the "SP" macro. See ""SP" in perlapi". (Available for
1000 backward source code compatibility with the old (Perl 5.005)
1001 thread model.)
1002 djSP;
1004 LVRET True if this op will be the return value of an lvalue
1006 subroutine
1007
1009 sv_2num NOTE: this function is experimental and may change or be
1010 removed without notice.
1011 Return an SV with the numeric value of the source SV, doing any
1013 necessary reference or overload conversion. The caller is
1014 expected to have handled get-magic already.
1015 SV* sv_2num(SV *const sv)
1017
1019 An SV (or AV, HV, etc.) is allocated in two parts: the head (struct sv,
1020 av, hv...) contains type and reference count information, and for many
1021 types, a pointer to the body (struct xrv, xpv, xpviv...), which
1022 contains fields specific to each type. Some types store all they need
1023 in the head, so don't have a body.
1024 In all but the most memory-paranoid configurations (ex: PURIFY), heads
1026 and bodies are allocated out of arenas, which by default are
1027 approximately 4K chunks of memory parcelled up into N heads or bodies.
1028 Sv-bodies are allocated by their sv-type, guaranteeing size consistency
1029 needed to allocate safely from arrays.
1030 For SV-heads, the first slot in each arena is reserved, and holds a
1032 link to the next arena, some flags, and a note of the number of slots.
1033 Snaked through each arena chain is a linked list of free items; when
1034 this becomes empty, an extra arena is allocated and divided up into N
1035 items which are threaded into the free list.
1036 SV-bodies are similar, but they use arena-sets by default, which
1038 separate the link and info from the arena itself, and reclaim the 1st
1039 slot in the arena. SV-bodies are further described later.
1040 The following global variables are associated with arenas:
1042 PL_sv_arenaroot pointer to list of SV arenas
1044 PL_sv_root pointer to list of free SV structures
1045 PL_body_arenas head of linked-list of body arenas
1047 PL_body_roots[] array of pointers to list of free bodies of svtype
1048 arrays are indexed by the svtype needed
1049 A few special SV heads are not allocated from an arena, but are instead
1051 directly created in the interpreter structure, eg PL_sv_undef. The
1052 size of arenas can be changed from the default by setting
1053 PERL_ARENA_SIZE appropriately at compile time.
1054 The SV arena serves the secondary purpose of allowing still-live SVs to
1056 be located and destroyed during final cleanup.
1057 At the lowest level, the macros new_SV() and del_SV() grab and free an
1059 SV head. (If debugging with -DD, del_SV() calls the function
1060 S_del_sv() to return the SV to the free list with error checking.)
1061 new_SV() calls more_sv() / sv_add_arena() to add an extra arena if the
1062 free list is empty. SVs in the free list have their SvTYPE field set
1063 to all ones.
1064 At the time of very final cleanup, sv_free_arenas() is called from
1066 perl_destruct() to physically free all the arenas allocated since the
1067 start of the interpreter.
1068 The function visit() scans the SV arenas list, and calls a specified
1070 function for each SV it finds which is still live - ie which has an
1071 SvTYPE other than all 1's, and a non-zero SvREFCNT. visit() is used by
1072 the following functions (specified as [function that calls visit()] /
1073 [function called by visit() for each SV]):
1074 sv_report_used() / do_report_used()
1076 dump all remaining SVs (debugging aid)
1077 sv_clean_objs() / do_clean_objs(),do_clean_named_objs(),
1079 do_clean_named_io_objs(),do_curse()
1080 Attempt to free all objects pointed to by RVs,
1081 try to do the same for all objects indir-
1082 ectly referenced by typeglobs too, and
1083 then do a final sweep, cursing any
1084 objects that remain. Called once from
1085 perl_destruct(), prior to calling sv_clean_all()
1086 below.
1087 sv_clean_all() / do_clean_all()
1089 SvREFCNT_dec(sv) each remaining SV, possibly
1090 triggering an sv_free(). It also sets the
1091 SVf_BREAK flag on the SV to indicate that the
1092 refcnt has been artificially lowered, and thus
1093 stopping sv_free() from giving spurious warnings
1094 about SVs which unexpectedly have a refcnt
1095 of zero. called repeatedly from perl_destruct()
1096 until there are no SVs left.
1097 sv_add_arena
1099 Given a chunk of memory, link it to the head of the list of
1100 arenas, and split it into a list of free SVs.
1101 void sv_add_arena(char *const ptr, const U32 size,
1103 const U32 flags)
1104 sv_clean_all
1106 Decrement the refcnt of each remaining SV, possibly triggering
1107 a cleanup. This function may have to be called multiple times
1108 to free SVs which are in complex self-referential hierarchies.
1109 I32 sv_clean_all()
1111 sv_clean_objs
1113 Attempt to destroy all objects not yet freed.
1114 void sv_clean_objs()
1116 sv_free_arenas
1118 Deallocate the memory used by all arenas. Note that all the
1119 individual SV heads and bodies within the arenas must already
1120 have been freed.
1121 void sv_free_arenas()
1123 SvTHINKFIRST
1125 A quick flag check to see whether an "sv" should be passed to
1126 "sv_force_normal" to be "downgraded" before "SvIVX" or "SvPVX"
1127 can be modified directly.
1128 For example, if your scalar is a reference and you want to
1130 modify the "SvIVX" slot, you can't just do "SvROK_off", as that
1131 will leak the referent.
1132 This is used internally by various sv-modifying functions, such
1134 as "sv_setsv", "sv_setiv" and "sv_pvn_force".
1135 One case that this does not handle is a gv without SvFAKE set.
1137 After
1138 if (SvTHINKFIRST(gv)) sv_force_normal(gv);
1140 it will still be a gv.
1142 "SvTHINKFIRST" sometimes produces false positives. In those
1144 cases "sv_force_normal" does nothing.
1145 U32 SvTHINKFIRST(SV *sv)
1147
1149 find_uninit_var
1150 NOTE: this function is experimental and may change or be
1151 removed without notice.
1152 Find the name of the undefined variable (if any) that caused
1154 the operator to issue a "Use of uninitialized value" warning.
1155 If match is true, only return a name if its value matches
1156 "uninit_sv". So roughly speaking, if a unary operator (such as
1157 "OP_COS") generates a warning, then following the direct child
1158 of the op may yield an "OP_PADSV" or "OP_GV" that gives the
1159 name of the undefined variable. On the other hand, with
1160 "OP_ADD" there are two branches to follow, so we only print the
1161 variable name if we get an exact match. "desc_p" points to a
1162 string pointer holding the description of the op. This may be
1163 updated if needed.
1164 The name is returned as a mortal SV.
1166 Assumes that "PL_op" is the OP that originally triggered the
1168 error, and that "PL_comppad"/"PL_curpad" points to the
1169 currently executing pad.
1170 SV* find_uninit_var(const OP *const obase,
1172 const SV *const uninit_sv,
1173 bool match, const char **desc_p)
1174 isSCRIPT_RUN
1176 Returns a bool as to whether or not the sequence of bytes from
1177 "s" up to but not including "send" form a "script run".
1178 "utf8_target" is TRUE iff the sequence starting at "s" is to be
1179 treated as UTF-8. To be precise, except for two degenerate
1180 cases given below, this function returns TRUE iff all code
1181 points in it come from any combination of three "scripts" given
1182 by the Unicode "Script Extensions" property: Common, Inherited,
1183 and possibly one other. Additionally all decimal digits must
1184 come from the same consecutive sequence of 10.
1185 For example, if all the characters in the sequence are Greek,
1187 or Common, or Inherited, this function will return TRUE,
1188 provided any decimal digits in it are from the same block of
1189 digits in Common. (These are the ASCII digits "0".."9" and
1190 additionally a block for full width forms of these, and several
1191 others used in mathematical notation.) For scripts (unlike
1192 Greek) that have their own digits defined this will accept
1193 either digits from that set or from one of the Common digit
1194 sets, but not a combination of the two. Some scripts, such as
1195 Arabic, have more than one set of digits. All digits must come
1196 from the same set for this function to return TRUE.
1197 *ret_script, if "ret_script" is not NULL, will on return of
1199 TRUE contain the script found, using the "SCX_enum" typedef.
1200 Its value will be "SCX_INVALID" if the function returns FALSE.
1201 If the sequence is empty, TRUE is returned, but *ret_script (if
1203 asked for) will be "SCX_INVALID".
1204 If the sequence contains a single code point which is
1206 unassigned to a character in the version of Unicode being used,
1207 the function will return TRUE, and the script will be
1208 "SCX_Unknown". Any other combination of unassigned code points
1209 in the input sequence will result in the function treating the
1210 input as not being a script run.
1211 The returned script will be "SCX_Inherited" iff all the code
1213 points in it are from the Inherited script.
1214 Otherwise, the returned script will be "SCX_Common" iff all the
1216 code points in it are from the Inherited or Common scripts.
1217 bool isSCRIPT_RUN(const U8 *s, const U8 *send,
1219 const bool utf8_target)
1220 is_utf8_non_invariant_string
1222 Returns TRUE if "is_utf8_invariant_string" in perlapi returns
1223 FALSE for the first "len" bytes of the string "s", but they
1224 are, nonetheless, legal Perl-extended UTF-8; otherwise returns
1225 FALSE.
1226 A TRUE return means that at least one code point represented by
1228 the sequence either is a wide character not representable as a
1229 single byte, or the representation differs depending on whether
1230 the sequence is encoded in UTF-8 or not.
1231 See also ""is_utf8_invariant_string" in perlapi",
1233 ""is_utf8_string" in perlapi"
1234 bool is_utf8_non_invariant_string(const U8* const s,
1236 STRLEN len)
1237 report_uninit
1239 Print appropriate "Use of uninitialized variable" warning.
1240 void report_uninit(const SV *uninit_sv)
1242 variant_under_utf8_count
1244 This function looks at the sequence of bytes between "s" and
1245 "e", which are assumed to be encoded in ASCII/Latin1, and
1246 returns how many of them would change should the string be
1247 translated into UTF-8. Due to the nature of UTF-8, each of
1248 these would occupy two bytes instead of the single one in the
1249 input string. Thus, this function returns the precise number
1250 of bytes the string would expand by when translated to UTF-8.
1251 Unlike most of the other functions that have "utf8" in their
1253 name, the input to this function is NOT a UTF-8-encoded string.
1254 The function name is slightly odd to emphasize this.
1255 This function is internal to Perl because khw thinks that any
1257 XS code that would want this is probably operating too close to
1258 the internals. Presenting a valid use case could change that.
1259 See also ""is_utf8_invariant_string" in perlapi" and
1261 ""is_utf8_invariant_string_loc" in perlapi",
1262 Size_t variant_under_utf8_count(const U8* const s,
1264 const U8* const e)
1265
1267 The following functions are currently undocumented. If you use one of
1268 them, you may wish to consider creating and submitting documentation
1269 for it.
1270 PerlIO_restore_errno
1272 PerlIO_save_errno
1273 PerlLIO_dup2_cloexec
1274 PerlLIO_dup_cloexec
1275 PerlLIO_open3_cloexec
1276 PerlLIO_open_cloexec
1277 PerlProc_pipe_cloexec
1278 PerlSock_accept_cloexec
1279 PerlSock_socket_cloexec
1280 PerlSock_socketpair_cloexec
1281 Slab_Alloc
1282 Slab_Free
1283 Slab_to_ro
1284 Slab_to_rw
1285 _add_range_to_invlist
1286 _byte_dump_string
1287 _core_swash_init
1288 _get_regclass_nonbitmap_data
1289 _get_swash_invlist
1290 _inverse_folds
1291 _invlistEQ
1292 _invlist_array_init
1293 _invlist_contains_cp
1294 _invlist_dump
1295 _invlist_intersection
1296 _invlist_intersection_maybe_complement_2nd
1297 _invlist_invert
1298 _invlist_len
1299 _invlist_populate_swatch
1300 _invlist_search
1301 _invlist_subtract
1302 _invlist_union
1303 _invlist_union_maybe_complement_2nd
1304 _is_grapheme
1305 _is_in_locale_category
1306 _mem_collxfrm
1307 _new_invlist
1308 _new_invlist_C_array
1309 _setup_canned_invlist
1310 _swash_to_invlist
1311 _to_fold_latin1
1312 _to_upper_title_latin1
1313 _warn_problematic_locale
1314 abort_execution
1315 add_cp_to_invlist
1316 alloc_LOGOP
1317 alloc_maybe_populate_EXACT
1318 allocmy
1319 amagic_is_enabled
1320 append_utf8_from_native_byte
1321 apply
1322 av_extend_guts
1323 av_nonelem
1324 av_reify
1325 bind_match
1326 boot_core_PerlIO
1327 boot_core_UNIVERSAL
1328 boot_core_mro
1329 cando
1330 check_utf8_print
1331 ck_anoncode
1332 ck_backtick
1333 ck_bitop
1334 ck_cmp
1335 ck_concat
1336 ck_defined
1337 ck_delete
1338 ck_each
1339 ck_entersub_args_core
1340 ck_eof
1341 ck_eval
1342 ck_exec
1343 ck_exists
1344 ck_ftst
1345 ck_fun
1346 ck_glob
1347 ck_grep
1348 ck_index
1349 ck_join
1350 ck_length
1351 ck_lfun
1352 ck_listiob
1353 ck_match
1354 ck_method
1355 ck_null
1356 ck_open
1357 ck_prototype
1358 ck_readline
1359 ck_refassign
1360 ck_repeat
1361 ck_require
1362 ck_return
1363 ck_rfun
1364 ck_rvconst
1365 ck_sassign
1366 ck_select
1367 ck_shift
1368 ck_smartmatch
1369 ck_sort
1370 ck_spair
1371 ck_split
1372 ck_stringify
1373 ck_subr
1374 ck_substr
1375 ck_svconst
1376 ck_tell
1377 ck_trunc
1378 closest_cop
1379 compute_EXACTish
1380 coresub_op
1381 create_eval_scope
1382 croak_caller
1383 croak_no_mem
1384 croak_popstack
1385 current_re_engine
1386 custom_op_get_field
1387 cv_ckproto_len_flags
1388 cv_clone_into
1389 cv_const_sv_or_av
1390 cv_undef_flags
1391 cvgv_from_hek
1392 cvgv_set
1393 cvstash_set
1394 deb_stack_all
1395 defelem_target
1396 delete_eval_scope
1397 delimcpy_no_escape
1398 die_unwind
1399 do_aexec
1400 do_aexec5
1401 do_eof
1402 do_exec
1403 do_exec3
1404 do_ipcctl
1405 do_ipcget
1406 do_msgrcv
1407 do_msgsnd
1408 do_ncmp
1409 do_open6
1410 do_open_raw
1411 do_print
1412 do_readline
1413 do_seek
1414 do_semop
1415 do_shmio
1416 do_sysseek
1417 do_tell
1418 do_trans
1419 do_vecget
1420 do_vecset
1421 do_vop
1422 does_utf8_overflow
1423 dofile
1424 drand48_init_r
1425 drand48_r
1426 dtrace_probe_call
1427 dtrace_probe_load
1428 dtrace_probe_op
1429 dtrace_probe_phase
1430 dump_all_perl
1431 dump_packsubs_perl
1432 dump_sub_perl
1433 dump_sv_child
1434 emulate_cop_io
1435 feature_is_enabled
1436 find_lexical_cv
1437 find_runcv_where
1438 find_script
1439 form_short_octal_warning
1440 free_tied_hv_pool
1441 get_db_sub
1442 get_debug_opts
1443 get_hash_seed
1444 get_invlist_iter_addr
1445 get_invlist_offset_addr
1446 get_invlist_previous_index_addr
1447 get_no_modify
1448 get_opargs
1449 get_re_arg
1450 getenv_len
1451 grok_atoUV
1452 grok_bslash_c
1453 grok_bslash_o
1454 grok_bslash_x
1455 gv_fetchmeth_internal
1456 gv_override
1457 gv_setref
1458 gv_stashpvn_internal
1459 gv_stashsvpvn_cached
1460 handle_named_backref
1461 hfree_next_entry
1462 hv_backreferences_p
1463 hv_kill_backrefs
1464 hv_placeholders_p
1465 hv_pushkv
1466 hv_undef_flags
1467 init_argv_symbols
1468 init_constants
1469 init_dbargs
1470 init_debugger
1471 init_named_cv
1472 init_uniprops
1473 invert
1474 invlist_array
1475 invlist_clear
1476 invlist_clone
1477 invlist_highest
1478 invlist_is_iterating
1479 invlist_iterfinish
1480 invlist_iterinit
1481 invlist_max
1482 invlist_previous_index
1483 invlist_set_len
1484 invlist_set_previous_index
1485 invlist_trim
1486 io_close
1487 isFF_OVERLONG
1488 isFOO_lc
1489 is_utf8_common
1490 is_utf8_common_with_len
1491 is_utf8_overlong_given_start_byte_ok
1492 isinfnansv
1493 jmaybe
1494 keyword
1495 keyword_plugin_standard
1496 list
1497 localize
1498 magic_clear_all_env
1499 magic_cleararylen_p
1500 magic_clearenv
1501 magic_clearisa
1502 magic_clearpack
1503 magic_clearsig
1504 magic_copycallchecker
1505 magic_existspack
1506 magic_freearylen_p
1507 magic_freeovrld
1508 magic_get
1509 magic_getarylen
1510 magic_getdebugvar
1511 magic_getdefelem
1512 magic_getnkeys
1513 magic_getpack
1514 magic_getpos
1515 magic_getsig
1516 magic_getsubstr
1517 magic_gettaint
1518 magic_getuvar
1519 magic_getvec
1520 magic_killbackrefs
1521 magic_nextpack
1522 magic_regdata_cnt
1523 magic_regdatum_get
1524 magic_regdatum_set
1525 magic_scalarpack
1526 magic_set
1527 magic_set_all_env
1528 magic_setarylen
1529 magic_setcollxfrm
1530 magic_setdbline
1531 magic_setdebugvar
1532 magic_setdefelem
1533 magic_setenv
1534 magic_setisa
1535 magic_setlvref
1536 magic_setmglob
1537 magic_setnkeys
1538 magic_setnonelem
1539 magic_setpack
1540 magic_setpos
1541 magic_setregexp
1542 magic_setsig
1543 magic_setsubstr
1544 magic_settaint
1545 magic_setutf8
1546 magic_setuvar
1547 magic_setvec
1548 magic_sizepack
1549 magic_wipepack
1550 malloc_good_size
1551 malloced_size
1552 mem_collxfrm
1553 mem_log_alloc
1554 mem_log_free
1555 mem_log_realloc
1556 mg_find_mglob
1557 mode_from_discipline
1558 more_bodies
1559 mro_meta_dup
1560 mro_meta_init
1561 multiconcat_stringify
1562 multideref_stringify
1563 my_attrs
1564 my_clearenv
1565 my_lstat_flags
1566 my_memrchr
1567 my_mkostemp
1568 my_mkstemp
1569 my_mkstemp_cloexec
1570 my_stat_flags
1571 my_strerror
1572 my_unexec
1573 newGP
1574 newMETHOP_internal
1575 newSTUB
1576 newSVavdefelem
1577 newXS_deffile
1578 new_warnings_bitfield
1579 nextargv
1580 noperl_die
1581 notify_parser_that_changed_to_utf8
1582 oopsAV
1583 oopsHV
1584 op_clear
1585 op_integerize
1586 op_lvalue_flags
1587 op_refcnt_dec
1588 op_refcnt_inc
1589 op_relocate_sv
1590 op_std_init
1591 op_unscope
1592 opmethod_stash
1593 opslab_force_free
1594 opslab_free
1595 opslab_free_nopad
1596 package
1597 package_version
1598 pad_add_weakref
1599 padlist_store
1600 padname_free
1601 padnamelist_free
1602 parse_unicode_opts
1603 parse_uniprop_string
1604 parser_free
1605 parser_free_nexttoke_ops
1606 path_is_searchable
1607 peep
1608 pmruntime
1609 populate_isa
1610 ptr_hash
1611 qerror
1612 re_exec_indentf
1613 re_indentf
1614 re_op_compile
1615 re_printf
1616 reg_named_buff
1617 reg_named_buff_iter
1618 reg_numbered_buff_fetch
1619 reg_numbered_buff_length
1620 reg_numbered_buff_store
1621 reg_qr_package
1622 reg_skipcomment
1623 reg_temp_copy
1624 regcurly
1625 regprop
1626 report_evil_fh
1627 report_redefined_cv
1628 report_wrongway_fh
1629 rpeep
1630 rsignal_restore
1631 rsignal_save
1632 rxres_save
1633 same_dirent
1634 save_strlen
1635 save_to_buffer
1636 sawparens
1637 scalar
1638 scalarvoid
1639 set_caret_X
1640 set_numeric_standard
1641 set_numeric_underlying
1642 set_padlist
1643 setfd_cloexec
1644 setfd_cloexec_for_nonsysfd
1645 setfd_cloexec_or_inhexec_by_sysfdness
1646 setfd_inhexec
1647 setfd_inhexec_for_sysfd
1648 should_warn_nl
1649 sighandler
1650 softref2xv
1651 ssc_add_range
1652 ssc_clear_locale
1653 ssc_cp_and
1654 ssc_intersection
1655 ssc_union
1656 sub_crush_depth
1657 sv_add_backref
1658 sv_buf_to_ro
1659 sv_del_backref
1660 sv_free2
1661 sv_kill_backrefs
1662 sv_len_utf8_nomg
1663 sv_magicext_mglob
1664 sv_mortalcopy_flags
1665 sv_only_taint_gmagic
1666 sv_or_pv_pos_u2b
1667 sv_resetpvn
1668 sv_sethek
1669 sv_setsv_cow
1670 sv_unglob
1671 swash_fetch
1672 swash_init
1673 tied_method
1674 tmps_grow_p
1675 translate_substr_offsets
1676 try_amagic_bin
1677 try_amagic_un
1678 unshare_hek
1679 utf16_to_utf8
1680 utf16_to_utf8_reversed
1681 utilize
1682 varname
1683 vivify_defelem
1684 vivify_ref
1685 wait4pid
1686 was_lvalue_sub
1687 watch
1688 win32_croak_not_implemented
1689 write_to_stderr
1690 xs_boot_epilog
1691 xs_handshake
1692 yyerror
1693 yyerror_pv
1694 yyerror_pvn
1695 yylex
1696 yyparse
1697 yyquit
1698 yyunlex
1699
1701 The autodocumentation system was originally added to the Perl core by
1702 Benjamin Stuhl. Documentation is by whoever was kind enough to
1703 document their functions.
1704
1706 perlguts, perlapi
1707perl v5.28.2 2019-04-23 PERLINTERN(1)