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       "AvFILLp"
19           If the array "av" is empty, this returns -1; otherwise it returns
20           the maximum value of the indices of all the array elements which
21           are currently defined in "av".  It does not handle magic, hence the
22           "p" private indication in its name.
23
24            SSize_t  AvFILLp(AV* av)
25

Callback Functions

27       There are only public API items currently in Callback Functions
28

Casting

30       There are only public API items currently in Casting
31

Character case changing

33       There are only public API items currently in Character case changing
34

Character classification

36       There are only public API items currently in Character classification
37

Compiler and Preprocessor information

39       There are only public API items currently in Compiler and Preprocessor
40       information
41

Compiler directives

43       There are only public API items currently in Compiler directives
44

Compile-time scope hooks

46       "BhkENTRY"
47           NOTE: "BhkENTRY" is experimental and may change or be removed
48           without notice.
49
50           Return an entry from the BHK structure.  "which" is a preprocessor
51           token indicating which entry to return.  If the appropriate flag is
52           not set this will return "NULL".  The type of the return value
53           depends on which entry you ask for.
54
55            void *  BhkENTRY(BHK *hk, which)
56
57       "BhkFLAGS"
58           NOTE: "BhkFLAGS" is experimental and may change or be removed
59           without notice.
60
61           Return the BHK's flags.
62
63            U32  BhkFLAGS(BHK *hk)
64
65       "CALL_BLOCK_HOOKS"
66           NOTE: "CALL_BLOCK_HOOKS" is experimental and may change or be
67           removed without notice.
68
69           Call all the registered block hooks for type "which".  "which" is a
70           preprocessing token; the type of "arg" depends on "which".
71
72            void  CALL_BLOCK_HOOKS(which, arg)
73

Concurrency

75       There are only public API items currently in Concurrency
76

COP Hint Hashes

78       There are only public API items currently in COP Hint Hashes
79

Custom Operators

81       "core_prototype"
82           This function assigns the prototype of the named core function to
83           "sv", or to a new mortal SV if "sv" is "NULL".  It returns the
84           modified "sv", or "NULL" if the core function has no prototype.
85           "code" is a code as returned by "keyword()".  It must not be equal
86           to 0.
87
88            SV *  core_prototype(SV *sv, const char *name, const int code,
89                                 int * const opnum)
90

CV Handling

92       "CvWEAKOUTSIDE"
93           Each CV has a pointer, "CvOUTSIDE()", to its lexically enclosing CV
94           (if any).  Because pointers to anonymous sub prototypes are stored
95           in "&" pad slots, it is a possible to get a circular reference,
96           with the parent pointing to the child and vice-versa.  To avoid the
97           ensuing memory leak, we do not increment the reference count of the
98           CV pointed to by "CvOUTSIDE" in the one specific instance that the
99           parent has a "&" pad slot pointing back to us.  In this case, we
100           set the "CvWEAKOUTSIDE" flag in the child.  This allows us to
101           determine under what circumstances we should decrement the refcount
102           of the parent when freeing the child.
103
104           There is a further complication with non-closure anonymous subs
105           (i.e. those that do not refer to any lexicals outside that sub).
106           In this case, the anonymous prototype is shared rather than being
107           cloned.  This has the consequence that the parent may be freed
108           while there are still active children, e.g.,
109
110               BEGIN { $a = sub { eval '$x' } }
111
112           In this case, the BEGIN is freed immediately after execution since
113           there are no active references to it: the anon sub prototype has
114           "CvWEAKOUTSIDE" set since it's not a closure, and $a points to the
115           same CV, so it doesn't contribute to BEGIN's refcount either.  When
116           $a is executed, the "eval '$x'" causes the chain of "CvOUTSIDE"s to
117           be followed, and the freed BEGIN is accessed.
118
119           To avoid this, whenever a CV and its associated pad is freed, any
120           "&" entries in the pad are explicitly removed from the pad, and if
121           the refcount of the pointed-to anon sub is still positive, then
122           that child's "CvOUTSIDE" is set to point to its grandparent.  This
123           will only occur in the single specific case of a non-closure anon
124           prototype having one or more active references (such as $a above).
125
126           One other thing to consider is that a CV may be merely undefined
127           rather than freed, eg "undef &foo".  In this case, its refcount may
128           not have reached zero, but we still delete its pad and its "CvROOT"
129           etc.  Since various children may still have their "CvOUTSIDE"
130           pointing at this undefined CV, we keep its own "CvOUTSIDE" for the
131           time being, so that the chain of lexical scopes is unbroken.  For
132           example, the following should print 123:
133
134               my $x = 123;
135               sub tmp { sub { eval '$x' } }
136               my $a = tmp();
137               undef &tmp;
138               print  $a->();
139
140            bool  CvWEAKOUTSIDE(CV *cv)
141
142       "docatch"
143           Check for the cases 0 or 3 of cur_env.je_ret, only used inside an
144           eval context.
145
146           0 is used as continue inside eval,
147
148           3 is used for a die caught by an inner eval - continue inner loop
149
150           See cop.h: je_mustcatch, when set at any runlevel to TRUE, means
151           eval ops must establish a local jmpenv to handle exception traps.
152
153            OP*  docatch(Perl_ppaddr_t firstpp)
154

Debugging

156       "free_c_backtrace"
157           Deallocates a backtrace received from get_c_backtrace.
158
159            void  free_c_backtrace(Perl_c_backtrace* bt)
160
161       "get_c_backtrace"
162           Collects the backtrace (aka "stacktrace") into a single linear
163           malloced buffer, which the caller must "Perl_free_c_backtrace()".
164
165           Scans the frames back by "depth + skip", then drops the "skip"
166           innermost, returning at most "depth" frames.
167
168            Perl_c_backtrace*  get_c_backtrace(int max_depth, int skip)
169
170       "PL_DBsingle"
171           When Perl is run in debugging mode, with the -d switch, this SV is
172           a boolean which indicates whether subs are being single-stepped.
173           Single-stepping is automatically turned on after every step.  This
174           is the C variable which corresponds to Perl's $DB::single variable.
175           See "PL_DBsub".
176
177           On threaded perls, each thread has an independent copy of this
178           variable; each initialized at creation time with the current value
179           of the creating thread's copy.
180
181            SV *  PL_DBsingle
182
183       "PL_DBsub"
184           When Perl is run in debugging mode, with the -d switch, this GV
185           contains the SV which holds the name of the sub being debugged.
186           This is the C variable which corresponds to Perl's $DB::sub
187           variable.  See "PL_DBsingle".
188
189           On threaded perls, each thread has an independent copy of this
190           variable; each initialized at creation time with the current value
191           of the creating thread's copy.
192
193            GV *  PL_DBsub
194
195       "PL_DBtrace"
196           Trace variable used when Perl is run in debugging mode, with the -d
197           switch.  This is the C variable which corresponds to Perl's
198           $DB::trace variable.  See "PL_DBsingle".
199
200           On threaded perls, each thread has an independent copy of this
201           variable; each initialized at creation time with the current value
202           of the creating thread's copy.
203
204            SV *  PL_DBtrace
205

Display functions

207       There are only public API items currently in Display functions
208

Embedding and Interpreter Cloning

210       "cv_dump"
211           dump the contents of a CV
212
213            void  cv_dump(const CV *cv, const char *title)
214
215       "cv_forget_slab"
216           When a CV has a reference count on its slab ("CvSLABBED"), it is
217           responsible for making sure it is freed.  (Hence, no two CVs should
218           ever have a reference count on the same slab.)  The CV only needs
219           to reference the slab during compilation.  Once it is compiled and
220           "CvROOT" attached, it has finished its job, so it can forget the
221           slab.
222
223            void  cv_forget_slab(CV *cv)
224
225       "do_dump_pad"
226           Dump the contents of a padlist
227
228            void  do_dump_pad(I32 level, PerlIO *file, PADLIST *padlist,
229                              int full)
230
231       "pad_alloc_name"
232           Allocates a place in the currently-compiling pad (via "pad_alloc"
233           in perlapi) and then stores a name for that entry.  "name" is
234           adopted and becomes the name entry; it must already contain the
235           name string.  "typestash" and "ourstash" and the "padadd_STATE"
236           flag get added to "name".  None of the other processing of
237           "pad_add_name_pvn" in perlapi is done.  Returns the offset of the
238           allocated pad slot.
239
240            PADOFFSET  pad_alloc_name(PADNAME *name, U32 flags, HV *typestash,
241                                      HV *ourstash)
242
243       "pad_block_start"
244           Update the pad compilation state variables on entry to a new block.
245
246            void  pad_block_start(int full)
247
248       "pad_check_dup"
249           Check for duplicate declarations: report any of:
250
251                * a 'my' in the current scope with the same name;
252                * an 'our' (anywhere in the pad) with the same name and the
253                  same stash as 'ourstash'
254
255           "is_our" indicates that the name to check is an "our" declaration.
256
257            void  pad_check_dup(PADNAME *name, U32 flags, const HV *ourstash)
258
259       "pad_findlex"
260           Find a named lexical anywhere in a chain of nested pads.  Add fake
261           entries in the inner pads if it's found in an outer one.
262
263           Returns the offset in the bottom pad of the lex or the fake lex.
264           "cv" is the CV in which to start the search, and seq is the current
265           "cop_seq" to match against.  If "warn" is true, print appropriate
266           warnings.  The "out_"* vars return values, and so are pointers to
267           where the returned values should be stored.  "out_capture", if non-
268           null, requests that the innermost instance of the lexical is
269           captured; "out_name" is set to the innermost matched pad name or
270           fake pad name; "out_flags" returns the flags normally associated
271           with the "PARENT_FAKELEX_FLAGS" field of a fake pad name.
272
273           Note that "pad_findlex()" is recursive; it recurses up the chain of
274           CVs, then comes back down, adding fake entries as it goes.  It has
275           to be this way because fake names in anon prototypes have to store
276           in "xpadn_low" the index into the parent pad.
277
278            PADOFFSET  pad_findlex(const char *namepv, STRLEN namelen,
279                                   U32 flags, const CV* cv, U32 seq, int warn,
280                                   SV** out_capture, PADNAME** out_name,
281                                   int *out_flags)
282
283       "pad_fixup_inner_anons"
284           For any anon CVs in the pad, change "CvOUTSIDE" of that CV from
285           "old_cv" to "new_cv" if necessary.  Needed when a newly-compiled CV
286           has to be moved to a pre-existing CV struct.
287
288            void  pad_fixup_inner_anons(PADLIST *padlist, CV *old_cv,
289                                        CV *new_cv)
290
291       "pad_free"
292           Free the SV at offset po in the current pad.
293
294            void  pad_free(PADOFFSET po)
295
296       "pad_leavemy"
297           Cleanup at end of scope during compilation: set the max seq number
298           for lexicals in this scope and warn of any lexicals that never got
299           introduced.
300
301            OP *  pad_leavemy()
302
303       "padlist_dup"
304           Duplicates a pad.
305
306            PADLIST *  padlist_dup(PADLIST *srcpad, CLONE_PARAMS *param)
307
308       "padname_dup"
309           Duplicates a pad name.
310
311            PADNAME *  padname_dup(PADNAME *src, CLONE_PARAMS *param)
312
313       "padnamelist_dup"
314           Duplicates a pad name list.
315
316            PADNAMELIST *  padnamelist_dup(PADNAMELIST *srcpad,
317                                           CLONE_PARAMS *param)
318
319       "pad_push"
320           Push a new pad frame onto the padlist, unless there's already a pad
321           at this depth, in which case don't bother creating a new one.  Then
322           give the new pad an @_ in slot zero.
323
324            void  pad_push(PADLIST *padlist, int depth)
325
326       "pad_reset"
327           Mark all the current temporaries for reuse
328
329            void  pad_reset()
330
331       "pad_setsv"
332           Set the value at offset "po" in the current (compiling or
333           executing) pad.  Use the macro "PAD_SETSV()" rather than calling
334           this function directly.
335
336            void  pad_setsv(PADOFFSET po, SV* sv)
337
338       "pad_sv"
339           Get the value at offset "po" in the current (compiling or
340           executing) pad.  Use macro "PAD_SV" instead of calling this
341           function directly.
342
343            SV*  pad_sv(PADOFFSET po)
344
345       "pad_swipe"
346           Abandon the tmp in the current pad at offset "po" and replace with
347           a new one.
348
349            void  pad_swipe(PADOFFSET po, bool refadjust)
350

Errno

352       "dSAVEDERRNO"
353           Declare variables needed to save "errno" and any operating system
354           specific error number.
355
356            void  dSAVEDERRNO
357
358       "dSAVE_ERRNO"
359           Declare variables needed to save "errno" and any operating system
360           specific error number, and save them for optional later restoration
361           by "RESTORE_ERRNO".
362
363            void  dSAVE_ERRNO
364
365       "RESTORE_ERRNO"
366           Restore "errno" and any operating system specific error number that
367           was saved by "dSAVE_ERRNO" or "RESTORE_ERRNO".
368
369            void  RESTORE_ERRNO
370
371       "SAVE_ERRNO"
372           Save "errno" and any operating system specific error number for
373           optional later restoration by "RESTORE_ERRNO".  Requires
374           "dSAVEDERRNO" or "dSAVE_ERRNO" in scope.
375
376            void  SAVE_ERRNO
377
378       "SETERRNO"
379           Set "errno", and on VMS set "vaxc$errno".
380
381            void  SETERRNO(int errcode, int vmserrcode)
382

Exception Handling (simple) Macros

384       There are only public API items currently in Exception Handling
385       (simple) Macros
386

Filesystem configuration values

388       There are only public API items currently in Filesystem configuration
389       values
390

Floating point configuration values

392       There are only public API items currently in Floating point
393       configuration values
394

Formats

396       There are only public API items currently in Formats
397

General Configuration

399       There are only public API items currently in General Configuration
400

Global Variables

402       There are only public API items currently in Global Variables
403

GV Handling

405       "gv_stashsvpvn_cached"
406           Returns a pointer to the stash for a specified package, possibly
407           cached.  Implements both ""gv_stashpvn"" in perlapi and
408           ""gv_stashsv"" in perlapi.
409
410           Requires one of either "namesv" or "namepv" to be non-null.
411
412           If the flag "GV_CACHE_ONLY" is set, return the stash only if found
413           in the cache; see ""gv_stashpvn"" in perlapi for details on the
414           other "flags".
415
416           Note it is strongly preferred for "namesv" to be non-null, for
417           performance reasons.
418
419            HV*  gv_stashsvpvn_cached(SV *namesv, const char* name,
420                                      U32 namelen, I32 flags)
421
422       "gv_try_downgrade"
423           NOTE: "gv_try_downgrade" is experimental and may change or be
424           removed without notice.
425
426           If the typeglob "gv" can be expressed more succinctly, by having
427           something other than a real GV in its place in the stash, replace
428           it with the optimised form.  Basic requirements for this are that
429           "gv" is a real typeglob, is sufficiently ordinary, and is only
430           referenced from its package.  This function is meant to be used
431           when a GV has been looked up in part to see what was there, causing
432           upgrading, but based on what was found it turns out that the real
433           GV isn't required after all.
434
435           If "gv" is a completely empty typeglob, it is deleted from the
436           stash.
437
438           If "gv" is a typeglob containing only a sufficiently-ordinary
439           constant sub, the typeglob is replaced with a scalar-reference
440           placeholder that more compactly represents the same thing.
441
442            void  gv_try_downgrade(GV* gv)
443

Hook manipulation

445       There are only public API items currently in Hook manipulation
446

HV Handling

448       "hv_ename_add"
449           Adds a name to a stash's internal list of effective names.  See
450           "hv_ename_delete".
451
452           This is called when a stash is assigned to a new location in the
453           symbol table.
454
455            void  hv_ename_add(HV *hv, const char *name, U32 len, U32 flags)
456
457       "hv_ename_delete"
458           Removes a name from a stash's internal list of effective names.  If
459           this is the name returned by "HvENAME", then another name in the
460           list will take its place ("HvENAME" will use it).
461
462           This is called when a stash is deleted from the symbol table.
463
464            void  hv_ename_delete(HV *hv, const char *name, U32 len,
465                                  U32 flags)
466
467       "refcounted_he_chain_2hv"
468           Generates and returns a "HV *" representing the content of a
469           "refcounted_he" chain.  "flags" is currently unused and must be
470           zero.
471
472            HV *  refcounted_he_chain_2hv(const struct refcounted_he *c,
473                                          U32 flags)
474
475       "refcounted_he_fetch_pv"
476           Like "refcounted_he_fetch_pvn", but takes a nul-terminated string
477           instead of a string/length pair.
478
479            SV *  refcounted_he_fetch_pv(const struct refcounted_he *chain,
480                                         const char *key, U32 hash, U32 flags)
481
482       "refcounted_he_fetch_pvn"
483           Search along a "refcounted_he" chain for an entry with the key
484           specified by "keypv" and "keylen".  If "flags" has the
485           "REFCOUNTED_HE_KEY_UTF8" bit set, the key octets are interpreted as
486           UTF-8, otherwise they are interpreted as Latin-1.  "hash" is a
487           precomputed hash of the key string, or zero if it has not been
488           precomputed.  Returns a mortal scalar representing the value
489           associated with the key, or &PL_sv_placeholder if there is no value
490           associated with the key.
491
492            SV *  refcounted_he_fetch_pvn(const struct refcounted_he *chain,
493                                          const char *keypv, STRLEN keylen,
494                                          U32 hash, U32 flags)
495
496       "refcounted_he_fetch_pvs"
497           Like "refcounted_he_fetch_pvn", but takes a literal string instead
498           of a string/length pair, and no precomputed hash.
499
500            SV *  refcounted_he_fetch_pvs(const struct refcounted_he *chain,
501                                          "key", U32 flags)
502
503       "refcounted_he_fetch_sv"
504           Like "refcounted_he_fetch_pvn", but takes a Perl scalar instead of
505           a string/length pair.
506
507            SV *  refcounted_he_fetch_sv(const struct refcounted_he *chain,
508                                         SV *key, U32 hash, U32 flags)
509
510       "refcounted_he_free"
511           Decrements the reference count of a "refcounted_he" by one.  If the
512           reference count reaches zero the structure's memory is freed, which
513           (recursively) causes a reduction of its parent "refcounted_he"'s
514           reference count.  It is safe to pass a null pointer to this
515           function: no action occurs in this case.
516
517            void  refcounted_he_free(struct refcounted_he *he)
518
519       "refcounted_he_inc"
520           Increment the reference count of a "refcounted_he".  The pointer to
521           the "refcounted_he" is also returned.  It is safe to pass a null
522           pointer to this function: no action occurs and a null pointer is
523           returned.
524
525            struct refcounted_he *  refcounted_he_inc(
526                                                     struct refcounted_he *he)
527
528       "refcounted_he_new_pv"
529           Like "refcounted_he_new_pvn", but takes a nul-terminated string
530           instead of a string/length pair.
531
532            struct refcounted_he *  refcounted_he_new_pv(
533                                                 struct refcounted_he *parent,
534                                                 const char *key, U32 hash,
535                                                 SV *value, U32 flags)
536
537       "refcounted_he_new_pvn"
538           Creates a new "refcounted_he".  This consists of a single key/value
539           pair and a reference to an existing "refcounted_he" chain (which
540           may be empty), and thus forms a longer chain.  When using the
541           longer chain, the new key/value pair takes precedence over any
542           entry for the same key further along the chain.
543
544           The new key is specified by "keypv" and "keylen".  If "flags" has
545           the "REFCOUNTED_HE_KEY_UTF8" bit set, the key octets are
546           interpreted as UTF-8, otherwise they are interpreted as Latin-1.
547           "hash" is a precomputed hash of the key string, or zero if it has
548           not been precomputed.
549
550           "value" is the scalar value to store for this key.  "value" is
551           copied by this function, which thus does not take ownership of any
552           reference to it, and later changes to the scalar will not be
553           reflected in the value visible in the "refcounted_he".  Complex
554           types of scalar will not be stored with referential integrity, but
555           will be coerced to strings.  "value" may be either null or
556           &PL_sv_placeholder to indicate that no value is to be associated
557           with the key; this, as with any non-null value, takes precedence
558           over the existence of a value for the key further along the chain.
559
560           "parent" points to the rest of the "refcounted_he" chain to be
561           attached to the new "refcounted_he".  This function takes ownership
562           of one reference to "parent", and returns one reference to the new
563           "refcounted_he".
564
565            struct refcounted_he *  refcounted_he_new_pvn(
566                                                 struct refcounted_he *parent,
567                                                 const char *keypv,
568                                                 STRLEN keylen, U32 hash,
569                                                 SV *value, U32 flags)
570
571       "refcounted_he_new_pvs"
572           Like "refcounted_he_new_pvn", but takes a literal string instead of
573           a string/length pair, and no precomputed hash.
574
575            struct refcounted_he *  refcounted_he_new_pvs(
576                                                 struct refcounted_he *parent,
577                                                 "key", SV *value, U32 flags)
578
579       "refcounted_he_new_sv"
580           Like "refcounted_he_new_pvn", but takes a Perl scalar instead of a
581           string/length pair.
582
583            struct refcounted_he *  refcounted_he_new_sv(
584                                                 struct refcounted_he *parent,
585                                                 SV *key, U32 hash, SV *value,
586                                                 U32 flags)
587

Input/Output

589       "PL_last_in_gv"
590           The GV which was last used for a filehandle input operation.
591           ("<FH>")
592
593           On threaded perls, each thread has an independent copy of this
594           variable; each initialized at creation time with the current value
595           of the creating thread's copy.
596
597            GV*  PL_last_in_gv
598
599       "PL_ofsgv"
600           The glob containing the output field separator - "*," in Perl
601           space.
602
603           On threaded perls, each thread has an independent copy of this
604           variable; each initialized at creation time with the current value
605           of the creating thread's copy.
606
607            GV*  PL_ofsgv
608
609       "PL_rs"
610           The input record separator - $/ in Perl space.
611
612           On threaded perls, each thread has an independent copy of this
613           variable; each initialized at creation time with the current value
614           of the creating thread's copy.
615
616            SV*  PL_rs
617
618       "start_glob"
619           NOTE: "start_glob" is experimental and may change or be removed
620           without notice.
621
622           Function called by "do_readline" to spawn a glob (or do the glob
623           inside perl on VMS).  This code used to be inline, but now perl
624           uses "File::Glob" this glob starter is only used by miniperl during
625           the build process, or when PERL_EXTERNAL_GLOB is defined.  Moving
626           it away shrinks pp_hot.c; shrinking pp_hot.c helps speed perl up.
627
628           NOTE: "start_glob" must be explicitly called as "Perl_start_glob"
629           with an "aTHX_" parameter.
630
631            PerlIO*  Perl_start_glob(pTHX_ SV *tmpglob, IO *io)
632

Integer configuration values

634       There are only public API items currently in Integer configuration
635       values
636

Lexer interface

638       "validate_proto"
639           NOTE: "validate_proto" is experimental and may change or be removed
640           without notice.
641
642           This function performs syntax checking on a prototype, "proto".  If
643           "warn" is true, any illegal characters or mismatched brackets will
644           trigger illegalproto warnings, declaring that they were detected in
645           the prototype for "name".
646
647           The return value is "true" if this is a valid prototype, and
648           "false" if it is not, regardless of whether "warn" was "true" or
649           "false".
650
651           Note that "NULL" is a valid "proto" and will always return "true".
652
653            bool  validate_proto(SV *name, SV *proto, bool warn,
654                                 bool curstash)
655

Locales

657       There are only public API items currently in Locales
658

Magic

660       "magic_clearhint"
661           Triggered by a delete from "%^H", records the key to
662           "PL_compiling.cop_hints_hash".
663
664            int  magic_clearhint(SV* sv, MAGIC* mg)
665
666       "magic_clearhints"
667           Triggered by clearing "%^H", resets "PL_compiling.cop_hints_hash".
668
669            int  magic_clearhints(SV* sv, MAGIC* mg)
670
671       "magic_methcall"
672           Invoke a magic method (like FETCH).
673
674           "sv" and "mg" are the tied thingy and the tie magic.
675
676           "meth" is the name of the method to call.
677
678           "argc" is the number of args (in addition to $self) to pass to the
679           method.
680
681           The "flags" can be:
682
683               G_DISCARD     invoke method with G_DISCARD flag and don't
684                             return a value
685               G_UNDEF_FILL  fill the stack with argc pointers to
686                             PL_sv_undef
687
688           The arguments themselves are any values following the "flags"
689           argument.
690
691           Returns the SV (if any) returned by the method, or "NULL" on
692           failure.
693
694           NOTE: "magic_methcall" must be explicitly called as
695           "Perl_magic_methcall" with an "aTHX_" parameter.
696
697            SV*  Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, SV *meth,
698                                     U32 flags, U32 argc, ...)
699
700       "magic_sethint"
701           Triggered by a store to "%^H", records the key/value pair to
702           "PL_compiling.cop_hints_hash".  It is assumed that hints aren't
703           storing anything that would need a deep copy.  Maybe we should warn
704           if we find a reference.
705
706            int  magic_sethint(SV* sv, MAGIC* mg)
707
708       "mg_localize"
709           Copy some of the magic from an existing SV to new localized version
710           of that SV.  Container magic (e.g., %ENV, $1, "tie") gets copied,
711           value magic doesn't (e.g., "taint", "pos").
712
713           If "setmagic" is false then no set magic will be called on the new
714           (empty) SV.  This typically means that assignment will soon follow
715           (e.g. 'local $x = $y'), and that will handle the magic.
716
717            void  mg_localize(SV* sv, SV* nsv, bool setmagic)
718

Memory Management

720       There are only public API items currently in Memory Management
721

MRO

723       "mro_get_linear_isa_dfs"
724           Returns the Depth-First Search linearization of @ISA the given
725           stash.  The return value is a read-only AV*.  "level" should be 0
726           (it is used internally in this function's recursion).
727
728           You are responsible for "SvREFCNT_inc()" on the return value if you
729           plan to store it anywhere semi-permanently (otherwise it might be
730           deleted out from under you the next time the cache is invalidated).
731
732            AV*  mro_get_linear_isa_dfs(HV* stash, U32 level)
733
734       "mro_isa_changed_in"
735           Takes the necessary steps (cache invalidations, mostly) when the
736           @ISA of the given package has changed.  Invoked by the "setisa"
737           magic, should not need to invoke directly.
738
739            void  mro_isa_changed_in(HV* stash)
740
741       "mro_package_moved"
742           Call this function to signal to a stash that it has been assigned
743           to another spot in the stash hierarchy.  "stash" is the stash that
744           has been assigned.  "oldstash" is the stash it replaces, if any.
745           "gv" is the glob that is actually being assigned to.
746
747           This can also be called with a null first argument to indicate that
748           "oldstash" has been deleted.
749
750           This function invalidates isa caches on the old stash, on all
751           subpackages nested inside it, and on the subclasses of all those,
752           including non-existent packages that have corresponding entries in
753           "stash".
754
755           It also sets the effective names ("HvENAME") on all the stashes as
756           appropriate.
757
758           If the "gv" is present and is not in the symbol table, then this
759           function simply returns.  This checked will be skipped if "flags &
760           1".
761
762            void  mro_package_moved(HV * const stash, HV * const oldstash,
763                                    const GV * const gv, U32 flags)
764

Multicall Functions

766       There are only public API items currently in Multicall Functions
767

Numeric Functions

769       "grok_atoUV"
770           parse a string, looking for a decimal unsigned integer.
771
772           On entry, "pv" points to the beginning of the string; "valptr"
773           points to a UV that will receive the converted value, if found;
774           "endptr" is either NULL or points to a variable that points to one
775           byte beyond the point in "pv" that this routine should examine.  If
776           "endptr" is NULL, "pv" is assumed to be NUL-terminated.
777
778           Returns FALSE if "pv" doesn't represent a valid unsigned integer
779           value (with no leading zeros).  Otherwise it returns TRUE, and sets
780           *valptr to that value.
781
782           If you constrain the portion of "pv" that is looked at by this
783           function (by passing a non-NULL "endptr"), and if the intial bytes
784           of that portion form a valid value, it will return TRUE, setting
785           *endptr to the byte following the final digit of the value.  But if
786           there is no constraint at what's looked at, all of "pv" must be
787           valid in order for TRUE to be returned.  *endptr is unchanged from
788           its value on input if FALSE is returned;
789
790           The only characters this accepts are the decimal digits '0'..'9'.
791
792           As opposed to atoi(3) or strtol(3), "grok_atoUV" does NOT allow
793           optional leading whitespace, nor negative inputs.  If such features
794           are required, the calling code needs to explicitly implement those.
795
796           Note that this function returns FALSE for inputs that would
797           overflow a UV, or have leading zeros.  Thus a single 0 is accepted,
798           but not 00 nor 01, 002, etc.
799
800           Background: "atoi" has severe problems with illegal inputs, it
801           cannot be used for incremental parsing, and therefore should be
802           avoided "atoi" and "strtol" are also affected by locale settings,
803           which can also be seen as a bug (global state controlled by user
804           environment).
805
806            bool  grok_atoUV(const char* pv, UV* valptr, const char** endptr)
807
808       "isinfnansv"
809           Checks whether the argument would be either an infinity or "NaN"
810           when used as a number, but is careful not to trigger non-numeric or
811           uninitialized warnings.  it assumes the caller has done
812           "SvGETMAGIC(sv)" already.
813
814            bool  isinfnansv(SV *sv)
815

Optree construction

817       There are only public API items currently in Optree construction
818

Optree Manipulation Functions

820       "finalize_optree"
821           This function finalizes the optree.  Should be called directly
822           after the complete optree is built.  It does some additional
823           checking which can't be done in the normal "ck_"xxx functions and
824           makes the tree thread-safe.
825
826            void  finalize_optree(OP* o)
827
828       "newATTRSUB_x"
829           Construct a Perl subroutine, also performing some surrounding jobs.
830
831           This function is expected to be called in a Perl compilation
832           context, and some aspects of the subroutine are taken from global
833           variables associated with compilation.  In particular, "PL_compcv"
834           represents the subroutine that is currently being compiled.  It
835           must be non-null when this function is called, and some aspects of
836           the subroutine being constructed are taken from it.  The
837           constructed subroutine may actually be a reuse of the "PL_compcv"
838           object, but will not necessarily be so.
839
840           If "block" is null then the subroutine will have no body, and for
841           the time being it will be an error to call it.  This represents a
842           forward subroutine declaration such as "sub foo ($$);".  If "block"
843           is non-null then it provides the Perl code of the subroutine body,
844           which will be executed when the subroutine is called.  This body
845           includes any argument unwrapping code resulting from a subroutine
846           signature or similar.  The pad use of the code must correspond to
847           the pad attached to "PL_compcv".  The code is not expected to
848           include a "leavesub" or "leavesublv" op; this function will add
849           such an op.  "block" is consumed by this function and will become
850           part of the constructed subroutine.
851
852           "proto" specifies the subroutine's prototype, unless one is
853           supplied as an attribute (see below).  If "proto" is null, then the
854           subroutine will not have a prototype.  If "proto" is non-null, it
855           must point to a "const" op whose value is a string, and the
856           subroutine will have that string as its prototype.  If a prototype
857           is supplied as an attribute, the attribute takes precedence over
858           "proto", but in that case "proto" should preferably be null.  In
859           any case, "proto" is consumed by this function.
860
861           "attrs" supplies attributes to be applied the subroutine.  A
862           handful of attributes take effect by built-in means, being applied
863           to "PL_compcv" immediately when seen.  Other attributes are
864           collected up and attached to the subroutine by this route.  "attrs"
865           may be null to supply no attributes, or point to a "const" op for a
866           single attribute, or point to a "list" op whose children apart from
867           the "pushmark" are "const" ops for one or more attributes.  Each
868           "const" op must be a string, giving the attribute name optionally
869           followed by parenthesised arguments, in the manner in which
870           attributes appear in Perl source.  The attributes will be applied
871           to the sub by this function.  "attrs" is consumed by this function.
872
873           If "o_is_gv" is false and "o" is null, then the subroutine will be
874           anonymous.  If "o_is_gv" is false and "o" is non-null, then "o"
875           must point to a "const" OP, which will be consumed by this
876           function, and its string value supplies a name for the subroutine.
877           The name may be qualified or unqualified, and if it is unqualified
878           then a default stash will be selected in some manner.  If "o_is_gv"
879           is true, then "o" doesn't point to an "OP" at all, but is instead a
880           cast pointer to a "GV" by which the subroutine will be named.
881
882           If there is already a subroutine of the specified name, then the
883           new sub will either replace the existing one in the glob or be
884           merged with the existing one.  A warning may be generated about
885           redefinition.
886
887           If the subroutine has one of a few special names, such as "BEGIN"
888           or "END", then it will be claimed by the appropriate queue for
889           automatic running of phase-related subroutines.  In this case the
890           relevant glob will be left not containing any subroutine, even if
891           it did contain one before.  In the case of "BEGIN", the subroutine
892           will be executed and the reference to it disposed of before this
893           function returns.
894
895           The function returns a pointer to the constructed subroutine.  If
896           the sub is anonymous then ownership of one counted reference to the
897           subroutine is transferred to the caller.  If the sub is named then
898           the caller does not get ownership of a reference.  In most such
899           cases, where the sub has a non-phase name, the sub will be alive at
900           the point it is returned by virtue of being contained in the glob
901           that names it.  A phase-named subroutine will usually be alive by
902           virtue of the reference owned by the phase's automatic run queue.
903           But a "BEGIN" subroutine, having already been executed, will quite
904           likely have been destroyed already by the time this function
905           returns, making it erroneous for the caller to make any use of the
906           returned pointer.  It is the caller's responsibility to ensure that
907           it knows which of these situations applies.
908
909            CV*  newATTRSUB_x(I32 floor, OP *o, OP *proto, OP *attrs,
910                              OP *block, bool o_is_gv)
911
912       "newXS_len_flags"
913           Construct an XS subroutine, also performing some surrounding jobs.
914
915           The subroutine will have the entry point "subaddr".  It will have
916           the prototype specified by the nul-terminated string "proto", or no
917           prototype if "proto" is null.  The prototype string is copied; the
918           caller can mutate the supplied string afterwards.  If "filename" is
919           non-null, it must be a nul-terminated filename, and the subroutine
920           will have its "CvFILE" set accordingly.  By default "CvFILE" is set
921           to point directly to the supplied string, which must be static.  If
922           "flags" has the "XS_DYNAMIC_FILENAME" bit set, then a copy of the
923           string will be taken instead.
924
925           Other aspects of the subroutine will be left in their default
926           state.  If anything else needs to be done to the subroutine for it
927           to function correctly, it is the caller's responsibility to do that
928           after this function has constructed it.  However, beware of the
929           subroutine potentially being destroyed before this function
930           returns, as described below.
931
932           If "name" is null then the subroutine will be anonymous, with its
933           "CvGV" referring to an "__ANON__" glob.  If "name" is non-null then
934           the subroutine will be named accordingly, referenced by the
935           appropriate glob.  "name" is a string of length "len" bytes giving
936           a sigilless symbol name, in UTF-8 if "flags" has the "SVf_UTF8" bit
937           set and in Latin-1 otherwise.  The name may be either qualified or
938           unqualified, with the stash defaulting in the same manner as for
939           "gv_fetchpvn_flags".  "flags" may contain flag bits understood by
940           "gv_fetchpvn_flags" with the same meaning as they have there, such
941           as "GV_ADDWARN".  The symbol is always added to the stash if
942           necessary, with "GV_ADDMULTI" semantics.
943
944           If there is already a subroutine of the specified name, then the
945           new sub will replace the existing one in the glob.  A warning may
946           be generated about the redefinition.  If the old subroutine was
947           "CvCONST" then the decision about whether to warn is influenced by
948           an expectation about whether the new subroutine will become a
949           constant of similar value.  That expectation is determined by
950           "const_svp".  (Note that the call to this function doesn't make the
951           new subroutine "CvCONST" in any case; that is left to the caller.)
952           If "const_svp" is null then it indicates that the new subroutine
953           will not become a constant.  If "const_svp" is non-null then it
954           indicates that the new subroutine will become a constant, and it
955           points to an "SV*" that provides the constant value that the
956           subroutine will have.
957
958           If the subroutine has one of a few special names, such as "BEGIN"
959           or "END", then it will be claimed by the appropriate queue for
960           automatic running of phase-related subroutines.  In this case the
961           relevant glob will be left not containing any subroutine, even if
962           it did contain one before.  In the case of "BEGIN", the subroutine
963           will be executed and the reference to it disposed of before this
964           function returns, and also before its prototype is set.  If a
965           "BEGIN" subroutine would not be sufficiently constructed by this
966           function to be ready for execution then the caller must prevent
967           this happening by giving the subroutine a different name.
968
969           The function returns a pointer to the constructed subroutine.  If
970           the sub is anonymous then ownership of one counted reference to the
971           subroutine is transferred to the caller.  If the sub is named then
972           the caller does not get ownership of a reference.  In most such
973           cases, where the sub has a non-phase name, the sub will be alive at
974           the point it is returned by virtue of being contained in the glob
975           that names it.  A phase-named subroutine will usually be alive by
976           virtue of the reference owned by the phase's automatic run queue.
977           But a "BEGIN" subroutine, having already been executed, will quite
978           likely have been destroyed already by the time this function
979           returns, making it erroneous for the caller to make any use of the
980           returned pointer.  It is the caller's responsibility to ensure that
981           it knows which of these situations applies.
982
983            CV *  newXS_len_flags(const char *name, STRLEN len,
984                                  XSUBADDR_t subaddr,
985                                  const char *const filename,
986                                  const char *const proto, SV **const_svp,
987                                  U32 flags)
988
989       "optimize_optree"
990           This function applies some optimisations to the optree in top-down
991           order.  It is called before the peephole optimizer, which processes
992           ops in execution order. Note that finalize_optree() also does a
993           top-down scan, but is called *after* the peephole optimizer.
994
995            void  optimize_optree(OP* o)
996
997       "traverse_op_tree"
998           Return the next op in a depth-first traversal of the op tree,
999           returning NULL when the traversal is complete.
1000
1001           The initial call must supply the root of the tree as both top and
1002           o.
1003
1004           For now it's static, but it may be exposed to the API in the
1005           future.
1006
1007            OP*  traverse_op_tree(OP* top, OP* o)
1008

Pack and Unpack

1010       There are only public API items currently in Pack and Unpack
1011

Pad Data Structures

1013       "CX_CURPAD_SAVE"
1014           Save the current pad in the given context block structure.
1015
1016            void  CX_CURPAD_SAVE(struct context)
1017
1018       "CX_CURPAD_SV"
1019           Access the SV at offset "po" in the saved current pad in the given
1020           context block structure (can be used as an lvalue).
1021
1022            SV *  CX_CURPAD_SV(struct context, PADOFFSET po)
1023
1024       "PAD_BASE_SV"
1025           Get the value from slot "po" in the base (DEPTH=1) pad of a padlist
1026
1027            SV *  PAD_BASE_SV(PADLIST padlist, PADOFFSET po)
1028
1029       "PAD_CLONE_VARS"
1030           Clone the state variables associated with running and compiling
1031           pads.
1032
1033            void  PAD_CLONE_VARS(PerlInterpreter *proto_perl,
1034                                 CLONE_PARAMS* param)
1035
1036       "PAD_COMPNAME_FLAGS"
1037           Return the flags for the current compiling pad name at offset "po".
1038           Assumes a valid slot entry.
1039
1040            U32  PAD_COMPNAME_FLAGS(PADOFFSET po)
1041
1042       "PAD_COMPNAME_GEN"
1043           The generation number of the name at offset "po" in the current
1044           compiling pad (lvalue).
1045
1046            STRLEN  PAD_COMPNAME_GEN(PADOFFSET po)
1047
1048       "PAD_COMPNAME_GEN_set"
1049           Sets the generation number of the name at offset "po" in the
1050           current ling pad (lvalue) to "gen".
1051
1052            STRLEN  PAD_COMPNAME_GEN_set(PADOFFSET po, int gen)
1053
1054       "PAD_COMPNAME_OURSTASH"
1055           Return the stash associated with an "our" variable.  Assumes the
1056           slot entry is a valid "our" lexical.
1057
1058            HV *  PAD_COMPNAME_OURSTASH(PADOFFSET po)
1059
1060       "PAD_COMPNAME_PV"
1061           Return the name of the current compiling pad name at offset "po".
1062           Assumes a valid slot entry.
1063
1064            char *  PAD_COMPNAME_PV(PADOFFSET po)
1065
1066       "PAD_COMPNAME_TYPE"
1067           Return the type (stash) of the current compiling pad name at offset
1068           "po".  Must be a valid name.  Returns null if not typed.
1069
1070            HV *  PAD_COMPNAME_TYPE(PADOFFSET po)
1071
1072       "PadnameIsOUR"
1073           Whether this is an "our" variable.
1074
1075            bool  PadnameIsOUR(PADNAME * pn)
1076
1077       "PadnameIsSTATE"
1078           Whether this is a "state" variable.
1079
1080            bool  PadnameIsSTATE(PADNAME * pn)
1081
1082       "PadnameOURSTASH"
1083           The stash in which this "our" variable was declared.
1084
1085            HV *  PadnameOURSTASH(PADNAME * pn)
1086
1087       "PadnameOUTER"
1088           Whether this entry belongs to an outer pad.  Entries for which this
1089           is true are often referred to as 'fake'.
1090
1091            bool  PadnameOUTER(PADNAME * pn)
1092
1093       "PadnameTYPE"
1094           The stash associated with a typed lexical.  This returns the %Foo::
1095           hash for "my Foo $bar".
1096
1097            HV *  PadnameTYPE(PADNAME * pn)
1098
1099       "PAD_RESTORE_LOCAL"
1100           Restore the old pad saved into the local variable "opad" by
1101           "PAD_SAVE_LOCAL()"
1102
1103            void  PAD_RESTORE_LOCAL(PAD *opad)
1104
1105       "PAD_SAVE_LOCAL"
1106           Save the current pad to the local variable "opad", then make the
1107           current pad equal to "npad"
1108
1109            void  PAD_SAVE_LOCAL(PAD *opad, PAD *npad)
1110
1111       "PAD_SAVE_SETNULLPAD"
1112           Save the current pad then set it to null.
1113
1114            void  PAD_SAVE_SETNULLPAD()
1115
1116       "PAD_SETSV"
1117           Set the slot at offset "po" in the current pad to "sv"
1118
1119            SV *  PAD_SETSV(PADOFFSET po, SV* sv)
1120
1121       "PAD_SET_CUR"
1122           Set the current pad to be pad "n" in the padlist, saving the
1123           previous current pad.  NB currently this macro expands to a string
1124           too long for some compilers, so it's best to replace it with
1125
1126               SAVECOMPPAD();
1127               PAD_SET_CUR_NOSAVE(padlist,n);
1128
1129            void  PAD_SET_CUR(PADLIST padlist, I32 n)
1130
1131       "PAD_SET_CUR_NOSAVE"
1132           like PAD_SET_CUR, but without the save
1133
1134            void  PAD_SET_CUR_NOSAVE(PADLIST padlist, I32 n)
1135
1136       "PAD_SV"
1137           Get the value at offset "po" in the current pad
1138
1139            SV *  PAD_SV(PADOFFSET po)
1140
1141       "PAD_SVl"
1142           Lightweight and lvalue version of "PAD_SV".  Get or set the value
1143           at offset "po" in the current pad.  Unlike "PAD_SV", does not print
1144           diagnostics with -DX.  For internal use only.
1145
1146            SV *  PAD_SVl(PADOFFSET po)
1147
1148       "SAVECLEARSV"
1149           Clear the pointed to pad value on scope exit.  (i.e. the runtime
1150           action of "my")
1151
1152            void  SAVECLEARSV(SV **svp)
1153
1154       "SAVECOMPPAD"
1155           save "PL_comppad" and "PL_curpad"
1156
1157            void  SAVECOMPPAD()
1158
1159       "SAVEPADSV"
1160           Save a pad slot (used to restore after an iteration)
1161
1162            void  SAVEPADSV(PADOFFSET po)
1163

Password and Group access

1165       There are only public API items currently in Password and Group access
1166

Paths to system commands

1168       There are only public API items currently in Paths to system commands
1169

Prototype information

1171       There are only public API items currently in Prototype information
1172

REGEXP Functions

1174       There are only public API items currently in REGEXP Functions
1175

Signals

1177       There are only public API items currently in Signals
1178

Site configuration

1180       There are only public API items currently in Site configuration
1181

Sockets configuration values

1183       There are only public API items currently in Sockets configuration
1184       values
1185

Source Filters

1187       There are only public API items currently in Source Filters
1188

Stack Manipulation Macros

1190       "djSP"
1191           Declare Just "SP".  This is actually identical to "dSP", and
1192           declares a local copy of perl's stack pointer, available via the
1193           "SP" macro.  See ""SP" in perlapi".  (Available for backward source
1194           code compatibility with the old (Perl 5.005) thread model.)
1195
1196              djSP();
1197
1198       "LVRET"
1199           True if this op will be the return value of an lvalue subroutine
1200

String Handling

1202       "delimcpy_no_escape"
1203           Copy a source buffer to a destination buffer, stopping at (but not
1204           including) the first occurrence in the source of the delimiter
1205           byte, "delim".  The source is the bytes between
1206           "from" and "from_end" - 1.  Similarly, the dest is "to" up to
1207           "to_end".
1208
1209           The number of bytes copied is written to *retlen.
1210
1211           Returns the position of "delim" in the "from" buffer, but if there
1212           is no such occurrence before "from_end", then "from_end" is
1213           returned, and the entire buffer "from" .. "from_end" - 1 is copied.
1214
1215           If there is room in the destination available after the copy, an
1216           extra terminating safety "NUL" byte is appended (not included in
1217           the returned length).
1218
1219           The error case is if the destination buffer is not large enough to
1220           accommodate everything that should be copied.  In this situation, a
1221           value larger than "to_end" - "to" is written to *retlen, and as
1222           much of the source as fits will be written to the destination.  Not
1223           having room for the safety "NUL" is not considered an error.
1224
1225            char*  delimcpy_no_escape(char* to, const char* to_end,
1226                                      const char* from, const char* from_end,
1227                                      const int delim, I32* retlen)
1228
1229       "quadmath_format_needed"
1230           "quadmath_format_needed()" returns true if the "format" string
1231           seems to contain at least one non-Q-prefixed "%[efgaEFGA]" format
1232           specifier, or returns false otherwise.
1233
1234           The format specifier detection is not complete printf-syntax
1235           detection, but it should catch most common cases.
1236
1237           If true is returned, those arguments should in theory be processed
1238           with "quadmath_snprintf()", but in case there is more than one such
1239           format specifier (see "quadmath_format_valid"), and if there is
1240           anything else beyond that one (even just a single byte), they
1241           cannot be processed because "quadmath_snprintf()" is very strict,
1242           accepting only one format spec, and nothing else.  In this case,
1243           the code should probably fail.
1244
1245            bool  quadmath_format_needed(const char* format)
1246
1247       "quadmath_format_valid"
1248           "quadmath_snprintf()" is very strict about its "format" string and
1249           will fail, returning -1, if the format is invalid.  It accepts
1250           exactly one format spec.
1251
1252           "quadmath_format_valid()" checks that the intended single spec
1253           looks sane: begins with "%", has only one "%", ends with
1254           "[efgaEFGA]", and has "Q" before it.  This is not a full "printf
1255           syntax check", just the basics.
1256
1257           Returns true if it is valid, false if not.
1258
1259           See also "quadmath_format_needed".
1260
1261            bool  quadmath_format_valid(const char* format)
1262

SV Flags

1264       "SVt_INVLIST"
1265           Type flag for scalars.  See "svtype" in perlapi.
1266

SV Handling

1268       "PL_Sv"
1269           A scratch pad SV for whatever temporary use you need.  Chiefly used
1270           as a fallback by macros on platforms where
1271           "PERL_USE_GCC_BRACE_GROUPS" in perlapi> is unavailable, and which
1272           would otherwise evaluate their SV parameter more than once.
1273
1274              PL_Sv
1275
1276       "sv_2bool"
1277           This macro is only used by "sv_true()" or its macro equivalent, and
1278           only if the latter's argument is neither "SvPOK", "SvIOK" nor
1279           "SvNOK".  It calls "sv_2bool_flags" with the "SV_GMAGIC" flag.
1280
1281            bool  sv_2bool(SV *const sv)
1282
1283       "sv_2bool_flags"
1284           This function is only used by "sv_true()" and friends,  and only if
1285           the latter's argument is neither "SvPOK", "SvIOK" nor "SvNOK".  If
1286           the flags contain "SV_GMAGIC", then it does an "mg_get()" first.
1287
1288            bool  sv_2bool_flags(SV *sv, I32 flags)
1289
1290       "sv_2num"
1291           NOTE: "sv_2num" is experimental and may change or be removed
1292           without notice.
1293
1294           Return an SV with the numeric value of the source SV, doing any
1295           necessary reference or overload conversion.  The caller is expected
1296           to have handled get-magic already.
1297
1298            SV*  sv_2num(SV *const sv)
1299
1300       "sv_2pvbyte_nolen"
1301           Return a pointer to the byte-encoded representation of the SV.  May
1302           cause the SV to be downgraded from UTF-8 as a side-effect.
1303
1304           Usually accessed via the "SvPVbyte_nolen" macro.
1305
1306            char*  sv_2pvbyte_nolen(SV* sv)
1307
1308       "sv_2pvutf8_nolen"
1309           Return a pointer to the UTF-8-encoded representation of the SV.
1310           May cause the SV to be upgraded to UTF-8 as a side-effect.
1311
1312           Usually accessed via the "SvPVutf8_nolen" macro.
1313
1314            char*  sv_2pvutf8_nolen(SV* sv)
1315
1316       "sv_2pv_flags"
1317           Returns a pointer to the string value of an SV, and sets *lp to its
1318           length.  If flags has the "SV_GMAGIC" bit set, does an "mg_get()"
1319           first.  Coerces "sv" to a string if necessary.  Normally invoked
1320           via the "SvPV_flags" macro.  "sv_2pv()" and "sv_2pv_nomg" usually
1321           end up here too.
1322
1323            char*  sv_2pv_flags(SV *const sv, STRLEN *const lp,
1324                                const U32 flags)
1325
1326       "sv_2pv_nolen"
1327           Like "sv_2pv()", but doesn't return the length too.  You should
1328           usually use the macro wrapper "SvPV_nolen(sv)" instead.
1329
1330            char*  sv_2pv_nolen(SV* sv)
1331
1332       "sv_add_arena"
1333           Given a chunk of memory, link it to the head of the list of arenas,
1334           and split it into a list of free SVs.
1335
1336            void  sv_add_arena(char *const ptr, const U32 size,
1337                               const U32 flags)
1338
1339       "sv_clean_all"
1340           Decrement the refcnt of each remaining SV, possibly triggering a
1341           cleanup.  This function may have to be called multiple times to
1342           free SVs which are in complex self-referential hierarchies.
1343
1344            I32  sv_clean_all()
1345
1346       "sv_clean_objs"
1347           Attempt to destroy all objects not yet freed.
1348
1349            void  sv_clean_objs()
1350
1351       "sv_free_arenas"
1352           Deallocate the memory used by all arenas.  Note that all the
1353           individual SV heads and bodies within the arenas must already have
1354           been freed.
1355
1356            void  sv_free_arenas()
1357
1358       "sv_grow"
1359           Expands the character buffer in the SV.  If necessary, uses
1360           "sv_unref" and upgrades the SV to "SVt_PV".  Returns a pointer to
1361           the character buffer.  Use the "SvGROW" wrapper instead.
1362
1363            char*  sv_grow(SV *const sv, STRLEN newlen)
1364
1365       "sv_iv"
1366           "DEPRECATED!"  It is planned to remove "sv_iv" from a future
1367           release of Perl.  Do not use it for new code; remove it from
1368           existing code.
1369
1370           A private implementation of the "SvIVx" macro for compilers which
1371           can't cope with complex macro expressions.  Always use the macro
1372           instead.
1373
1374            IV  sv_iv(SV* sv)
1375
1376       "sv_newref"
1377           Increment an SV's reference count.  Use the "SvREFCNT_inc()"
1378           wrapper instead.
1379
1380            SV*  sv_newref(SV *const sv)
1381
1382       "sv_nv"
1383           "DEPRECATED!"  It is planned to remove "sv_nv" from a future
1384           release of Perl.  Do not use it for new code; remove it from
1385           existing code.
1386
1387           A private implementation of the "SvNVx" macro for compilers which
1388           can't cope with complex macro expressions.  Always use the macro
1389           instead.
1390
1391            NV  sv_nv(SV* sv)
1392
1393       "sv_pv"
1394           Use the "SvPV_nolen" macro instead
1395
1396            char*  sv_pv(SV *sv)
1397
1398       "sv_pvbyte"
1399           Use "SvPVbyte_nolen" instead.
1400
1401            char*  sv_pvbyte(SV *sv)
1402
1403       "sv_pvbyten"
1404           "DEPRECATED!"  It is planned to remove "sv_pvbyten" from a future
1405           release of Perl.  Do not use it for new code; remove it from
1406           existing code.
1407
1408           A private implementation of the "SvPVbyte" macro for compilers
1409           which can't cope with complex macro expressions.  Always use the
1410           macro instead.
1411
1412            char*  sv_pvbyten(SV *sv, STRLEN *lp)
1413
1414       "sv_pvbyten_force"
1415           The backend for the "SvPVbytex_force" macro.  Always use the macro
1416           instead.  If the SV cannot be downgraded from UTF-8, this croaks.
1417
1418            char*  sv_pvbyten_force(SV *const sv, STRLEN *const lp)
1419
1420       "sv_pvn"
1421           "DEPRECATED!"  It is planned to remove "sv_pvn" from a future
1422           release of Perl.  Do not use it for new code; remove it from
1423           existing code.
1424
1425           A private implementation of the "SvPV" macro for compilers which
1426           can't cope with complex macro expressions.  Always use the macro
1427           instead.
1428
1429            char*  sv_pvn(SV *sv, STRLEN *lp)
1430
1431       "sv_pvn_force"
1432           Get a sensible string out of the SV somehow.  A private
1433           implementation of the "SvPV_force" macro for compilers which can't
1434           cope with complex macro expressions.  Always use the macro instead.
1435
1436            char*  sv_pvn_force(SV* sv, STRLEN* lp)
1437
1438       "sv_pvutf8"
1439           Use the "SvPVutf8_nolen" macro instead
1440
1441            char*  sv_pvutf8(SV *sv)
1442
1443       "sv_pvutf8n"
1444           "DEPRECATED!"  It is planned to remove "sv_pvutf8n" from a future
1445           release of Perl.  Do not use it for new code; remove it from
1446           existing code.
1447
1448           A private implementation of the "SvPVutf8" macro for compilers
1449           which can't cope with complex macro expressions.  Always use the
1450           macro instead.
1451
1452            char*  sv_pvutf8n(SV *sv, STRLEN *lp)
1453
1454       "sv_pvutf8n_force"
1455           The backend for the "SvPVutf8x_force" macro.  Always use the macro
1456           instead.
1457
1458            char*  sv_pvutf8n_force(SV *const sv, STRLEN *const lp)
1459
1460       "sv_taint"
1461           Taint an SV.  Use "SvTAINTED_on" instead.
1462
1463            void  sv_taint(SV* sv)
1464
1465       "sv_tainted"
1466           Test an SV for taintedness.  Use "SvTAINTED" instead.
1467
1468            bool  sv_tainted(SV *const sv)
1469
1470       "SvTHINKFIRST"
1471           A quick flag check to see whether an "sv" should be passed to
1472           "sv_force_normal" to be "downgraded" before "SvIVX" or "SvPVX" can
1473           be modified directly.
1474
1475           For example, if your scalar is a reference and you want to modify
1476           the "SvIVX" slot, you can't just do "SvROK_off", as that will leak
1477           the referent.
1478
1479           This is used internally by various sv-modifying functions, such as
1480           "sv_setsv", "sv_setiv" and "sv_pvn_force".
1481
1482           One case that this does not handle is a gv without SvFAKE set.
1483           After
1484
1485               if (SvTHINKFIRST(gv)) sv_force_normal(gv);
1486
1487           it will still be a gv.
1488
1489           "SvTHINKFIRST" sometimes produces false positives.  In those cases
1490           "sv_force_normal" does nothing.
1491
1492            U32  SvTHINKFIRST(SV *sv)
1493
1494       "sv_true"
1495           Returns true if the SV has a true value by Perl's rules.  Use the
1496           "SvTRUE" macro instead, which may call "sv_true()" or may instead
1497           use an in-line version.
1498
1499            I32  sv_true(SV *const sv)
1500
1501       "sv_untaint"
1502           Untaint an SV.  Use "SvTAINTED_off" instead.
1503
1504            void  sv_untaint(SV *const sv)
1505
1506       "sv_uv"
1507           "DEPRECATED!"  It is planned to remove "sv_uv" from a future
1508           release of Perl.  Do not use it for new code; remove it from
1509           existing code.
1510
1511           A private implementation of the "SvUVx" macro for compilers which
1512           can't cope with complex macro expressions.  Always use the macro
1513           instead.
1514
1515            UV  sv_uv(SV* sv)
1516

Time

1518       There are only public API items currently in Time
1519

Typedef names

1521       There are only public API items currently in Typedef names
1522

Unicode Support

1524       "bytes_from_utf8_loc"
1525           NOTE: "bytes_from_utf8_loc" is experimental and may change or be
1526           removed without notice.
1527
1528           Like ""bytes_from_utf8" in perlapi()", but takes an extra
1529           parameter, a pointer to where to store the location of the first
1530           character in "s" that cannot be converted to non-UTF8.
1531
1532           If that parameter is "NULL", this function behaves identically to
1533           "bytes_from_utf8".
1534
1535           Otherwise if *is_utf8p is 0 on input, the function behaves
1536           identically to "bytes_from_utf8", except it also sets
1537           *first_non_downgradable to "NULL".
1538
1539           Otherwise, the function returns a newly created "NUL"-terminated
1540           string containing the non-UTF8 equivalent of the convertible first
1541           portion of "s".  *lenp is set to its length, not including the
1542           terminating "NUL".  If the entire input string was converted,
1543           *is_utf8p is set to a FALSE value, and *first_non_downgradable is
1544           set to "NULL".
1545
1546           Otherwise, *first_non_downgradable is set to point to the first
1547           byte of the first character in the original string that wasn't
1548           converted.  *is_utf8p is unchanged.  Note that the new string may
1549           have length 0.
1550
1551           Another way to look at it is, if *first_non_downgradable is
1552           non-"NULL" and *is_utf8p is TRUE, this function starts at the
1553           beginning of "s" and converts as many characters in it as possible
1554           stopping at the first one it finds that can't be converted to
1555           non-UTF-8.  *first_non_downgradable is set to point to that.  The
1556           function returns the portion that could be converted in a newly
1557           created "NUL"-terminated string, and *lenp is set to its length,
1558           not including the terminating "NUL".  If the very first character
1559           in the original could not be converted, *lenp will be 0, and the
1560           new string will contain just a single "NUL".  If the entire input
1561           string was converted, *is_utf8p is set to FALSE and
1562           *first_non_downgradable is set to "NULL".
1563
1564           Upon successful return, the number of variants in the converted
1565           portion of the string can be computed by having saved the value of
1566           *lenp before the call, and subtracting the after-call value of
1567           *lenp from it.
1568
1569            U8*  bytes_from_utf8_loc(const U8 *s, STRLEN *lenp,
1570                                     bool *is_utf8p,
1571                                     const U8 ** first_unconverted)
1572
1573       "find_uninit_var"
1574           NOTE: "find_uninit_var" is experimental and may change or be
1575           removed without notice.
1576
1577           Find the name of the undefined variable (if any) that caused the
1578           operator to issue a "Use of uninitialized value" warning.  If match
1579           is true, only return a name if its value matches "uninit_sv".  So
1580           roughly speaking, if a unary operator (such as "OP_COS") generates
1581           a warning, then following the direct child of the op may yield an
1582           "OP_PADSV" or "OP_GV" that gives the name of the undefined
1583           variable.  On the other hand, with "OP_ADD" there are two branches
1584           to follow, so we only print the variable name if we get an exact
1585           match.  "desc_p" points to a string pointer holding the description
1586           of the op.  This may be updated if needed.
1587
1588           The name is returned as a mortal SV.
1589
1590           Assumes that "PL_op" is the OP that originally triggered the error,
1591           and that "PL_comppad"/"PL_curpad" points to the currently executing
1592           pad.
1593
1594            SV*  find_uninit_var(const OP *const obase,
1595                                 const SV *const uninit_sv, bool match,
1596                                 const char **desc_p)
1597
1598       "isSCRIPT_RUN"
1599           Returns a bool as to whether or not the sequence of bytes from "s"
1600           up to but not including "send" form a "script run".  "utf8_target"
1601           is TRUE iff the sequence starting at "s" is to be treated as UTF-8.
1602           To be precise, except for two degenerate cases given below, this
1603           function returns TRUE iff all code points in it come from any
1604           combination of three "scripts" given by the Unicode "Script
1605           Extensions" property: Common, Inherited, and possibly one other.
1606           Additionally all decimal digits must come from the same consecutive
1607           sequence of 10.
1608
1609           For example, if all the characters in the sequence are Greek, or
1610           Common, or Inherited, this function will return TRUE, provided any
1611           decimal digits in it are from the same block of digits in Common.
1612           (These are the ASCII digits "0".."9" and additionally a block for
1613           full width forms of these, and several others used in mathematical
1614           notation.)   For scripts (unlike Greek) that have their own digits
1615           defined this will accept either digits from that set or from one of
1616           the Common digit sets, but not a combination of the two.  Some
1617           scripts, such as Arabic, have more than one set of digits.  All
1618           digits must come from the same set for this function to return
1619           TRUE.
1620
1621           *ret_script, if "ret_script" is not NULL, will on return of TRUE
1622           contain the script found, using the "SCX_enum" typedef.  Its value
1623           will be "SCX_INVALID" if the function returns FALSE.
1624
1625           If the sequence is empty, TRUE is returned, but *ret_script (if
1626           asked for) will be "SCX_INVALID".
1627
1628           If the sequence contains a single code point which is unassigned to
1629           a character in the version of Unicode being used, the function will
1630           return TRUE, and the script will be "SCX_Unknown".  Any other
1631           combination of unassigned code points in the input sequence will
1632           result in the function treating the input as not being a script
1633           run.
1634
1635           The returned script will be "SCX_Inherited" iff all the code points
1636           in it are from the Inherited script.
1637
1638           Otherwise, the returned script will be "SCX_Common" iff all the
1639           code points in it are from the Inherited or Common scripts.
1640
1641            bool  isSCRIPT_RUN(const U8 *s, const U8 *send,
1642                               const bool utf8_target)
1643
1644       "is_utf8_non_invariant_string"
1645           Returns TRUE if "is_utf8_invariant_string" in perlapi returns FALSE
1646           for the first "len" bytes of the string "s", but they are,
1647           nonetheless, legal Perl-extended UTF-8; otherwise returns FALSE.
1648
1649           A TRUE return means that at least one code point represented by the
1650           sequence either is a wide character not representable as a single
1651           byte, or the representation differs depending on whether the
1652           sequence is encoded in UTF-8 or not.
1653
1654           See also ""is_utf8_invariant_string" in perlapi", ""is_utf8_string"
1655           in perlapi"
1656
1657            bool  is_utf8_non_invariant_string(const U8* const s, STRLEN len)
1658
1659       "report_uninit"
1660           Print appropriate "Use of uninitialized variable" warning.
1661
1662            void  report_uninit(const SV *uninit_sv)
1663
1664       "utf8n_to_uvuni"
1665           "DEPRECATED!"  It is planned to remove "utf8n_to_uvuni" from a
1666           future release of Perl.  Do not use it for new code; remove it from
1667           existing code.
1668
1669           Instead use "utf8_to_uvchr_buf" in perlapi, or rarely,
1670           "utf8n_to_uvchr" in perlapi.
1671
1672           This function was useful for code that wanted to handle both EBCDIC
1673           and ASCII platforms with Unicode properties, but starting in Perl
1674           v5.20, the distinctions between the platforms have mostly been made
1675           invisible to most code, so this function is quite unlikely to be
1676           what you want.  If you do need this precise functionality, use
1677           instead "NATIVE_TO_UNI(utf8_to_uvchr_buf(...))"  or
1678           "NATIVE_TO_UNI(utf8n_to_uvchr(...))".
1679
1680            UV  utf8n_to_uvuni(const U8 *s, STRLEN curlen, STRLEN *retlen,
1681                               U32 flags)
1682
1683       "utf8_to_uvuni"
1684           "DEPRECATED!"  It is planned to remove "utf8_to_uvuni" from a
1685           future release of Perl.  Do not use it for new code; remove it from
1686           existing code.
1687
1688           Returns the Unicode code point of the first character in the string
1689           "s" which is assumed to be in UTF-8 encoding; "retlen" will be set
1690           to the length, in bytes, of that character.
1691
1692           Some, but not all, UTF-8 malformations are detected, and in fact,
1693           some malformed input could cause reading beyond the end of the
1694           input buffer, which is one reason why this function is deprecated.
1695           The other is that only in extremely limited circumstances should
1696           the Unicode versus native code point be of any interest to you.
1697           See "utf8_to_uvuni_buf" for alternatives.
1698
1699           If "s" points to one of the detected malformations, and UTF8
1700           warnings are enabled, zero is returned and *retlen is set (if
1701           "retlen" doesn't point to NULL) to -1.  If those warnings are off,
1702           the computed value if well-defined (or the Unicode REPLACEMENT
1703           CHARACTER, if not) is silently returned, and *retlen is set (if
1704           "retlen" isn't NULL) so that ("s" + *retlen) is the next possible
1705           position in "s" that could begin a non-malformed character.  See
1706           "utf8n_to_uvchr" in perlapi for details on when the REPLACEMENT
1707           CHARACTER is returned.
1708
1709            UV  utf8_to_uvuni(const U8 *s, STRLEN *retlen)
1710
1711       "utf8_to_uvuni_buf"
1712           "DEPRECATED!"  It is planned to remove "utf8_to_uvuni_buf" from a
1713           future release of Perl.  Do not use it for new code; remove it from
1714           existing code.
1715
1716           Only in very rare circumstances should code need to be dealing in
1717           Unicode (as opposed to native) code points.  In those few cases,
1718           use "NATIVE_TO_UNI(utf8_to_uvchr_buf(...))" instead.  If you are
1719           not absolutely sure this is one of those cases, then assume it
1720           isn't and use plain "utf8_to_uvchr_buf" instead.
1721
1722           Returns the Unicode (not-native) code point of the first character
1723           in the string "s" which is assumed to be in UTF-8 encoding; "send"
1724           points to 1 beyond the end of "s".  "retlen" will be set to the
1725           length, in bytes, of that character.
1726
1727           If "s" does not point to a well-formed UTF-8 character and UTF8
1728           warnings are enabled, zero is returned and *retlen is set (if
1729           "retlen" isn't NULL) to -1.  If those warnings are off, the
1730           computed value if well-defined (or the Unicode REPLACEMENT
1731           CHARACTER, if not) is silently returned, and *retlen is set (if
1732           "retlen" isn't NULL) so that ("s" + *retlen) is the next possible
1733           position in "s" that could begin a non-malformed character.  See
1734           "utf8n_to_uvchr" in perlapi for details on when the REPLACEMENT
1735           CHARACTER is returned.
1736
1737            UV  utf8_to_uvuni_buf(const U8 *s, const U8 *send, STRLEN *retlen)
1738
1739       "uvoffuni_to_utf8_flags"
1740           THIS FUNCTION SHOULD BE USED IN ONLY VERY SPECIALIZED
1741           CIRCUMSTANCES.  Instead, Almost all code should use "uvchr_to_utf8"
1742           in perlapi or "uvchr_to_utf8_flags" in perlapi.
1743
1744           This function is like them, but the input is a strict Unicode (as
1745           opposed to native) code point.  Only in very rare circumstances
1746           should code not be using the native code point.
1747
1748           For details, see the description for "uvchr_to_utf8_flags" in
1749           perlapi.
1750
1751            U8*  uvoffuni_to_utf8_flags(U8 *d, UV uv, const UV flags)
1752
1753       "uvuni_to_utf8_flags"
1754           "DEPRECATED!"  It is planned to remove "uvuni_to_utf8_flags" from a
1755           future release of Perl.  Do not use it for new code; remove it from
1756           existing code.
1757
1758           Instead you almost certainly want to use "uvchr_to_utf8" in perlapi
1759           or "uvchr_to_utf8_flags" in perlapi.
1760
1761           This function is a deprecated synonym for "uvoffuni_to_utf8_flags",
1762           which itself, while not deprecated, should be used only in isolated
1763           circumstances.  These functions were useful for code that wanted to
1764           handle both EBCDIC and ASCII platforms with Unicode properties, but
1765           starting in Perl v5.20, the distinctions between the platforms have
1766           mostly been made invisible to most code, so this function is quite
1767           unlikely to be what you want.
1768
1769            U8*  uvuni_to_utf8_flags(U8 *d, UV uv, UV flags)
1770
1771       "valid_utf8_to_uvchr"
1772           Like ""utf8_to_uvchr_buf" in perlapi", but should only be called
1773           when it is known that the next character in the input UTF-8 string
1774           "s" is well-formed (e.g., it passes ""isUTF8_CHAR" in perlapi".
1775           Surrogates, non-character code points, and non-Unicode code points
1776           are allowed.
1777
1778            UV  valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen)
1779
1780       "variant_under_utf8_count"
1781           This function looks at the sequence of bytes between "s" and "e",
1782           which are assumed to be encoded in ASCII/Latin1, and returns how
1783           many of them would change should the string be translated into
1784           UTF-8.  Due to the nature of UTF-8, each of these would occupy two
1785           bytes instead of the single one in the input string.  Thus, this
1786           function returns the precise number of bytes the string would
1787           expand by when translated to UTF-8.
1788
1789           Unlike most of the other functions that have "utf8" in their name,
1790           the input to this function is NOT a UTF-8-encoded string.  The
1791           function name is slightly odd to emphasize this.
1792
1793           This function is internal to Perl because khw thinks that any XS
1794           code that would want this is probably operating too close to the
1795           internals.  Presenting a valid use case could change that.
1796
1797           See also ""is_utf8_invariant_string" in perlapi" and
1798           ""is_utf8_invariant_string_loc" in perlapi",
1799
1800            Size_t  variant_under_utf8_count(const U8* const s,
1801                                             const U8* const e)
1802

Utility Functions

1804       There are only public API items currently in Utility Functions
1805

Versioning

1807       There are only public API items currently in Versioning
1808

Warning and Dieing

1810       "PL_dowarn"
1811           The C variable that roughly corresponds to Perl's $^W warning
1812           variable.  However, $^W is treated as a boolean, whereas
1813           "PL_dowarn" is a collection of flag bits.
1814
1815           On threaded perls, each thread has an independent copy of this
1816           variable; each initialized at creation time with the current value
1817           of the creating thread's copy.
1818
1819            U8  PL_dowarn
1820

XS

1822       There are only public API items currently in XS
1823

Undocumented elements

1825       The following functions are currently undocumented.  If you use one of
1826       them, you may wish to consider creating and submitting documentation
1827       for it.
1828
1829        abort_execution
1830        add_cp_to_invlist
1831        _add_range_to_invlist
1832        alloc_LOGOP
1833        allocmy
1834        amagic_cmp
1835        amagic_cmp_desc
1836        amagic_cmp_locale
1837        amagic_cmp_locale_desc
1838        amagic_is_enabled
1839        amagic_i_ncmp
1840        amagic_i_ncmp_desc
1841        amagic_ncmp
1842        amagic_ncmp_desc
1843        append_utf8_from_native_byte
1844        apply
1845        ASCII_TO_NEED
1846        av_arylen_p
1847        av_extend_guts
1848        av_iter_p
1849        av_nonelem
1850        av_reify
1851        bind_match
1852        boot_core_mro
1853        boot_core_PerlIO
1854        boot_core_UNIVERSAL
1855        _byte_dump_string
1856        cando
1857        cast_i32
1858        cast_iv
1859        cast_ulong
1860        cast_uv
1861        check_utf8_print
1862        ck_anoncode
1863        ck_backtick
1864        ck_bitop
1865        ck_cmp
1866        ck_concat
1867        ck_defined
1868        ck_delete
1869        ck_each
1870        ck_entersub_args_core
1871        ck_eof
1872        ck_eval
1873        ck_exec
1874        ck_exists
1875        ck_ftst
1876        ck_fun
1877        ck_glob
1878        ck_grep
1879        ck_index
1880        ck_isa
1881        ck_join
1882        ck_length
1883        ck_lfun
1884        ck_listiob
1885        ck_match
1886        ck_method
1887        ck_null
1888        ck_open
1889        ck_prototype
1890        ck_readline
1891        ck_refassign
1892        ck_repeat
1893        ck_require
1894        ck_return
1895        ck_rfun
1896        ck_rvconst
1897        ck_sassign
1898        ck_select
1899        ck_shift
1900        ck_smartmatch
1901        ck_sort
1902        ck_spair
1903        ck_split
1904        ck_stringify
1905        ck_subr
1906        ck_substr
1907        ck_svconst
1908        ck_tell
1909        ck_trunc
1910        ck_trycatch
1911        ckwarn
1912        ckwarn_d
1913        closest_cop
1914        cmpchain_extend
1915        cmpchain_finish
1916        cmpchain_start
1917        cmp_desc
1918        cmp_locale_desc
1919        cntrl_to_mnemonic
1920        coresub_op
1921        create_eval_scope
1922        croak_caller
1923        croak_memory_wrap
1924        croak_no_mem
1925        croak_popstack
1926        csighandler
1927        csighandler1
1928        csighandler3
1929        current_re_engine
1930        custom_op_get_field
1931        cv_ckproto_len_flags
1932        cv_clone_into
1933        cv_const_sv_or_av
1934        cvgv_from_hek
1935        cvgv_set
1936        cvstash_set
1937        cv_undef_flags
1938        cx_dump
1939        cx_dup
1940        cxinc
1941        cx_popblock
1942        cx_popeval
1943        cx_popformat
1944        cx_popgiven
1945        cx_poploop
1946        cx_popsub
1947        cx_popsub_args
1948        cx_popsub_common
1949        cx_popwhen
1950        cx_pushblock
1951        cx_pusheval
1952        cx_pushformat
1953        cx_pushgiven
1954        cx_pushloop_for
1955        cx_pushloop_plain
1956        cx_pushsub
1957        cx_pushtry
1958        cx_pushwhen
1959        cx_topblock
1960        deb_stack_all
1961        defelem_target
1962        delete_eval_scope
1963        despatch_signals
1964        die_unwind
1965        do_aexec
1966        do_aexec5
1967        do_eof
1968        does_utf8_overflow
1969        do_exec
1970        do_exec3
1971        dofile
1972        do_gvgv_dump
1973        do_gv_dump
1974        do_hv_dump
1975        doing_taint
1976        do_ipcctl
1977        do_ipcget
1978        do_magic_dump
1979        do_msgrcv
1980        do_msgsnd
1981        do_ncmp
1982        do_open6
1983        do_open_raw
1984        do_op_dump
1985        do_pmop_dump
1986        do_print
1987        do_readline
1988        do_seek
1989        do_semop
1990        do_shmio
1991        do_sv_dump
1992        do_sysseek
1993        do_tell
1994        do_trans
1995        do_uniprop_match
1996        do_vecget
1997        do_vecset
1998        do_vop
1999        drand48_init_r
2000        drand48_r
2001        dtrace_probe_call
2002        dtrace_probe_load
2003        dtrace_probe_op
2004        dtrace_probe_phase
2005        dump_all_perl
2006        dump_indent
2007        dump_packsubs_perl
2008        dump_sub_perl
2009        dump_sv_child
2010        dump_vindent
2011        dup_warnings
2012        emulate_cop_io
2013        find_first_differing_byte_pos
2014        find_lexical_cv
2015        find_runcv_where
2016        find_script
2017        foldEQ_latin1
2018        foldEQ_latin1_s2_folded
2019        foldEQ_utf8_flags
2020        _force_out_malformed_utf8_message
2021        form_alien_digit_msg
2022        form_cp_too_large_msg
2023        free_tied_hv_pool
2024        free_tmps
2025        get_and_check_backslash_N_name
2026        get_db_sub
2027        get_debug_opts
2028        get_deprecated_property_msg
2029        getenv_len
2030        get_hash_seed
2031        get_invlist_iter_addr
2032        get_invlist_offset_addr
2033        get_invlist_previous_index_addr
2034        get_no_modify
2035        get_opargs
2036        get_prop_definition
2037        get_prop_values
2038        get_regclass_nonbitmap_data
2039        get_regex_charset_name
2040        get_re_arg
2041        get_re_gclass_nonbitmap_data
2042        gimme_V
2043        grok_bin_oct_hex
2044        grok_bslash_c
2045        grok_bslash_o
2046        grok_bslash_x
2047        gv_check
2048        gv_fetchmeth_internal
2049        gv_override
2050        gv_setref
2051        gv_stashpvn_internal
2052        hfree_next_entry
2053        hv_backreferences_p
2054        hv_common
2055        hv_common_key_len
2056        hv_kill_backrefs
2057        hv_placeholders_p
2058        hv_pushkv
2059        hv_undef_flags
2060        init_argv_symbols
2061        init_constants
2062        init_dbargs
2063        init_debugger
2064        init_i18nl10n
2065        init_i18nl14n
2066        init_named_cv
2067        init_uniprops
2068        _inverse_folds
2069        invert
2070        invlist_array
2071        invlist_clear
2072        invlist_clone
2073        invlist_contents
2074        _invlistEQ
2075        invlist_extend
2076        invlist_highest
2077        invlist_is_iterating
2078        invlist_iterfinish
2079        invlist_iterinit
2080        invlist_iternext
2081        invlist_lowest
2082        invlist_max
2083        invlist_previous_index
2084        invlist_set_len
2085        invlist_set_previous_index
2086        invlist_trim
2087        _invlist_array_init
2088        _invlist_contains_cp
2089        _invlist_dump
2090        _invlist_intersection
2091        _invlist_intersection_maybe_complement_2nd
2092        _invlist_invert
2093        _invlist_len
2094        _invlist_search
2095        _invlist_subtract
2096        _invlist_union
2097        _invlist_union_maybe_complement_2nd
2098        invmap_dump
2099        io_close
2100        isFF_OVERLONG
2101        is_grapheme
2102        is_invlist
2103        is_utf8_char_helper
2104        is_utf8_common
2105        is_utf8_overlong_given_start_byte_ok
2106        _is_cur_LC_category_utf8
2107        _is_in_locale_category
2108        _is_uni_FOO
2109        _is_uni_perl_idcont
2110        _is_uni_perl_idstart
2111        _is_utf8_FOO
2112        _is_utf8_perl_idcont
2113        _is_utf8_perl_idstart
2114        jmaybe
2115        keyword
2116        keyword_plugin_standard
2117        list
2118        load_charnames
2119        localize
2120        lossless_NV_to_IV
2121        magic_cleararylen_p
2122        magic_clearenv
2123        magic_clearisa
2124        magic_clearpack
2125        magic_clearsig
2126        magic_clear_all_env
2127        magic_copycallchecker
2128        magic_existspack
2129

AUTHORS

2131       The autodocumentation system was originally added to the Perl core by
2132       Benjamin Stuhl.  Documentation is by whoever was kind enough to
2133       document their functions.
2134

SEE ALSO

2136       config.h, perlapi, perlapio, perlcall, perlclib, perlfilter, perlguts,
2137       perlinterp, perliol, perlmroapi, perlreguts, perlxs
2138
2139
2140
2141perl v5.34.1                      2022-03-15                     PERLINTERN(1)
Impressum