1PERLINTERN(1)          Perl Programmers Reference Guide          PERLINTERN(1)
2
3
4

NAME

6       perlintern - autogenerated documentation of purely internal Perl
7       functions
8

DESCRIPTION

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
15       It has the same sections as perlapi, though some may be empty.
16

AV Handling

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
24           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
30           The rough perl equivalent is $myarray[$key].
31
32            SV**  av_fetch_simple(AV *av, SSize_t key, I32 lval)
33
34       "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
40            SSize_t  AvFILLp(AV* av)
41
42       "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
46           Creates a new AV and allocates its SV* array.
47
48           This is similar to, but more efficient than doing:
49
50               AV *av = newAV();
51               av_extend(av, key);
52
53           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
57           The "zeroflag" parameter controls whether or not the array is NULL
58           initialized.
59
60            AV*  av_new_alloc(SSize_t size, bool zeroflag)
61
62       "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
68           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
72           Note that the caller is responsible for suitably incrementing the
73           reference count of "val" before the call.
74
75           Approximate Perl equivalent: "splice(@myarray, $key, 1, $val)".
76
77            SV**  av_store_simple(AV *av, SSize_t key, SV *val)
78

Callback Functions

80       "dowantarray"
81           Implements the deprecated ""GIMME"" in perlapi.
82
83            U8  dowantarray()
84
85       "leave_scope"
86           Implements "LEAVE_SCOPE" which you should use instead.
87
88            void  leave_scope(I32 base)
89
90       "pop_scope"
91           Implements ""LEAVE"" in perlapi
92
93            void  pop_scope()
94
95       "push_scope"
96           Implements ""ENTER"" in perlapi
97
98            void  push_scope()
99
100       "save_adelete"
101           Implements "SAVEADELETE".
102
103            void  save_adelete(AV *av, SSize_t key)
104
105       "save_generic_pvref"
106           Implements "SAVEGENERICPV".
107
108           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
112            void  save_generic_pvref(char** str)
113
114       "save_generic_svref"
115           Implements "SAVEGENERICSV".
116
117           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
121            void  save_generic_svref(SV** sptr)
122
123       "save_hdelete"
124           Implements "SAVEHDELETE".
125
126            void  save_hdelete(HV *hv, SV *keysv)
127
128       "save_hints"
129           Implements "SAVEHINTS".
130
131            void  save_hints()
132
133       "save_op"
134           Implements "SAVEOP".
135
136            void  save_op()
137
138       "save_padsv_and_mortalize"
139           Implements "SAVEPADSVANDMORTALIZE".
140
141            void  save_padsv_and_mortalize(PADOFFSET off)
142
143       "save_set_svflags"
144           Implements "SAVESETSVFLAGS".
145
146           Set the SvFLAGS specified by mask to the values in val
147
148            void  save_set_svflags(SV *sv, U32 mask, U32 val)
149
150       "save_shared_pvref"
151           Implements "SAVESHAREDPV".
152
153           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
157            void  save_shared_pvref(char** str)
158
159       "save_vptr"
160           Implements "SAVEVPTR".
161
162            void  save_vptr(void *ptr)
163

Casting

165       There are only public API items currently in Casting
166

Character case changing

168       There are only public API items currently in Character case changing
169

Character classification

171       There are only public API items currently in Character classification
172

Compiler and Preprocessor information

174       There are only public API items currently in Compiler and Preprocessor
175       information
176

Compiler directives

178       There are only public API items currently in Compiler directives
179

Compile-time scope hooks

181       "BhkENTRY"
182           NOTE: "BhkENTRY" is experimental and may change or be removed
183           without notice.
184
185           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
190            void *  BhkENTRY(BHK *hk, which)
191
192       "BhkFLAGS"
193           NOTE: "BhkFLAGS" is experimental and may change or be removed
194           without notice.
195
196           Return the BHK's flags.
197
198            U32  BhkFLAGS(BHK *hk)
199
200       "CALL_BLOCK_HOOKS"
201           NOTE: "CALL_BLOCK_HOOKS" is experimental and may change or be
202           removed without notice.
203
204           Call all the registered block hooks for type "which".  "which" is a
205           preprocessing token; the type of "arg" depends on "which".
206
207            void  CALL_BLOCK_HOOKS(which, arg)
208

Concurrency

210       "CVf_SLABBED"
211       "CvROOT"
212       "CvSTART"
213           Described in perlguts.
214
215       "CX_CUR"
216           Described in perlguts.
217
218              CX_CUR()
219
220       "CXINC"
221           Described in perlguts.
222
223       "CX_LEAVE_SCOPE"
224           Described in perlguts.
225
226            void  CX_LEAVE_SCOPE(PERL_CONTEXT* cx)
227
228       "CX_POP"
229           Described in perlguts.
230
231            void  CX_POP(PERL_CONTEXT* cx)
232
233       "cxstack"
234           Described in perlguts.
235
236       "cxstack_ix"
237           Described in perlguts.
238
239       "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
254       "cx_type"
255           Described in perlguts.
256
257       "dounwind"
258           Described in perlguts.
259
260            void  dounwind(I32 cxix)
261
262       "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
267            Pid_t  my_fork()
268
269       "PERL_CONTEXT"
270           Described in perlguts.
271

COPs and Hint Hashes

273       There are only public API items currently in COPs and Hint Hashes
274

Custom Operators

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
283            SV *  core_prototype(SV *sv, const char *name, const int code,
284                                 int * const opnum)
285

CV Handling

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
299           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
305               BEGIN { $a = sub { eval '$x' } }
306
307           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
314           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
321           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
329               my $x = 123;
330               sub tmp { sub { eval '$x' } }
331               my $a = tmp();
332               undef &tmp;
333               print  $a->();
334
335            bool  CvWEAKOUTSIDE(CV *cv)
336
337       "docatch"
338           Check for the cases 0 or 3 of cur_env.je_ret, only used inside an
339           eval context.
340
341           0 is used as continue inside eval,
342
343           3 is used for a die caught by an inner eval - continue inner loop
344
345           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
348            OP*  docatch(Perl_ppaddr_t firstpp)
349

Debugging

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
358           The program is responsible for maintaining the correct value for
359           "depth".
360
361              _aDEPTH
362
363       "debop"
364           Implements -Dt perl command line option on OP "o".
365
366            I32  debop(const OP* o)
367
368       "debprof"
369           Called to indicate that "o" was executed, for profiling purposes
370           under the "-DP" command line option.
371
372            void  debprof(const OP *o)
373
374       "debprofdump"
375           Dumps the contents of the data collected by the "-DP" perl command
376           line option.
377
378            void  debprofdump()
379
380       "free_c_backtrace"
381           Deallocates a backtrace received from get_c_backtrace.
382
383            void  free_c_backtrace(Perl_c_backtrace* bt)
384
385       "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
389           Scans the frames back by "depth + skip", then drops the "skip"
390           innermost, returning at most "depth" frames.
391
392            Perl_c_backtrace*  get_c_backtrace(int max_depth, int skip)
393
394       "_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
399       "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
406           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
410            SV *  PL_DBsingle
411
412       "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
418           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
422            GV *  PL_DBsub
423
424       "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
429           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
433            SV *  PL_DBtrace
434
435       "runops_debug"
436           Described in perlguts.
437
438            int  runops_debug()
439
440       "runops_standard"
441           Described in perlguts.
442
443            int  runops_standard()
444

Display functions

446       "sv_peek"
447           Implements "SvPEEK"
448
449            char*  sv_peek(SV* sv)
450

Embedding, Threads, and Interpreter Cloning

452       "cv_dump"
453           dump the contents of a CV
454
455            void  cv_dump(const CV *cv, const char *title)
456
457       "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
465            void  cv_forget_slab(CV *cv)
466
467       "do_dump_pad"
468           Dump the contents of a padlist
469
470            void  do_dump_pad(I32 level, PerlIO *file, PADLIST *padlist,
471                              int full)
472
473       "get_context"
474           Implements ""PERL_GET_CONTEXT"" in perlapi, which you should use
475           instead.
476
477            void*  get_context()
478
479       "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
488            PADOFFSET  pad_alloc_name(PADNAME *name, U32 flags, HV *typestash,
489                                      HV *ourstash)
490
491       "pad_block_start"
492           Update the pad compilation state variables on entry to a new block.
493
494            void  pad_block_start(int full)
495
496       "pad_check_dup"
497           Check for duplicate declarations: report any of:
498
499                * 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
503           "is_our" indicates that the name to check is an "our" declaration.
504
505            void  pad_check_dup(PADNAME *name, U32 flags, const HV *ourstash)
506
507       "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
511           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
521           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
526            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
531       "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
536            void  pad_fixup_inner_anons(PADLIST *padlist, CV *old_cv,
537                                        CV *new_cv)
538
539       "pad_free"
540           Free the SV at offset po in the current pad.
541
542            void  pad_free(PADOFFSET po)
543
544       "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
549            OP *  pad_leavemy()
550
551       "padlist_dup"
552           Duplicates a pad.
553
554            PADLIST *  padlist_dup(PADLIST *srcpad, CLONE_PARAMS *param)
555
556       "padname_dup"
557           Duplicates a pad name.
558
559            PADNAME *  padname_dup(PADNAME *src, CLONE_PARAMS *param)
560
561       "padnamelist_dup"
562           Duplicates a pad name list.
563
564            PADNAMELIST *  padnamelist_dup(PADNAMELIST *srcpad,
565                                           CLONE_PARAMS *param)
566
567       "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
572            void  pad_push(PADLIST *padlist, int depth)
573
574       "pad_reset"
575           Mark all the current temporaries for reuse
576
577            void  pad_reset()
578
579       "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
584            void  pad_setsv(PADOFFSET po, SV* sv)
585
586       "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
591            SV*  pad_sv(PADOFFSET po)
592
593       "pad_swipe"
594           Abandon the tmp in the current pad at offset "po" and replace with
595           a new one.
596
597            void  pad_swipe(PADOFFSET po, bool refadjust)
598
599       "set_context"
600           Implements ""PERL_SET_CONTEXT"" in perlapi, which you should use
601           instead.
602
603            void  set_context(void *t)
604

Errno

606       "dSAVEDERRNO"
607           Declare variables needed to save "errno" and any operating system
608           specific error number.
609
610            void  dSAVEDERRNO
611
612       "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
617            void  dSAVE_ERRNO
618
619       "RESTORE_ERRNO"
620           Restore "errno" and any operating system specific error number that
621           was saved by "dSAVE_ERRNO" or "RESTORE_ERRNO".
622
623            void  RESTORE_ERRNO
624
625       "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
630            void  SAVE_ERRNO
631
632       "SETERRNO"
633           Set "errno", and on VMS set "vaxc$errno".
634
635            void  SETERRNO(int errcode, int vmserrcode)
636

Exception Handling (simple) Macros

638       There are only public API items currently in Exception Handling
639       (simple) Macros
640

Filesystem configuration values

642       There are only public API items currently in Filesystem configuration
643       values
644

Floating point

646       There are only public API items currently in Floating point
647

General Configuration

649       There are only public API items currently in General Configuration
650

Global Variables

652       There are only public API items currently in Global Variables
653

GV Handling and Stashes

655       "gp_dup"
656           Duplicate a typeglob, returning a pointer to the cloned object.
657
658            GP*  gp_dup(GP *const gp, CLONE_PARAMS *const param)
659
660       "gv_handler"
661           Implements "StashHANDLER", which you should use instead
662
663            CV*  gv_handler(HV* stash, I32 id)
664
665       "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
670           Requires one of either "namesv" or "namepv" to be non-null.
671
672           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
676           Note it is strongly preferred for "namesv" to be non-null, for
677           performance reasons.
678
679            HV*  gv_stashsvpvn_cached(SV *namesv, const char* name,
680                                      U32 namelen, I32 flags)
681
682       "gv_try_downgrade"
683           NOTE: "gv_try_downgrade" is experimental and may change or be
684           removed without notice.
685
686           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
695           If "gv" is a completely empty typeglob, it is deleted from the
696           stash.
697
698           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
702            void  gv_try_downgrade(GV* gv)
703

Hook manipulation

705       There are only public API items currently in Hook manipulation
706

HV Handling

708       "hv_eiter_p"
709           Implements "HvEITER" which you should use instead.
710
711           NOTE: "hv_eiter_p" must be explicitly called as "Perl_hv_eiter_p"
712           with an "aTHX_" parameter.
713
714            HE**  Perl_hv_eiter_p(pTHX_ HV *hv)
715
716       "hv_eiter_set"
717           Implements "HvEITER_set" which you should use instead.
718
719           NOTE: "hv_eiter_set" must be explicitly called as
720           "Perl_hv_eiter_set" with an "aTHX_" parameter.
721
722            void  Perl_hv_eiter_set(pTHX_ HV *hv, HE *eiter)
723
724       "hv_ename_add"
725           Adds a name to a stash's internal list of effective names.  See
726           "hv_ename_delete".
727
728           This is called when a stash is assigned to a new location in the
729           symbol table.
730
731            void  hv_ename_add(HV *hv, const char *name, U32 len, U32 flags)
732
733       "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
738           This is called when a stash is deleted from the symbol table.
739
740            void  hv_ename_delete(HV *hv, const char *name, U32 len,
741                                  U32 flags)
742
743       "hv_fill"
744           Returns the number of hash buckets that happen to be in use.
745
746           This function implements the "HvFILL" macro which you should use
747           instead.
748
749           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
754           NOTE: "hv_fill" must be explicitly called as "Perl_hv_fill" with an
755           "aTHX_" parameter.
756
757            STRLEN  Perl_hv_fill(pTHX_ HV *const hv)
758
759       "hv_placeholders_get"
760           Implements "HvPLACEHOLDERS_get", which you should use instead.
761
762           NOTE: "hv_placeholders_get" must be explicitly called as
763           "Perl_hv_placeholders_get" with an "aTHX_" parameter.
764
765            I32  Perl_hv_placeholders_get(pTHX_ const HV *hv)
766
767       "hv_placeholders_set"
768           Implements "HvPLACEHOLDERS_set", which you should use instead.
769
770           NOTE: "hv_placeholders_set" must be explicitly called as
771           "Perl_hv_placeholders_set" with an "aTHX_" parameter.
772
773            void  Perl_hv_placeholders_set(pTHX_ HV *hv, I32 ph)
774
775       "hv_riter_p"
776           Implements "HvRITER" which you should use instead.
777
778           NOTE: "hv_riter_p" must be explicitly called as "Perl_hv_riter_p"
779           with an "aTHX_" parameter.
780
781            I32*  Perl_hv_riter_p(pTHX_ HV *hv)
782
783       "hv_riter_set"
784           Implements "HvRITER_set" which you should use instead.
785
786           NOTE: "hv_riter_set" must be explicitly called as
787           "Perl_hv_riter_set" with an "aTHX_" parameter.
788
789            void  Perl_hv_riter_set(pTHX_ HV *hv, I32 riter)
790
791       "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
796            HV *  refcounted_he_chain_2hv(const struct refcounted_he *c,
797                                          U32 flags)
798
799       "refcounted_he_fetch_pv"
800           Like "refcounted_he_fetch_pvn", but takes a nul-terminated string
801           instead of a string/length pair.
802
803            SV *  refcounted_he_fetch_pv(const struct refcounted_he *chain,
804                                         const char *key, U32 hash, U32 flags)
805
806       "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
816            SV *  refcounted_he_fetch_pvn(const struct refcounted_he *chain,
817                                          const char *keypv, STRLEN keylen,
818                                          U32 hash, U32 flags)
819
820       "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
824            SV *  refcounted_he_fetch_pvs(const struct refcounted_he *chain,
825                                          "key", U32 flags)
826
827       "refcounted_he_fetch_sv"
828           Like "refcounted_he_fetch_pvn", but takes a Perl scalar instead of
829           a string/length pair.
830
831            SV *  refcounted_he_fetch_sv(const struct refcounted_he *chain,
832                                         SV *key, U32 hash, U32 flags)
833
834       "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
841            void  refcounted_he_free(struct refcounted_he *he)
842
843       "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
849            struct refcounted_he *  refcounted_he_inc(
850                                                     struct refcounted_he *he)
851
852       "refcounted_he_new_pv"
853           Like "refcounted_he_new_pvn", but takes a nul-terminated string
854           instead of a string/length pair.
855
856            struct refcounted_he *  refcounted_he_new_pv(
857                                                 struct refcounted_he *parent,
858                                                 const char *key, U32 hash,
859                                                 SV *value, U32 flags)
860
861       "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
868           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
874           "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
884           "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
889            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
895       "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
899            struct refcounted_he *  refcounted_he_new_pvs(
900                                                 struct refcounted_he *parent,
901                                                 "key", SV *value, U32 flags)
902
903       "refcounted_he_new_sv"
904           Like "refcounted_he_new_pvn", but takes a Perl scalar instead of a
905           string/length pair.
906
907            struct refcounted_he *  refcounted_he_new_sv(
908                                                 struct refcounted_he *parent,
909                                                 SV *key, U32 hash, SV *value,
910                                                 U32 flags)
911
912       "unsharepvn"
913           If no one has access to shared string "str" with length "len", free
914           it.
915
916           "len" and "hash" must both be valid for "str".
917
918            void  unsharepvn(const char* sv, I32 len, U32 hash)
919

Input/Output

921       "dirp_dup"
922           Duplicate a directory handle, returning a pointer to the cloned
923           object.
924
925            DIR*  dirp_dup(DIR *const dp, CLONE_PARAMS *const param)
926
927       "fp_dup"
928           Duplicate a file handle, returning a pointer to the cloned object.
929
930            PerlIO*  fp_dup(PerlIO *const fp, const char type,
931                            CLONE_PARAMS *const param)
932
933       "my_fflush_all"
934           Implements "PERL_FLUSHALL_FOR_CHILD" on some platforms.
935
936            I32  my_fflush_all()
937
938       "my_mkostemp"
939           The C library mkostemp(3) if available, or a Perl implementation of
940           it.
941
942           NOTE: "my_mkostemp" must be explicitly called as "Perl_my_mkostemp"
943           .
944
945            int  Perl_my_mkostemp(char *templte, int flags)
946
947       "my_mkstemp"
948           The C library mkstemp(3) if available, or a Perl implementation of
949           it.
950
951           NOTE: "my_mkstemp" must be explicitly called as "Perl_my_mkstemp" .
952
953            int  Perl_my_mkstemp(char *templte)
954
955       "PL_last_in_gv"
956           The GV which was last used for a filehandle input operation.
957           ("<FH>")
958
959           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
963            GV*  PL_last_in_gv
964
965       "PL_ofsgv"
966           The glob containing the output field separator - "*," in Perl
967           space.
968
969           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
973            GV*  PL_ofsgv
974
975       "PL_rs"
976           The input record separator - $/ in Perl space.
977
978           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
982            SV*  PL_rs
983
984       "start_glob"
985           NOTE: "start_glob" is experimental and may change or be removed
986           without notice.
987
988           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
994           NOTE: "start_glob" must be explicitly called as "Perl_start_glob"
995           with an "aTHX_" parameter.
996
997            PerlIO*  Perl_start_glob(pTHX_ SV *tmpglob, IO *io)
998

Integer

1000       There are only public API items currently in Integer
1001

I/O Formats

1003       There are only public API items currently in I/O Formats
1004

Lexer interface

1006       "validate_proto"
1007           NOTE: "validate_proto" is experimental and may change or be removed
1008           without notice.
1009
1010           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
1015           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
1019           Note that "NULL" is a valid "proto" and will always return "true".
1020
1021            bool  validate_proto(SV *name, SV *proto, bool warn,
1022                                 bool curstash)
1023

Locales

1025       There are only public API items currently in Locales
1026

Magic

1028       "magic_clearhint"
1029           Triggered by a delete from "%^H", records the key to
1030           "PL_compiling.cop_hints_hash".
1031
1032            int  magic_clearhint(SV* sv, MAGIC* mg)
1033
1034       "magic_clearhints"
1035           Triggered by clearing "%^H", resets "PL_compiling.cop_hints_hash".
1036
1037            int  magic_clearhints(SV* sv, MAGIC* mg)
1038
1039       "magic_methcall"
1040           Invoke a magic method (like FETCH).
1041
1042           "sv" and "mg" are the tied thingy and the tie magic.
1043
1044           "meth" is the name of the method to call.
1045
1046           "argc" is the number of args (in addition to $self) to pass to the
1047           method.
1048
1049           The "flags" can be:
1050
1051               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
1056           The arguments themselves are any values following the "flags"
1057           argument.
1058
1059           Returns the SV (if any) returned by the method, or "NULL" on
1060           failure.
1061
1062           NOTE: "magic_methcall" must be explicitly called as
1063           "Perl_magic_methcall" with an "aTHX_" parameter.
1064
1065            SV*  Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, SV *meth,
1066                                     U32 flags, U32 argc, ...)
1067
1068       "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
1074            int  magic_sethint(SV* sv, MAGIC* mg)
1075
1076       "mg_dup"
1077           Duplicate a chain of magic, returning a pointer to the cloned
1078           object.
1079
1080            MAGIC*  mg_dup(MAGIC *mg, CLONE_PARAMS *const param)
1081
1082       "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
1087           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
1091            void  mg_localize(SV* sv, SV* nsv, bool setmagic)
1092
1093       "si_dup"
1094           Duplicate a stack info structure, returning a pointer to the cloned
1095           object.
1096
1097            PERL_SI*  si_dup(PERL_SI* si, CLONE_PARAMS* param)
1098
1099       "ss_dup"
1100           Duplicate the save stack, returning a pointer to the cloned object.
1101
1102            ANY*  ss_dup(PerlInterpreter* proto_perl, CLONE_PARAMS* param)
1103

Memory Management

1105       "calloc"
1106           Implements ""Newxz"" in perlapi which you should use instead.
1107
1108           NOTE: "calloc" must be explicitly called as "Perl_calloc" .
1109
1110            Malloc_t  Perl_calloc(MEM_SIZE elements, MEM_SIZE size)
1111
1112       "malloc"
1113           Implements ""Newx"" in perlapi which you should use instead.
1114
1115           NOTE: "malloc" must be explicitly called as "Perl_malloc" .
1116
1117            Malloc_t  Perl_malloc(MEM_SIZE nbytes)
1118
1119       "mfree"
1120           Implements ""Safefree"" in perlapi which you should use instead.
1121
1122           NOTE: "mfree" must be explicitly called as "Perl_mfree" .
1123
1124            Free_t  Perl_mfree(Malloc_t where)
1125
1126       "realloc"
1127           Implements ""Renew"" in perlapi which you should use instead.
1128
1129           NOTE: "realloc" must be explicitly called as "Perl_realloc" .
1130
1131            Malloc_t  Perl_realloc(Malloc_t where, MEM_SIZE nbytes)
1132

MRO

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
1139           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
1143            AV*  mro_get_linear_isa_dfs(HV* stash, U32 level)
1144
1145       "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
1150            void  mro_isa_changed_in(HV* stash)
1151
1152       "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
1158           This can also be called with a null first argument to indicate that
1159           "oldstash" has been deleted.
1160
1161           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
1166           It also sets the effective names ("HvENAME") on all the stashes as
1167           appropriate.
1168
1169           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
1173            void  mro_package_moved(HV * const stash, HV * const oldstash,
1174                                    const GV * const gv, U32 flags)
1175

Multicall Functions

1177       There are only public API items currently in Multicall Functions
1178

Numeric Functions

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
1186           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
1190            bool  isinfnansv(SV *sv)
1191

Optrees

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
1199            void  finalize_optree(OP* o)
1200
1201       "newATTRSUB_x"
1202           Construct a Perl subroutine, also performing some surrounding jobs.
1203
1204           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
1213           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
1225           "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
1234           "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
1246           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
1255           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
1260           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
1268           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
1282            CV*  newATTRSUB_x(I32 floor, OP *o, OP *proto, OP *attrs,
1283                              OP *block, bool o_is_gv)
1284
1285       "newXS_len_flags"
1286           Construct an XS subroutine, also performing some surrounding jobs.
1287
1288           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
1298           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
1305           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
1317           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
1331           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
1342           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
1356            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
1362       "op_refcnt_lock"
1363           Implements the "OP_REFCNT_LOCK" macro which you should use instead.
1364
1365            void  op_refcnt_lock()
1366
1367       "op_refcnt_unlock"
1368           Implements the "OP_REFCNT_UNLOCK" macro which you should use
1369           instead.
1370
1371            void  op_refcnt_unlock()
1372
1373       "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
1379            void  optimize_optree(OP* o)
1380
1381       "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
1385           The initial call must supply the root of the tree as both top and
1386           o.
1387
1388           For now it's static, but it may be exposed to the API in the
1389           future.
1390
1391            OP*  traverse_op_tree(OP* top, OP* o)
1392

Pack and Unpack

1394       There are only public API items currently in Pack and Unpack
1395

Pad Data Structures

1397       "CX_CURPAD_SAVE"
1398           Save the current pad in the given context block structure.
1399
1400            void  CX_CURPAD_SAVE(struct context)
1401
1402       "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
1406            SV *  CX_CURPAD_SV(struct context, PADOFFSET po)
1407
1408       "PAD_BASE_SV"
1409           Get the value from slot "po" in the base (DEPTH=1) pad of a padlist
1410
1411            SV *  PAD_BASE_SV(PADLIST padlist, PADOFFSET po)
1412
1413       "PAD_CLONE_VARS"
1414           Clone the state variables associated with running and compiling
1415           pads.
1416
1417            void  PAD_CLONE_VARS(PerlInterpreter *proto_perl,
1418                                 CLONE_PARAMS* param)
1419
1420       "PAD_COMPNAME_FLAGS"
1421           Return the flags for the current compiling pad name at offset "po".
1422           Assumes a valid slot entry.
1423
1424            U32  PAD_COMPNAME_FLAGS(PADOFFSET po)
1425
1426       "PAD_COMPNAME_GEN"
1427           The generation number of the name at offset "po" in the current
1428           compiling pad (lvalue).
1429
1430            STRLEN  PAD_COMPNAME_GEN(PADOFFSET po)
1431
1432       "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
1436            STRLEN  PAD_COMPNAME_GEN_set(PADOFFSET po, int gen)
1437
1438       "PAD_COMPNAME_OURSTASH"
1439           Return the stash associated with an "our" variable.  Assumes the
1440           slot entry is a valid "our" lexical.
1441
1442            HV *  PAD_COMPNAME_OURSTASH(PADOFFSET po)
1443
1444       "PAD_COMPNAME_PV"
1445           Return the name of the current compiling pad name at offset "po".
1446           Assumes a valid slot entry.
1447
1448            char *  PAD_COMPNAME_PV(PADOFFSET po)
1449
1450       "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
1454            HV *  PAD_COMPNAME_TYPE(PADOFFSET po)
1455
1456       "PadnameIsOUR"
1457           Whether this is an "our" variable.
1458
1459            bool  PadnameIsOUR(PADNAME * pn)
1460
1461       "PadnameIsSTATE"
1462           Whether this is a "state" variable.
1463
1464            bool  PadnameIsSTATE(PADNAME * pn)
1465
1466       "PadnameOURSTASH"
1467           The stash in which this "our" variable was declared.
1468
1469            HV *  PadnameOURSTASH(PADNAME * pn)
1470
1471       "PadnameOUTER"
1472           Whether this entry belongs to an outer pad.  Entries for which this
1473           is true are often referred to as 'fake'.
1474
1475            bool  PadnameOUTER(PADNAME * pn)
1476
1477       "PadnameTYPE"
1478           The stash associated with a typed lexical.  This returns the %Foo::
1479           hash for "my Foo $bar".
1480
1481            HV *  PadnameTYPE(PADNAME * pn)
1482
1483       "PAD_RESTORE_LOCAL"
1484           Restore the old pad saved into the local variable "opad" by
1485           "PAD_SAVE_LOCAL()"
1486
1487            void  PAD_RESTORE_LOCAL(PAD *opad)
1488
1489       "PAD_SAVE_LOCAL"
1490           Save the current pad to the local variable "opad", then make the
1491           current pad equal to "npad"
1492
1493            void  PAD_SAVE_LOCAL(PAD *opad, PAD *npad)
1494
1495       "PAD_SAVE_SETNULLPAD"
1496           Save the current pad then set it to null.
1497
1498            void  PAD_SAVE_SETNULLPAD()
1499
1500       "PAD_SETSV"
1501           Set the slot at offset "po" in the current pad to "sv"
1502
1503            SV *  PAD_SETSV(PADOFFSET po, SV* sv)
1504
1505       "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
1510               SAVECOMPPAD();
1511               PAD_SET_CUR_NOSAVE(padlist,n);
1512
1513            void  PAD_SET_CUR(PADLIST padlist, I32 n)
1514
1515       "PAD_SET_CUR_NOSAVE"
1516           like PAD_SET_CUR, but without the save
1517
1518            void  PAD_SET_CUR_NOSAVE(PADLIST padlist, I32 n)
1519
1520       "PAD_SV"
1521           Get the value at offset "po" in the current pad
1522
1523            SV *  PAD_SV(PADOFFSET po)
1524
1525       "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
1530            SV *  PAD_SVl(PADOFFSET po)
1531
1532       "SAVECLEARSV"
1533           Clear the pointed to pad value on scope exit.  (i.e. the runtime
1534           action of "my")
1535
1536            void  SAVECLEARSV(SV **svp)
1537
1538       "SAVECOMPPAD"
1539           save "PL_comppad" and "PL_curpad"
1540
1541            void  SAVECOMPPAD()
1542
1543       "SAVEPADSV"
1544           Save a pad slot (used to restore after an iteration)
1545
1546            void  SAVEPADSV(PADOFFSET po)
1547

Password and Group access

1549       There are only public API items currently in Password and Group access
1550

Paths to system commands

1552       There are only public API items currently in Paths to system commands
1553

Prototype information

1555       There are only public API items currently in Prototype information
1556

REGEXP Functions

1558       "regnode"
1559           Described in perlreguts.
1560

Reports and Formats

1562       There are only public API items currently in Reports and Formats
1563

Signals

1565       There are only public API items currently in Signals
1566

Site configuration

1568       There are only public API items currently in Site configuration
1569

Sockets configuration values

1571       There are only public API items currently in Sockets configuration
1572       values
1573

Source Filters

1575       There are only public API items currently in Source Filters
1576

Stack Manipulation Macros

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
1584              djSP();
1585
1586       "LVRET"
1587           True if this op will be the return value of an lvalue subroutine
1588
1589       "save_alloc"
1590           Implements ""SSNEW"" in perlapi and kin, which should be used
1591           instead of this function.
1592
1593            I32  save_alloc(I32 size, I32 pad)
1594

String Handling

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
1603           The number of bytes copied is written to *retlen.
1604
1605           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
1609           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
1613           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
1619            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
1623       "my_cxt_init"
1624           Implements the ""MY_CXT_INIT"" in perlxs macro, which you should
1625           use instead.
1626
1627           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
1634           NOTE: "my_cxt_init" must be explicitly called as "Perl_my_cxt_init"
1635           with an "aTHX_" parameter.
1636
1637            void*  Perl_my_cxt_init(pTHX_ int *indexp, size_t size)
1638
1639       "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
1644           The format specifier detection is not complete printf-syntax
1645           detection, but it should catch most common cases.
1646
1647           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
1655            bool  quadmath_format_needed(const char* format)
1656
1657       "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
1662           "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
1667           Returns true if it is valid, false if not.
1668
1669           See also "quadmath_format_needed".
1670
1671            bool  quadmath_format_valid(const char* format)
1672

SV Flags

1674       "SVt_INVLIST"
1675           Type flag for scalars.  See "svtype" in perlapi.
1676

SV Handling

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
1684              PL_Sv
1685
1686       "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
1691            bool  sv_2bool(SV *const sv)
1692
1693       "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
1698            bool  sv_2bool_flags(SV *sv, I32 flags)
1699
1700       "sv_2num"
1701           NOTE: "sv_2num" is experimental and may change or be removed
1702           without notice.
1703
1704           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
1708            SV*  sv_2num(SV *const sv)
1709
1710       "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
1714           Usually accessed via the "SvPVbyte_nolen" macro.
1715
1716            char*  sv_2pvbyte_nolen(SV* sv)
1717
1718       "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
1722           Usually accessed via the "SvPVutf8_nolen" macro.
1723
1724            char*  sv_2pvutf8_nolen(SV* sv)
1725
1726       "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
1730            char*  sv_2pv_nolen(SV* sv)
1731
1732       "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
1736            void  sv_add_arena(char *const ptr, const U32 size,
1737                               const U32 flags)
1738
1739       "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
1744            I32  sv_clean_all()
1745
1746       "sv_clean_objs"
1747           Attempt to destroy all objects not yet freed.
1748
1749            void  sv_clean_objs()
1750
1751       "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
1756            void  sv_free_arenas()
1757
1758       "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
1763            char*  sv_grow(SV *const sv, STRLEN newlen)
1764
1765       "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
1772            char*  sv_grow_fresh(SV *const sv, STRLEN newlen)
1773
1774       "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
1779           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
1783            IV  sv_iv(SV* sv)
1784
1785       "sv_newref"
1786           Increment an SV's reference count.  Use the "SvREFCNT_inc()"
1787           wrapper instead.
1788
1789            SV*  sv_newref(SV *const sv)
1790
1791       "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
1796           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
1800            NV  sv_nv(SV* sv)
1801
1802       "sv_pv"
1803           Use the "SvPV_nolen" macro instead
1804
1805            char*  sv_pv(SV *sv)
1806
1807       "sv_pvbyte"
1808           Use "SvPVbyte_nolen" instead.
1809
1810            char*  sv_pvbyte(SV *sv)
1811
1812       "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
1817           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
1821            char*  sv_pvbyten(SV *sv, STRLEN *lp)
1822
1823       "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
1827            char*  sv_pvbyten_force(SV *const sv, STRLEN *const lp)
1828
1829       "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
1834           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
1838            char*  sv_pvn(SV *sv, STRLEN *lp)
1839
1840       "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
1845            char*  sv_pvn_force(SV* sv, STRLEN* lp)
1846
1847       "sv_pvutf8"
1848           Use the "SvPVutf8_nolen" macro instead
1849
1850            char*  sv_pvutf8(SV *sv)
1851
1852       "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
1857           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
1861            char*  sv_pvutf8n(SV *sv, STRLEN *lp)
1862
1863       "sv_pvutf8n_force"
1864           The backend for the "SvPVutf8x_force" macro.  Always use the macro
1865           instead.
1866
1867            char*  sv_pvutf8n_force(SV *const sv, STRLEN *const lp)
1868
1869       "sv_tainted"
1870           Test an SV for taintedness.  Use "SvTAINTED" instead.
1871
1872            bool  sv_tainted(SV *const sv)
1873
1874       "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
1879           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
1883           This is used internally by various sv-modifying functions, such as
1884           "sv_setsv", "sv_setiv" and "sv_pvn_force".
1885
1886           One case that this does not handle is a gv without SvFAKE set.
1887           After
1888
1889               if (SvTHINKFIRST(gv)) sv_force_normal(gv);
1890
1891           it will still be a gv.
1892
1893           "SvTHINKFIRST" sometimes produces false positives.  In those cases
1894           "sv_force_normal" does nothing.
1895
1896            U32  SvTHINKFIRST(SV *sv)
1897
1898       "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
1903            I32  sv_true(SV *const sv)
1904
1905       "sv_untaint"
1906           Untaint an SV.  Use "SvTAINTED_off" instead.
1907
1908            void  sv_untaint(SV *const sv)
1909
1910       "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
1915           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
1919            UV  sv_uv(SV* sv)
1920

Tainting

1922       "sv_taint"
1923           Taint an SV.  Use "SvTAINTED_on" instead.
1924
1925            void  sv_taint(SV* sv)
1926
1927       "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
1932            void  TAINT()
1933
1934       "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
1939            void  TAINT_ENV
1940
1941       "taint_env"
1942           Implements the "TAINT_ENV" macro, which you should generally use
1943           instead.
1944
1945            void  taint_env()
1946
1947       "TAINT_get"
1948           Returns a boolean as to whether some element is tainted or not.
1949
1950            bool  TAINT_get()
1951
1952       "TAINT_IF"
1953           If "c" evaluates to true, call ""TAINT"" to indicate that something
1954           is tainted; otherwise do nothing.
1955
1956            void  TAINT_IF(bool c)
1957
1958       "TAINTING_get"
1959           Returns a boolean as to whether taint checking is enabled or not.
1960
1961            bool  TAINTING_get()
1962
1963       "TAINTING_set"
1964           Turn taint checking mode off/on
1965
1966            void  TAINTING_set(bool s)
1967
1968       "TAINT_NOT"
1969           Remove any taintedness previously set by, e.g., "TAINT".
1970
1971            void  TAINT_NOT()
1972
1973       "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
1978            void  TAINT_PROPER(const char * s)
1979
1980       "taint_proper"
1981           Implements the "TAINT_PROPER" macro, which you should generally use
1982           instead.
1983
1984            void  taint_proper(const char* f, const char *const s)
1985
1986       "TAINT_set"
1987           If "s" is true, ""TAINT_get"" returns true; If "s" is false,
1988           ""TAINT_get"" returns false;
1989
1990            void  TAINT_set(bool s)
1991
1992       "TAINT_WARN_get"
1993           Returns false if tainting violations are fatal; Returns true if
1994           they're just warnings
1995
1996            bool  TAINT_WARN_get()
1997
1998       "TAINT_WARN_set"
1999           "s" being true indicates ""TAINT_WARN_get"" should return that
2000           tainting violations are just warnings
2001
2002           "s" being false indicates ""TAINT_WARN_get"" should return that
2003           tainting violations are fatal.
2004
2005            void  TAINT_WARN_set(bool s)
2006

Time

2008       There are only public API items currently in Time
2009

Typedef names

2011       There are only public API items currently in Typedef names
2012

Unicode Support

2014       "bytes_from_utf8_loc"
2015           NOTE: "bytes_from_utf8_loc" is experimental and may change or be
2016           removed without notice.
2017
2018           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
2022           If that parameter is "NULL", this function behaves identically to
2023           "bytes_from_utf8".
2024
2025           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
2029           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
2036           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
2041           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
2054           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
2059            U8*  bytes_from_utf8_loc(const U8 *s, STRLEN *lenp,
2060                                     bool *is_utf8p,
2061                                     const U8 ** first_unconverted)
2062
2063       "find_uninit_var"
2064           NOTE: "find_uninit_var" is experimental and may change or be
2065           removed without notice.
2066
2067           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
2078           The name is returned as a mortal SV.
2079
2080           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
2084            SV*  find_uninit_var(const OP *const obase,
2085                                 const SV *const uninit_sv, bool match,
2086                                 const char **desc_p)
2087
2088       "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
2099           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
2111           *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
2115           If the sequence is empty, TRUE is returned, but *ret_script (if
2116           asked for) will be "SCX_INVALID".
2117
2118           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
2125           The returned script will be "SCX_Inherited" iff all the code points
2126           in it are from the Inherited script.
2127
2128           Otherwise, the returned script will be "SCX_Common" iff all the
2129           code points in it are from the Inherited or Common scripts.
2130
2131            bool  isSCRIPT_RUN(const U8 *s, const U8 *send,
2132                               const bool utf8_target)
2133
2134       "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
2139           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
2144           See also ""is_utf8_invariant_string" in perlapi", ""is_utf8_string"
2145           in perlapi"
2146
2147            bool  is_utf8_non_invariant_string(const U8* const s, STRLEN len)
2148
2149       "report_uninit"
2150           Print appropriate "Use of uninitialized variable" warning.
2151
2152            void  report_uninit(const SV *uninit_sv)
2153
2154       "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
2159           Instead use "utf8_to_uvchr_buf" in perlapi, or rarely,
2160           "utf8n_to_uvchr" in perlapi.
2161
2162           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
2170            UV  utf8n_to_uvuni(const U8 *s, STRLEN curlen, STRLEN *retlen,
2171                               U32 flags)
2172
2173       "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
2178           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
2182           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
2189           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
2199            UV  utf8_to_uvuni(const U8 *s, STRLEN *retlen)
2200
2201       "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
2206           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
2212           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
2217           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
2227            UV  utf8_to_uvuni_buf(const U8 *s, const U8 *send, STRLEN *retlen)
2228
2229       "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
2234           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
2238           For details, see the description for "uvchr_to_utf8_flags" in
2239           perlapi.
2240
2241            U8*  uvoffuni_to_utf8_flags(U8 *d, UV uv, UV flags)
2242
2243       "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
2248           Instead you almost certainly want to use "uvchr_to_utf8" in perlapi
2249           or "uvchr_to_utf8_flags" in perlapi.
2250
2251           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
2259            U8*  uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)
2260
2261       "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
2268            UV  valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen)
2269
2270       "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
2279           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
2283           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
2287           See also ""is_utf8_invariant_string" in perlapi" and
2288           ""is_utf8_invariant_string_loc" in perlapi",
2289
2290            Size_t  variant_under_utf8_count(const U8* const s,
2291                                             const U8* const e)
2292

Utility Functions

2294       "my_popen_list"
2295           Implementing function on some systems for PerlProc_popen_list()
2296
2297            PerlIO*  my_popen_list(const char* mode, int n, SV ** args)
2298
2299       "my_socketpair"
2300           Emulates socketpair(2) on systems that don't have it, but which do
2301           have enough functionality for the emulation.
2302
2303            int  my_socketpair(int family, int type, int protocol, int fd[2])
2304

Versioning

2306       There are only public API items currently in Versioning
2307

Warning and Dieing

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
2314           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
2318            U8  PL_dowarn
2319

XS

2321       There are only public API items currently in XS
2322

Undocumented elements

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
2328        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_free
2711        mem_log_realloc
2712        _mem_collxfrm
2713        mg_find_mglob
2714        mg_size
2715        mode_from_discipline
2716        more_bodies
2717        more_sv
2718        moreswitches
2719        mortal_getenv
2720        mro_get_private_data
2721        mro_meta_dup
2722        mro_meta_init
2723        msbit_pos32
2724        msbit_pos64
2725        multiconcat_stringify
2726        multideref_stringify
2727        my_atof2
2728        my_atof3
2729        my_attrs
2730        my_clearenv
2731        my_lstat
2732        my_lstat_flags
2733        my_memrchr
2734        my_mkostemp_cloexec
2735        my_mkstemp_cloexec
2736        my_stat
2737        my_stat_flags
2738        my_strerror
2739        my_unexec
2740        NATIVE_TO_NEED
2741        newFORM
2742        newGP
2743        newMETHOP_internal
2744        newMYSUB
2745        newPROG
2746        new_stackinfo
2747        newSTUB
2748        newSVavdefelem
2749        new_warnings_bitfield
2750        newXS_deffile
2751        _new_invlist
2752        _new_invlist_C_array
2753        nextargv
2754        no_bareword_filehandle
2755        noperl_die
2756        notify_parser_that_changed_to_utf8
2757        oopsAV
2758        oopsHV
2759        op_clear
2760        op_integerize
2761        op_lvalue_flags
2762        opmethod_stash
2763        op_refcnt_dec
2764        op_refcnt_inc
2765        op_relocate_sv
2766        opslab_force_free
2767        opslab_free
2768        opslab_free_nopad
2769        op_std_init
2770        op_unscope
2771        package
2772        package_version
2773        pad_add_weakref
2774        padlist_store
2775        padname_free
2776        PadnameIN_SCOPE
2777        padnamelist_free
2778        parser_dup
2779        parser_free
2780        parser_free_nexttoke_ops
2781        parse_unicode_opts
2782        path_is_searchable
2783        peep
2784        perl_alloc_using
2785        perl_clone_using
2786        PerlIO_context_layers
2787        PerlIO_restore_errno
2788        PerlIO_save_errno
2789        PerlLIO_dup2_cloexec
2790        PerlLIO_dup_cloexec
2791        PerlLIO_open3_cloexec
2792        PerlLIO_open_cloexec
2793        PerlProc_pipe_cloexec
2794        PerlSock_accept_cloexec
2795        PerlSock_socketpair_cloexec
2796        PerlSock_socket_cloexec
2797        perly_sighandler
2798        pmruntime
2799        POPMARK
2800        populate_isa
2801        pregfree
2802        pregfree2
2803        qerror
2804        ReANY
2805        reentrant_free
2806        reentrant_init
2807        reentrant_retry
2808        reentrant_size
2809        re_exec_indentf
2810        ref
2811        regcurly
2812        regdump
2813        regdupe_internal
2814        regexec_flags
2815        regfree_internal
2816        reginitcolors
2817        reg_named_buff
2818        reg_named_buff_all
2819        reg_named_buff_exists
2820        reg_named_buff_fetch
2821        reg_named_buff_firstkey
2822        reg_named_buff_iter
2823        reg_named_buff_nextkey
2824        reg_named_buff_scalar
2825        regnext
2826        reg_numbered_buff_fetch
2827        reg_numbered_buff_length
2828        reg_numbered_buff_store
2829        regprop
2830        reg_qr_package
2831        reg_skipcomment
2832        reg_temp_copy
2833        re_indentf
2834        re_intuit_start
2835        re_intuit_string
2836        re_op_compile
2837        report_evil_fh
2838        report_redefined_cv
2839        report_wrongway_fh
2840        re_printf
2841        rpeep
2842        rsignal_restore
2843        rsignal_save
2844        rvpv_dup
2845        rxres_save
2846        same_dirent
2847        save_bool
2848        save_clearsv
2849        save_delete
2850        save_destructor
2851        save_destructor_x
2852        save_freeop
2853        save_freepv
2854        save_freesv
2855        save_I16
2856        save_I32
2857        save_I8
2858        save_int
2859        save_iv
2860        save_long
2861        save_mortalizesv
2862        save_pptr
2863        save_re_context
2864        save_sptr
2865        savestack_grow
2866        savestack_grow_cnt
2867        save_strlen
2868        save_to_buffer
2869        sawparens
2870        scalar
2871        scalarvoid
2872        scan_num
2873        scan_str
2874        scan_word
2875        seed
2876        set_caret_X
2877        setfd_cloexec
2878        setfd_cloexec_for_nonsysfd
2879        setfd_cloexec_or_inhexec_by_sysfdness
2880        setfd_inhexec
2881        setfd_inhexec_for_sysfd
2882        set_numeric_standard
2883        set_numeric_underlying
2884        set_padlist
2885        _setup_canned_invlist
2886        share_hek
2887        should_warn_nl
2888        should_we_output_Debug_r
2889        sighandler
2890        sighandler1
2891        sighandler3
2892        single_1bit_pos32
2893        single_1bit_pos64
2894        skipspace_flags
2895        Slab_Alloc
2896        Slab_Free
2897        Slab_to_ro
2898        Slab_to_rw
2899        softref2xv
2900        sortsv_flags_impl
2901        stack_grow
2902        str_to_version
2903        sub_crush_depth
2904        sv_2iv
2905        sv_2uv
2906        sv_add_backref
2907        sv_buf_to_ro
2908        sv_del_backref
2909        sv_free2
2910        sv_i_ncmp
2911        sv_i_ncmp_desc
2912        sv_kill_backrefs
2913        sv_magicext_mglob
2914        sv_ncmp
2915        sv_ncmp_desc
2916        sv_only_taint_gmagic
2917        sv_or_pv_pos_u2b
2918        sv_resetpvn
2919        sv_sethek
2920        sv_setsv_cow
2921        SvTRUE_common
2922        sv_unglob
2923        sys_init
2924        sys_init3
2925        sys_intern_clear
2926        sys_intern_dup
2927        sys_intern_init
2928        sys_term
2929        tied_method
2930        tmps_grow_p
2931        TOPMARK
2932        to_uni_fold
2933        to_uni_lower
2934        to_uni_title
2935        to_uni_upper
2936        _to_fold_latin1
2937        _to_uni_fold_flags
2938        _to_upper_title_latin1
2939        _to_utf8_fold_flags
2940        _to_utf8_lower_flags
2941        _to_utf8_title_flags
2942        _to_utf8_upper_flags
2943        translate_substr_offsets
2944        try_amagic_bin
2945        try_amagic_un
2946        uiv_2buf
2947        unlnk
2948        unshare_hek
2949        utf16_to_utf8
2950        utf16_to_utf8_base
2951        utf16_to_utf8_reversed
2952        _utf8n_to_uvchr_msgs_helper
2953        utf8_to_utf16_base
2954        utf8_to_uvchr_buf_helper
2955        utilize
2956        uvoffuni_to_utf8_flags_msgs
2957        uvuni_to_utf8
2958        valid_utf8_to_uvuni
2959        variant_byte_number
2960        varname
2961        vivify_defelem
2962        vivify_ref
2963        wait4pid
2964        _warn_problematic_locale
2965        was_lvalue_sub
2966        watch
2967        win32_croak_not_implemented
2968        write_to_stderr
2969        xs_boot_epilog
2970        xs_handshake
2971        yyerror
2972        yyerror_pv
2973        yyerror_pvn
2974        yylex
2975        yyparse
2976        yyquit
2977        yyunlex
2978

AUTHORS

2980       The autodocumentation system was originally added to the Perl core by
2981       Benjamin Stuhl.  Documentation is by whoever was kind enough to
2982       document their functions.
2983

SEE ALSO

2985       config.h, perlapi, perlapio, perlcall, perlclib, perlembed, perlfilter,
2986       perlguts, perlhacktips, perlinterp, perliol, perlmroapi, perlreapi,
2987       perlreguts, perlxs
2988
2989
2990
2991perl v5.36.0                      2022-08-30                     PERLINTERN(1)
Impressum