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 "av_fetch_simple"
19 This is a cut-down version of av_fetch that assumes that the array
20 is very straightforward - no magic, not readonly, and AvREAL - and
21 that "key" is not negative. This function MUST NOT be used in
22 situations where any of those assumptions may not hold.
23 Returns the SV at the specified index in the array. The "key" is
25 the index. If lval is true, you are guaranteed to get a real SV
26 back (in case it wasn't real before), which you can then modify.
27 Check that the return value is non-null before dereferencing it to
28 a "SV*".
29 The rough perl equivalent is $myarray[$key].
31 SV** av_fetch_simple(AV *av, SSize_t key, I32 lval)
33 "AvFILLp"
35 If the array "av" is empty, this returns -1; otherwise it returns
36 the maximum value of the indices of all the array elements which
37 are currently defined in "av". It does not handle magic, hence the
38 "p" private indication in its name.
39 SSize_t AvFILLp(AV* av)
41 "av_new_alloc"
43 This implements ""newAV_alloc_x"" in perlapi and ""newAV_alloc_xz""
44 in perlapi, which are the public API for this functionality.
45 Creates a new AV and allocates its SV* array.
47 This is similar to, but more efficient than doing:
49 AV *av = newAV();
51 av_extend(av, key);
52 The size parameter is used to pre-allocate a SV* array large enough
54 to hold at least elements "0..(size-1)". "size" must be at least
55 1.
56 The "zeroflag" parameter controls whether or not the array is NULL
58 initialized.
59 AV* av_new_alloc(SSize_t size, bool zeroflag)
61 "av_store_simple"
63 This is a cut-down version of av_store that assumes that the array
64 is very straightforward - no magic, not readonly, and AvREAL - and
65 that "key" is not negative. This function MUST NOT be used in
66 situations where any of those assumptions may not hold.
67 Stores an SV in an array. The array index is specified as "key".
69 It can be dereferenced to get the "SV*" that was stored there (=
70 "val")).
71 Note that the caller is responsible for suitably incrementing the
73 reference count of "val" before the call.
74 Approximate Perl equivalent: "splice(@myarray, $key, 1, $val)".
76 SV** av_store_simple(AV *av, SSize_t key, SV *val)
78
80 "dowantarray"
81 Implements the deprecated ""GIMME"" in perlapi.
82 U8 dowantarray()
84 "leave_scope"
86 Implements "LEAVE_SCOPE" which you should use instead.
87 void leave_scope(I32 base)
89 "pop_scope"
91 Implements ""LEAVE"" in perlapi
92 void pop_scope()
94 "push_scope"
96 Implements ""ENTER"" in perlapi
97 void push_scope()
99 "save_adelete"
101 Implements "SAVEADELETE".
102 void save_adelete(AV *av, SSize_t key)
104 "save_generic_pvref"
106 Implements "SAVEGENERICPV".
107 Like save_pptr(), but also Safefree()s the new value if it is
109 different from the old one. Can be used to restore a global char*
110 to its prior contents, freeing new value.
111 void save_generic_pvref(char** str)
113 "save_generic_svref"
115 Implements "SAVEGENERICSV".
116 Like save_sptr(), but also SvREFCNT_dec()s the new value. Can be
118 used to restore a global SV to its prior contents, freeing new
119 value.
120 void save_generic_svref(SV** sptr)
122 "save_hdelete"
124 Implements "SAVEHDELETE".
125 void save_hdelete(HV *hv, SV *keysv)
127 "save_hints"
129 Implements "SAVEHINTS".
130 void save_hints()
132 "save_op"
134 Implements "SAVEOP".
135 void save_op()
137 "save_padsv_and_mortalize"
139 Implements "SAVEPADSVANDMORTALIZE".
140 void save_padsv_and_mortalize(PADOFFSET off)
142 "save_set_svflags"
144 Implements "SAVESETSVFLAGS".
145 Set the SvFLAGS specified by mask to the values in val
147 void save_set_svflags(SV *sv, U32 mask, U32 val)
149 "save_shared_pvref"
151 Implements "SAVESHAREDPV".
152 Like save_generic_pvref(), but uses PerlMemShared_free() rather
154 than Safefree(). Can be used to restore a shared global char* to
155 its prior contents, freeing new value.
156 void save_shared_pvref(char** str)
158 "save_vptr"
160 Implements "SAVEVPTR".
161 void save_vptr(void *ptr)
163
165 There are only public API items currently in Casting
166
168 There are only public API items currently in Character case changing
169
171 There are only public API items currently in Character classification
172
174 There are only public API items currently in Compiler and Preprocessor
175 information
176
178 There are only public API items currently in Compiler directives
179
181 "BhkENTRY"
182 NOTE: "BhkENTRY" is experimental and may change or be removed
183 without notice.
184 Return an entry from the BHK structure. "which" is a preprocessor
186 token indicating which entry to return. If the appropriate flag is
187 not set this will return "NULL". The type of the return value
188 depends on which entry you ask for.
189 void * BhkENTRY(BHK *hk, which)
191 "BhkFLAGS"
193 NOTE: "BhkFLAGS" is experimental and may change or be removed
194 without notice.
195 Return the BHK's flags.
197 U32 BhkFLAGS(BHK *hk)
199 "CALL_BLOCK_HOOKS"
201 NOTE: "CALL_BLOCK_HOOKS" is experimental and may change or be
202 removed without notice.
203 Call all the registered block hooks for type "which". "which" is a
205 preprocessing token; the type of "arg" depends on "which".
206 void CALL_BLOCK_HOOKS(which, arg)
208
210 "CVf_SLABBED"
211 "CvROOT"
212 "CvSTART"
213 Described in perlguts.
214 "CX_CUR"
216 Described in perlguts.
217 CX_CUR()
219 "CXINC"
221 Described in perlguts.
222 "CX_LEAVE_SCOPE"
224 Described in perlguts.
225 void CX_LEAVE_SCOPE(PERL_CONTEXT* cx)
227 "CX_POP"
229 Described in perlguts.
230 void CX_POP(PERL_CONTEXT* cx)
232 "cxstack"
234 Described in perlguts.
235 "cxstack_ix"
237 Described in perlguts.
238 "CXt_BLOCK"
240 "CXt_EVAL"
241 "CXt_FORMAT"
242 "CXt_GIVEN"
243 "CXt_LOOP_ARY"
244 "CXt_LOOP_LAZYIV"
245 "CXt_LOOP_LAZYSV"
246 "CXt_LOOP_LIST"
247 "CXt_LOOP_PLAIN"
248 "CXt_NULL"
249 "CXt_SUB"
250 "CXt_SUBST"
251 "CXt_WHEN"
252 Described in perlguts.
253 "cx_type"
255 Described in perlguts.
256 "dounwind"
258 Described in perlguts.
259 void dounwind(I32 cxix)
261 "my_fork"
263 This is for the use of "PerlProc_fork" as a wrapper for the C
264 library fork(2) on some platforms to hide some platform quirks. It
265 should not be used except through "PerlProc_fork".
266 Pid_t my_fork()
268 "PERL_CONTEXT"
270 Described in perlguts.
271
273 There are only public API items currently in COPs and Hint Hashes
274
276 "core_prototype"
277 This function assigns the prototype of the named core function to
278 "sv", or to a new mortal SV if "sv" is "NULL". It returns the
279 modified "sv", or "NULL" if the core function has no prototype.
280 "code" is a code as returned by "keyword()". It must not be equal
281 to 0.
282 SV * core_prototype(SV *sv, const char *name, const int code,
284 int * const opnum)
285
287 "CvWEAKOUTSIDE"
288 Each CV has a pointer, "CvOUTSIDE()", to its lexically enclosing CV
289 (if any). Because pointers to anonymous sub prototypes are stored
290 in "&" pad slots, it is a possible to get a circular reference,
291 with the parent pointing to the child and vice-versa. To avoid the
292 ensuing memory leak, we do not increment the reference count of the
293 CV pointed to by "CvOUTSIDE" in the one specific instance that the
294 parent has a "&" pad slot pointing back to us. In this case, we
295 set the "CvWEAKOUTSIDE" flag in the child. This allows us to
296 determine under what circumstances we should decrement the refcount
297 of the parent when freeing the child.
298 There is a further complication with non-closure anonymous subs
300 (i.e. those that do not refer to any lexicals outside that sub).
301 In this case, the anonymous prototype is shared rather than being
302 cloned. This has the consequence that the parent may be freed
303 while there are still active children, e.g.,
304 BEGIN { $a = sub { eval '$x' } }
306 In this case, the BEGIN is freed immediately after execution since
308 there are no active references to it: the anon sub prototype has
309 "CvWEAKOUTSIDE" set since it's not a closure, and $a points to the
310 same CV, so it doesn't contribute to BEGIN's refcount either. When
311 $a is executed, the "eval '$x'" causes the chain of "CvOUTSIDE"s to
312 be followed, and the freed BEGIN is accessed.
313 To avoid this, whenever a CV and its associated pad is freed, any
315 "&" entries in the pad are explicitly removed from the pad, and if
316 the refcount of the pointed-to anon sub is still positive, then
317 that child's "CvOUTSIDE" is set to point to its grandparent. This
318 will only occur in the single specific case of a non-closure anon
319 prototype having one or more active references (such as $a above).
320 One other thing to consider is that a CV may be merely undefined
322 rather than freed, eg "undef &foo". In this case, its refcount may
323 not have reached zero, but we still delete its pad and its "CvROOT"
324 etc. Since various children may still have their "CvOUTSIDE"
325 pointing at this undefined CV, we keep its own "CvOUTSIDE" for the
326 time being, so that the chain of lexical scopes is unbroken. For
327 example, the following should print 123:
328 my $x = 123;
330 sub tmp { sub { eval '$x' } }
331 my $a = tmp();
332 undef &tmp;
333 print $a->();
334 bool CvWEAKOUTSIDE(CV *cv)
336 "docatch"
338 Check for the cases 0 or 3 of cur_env.je_ret, only used inside an
339 eval context.
340 0 is used as continue inside eval,
342 3 is used for a die caught by an inner eval - continue inner loop
344 See cop.h: je_mustcatch, when set at any runlevel to TRUE, means
346 eval ops must establish a local jmpenv to handle exception traps.
347 OP* docatch(Perl_ppaddr_t firstpp)
349
351 "_aDEPTH"
352 Some functions when compiled under DEBUGGING take an extra final
353 argument named "depth", indicating the C stack depth. This
354 argument is omitted otherwise. This macro expands to either
355 ", depth" under DEBUGGING, or to nothing at all when not under
356 DEBUGGING, reducing the number of "#ifdef"'s in the code.
357 The program is responsible for maintaining the correct value for
359 "depth".
360 _aDEPTH
362 "debop"
364 Implements -Dt perl command line option on OP "o".
365 I32 debop(const OP* o)
367 "debprof"
369 Called to indicate that "o" was executed, for profiling purposes
370 under the "-DP" command line option.
371 void debprof(const OP *o)
373 "debprofdump"
375 Dumps the contents of the data collected by the "-DP" perl command
376 line option.
377 void debprofdump()
379 "free_c_backtrace"
381 Deallocates a backtrace received from get_c_backtrace.
382 void free_c_backtrace(Perl_c_backtrace* bt)
384 "get_c_backtrace"
386 Collects the backtrace (aka "stacktrace") into a single linear
387 malloced buffer, which the caller must "Perl_free_c_backtrace()".
388 Scans the frames back by "depth + skip", then drops the "skip"
390 innermost, returning at most "depth" frames.
391 Perl_c_backtrace* get_c_backtrace(int max_depth, int skip)
393 "_pDEPTH"
395 This is used in the prototype declarations for functions that take
396 a ""_aDEPTH"" final parameter, much like "pTHX_" is used in
397 functions that take a thread context initial parameter.
398 "PL_DBsingle"
400 When Perl is run in debugging mode, with the -d switch, this SV is
401 a boolean which indicates whether subs are being single-stepped.
402 Single-stepping is automatically turned on after every step. This
403 is the C variable which corresponds to Perl's $DB::single variable.
404 See "PL_DBsub".
405 On threaded perls, each thread has an independent copy of this
407 variable; each initialized at creation time with the current value
408 of the creating thread's copy.
409 SV * PL_DBsingle
411 "PL_DBsub"
413 When Perl is run in debugging mode, with the -d switch, this GV
414 contains the SV which holds the name of the sub being debugged.
415 This is the C variable which corresponds to Perl's $DB::sub
416 variable. See "PL_DBsingle".
417 On threaded perls, each thread has an independent copy of this
419 variable; each initialized at creation time with the current value
420 of the creating thread's copy.
421 GV * PL_DBsub
423 "PL_DBtrace"
425 Trace variable used when Perl is run in debugging mode, with the -d
426 switch. This is the C variable which corresponds to Perl's
427 $DB::trace variable. See "PL_DBsingle".
428 On threaded perls, each thread has an independent copy of this
430 variable; each initialized at creation time with the current value
431 of the creating thread's copy.
432 SV * PL_DBtrace
434 "runops_debug"
436 Described in perlguts.
437 int runops_debug()
439 "runops_standard"
441 Described in perlguts.
442 int runops_standard()
444
446 "sv_peek"
447 Implements "SvPEEK"
448 char* sv_peek(SV* sv)
450
452 "cv_dump"
453 dump the contents of a CV
454 void cv_dump(const CV *cv, const char *title)
456 "cv_forget_slab"
458 When a CV has a reference count on its slab ("CvSLABBED"), it is
459 responsible for making sure it is freed. (Hence, no two CVs should
460 ever have a reference count on the same slab.) The CV only needs
461 to reference the slab during compilation. Once it is compiled and
462 "CvROOT" attached, it has finished its job, so it can forget the
463 slab.
464 void cv_forget_slab(CV *cv)
466 "do_dump_pad"
468 Dump the contents of a padlist
469 void do_dump_pad(I32 level, PerlIO *file, PADLIST *padlist,
471 int full)
472 "get_context"
474 Implements ""PERL_GET_CONTEXT"" in perlapi, which you should use
475 instead.
476 void* get_context()
478 "pad_alloc_name"
480 Allocates a place in the currently-compiling pad (via "pad_alloc"
481 in perlapi) and then stores a name for that entry. "name" is
482 adopted and becomes the name entry; it must already contain the
483 name string. "typestash" and "ourstash" and the "padadd_STATE"
484 flag get added to "name". None of the other processing of
485 "pad_add_name_pvn" in perlapi is done. Returns the offset of the
486 allocated pad slot.
487 PADOFFSET pad_alloc_name(PADNAME *name, U32 flags, HV *typestash,
489 HV *ourstash)
490 "pad_block_start"
492 Update the pad compilation state variables on entry to a new block.
493 void pad_block_start(int full)
495 "pad_check_dup"
497 Check for duplicate declarations: report any of:
498 * a 'my' in the current scope with the same name;
500 * an 'our' (anywhere in the pad) with the same name and the
501 same stash as 'ourstash'
502 "is_our" indicates that the name to check is an "our" declaration.
504 void pad_check_dup(PADNAME *name, U32 flags, const HV *ourstash)
506 "pad_findlex"
508 Find a named lexical anywhere in a chain of nested pads. Add fake
509 entries in the inner pads if it's found in an outer one.
510 Returns the offset in the bottom pad of the lex or the fake lex.
512 "cv" is the CV in which to start the search, and seq is the current
513 "cop_seq" to match against. If "warn" is true, print appropriate
514 warnings. The "out_"* vars return values, and so are pointers to
515 where the returned values should be stored. "out_capture", if non-
516 null, requests that the innermost instance of the lexical is
517 captured; "out_name" is set to the innermost matched pad name or
518 fake pad name; "out_flags" returns the flags normally associated
519 with the "PARENT_FAKELEX_FLAGS" field of a fake pad name.
520 Note that "pad_findlex()" is recursive; it recurses up the chain of
522 CVs, then comes back down, adding fake entries as it goes. It has
523 to be this way because fake names in anon prototypes have to store
524 in "xpadn_low" the index into the parent pad.
525 PADOFFSET pad_findlex(const char *namepv, STRLEN namelen,
527 U32 flags, const CV* cv, U32 seq, int warn,
528 SV** out_capture, PADNAME** out_name,
529 int *out_flags)
530 "pad_fixup_inner_anons"
532 For any anon CVs in the pad, change "CvOUTSIDE" of that CV from
533 "old_cv" to "new_cv" if necessary. Needed when a newly-compiled CV
534 has to be moved to a pre-existing CV struct.
535 void pad_fixup_inner_anons(PADLIST *padlist, CV *old_cv,
537 CV *new_cv)
538 "pad_free"
540 Free the SV at offset po in the current pad.
541 void pad_free(PADOFFSET po)
543 "pad_leavemy"
545 Cleanup at end of scope during compilation: set the max seq number
546 for lexicals in this scope and warn of any lexicals that never got
547 introduced.
548 OP * pad_leavemy()
550 "padlist_dup"
552 Duplicates a pad.
553 PADLIST * padlist_dup(PADLIST *srcpad, CLONE_PARAMS *param)
555 "padname_dup"
557 Duplicates a pad name.
558 PADNAME * padname_dup(PADNAME *src, CLONE_PARAMS *param)
560 "padnamelist_dup"
562 Duplicates a pad name list.
563 PADNAMELIST * padnamelist_dup(PADNAMELIST *srcpad,
565 CLONE_PARAMS *param)
566 "pad_push"
568 Push a new pad frame onto the padlist, unless there's already a pad
569 at this depth, in which case don't bother creating a new one. Then
570 give the new pad an @_ in slot zero.
571 void pad_push(PADLIST *padlist, int depth)
573 "pad_reset"
575 Mark all the current temporaries for reuse
576 void pad_reset()
578 "pad_setsv"
580 Set the value at offset "po" in the current (compiling or
581 executing) pad. Use the macro "PAD_SETSV()" rather than calling
582 this function directly.
583 void pad_setsv(PADOFFSET po, SV* sv)
585 "pad_sv"
587 Get the value at offset "po" in the current (compiling or
588 executing) pad. Use macro "PAD_SV" instead of calling this
589 function directly.
590 SV* pad_sv(PADOFFSET po)
592 "pad_swipe"
594 Abandon the tmp in the current pad at offset "po" and replace with
595 a new one.
596 void pad_swipe(PADOFFSET po, bool refadjust)
598 "set_context"
600 Implements ""PERL_SET_CONTEXT"" in perlapi, which you should use
601 instead.
602 void set_context(void *t)
604
606 "dSAVEDERRNO"
607 Declare variables needed to save "errno" and any operating system
608 specific error number.
609 void dSAVEDERRNO
611 "dSAVE_ERRNO"
613 Declare variables needed to save "errno" and any operating system
614 specific error number, and save them for optional later restoration
615 by "RESTORE_ERRNO".
616 void dSAVE_ERRNO
618 "RESTORE_ERRNO"
620 Restore "errno" and any operating system specific error number that
621 was saved by "dSAVE_ERRNO" or "RESTORE_ERRNO".
622 void RESTORE_ERRNO
624 "SAVE_ERRNO"
626 Save "errno" and any operating system specific error number for
627 optional later restoration by "RESTORE_ERRNO". Requires
628 "dSAVEDERRNO" or "dSAVE_ERRNO" in scope.
629 void SAVE_ERRNO
631 "SETERRNO"
633 Set "errno", and on VMS set "vaxc$errno".
634 void SETERRNO(int errcode, int vmserrcode)
636
638 There are only public API items currently in Exception Handling
639 (simple) Macros
640
642 There are only public API items currently in Filesystem configuration
643 values
644
646 There are only public API items currently in Floating point
647
649 There are only public API items currently in General Configuration
650
652 There are only public API items currently in Global Variables
653
655 "gp_dup"
656 Duplicate a typeglob, returning a pointer to the cloned object.
657 GP* gp_dup(GP *const gp, CLONE_PARAMS *const param)
659 "gv_handler"
661 Implements "StashHANDLER", which you should use instead
662 CV* gv_handler(HV* stash, I32 id)
664 "gv_stashsvpvn_cached"
666 Returns a pointer to the stash for a specified package, possibly
667 cached. Implements both ""gv_stashpvn"" in perlapi and
668 ""gv_stashsv"" in perlapi.
669 Requires one of either "namesv" or "namepv" to be non-null.
671 If the flag "GV_CACHE_ONLY" is set, return the stash only if found
673 in the cache; see ""gv_stashpvn"" in perlapi for details on the
674 other "flags".
675 Note it is strongly preferred for "namesv" to be non-null, for
677 performance reasons.
678 HV* gv_stashsvpvn_cached(SV *namesv, const char* name,
680 U32 namelen, I32 flags)
681 "gv_try_downgrade"
683 NOTE: "gv_try_downgrade" is experimental and may change or be
684 removed without notice.
685 If the typeglob "gv" can be expressed more succinctly, by having
687 something other than a real GV in its place in the stash, replace
688 it with the optimised form. Basic requirements for this are that
689 "gv" is a real typeglob, is sufficiently ordinary, and is only
690 referenced from its package. This function is meant to be used
691 when a GV has been looked up in part to see what was there, causing
692 upgrading, but based on what was found it turns out that the real
693 GV isn't required after all.
694 If "gv" is a completely empty typeglob, it is deleted from the
696 stash.
697 If "gv" is a typeglob containing only a sufficiently-ordinary
699 constant sub, the typeglob is replaced with a scalar-reference
700 placeholder that more compactly represents the same thing.
701 void gv_try_downgrade(GV* gv)
703
705 There are only public API items currently in Hook manipulation
706
708 "hv_eiter_p"
709 Implements "HvEITER" which you should use instead.
710 NOTE: "hv_eiter_p" must be explicitly called as "Perl_hv_eiter_p"
712 with an "aTHX_" parameter.
713 HE** Perl_hv_eiter_p(pTHX_ HV *hv)
715 "hv_eiter_set"
717 Implements "HvEITER_set" which you should use instead.
718 NOTE: "hv_eiter_set" must be explicitly called as
720 "Perl_hv_eiter_set" with an "aTHX_" parameter.
721 void Perl_hv_eiter_set(pTHX_ HV *hv, HE *eiter)
723 "hv_ename_add"
725 Adds a name to a stash's internal list of effective names. See
726 "hv_ename_delete".
727 This is called when a stash is assigned to a new location in the
729 symbol table.
730 void hv_ename_add(HV *hv, const char *name, U32 len, U32 flags)
732 "hv_ename_delete"
734 Removes a name from a stash's internal list of effective names. If
735 this is the name returned by "HvENAME", then another name in the
736 list will take its place ("HvENAME" will use it).
737 This is called when a stash is deleted from the symbol table.
739 void hv_ename_delete(HV *hv, const char *name, U32 len,
741 U32 flags)
742 "hv_fill"
744 Returns the number of hash buckets that happen to be in use.
745 This function implements the "HvFILL" macro which you should use
747 instead.
748 As of perl 5.25 this function is used only for debugging purposes,
750 and the number of used hash buckets is not in any way cached, thus
751 this function can be costly to execute as it must iterate over all
752 the buckets in the hash.
753 NOTE: "hv_fill" must be explicitly called as "Perl_hv_fill" with an
755 "aTHX_" parameter.
756 STRLEN Perl_hv_fill(pTHX_ HV *const hv)
758 "hv_placeholders_get"
760 Implements "HvPLACEHOLDERS_get", which you should use instead.
761 NOTE: "hv_placeholders_get" must be explicitly called as
763 "Perl_hv_placeholders_get" with an "aTHX_" parameter.
764 I32 Perl_hv_placeholders_get(pTHX_ const HV *hv)
766 "hv_placeholders_set"
768 Implements "HvPLACEHOLDERS_set", which you should use instead.
769 NOTE: "hv_placeholders_set" must be explicitly called as
771 "Perl_hv_placeholders_set" with an "aTHX_" parameter.
772 void Perl_hv_placeholders_set(pTHX_ HV *hv, I32 ph)
774 "hv_riter_p"
776 Implements "HvRITER" which you should use instead.
777 NOTE: "hv_riter_p" must be explicitly called as "Perl_hv_riter_p"
779 with an "aTHX_" parameter.
780 I32* Perl_hv_riter_p(pTHX_ HV *hv)
782 "hv_riter_set"
784 Implements "HvRITER_set" which you should use instead.
785 NOTE: "hv_riter_set" must be explicitly called as
787 "Perl_hv_riter_set" with an "aTHX_" parameter.
788 void Perl_hv_riter_set(pTHX_ HV *hv, I32 riter)
790 "refcounted_he_chain_2hv"
792 Generates and returns a "HV *" representing the content of a
793 "refcounted_he" chain. "flags" is currently unused and must be
794 zero.
795 HV * refcounted_he_chain_2hv(const struct refcounted_he *c,
797 U32 flags)
798 "refcounted_he_fetch_pv"
800 Like "refcounted_he_fetch_pvn", but takes a nul-terminated string
801 instead of a string/length pair.
802 SV * refcounted_he_fetch_pv(const struct refcounted_he *chain,
804 const char *key, U32 hash, U32 flags)
805 "refcounted_he_fetch_pvn"
807 Search along a "refcounted_he" chain for an entry with the key
808 specified by "keypv" and "keylen". If "flags" has the
809 "REFCOUNTED_HE_KEY_UTF8" bit set, the key octets are interpreted as
810 UTF-8, otherwise they are interpreted as Latin-1. "hash" is a
811 precomputed hash of the key string, or zero if it has not been
812 precomputed. Returns a mortal scalar representing the value
813 associated with the key, or &PL_sv_placeholder if there is no value
814 associated with the key.
815 SV * refcounted_he_fetch_pvn(const struct refcounted_he *chain,
817 const char *keypv, STRLEN keylen,
818 U32 hash, U32 flags)
819 "refcounted_he_fetch_pvs"
821 Like "refcounted_he_fetch_pvn", but takes a literal string instead
822 of a string/length pair, and no precomputed hash.
823 SV * refcounted_he_fetch_pvs(const struct refcounted_he *chain,
825 "key", U32 flags)
826 "refcounted_he_fetch_sv"
828 Like "refcounted_he_fetch_pvn", but takes a Perl scalar instead of
829 a string/length pair.
830 SV * refcounted_he_fetch_sv(const struct refcounted_he *chain,
832 SV *key, U32 hash, U32 flags)
833 "refcounted_he_free"
835 Decrements the reference count of a "refcounted_he" by one. If the
836 reference count reaches zero the structure's memory is freed, which
837 (recursively) causes a reduction of its parent "refcounted_he"'s
838 reference count. It is safe to pass a null pointer to this
839 function: no action occurs in this case.
840 void refcounted_he_free(struct refcounted_he *he)
842 "refcounted_he_inc"
844 Increment the reference count of a "refcounted_he". The pointer to
845 the "refcounted_he" is also returned. It is safe to pass a null
846 pointer to this function: no action occurs and a null pointer is
847 returned.
848 struct refcounted_he * refcounted_he_inc(
850 struct refcounted_he *he)
851 "refcounted_he_new_pv"
853 Like "refcounted_he_new_pvn", but takes a nul-terminated string
854 instead of a string/length pair.
855 struct refcounted_he * refcounted_he_new_pv(
857 struct refcounted_he *parent,
858 const char *key, U32 hash,
859 SV *value, U32 flags)
860 "refcounted_he_new_pvn"
862 Creates a new "refcounted_he". This consists of a single key/value
863 pair and a reference to an existing "refcounted_he" chain (which
864 may be empty), and thus forms a longer chain. When using the
865 longer chain, the new key/value pair takes precedence over any
866 entry for the same key further along the chain.
867 The new key is specified by "keypv" and "keylen". If "flags" has
869 the "REFCOUNTED_HE_KEY_UTF8" bit set, the key octets are
870 interpreted as UTF-8, otherwise they are interpreted as Latin-1.
871 "hash" is a precomputed hash of the key string, or zero if it has
872 not been precomputed.
873 "value" is the scalar value to store for this key. "value" is
875 copied by this function, which thus does not take ownership of any
876 reference to it, and later changes to the scalar will not be
877 reflected in the value visible in the "refcounted_he". Complex
878 types of scalar will not be stored with referential integrity, but
879 will be coerced to strings. "value" may be either null or
880 &PL_sv_placeholder to indicate that no value is to be associated
881 with the key; this, as with any non-null value, takes precedence
882 over the existence of a value for the key further along the chain.
883 "parent" points to the rest of the "refcounted_he" chain to be
885 attached to the new "refcounted_he". This function takes ownership
886 of one reference to "parent", and returns one reference to the new
887 "refcounted_he".
888 struct refcounted_he * refcounted_he_new_pvn(
890 struct refcounted_he *parent,
891 const char *keypv,
892 STRLEN keylen, U32 hash,
893 SV *value, U32 flags)
894 "refcounted_he_new_pvs"
896 Like "refcounted_he_new_pvn", but takes a literal string instead of
897 a string/length pair, and no precomputed hash.
898 struct refcounted_he * refcounted_he_new_pvs(
900 struct refcounted_he *parent,
901 "key", SV *value, U32 flags)
902 "refcounted_he_new_sv"
904 Like "refcounted_he_new_pvn", but takes a Perl scalar instead of a
905 string/length pair.
906 struct refcounted_he * refcounted_he_new_sv(
908 struct refcounted_he *parent,
909 SV *key, U32 hash, SV *value,
910 U32 flags)
911 "unsharepvn"
913 If no one has access to shared string "str" with length "len", free
914 it.
915 "len" and "hash" must both be valid for "str".
917 void unsharepvn(const char* sv, I32 len, U32 hash)
919
921 "dirp_dup"
922 Duplicate a directory handle, returning a pointer to the cloned
923 object.
924 DIR* dirp_dup(DIR *const dp, CLONE_PARAMS *const param)
926 "fp_dup"
928 Duplicate a file handle, returning a pointer to the cloned object.
929 PerlIO* fp_dup(PerlIO *const fp, const char type,
931 CLONE_PARAMS *const param)
932 "my_fflush_all"
934 Implements "PERL_FLUSHALL_FOR_CHILD" on some platforms.
935 I32 my_fflush_all()
937 "my_mkostemp"
939 The C library mkostemp(3) if available, or a Perl implementation of
940 it.
941 NOTE: "my_mkostemp" must be explicitly called as "Perl_my_mkostemp"
943 .
944 int Perl_my_mkostemp(char *templte, int flags)
946 "my_mkstemp"
948 The C library mkstemp(3) if available, or a Perl implementation of
949 it.
950 NOTE: "my_mkstemp" must be explicitly called as "Perl_my_mkstemp" .
952 int Perl_my_mkstemp(char *templte)
954 "PL_last_in_gv"
956 The GV which was last used for a filehandle input operation.
957 ("<FH>")
958 On threaded perls, each thread has an independent copy of this
960 variable; each initialized at creation time with the current value
961 of the creating thread's copy.
962 GV* PL_last_in_gv
964 "PL_ofsgv"
966 The glob containing the output field separator - "*," in Perl
967 space.
968 On threaded perls, each thread has an independent copy of this
970 variable; each initialized at creation time with the current value
971 of the creating thread's copy.
972 GV* PL_ofsgv
974 "PL_rs"
976 The input record separator - $/ in Perl space.
977 On threaded perls, each thread has an independent copy of this
979 variable; each initialized at creation time with the current value
980 of the creating thread's copy.
981 SV* PL_rs
983 "start_glob"
985 NOTE: "start_glob" is experimental and may change or be removed
986 without notice.
987 Function called by "do_readline" to spawn a glob (or do the glob
989 inside perl on VMS). This code used to be inline, but now perl
990 uses "File::Glob" this glob starter is only used by miniperl during
991 the build process, or when PERL_EXTERNAL_GLOB is defined. Moving
992 it away shrinks pp_hot.c; shrinking pp_hot.c helps speed perl up.
993 NOTE: "start_glob" must be explicitly called as "Perl_start_glob"
995 with an "aTHX_" parameter.
996 PerlIO* Perl_start_glob(pTHX_ SV *tmpglob, IO *io)
998
1000 There are only public API items currently in Integer
1001
1003 There are only public API items currently in I/O Formats
1004
1006 "validate_proto"
1007 NOTE: "validate_proto" is experimental and may change or be removed
1008 without notice.
1009 This function performs syntax checking on a prototype, "proto". If
1011 "warn" is true, any illegal characters or mismatched brackets will
1012 trigger illegalproto warnings, declaring that they were detected in
1013 the prototype for "name".
1014 The return value is "true" if this is a valid prototype, and
1016 "false" if it is not, regardless of whether "warn" was "true" or
1017 "false".
1018 Note that "NULL" is a valid "proto" and will always return "true".
1020 bool validate_proto(SV *name, SV *proto, bool warn,
1022 bool curstash)
1023
1025 There are only public API items currently in Locales
1026
1028 "magic_clearhint"
1029 Triggered by a delete from "%^H", records the key to
1030 "PL_compiling.cop_hints_hash".
1031 int magic_clearhint(SV* sv, MAGIC* mg)
1033 "magic_clearhints"
1035 Triggered by clearing "%^H", resets "PL_compiling.cop_hints_hash".
1036 int magic_clearhints(SV* sv, MAGIC* mg)
1038 "magic_methcall"
1040 Invoke a magic method (like FETCH).
1041 "sv" and "mg" are the tied thingy and the tie magic.
1043 "meth" is the name of the method to call.
1045 "argc" is the number of args (in addition to $self) to pass to the
1047 method.
1048 The "flags" can be:
1050 G_DISCARD invoke method with G_DISCARD flag and don't
1052 return a value
1053 G_UNDEF_FILL fill the stack with argc pointers to
1054 PL_sv_undef
1055 The arguments themselves are any values following the "flags"
1057 argument.
1058 Returns the SV (if any) returned by the method, or "NULL" on
1060 failure.
1061 NOTE: "magic_methcall" must be explicitly called as
1063 "Perl_magic_methcall" with an "aTHX_" parameter.
1064 SV* Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, SV *meth,
1066 U32 flags, U32 argc, ...)
1067 "magic_sethint"
1069 Triggered by a store to "%^H", records the key/value pair to
1070 "PL_compiling.cop_hints_hash". It is assumed that hints aren't
1071 storing anything that would need a deep copy. Maybe we should warn
1072 if we find a reference.
1073 int magic_sethint(SV* sv, MAGIC* mg)
1075 "mg_dup"
1077 Duplicate a chain of magic, returning a pointer to the cloned
1078 object.
1079 MAGIC* mg_dup(MAGIC *mg, CLONE_PARAMS *const param)
1081 "mg_localize"
1083 Copy some of the magic from an existing SV to new localized version
1084 of that SV. Container magic (e.g., %ENV, $1, "tie") gets copied,
1085 value magic doesn't (e.g., "taint", "pos").
1086 If "setmagic" is false then no set magic will be called on the new
1088 (empty) SV. This typically means that assignment will soon follow
1089 (e.g. 'local $x = $y'), and that will handle the magic.
1090 void mg_localize(SV* sv, SV* nsv, bool setmagic)
1092 "si_dup"
1094 Duplicate a stack info structure, returning a pointer to the cloned
1095 object.
1096 PERL_SI* si_dup(PERL_SI* si, CLONE_PARAMS* param)
1098 "ss_dup"
1100 Duplicate the save stack, returning a pointer to the cloned object.
1101 ANY* ss_dup(PerlInterpreter* proto_perl, CLONE_PARAMS* param)
1103
1105 "calloc"
1106 Implements ""Newxz"" in perlapi which you should use instead.
1107 NOTE: "calloc" must be explicitly called as "Perl_calloc" .
1109 Malloc_t Perl_calloc(MEM_SIZE elements, MEM_SIZE size)
1111 "malloc"
1113 Implements ""Newx"" in perlapi which you should use instead.
1114 NOTE: "malloc" must be explicitly called as "Perl_malloc" .
1116 Malloc_t Perl_malloc(MEM_SIZE nbytes)
1118 "mfree"
1120 Implements ""Safefree"" in perlapi which you should use instead.
1121 NOTE: "mfree" must be explicitly called as "Perl_mfree" .
1123 Free_t Perl_mfree(Malloc_t where)
1125 "realloc"
1127 Implements ""Renew"" in perlapi which you should use instead.
1128 NOTE: "realloc" must be explicitly called as "Perl_realloc" .
1130 Malloc_t Perl_realloc(Malloc_t where, MEM_SIZE nbytes)
1132
1134 "mro_get_linear_isa_dfs"
1135 Returns the Depth-First Search linearization of @ISA the given
1136 stash. The return value is a read-only AV*. "level" should be 0
1137 (it is used internally in this function's recursion).
1138 You are responsible for "SvREFCNT_inc()" on the return value if you
1140 plan to store it anywhere semi-permanently (otherwise it might be
1141 deleted out from under you the next time the cache is invalidated).
1142 AV* mro_get_linear_isa_dfs(HV* stash, U32 level)
1144 "mro_isa_changed_in"
1146 Takes the necessary steps (cache invalidations, mostly) when the
1147 @ISA of the given package has changed. Invoked by the "setisa"
1148 magic, should not need to invoke directly.
1149 void mro_isa_changed_in(HV* stash)
1151 "mro_package_moved"
1153 Call this function to signal to a stash that it has been assigned
1154 to another spot in the stash hierarchy. "stash" is the stash that
1155 has been assigned. "oldstash" is the stash it replaces, if any.
1156 "gv" is the glob that is actually being assigned to.
1157 This can also be called with a null first argument to indicate that
1159 "oldstash" has been deleted.
1160 This function invalidates isa caches on the old stash, on all
1162 subpackages nested inside it, and on the subclasses of all those,
1163 including non-existent packages that have corresponding entries in
1164 "stash".
1165 It also sets the effective names ("HvENAME") on all the stashes as
1167 appropriate.
1168 If the "gv" is present and is not in the symbol table, then this
1170 function simply returns. This checked will be skipped if "flags &
1171 1".
1172 void mro_package_moved(HV * const stash, HV * const oldstash,
1174 const GV * const gv, U32 flags)
1175
1177 There are only public API items currently in Multicall Functions
1178
1180 "isinfnansv"
1181 Checks whether the argument would be either an infinity or "NaN"
1182 when used as a number, but is careful not to trigger non-numeric or
1183 uninitialized warnings. it assumes the caller has done
1184 "SvGETMAGIC(sv)" already.
1185 Note that this always accepts trailing garbage (similar to
1187 "grok_number_flags" with "PERL_SCAN_TRAILING"), so "inferior" and
1188 "NAND gates" will return true.
1189 bool isinfnansv(SV *sv)
1191
1193 "finalize_optree"
1194 This function finalizes the optree. Should be called directly
1195 after the complete optree is built. It does some additional
1196 checking which can't be done in the normal "ck_"xxx functions and
1197 makes the tree thread-safe.
1198 void finalize_optree(OP* o)
1200 "newATTRSUB_x"
1202 Construct a Perl subroutine, also performing some surrounding jobs.
1203 This function is expected to be called in a Perl compilation
1205 context, and some aspects of the subroutine are taken from global
1206 variables associated with compilation. In particular, "PL_compcv"
1207 represents the subroutine that is currently being compiled. It
1208 must be non-null when this function is called, and some aspects of
1209 the subroutine being constructed are taken from it. The
1210 constructed subroutine may actually be a reuse of the "PL_compcv"
1211 object, but will not necessarily be so.
1212 If "block" is null then the subroutine will have no body, and for
1214 the time being it will be an error to call it. This represents a
1215 forward subroutine declaration such as "sub foo ($$);". If "block"
1216 is non-null then it provides the Perl code of the subroutine body,
1217 which will be executed when the subroutine is called. This body
1218 includes any argument unwrapping code resulting from a subroutine
1219 signature or similar. The pad use of the code must correspond to
1220 the pad attached to "PL_compcv". The code is not expected to
1221 include a "leavesub" or "leavesublv" op; this function will add
1222 such an op. "block" is consumed by this function and will become
1223 part of the constructed subroutine.
1224 "proto" specifies the subroutine's prototype, unless one is
1226 supplied as an attribute (see below). If "proto" is null, then the
1227 subroutine will not have a prototype. If "proto" is non-null, it
1228 must point to a "const" op whose value is a string, and the
1229 subroutine will have that string as its prototype. If a prototype
1230 is supplied as an attribute, the attribute takes precedence over
1231 "proto", but in that case "proto" should preferably be null. In
1232 any case, "proto" is consumed by this function.
1233 "attrs" supplies attributes to be applied the subroutine. A
1235 handful of attributes take effect by built-in means, being applied
1236 to "PL_compcv" immediately when seen. Other attributes are
1237 collected up and attached to the subroutine by this route. "attrs"
1238 may be null to supply no attributes, or point to a "const" op for a
1239 single attribute, or point to a "list" op whose children apart from
1240 the "pushmark" are "const" ops for one or more attributes. Each
1241 "const" op must be a string, giving the attribute name optionally
1242 followed by parenthesised arguments, in the manner in which
1243 attributes appear in Perl source. The attributes will be applied
1244 to the sub by this function. "attrs" is consumed by this function.
1245 If "o_is_gv" is false and "o" is null, then the subroutine will be
1247 anonymous. If "o_is_gv" is false and "o" is non-null, then "o"
1248 must point to a "const" OP, which will be consumed by this
1249 function, and its string value supplies a name for the subroutine.
1250 The name may be qualified or unqualified, and if it is unqualified
1251 then a default stash will be selected in some manner. If "o_is_gv"
1252 is true, then "o" doesn't point to an "OP" at all, but is instead a
1253 cast pointer to a "GV" by which the subroutine will be named.
1254 If there is already a subroutine of the specified name, then the
1256 new sub will either replace the existing one in the glob or be
1257 merged with the existing one. A warning may be generated about
1258 redefinition.
1259 If the subroutine has one of a few special names, such as "BEGIN"
1261 or "END", then it will be claimed by the appropriate queue for
1262 automatic running of phase-related subroutines. In this case the
1263 relevant glob will be left not containing any subroutine, even if
1264 it did contain one before. In the case of "BEGIN", the subroutine
1265 will be executed and the reference to it disposed of before this
1266 function returns.
1267 The function returns a pointer to the constructed subroutine. If
1269 the sub is anonymous then ownership of one counted reference to the
1270 subroutine is transferred to the caller. If the sub is named then
1271 the caller does not get ownership of a reference. In most such
1272 cases, where the sub has a non-phase name, the sub will be alive at
1273 the point it is returned by virtue of being contained in the glob
1274 that names it. A phase-named subroutine will usually be alive by
1275 virtue of the reference owned by the phase's automatic run queue.
1276 But a "BEGIN" subroutine, having already been executed, will quite
1277 likely have been destroyed already by the time this function
1278 returns, making it erroneous for the caller to make any use of the
1279 returned pointer. It is the caller's responsibility to ensure that
1280 it knows which of these situations applies.
1281 CV* newATTRSUB_x(I32 floor, OP *o, OP *proto, OP *attrs,
1283 OP *block, bool o_is_gv)
1284 "newXS_len_flags"
1286 Construct an XS subroutine, also performing some surrounding jobs.
1287 The subroutine will have the entry point "subaddr". It will have
1289 the prototype specified by the nul-terminated string "proto", or no
1290 prototype if "proto" is null. The prototype string is copied; the
1291 caller can mutate the supplied string afterwards. If "filename" is
1292 non-null, it must be a nul-terminated filename, and the subroutine
1293 will have its "CvFILE" set accordingly. By default "CvFILE" is set
1294 to point directly to the supplied string, which must be static. If
1295 "flags" has the "XS_DYNAMIC_FILENAME" bit set, then a copy of the
1296 string will be taken instead.
1297 Other aspects of the subroutine will be left in their default
1299 state. If anything else needs to be done to the subroutine for it
1300 to function correctly, it is the caller's responsibility to do that
1301 after this function has constructed it. However, beware of the
1302 subroutine potentially being destroyed before this function
1303 returns, as described below.
1304 If "name" is null then the subroutine will be anonymous, with its
1306 "CvGV" referring to an "__ANON__" glob. If "name" is non-null then
1307 the subroutine will be named accordingly, referenced by the
1308 appropriate glob. "name" is a string of length "len" bytes giving
1309 a sigilless symbol name, in UTF-8 if "flags" has the "SVf_UTF8" bit
1310 set and in Latin-1 otherwise. The name may be either qualified or
1311 unqualified, with the stash defaulting in the same manner as for
1312 "gv_fetchpvn_flags". "flags" may contain flag bits understood by
1313 "gv_fetchpvn_flags" with the same meaning as they have there, such
1314 as "GV_ADDWARN". The symbol is always added to the stash if
1315 necessary, with "GV_ADDMULTI" semantics.
1316 If there is already a subroutine of the specified name, then the
1318 new sub will replace the existing one in the glob. A warning may
1319 be generated about the redefinition. If the old subroutine was
1320 "CvCONST" then the decision about whether to warn is influenced by
1321 an expectation about whether the new subroutine will become a
1322 constant of similar value. That expectation is determined by
1323 "const_svp". (Note that the call to this function doesn't make the
1324 new subroutine "CvCONST" in any case; that is left to the caller.)
1325 If "const_svp" is null then it indicates that the new subroutine
1326 will not become a constant. If "const_svp" is non-null then it
1327 indicates that the new subroutine will become a constant, and it
1328 points to an "SV*" that provides the constant value that the
1329 subroutine will have.
1330 If the subroutine has one of a few special names, such as "BEGIN"
1332 or "END", then it will be claimed by the appropriate queue for
1333 automatic running of phase-related subroutines. In this case the
1334 relevant glob will be left not containing any subroutine, even if
1335 it did contain one before. In the case of "BEGIN", the subroutine
1336 will be executed and the reference to it disposed of before this
1337 function returns, and also before its prototype is set. If a
1338 "BEGIN" subroutine would not be sufficiently constructed by this
1339 function to be ready for execution then the caller must prevent
1340 this happening by giving the subroutine a different name.
1341 The function returns a pointer to the constructed subroutine. If
1343 the sub is anonymous then ownership of one counted reference to the
1344 subroutine is transferred to the caller. If the sub is named then
1345 the caller does not get ownership of a reference. In most such
1346 cases, where the sub has a non-phase name, the sub will be alive at
1347 the point it is returned by virtue of being contained in the glob
1348 that names it. A phase-named subroutine will usually be alive by
1349 virtue of the reference owned by the phase's automatic run queue.
1350 But a "BEGIN" subroutine, having already been executed, will quite
1351 likely have been destroyed already by the time this function
1352 returns, making it erroneous for the caller to make any use of the
1353 returned pointer. It is the caller's responsibility to ensure that
1354 it knows which of these situations applies.
1355 CV * newXS_len_flags(const char *name, STRLEN len,
1357 XSUBADDR_t subaddr,
1358 const char *const filename,
1359 const char *const proto, SV **const_svp,
1360 U32 flags)
1361 "op_refcnt_lock"
1363 Implements the "OP_REFCNT_LOCK" macro which you should use instead.
1364 void op_refcnt_lock()
1366 "op_refcnt_unlock"
1368 Implements the "OP_REFCNT_UNLOCK" macro which you should use
1369 instead.
1370 void op_refcnt_unlock()
1372 "optimize_optree"
1374 This function applies some optimisations to the optree in top-down
1375 order. It is called before the peephole optimizer, which processes
1376 ops in execution order. Note that finalize_optree() also does a
1377 top-down scan, but is called *after* the peephole optimizer.
1378 void optimize_optree(OP* o)
1380 "traverse_op_tree"
1382 Return the next op in a depth-first traversal of the op tree,
1383 returning NULL when the traversal is complete.
1384 The initial call must supply the root of the tree as both top and
1386 o.
1387 For now it's static, but it may be exposed to the API in the
1389 future.
1390 OP* traverse_op_tree(OP* top, OP* o)
1392
1394 There are only public API items currently in Pack and Unpack
1395
1397 "CX_CURPAD_SAVE"
1398 Save the current pad in the given context block structure.
1399 void CX_CURPAD_SAVE(struct context)
1401 "CX_CURPAD_SV"
1403 Access the SV at offset "po" in the saved current pad in the given
1404 context block structure (can be used as an lvalue).
1405 SV * CX_CURPAD_SV(struct context, PADOFFSET po)
1407 "PAD_BASE_SV"
1409 Get the value from slot "po" in the base (DEPTH=1) pad of a padlist
1410 SV * PAD_BASE_SV(PADLIST padlist, PADOFFSET po)
1412 "PAD_CLONE_VARS"
1414 Clone the state variables associated with running and compiling
1415 pads.
1416 void PAD_CLONE_VARS(PerlInterpreter *proto_perl,
1418 CLONE_PARAMS* param)
1419 "PAD_COMPNAME_FLAGS"
1421 Return the flags for the current compiling pad name at offset "po".
1422 Assumes a valid slot entry.
1423 U32 PAD_COMPNAME_FLAGS(PADOFFSET po)
1425 "PAD_COMPNAME_GEN"
1427 The generation number of the name at offset "po" in the current
1428 compiling pad (lvalue).
1429 STRLEN PAD_COMPNAME_GEN(PADOFFSET po)
1431 "PAD_COMPNAME_GEN_set"
1433 Sets the generation number of the name at offset "po" in the
1434 current ling pad (lvalue) to "gen".
1435 STRLEN PAD_COMPNAME_GEN_set(PADOFFSET po, int gen)
1437 "PAD_COMPNAME_OURSTASH"
1439 Return the stash associated with an "our" variable. Assumes the
1440 slot entry is a valid "our" lexical.
1441 HV * PAD_COMPNAME_OURSTASH(PADOFFSET po)
1443 "PAD_COMPNAME_PV"
1445 Return the name of the current compiling pad name at offset "po".
1446 Assumes a valid slot entry.
1447 char * PAD_COMPNAME_PV(PADOFFSET po)
1449 "PAD_COMPNAME_TYPE"
1451 Return the type (stash) of the current compiling pad name at offset
1452 "po". Must be a valid name. Returns null if not typed.
1453 HV * PAD_COMPNAME_TYPE(PADOFFSET po)
1455 "PadnameIsOUR"
1457 Whether this is an "our" variable.
1458 bool PadnameIsOUR(PADNAME * pn)
1460 "PadnameIsSTATE"
1462 Whether this is a "state" variable.
1463 bool PadnameIsSTATE(PADNAME * pn)
1465 "PadnameOURSTASH"
1467 The stash in which this "our" variable was declared.
1468 HV * PadnameOURSTASH(PADNAME * pn)
1470 "PadnameOUTER"
1472 Whether this entry belongs to an outer pad. Entries for which this
1473 is true are often referred to as 'fake'.
1474 bool PadnameOUTER(PADNAME * pn)
1476 "PadnameTYPE"
1478 The stash associated with a typed lexical. This returns the %Foo::
1479 hash for "my Foo $bar".
1480 HV * PadnameTYPE(PADNAME * pn)
1482 "PAD_RESTORE_LOCAL"
1484 Restore the old pad saved into the local variable "opad" by
1485 "PAD_SAVE_LOCAL()"
1486 void PAD_RESTORE_LOCAL(PAD *opad)
1488 "PAD_SAVE_LOCAL"
1490 Save the current pad to the local variable "opad", then make the
1491 current pad equal to "npad"
1492 void PAD_SAVE_LOCAL(PAD *opad, PAD *npad)
1494 "PAD_SAVE_SETNULLPAD"
1496 Save the current pad then set it to null.
1497 void PAD_SAVE_SETNULLPAD()
1499 "PAD_SETSV"
1501 Set the slot at offset "po" in the current pad to "sv"
1502 SV * PAD_SETSV(PADOFFSET po, SV* sv)
1504 "PAD_SET_CUR"
1506 Set the current pad to be pad "n" in the padlist, saving the
1507 previous current pad. NB currently this macro expands to a string
1508 too long for some compilers, so it's best to replace it with
1509 SAVECOMPPAD();
1511 PAD_SET_CUR_NOSAVE(padlist,n);
1512 void PAD_SET_CUR(PADLIST padlist, I32 n)
1514 "PAD_SET_CUR_NOSAVE"
1516 like PAD_SET_CUR, but without the save
1517 void PAD_SET_CUR_NOSAVE(PADLIST padlist, I32 n)
1519 "PAD_SV"
1521 Get the value at offset "po" in the current pad
1522 SV * PAD_SV(PADOFFSET po)
1524 "PAD_SVl"
1526 Lightweight and lvalue version of "PAD_SV". Get or set the value
1527 at offset "po" in the current pad. Unlike "PAD_SV", does not print
1528 diagnostics with -DX. For internal use only.
1529 SV * PAD_SVl(PADOFFSET po)
1531 "SAVECLEARSV"
1533 Clear the pointed to pad value on scope exit. (i.e. the runtime
1534 action of "my")
1535 void SAVECLEARSV(SV **svp)
1537 "SAVECOMPPAD"
1539 save "PL_comppad" and "PL_curpad"
1540 void SAVECOMPPAD()
1542 "SAVEPADSV"
1544 Save a pad slot (used to restore after an iteration)
1545 void SAVEPADSV(PADOFFSET po)
1547
1549 There are only public API items currently in Password and Group access
1550
1552 There are only public API items currently in Paths to system commands
1553
1555 There are only public API items currently in Prototype information
1556
1558 "regnode"
1559 Described in perlreguts.
1560
1562 There are only public API items currently in Reports and Formats
1563
1565 There are only public API items currently in Signals
1566
1568 There are only public API items currently in Site configuration
1569
1571 There are only public API items currently in Sockets configuration
1572 values
1573
1575 There are only public API items currently in Source Filters
1576
1578 "djSP"
1579 Declare Just "SP". This is actually identical to "dSP", and
1580 declares a local copy of perl's stack pointer, available via the
1581 "SP" macro. See ""SP" in perlapi". (Available for backward source
1582 code compatibility with the old (Perl 5.005) thread model.)
1583 djSP();
1585 "LVRET"
1587 True if this op will be the return value of an lvalue subroutine
1588 "save_alloc"
1590 Implements ""SSNEW"" in perlapi and kin, which should be used
1591 instead of this function.
1592 I32 save_alloc(I32 size, I32 pad)
1594
1596 "delimcpy_no_escape"
1597 Copy a source buffer to a destination buffer, stopping at (but not
1598 including) the first occurrence in the source of the delimiter
1599 byte, "delim". The source is the bytes between
1600 "from" and "from_end" - 1. Similarly, the dest is "to" up to
1601 "to_end".
1602 The number of bytes copied is written to *retlen.
1604 Returns the position of "delim" in the "from" buffer, but if there
1606 is no such occurrence before "from_end", then "from_end" is
1607 returned, and the entire buffer "from" .. "from_end" - 1 is copied.
1608 If there is room in the destination available after the copy, an
1610 extra terminating safety "NUL" byte is appended (not included in
1611 the returned length).
1612 The error case is if the destination buffer is not large enough to
1614 accommodate everything that should be copied. In this situation, a
1615 value larger than "to_end" - "to" is written to *retlen, and as
1616 much of the source as fits will be written to the destination. Not
1617 having room for the safety "NUL" is not considered an error.
1618 char* delimcpy_no_escape(char* to, const char* to_end,
1620 const char* from, const char* from_end,
1621 const int delim, I32* retlen)
1622 "my_cxt_init"
1624 Implements the ""MY_CXT_INIT"" in perlxs macro, which you should
1625 use instead.
1626 The first time a module is loaded, the global "PL_my_cxt_index" is
1628 incremented, and that value is assigned to that module's static
1629 "my_cxt_index" (whose address is passed as an arg). Then, for each
1630 interpreter this function is called for, it makes sure a "void*"
1631 slot is available to hang the static data off, by allocating or
1632 extending the interpreter's "PL_my_cxt_list" array
1633 NOTE: "my_cxt_init" must be explicitly called as "Perl_my_cxt_init"
1635 with an "aTHX_" parameter.
1636 void* Perl_my_cxt_init(pTHX_ int *indexp, size_t size)
1638 "quadmath_format_needed"
1640 "quadmath_format_needed()" returns true if the "format" string
1641 seems to contain at least one non-Q-prefixed "%[efgaEFGA]" format
1642 specifier, or returns false otherwise.
1643 The format specifier detection is not complete printf-syntax
1645 detection, but it should catch most common cases.
1646 If true is returned, those arguments should in theory be processed
1648 with "quadmath_snprintf()", but in case there is more than one such
1649 format specifier (see "quadmath_format_valid"), and if there is
1650 anything else beyond that one (even just a single byte), they
1651 cannot be processed because "quadmath_snprintf()" is very strict,
1652 accepting only one format spec, and nothing else. In this case,
1653 the code should probably fail.
1654 bool quadmath_format_needed(const char* format)
1656 "quadmath_format_valid"
1658 "quadmath_snprintf()" is very strict about its "format" string and
1659 will fail, returning -1, if the format is invalid. It accepts
1660 exactly one format spec.
1661 "quadmath_format_valid()" checks that the intended single spec
1663 looks sane: begins with "%", has only one "%", ends with
1664 "[efgaEFGA]", and has "Q" before it. This is not a full "printf
1665 syntax check", just the basics.
1666 Returns true if it is valid, false if not.
1668 See also "quadmath_format_needed".
1670 bool quadmath_format_valid(const char* format)
1672
1674 "SVt_INVLIST"
1675 Type flag for scalars. See "svtype" in perlapi.
1676
1678 "PL_Sv"
1679 A scratch pad SV for whatever temporary use you need. Chiefly used
1680 as a fallback by macros on platforms where
1681 "PERL_USE_GCC_BRACE_GROUPS" in perlapi> is unavailable, and which
1682 would otherwise evaluate their SV parameter more than once.
1683 PL_Sv
1685 "sv_2bool"
1687 This macro is only used by "sv_true()" or its macro equivalent, and
1688 only if the latter's argument is neither "SvPOK", "SvIOK" nor
1689 "SvNOK". It calls "sv_2bool_flags" with the "SV_GMAGIC" flag.
1690 bool sv_2bool(SV *const sv)
1692 "sv_2bool_flags"
1694 This function is only used by "sv_true()" and friends, and only if
1695 the latter's argument is neither "SvPOK", "SvIOK" nor "SvNOK". If
1696 the flags contain "SV_GMAGIC", then it does an "mg_get()" first.
1697 bool sv_2bool_flags(SV *sv, I32 flags)
1699 "sv_2num"
1701 NOTE: "sv_2num" is experimental and may change or be removed
1702 without notice.
1703 Return an SV with the numeric value of the source SV, doing any
1705 necessary reference or overload conversion. The caller is expected
1706 to have handled get-magic already.
1707 SV* sv_2num(SV *const sv)
1709 "sv_2pvbyte_nolen"
1711 Return a pointer to the byte-encoded representation of the SV. May
1712 cause the SV to be downgraded from UTF-8 as a side-effect.
1713 Usually accessed via the "SvPVbyte_nolen" macro.
1715 char* sv_2pvbyte_nolen(SV* sv)
1717 "sv_2pvutf8_nolen"
1719 Return a pointer to the UTF-8-encoded representation of the SV.
1720 May cause the SV to be upgraded to UTF-8 as a side-effect.
1721 Usually accessed via the "SvPVutf8_nolen" macro.
1723 char* sv_2pvutf8_nolen(SV* sv)
1725 "sv_2pv_nolen"
1727 Like "sv_2pv()", but doesn't return the length too. You should
1728 usually use the macro wrapper "SvPV_nolen(sv)" instead.
1729 char* sv_2pv_nolen(SV* sv)
1731 "sv_add_arena"
1733 Given a chunk of memory, link it to the head of the list of arenas,
1734 and split it into a list of free SVs.
1735 void sv_add_arena(char *const ptr, const U32 size,
1737 const U32 flags)
1738 "sv_clean_all"
1740 Decrement the refcnt of each remaining SV, possibly triggering a
1741 cleanup. This function may have to be called multiple times to
1742 free SVs which are in complex self-referential hierarchies.
1743 I32 sv_clean_all()
1745 "sv_clean_objs"
1747 Attempt to destroy all objects not yet freed.
1748 void sv_clean_objs()
1750 "sv_free_arenas"
1752 Deallocate the memory used by all arenas. Note that all the
1753 individual SV heads and bodies within the arenas must already have
1754 been freed.
1755 void sv_free_arenas()
1757 "sv_grow"
1759 Expands the character buffer in the SV. If necessary, uses
1760 "sv_unref" and upgrades the SV to "SVt_PV". Returns a pointer to
1761 the character buffer. Use the "SvGROW" wrapper instead.
1762 char* sv_grow(SV *const sv, STRLEN newlen)
1764 "sv_grow_fresh"
1766 A cut-down version of sv_grow intended only for when sv is a
1767 freshly-minted SVt_PV, SVt_PVIV, SVt_PVNV, or SVt_PVMG. i.e. sv has
1768 the default flags, has never been any other type, and does not have
1769 an existing string. Basically, just assigns a char buffer and
1770 returns a pointer to it.
1771 char* sv_grow_fresh(SV *const sv, STRLEN newlen)
1773 "sv_iv"
1775 "DEPRECATED!" It is planned to remove "sv_iv" from a future
1776 release of Perl. Do not use it for new code; remove it from
1777 existing code.
1778 A private implementation of the "SvIVx" macro for compilers which
1780 can't cope with complex macro expressions. Always use the macro
1781 instead.
1782 IV sv_iv(SV* sv)
1784 "sv_newref"
1786 Increment an SV's reference count. Use the "SvREFCNT_inc()"
1787 wrapper instead.
1788 SV* sv_newref(SV *const sv)
1790 "sv_nv"
1792 "DEPRECATED!" It is planned to remove "sv_nv" from a future
1793 release of Perl. Do not use it for new code; remove it from
1794 existing code.
1795 A private implementation of the "SvNVx" macro for compilers which
1797 can't cope with complex macro expressions. Always use the macro
1798 instead.
1799 NV sv_nv(SV* sv)
1801 "sv_pv"
1803 Use the "SvPV_nolen" macro instead
1804 char* sv_pv(SV *sv)
1806 "sv_pvbyte"
1808 Use "SvPVbyte_nolen" instead.
1809 char* sv_pvbyte(SV *sv)
1811 "sv_pvbyten"
1813 "DEPRECATED!" It is planned to remove "sv_pvbyten" from a future
1814 release of Perl. Do not use it for new code; remove it from
1815 existing code.
1816 A private implementation of the "SvPVbyte" macro for compilers
1818 which can't cope with complex macro expressions. Always use the
1819 macro instead.
1820 char* sv_pvbyten(SV *sv, STRLEN *lp)
1822 "sv_pvbyten_force"
1824 The backend for the "SvPVbytex_force" macro. Always use the macro
1825 instead. If the SV cannot be downgraded from UTF-8, this croaks.
1826 char* sv_pvbyten_force(SV *const sv, STRLEN *const lp)
1828 "sv_pvn"
1830 "DEPRECATED!" It is planned to remove "sv_pvn" from a future
1831 release of Perl. Do not use it for new code; remove it from
1832 existing code.
1833 A private implementation of the "SvPV" macro for compilers which
1835 can't cope with complex macro expressions. Always use the macro
1836 instead.
1837 char* sv_pvn(SV *sv, STRLEN *lp)
1839 "sv_pvn_force"
1841 Get a sensible string out of the SV somehow. A private
1842 implementation of the "SvPV_force" macro for compilers which can't
1843 cope with complex macro expressions. Always use the macro instead.
1844 char* sv_pvn_force(SV* sv, STRLEN* lp)
1846 "sv_pvutf8"
1848 Use the "SvPVutf8_nolen" macro instead
1849 char* sv_pvutf8(SV *sv)
1851 "sv_pvutf8n"
1853 "DEPRECATED!" It is planned to remove "sv_pvutf8n" from a future
1854 release of Perl. Do not use it for new code; remove it from
1855 existing code.
1856 A private implementation of the "SvPVutf8" macro for compilers
1858 which can't cope with complex macro expressions. Always use the
1859 macro instead.
1860 char* sv_pvutf8n(SV *sv, STRLEN *lp)
1862 "sv_pvutf8n_force"
1864 The backend for the "SvPVutf8x_force" macro. Always use the macro
1865 instead.
1866 char* sv_pvutf8n_force(SV *const sv, STRLEN *const lp)
1868 "sv_tainted"
1870 Test an SV for taintedness. Use "SvTAINTED" instead.
1871 bool sv_tainted(SV *const sv)
1873 "SvTHINKFIRST"
1875 A quick flag check to see whether an "sv" should be passed to
1876 "sv_force_normal" to be "downgraded" before "SvIVX" or "SvPVX" can
1877 be modified directly.
1878 For example, if your scalar is a reference and you want to modify
1880 the "SvIVX" slot, you can't just do "SvROK_off", as that will leak
1881 the referent.
1882 This is used internally by various sv-modifying functions, such as
1884 "sv_setsv", "sv_setiv" and "sv_pvn_force".
1885 One case that this does not handle is a gv without SvFAKE set.
1887 After
1888 if (SvTHINKFIRST(gv)) sv_force_normal(gv);
1890 it will still be a gv.
1892 "SvTHINKFIRST" sometimes produces false positives. In those cases
1894 "sv_force_normal" does nothing.
1895 U32 SvTHINKFIRST(SV *sv)
1897 "sv_true"
1899 Returns true if the SV has a true value by Perl's rules. Use the
1900 "SvTRUE" macro instead, which may call "sv_true()" or may instead
1901 use an in-line version.
1902 I32 sv_true(SV *const sv)
1904 "sv_untaint"
1906 Untaint an SV. Use "SvTAINTED_off" instead.
1907 void sv_untaint(SV *const sv)
1909 "sv_uv"
1911 "DEPRECATED!" It is planned to remove "sv_uv" from a future
1912 release of Perl. Do not use it for new code; remove it from
1913 existing code.
1914 A private implementation of the "SvUVx" macro for compilers which
1916 can't cope with complex macro expressions. Always use the macro
1917 instead.
1918 UV sv_uv(SV* sv)
1920
1922 "sv_taint"
1923 Taint an SV. Use "SvTAINTED_on" instead.
1924 void sv_taint(SV* sv)
1926 "TAINT"
1928 If we aren't in taint checking mode, do nothing; otherwise indicate
1929 to ""TAINT_set"" and ""TAINT_PROPER"" that some unspecified element
1930 is tainted.
1931 void TAINT()
1933 "TAINT_ENV"
1935 Looks at several components of %ENV for taintedness, and calls
1936 ""taint_proper"" if any are tainted. The components it searches
1937 are things like $PATH.
1938 void TAINT_ENV
1940 "taint_env"
1942 Implements the "TAINT_ENV" macro, which you should generally use
1943 instead.
1944 void taint_env()
1946 "TAINT_get"
1948 Returns a boolean as to whether some element is tainted or not.
1949 bool TAINT_get()
1951 "TAINT_IF"
1953 If "c" evaluates to true, call ""TAINT"" to indicate that something
1954 is tainted; otherwise do nothing.
1955 void TAINT_IF(bool c)
1957 "TAINTING_get"
1959 Returns a boolean as to whether taint checking is enabled or not.
1960 bool TAINTING_get()
1962 "TAINTING_set"
1964 Turn taint checking mode off/on
1965 void TAINTING_set(bool s)
1967 "TAINT_NOT"
1969 Remove any taintedness previously set by, e.g., "TAINT".
1970 void TAINT_NOT()
1972 "TAINT_PROPER"
1974 If no element is tainted, do nothing; otherwise output a message
1975 (containing "s") that indicates there is a tainting violation. If
1976 such violations are fatal, it croaks.
1977 void TAINT_PROPER(const char * s)
1979 "taint_proper"
1981 Implements the "TAINT_PROPER" macro, which you should generally use
1982 instead.
1983 void taint_proper(const char* f, const char *const s)
1985 "TAINT_set"
1987 If "s" is true, ""TAINT_get"" returns true; If "s" is false,
1988 ""TAINT_get"" returns false;
1989 void TAINT_set(bool s)
1991 "TAINT_WARN_get"
1993 Returns false if tainting violations are fatal; Returns true if
1994 they're just warnings
1995 bool TAINT_WARN_get()
1997 "TAINT_WARN_set"
1999 "s" being true indicates ""TAINT_WARN_get"" should return that
2000 tainting violations are just warnings
2001 "s" being false indicates ""TAINT_WARN_get"" should return that
2003 tainting violations are fatal.
2004 void TAINT_WARN_set(bool s)
2006
2008 There are only public API items currently in Time
2009
2011 There are only public API items currently in Typedef names
2012
2014 "bytes_from_utf8_loc"
2015 NOTE: "bytes_from_utf8_loc" is experimental and may change or be
2016 removed without notice.
2017 Like ""bytes_from_utf8" in perlapi()", but takes an extra
2019 parameter, a pointer to where to store the location of the first
2020 character in "s" that cannot be converted to non-UTF8.
2021 If that parameter is "NULL", this function behaves identically to
2023 "bytes_from_utf8".
2024 Otherwise if *is_utf8p is 0 on input, the function behaves
2026 identically to "bytes_from_utf8", except it also sets
2027 *first_non_downgradable to "NULL".
2028 Otherwise, the function returns a newly created "NUL"-terminated
2030 string containing the non-UTF8 equivalent of the convertible first
2031 portion of "s". *lenp is set to its length, not including the
2032 terminating "NUL". If the entire input string was converted,
2033 *is_utf8p is set to a FALSE value, and *first_non_downgradable is
2034 set to "NULL".
2035 Otherwise, *first_non_downgradable is set to point to the first
2037 byte of the first character in the original string that wasn't
2038 converted. *is_utf8p is unchanged. Note that the new string may
2039 have length 0.
2040 Another way to look at it is, if *first_non_downgradable is
2042 non-"NULL" and *is_utf8p is TRUE, this function starts at the
2043 beginning of "s" and converts as many characters in it as possible
2044 stopping at the first one it finds that can't be converted to
2045 non-UTF-8. *first_non_downgradable is set to point to that. The
2046 function returns the portion that could be converted in a newly
2047 created "NUL"-terminated string, and *lenp is set to its length,
2048 not including the terminating "NUL". If the very first character
2049 in the original could not be converted, *lenp will be 0, and the
2050 new string will contain just a single "NUL". If the entire input
2051 string was converted, *is_utf8p is set to FALSE and
2052 *first_non_downgradable is set to "NULL".
2053 Upon successful return, the number of variants in the converted
2055 portion of the string can be computed by having saved the value of
2056 *lenp before the call, and subtracting the after-call value of
2057 *lenp from it.
2058 U8* bytes_from_utf8_loc(const U8 *s, STRLEN *lenp,
2060 bool *is_utf8p,
2061 const U8 ** first_unconverted)
2062 "find_uninit_var"
2064 NOTE: "find_uninit_var" is experimental and may change or be
2065 removed without notice.
2066 Find the name of the undefined variable (if any) that caused the
2068 operator to issue a "Use of uninitialized value" warning. If match
2069 is true, only return a name if its value matches "uninit_sv". So
2070 roughly speaking, if a unary operator (such as "OP_COS") generates
2071 a warning, then following the direct child of the op may yield an
2072 "OP_PADSV" or "OP_GV" that gives the name of the undefined
2073 variable. On the other hand, with "OP_ADD" there are two branches
2074 to follow, so we only print the variable name if we get an exact
2075 match. "desc_p" points to a string pointer holding the description
2076 of the op. This may be updated if needed.
2077 The name is returned as a mortal SV.
2079 Assumes that "PL_op" is the OP that originally triggered the error,
2081 and that "PL_comppad"/"PL_curpad" points to the currently executing
2082 pad.
2083 SV* find_uninit_var(const OP *const obase,
2085 const SV *const uninit_sv, bool match,
2086 const char **desc_p)
2087 "isSCRIPT_RUN"
2089 Returns a bool as to whether or not the sequence of bytes from "s"
2090 up to but not including "send" form a "script run". "utf8_target"
2091 is TRUE iff the sequence starting at "s" is to be treated as UTF-8.
2092 To be precise, except for two degenerate cases given below, this
2093 function returns TRUE iff all code points in it come from any
2094 combination of three "scripts" given by the Unicode "Script
2095 Extensions" property: Common, Inherited, and possibly one other.
2096 Additionally all decimal digits must come from the same consecutive
2097 sequence of 10.
2098 For example, if all the characters in the sequence are Greek, or
2100 Common, or Inherited, this function will return TRUE, provided any
2101 decimal digits in it are from the same block of digits in Common.
2102 (These are the ASCII digits "0".."9" and additionally a block for
2103 full width forms of these, and several others used in mathematical
2104 notation.) For scripts (unlike Greek) that have their own digits
2105 defined this will accept either digits from that set or from one of
2106 the Common digit sets, but not a combination of the two. Some
2107 scripts, such as Arabic, have more than one set of digits. All
2108 digits must come from the same set for this function to return
2109 TRUE.
2110 *ret_script, if "ret_script" is not NULL, will on return of TRUE
2112 contain the script found, using the "SCX_enum" typedef. Its value
2113 will be "SCX_INVALID" if the function returns FALSE.
2114 If the sequence is empty, TRUE is returned, but *ret_script (if
2116 asked for) will be "SCX_INVALID".
2117 If the sequence contains a single code point which is unassigned to
2119 a character in the version of Unicode being used, the function will
2120 return TRUE, and the script will be "SCX_Unknown". Any other
2121 combination of unassigned code points in the input sequence will
2122 result in the function treating the input as not being a script
2123 run.
2124 The returned script will be "SCX_Inherited" iff all the code points
2126 in it are from the Inherited script.
2127 Otherwise, the returned script will be "SCX_Common" iff all the
2129 code points in it are from the Inherited or Common scripts.
2130 bool isSCRIPT_RUN(const U8 *s, const U8 *send,
2132 const bool utf8_target)
2133 "is_utf8_non_invariant_string"
2135 Returns TRUE if "is_utf8_invariant_string" in perlapi returns FALSE
2136 for the first "len" bytes of the string "s", but they are,
2137 nonetheless, legal Perl-extended UTF-8; otherwise returns FALSE.
2138 A TRUE return means that at least one code point represented by the
2140 sequence either is a wide character not representable as a single
2141 byte, or the representation differs depending on whether the
2142 sequence is encoded in UTF-8 or not.
2143 See also ""is_utf8_invariant_string" in perlapi", ""is_utf8_string"
2145 in perlapi"
2146 bool is_utf8_non_invariant_string(const U8* const s, STRLEN len)
2148 "report_uninit"
2150 Print appropriate "Use of uninitialized variable" warning.
2151 void report_uninit(const SV *uninit_sv)
2153 "utf8n_to_uvuni"
2155 "DEPRECATED!" It is planned to remove "utf8n_to_uvuni" from a
2156 future release of Perl. Do not use it for new code; remove it from
2157 existing code.
2158 Instead use "utf8_to_uvchr_buf" in perlapi, or rarely,
2160 "utf8n_to_uvchr" in perlapi.
2161 This function was useful for code that wanted to handle both EBCDIC
2163 and ASCII platforms with Unicode properties, but starting in Perl
2164 v5.20, the distinctions between the platforms have mostly been made
2165 invisible to most code, so this function is quite unlikely to be
2166 what you want. If you do need this precise functionality, use
2167 instead "NATIVE_TO_UNI(utf8_to_uvchr_buf(...))" or
2168 "NATIVE_TO_UNI(utf8n_to_uvchr(...))".
2169 UV utf8n_to_uvuni(const U8 *s, STRLEN curlen, STRLEN *retlen,
2171 U32 flags)
2172 "utf8_to_uvuni"
2174 "DEPRECATED!" It is planned to remove "utf8_to_uvuni" from a
2175 future release of Perl. Do not use it for new code; remove it from
2176 existing code.
2177 Returns the Unicode code point of the first character in the string
2179 "s" which is assumed to be in UTF-8 encoding; "retlen" will be set
2180 to the length, in bytes, of that character.
2181 Some, but not all, UTF-8 malformations are detected, and in fact,
2183 some malformed input could cause reading beyond the end of the
2184 input buffer, which is one reason why this function is deprecated.
2185 The other is that only in extremely limited circumstances should
2186 the Unicode versus native code point be of any interest to you.
2187 See "utf8_to_uvuni_buf" for alternatives.
2188 If "s" points to one of the detected malformations, and UTF8
2190 warnings are enabled, zero is returned and *retlen is set (if
2191 "retlen" doesn't point to NULL) to -1. If those warnings are off,
2192 the computed value if well-defined (or the Unicode REPLACEMENT
2193 CHARACTER, if not) is silently returned, and *retlen is set (if
2194 "retlen" isn't NULL) so that ("s" + *retlen) is the next possible
2195 position in "s" that could begin a non-malformed character. See
2196 "utf8n_to_uvchr" in perlapi for details on when the REPLACEMENT
2197 CHARACTER is returned.
2198 UV utf8_to_uvuni(const U8 *s, STRLEN *retlen)
2200 "utf8_to_uvuni_buf"
2202 "DEPRECATED!" It is planned to remove "utf8_to_uvuni_buf" from a
2203 future release of Perl. Do not use it for new code; remove it from
2204 existing code.
2205 Only in very rare circumstances should code need to be dealing in
2207 Unicode (as opposed to native) code points. In those few cases,
2208 use "NATIVE_TO_UNI(utf8_to_uvchr_buf(...))" instead. If you are
2209 not absolutely sure this is one of those cases, then assume it
2210 isn't and use plain "utf8_to_uvchr_buf" instead.
2211 Returns the Unicode (not-native) code point of the first character
2213 in the string "s" which is assumed to be in UTF-8 encoding; "send"
2214 points to 1 beyond the end of "s". "retlen" will be set to the
2215 length, in bytes, of that character.
2216 If "s" does not point to a well-formed UTF-8 character and UTF8
2218 warnings are enabled, zero is returned and *retlen is set (if
2219 "retlen" isn't NULL) to -1. If those warnings are off, the
2220 computed value if well-defined (or the Unicode REPLACEMENT
2221 CHARACTER, if not) is silently returned, and *retlen is set (if
2222 "retlen" isn't NULL) so that ("s" + *retlen) is the next possible
2223 position in "s" that could begin a non-malformed character. See
2224 "utf8n_to_uvchr" in perlapi for details on when the REPLACEMENT
2225 CHARACTER is returned.
2226 UV utf8_to_uvuni_buf(const U8 *s, const U8 *send, STRLEN *retlen)
2228 "uvoffuni_to_utf8_flags"
2230 THIS FUNCTION SHOULD BE USED IN ONLY VERY SPECIALIZED
2231 CIRCUMSTANCES. Instead, Almost all code should use "uvchr_to_utf8"
2232 in perlapi or "uvchr_to_utf8_flags" in perlapi.
2233 This function is like them, but the input is a strict Unicode (as
2235 opposed to native) code point. Only in very rare circumstances
2236 should code not be using the native code point.
2237 For details, see the description for "uvchr_to_utf8_flags" in
2239 perlapi.
2240 U8* uvoffuni_to_utf8_flags(U8 *d, UV uv, UV flags)
2242 "uvuni_to_utf8_flags"
2244 "DEPRECATED!" It is planned to remove "uvuni_to_utf8_flags" from a
2245 future release of Perl. Do not use it for new code; remove it from
2246 existing code.
2247 Instead you almost certainly want to use "uvchr_to_utf8" in perlapi
2249 or "uvchr_to_utf8_flags" in perlapi.
2250 This function is a deprecated synonym for "uvoffuni_to_utf8_flags",
2252 which itself, while not deprecated, should be used only in isolated
2253 circumstances. These functions were useful for code that wanted to
2254 handle both EBCDIC and ASCII platforms with Unicode properties, but
2255 starting in Perl v5.20, the distinctions between the platforms have
2256 mostly been made invisible to most code, so this function is quite
2257 unlikely to be what you want.
2258 U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)
2260 "valid_utf8_to_uvchr"
2262 Like ""utf8_to_uvchr_buf" in perlapi", but should only be called
2263 when it is known that the next character in the input UTF-8 string
2264 "s" is well-formed (e.g., it passes ""isUTF8_CHAR" in perlapi".
2265 Surrogates, non-character code points, and non-Unicode code points
2266 are allowed.
2267 UV valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen)
2269 "variant_under_utf8_count"
2271 This function looks at the sequence of bytes between "s" and "e",
2272 which are assumed to be encoded in ASCII/Latin1, and returns how
2273 many of them would change should the string be translated into
2274 UTF-8. Due to the nature of UTF-8, each of these would occupy two
2275 bytes instead of the single one in the input string. Thus, this
2276 function returns the precise number of bytes the string would
2277 expand by when translated to UTF-8.
2278 Unlike most of the other functions that have "utf8" in their name,
2280 the input to this function is NOT a UTF-8-encoded string. The
2281 function name is slightly odd to emphasize this.
2282 This function is internal to Perl because khw thinks that any XS
2284 code that would want this is probably operating too close to the
2285 internals. Presenting a valid use case could change that.
2286 See also ""is_utf8_invariant_string" in perlapi" and
2288 ""is_utf8_invariant_string_loc" in perlapi",
2289 Size_t variant_under_utf8_count(const U8* const s,
2291 const U8* const e)
2292
2294 "my_popen_list"
2295 Implementing function on some systems for PerlProc_popen_list()
2296 PerlIO* my_popen_list(const char* mode, int n, SV ** args)
2298 "my_socketpair"
2300 Emulates socketpair(2) on systems that don't have it, but which do
2301 have enough functionality for the emulation.
2302 int my_socketpair(int family, int type, int protocol, int fd[2])
2304
2306 There are only public API items currently in Versioning
2307
2309 "PL_dowarn"
2310 The C variable that roughly corresponds to Perl's $^W warning
2311 variable. However, $^W is treated as a boolean, whereas
2312 "PL_dowarn" is a collection of flag bits.
2313 On threaded perls, each thread has an independent copy of this
2315 variable; each initialized at creation time with the current value
2316 of the creating thread's copy.
2317 U8 PL_dowarn
2319
2321 There are only public API items currently in XS
2322
2324 The following functions are currently undocumented. If you use one of
2325 them, you may wish to consider creating and submitting documentation
2326 for it.
2327 abort_execution
2329 add_cp_to_invlist
2330 _add_range_to_invlist
2331 alloc_LOGOP
2332 allocmy
2333 amagic_cmp
2334 amagic_cmp_desc
2335 amagic_cmp_locale
2336 amagic_cmp_locale_desc
2337 amagic_is_enabled
2338 amagic_i_ncmp
2339 amagic_i_ncmp_desc
2340 amagic_ncmp
2341 amagic_ncmp_desc
2342 any_dup
2343 append_utf8_from_native_byte
2344 apply
2345 ASCII_TO_NEED
2346 atfork_lock
2347 atfork_unlock
2348 av_arylen_p
2349 av_extend_guts
2350 av_iter_p
2351 av_nonelem
2352 av_reify
2353 bind_match
2354 block_gimme
2355 boot_core_builtin
2356 boot_core_mro
2357 boot_core_PerlIO
2358 boot_core_UNIVERSAL
2359 _byte_dump_string
2360 call_list
2361 cando
2362 cast_i32
2363 cast_iv
2364 cast_ulong
2365 cast_uv
2366 check_utf8_print
2367 ck_anoncode
2368 ck_backtick
2369 ck_bitop
2370 ck_cmp
2371 ck_concat
2372 ck_defined
2373 ck_delete
2374 ck_each
2375 ck_entersub_args_core
2376 ck_eof
2377 ck_eval
2378 ck_exec
2379 ck_exists
2380 ck_ftst
2381 ck_fun
2382 ck_glob
2383 ck_grep
2384 ck_index
2385 ck_isa
2386 ck_join
2387 ck_length
2388 ck_lfun
2389 ck_listiob
2390 ck_match
2391 ck_method
2392 ck_null
2393 ck_open
2394 ck_prototype
2395 ck_readline
2396 ck_refassign
2397 ck_repeat
2398 ck_require
2399 ck_return
2400 ck_rfun
2401 ck_rvconst
2402 ck_sassign
2403 ck_select
2404 ck_shift
2405 ck_smartmatch
2406 ck_sort
2407 ck_spair
2408 ck_split
2409 ck_stringify
2410 ck_subr
2411 ck_substr
2412 ck_svconst
2413 ck_tell
2414 ck_trunc
2415 ck_trycatch
2416 ckwarn
2417 ckwarn_d
2418 clear_defarray
2419 closest_cop
2420 cmpchain_extend
2421 cmpchain_finish
2422 cmpchain_start
2423 cmp_desc
2424 cmp_locale_desc
2425 cntrl_to_mnemonic
2426 cop_file_avn
2427 coresub_op
2428 create_eval_scope
2429 croak_caller
2430 croak_memory_wrap
2431 croak_no_mem
2432 croak_popstack
2433 csighandler
2434 csighandler1
2435 csighandler3
2436 current_re_engine
2437 custom_op_get_field
2438 cv_ckproto_len_flags
2439 cv_clone_into
2440 cv_const_sv_or_av
2441 cvgv_from_hek
2442 cvgv_set
2443 cvstash_set
2444 cv_undef_flags
2445 cx_dump
2446 cx_dup
2447 cxinc
2448 cx_popblock
2449 cx_popeval
2450 cx_popformat
2451 cx_popgiven
2452 cx_poploop
2453 cx_popsub
2454 cx_popsub_args
2455 cx_popsub_common
2456 cx_popwhen
2457 cx_pushblock
2458 cx_pusheval
2459 cx_pushformat
2460 cx_pushgiven
2461 cx_pushloop_for
2462 cx_pushloop_plain
2463 cx_pushsub
2464 cx_pushtry
2465 cx_pushwhen
2466 cx_topblock
2467 debstackptrs
2468 deb_stack_all
2469 debug_hash_seed
2470 defelem_target
2471 delete_eval_scope
2472 despatch_signals
2473 die_unwind
2474 do_aexec
2475 do_aexec5
2476 do_aspawn
2477 do_eof
2478 does_utf8_overflow
2479 do_exec
2480 do_exec3
2481 dofile
2482 do_gvgv_dump
2483 do_gv_dump
2484 do_hv_dump
2485 doing_taint
2486 do_ipcctl
2487 do_ipcget
2488 do_magic_dump
2489 do_msgrcv
2490 do_msgsnd
2491 do_ncmp
2492 do_open6
2493 do_open_raw
2494 do_op_dump
2495 do_pmop_dump
2496 do_print
2497 do_readline
2498 doref
2499 do_seek
2500 do_semop
2501 do_shmio
2502 do_spawn
2503 do_spawn_nowait
2504 do_sv_dump
2505 do_sysseek
2506 do_tell
2507 do_trans
2508 do_uniprop_match
2509 do_vecget
2510 do_vecset
2511 do_vop
2512 drand48_init_r
2513 drand48_r
2514 dtrace_probe_call
2515 dtrace_probe_load
2516 dtrace_probe_op
2517 dtrace_probe_phase
2518 dump_all_perl
2519 dump_indent
2520 dump_packsubs_perl
2521 dump_sub_perl
2522 dump_sv_child
2523 dump_vindent
2524 dup_warnings
2525 emulate_cop_io
2526 find_first_differing_byte_pos
2527 find_lexical_cv
2528 find_runcv_where
2529 find_script
2530 foldEQ_latin1
2531 foldEQ_latin1_s2_folded
2532 foldEQ_utf8_flags
2533 _force_out_malformed_utf8_message
2534 form_alien_digit_msg
2535 form_cp_too_large_msg
2536 free_tied_hv_pool
2537 free_tmps
2538 get_and_check_backslash_N_name
2539 get_db_sub
2540 get_debug_opts
2541 get_deprecated_property_msg
2542 getenv_len
2543 get_hash_seed
2544 get_invlist_iter_addr
2545 get_invlist_offset_addr
2546 get_invlist_previous_index_addr
2547 get_mstats
2548 get_no_modify
2549 get_opargs
2550 get_ppaddr
2551 get_prop_definition
2552 get_prop_values
2553 get_regclass_nonbitmap_data
2554 get_regex_charset_name
2555 get_re_arg
2556 get_re_gclass_nonbitmap_data
2557 get_vtbl
2558 gimme_V
2559 gp_free
2560 gp_ref
2561 grok_bin_oct_hex
2562 grok_bslash_c
2563 grok_bslash_o
2564 grok_bslash_x
2565 gv_check
2566 gv_fetchmeth_internal
2567 gv_override
2568 gv_setref
2569 gv_stashpvn_internal
2570 he_dup
2571 hek_dup
2572 hfree_next_entry
2573 hv_auxalloc
2574 hv_backreferences_p
2575 hv_common
2576 hv_common_key_len
2577 hv_delayfree_ent
2578 hv_kill_backrefs
2579 hv_placeholders_p
2580 hv_pushkv
2581 hv_rand_set
2582 hv_undef_flags
2583 init_argv_symbols
2584 init_constants
2585 init_dbargs
2586 init_debugger
2587 init_i18nl10n
2588 init_i18nl14n
2589 init_named_cv
2590 init_stacks
2591 init_tm
2592 init_uniprops
2593 _inverse_folds
2594 invert
2595 invlist_array
2596 invlist_clear
2597 invlist_clone
2598 invlist_contents
2599 _invlistEQ
2600 invlist_extend
2601 invlist_highest
2602 invlist_is_iterating
2603 invlist_iterfinish
2604 invlist_iterinit
2605 invlist_iternext
2606 invlist_lowest
2607 invlist_max
2608 invlist_previous_index
2609 invlist_set_len
2610 invlist_set_previous_index
2611 invlist_trim
2612 _invlist_array_init
2613 _invlist_contains_cp
2614 _invlist_dump
2615 _invlist_intersection
2616 _invlist_intersection_maybe_complement_2nd
2617 _invlist_invert
2618 _invlist_len
2619 _invlist_search
2620 _invlist_subtract
2621 _invlist_union
2622 _invlist_union_maybe_complement_2nd
2623 invmap_dump
2624 io_close
2625 isFF_overlong
2626 is_grapheme
2627 is_invlist
2628 is_utf8_char_helper_
2629 is_utf8_common
2630 is_utf8_FF_helper_
2631 is_utf8_overlong
2632 _is_cur_LC_category_utf8
2633 _is_in_locale_category
2634 _is_uni_FOO
2635 _is_uni_perl_idcont
2636 _is_uni_perl_idstart
2637 _is_utf8_FOO
2638 _is_utf8_perl_idcont
2639 _is_utf8_perl_idstart
2640 jmaybe
2641 keyword
2642 keyword_plugin_standard
2643 list
2644 load_charnames
2645 localize
2646 lossless_NV_to_IV
2647 lsbit_pos32
2648 lsbit_pos64
2649 magic_cleararylen_p
2650 magic_clearenv
2651 magic_clearisa
2652 magic_clearpack
2653 magic_clearsig
2654 magic_clear_all_env
2655 magic_copycallchecker
2656 magic_existspack
2657 magic_freearylen_p
2658 magic_freecollxfrm
2659 magic_freemglob
2660 magic_freeovrld
2661 magic_freeutf8
2662 magic_get
2663 magic_getarylen
2664 magic_getdebugvar
2665 magic_getdefelem
2666 magic_getnkeys
2667 magic_getpack
2668 magic_getpos
2669 magic_getsig
2670 magic_getsubstr
2671 magic_gettaint
2672 magic_getuvar
2673 magic_getvec
2674 magic_killbackrefs
2675 magic_nextpack
2676 magic_regdata_cnt
2677 magic_regdatum_get
2678 magic_regdatum_set
2679 magic_scalarpack
2680 magic_set
2681 magic_setarylen
2682 magic_setcollxfrm
2683 magic_setdbline
2684 magic_setdebugvar
2685 magic_setdefelem
2686 magic_setenv
2687 magic_setisa
2688 magic_setlvref
2689 magic_setmglob
2690 magic_setnkeys
2691 magic_setnonelem
2692 magic_setpack
2693 magic_setpos
2694 magic_setregexp
2695 magic_setsig
2696 magic_setsigall
2697 magic_setsubstr
2698 magic_settaint
2699 magic_setutf8
2700 magic_setuvar
2701 magic_setvec
2702 magic_set_all_env
2703 magic_sizepack
2704 magic_wipepack
2705 malloced_size
2706 malloc_good_size
2707 markstack_grow
2708 mem_collxfrm
2709 mem_log_alloc
2710 mem_log_del_sv
2711 mem_log_free
2712 mem_log_new_sv
2713 mem_log_realloc
2714 _mem_collxfrm
2715 mg_find_mglob
2716 mg_size
2717 mode_from_discipline
2718 more_bodies
2719 more_sv
2720 moreswitches
2721 mortal_getenv
2722 mro_get_private_data
2723 mro_meta_dup
2724 mro_meta_init
2725 msbit_pos32
2726 msbit_pos64
2727 multiconcat_stringify
2728 multideref_stringify
2729 my_atof2
2730 my_atof3
2731 my_attrs
2732 my_clearenv
2733 my_lstat
2734 my_lstat_flags
2735 my_memrchr
2736 my_mkostemp_cloexec
2737 my_mkstemp_cloexec
2738 my_stat
2739 my_stat_flags
2740 my_strerror
2741 my_unexec
2742 NATIVE_TO_NEED
2743 newFORM
2744 newGP
2745 newMETHOP_internal
2746 newMYSUB
2747 newPROG
2748 new_stackinfo
2749 newSTUB
2750 newSVavdefelem
2751 new_warnings_bitfield
2752 newXS_deffile
2753 _new_invlist
2754 _new_invlist_C_array
2755 nextargv
2756 no_bareword_filehandle
2757 noperl_die
2758 notify_parser_that_changed_to_utf8
2759 oopsAV
2760 oopsHV
2761 op_clear
2762 op_integerize
2763 op_lvalue_flags
2764 opmethod_stash
2765 op_refcnt_dec
2766 op_refcnt_inc
2767 op_relocate_sv
2768 opslab_force_free
2769 opslab_free
2770 opslab_free_nopad
2771 op_std_init
2772 op_unscope
2773 package
2774 package_version
2775 pad_add_weakref
2776 padlist_store
2777 padname_free
2778 PadnameIN_SCOPE
2779 padnamelist_free
2780 parser_dup
2781 parser_free
2782 parser_free_nexttoke_ops
2783 parse_unicode_opts
2784 path_is_searchable
2785 peep
2786 perl_alloc_using
2787 perl_clone_using
2788 PerlIO_context_layers
2789 PerlIO_restore_errno
2790 PerlIO_save_errno
2791 PerlLIO_dup2_cloexec
2792 PerlLIO_dup_cloexec
2793 PerlLIO_open3_cloexec
2794 PerlLIO_open_cloexec
2795 PerlProc_pipe_cloexec
2796 PerlSock_accept_cloexec
2797 PerlSock_socketpair_cloexec
2798 PerlSock_socket_cloexec
2799 perly_sighandler
2800 pmruntime
2801 POPMARK
2802 populate_isa
2803 pregfree
2804 pregfree2
2805 qerror
2806 ReANY
2807 reentrant_free
2808 reentrant_init
2809 reentrant_retry
2810 reentrant_size
2811 re_exec_indentf
2812 ref
2813 regcurly
2814 regdump
2815 regdupe_internal
2816 regexec_flags
2817 regfree_internal
2818 reginitcolors
2819 reg_named_buff
2820 reg_named_buff_all
2821 reg_named_buff_exists
2822 reg_named_buff_fetch
2823 reg_named_buff_firstkey
2824 reg_named_buff_iter
2825 reg_named_buff_nextkey
2826 reg_named_buff_scalar
2827 regnext
2828 reg_numbered_buff_fetch
2829 reg_numbered_buff_length
2830 reg_numbered_buff_store
2831 regprop
2832 reg_qr_package
2833 reg_skipcomment
2834 reg_temp_copy
2835 re_indentf
2836 re_intuit_start
2837 re_intuit_string
2838 re_op_compile
2839 report_evil_fh
2840 report_redefined_cv
2841 report_wrongway_fh
2842 re_printf
2843 rpeep
2844 rsignal_restore
2845 rsignal_save
2846 rvpv_dup
2847 rxres_save
2848 same_dirent
2849 save_bool
2850 save_clearsv
2851 save_delete
2852 save_destructor
2853 save_destructor_x
2854 save_freeop
2855 save_freepv
2856 save_freesv
2857 save_I16
2858 save_I32
2859 save_I8
2860 save_int
2861 save_iv
2862 save_long
2863 save_mortalizesv
2864 save_pptr
2865 save_re_context
2866 save_sptr
2867 savestack_grow
2868 savestack_grow_cnt
2869 save_strlen
2870 save_to_buffer
2871 sawparens
2872 scalar
2873 scalarvoid
2874 scan_num
2875 scan_str
2876 scan_word
2877 seed
2878 set_caret_X
2879 setfd_cloexec
2880 setfd_cloexec_for_nonsysfd
2881 setfd_cloexec_or_inhexec_by_sysfdness
2882 setfd_inhexec
2883 setfd_inhexec_for_sysfd
2884 set_numeric_standard
2885 set_numeric_underlying
2886 set_padlist
2887 _setup_canned_invlist
2888 share_hek
2889 should_warn_nl
2890 should_we_output_Debug_r
2891 sighandler
2892 sighandler1
2893 sighandler3
2894 single_1bit_pos32
2895 single_1bit_pos64
2896 skipspace_flags
2897 Slab_Alloc
2898 Slab_Free
2899 Slab_to_ro
2900 Slab_to_rw
2901 softref2xv
2902 sortsv_flags_impl
2903 stack_grow
2904 str_to_version
2905 sub_crush_depth
2906 sv_2iv
2907 sv_2uv
2908 sv_add_backref
2909 sv_buf_to_ro
2910 sv_del_backref
2911 sv_free2
2912 sv_i_ncmp
2913 sv_i_ncmp_desc
2914 sv_kill_backrefs
2915 sv_magicext_mglob
2916 sv_ncmp
2917 sv_ncmp_desc
2918 sv_only_taint_gmagic
2919 sv_or_pv_pos_u2b
2920 sv_resetpvn
2921 sv_sethek
2922 sv_setsv_cow
2923 SvTRUE_common
2924 sv_unglob
2925 sys_init
2926 sys_init3
2927 sys_intern_clear
2928 sys_intern_dup
2929 sys_intern_init
2930 sys_term
2931 tied_method
2932 tmps_grow_p
2933 TOPMARK
2934 to_uni_fold
2935 to_uni_lower
2936 to_uni_title
2937 to_uni_upper
2938 _to_fold_latin1
2939 _to_uni_fold_flags
2940 _to_upper_title_latin1
2941 _to_utf8_fold_flags
2942 _to_utf8_lower_flags
2943 _to_utf8_title_flags
2944 _to_utf8_upper_flags
2945 translate_substr_offsets
2946 try_amagic_bin
2947 try_amagic_un
2948 uiv_2buf
2949 unlnk
2950 unshare_hek
2951 utf16_to_utf8
2952 utf16_to_utf8_base
2953 utf16_to_utf8_reversed
2954 _utf8n_to_uvchr_msgs_helper
2955 utf8_to_utf16_base
2956 utf8_to_uvchr_buf_helper
2957 utilize
2958 uvoffuni_to_utf8_flags_msgs
2959 uvuni_to_utf8
2960 valid_utf8_to_uvuni
2961 variant_byte_number
2962 varname
2963 vivify_defelem
2964 vivify_ref
2965 wait4pid
2966 _warn_problematic_locale
2967 was_lvalue_sub
2968 watch
2969 win32_croak_not_implemented
2970 write_to_stderr
2971 xs_boot_epilog
2972 xs_handshake
2973 yyerror
2974 yyerror_pv
2975 yyerror_pvn
2976 yylex
2977 yyparse
2978 yyquit
2979 yyunlex
2980
2982 The autodocumentation system was originally added to the Perl core by
2983 Benjamin Stuhl. Documentation is by whoever was kind enough to
2984 document their functions.
2985
2987 config.h, perlapi, perlapio, perlcall, perlclib, perlembed, perlfilter,
2988 perlguts, perlhacktips, perlinterp, perliol, perlmroapi, perlreapi,
2989 perlreguts, perlxs
2990perl v5.36.3 2023-11-30 PERLINTERN(1)