1PERLINTERN(1) Perl Programmers Reference Guide PERLINTERN(1)
2
6 perlintern - autogenerated documentation of purely internal Perl
7 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 It has the same sections as perlapi, though some may be empty.
16
18 "AvFILLp"
19 If the array "av" is empty, this returns -1; otherwise it returns
20 the maximum value of the indices of all the array elements which
21 are currently defined in "av". It does not handle magic, hence the
22 "p" private indication in its name.
23 SSize_t AvFILLp(AV* av)
25
27 There are only public API items currently in Callback Functions
28
30 There are only public API items currently in Casting
31
33 There are only public API items currently in Character case changing
34
36 There are only public API items currently in Character classification
37
39 There are only public API items currently in Compiler and Preprocessor
40 information
41
43 There are only public API items currently in Compiler directives
44
46 "BhkENTRY"
47 NOTE: "BhkENTRY" is experimental and may change or be removed
48 without notice.
49 Return an entry from the BHK structure. "which" is a preprocessor
51 token indicating which entry to return. If the appropriate flag is
52 not set this will return "NULL". The type of the return value
53 depends on which entry you ask for.
54 void * BhkENTRY(BHK *hk, which)
56 "BhkFLAGS"
58 NOTE: "BhkFLAGS" is experimental and may change or be removed
59 without notice.
60 Return the BHK's flags.
62 U32 BhkFLAGS(BHK *hk)
64 "CALL_BLOCK_HOOKS"
66 NOTE: "CALL_BLOCK_HOOKS" is experimental and may change or be
67 removed without notice.
68 Call all the registered block hooks for type "which". "which" is a
70 preprocessing token; the type of "arg" depends on "which".
71 void CALL_BLOCK_HOOKS(which, arg)
73
75 There are only public API items currently in Concurrency
76
78 There are only public API items currently in COP Hint Hashes
79
81 "core_prototype"
82 This function assigns the prototype of the named core function to
83 "sv", or to a new mortal SV if "sv" is "NULL". It returns the
84 modified "sv", or "NULL" if the core function has no prototype.
85 "code" is a code as returned by "keyword()". It must not be equal
86 to 0.
87 SV * core_prototype(SV *sv, const char *name, const int code,
89 int * const opnum)
90
92 "CvWEAKOUTSIDE"
93 Each CV has a pointer, "CvOUTSIDE()", to its lexically enclosing CV
94 (if any). Because pointers to anonymous sub prototypes are stored
95 in "&" pad slots, it is a possible to get a circular reference,
96 with the parent pointing to the child and vice-versa. To avoid the
97 ensuing memory leak, we do not increment the reference count of the
98 CV pointed to by "CvOUTSIDE" in the one specific instance that the
99 parent has a "&" pad slot pointing back to us. In this case, we
100 set the "CvWEAKOUTSIDE" flag in the child. This allows us to
101 determine under what circumstances we should decrement the refcount
102 of the parent when freeing the child.
103 There is a further complication with non-closure anonymous subs
105 (i.e. those that do not refer to any lexicals outside that sub).
106 In this case, the anonymous prototype is shared rather than being
107 cloned. This has the consequence that the parent may be freed
108 while there are still active children, e.g.,
109 BEGIN { $a = sub { eval '$x' } }
111 In this case, the BEGIN is freed immediately after execution since
113 there are no active references to it: the anon sub prototype has
114 "CvWEAKOUTSIDE" set since it's not a closure, and $a points to the
115 same CV, so it doesn't contribute to BEGIN's refcount either. When
116 $a is executed, the "eval '$x'" causes the chain of "CvOUTSIDE"s to
117 be followed, and the freed BEGIN is accessed.
118 To avoid this, whenever a CV and its associated pad is freed, any
120 "&" entries in the pad are explicitly removed from the pad, and if
121 the refcount of the pointed-to anon sub is still positive, then
122 that child's "CvOUTSIDE" is set to point to its grandparent. This
123 will only occur in the single specific case of a non-closure anon
124 prototype having one or more active references (such as $a above).
125 One other thing to consider is that a CV may be merely undefined
127 rather than freed, eg "undef &foo". In this case, its refcount may
128 not have reached zero, but we still delete its pad and its "CvROOT"
129 etc. Since various children may still have their "CvOUTSIDE"
130 pointing at this undefined CV, we keep its own "CvOUTSIDE" for the
131 time being, so that the chain of lexical scopes is unbroken. For
132 example, the following should print 123:
133 my $x = 123;
135 sub tmp { sub { eval '$x' } }
136 my $a = tmp();
137 undef &tmp;
138 print $a->();
139 bool CvWEAKOUTSIDE(CV *cv)
141 "docatch"
143 Check for the cases 0 or 3 of cur_env.je_ret, only used inside an
144 eval context.
145 0 is used as continue inside eval,
147 3 is used for a die caught by an inner eval - continue inner loop
149 See cop.h: je_mustcatch, when set at any runlevel to TRUE, means
151 eval ops must establish a local jmpenv to handle exception traps.
152 OP* docatch(Perl_ppaddr_t firstpp)
154
156 "free_c_backtrace"
157 Deallocates a backtrace received from get_c_backtrace.
158 void free_c_backtrace(Perl_c_backtrace* bt)
160 "get_c_backtrace"
162 Collects the backtrace (aka "stacktrace") into a single linear
163 malloced buffer, which the caller must "Perl_free_c_backtrace()".
164 Scans the frames back by "depth + skip", then drops the "skip"
166 innermost, returning at most "depth" frames.
167 Perl_c_backtrace* get_c_backtrace(int max_depth, int skip)
169 "PL_DBsingle"
171 When Perl is run in debugging mode, with the -d switch, this SV is
172 a boolean which indicates whether subs are being single-stepped.
173 Single-stepping is automatically turned on after every step. This
174 is the C variable which corresponds to Perl's $DB::single variable.
175 See "PL_DBsub".
176 On threaded perls, each thread has an independent copy of this
178 variable; each initialized at creation time with the current value
179 of the creating thread's copy.
180 SV * PL_DBsingle
182 "PL_DBsub"
184 When Perl is run in debugging mode, with the -d switch, this GV
185 contains the SV which holds the name of the sub being debugged.
186 This is the C variable which corresponds to Perl's $DB::sub
187 variable. See "PL_DBsingle".
188 On threaded perls, each thread has an independent copy of this
190 variable; each initialized at creation time with the current value
191 of the creating thread's copy.
192 GV * PL_DBsub
194 "PL_DBtrace"
196 Trace variable used when Perl is run in debugging mode, with the -d
197 switch. This is the C variable which corresponds to Perl's
198 $DB::trace variable. See "PL_DBsingle".
199 On threaded perls, each thread has an independent copy of this
201 variable; each initialized at creation time with the current value
202 of the creating thread's copy.
203 SV * PL_DBtrace
205
207 There are only public API items currently in Display functions
208
210 "cv_dump"
211 dump the contents of a CV
212 void cv_dump(const CV *cv, const char *title)
214 "cv_forget_slab"
216 When a CV has a reference count on its slab ("CvSLABBED"), it is
217 responsible for making sure it is freed. (Hence, no two CVs should
218 ever have a reference count on the same slab.) The CV only needs
219 to reference the slab during compilation. Once it is compiled and
220 "CvROOT" attached, it has finished its job, so it can forget the
221 slab.
222 void cv_forget_slab(CV *cv)
224 "do_dump_pad"
226 Dump the contents of a padlist
227 void do_dump_pad(I32 level, PerlIO *file, PADLIST *padlist,
229 int full)
230 "pad_alloc_name"
232 Allocates a place in the currently-compiling pad (via "pad_alloc"
233 in perlapi) and then stores a name for that entry. "name" is
234 adopted and becomes the name entry; it must already contain the
235 name string. "typestash" and "ourstash" and the "padadd_STATE"
236 flag get added to "name". None of the other processing of
237 "pad_add_name_pvn" in perlapi is done. Returns the offset of the
238 allocated pad slot.
239 PADOFFSET pad_alloc_name(PADNAME *name, U32 flags, HV *typestash,
241 HV *ourstash)
242 "pad_block_start"
244 Update the pad compilation state variables on entry to a new block.
245 void pad_block_start(int full)
247 "pad_check_dup"
249 Check for duplicate declarations: report any of:
250 * a 'my' in the current scope with the same name;
252 * an 'our' (anywhere in the pad) with the same name and the
253 same stash as 'ourstash'
254 "is_our" indicates that the name to check is an "our" declaration.
256 void pad_check_dup(PADNAME *name, U32 flags, const HV *ourstash)
258 "pad_findlex"
260 Find a named lexical anywhere in a chain of nested pads. Add fake
261 entries in the inner pads if it's found in an outer one.
262 Returns the offset in the bottom pad of the lex or the fake lex.
264 "cv" is the CV in which to start the search, and seq is the current
265 "cop_seq" to match against. If "warn" is true, print appropriate
266 warnings. The "out_"* vars return values, and so are pointers to
267 where the returned values should be stored. "out_capture", if non-
268 null, requests that the innermost instance of the lexical is
269 captured; "out_name" is set to the innermost matched pad name or
270 fake pad name; "out_flags" returns the flags normally associated
271 with the "PARENT_FAKELEX_FLAGS" field of a fake pad name.
272 Note that "pad_findlex()" is recursive; it recurses up the chain of
274 CVs, then comes back down, adding fake entries as it goes. It has
275 to be this way because fake names in anon prototypes have to store
276 in "xpadn_low" the index into the parent pad.
277 PADOFFSET pad_findlex(const char *namepv, STRLEN namelen,
279 U32 flags, const CV* cv, U32 seq, int warn,
280 SV** out_capture, PADNAME** out_name,
281 int *out_flags)
282 "pad_fixup_inner_anons"
284 For any anon CVs in the pad, change "CvOUTSIDE" of that CV from
285 "old_cv" to "new_cv" if necessary. Needed when a newly-compiled CV
286 has to be moved to a pre-existing CV struct.
287 void pad_fixup_inner_anons(PADLIST *padlist, CV *old_cv,
289 CV *new_cv)
290 "pad_free"
292 Free the SV at offset po in the current pad.
293 void pad_free(PADOFFSET po)
295 "pad_leavemy"
297 Cleanup at end of scope during compilation: set the max seq number
298 for lexicals in this scope and warn of any lexicals that never got
299 introduced.
300 OP * pad_leavemy()
302 "padlist_dup"
304 Duplicates a pad.
305 PADLIST * padlist_dup(PADLIST *srcpad, CLONE_PARAMS *param)
307 "padname_dup"
309 Duplicates a pad name.
310 PADNAME * padname_dup(PADNAME *src, CLONE_PARAMS *param)
312 "padnamelist_dup"
314 Duplicates a pad name list.
315 PADNAMELIST * padnamelist_dup(PADNAMELIST *srcpad,
317 CLONE_PARAMS *param)
318 "pad_push"
320 Push a new pad frame onto the padlist, unless there's already a pad
321 at this depth, in which case don't bother creating a new one. Then
322 give the new pad an @_ in slot zero.
323 void pad_push(PADLIST *padlist, int depth)
325 "pad_reset"
327 Mark all the current temporaries for reuse
328 void pad_reset()
330 "pad_setsv"
332 Set the value at offset "po" in the current (compiling or
333 executing) pad. Use the macro "PAD_SETSV()" rather than calling
334 this function directly.
335 void pad_setsv(PADOFFSET po, SV* sv)
337 "pad_sv"
339 Get the value at offset "po" in the current (compiling or
340 executing) pad. Use macro "PAD_SV" instead of calling this
341 function directly.
342 SV* pad_sv(PADOFFSET po)
344 "pad_swipe"
346 Abandon the tmp in the current pad at offset "po" and replace with
347 a new one.
348 void pad_swipe(PADOFFSET po, bool refadjust)
350
352 "dSAVEDERRNO"
353 Declare variables needed to save "errno" and any operating system
354 specific error number.
355 void dSAVEDERRNO
357 "dSAVE_ERRNO"
359 Declare variables needed to save "errno" and any operating system
360 specific error number, and save them for optional later restoration
361 by "RESTORE_ERRNO".
362 void dSAVE_ERRNO
364 "RESTORE_ERRNO"
366 Restore "errno" and any operating system specific error number that
367 was saved by "dSAVE_ERRNO" or "RESTORE_ERRNO".
368 void RESTORE_ERRNO
370 "SAVE_ERRNO"
372 Save "errno" and any operating system specific error number for
373 optional later restoration by "RESTORE_ERRNO". Requires
374 "dSAVEDERRNO" or "dSAVE_ERRNO" in scope.
375 void SAVE_ERRNO
377 "SETERRNO"
379 Set "errno", and on VMS set "vaxc$errno".
380 void SETERRNO(int errcode, int vmserrcode)
382
384 There are only public API items currently in Exception Handling
385 (simple) Macros
386
388 There are only public API items currently in Filesystem configuration
389 values
390
392 There are only public API items currently in Floating point
393 configuration values
394
396 There are only public API items currently in Formats
397
399 There are only public API items currently in General Configuration
400
402 There are only public API items currently in Global Variables
403
405 "gv_stashsvpvn_cached"
406 Returns a pointer to the stash for a specified package, possibly
407 cached. Implements both ""gv_stashpvn"" in perlapi and
408 ""gv_stashsv"" in perlapi.
409 Requires one of either "namesv" or "namepv" to be non-null.
411 If the flag "GV_CACHE_ONLY" is set, return the stash only if found
413 in the cache; see ""gv_stashpvn"" in perlapi for details on the
414 other "flags".
415 Note it is strongly preferred for "namesv" to be non-null, for
417 performance reasons.
418 HV* gv_stashsvpvn_cached(SV *namesv, const char* name,
420 U32 namelen, I32 flags)
421 "gv_try_downgrade"
423 NOTE: "gv_try_downgrade" is experimental and may change or be
424 removed without notice.
425 If the typeglob "gv" can be expressed more succinctly, by having
427 something other than a real GV in its place in the stash, replace
428 it with the optimised form. Basic requirements for this are that
429 "gv" is a real typeglob, is sufficiently ordinary, and is only
430 referenced from its package. This function is meant to be used
431 when a GV has been looked up in part to see what was there, causing
432 upgrading, but based on what was found it turns out that the real
433 GV isn't required after all.
434 If "gv" is a completely empty typeglob, it is deleted from the
436 stash.
437 If "gv" is a typeglob containing only a sufficiently-ordinary
439 constant sub, the typeglob is replaced with a scalar-reference
440 placeholder that more compactly represents the same thing.
441 void gv_try_downgrade(GV* gv)
443
445 There are only public API items currently in Hook manipulation
446
448 "hv_ename_add"
449 Adds a name to a stash's internal list of effective names. See
450 "hv_ename_delete".
451 This is called when a stash is assigned to a new location in the
453 symbol table.
454 void hv_ename_add(HV *hv, const char *name, U32 len, U32 flags)
456 "hv_ename_delete"
458 Removes a name from a stash's internal list of effective names. If
459 this is the name returned by "HvENAME", then another name in the
460 list will take its place ("HvENAME" will use it).
461 This is called when a stash is deleted from the symbol table.
463 void hv_ename_delete(HV *hv, const char *name, U32 len,
465 U32 flags)
466 "refcounted_he_chain_2hv"
468 Generates and returns a "HV *" representing the content of a
469 "refcounted_he" chain. "flags" is currently unused and must be
470 zero.
471 HV * refcounted_he_chain_2hv(const struct refcounted_he *c,
473 U32 flags)
474 "refcounted_he_fetch_pv"
476 Like "refcounted_he_fetch_pvn", but takes a nul-terminated string
477 instead of a string/length pair.
478 SV * refcounted_he_fetch_pv(const struct refcounted_he *chain,
480 const char *key, U32 hash, U32 flags)
481 "refcounted_he_fetch_pvn"
483 Search along a "refcounted_he" chain for an entry with the key
484 specified by "keypv" and "keylen". If "flags" has the
485 "REFCOUNTED_HE_KEY_UTF8" bit set, the key octets are interpreted as
486 UTF-8, otherwise they are interpreted as Latin-1. "hash" is a
487 precomputed hash of the key string, or zero if it has not been
488 precomputed. Returns a mortal scalar representing the value
489 associated with the key, or &PL_sv_placeholder if there is no value
490 associated with the key.
491 SV * refcounted_he_fetch_pvn(const struct refcounted_he *chain,
493 const char *keypv, STRLEN keylen,
494 U32 hash, U32 flags)
495 "refcounted_he_fetch_pvs"
497 Like "refcounted_he_fetch_pvn", but takes a literal string instead
498 of a string/length pair, and no precomputed hash.
499 SV * refcounted_he_fetch_pvs(const struct refcounted_he *chain,
501 "key", U32 flags)
502 "refcounted_he_fetch_sv"
504 Like "refcounted_he_fetch_pvn", but takes a Perl scalar instead of
505 a string/length pair.
506 SV * refcounted_he_fetch_sv(const struct refcounted_he *chain,
508 SV *key, U32 hash, U32 flags)
509 "refcounted_he_free"
511 Decrements the reference count of a "refcounted_he" by one. If the
512 reference count reaches zero the structure's memory is freed, which
513 (recursively) causes a reduction of its parent "refcounted_he"'s
514 reference count. It is safe to pass a null pointer to this
515 function: no action occurs in this case.
516 void refcounted_he_free(struct refcounted_he *he)
518 "refcounted_he_inc"
520 Increment the reference count of a "refcounted_he". The pointer to
521 the "refcounted_he" is also returned. It is safe to pass a null
522 pointer to this function: no action occurs and a null pointer is
523 returned.
524 struct refcounted_he * refcounted_he_inc(
526 struct refcounted_he *he)
527 "refcounted_he_new_pv"
529 Like "refcounted_he_new_pvn", but takes a nul-terminated string
530 instead of a string/length pair.
531 struct refcounted_he * refcounted_he_new_pv(
533 struct refcounted_he *parent,
534 const char *key, U32 hash,
535 SV *value, U32 flags)
536 "refcounted_he_new_pvn"
538 Creates a new "refcounted_he". This consists of a single key/value
539 pair and a reference to an existing "refcounted_he" chain (which
540 may be empty), and thus forms a longer chain. When using the
541 longer chain, the new key/value pair takes precedence over any
542 entry for the same key further along the chain.
543 The new key is specified by "keypv" and "keylen". If "flags" has
545 the "REFCOUNTED_HE_KEY_UTF8" bit set, the key octets are
546 interpreted as UTF-8, otherwise they are interpreted as Latin-1.
547 "hash" is a precomputed hash of the key string, or zero if it has
548 not been precomputed.
549 "value" is the scalar value to store for this key. "value" is
551 copied by this function, which thus does not take ownership of any
552 reference to it, and later changes to the scalar will not be
553 reflected in the value visible in the "refcounted_he". Complex
554 types of scalar will not be stored with referential integrity, but
555 will be coerced to strings. "value" may be either null or
556 &PL_sv_placeholder to indicate that no value is to be associated
557 with the key; this, as with any non-null value, takes precedence
558 over the existence of a value for the key further along the chain.
559 "parent" points to the rest of the "refcounted_he" chain to be
561 attached to the new "refcounted_he". This function takes ownership
562 of one reference to "parent", and returns one reference to the new
563 "refcounted_he".
564 struct refcounted_he * refcounted_he_new_pvn(
566 struct refcounted_he *parent,
567 const char *keypv,
568 STRLEN keylen, U32 hash,
569 SV *value, U32 flags)
570 "refcounted_he_new_pvs"
572 Like "refcounted_he_new_pvn", but takes a literal string instead of
573 a string/length pair, and no precomputed hash.
574 struct refcounted_he * refcounted_he_new_pvs(
576 struct refcounted_he *parent,
577 "key", SV *value, U32 flags)
578 "refcounted_he_new_sv"
580 Like "refcounted_he_new_pvn", but takes a Perl scalar instead of a
581 string/length pair.
582 struct refcounted_he * refcounted_he_new_sv(
584 struct refcounted_he *parent,
585 SV *key, U32 hash, SV *value,
586 U32 flags)
587
589 "PL_last_in_gv"
590 The GV which was last used for a filehandle input operation.
591 ("<FH>")
592 On threaded perls, each thread has an independent copy of this
594 variable; each initialized at creation time with the current value
595 of the creating thread's copy.
596 GV* PL_last_in_gv
598 "PL_ofsgv"
600 The glob containing the output field separator - "*," in Perl
601 space.
602 On threaded perls, each thread has an independent copy of this
604 variable; each initialized at creation time with the current value
605 of the creating thread's copy.
606 GV* PL_ofsgv
608 "PL_rs"
610 The input record separator - $/ in Perl space.
611 On threaded perls, each thread has an independent copy of this
613 variable; each initialized at creation time with the current value
614 of the creating thread's copy.
615 SV* PL_rs
617 "start_glob"
619 NOTE: "start_glob" is experimental and may change or be removed
620 without notice.
621 Function called by "do_readline" to spawn a glob (or do the glob
623 inside perl on VMS). This code used to be inline, but now perl
624 uses "File::Glob" this glob starter is only used by miniperl during
625 the build process, or when PERL_EXTERNAL_GLOB is defined. Moving
626 it away shrinks pp_hot.c; shrinking pp_hot.c helps speed perl up.
627 NOTE: "start_glob" must be explicitly called as "Perl_start_glob"
629 with an "aTHX_" parameter.
630 PerlIO* Perl_start_glob(pTHX_ SV *tmpglob, IO *io)
632
634 There are only public API items currently in Integer configuration
635 values
636
638 "validate_proto"
639 NOTE: "validate_proto" is experimental and may change or be removed
640 without notice.
641 This function performs syntax checking on a prototype, "proto". If
643 "warn" is true, any illegal characters or mismatched brackets will
644 trigger illegalproto warnings, declaring that they were detected in
645 the prototype for "name".
646 The return value is "true" if this is a valid prototype, and
648 "false" if it is not, regardless of whether "warn" was "true" or
649 "false".
650 Note that "NULL" is a valid "proto" and will always return "true".
652 bool validate_proto(SV *name, SV *proto, bool warn,
654 bool curstash)
655
657 There are only public API items currently in Locales
658
660 "magic_clearhint"
661 Triggered by a delete from "%^H", records the key to
662 "PL_compiling.cop_hints_hash".
663 int magic_clearhint(SV* sv, MAGIC* mg)
665 "magic_clearhints"
667 Triggered by clearing "%^H", resets "PL_compiling.cop_hints_hash".
668 int magic_clearhints(SV* sv, MAGIC* mg)
670 "magic_methcall"
672 Invoke a magic method (like FETCH).
673 "sv" and "mg" are the tied thingy and the tie magic.
675 "meth" is the name of the method to call.
677 "argc" is the number of args (in addition to $self) to pass to the
679 method.
680 The "flags" can be:
682 G_DISCARD invoke method with G_DISCARD flag and don't
684 return a value
685 G_UNDEF_FILL fill the stack with argc pointers to
686 PL_sv_undef
687 The arguments themselves are any values following the "flags"
689 argument.
690 Returns the SV (if any) returned by the method, or "NULL" on
692 failure.
693 NOTE: "magic_methcall" must be explicitly called as
695 "Perl_magic_methcall" with an "aTHX_" parameter.
696 SV* Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, SV *meth,
698 U32 flags, U32 argc, ...)
699 "magic_sethint"
701 Triggered by a store to "%^H", records the key/value pair to
702 "PL_compiling.cop_hints_hash". It is assumed that hints aren't
703 storing anything that would need a deep copy. Maybe we should warn
704 if we find a reference.
705 int magic_sethint(SV* sv, MAGIC* mg)
707 "mg_localize"
709 Copy some of the magic from an existing SV to new localized version
710 of that SV. Container magic (e.g., %ENV, $1, "tie") gets copied,
711 value magic doesn't (e.g., "taint", "pos").
712 If "setmagic" is false then no set magic will be called on the new
714 (empty) SV. This typically means that assignment will soon follow
715 (e.g. 'local $x = $y'), and that will handle the magic.
716 void mg_localize(SV* sv, SV* nsv, bool setmagic)
718
720 There are only public API items currently in Memory Management
721
723 "mro_get_linear_isa_dfs"
724 Returns the Depth-First Search linearization of @ISA the given
725 stash. The return value is a read-only AV*. "level" should be 0
726 (it is used internally in this function's recursion).
727 You are responsible for "SvREFCNT_inc()" on the return value if you
729 plan to store it anywhere semi-permanently (otherwise it might be
730 deleted out from under you the next time the cache is invalidated).
731 AV* mro_get_linear_isa_dfs(HV* stash, U32 level)
733 "mro_isa_changed_in"
735 Takes the necessary steps (cache invalidations, mostly) when the
736 @ISA of the given package has changed. Invoked by the "setisa"
737 magic, should not need to invoke directly.
738 void mro_isa_changed_in(HV* stash)
740 "mro_package_moved"
742 Call this function to signal to a stash that it has been assigned
743 to another spot in the stash hierarchy. "stash" is the stash that
744 has been assigned. "oldstash" is the stash it replaces, if any.
745 "gv" is the glob that is actually being assigned to.
746 This can also be called with a null first argument to indicate that
748 "oldstash" has been deleted.
749 This function invalidates isa caches on the old stash, on all
751 subpackages nested inside it, and on the subclasses of all those,
752 including non-existent packages that have corresponding entries in
753 "stash".
754 It also sets the effective names ("HvENAME") on all the stashes as
756 appropriate.
757 If the "gv" is present and is not in the symbol table, then this
759 function simply returns. This checked will be skipped if "flags &
760 1".
761 void mro_package_moved(HV * const stash, HV * const oldstash,
763 const GV * const gv, U32 flags)
764
766 There are only public API items currently in Multicall Functions
767
769 "grok_atoUV"
770 parse a string, looking for a decimal unsigned integer.
771 On entry, "pv" points to the beginning of the string; "valptr"
773 points to a UV that will receive the converted value, if found;
774 "endptr" is either NULL or points to a variable that points to one
775 byte beyond the point in "pv" that this routine should examine. If
776 "endptr" is NULL, "pv" is assumed to be NUL-terminated.
777 Returns FALSE if "pv" doesn't represent a valid unsigned integer
779 value (with no leading zeros). Otherwise it returns TRUE, and sets
780 *valptr to that value.
781 If you constrain the portion of "pv" that is looked at by this
783 function (by passing a non-NULL "endptr"), and if the intial bytes
784 of that portion form a valid value, it will return TRUE, setting
785 *endptr to the byte following the final digit of the value. But if
786 there is no constraint at what's looked at, all of "pv" must be
787 valid in order for TRUE to be returned. *endptr is unchanged from
788 its value on input if FALSE is returned;
789 The only characters this accepts are the decimal digits '0'..'9'.
791 As opposed to atoi(3) or strtol(3), "grok_atoUV" does NOT allow
793 optional leading whitespace, nor negative inputs. If such features
794 are required, the calling code needs to explicitly implement those.
795 Note that this function returns FALSE for inputs that would
797 overflow a UV, or have leading zeros. Thus a single 0 is accepted,
798 but not 00 nor 01, 002, etc.
799 Background: "atoi" has severe problems with illegal inputs, it
801 cannot be used for incremental parsing, and therefore should be
802 avoided "atoi" and "strtol" are also affected by locale settings,
803 which can also be seen as a bug (global state controlled by user
804 environment).
805 bool grok_atoUV(const char* pv, UV* valptr, const char** endptr)
807 "isinfnansv"
809 Checks whether the argument would be either an infinity or "NaN"
810 when used as a number, but is careful not to trigger non-numeric or
811 uninitialized warnings. it assumes the caller has done
812 "SvGETMAGIC(sv)" already.
813 bool isinfnansv(SV *sv)
815
817 There are only public API items currently in Optree construction
818
820 "finalize_optree"
821 This function finalizes the optree. Should be called directly
822 after the complete optree is built. It does some additional
823 checking which can't be done in the normal "ck_"xxx functions and
824 makes the tree thread-safe.
825 void finalize_optree(OP* o)
827 "newATTRSUB_x"
829 Construct a Perl subroutine, also performing some surrounding jobs.
830 This function is expected to be called in a Perl compilation
832 context, and some aspects of the subroutine are taken from global
833 variables associated with compilation. In particular, "PL_compcv"
834 represents the subroutine that is currently being compiled. It
835 must be non-null when this function is called, and some aspects of
836 the subroutine being constructed are taken from it. The
837 constructed subroutine may actually be a reuse of the "PL_compcv"
838 object, but will not necessarily be so.
839 If "block" is null then the subroutine will have no body, and for
841 the time being it will be an error to call it. This represents a
842 forward subroutine declaration such as "sub foo ($$);". If "block"
843 is non-null then it provides the Perl code of the subroutine body,
844 which will be executed when the subroutine is called. This body
845 includes any argument unwrapping code resulting from a subroutine
846 signature or similar. The pad use of the code must correspond to
847 the pad attached to "PL_compcv". The code is not expected to
848 include a "leavesub" or "leavesublv" op; this function will add
849 such an op. "block" is consumed by this function and will become
850 part of the constructed subroutine.
851 "proto" specifies the subroutine's prototype, unless one is
853 supplied as an attribute (see below). If "proto" is null, then the
854 subroutine will not have a prototype. If "proto" is non-null, it
855 must point to a "const" op whose value is a string, and the
856 subroutine will have that string as its prototype. If a prototype
857 is supplied as an attribute, the attribute takes precedence over
858 "proto", but in that case "proto" should preferably be null. In
859 any case, "proto" is consumed by this function.
860 "attrs" supplies attributes to be applied the subroutine. A
862 handful of attributes take effect by built-in means, being applied
863 to "PL_compcv" immediately when seen. Other attributes are
864 collected up and attached to the subroutine by this route. "attrs"
865 may be null to supply no attributes, or point to a "const" op for a
866 single attribute, or point to a "list" op whose children apart from
867 the "pushmark" are "const" ops for one or more attributes. Each
868 "const" op must be a string, giving the attribute name optionally
869 followed by parenthesised arguments, in the manner in which
870 attributes appear in Perl source. The attributes will be applied
871 to the sub by this function. "attrs" is consumed by this function.
872 If "o_is_gv" is false and "o" is null, then the subroutine will be
874 anonymous. If "o_is_gv" is false and "o" is non-null, then "o"
875 must point to a "const" OP, which will be consumed by this
876 function, and its string value supplies a name for the subroutine.
877 The name may be qualified or unqualified, and if it is unqualified
878 then a default stash will be selected in some manner. If "o_is_gv"
879 is true, then "o" doesn't point to an "OP" at all, but is instead a
880 cast pointer to a "GV" by which the subroutine will be named.
881 If there is already a subroutine of the specified name, then the
883 new sub will either replace the existing one in the glob or be
884 merged with the existing one. A warning may be generated about
885 redefinition.
886 If the subroutine has one of a few special names, such as "BEGIN"
888 or "END", then it will be claimed by the appropriate queue for
889 automatic running of phase-related subroutines. In this case the
890 relevant glob will be left not containing any subroutine, even if
891 it did contain one before. In the case of "BEGIN", the subroutine
892 will be executed and the reference to it disposed of before this
893 function returns.
894 The function returns a pointer to the constructed subroutine. If
896 the sub is anonymous then ownership of one counted reference to the
897 subroutine is transferred to the caller. If the sub is named then
898 the caller does not get ownership of a reference. In most such
899 cases, where the sub has a non-phase name, the sub will be alive at
900 the point it is returned by virtue of being contained in the glob
901 that names it. A phase-named subroutine will usually be alive by
902 virtue of the reference owned by the phase's automatic run queue.
903 But a "BEGIN" subroutine, having already been executed, will quite
904 likely have been destroyed already by the time this function
905 returns, making it erroneous for the caller to make any use of the
906 returned pointer. It is the caller's responsibility to ensure that
907 it knows which of these situations applies.
908 CV* newATTRSUB_x(I32 floor, OP *o, OP *proto, OP *attrs,
910 OP *block, bool o_is_gv)
911 "newXS_len_flags"
913 Construct an XS subroutine, also performing some surrounding jobs.
914 The subroutine will have the entry point "subaddr". It will have
916 the prototype specified by the nul-terminated string "proto", or no
917 prototype if "proto" is null. The prototype string is copied; the
918 caller can mutate the supplied string afterwards. If "filename" is
919 non-null, it must be a nul-terminated filename, and the subroutine
920 will have its "CvFILE" set accordingly. By default "CvFILE" is set
921 to point directly to the supplied string, which must be static. If
922 "flags" has the "XS_DYNAMIC_FILENAME" bit set, then a copy of the
923 string will be taken instead.
924 Other aspects of the subroutine will be left in their default
926 state. If anything else needs to be done to the subroutine for it
927 to function correctly, it is the caller's responsibility to do that
928 after this function has constructed it. However, beware of the
929 subroutine potentially being destroyed before this function
930 returns, as described below.
931 If "name" is null then the subroutine will be anonymous, with its
933 "CvGV" referring to an "__ANON__" glob. If "name" is non-null then
934 the subroutine will be named accordingly, referenced by the
935 appropriate glob. "name" is a string of length "len" bytes giving
936 a sigilless symbol name, in UTF-8 if "flags" has the "SVf_UTF8" bit
937 set and in Latin-1 otherwise. The name may be either qualified or
938 unqualified, with the stash defaulting in the same manner as for
939 "gv_fetchpvn_flags". "flags" may contain flag bits understood by
940 "gv_fetchpvn_flags" with the same meaning as they have there, such
941 as "GV_ADDWARN". The symbol is always added to the stash if
942 necessary, with "GV_ADDMULTI" semantics.
943 If there is already a subroutine of the specified name, then the
945 new sub will replace the existing one in the glob. A warning may
946 be generated about the redefinition. If the old subroutine was
947 "CvCONST" then the decision about whether to warn is influenced by
948 an expectation about whether the new subroutine will become a
949 constant of similar value. That expectation is determined by
950 "const_svp". (Note that the call to this function doesn't make the
951 new subroutine "CvCONST" in any case; that is left to the caller.)
952 If "const_svp" is null then it indicates that the new subroutine
953 will not become a constant. If "const_svp" is non-null then it
954 indicates that the new subroutine will become a constant, and it
955 points to an "SV*" that provides the constant value that the
956 subroutine will have.
957 If the subroutine has one of a few special names, such as "BEGIN"
959 or "END", then it will be claimed by the appropriate queue for
960 automatic running of phase-related subroutines. In this case the
961 relevant glob will be left not containing any subroutine, even if
962 it did contain one before. In the case of "BEGIN", the subroutine
963 will be executed and the reference to it disposed of before this
964 function returns, and also before its prototype is set. If a
965 "BEGIN" subroutine would not be sufficiently constructed by this
966 function to be ready for execution then the caller must prevent
967 this happening by giving the subroutine a different name.
968 The function returns a pointer to the constructed subroutine. If
970 the sub is anonymous then ownership of one counted reference to the
971 subroutine is transferred to the caller. If the sub is named then
972 the caller does not get ownership of a reference. In most such
973 cases, where the sub has a non-phase name, the sub will be alive at
974 the point it is returned by virtue of being contained in the glob
975 that names it. A phase-named subroutine will usually be alive by
976 virtue of the reference owned by the phase's automatic run queue.
977 But a "BEGIN" subroutine, having already been executed, will quite
978 likely have been destroyed already by the time this function
979 returns, making it erroneous for the caller to make any use of the
980 returned pointer. It is the caller's responsibility to ensure that
981 it knows which of these situations applies.
982 CV * newXS_len_flags(const char *name, STRLEN len,
984 XSUBADDR_t subaddr,
985 const char *const filename,
986 const char *const proto, SV **const_svp,
987 U32 flags)
988 "optimize_optree"
990 This function applies some optimisations to the optree in top-down
991 order. It is called before the peephole optimizer, which processes
992 ops in execution order. Note that finalize_optree() also does a
993 top-down scan, but is called *after* the peephole optimizer.
994 void optimize_optree(OP* o)
996 "traverse_op_tree"
998 Return the next op in a depth-first traversal of the op tree,
999 returning NULL when the traversal is complete.
1000 The initial call must supply the root of the tree as both top and
1002 o.
1003 For now it's static, but it may be exposed to the API in the
1005 future.
1006 OP* traverse_op_tree(OP* top, OP* o)
1008
1010 There are only public API items currently in Pack and Unpack
1011
1013 "CX_CURPAD_SAVE"
1014 Save the current pad in the given context block structure.
1015 void CX_CURPAD_SAVE(struct context)
1017 "CX_CURPAD_SV"
1019 Access the SV at offset "po" in the saved current pad in the given
1020 context block structure (can be used as an lvalue).
1021 SV * CX_CURPAD_SV(struct context, PADOFFSET po)
1023 "PAD_BASE_SV"
1025 Get the value from slot "po" in the base (DEPTH=1) pad of a padlist
1026 SV * PAD_BASE_SV(PADLIST padlist, PADOFFSET po)
1028 "PAD_CLONE_VARS"
1030 Clone the state variables associated with running and compiling
1031 pads.
1032 void PAD_CLONE_VARS(PerlInterpreter *proto_perl,
1034 CLONE_PARAMS* param)
1035 "PAD_COMPNAME_FLAGS"
1037 Return the flags for the current compiling pad name at offset "po".
1038 Assumes a valid slot entry.
1039 U32 PAD_COMPNAME_FLAGS(PADOFFSET po)
1041 "PAD_COMPNAME_GEN"
1043 The generation number of the name at offset "po" in the current
1044 compiling pad (lvalue).
1045 STRLEN PAD_COMPNAME_GEN(PADOFFSET po)
1047 "PAD_COMPNAME_GEN_set"
1049 Sets the generation number of the name at offset "po" in the
1050 current ling pad (lvalue) to "gen".
1051 STRLEN PAD_COMPNAME_GEN_set(PADOFFSET po, int gen)
1053 "PAD_COMPNAME_OURSTASH"
1055 Return the stash associated with an "our" variable. Assumes the
1056 slot entry is a valid "our" lexical.
1057 HV * PAD_COMPNAME_OURSTASH(PADOFFSET po)
1059 "PAD_COMPNAME_PV"
1061 Return the name of the current compiling pad name at offset "po".
1062 Assumes a valid slot entry.
1063 char * PAD_COMPNAME_PV(PADOFFSET po)
1065 "PAD_COMPNAME_TYPE"
1067 Return the type (stash) of the current compiling pad name at offset
1068 "po". Must be a valid name. Returns null if not typed.
1069 HV * PAD_COMPNAME_TYPE(PADOFFSET po)
1071 "PadnameIsOUR"
1073 Whether this is an "our" variable.
1074 bool PadnameIsOUR(PADNAME * pn)
1076 "PadnameIsSTATE"
1078 Whether this is a "state" variable.
1079 bool PadnameIsSTATE(PADNAME * pn)
1081 "PadnameOURSTASH"
1083 The stash in which this "our" variable was declared.
1084 HV * PadnameOURSTASH(PADNAME * pn)
1086 "PadnameOUTER"
1088 Whether this entry belongs to an outer pad. Entries for which this
1089 is true are often referred to as 'fake'.
1090 bool PadnameOUTER(PADNAME * pn)
1092 "PadnameTYPE"
1094 The stash associated with a typed lexical. This returns the %Foo::
1095 hash for "my Foo $bar".
1096 HV * PadnameTYPE(PADNAME * pn)
1098 "PAD_RESTORE_LOCAL"
1100 Restore the old pad saved into the local variable "opad" by
1101 "PAD_SAVE_LOCAL()"
1102 void PAD_RESTORE_LOCAL(PAD *opad)
1104 "PAD_SAVE_LOCAL"
1106 Save the current pad to the local variable "opad", then make the
1107 current pad equal to "npad"
1108 void PAD_SAVE_LOCAL(PAD *opad, PAD *npad)
1110 "PAD_SAVE_SETNULLPAD"
1112 Save the current pad then set it to null.
1113 void PAD_SAVE_SETNULLPAD()
1115 "PAD_SETSV"
1117 Set the slot at offset "po" in the current pad to "sv"
1118 SV * PAD_SETSV(PADOFFSET po, SV* sv)
1120 "PAD_SET_CUR"
1122 Set the current pad to be pad "n" in the padlist, saving the
1123 previous current pad. NB currently this macro expands to a string
1124 too long for some compilers, so it's best to replace it with
1125 SAVECOMPPAD();
1127 PAD_SET_CUR_NOSAVE(padlist,n);
1128 void PAD_SET_CUR(PADLIST padlist, I32 n)
1130 "PAD_SET_CUR_NOSAVE"
1132 like PAD_SET_CUR, but without the save
1133 void PAD_SET_CUR_NOSAVE(PADLIST padlist, I32 n)
1135 "PAD_SV"
1137 Get the value at offset "po" in the current pad
1138 SV * PAD_SV(PADOFFSET po)
1140 "PAD_SVl"
1142 Lightweight and lvalue version of "PAD_SV". Get or set the value
1143 at offset "po" in the current pad. Unlike "PAD_SV", does not print
1144 diagnostics with -DX. For internal use only.
1145 SV * PAD_SVl(PADOFFSET po)
1147 "SAVECLEARSV"
1149 Clear the pointed to pad value on scope exit. (i.e. the runtime
1150 action of "my")
1151 void SAVECLEARSV(SV **svp)
1153 "SAVECOMPPAD"
1155 save "PL_comppad" and "PL_curpad"
1156 void SAVECOMPPAD()
1158 "SAVEPADSV"
1160 Save a pad slot (used to restore after an iteration)
1161 void SAVEPADSV(PADOFFSET po)
1163
1165 There are only public API items currently in Password and Group access
1166
1168 There are only public API items currently in Paths to system commands
1169
1171 There are only public API items currently in Prototype information
1172
1174 There are only public API items currently in REGEXP Functions
1175
1177 There are only public API items currently in Signals
1178
1180 There are only public API items currently in Site configuration
1181
1183 There are only public API items currently in Sockets configuration
1184 values
1185
1187 There are only public API items currently in Source Filters
1188
1190 "djSP"
1191 Declare Just "SP". This is actually identical to "dSP", and
1192 declares a local copy of perl's stack pointer, available via the
1193 "SP" macro. See ""SP" in perlapi". (Available for backward source
1194 code compatibility with the old (Perl 5.005) thread model.)
1195 djSP();
1197 "LVRET"
1199 True if this op will be the return value of an lvalue subroutine
1200
1202 "delimcpy_no_escape"
1203 Copy a source buffer to a destination buffer, stopping at (but not
1204 including) the first occurrence in the source of the delimiter
1205 byte, "delim". The source is the bytes between
1206 "from" and "from_end" - 1. Similarly, the dest is "to" up to
1207 "to_end".
1208 The number of bytes copied is written to *retlen.
1210 Returns the position of "delim" in the "from" buffer, but if there
1212 is no such occurrence before "from_end", then "from_end" is
1213 returned, and the entire buffer "from" .. "from_end" - 1 is copied.
1214 If there is room in the destination available after the copy, an
1216 extra terminating safety "NUL" byte is appended (not included in
1217 the returned length).
1218 The error case is if the destination buffer is not large enough to
1220 accommodate everything that should be copied. In this situation, a
1221 value larger than "to_end" - "to" is written to *retlen, and as
1222 much of the source as fits will be written to the destination. Not
1223 having room for the safety "NUL" is not considered an error.
1224 char* delimcpy_no_escape(char* to, const char* to_end,
1226 const char* from, const char* from_end,
1227 const int delim, I32* retlen)
1228 "quadmath_format_needed"
1230 "quadmath_format_needed()" returns true if the "format" string
1231 seems to contain at least one non-Q-prefixed "%[efgaEFGA]" format
1232 specifier, or returns false otherwise.
1233 The format specifier detection is not complete printf-syntax
1235 detection, but it should catch most common cases.
1236 If true is returned, those arguments should in theory be processed
1238 with "quadmath_snprintf()", but in case there is more than one such
1239 format specifier (see "quadmath_format_valid"), and if there is
1240 anything else beyond that one (even just a single byte), they
1241 cannot be processed because "quadmath_snprintf()" is very strict,
1242 accepting only one format spec, and nothing else. In this case,
1243 the code should probably fail.
1244 bool quadmath_format_needed(const char* format)
1246 "quadmath_format_valid"
1248 "quadmath_snprintf()" is very strict about its "format" string and
1249 will fail, returning -1, if the format is invalid. It accepts
1250 exactly one format spec.
1251 "quadmath_format_valid()" checks that the intended single spec
1253 looks sane: begins with "%", has only one "%", ends with
1254 "[efgaEFGA]", and has "Q" before it. This is not a full "printf
1255 syntax check", just the basics.
1256 Returns true if it is valid, false if not.
1258 See also "quadmath_format_needed".
1260 bool quadmath_format_valid(const char* format)
1262
1264 "SVt_INVLIST"
1265 Type flag for scalars. See "svtype" in perlapi.
1266
1268 "PL_Sv"
1269 A scratch pad SV for whatever temporary use you need. Chiefly used
1270 as a fallback by macros on platforms where
1271 "PERL_USE_GCC_BRACE_GROUPS" in perlapi> is unavailable, and which
1272 would otherwise evaluate their SV parameter more than once.
1273 PL_Sv
1275 "sv_2bool"
1277 This macro is only used by "sv_true()" or its macro equivalent, and
1278 only if the latter's argument is neither "SvPOK", "SvIOK" nor
1279 "SvNOK". It calls "sv_2bool_flags" with the "SV_GMAGIC" flag.
1280 bool sv_2bool(SV *const sv)
1282 "sv_2bool_flags"
1284 This function is only used by "sv_true()" and friends, and only if
1285 the latter's argument is neither "SvPOK", "SvIOK" nor "SvNOK". If
1286 the flags contain "SV_GMAGIC", then it does an "mg_get()" first.
1287 bool sv_2bool_flags(SV *sv, I32 flags)
1289 "sv_2num"
1291 NOTE: "sv_2num" is experimental and may change or be removed
1292 without notice.
1293 Return an SV with the numeric value of the source SV, doing any
1295 necessary reference or overload conversion. The caller is expected
1296 to have handled get-magic already.
1297 SV* sv_2num(SV *const sv)
1299 "sv_2pvbyte_nolen"
1301 Return a pointer to the byte-encoded representation of the SV. May
1302 cause the SV to be downgraded from UTF-8 as a side-effect.
1303 Usually accessed via the "SvPVbyte_nolen" macro.
1305 char* sv_2pvbyte_nolen(SV* sv)
1307 "sv_2pvutf8_nolen"
1309 Return a pointer to the UTF-8-encoded representation of the SV.
1310 May cause the SV to be upgraded to UTF-8 as a side-effect.
1311 Usually accessed via the "SvPVutf8_nolen" macro.
1313 char* sv_2pvutf8_nolen(SV* sv)
1315 "sv_2pv_flags"
1317 Returns a pointer to the string value of an SV, and sets *lp to its
1318 length. If flags has the "SV_GMAGIC" bit set, does an "mg_get()"
1319 first. Coerces "sv" to a string if necessary. Normally invoked
1320 via the "SvPV_flags" macro. "sv_2pv()" and "sv_2pv_nomg" usually
1321 end up here too.
1322 char* sv_2pv_flags(SV *const sv, STRLEN *const lp,
1324 const U32 flags)
1325 "sv_2pv_nolen"
1327 Like "sv_2pv()", but doesn't return the length too. You should
1328 usually use the macro wrapper "SvPV_nolen(sv)" instead.
1329 char* sv_2pv_nolen(SV* sv)
1331 "sv_add_arena"
1333 Given a chunk of memory, link it to the head of the list of arenas,
1334 and split it into a list of free SVs.
1335 void sv_add_arena(char *const ptr, const U32 size,
1337 const U32 flags)
1338 "sv_clean_all"
1340 Decrement the refcnt of each remaining SV, possibly triggering a
1341 cleanup. This function may have to be called multiple times to
1342 free SVs which are in complex self-referential hierarchies.
1343 I32 sv_clean_all()
1345 "sv_clean_objs"
1347 Attempt to destroy all objects not yet freed.
1348 void sv_clean_objs()
1350 "sv_free_arenas"
1352 Deallocate the memory used by all arenas. Note that all the
1353 individual SV heads and bodies within the arenas must already have
1354 been freed.
1355 void sv_free_arenas()
1357 "sv_grow"
1359 Expands the character buffer in the SV. If necessary, uses
1360 "sv_unref" and upgrades the SV to "SVt_PV". Returns a pointer to
1361 the character buffer. Use the "SvGROW" wrapper instead.
1362 char* sv_grow(SV *const sv, STRLEN newlen)
1364 "sv_iv"
1366 "DEPRECATED!" It is planned to remove "sv_iv" from a future
1367 release of Perl. Do not use it for new code; remove it from
1368 existing code.
1369 A private implementation of the "SvIVx" macro for compilers which
1371 can't cope with complex macro expressions. Always use the macro
1372 instead.
1373 IV sv_iv(SV* sv)
1375 "sv_newref"
1377 Increment an SV's reference count. Use the "SvREFCNT_inc()"
1378 wrapper instead.
1379 SV* sv_newref(SV *const sv)
1381 "sv_nv"
1383 "DEPRECATED!" It is planned to remove "sv_nv" from a future
1384 release of Perl. Do not use it for new code; remove it from
1385 existing code.
1386 A private implementation of the "SvNVx" macro for compilers which
1388 can't cope with complex macro expressions. Always use the macro
1389 instead.
1390 NV sv_nv(SV* sv)
1392 "sv_pv"
1394 Use the "SvPV_nolen" macro instead
1395 char* sv_pv(SV *sv)
1397 "sv_pvbyte"
1399 Use "SvPVbyte_nolen" instead.
1400 char* sv_pvbyte(SV *sv)
1402 "sv_pvbyten"
1404 "DEPRECATED!" It is planned to remove "sv_pvbyten" from a future
1405 release of Perl. Do not use it for new code; remove it from
1406 existing code.
1407 A private implementation of the "SvPVbyte" macro for compilers
1409 which can't cope with complex macro expressions. Always use the
1410 macro instead.
1411 char* sv_pvbyten(SV *sv, STRLEN *lp)
1413 "sv_pvbyten_force"
1415 The backend for the "SvPVbytex_force" macro. Always use the macro
1416 instead. If the SV cannot be downgraded from UTF-8, this croaks.
1417 char* sv_pvbyten_force(SV *const sv, STRLEN *const lp)
1419 "sv_pvn"
1421 "DEPRECATED!" It is planned to remove "sv_pvn" from a future
1422 release of Perl. Do not use it for new code; remove it from
1423 existing code.
1424 A private implementation of the "SvPV" macro for compilers which
1426 can't cope with complex macro expressions. Always use the macro
1427 instead.
1428 char* sv_pvn(SV *sv, STRLEN *lp)
1430 "sv_pvn_force"
1432 Get a sensible string out of the SV somehow. A private
1433 implementation of the "SvPV_force" macro for compilers which can't
1434 cope with complex macro expressions. Always use the macro instead.
1435 char* sv_pvn_force(SV* sv, STRLEN* lp)
1437 "sv_pvutf8"
1439 Use the "SvPVutf8_nolen" macro instead
1440 char* sv_pvutf8(SV *sv)
1442 "sv_pvutf8n"
1444 "DEPRECATED!" It is planned to remove "sv_pvutf8n" from a future
1445 release of Perl. Do not use it for new code; remove it from
1446 existing code.
1447 A private implementation of the "SvPVutf8" macro for compilers
1449 which can't cope with complex macro expressions. Always use the
1450 macro instead.
1451 char* sv_pvutf8n(SV *sv, STRLEN *lp)
1453 "sv_pvutf8n_force"
1455 The backend for the "SvPVutf8x_force" macro. Always use the macro
1456 instead.
1457 char* sv_pvutf8n_force(SV *const sv, STRLEN *const lp)
1459 "sv_taint"
1461 Taint an SV. Use "SvTAINTED_on" instead.
1462 void sv_taint(SV* sv)
1464 "sv_tainted"
1466 Test an SV for taintedness. Use "SvTAINTED" instead.
1467 bool sv_tainted(SV *const sv)
1469 "SvTHINKFIRST"
1471 A quick flag check to see whether an "sv" should be passed to
1472 "sv_force_normal" to be "downgraded" before "SvIVX" or "SvPVX" can
1473 be modified directly.
1474 For example, if your scalar is a reference and you want to modify
1476 the "SvIVX" slot, you can't just do "SvROK_off", as that will leak
1477 the referent.
1478 This is used internally by various sv-modifying functions, such as
1480 "sv_setsv", "sv_setiv" and "sv_pvn_force".
1481 One case that this does not handle is a gv without SvFAKE set.
1483 After
1484 if (SvTHINKFIRST(gv)) sv_force_normal(gv);
1486 it will still be a gv.
1488 "SvTHINKFIRST" sometimes produces false positives. In those cases
1490 "sv_force_normal" does nothing.
1491 U32 SvTHINKFIRST(SV *sv)
1493 "sv_true"
1495 Returns true if the SV has a true value by Perl's rules. Use the
1496 "SvTRUE" macro instead, which may call "sv_true()" or may instead
1497 use an in-line version.
1498 I32 sv_true(SV *const sv)
1500 "sv_untaint"
1502 Untaint an SV. Use "SvTAINTED_off" instead.
1503 void sv_untaint(SV *const sv)
1505 "sv_uv"
1507 "DEPRECATED!" It is planned to remove "sv_uv" from a future
1508 release of Perl. Do not use it for new code; remove it from
1509 existing code.
1510 A private implementation of the "SvUVx" macro for compilers which
1512 can't cope with complex macro expressions. Always use the macro
1513 instead.
1514 UV sv_uv(SV* sv)
1516
1518 There are only public API items currently in Time
1519
1521 There are only public API items currently in Typedef names
1522
1524 "bytes_from_utf8_loc"
1525 NOTE: "bytes_from_utf8_loc" is experimental and may change or be
1526 removed without notice.
1527 Like ""bytes_from_utf8" in perlapi()", but takes an extra
1529 parameter, a pointer to where to store the location of the first
1530 character in "s" that cannot be converted to non-UTF8.
1531 If that parameter is "NULL", this function behaves identically to
1533 "bytes_from_utf8".
1534 Otherwise if *is_utf8p is 0 on input, the function behaves
1536 identically to "bytes_from_utf8", except it also sets
1537 *first_non_downgradable to "NULL".
1538 Otherwise, the function returns a newly created "NUL"-terminated
1540 string containing the non-UTF8 equivalent of the convertible first
1541 portion of "s". *lenp is set to its length, not including the
1542 terminating "NUL". If the entire input string was converted,
1543 *is_utf8p is set to a FALSE value, and *first_non_downgradable is
1544 set to "NULL".
1545 Otherwise, *first_non_downgradable is set to point to the first
1547 byte of the first character in the original string that wasn't
1548 converted. *is_utf8p is unchanged. Note that the new string may
1549 have length 0.
1550 Another way to look at it is, if *first_non_downgradable is
1552 non-"NULL" and *is_utf8p is TRUE, this function starts at the
1553 beginning of "s" and converts as many characters in it as possible
1554 stopping at the first one it finds that can't be converted to
1555 non-UTF-8. *first_non_downgradable is set to point to that. The
1556 function returns the portion that could be converted in a newly
1557 created "NUL"-terminated string, and *lenp is set to its length,
1558 not including the terminating "NUL". If the very first character
1559 in the original could not be converted, *lenp will be 0, and the
1560 new string will contain just a single "NUL". If the entire input
1561 string was converted, *is_utf8p is set to FALSE and
1562 *first_non_downgradable is set to "NULL".
1563 Upon successful return, the number of variants in the converted
1565 portion of the string can be computed by having saved the value of
1566 *lenp before the call, and subtracting the after-call value of
1567 *lenp from it.
1568 U8* bytes_from_utf8_loc(const U8 *s, STRLEN *lenp,
1570 bool *is_utf8p,
1571 const U8 ** first_unconverted)
1572 "find_uninit_var"
1574 NOTE: "find_uninit_var" is experimental and may change or be
1575 removed without notice.
1576 Find the name of the undefined variable (if any) that caused the
1578 operator to issue a "Use of uninitialized value" warning. If match
1579 is true, only return a name if its value matches "uninit_sv". So
1580 roughly speaking, if a unary operator (such as "OP_COS") generates
1581 a warning, then following the direct child of the op may yield an
1582 "OP_PADSV" or "OP_GV" that gives the name of the undefined
1583 variable. On the other hand, with "OP_ADD" there are two branches
1584 to follow, so we only print the variable name if we get an exact
1585 match. "desc_p" points to a string pointer holding the description
1586 of the op. This may be updated if needed.
1587 The name is returned as a mortal SV.
1589 Assumes that "PL_op" is the OP that originally triggered the error,
1591 and that "PL_comppad"/"PL_curpad" points to the currently executing
1592 pad.
1593 SV* find_uninit_var(const OP *const obase,
1595 const SV *const uninit_sv, bool match,
1596 const char **desc_p)
1597 "isSCRIPT_RUN"
1599 Returns a bool as to whether or not the sequence of bytes from "s"
1600 up to but not including "send" form a "script run". "utf8_target"
1601 is TRUE iff the sequence starting at "s" is to be treated as UTF-8.
1602 To be precise, except for two degenerate cases given below, this
1603 function returns TRUE iff all code points in it come from any
1604 combination of three "scripts" given by the Unicode "Script
1605 Extensions" property: Common, Inherited, and possibly one other.
1606 Additionally all decimal digits must come from the same consecutive
1607 sequence of 10.
1608 For example, if all the characters in the sequence are Greek, or
1610 Common, or Inherited, this function will return TRUE, provided any
1611 decimal digits in it are from the same block of digits in Common.
1612 (These are the ASCII digits "0".."9" and additionally a block for
1613 full width forms of these, and several others used in mathematical
1614 notation.) For scripts (unlike Greek) that have their own digits
1615 defined this will accept either digits from that set or from one of
1616 the Common digit sets, but not a combination of the two. Some
1617 scripts, such as Arabic, have more than one set of digits. All
1618 digits must come from the same set for this function to return
1619 TRUE.
1620 *ret_script, if "ret_script" is not NULL, will on return of TRUE
1622 contain the script found, using the "SCX_enum" typedef. Its value
1623 will be "SCX_INVALID" if the function returns FALSE.
1624 If the sequence is empty, TRUE is returned, but *ret_script (if
1626 asked for) will be "SCX_INVALID".
1627 If the sequence contains a single code point which is unassigned to
1629 a character in the version of Unicode being used, the function will
1630 return TRUE, and the script will be "SCX_Unknown". Any other
1631 combination of unassigned code points in the input sequence will
1632 result in the function treating the input as not being a script
1633 run.
1634 The returned script will be "SCX_Inherited" iff all the code points
1636 in it are from the Inherited script.
1637 Otherwise, the returned script will be "SCX_Common" iff all the
1639 code points in it are from the Inherited or Common scripts.
1640 bool isSCRIPT_RUN(const U8 *s, const U8 *send,
1642 const bool utf8_target)
1643 "is_utf8_non_invariant_string"
1645 Returns TRUE if "is_utf8_invariant_string" in perlapi returns FALSE
1646 for the first "len" bytes of the string "s", but they are,
1647 nonetheless, legal Perl-extended UTF-8; otherwise returns FALSE.
1648 A TRUE return means that at least one code point represented by the
1650 sequence either is a wide character not representable as a single
1651 byte, or the representation differs depending on whether the
1652 sequence is encoded in UTF-8 or not.
1653 See also ""is_utf8_invariant_string" in perlapi", ""is_utf8_string"
1655 in perlapi"
1656 bool is_utf8_non_invariant_string(const U8* const s, STRLEN len)
1658 "report_uninit"
1660 Print appropriate "Use of uninitialized variable" warning.
1661 void report_uninit(const SV *uninit_sv)
1663 "utf8n_to_uvuni"
1665 "DEPRECATED!" It is planned to remove "utf8n_to_uvuni" from a
1666 future release of Perl. Do not use it for new code; remove it from
1667 existing code.
1668 Instead use "utf8_to_uvchr_buf" in perlapi, or rarely,
1670 "utf8n_to_uvchr" in perlapi.
1671 This function was useful for code that wanted to handle both EBCDIC
1673 and ASCII platforms with Unicode properties, but starting in Perl
1674 v5.20, the distinctions between the platforms have mostly been made
1675 invisible to most code, so this function is quite unlikely to be
1676 what you want. If you do need this precise functionality, use
1677 instead "NATIVE_TO_UNI(utf8_to_uvchr_buf(...))" or
1678 "NATIVE_TO_UNI(utf8n_to_uvchr(...))".
1679 UV utf8n_to_uvuni(const U8 *s, STRLEN curlen, STRLEN *retlen,
1681 U32 flags)
1682 "utf8_to_uvuni"
1684 "DEPRECATED!" It is planned to remove "utf8_to_uvuni" from a
1685 future release of Perl. Do not use it for new code; remove it from
1686 existing code.
1687 Returns the Unicode code point of the first character in the string
1689 "s" which is assumed to be in UTF-8 encoding; "retlen" will be set
1690 to the length, in bytes, of that character.
1691 Some, but not all, UTF-8 malformations are detected, and in fact,
1693 some malformed input could cause reading beyond the end of the
1694 input buffer, which is one reason why this function is deprecated.
1695 The other is that only in extremely limited circumstances should
1696 the Unicode versus native code point be of any interest to you.
1697 See "utf8_to_uvuni_buf" for alternatives.
1698 If "s" points to one of the detected malformations, and UTF8
1700 warnings are enabled, zero is returned and *retlen is set (if
1701 "retlen" doesn't point to NULL) to -1. If those warnings are off,
1702 the computed value if well-defined (or the Unicode REPLACEMENT
1703 CHARACTER, if not) is silently returned, and *retlen is set (if
1704 "retlen" isn't NULL) so that ("s" + *retlen) is the next possible
1705 position in "s" that could begin a non-malformed character. See
1706 "utf8n_to_uvchr" in perlapi for details on when the REPLACEMENT
1707 CHARACTER is returned.
1708 UV utf8_to_uvuni(const U8 *s, STRLEN *retlen)
1710 "utf8_to_uvuni_buf"
1712 "DEPRECATED!" It is planned to remove "utf8_to_uvuni_buf" from a
1713 future release of Perl. Do not use it for new code; remove it from
1714 existing code.
1715 Only in very rare circumstances should code need to be dealing in
1717 Unicode (as opposed to native) code points. In those few cases,
1718 use "NATIVE_TO_UNI(utf8_to_uvchr_buf(...))" instead. If you are
1719 not absolutely sure this is one of those cases, then assume it
1720 isn't and use plain "utf8_to_uvchr_buf" instead.
1721 Returns the Unicode (not-native) code point of the first character
1723 in the string "s" which is assumed to be in UTF-8 encoding; "send"
1724 points to 1 beyond the end of "s". "retlen" will be set to the
1725 length, in bytes, of that character.
1726 If "s" does not point to a well-formed UTF-8 character and UTF8
1728 warnings are enabled, zero is returned and *retlen is set (if
1729 "retlen" isn't NULL) to -1. If those warnings are off, the
1730 computed value if well-defined (or the Unicode REPLACEMENT
1731 CHARACTER, if not) is silently returned, and *retlen is set (if
1732 "retlen" isn't NULL) so that ("s" + *retlen) is the next possible
1733 position in "s" that could begin a non-malformed character. See
1734 "utf8n_to_uvchr" in perlapi for details on when the REPLACEMENT
1735 CHARACTER is returned.
1736 UV utf8_to_uvuni_buf(const U8 *s, const U8 *send, STRLEN *retlen)
1738 "uvoffuni_to_utf8_flags"
1740 THIS FUNCTION SHOULD BE USED IN ONLY VERY SPECIALIZED
1741 CIRCUMSTANCES. Instead, Almost all code should use "uvchr_to_utf8"
1742 in perlapi or "uvchr_to_utf8_flags" in perlapi.
1743 This function is like them, but the input is a strict Unicode (as
1745 opposed to native) code point. Only in very rare circumstances
1746 should code not be using the native code point.
1747 For details, see the description for "uvchr_to_utf8_flags" in
1749 perlapi.
1750 U8* uvoffuni_to_utf8_flags(U8 *d, UV uv, const UV flags)
1752 "uvuni_to_utf8_flags"
1754 "DEPRECATED!" It is planned to remove "uvuni_to_utf8_flags" from a
1755 future release of Perl. Do not use it for new code; remove it from
1756 existing code.
1757 Instead you almost certainly want to use "uvchr_to_utf8" in perlapi
1759 or "uvchr_to_utf8_flags" in perlapi.
1760 This function is a deprecated synonym for "uvoffuni_to_utf8_flags",
1762 which itself, while not deprecated, should be used only in isolated
1763 circumstances. These functions were useful for code that wanted to
1764 handle both EBCDIC and ASCII platforms with Unicode properties, but
1765 starting in Perl v5.20, the distinctions between the platforms have
1766 mostly been made invisible to most code, so this function is quite
1767 unlikely to be what you want.
1768 U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)
1770 "valid_utf8_to_uvchr"
1772 Like ""utf8_to_uvchr_buf" in perlapi", but should only be called
1773 when it is known that the next character in the input UTF-8 string
1774 "s" is well-formed (e.g., it passes ""isUTF8_CHAR" in perlapi".
1775 Surrogates, non-character code points, and non-Unicode code points
1776 are allowed.
1777 UV valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen)
1779 "variant_under_utf8_count"
1781 This function looks at the sequence of bytes between "s" and "e",
1782 which are assumed to be encoded in ASCII/Latin1, and returns how
1783 many of them would change should the string be translated into
1784 UTF-8. Due to the nature of UTF-8, each of these would occupy two
1785 bytes instead of the single one in the input string. Thus, this
1786 function returns the precise number of bytes the string would
1787 expand by when translated to UTF-8.
1788 Unlike most of the other functions that have "utf8" in their name,
1790 the input to this function is NOT a UTF-8-encoded string. The
1791 function name is slightly odd to emphasize this.
1792 This function is internal to Perl because khw thinks that any XS
1794 code that would want this is probably operating too close to the
1795 internals. Presenting a valid use case could change that.
1796 See also ""is_utf8_invariant_string" in perlapi" and
1798 ""is_utf8_invariant_string_loc" in perlapi",
1799 Size_t variant_under_utf8_count(const U8* const s,
1801 const U8* const e)
1802
1804 There are only public API items currently in Utility Functions
1805
1807 There are only public API items currently in Versioning
1808
1810 "PL_dowarn"
1811 The C variable that roughly corresponds to Perl's $^W warning
1812 variable. However, $^W is treated as a boolean, whereas
1813 "PL_dowarn" is a collection of flag bits.
1814 On threaded perls, each thread has an independent copy of this
1816 variable; each initialized at creation time with the current value
1817 of the creating thread's copy.
1818 U8 PL_dowarn
1820
1822 There are only public API items currently in XS
1823
1825 The following functions are currently undocumented. If you use one of
1826 them, you may wish to consider creating and submitting documentation
1827 for it.
1828 abort_execution
1830 add_cp_to_invlist
1831 _add_range_to_invlist
1832 alloc_LOGOP
1833 allocmy
1834 amagic_cmp
1835 amagic_cmp_desc
1836 amagic_cmp_locale
1837 amagic_cmp_locale_desc
1838 amagic_is_enabled
1839 amagic_i_ncmp
1840 amagic_i_ncmp_desc
1841 amagic_ncmp
1842 amagic_ncmp_desc
1843 append_utf8_from_native_byte
1844 apply
1845 ASCII_TO_NEED
1846 av_arylen_p
1847 av_extend_guts
1848 av_iter_p
1849 av_nonelem
1850 av_reify
1851 bind_match
1852 boot_core_mro
1853 boot_core_PerlIO
1854 boot_core_UNIVERSAL
1855 _byte_dump_string
1856 cando
1857 cast_i32
1858 cast_iv
1859 cast_ulong
1860 cast_uv
1861 check_utf8_print
1862 ck_anoncode
1863 ck_backtick
1864 ck_bitop
1865 ck_cmp
1866 ck_concat
1867 ck_defined
1868 ck_delete
1869 ck_each
1870 ck_entersub_args_core
1871 ck_eof
1872 ck_eval
1873 ck_exec
1874 ck_exists
1875 ck_ftst
1876 ck_fun
1877 ck_glob
1878 ck_grep
1879 ck_index
1880 ck_isa
1881 ck_join
1882 ck_length
1883 ck_lfun
1884 ck_listiob
1885 ck_match
1886 ck_method
1887 ck_null
1888 ck_open
1889 ck_prototype
1890 ck_readline
1891 ck_refassign
1892 ck_repeat
1893 ck_require
1894 ck_return
1895 ck_rfun
1896 ck_rvconst
1897 ck_sassign
1898 ck_select
1899 ck_shift
1900 ck_smartmatch
1901 ck_sort
1902 ck_spair
1903 ck_split
1904 ck_stringify
1905 ck_subr
1906 ck_substr
1907 ck_svconst
1908 ck_tell
1909 ck_trunc
1910 ck_trycatch
1911 ckwarn
1912 ckwarn_d
1913 closest_cop
1914 cmpchain_extend
1915 cmpchain_finish
1916 cmpchain_start
1917 cmp_desc
1918 cmp_locale_desc
1919 cntrl_to_mnemonic
1920 coresub_op
1921 create_eval_scope
1922 croak_caller
1923 croak_memory_wrap
1924 croak_no_mem
1925 croak_popstack
1926 csighandler
1927 csighandler1
1928 csighandler3
1929 current_re_engine
1930 custom_op_get_field
1931 cv_ckproto_len_flags
1932 cv_clone_into
1933 cv_const_sv_or_av
1934 cvgv_from_hek
1935 cvgv_set
1936 cvstash_set
1937 cv_undef_flags
1938 cx_dump
1939 cx_dup
1940 cxinc
1941 cx_popblock
1942 cx_popeval
1943 cx_popformat
1944 cx_popgiven
1945 cx_poploop
1946 cx_popsub
1947 cx_popsub_args
1948 cx_popsub_common
1949 cx_popwhen
1950 cx_pushblock
1951 cx_pusheval
1952 cx_pushformat
1953 cx_pushgiven
1954 cx_pushloop_for
1955 cx_pushloop_plain
1956 cx_pushsub
1957 cx_pushtry
1958 cx_pushwhen
1959 cx_topblock
1960 deb_stack_all
1961 defelem_target
1962 delete_eval_scope
1963 despatch_signals
1964 die_unwind
1965 do_aexec
1966 do_aexec5
1967 do_eof
1968 does_utf8_overflow
1969 do_exec
1970 do_exec3
1971 dofile
1972 do_gvgv_dump
1973 do_gv_dump
1974 do_hv_dump
1975 doing_taint
1976 do_ipcctl
1977 do_ipcget
1978 do_magic_dump
1979 do_msgrcv
1980 do_msgsnd
1981 do_ncmp
1982 do_open6
1983 do_open_raw
1984 do_op_dump
1985 do_pmop_dump
1986 do_print
1987 do_readline
1988 do_seek
1989 do_semop
1990 do_shmio
1991 do_sv_dump
1992 do_sysseek
1993 do_tell
1994 do_trans
1995 do_uniprop_match
1996 do_vecget
1997 do_vecset
1998 do_vop
1999 drand48_init_r
2000 drand48_r
2001 dtrace_probe_call
2002 dtrace_probe_load
2003 dtrace_probe_op
2004 dtrace_probe_phase
2005 dump_all_perl
2006 dump_indent
2007 dump_packsubs_perl
2008 dump_sub_perl
2009 dump_sv_child
2010 dump_vindent
2011 dup_warnings
2012 emulate_cop_io
2013 find_first_differing_byte_pos
2014 find_lexical_cv
2015 find_runcv_where
2016 find_script
2017 foldEQ_latin1
2018 foldEQ_latin1_s2_folded
2019 foldEQ_utf8_flags
2020 _force_out_malformed_utf8_message
2021 form_alien_digit_msg
2022 form_cp_too_large_msg
2023 free_tied_hv_pool
2024 free_tmps
2025 get_and_check_backslash_N_name
2026 get_db_sub
2027 get_debug_opts
2028 get_deprecated_property_msg
2029 getenv_len
2030 get_hash_seed
2031 get_invlist_iter_addr
2032 get_invlist_offset_addr
2033 get_invlist_previous_index_addr
2034 get_no_modify
2035 get_opargs
2036 get_prop_definition
2037 get_prop_values
2038 get_regclass_nonbitmap_data
2039 get_regex_charset_name
2040 get_re_arg
2041 get_re_gclass_nonbitmap_data
2042 gimme_V
2043 grok_bin_oct_hex
2044 grok_bslash_c
2045 grok_bslash_o
2046 grok_bslash_x
2047 gv_check
2048 gv_fetchmeth_internal
2049 gv_override
2050 gv_setref
2051 gv_stashpvn_internal
2052 hfree_next_entry
2053 hv_backreferences_p
2054 hv_common
2055 hv_common_key_len
2056 hv_kill_backrefs
2057 hv_placeholders_p
2058 hv_pushkv
2059 hv_undef_flags
2060 init_argv_symbols
2061 init_constants
2062 init_dbargs
2063 init_debugger
2064 init_i18nl10n
2065 init_i18nl14n
2066 init_named_cv
2067 init_uniprops
2068 _inverse_folds
2069 invert
2070 invlist_array
2071 invlist_clear
2072 invlist_clone
2073 invlist_contents
2074 _invlistEQ
2075 invlist_extend
2076 invlist_highest
2077 invlist_is_iterating
2078 invlist_iterfinish
2079 invlist_iterinit
2080 invlist_iternext
2081 invlist_lowest
2082 invlist_max
2083 invlist_previous_index
2084 invlist_set_len
2085 invlist_set_previous_index
2086 invlist_trim
2087 _invlist_array_init
2088 _invlist_contains_cp
2089 _invlist_dump
2090 _invlist_intersection
2091 _invlist_intersection_maybe_complement_2nd
2092 _invlist_invert
2093 _invlist_len
2094 _invlist_search
2095 _invlist_subtract
2096 _invlist_union
2097 _invlist_union_maybe_complement_2nd
2098 invmap_dump
2099 io_close
2100 isFF_OVERLONG
2101 is_grapheme
2102 is_invlist
2103 is_utf8_char_helper
2104 is_utf8_common
2105 is_utf8_overlong_given_start_byte_ok
2106 _is_cur_LC_category_utf8
2107 _is_in_locale_category
2108 _is_uni_FOO
2109 _is_uni_perl_idcont
2110 _is_uni_perl_idstart
2111 _is_utf8_FOO
2112 _is_utf8_perl_idcont
2113 _is_utf8_perl_idstart
2114 jmaybe
2115 keyword
2116 keyword_plugin_standard
2117 list
2118 load_charnames
2119 localize
2120 lossless_NV_to_IV
2121 magic_cleararylen_p
2122 magic_clearenv
2123 magic_clearisa
2124 magic_clearpack
2125 magic_clearsig
2126 magic_clear_all_env
2127 magic_copycallchecker
2128 magic_existspack
2129
2131 The autodocumentation system was originally added to the Perl core by
2132 Benjamin Stuhl. Documentation is by whoever was kind enough to
2133 document their functions.
2134
2136 config.h, perlapi, perlapio, perlcall, perlclib, perlfilter, perlguts,
2137 perlinterp, perliol, perlmroapi, perlreguts, perlxs
2138perl v5.34.0 2021-10-18 PERLINTERN(1)