1PERLINTERN(1) Perl Programmers Reference Guide PERLINTERN(1)
2
6 perlintern - autogenerated documentation of purely internal Perl
7 functions
8
10 This file is the autogenerated documentation of functions in the Perl
11 interpreter that are documented using Perl's internal documentation
12 format but are not marked as part of the Perl API. In other words,
13 they are not for use in extensions!
14 It has the same sections as perlapi, though some may be empty.
16
18 "av_fetch_simple"
19 This is a cut-down version of av_fetch that assumes that the array
20 is very straightforward - no magic, not readonly, and AvREAL - and
21 that "key" is not negative. This function MUST NOT be used in
22 situations where any of those assumptions may not hold.
23 Returns the SV at the specified index in the array. The "key" is
25 the index. If lval is true, you are guaranteed to get a real SV
26 back (in case it wasn't real before), which you can then modify.
27 Check that the return value is non-null before dereferencing it to
28 a "SV*".
29 The rough perl equivalent is $myarray[$key].
31 SV ** av_fetch_simple(AV *av, SSize_t key, I32 lval)
33 "AvFILLp"
35 If the array "av" is empty, this returns -1; otherwise it returns
36 the maximum value of the indices of all the array elements which
37 are currently defined in "av". It does not handle magic, hence the
38 "p" private indication in its name.
39 SSize_t AvFILLp(AV* av)
41 "av_new_alloc"
43 This implements ""newAV_alloc_x"" in perlapi and ""newAV_alloc_xz""
44 in perlapi, which are the public API for this functionality.
45 Creates a new AV and allocates its SV* array.
47 This is similar to, but more efficient than doing:
49 AV *av = newAV();
51 av_extend(av, key);
52 The size parameter is used to pre-allocate a SV* array large enough
54 to hold at least elements "0..(size-1)". "size" must be at least
55 1.
56 The "zeroflag" parameter controls whether or not the array is NULL
58 initialized.
59 AV * av_new_alloc(SSize_t size, bool zeroflag)
61 "av_store_simple"
63 This is a cut-down version of av_store that assumes that the array
64 is very straightforward - no magic, not readonly, and AvREAL - and
65 that "key" is not negative. This function MUST NOT be used in
66 situations where any of those assumptions may not hold.
67 Stores an SV in an array. The array index is specified as "key".
69 It can be dereferenced to get the "SV*" that was stored there (=
70 "val")).
71 Note that the caller is responsible for suitably incrementing the
73 reference count of "val" before the call.
74 Approximate Perl equivalent: "splice(@myarray, $key, 1, $val)".
76 SV ** av_store_simple(AV *av, SSize_t key, SV *val)
78
80 "dowantarray"
81 "DEPRECATED!" It is planned to remove "dowantarray" from a future
82 release of Perl. Do not use it for new code; remove it from
83 existing code.
84 Implements the deprecated ""GIMME"" in perlapi.
86 U8 dowantarray()
88 "leave_scope"
90 Implements "LEAVE_SCOPE" which you should use instead.
91 void leave_scope(I32 base)
93 "magic_freedestruct"
95 This function is called via magic to implement the
96 mortal_destructor_sv() and mortal_destructor_x() functions. It
97 should not be called directly and has no user servicable parts.
98 int magic_freedestruct(SV *sv, MAGIC *mg)
100 "mortal_svfunc_x"
102 This function arranges for a C function reference to be called at
103 the end of the current statement with the arguments provided. It is
104 a wrapper around mortal_destructor_sv() which ensures that the
105 latter function is called appropriately.
106 Be aware that there is a signficant difference in timing between
108 the end of the current statement and the end of the current pseudo
109 block. If you are looking for a mechanism to trigger a function at
110 the end of the current pseudo block you should look at
111 SAVEDESTRUCTORX() instead of this function.
112 void mortal_svfunc_x(SVFUNC_t f, SV *p)
114 "pop_scope"
116 Implements ""LEAVE"" in perlapi
117 void pop_scope()
119 "push_scope"
121 Implements ""ENTER"" in perlapi
122 void push_scope()
124 "save_adelete"
126 Implements "SAVEADELETE".
127 void save_adelete(AV *av, SSize_t key)
129 "save_freercpv"
131 Implements "SAVEFREERCPV".
132 Saves and frees a refcounted string. Calls rcpv_free() on the
134 argument when the current pseudo block is finished.
135 void save_freercpv(char *rcpv)
137 "save_generic_pvref"
139 Implements "SAVEGENERICPV".
140 Like save_pptr(), but also Safefree()s the new value if it is
142 different from the old one. Can be used to restore a global char*
143 to its prior contents, freeing new value.
144 void save_generic_pvref(char **str)
146 "save_generic_svref"
148 Implements "SAVEGENERICSV".
149 Like save_sptr(), but also SvREFCNT_dec()s the new value. Can be
151 used to restore a global SV to its prior contents, freeing new
152 value.
153 void save_generic_svref(SV **sptr)
155 "save_hdelete"
157 Implements "SAVEHDELETE".
158 void save_hdelete(HV *hv, SV *keysv)
160 "save_hints"
162 Implements "SAVEHINTS".
163 void save_hints()
165 "save_op"
167 Implements "SAVEOP".
168 void save_op()
170 "save_padsv_and_mortalize"
172 Implements "SAVEPADSVANDMORTALIZE".
173 void save_padsv_and_mortalize(PADOFFSET off)
175 "save_pushptr"
177 The refcnt of object "ptr" will be decremented at the end of the
178 current pseudo-block. "type" gives the type of "ptr", expressed as
179 one of the constants in scope.h whose name begins with "SAVEt_".
180 This is the underlying implementation of several macros, like
182 "SAVEFREESV".
183 void save_pushptr(void * const ptr, const int type)
185 "save_rcpv"
187 Implements "SAVERCPV".
188 Saves and restores a refcounted string, similar to what
190 save_generic_svref would do for a SV*. Can be used to restore a
191 refcounted string to its previous state. Performs the appropriate
192 refcount counting so that nothing should leak or be prematurely
193 freed.
194 void save_rcpv(char **prcpv)
196 "save_scalar_at"
198 A helper function for localizing the SV referenced by *sptr.
199 If "SAVEf_KEEPOLDELEM" is set in in "flags", the function returns
201 the input scalar untouched.
202 Otherwise it replaces *sptr with a new "undef" scalar, and returns
204 that. The new scalar will have the old one's magic (if any) copied
205 to it. If there is such magic, and "SAVEf_SETMAGIC" is set in in
206 "flags", 'set' magic will be processed on the new scalar. If
207 unset, 'set' magic will be skipped. The latter typically means
208 that assignment will soon follow (e.g., 'local $x = $y'), and that
209 will handle the magic.
210 SV * save_scalar_at(SV **sptr, const U32 flags)
212 "save_set_svflags"
214 Implements "SAVESETSVFLAGS".
215 Set the SvFLAGS specified by mask to the values in val
217 void save_set_svflags(SV *sv, U32 mask, U32 val)
219 "save_shared_pvref"
221 Implements "SAVESHAREDPV".
222 Like save_generic_pvref(), but uses PerlMemShared_free() rather
224 than Safefree(). Can be used to restore a shared global char* to
225 its prior contents, freeing new value.
226 void save_shared_pvref(char **str)
228 "save_vptr"
230 Implements "SAVEVPTR".
231 void save_vptr(void *ptr)
233
235 There are currently no internal API items in Casting
236
238 There are currently no internal API items in Character case changing
239
241 There are currently no internal API items in Character classification
242
244 There are currently no internal API items in Compiler and Preprocessor
245 information
246
248 There are currently no internal API items in Compiler directives
249
251 "BhkENTRY"
252 NOTE: "BhkENTRY" is experimental and may change or be removed
253 without notice.
254 Return an entry from the BHK structure. "which" is a preprocessor
256 token indicating which entry to return. If the appropriate flag is
257 not set this will return "NULL". The type of the return value
258 depends on which entry you ask for.
259 void * BhkENTRY(BHK *hk, token which)
261 "BhkFLAGS"
263 NOTE: "BhkFLAGS" is experimental and may change or be removed
264 without notice.
265 Return the BHK's flags.
267 U32 BhkFLAGS(BHK *hk)
269 "CALL_BLOCK_HOOKS"
271 NOTE: "CALL_BLOCK_HOOKS" is experimental and may change or be
272 removed without notice.
273 Call all the registered block hooks for type "which". "which" is a
275 preprocessing token; the type of "arg" depends on "which".
276 void CALL_BLOCK_HOOKS(token which, arg)
278
280 "CVf_SLABBED"
281 "CvROOT"
282 "CvSTART"
283 Described in perlguts.
284 "CX_CUR"
286 Described in perlguts.
287 CX_CUR()
289 "CXINC"
291 Described in perlguts.
292 "CX_LEAVE_SCOPE"
294 Described in perlguts.
295 void CX_LEAVE_SCOPE(PERL_CONTEXT* cx)
297 "CX_POP"
299 Described in perlguts.
300 void CX_POP(PERL_CONTEXT* cx)
302 "cxstack"
304 Described in perlguts.
305 "cxstack_ix"
307 Described in perlguts.
308 "CXt_BLOCK"
310 "CXt_EVAL"
311 "CXt_FORMAT"
312 "CXt_GIVEN"
313 "CXt_LOOP_ARY"
314 "CXt_LOOP_LAZYIV"
315 "CXt_LOOP_LAZYSV"
316 "CXt_LOOP_LIST"
317 "CXt_LOOP_PLAIN"
318 "CXt_NULL"
319 "CXt_SUB"
320 "CXt_SUBST"
321 "CXt_WHEN"
322 Described in perlguts.
323 "cx_type"
325 Described in perlguts.
326 "dounwind"
328 Described in perlguts.
329 void dounwind(I32 cxix)
331 "my_fork"
333 This is for the use of "PerlProc_fork" as a wrapper for the C
334 library fork(2) on some platforms to hide some platform quirks. It
335 should not be used except through "PerlProc_fork".
336 Pid_t my_fork()
338 "PERL_CONTEXT"
340 Described in perlguts.
341
343 There are currently no internal API items in COPs and Hint Hashes
344
346 "core_prototype"
347 This function assigns the prototype of the named core function to
348 "sv", or to a new mortal SV if "sv" is "NULL". It returns the
349 modified "sv", or "NULL" if the core function has no prototype.
350 "code" is a code as returned by keyword(). It must not be equal to
351 0.
352 SV * core_prototype(SV *sv, const char *name, const int code,
354 int * const opnum)
355
357 "CvREFCOUNTED_ANYSV"
358 If true, indicates that the "CvXSUBANY(cv).any_sv" member contains
359 an SV pointer whose reference count should be decremented when the
360 CV itself is freed. In addition, cv_clone() will increment the
361 reference count, and sv_dup() will duplicate the entire pointed-to
362 SV if this flag is set.
363 Any CV that wraps an XSUB has an "ANY" union that the XSUB function
365 is free to use for its own purposes. It may be the case that the
366 code wishes to store an SV in the "any_sv" member of this union.
367 By setting this flag, this SV reference will be properly reclaimed
368 or duplicated when the CV itself is.
369 bool CvREFCOUNTED_ANYSV(CV *cv)
371 "CvREFCOUNTED_ANYSV_off"
373 Helper macro to turn off the "CvREFCOUNTED_ANYSV" flag.
374 void CvREFCOUNTED_ANYSV_off(CV *cv)
376 "CvREFCOUNTED_ANYSV_on"
378 Helper macro to turn on the "CvREFCOUNTED_ANYSV" flag.
379 void CvREFCOUNTED_ANYSV_on(CV *cv)
381 "CvWEAKOUTSIDE"
383 Each CV has a pointer, CvOUTSIDE(), to its lexically enclosing CV
384 (if any). Because pointers to anonymous sub prototypes are stored
385 in "&" pad slots, it is a possible to get a circular reference,
386 with the parent pointing to the child and vice-versa. To avoid the
387 ensuing memory leak, we do not increment the reference count of the
388 CV pointed to by "CvOUTSIDE" in the one specific instance that the
389 parent has a "&" pad slot pointing back to us. In this case, we
390 set the "CvWEAKOUTSIDE" flag in the child. This allows us to
391 determine under what circumstances we should decrement the refcount
392 of the parent when freeing the child.
393 There is a further complication with non-closure anonymous subs
395 (i.e. those that do not refer to any lexicals outside that sub).
396 In this case, the anonymous prototype is shared rather than being
397 cloned. This has the consequence that the parent may be freed
398 while there are still active children, e.g.,
399 BEGIN { $a = sub { eval '$x' } }
401 In this case, the BEGIN is freed immediately after execution since
403 there are no active references to it: the anon sub prototype has
404 "CvWEAKOUTSIDE" set since it's not a closure, and $a points to the
405 same CV, so it doesn't contribute to BEGIN's refcount either. When
406 $a is executed, the "eval '$x'" causes the chain of "CvOUTSIDE"s to
407 be followed, and the freed BEGIN is accessed.
408 To avoid this, whenever a CV and its associated pad is freed, any
410 "&" entries in the pad are explicitly removed from the pad, and if
411 the refcount of the pointed-to anon sub is still positive, then
412 that child's "CvOUTSIDE" is set to point to its grandparent. This
413 will only occur in the single specific case of a non-closure anon
414 prototype having one or more active references (such as $a above).
415 One other thing to consider is that a CV may be merely undefined
417 rather than freed, eg "undef &foo". In this case, its refcount may
418 not have reached zero, but we still delete its pad and its "CvROOT"
419 etc. Since various children may still have their "CvOUTSIDE"
420 pointing at this undefined CV, we keep its own "CvOUTSIDE" for the
421 time being, so that the chain of lexical scopes is unbroken. For
422 example, the following should print 123:
423 my $x = 123;
425 sub tmp { sub { eval '$x' } }
426 my $a = tmp();
427 undef &tmp;
428 print $a->();
429 bool CvWEAKOUTSIDE(CV *cv)
431 "docatch"
433 Interpose, for the current op and RUNOPS loop,
434 - a new JMPENV stack catch frame, and
436 - an inner RUNOPS loop to run all the remaining ops following the
437 current PL_op.
438 Then handle any exceptions raised while in that loop. For a caught
440 eval at this level, re-enter the loop with the specified restart op
441 (i.e. the op following the OP_LEAVETRY etc); otherwise re-throw the
442 exception.
443 docatch() is intended to be used like this:
445 PP(pp_entertry)
447 {
448 if (CATCH_GET)
449 return docatch(Perl_pp_entertry);
450 ... rest of function ...
452 return PL_op->op_next;
453 }
454 If a new catch frame isn't needed, the op behaves normally.
456 Otherwise it calls docatch(), which recursively calls
457 pp_entertry(), this time with CATCH_GET() false, so the rest of the
458 body of the entertry is run. Then docatch() calls CALLRUNOPS()
459 which executes all the ops following the entertry. When the loop
460 finally finishes, control returns to docatch(), which pops the
461 JMPENV and returns to the parent pp_entertry(), which itself
462 immediately returns. Note that *all* subsequent ops are run within
463 the inner RUNOPS loop, not just the body of the eval. For example,
464 in
465 sub TIEARRAY { eval {1}; my $x }
467 tie @a, "main";
468 at the point the 'my' is executed, the C stack will look something
470 like:
471 #10 main()
473 #9 perl_run() # JMPENV_PUSH level 1 here
474 #8 S_run_body()
475 #7 Perl_runops_standard() # main RUNOPS loop
476 #6 Perl_pp_tie()
477 #5 Perl_call_sv()
478 #4 Perl_runops_standard() # unguarded RUNOPS loop: no new JMPENV
479 #3 Perl_pp_entertry()
480 #2 S_docatch() # JMPENV_PUSH level 2 here
481 #1 Perl_runops_standard() # docatch()'s RUNOPs loop
482 #0 Perl_pp_padsv()
483 Basically, any section of the perl core which starts a RUNOPS loop
485 may make a promise that it will catch any exceptions and restart
486 the loop if necessary. If it's not prepared to do that (like
487 call_sv() isn't), then it sets CATCH_GET() to true, so that any
488 later eval-like code knows to set up a new handler and loop (via
489 docatch()).
490 See "Exception handing" in perlinterp for further details.
492 OP * docatch(Perl_ppaddr_t firstpp)
494
496 "comma_aDEPTH"
497 Some functions when compiled under DEBUGGING take an extra final
498 argument named "depth", indicating the C stack depth. This
499 argument is omitted otherwise. This macro expands to either
500 ", depth" under DEBUGGING, or to nothing at all when not under
501 DEBUGGING, reducing the number of "#ifdef"'s in the code.
502 The program is responsible for maintaining the correct value for
504 "depth".
505 comma_aDEPTH
507 "comma_pDEPTH"
509 This is used in the prototype declarations for functions that take
510 a ""comma_aDEPTH"" final parameter, much like "pTHX_" is used in
511 functions that take a thread context initial parameter.
512 "debop"
514 Implements -Dt perl command line option on OP "o".
515 I32 debop(const OP *o)
517 "debprof"
519 Called to indicate that "o" was executed, for profiling purposes
520 under the "-DP" command line option.
521 void debprof(const OP *o)
523 "debprofdump"
525 Dumps the contents of the data collected by the "-DP" perl command
526 line option.
527 void debprofdump()
529 "debug_aDEPTH"
531 Same as ""comma_aDEPTH"" but with no leading argument. Intended for
532 functions with no normal arguments, and used by ""comma_aDEPTH""
533 itself.
534 debug_aDEPTH
536 "debug_pDEPTH"
538 Same as ""comma_pDEPTH"" but with no leading argument. Intended for
539 functions with no normal arguments, and used by ""comma_pDEPTH""
540 itself.
541 debug_pDEPTH
543 "free_c_backtrace"
545 Deallocates a backtrace received from get_c_backtrace.
546 void free_c_backtrace(Perl_c_backtrace *bt)
548 "get_c_backtrace"
550 Collects the backtrace (aka "stacktrace") into a single linear
551 malloced buffer, which the caller must Perl_free_c_backtrace().
552 Scans the frames back by "depth + skip", then drops the "skip"
554 innermost, returning at most "depth" frames.
555 Perl_c_backtrace * get_c_backtrace(int max_depth, int skip)
557 "PL_DBsingle"
559 When Perl is run in debugging mode, with the -d switch, this SV is
560 a boolean which indicates whether subs are being single-stepped.
561 Single-stepping is automatically turned on after every step. This
562 is the C variable which corresponds to Perl's $DB::single variable.
563 See "PL_DBsub".
564 On threaded perls, each thread has an independent copy of this
566 variable; each initialized at creation time with the current value
567 of the creating thread's copy.
568 SV * PL_DBsingle
570 "PL_DBsub"
572 When Perl is run in debugging mode, with the -d switch, this GV
573 contains the SV which holds the name of the sub being debugged.
574 This is the C variable which corresponds to Perl's $DB::sub
575 variable. See "PL_DBsingle".
576 On threaded perls, each thread has an independent copy of this
578 variable; each initialized at creation time with the current value
579 of the creating thread's copy.
580 GV * PL_DBsub
582 "PL_DBtrace"
584 Trace variable used when Perl is run in debugging mode, with the -d
585 switch. This is the C variable which corresponds to Perl's
586 $DB::trace variable. See "PL_DBsingle".
587 On threaded perls, each thread has an independent copy of this
589 variable; each initialized at creation time with the current value
590 of the creating thread's copy.
591 SV * PL_DBtrace
593 "runops_debug"
595 Described in perlguts.
596 int runops_debug()
598 "runops_standard"
600 Described in perlguts.
601 int runops_standard()
603
605 "sv_peek"
606 Implements "SvPEEK"
607 char * sv_peek(SV *sv)
609
611 "cv_dump"
612 dump the contents of a CV
613 void cv_dump(const CV *cv, const char *title)
615 "cv_forget_slab"
617 When a CV has a reference count on its slab ("CvSLABBED"), it is
618 responsible for making sure it is freed. (Hence, no two CVs should
619 ever have a reference count on the same slab.) The CV only needs
620 to reference the slab during compilation. Once it is compiled and
621 "CvROOT" attached, it has finished its job, so it can forget the
622 slab.
623 void cv_forget_slab(CV *cv)
625 "do_dump_pad"
627 Dump the contents of a padlist
628 void do_dump_pad(I32 level, PerlIO *file, PADLIST *padlist,
630 int full)
631 "get_context"
633 Implements ""PERL_GET_CONTEXT"" in perlapi, which you should use
634 instead.
635 void * get_context()
637 "pad_alloc_name"
639 Allocates a place in the currently-compiling pad (via "pad_alloc"
640 in perlapi) and then stores a name for that entry. "name" is
641 adopted and becomes the name entry; it must already contain the
642 name string. "typestash" and "ourstash" and the "padadd_STATE"
643 flag get added to "name". None of the other processing of
644 "pad_add_name_pvn" in perlapi is done. Returns the offset of the
645 allocated pad slot.
646 PADOFFSET pad_alloc_name(PADNAME *name, U32 flags, HV *typestash,
648 HV *ourstash)
649 "pad_block_start"
651 Update the pad compilation state variables on entry to a new block.
652 void pad_block_start(int full)
654 "pad_check_dup"
656 Check for duplicate declarations: report any of:
657 * a 'my' in the current scope with the same name;
659 * an 'our' (anywhere in the pad) with the same name and the
660 same stash as 'ourstash'
661 "is_our" indicates that the name to check is an "our" declaration.
663 void pad_check_dup(PADNAME *name, U32 flags, const HV *ourstash)
665 "pad_findlex"
667 Find a named lexical anywhere in a chain of nested pads. Add fake
668 entries in the inner pads if it's found in an outer one.
669 Returns the offset in the bottom pad of the lex or the fake lex.
671 "cv" is the CV in which to start the search, and seq is the current
672 "cop_seq" to match against. If "warn" is true, print appropriate
673 warnings. The "out_"* vars return values, and so are pointers to
674 where the returned values should be stored. "out_capture", if non-
675 null, requests that the innermost instance of the lexical is
676 captured; "out_name" is set to the innermost matched pad name or
677 fake pad name; "out_flags" returns the flags normally associated
678 with the "PARENT_FAKELEX_FLAGS" field of a fake pad name.
679 Note that pad_findlex() is recursive; it recurses up the chain of
681 CVs, then comes back down, adding fake entries as it goes. It has
682 to be this way because fake names in anon prototypes have to store
683 in "xpadn_low" the index into the parent pad.
684 PADOFFSET pad_findlex(const char *namepv, STRLEN namelen,
686 U32 flags, const CV *cv, U32 seq, int warn,
687 SV **out_capture, PADNAME **out_name,
688 int *out_flags)
689 "pad_fixup_inner_anons"
691 For any anon CVs in the pad, change "CvOUTSIDE" of that CV from
692 "old_cv" to "new_cv" if necessary. Needed when a newly-compiled CV
693 has to be moved to a pre-existing CV struct.
694 void pad_fixup_inner_anons(PADLIST *padlist, CV *old_cv,
696 CV *new_cv)
697 "pad_free"
699 Free the SV at offset po in the current pad.
700 void pad_free(PADOFFSET po)
702 "pad_leavemy"
704 Cleanup at end of scope during compilation: set the max seq number
705 for lexicals in this scope and warn of any lexicals that never got
706 introduced.
707 OP * pad_leavemy()
709 "padlist_dup"
711 Duplicates a pad.
712 PADLIST * padlist_dup(PADLIST *srcpad, CLONE_PARAMS *param)
714 "padname_dup"
716 Duplicates a pad name.
717 PADNAME * padname_dup(PADNAME *src, CLONE_PARAMS *param)
719 "padnamelist_dup"
721 Duplicates a pad name list.
722 PADNAMELIST * padnamelist_dup(PADNAMELIST *srcpad,
724 CLONE_PARAMS *param)
725 "pad_push"
727 Push a new pad frame onto the padlist, unless there's already a pad
728 at this depth, in which case don't bother creating a new one. Then
729 give the new pad an @_ in slot zero.
730 void pad_push(PADLIST *padlist, int depth)
732 "pad_reset"
734 Mark all the current temporaries for reuse
735 void pad_reset()
737 "pad_setsv"
739 Set the value at offset "po" in the current (compiling or
740 executing) pad. Use the macro PAD_SETSV() rather than calling this
741 function directly.
742 void pad_setsv(PADOFFSET po, SV *sv)
744 "pad_sv"
746 Get the value at offset "po" in the current (compiling or
747 executing) pad. Use macro "PAD_SV" instead of calling this
748 function directly.
749 SV * pad_sv(PADOFFSET po)
751 "pad_swipe"
753 Abandon the tmp in the current pad at offset "po" and replace with
754 a new one.
755 void pad_swipe(PADOFFSET po, bool refadjust)
757 "set_context"
759 Implements ""PERL_SET_CONTEXT"" in perlapi, which you should use
760 instead.
761 void set_context(void *t)
763 "si_dup"
765 Duplicate a stack info structure, returning a pointer to the cloned
766 object.
767 PERL_SI * si_dup(PERL_SI *si, CLONE_PARAMS *param)
769 "ss_dup"
771 Duplicate the save stack, returning a pointer to the cloned object.
772 ANY * ss_dup(PerlInterpreter *proto_perl, CLONE_PARAMS *param)
774
776 "dSAVEDERRNO"
777 Declare variables needed to save "errno" and any operating system
778 specific error number.
779 void dSAVEDERRNO
781 "dSAVE_ERRNO"
783 Declare variables needed to save "errno" and any operating system
784 specific error number, and save them for optional later restoration
785 by "RESTORE_ERRNO".
786 void dSAVE_ERRNO
788 "RESTORE_ERRNO"
790 Restore "errno" and any operating system specific error number that
791 was saved by "dSAVE_ERRNO" or "RESTORE_ERRNO".
792 void RESTORE_ERRNO
794 "SAVE_ERRNO"
796 Save "errno" and any operating system specific error number for
797 optional later restoration by "RESTORE_ERRNO". Requires
798 "dSAVEDERRNO" or "dSAVE_ERRNO" in scope.
799 void SAVE_ERRNO
801 "SETERRNO"
803 Set "errno", and on VMS set "vaxc$errno".
804 void SETERRNO(int errcode, int vmserrcode)
806
808 There are currently no internal API items in Exception Handling
809 (simple) Macros
810
812 There are currently no internal API items in Filesystem configuration
813 values
814
816 There are currently no internal API items in Floating point
817
819 There are currently no internal API items in General Configuration
820
822 There are currently no internal API items in Global Variables
823
825 "amagic_applies"
826 Check "sv" to see if the overloaded (active magic) operation
827 "method" applies to it. If the sv is not SvROK or it is not an
828 object then returns false, otherwise checks if the object is
829 blessed into a class supporting overloaded operations, and returns
830 true if a call to amagic_call() with this SV and the given method
831 would trigger an amagic operation, including via the overload
832 fallback rules or via nomethod. Thus a call like:
833 amagic_applies(sv, string_amg, AMG_unary)
835 would return true for an object with overloading set up in any of
837 the following ways:
838 use overload q("") => sub { ... };
840 use overload q(0+) => sub { ... }, fallback => 1;
841 and could be used to tell if a given object would stringify to
843 something other than the normal default ref stringification.
844 Note that the fact that this function returns TRUE does not mean
846 you can succesfully perform the operation with amagic_call(), for
847 instance any overloaded method might throw a fatal exception,
848 however if this function returns FALSE you can be confident that it
849 will NOT perform the given overload operation.
850 "method" is an integer enum, one of the values found in overload.h,
852 for instance "string_amg".
853 "flags" should be set to AMG_unary for unary operations.
855 bool amagic_applies(SV *sv, int method, int flags)
857 "gp_dup"
859 Duplicate a typeglob, returning a pointer to the cloned object.
860 GP * gp_dup(GP * const gp, CLONE_PARAMS * const param)
862 "gv_handler"
864 Implements "StashHANDLER", which you should use instead
865 CV * gv_handler(HV *stash, I32 id)
867 "gv_stashsvpvn_cached"
869 Returns a pointer to the stash for a specified package, possibly
870 cached. Implements both ""gv_stashpvn"" in perlapi and
871 ""gv_stashsv"" in perlapi.
872 Requires one of either "namesv" or "namepv" to be non-null.
874 If the flag "GV_CACHE_ONLY" is set, return the stash only if found
876 in the cache; see ""gv_stashpvn"" in perlapi for details on the
877 other "flags".
878 Note it is strongly preferred for "namesv" to be non-null, for
880 performance reasons.
881 HV * gv_stashsvpvn_cached(SV *namesv, const char *name,
883 U32 namelen, I32 flags)
884 "gv_try_downgrade"
886 NOTE: "gv_try_downgrade" is experimental and may change or be
887 removed without notice.
888 If the typeglob "gv" can be expressed more succinctly, by having
890 something other than a real GV in its place in the stash, replace
891 it with the optimised form. Basic requirements for this are that
892 "gv" is a real typeglob, is sufficiently ordinary, and is only
893 referenced from its package. This function is meant to be used
894 when a GV has been looked up in part to see what was there, causing
895 upgrading, but based on what was found it turns out that the real
896 GV isn't required after all.
897 If "gv" is a completely empty typeglob, it is deleted from the
899 stash.
900 If "gv" is a typeglob containing only a sufficiently-ordinary
902 constant sub, the typeglob is replaced with a scalar-reference
903 placeholder that more compactly represents the same thing.
904 void gv_try_downgrade(GV *gv)
906
908 There are currently no internal API items in Hook manipulation
909
911 "hv_eiter_p"
912 Implements "HvEITER" which you should use instead.
913 NOTE: "hv_eiter_p" must be explicitly called as "Perl_hv_eiter_p"
915 with an "aTHX_" parameter.
916 HE ** Perl_hv_eiter_p(pTHX_ HV *hv)
918 "hv_eiter_set"
920 Implements "HvEITER_set" which you should use instead.
921 NOTE: "hv_eiter_set" must be explicitly called as
923 "Perl_hv_eiter_set" with an "aTHX_" parameter.
924 void Perl_hv_eiter_set(pTHX_ HV *hv, HE *eiter)
926 "hv_ename_add"
928 Adds a name to a stash's internal list of effective names. See
929 "hv_ename_delete".
930 This is called when a stash is assigned to a new location in the
932 symbol table.
933 void hv_ename_add(HV *hv, const char *name, U32 len, U32 flags)
935 "hv_ename_delete"
937 Removes a name from a stash's internal list of effective names. If
938 this is the name returned by "HvENAME", then another name in the
939 list will take its place ("HvENAME" will use it).
940 This is called when a stash is deleted from the symbol table.
942 void hv_ename_delete(HV *hv, const char *name, U32 len,
944 U32 flags)
945 "hv_fill"
947 Returns the number of hash buckets that happen to be in use.
948 This function implements the "HvFILL" macro which you should use
950 instead.
951 As of perl 5.25 this function is used only for debugging purposes,
953 and the number of used hash buckets is not in any way cached, thus
954 this function can be costly to execute as it must iterate over all
955 the buckets in the hash.
956 NOTE: "hv_fill" must be explicitly called as "Perl_hv_fill" with an
958 "aTHX_" parameter.
959 STRLEN Perl_hv_fill(pTHX_ HV * const hv)
961 "hv_placeholders_get"
963 Implements "HvPLACEHOLDERS_get", which you should use instead.
964 NOTE: "hv_placeholders_get" must be explicitly called as
966 "Perl_hv_placeholders_get" with an "aTHX_" parameter.
967 I32 Perl_hv_placeholders_get(pTHX_ const HV *hv)
969 "hv_placeholders_set"
971 Implements "HvPLACEHOLDERS_set", which you should use instead.
972 NOTE: "hv_placeholders_set" must be explicitly called as
974 "Perl_hv_placeholders_set" with an "aTHX_" parameter.
975 void Perl_hv_placeholders_set(pTHX_ HV *hv, I32 ph)
977 "hv_riter_p"
979 Implements "HvRITER" which you should use instead.
980 NOTE: "hv_riter_p" must be explicitly called as "Perl_hv_riter_p"
982 with an "aTHX_" parameter.
983 I32 * Perl_hv_riter_p(pTHX_ HV *hv)
985 "hv_riter_set"
987 Implements "HvRITER_set" which you should use instead.
988 NOTE: "hv_riter_set" must be explicitly called as
990 "Perl_hv_riter_set" with an "aTHX_" parameter.
991 void Perl_hv_riter_set(pTHX_ HV *hv, I32 riter)
993 "refcounted_he_chain_2hv"
995 Generates and returns a "HV *" representing the content of a
996 "refcounted_he" chain. "flags" is currently unused and must be
997 zero.
998 HV * refcounted_he_chain_2hv(const struct refcounted_he *c,
1000 U32 flags)
1001 "refcounted_he_fetch_pv"
1003 Like "refcounted_he_fetch_pvn", but takes a nul-terminated string
1004 instead of a string/length pair.
1005 SV * refcounted_he_fetch_pv(const struct refcounted_he *chain,
1007 const char *key, U32 hash, U32 flags)
1008 "refcounted_he_fetch_pvn"
1010 Search along a "refcounted_he" chain for an entry with the key
1011 specified by "keypv" and "keylen". If "flags" has the
1012 "REFCOUNTED_HE_KEY_UTF8" bit set, the key octets are interpreted as
1013 UTF-8, otherwise they are interpreted as Latin-1. "hash" is a
1014 precomputed hash of the key string, or zero if it has not been
1015 precomputed. Returns a mortal scalar representing the value
1016 associated with the key, or &PL_sv_placeholder if there is no value
1017 associated with the key.
1018 SV * refcounted_he_fetch_pvn(const struct refcounted_he *chain,
1020 const char *keypv, STRLEN keylen,
1021 U32 hash, U32 flags)
1022 "refcounted_he_fetch_pvs"
1024 Like "refcounted_he_fetch_pvn", but takes a literal string instead
1025 of a string/length pair, and no precomputed hash.
1026 SV * refcounted_he_fetch_pvs(const struct refcounted_he *chain,
1028 "key", U32 flags)
1029 "refcounted_he_fetch_sv"
1031 Like "refcounted_he_fetch_pvn", but takes a Perl scalar instead of
1032 a string/length pair.
1033 SV * refcounted_he_fetch_sv(const struct refcounted_he *chain,
1035 SV *key, U32 hash, U32 flags)
1036 "refcounted_he_free"
1038 Decrements the reference count of a "refcounted_he" by one. If the
1039 reference count reaches zero the structure's memory is freed, which
1040 (recursively) causes a reduction of its parent "refcounted_he"'s
1041 reference count. It is safe to pass a null pointer to this
1042 function: no action occurs in this case.
1043 void refcounted_he_free(struct refcounted_he *he)
1045 "refcounted_he_inc"
1047 Increment the reference count of a "refcounted_he". The pointer to
1048 the "refcounted_he" is also returned. It is safe to pass a null
1049 pointer to this function: no action occurs and a null pointer is
1050 returned.
1051 struct refcounted_he * refcounted_he_inc(
1053 struct refcounted_he *he)
1054 "refcounted_he_new_pv"
1056 Like "refcounted_he_new_pvn", but takes a nul-terminated string
1057 instead of a string/length pair.
1058 struct refcounted_he * refcounted_he_new_pv(
1060 struct refcounted_he *parent,
1061 const char *key, U32 hash,
1062 SV *value, U32 flags)
1063 "refcounted_he_new_pvn"
1065 Creates a new "refcounted_he". This consists of a single key/value
1066 pair and a reference to an existing "refcounted_he" chain (which
1067 may be empty), and thus forms a longer chain. When using the
1068 longer chain, the new key/value pair takes precedence over any
1069 entry for the same key further along the chain.
1070 The new key is specified by "keypv" and "keylen". If "flags" has
1072 the "REFCOUNTED_HE_KEY_UTF8" bit set, the key octets are
1073 interpreted as UTF-8, otherwise they are interpreted as Latin-1.
1074 "hash" is a precomputed hash of the key string, or zero if it has
1075 not been precomputed.
1076 "value" is the scalar value to store for this key. "value" is
1078 copied by this function, which thus does not take ownership of any
1079 reference to it, and later changes to the scalar will not be
1080 reflected in the value visible in the "refcounted_he". Complex
1081 types of scalar will not be stored with referential integrity, but
1082 will be coerced to strings. "value" may be either null or
1083 &PL_sv_placeholder to indicate that no value is to be associated
1084 with the key; this, as with any non-null value, takes precedence
1085 over the existence of a value for the key further along the chain.
1086 "parent" points to the rest of the "refcounted_he" chain to be
1088 attached to the new "refcounted_he". This function takes ownership
1089 of one reference to "parent", and returns one reference to the new
1090 "refcounted_he".
1091 struct refcounted_he * refcounted_he_new_pvn(
1093 struct refcounted_he *parent,
1094 const char *keypv,
1095 STRLEN keylen, U32 hash,
1096 SV *value, U32 flags)
1097 "refcounted_he_new_pvs"
1099 Like "refcounted_he_new_pvn", but takes a literal string instead of
1100 a string/length pair, and no precomputed hash.
1101 struct refcounted_he * refcounted_he_new_pvs(
1103 struct refcounted_he *parent,
1104 "key", SV *value, U32 flags)
1105 "refcounted_he_new_sv"
1107 Like "refcounted_he_new_pvn", but takes a Perl scalar instead of a
1108 string/length pair.
1109 struct refcounted_he * refcounted_he_new_sv(
1111 struct refcounted_he *parent,
1112 SV *key, U32 hash, SV *value,
1113 U32 flags)
1114 "unsharepvn"
1116 If no one has access to shared string "str" with length "len", free
1117 it.
1118 "len" and "hash" must both be valid for "str".
1120 void unsharepvn(const char *sv, I32 len, U32 hash)
1122
1124 "dirp_dup"
1125 Duplicate a directory handle, returning a pointer to the cloned
1126 object.
1127 DIR * dirp_dup(DIR * const dp, CLONE_PARAMS * const param)
1129 "fp_dup"
1131 Duplicate a file handle, returning a pointer to the cloned object.
1132 PerlIO * fp_dup(PerlIO * const fp, const char type,
1134 CLONE_PARAMS * const param)
1135 "my_fflush_all"
1137 Implements "PERL_FLUSHALL_FOR_CHILD" on some platforms.
1138 I32 my_fflush_all()
1140 "my_mkostemp"
1142 The C library mkostemp(3) if available, or a Perl implementation of
1143 it.
1144 NOTE: "my_mkostemp" must be explicitly called as "Perl_my_mkostemp"
1146 .
1147 int Perl_my_mkostemp(char *templte, int flags)
1149 "my_mkstemp"
1151 The C library mkstemp(3) if available, or a Perl implementation of
1152 it.
1153 NOTE: "my_mkstemp" must be explicitly called as "Perl_my_mkstemp" .
1155 int Perl_my_mkstemp(char *templte)
1157 "PL_last_in_gv"
1159 The GV which was last used for a filehandle input operation.
1160 ("<FH>")
1161 On threaded perls, each thread has an independent copy of this
1163 variable; each initialized at creation time with the current value
1164 of the creating thread's copy.
1165 GV* PL_last_in_gv
1167 "PL_ofsgv"
1169 The glob containing the output field separator - "*," in Perl
1170 space.
1171 On threaded perls, each thread has an independent copy of this
1173 variable; each initialized at creation time with the current value
1174 of the creating thread's copy.
1175 GV* PL_ofsgv
1177 "PL_rs"
1179 The input record separator - $/ in Perl space.
1180 On threaded perls, each thread has an independent copy of this
1182 variable; each initialized at creation time with the current value
1183 of the creating thread's copy.
1184 SV* PL_rs
1186 "start_glob"
1188 NOTE: "start_glob" is experimental and may change or be removed
1189 without notice.
1190 Function called by "do_readline" to spawn a glob (or do the glob
1192 inside perl on VMS). This code used to be inline, but now perl
1193 uses "File::Glob" this glob starter is only used by miniperl during
1194 the build process, or when PERL_EXTERNAL_GLOB is defined. Moving
1195 it away shrinks pp_hot.c; shrinking pp_hot.c helps speed perl up.
1196 NOTE: "start_glob" must be explicitly called as "Perl_start_glob"
1198 with an "aTHX_" parameter.
1199 PerlIO * Perl_start_glob(pTHX_ SV *tmpglob, IO *io)
1201
1203 There are currently no internal API items in Integer
1204
1206 There are currently no internal API items in I/O Formats
1207
1209 "resume_compcv_and_save"
1210 Resumes a buffer previously suspended by the "suspend_compcv"
1211 function, in a way that will be re-suspended at the end of the
1212 scope so it can be used again later. This should be used within an
1213 "ENTER"/"LEAVE" scoped pair.
1214 void resume_compcv_and_save(struct suspended_compcv *buffer)
1216 "resume_compcv_final"
1218 Resumes the parser state previously saved using the
1219 "suspend_compcv" function for a final time before being compiled
1220 into a full CV. This should be used within an "ENTER"/"LEAVE"
1221 scoped pair.
1222 void resume_compcv_final(struct suspended_compcv *buffer)
1224 "validate_proto"
1226 NOTE: "validate_proto" is experimental and may change or be removed
1227 without notice.
1228 This function performs syntax checking on a prototype, "proto". If
1230 "warn" is true, any illegal characters or mismatched brackets will
1231 trigger illegalproto warnings, declaring that they were detected in
1232 the prototype for "name".
1233 The return value is "true" if this is a valid prototype, and
1235 "false" if it is not, regardless of whether "warn" was "true" or
1236 "false".
1237 Note that "NULL" is a valid "proto" and will always return "true".
1239 bool validate_proto(SV *name, SV *proto, bool warn,
1241 bool curstash)
1242
1244 There are currently no internal API items in Locales
1245
1247 "magic_clearhint"
1248 Triggered by a delete from "%^H", records the key to
1249 "PL_compiling.cop_hints_hash".
1250 int magic_clearhint(SV *sv, MAGIC *mg)
1252 "magic_clearhints"
1254 Triggered by clearing "%^H", resets "PL_compiling.cop_hints_hash".
1255 int magic_clearhints(SV *sv, MAGIC *mg)
1257 "magic_methcall"
1259 Invoke a magic method (like FETCH).
1260 "sv" and "mg" are the tied thingy and the tie magic.
1262 "meth" is the name of the method to call.
1264 "argc" is the number of args (in addition to $self) to pass to the
1266 method.
1267 The "flags" can be:
1269 G_DISCARD invoke method with G_DISCARD flag and don't
1271 return a value
1272 G_UNDEF_FILL fill the stack with argc pointers to
1273 PL_sv_undef
1274 The arguments themselves are any values following the "flags"
1276 argument.
1277 Returns the SV (if any) returned by the method, or "NULL" on
1279 failure.
1280 NOTE: "magic_methcall" must be explicitly called as
1282 "Perl_magic_methcall" with an "aTHX_" parameter.
1283 SV * Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg,
1285 SV *meth, U32 flags, U32 argc, ...)
1286 "magic_sethint"
1288 Triggered by a store to "%^H", records the key/value pair to
1289 "PL_compiling.cop_hints_hash". It is assumed that hints aren't
1290 storing anything that would need a deep copy. Maybe we should warn
1291 if we find a reference.
1292 int magic_sethint(SV *sv, MAGIC *mg)
1294 "mg_dup"
1296 Duplicate a chain of magic, returning a pointer to the cloned
1297 object.
1298 MAGIC * mg_dup(MAGIC *mg, CLONE_PARAMS * const param)
1300 "mg_localize"
1302 Copy some of the magic from an existing SV to new localized version
1303 of that SV. Container magic (e.g., %ENV, $1, "tie") gets copied,
1304 value magic doesn't (e.g., "taint", "pos").
1305 If "setmagic" is false then no set magic will be called on the new
1307 (empty) SV. This typically means that assignment will soon follow
1308 (e.g. 'local $x = $y'), and that will handle the magic.
1309 void mg_localize(SV *sv, SV *nsv, bool setmagic)
1311
1313 "calloc"
1314 Implements ""Newxz"" in perlapi which you should use instead.
1315 NOTE: "calloc" must be explicitly called as "Perl_calloc" .
1317 Malloc_t Perl_calloc(MEM_SIZE elements, MEM_SIZE size)
1319 "malloc"
1321 Implements ""Newx"" in perlapi which you should use instead.
1322 NOTE: "malloc" must be explicitly called as "Perl_malloc" .
1324 Malloc_t Perl_malloc(MEM_SIZE nbytes)
1326 "mfree"
1328 Implements ""Safefree"" in perlapi which you should use instead.
1329 NOTE: "mfree" must be explicitly called as "Perl_mfree" .
1331 Free_t Perl_mfree(Malloc_t where)
1333 "realloc"
1335 Implements ""Renew"" in perlapi which you should use instead.
1336 NOTE: "realloc" must be explicitly called as "Perl_realloc" .
1338 Malloc_t Perl_realloc(Malloc_t where, MEM_SIZE nbytes)
1340
1342 "mro_get_linear_isa_dfs"
1343 Returns the Depth-First Search linearization of @ISA the given
1344 stash. The return value is a read-only AV* whose elements are
1345 string SVs giving class names. "level" should be 0 (it is used
1346 internally in this function's recursion).
1347 You are responsible for SvREFCNT_inc() on the return value if you
1349 plan to store it anywhere semi-permanently (otherwise it might be
1350 deleted out from under you the next time the cache is invalidated).
1351 AV * mro_get_linear_isa_dfs(HV *stash, U32 level)
1353 "mro_isa_changed_in"
1355 Takes the necessary steps (cache invalidations, mostly) when the
1356 @ISA of the given package has changed. Invoked by the "setisa"
1357 magic, should not need to invoke directly.
1358 void mro_isa_changed_in(HV *stash)
1360 "mro_package_moved"
1362 Call this function to signal to a stash that it has been assigned
1363 to another spot in the stash hierarchy. "stash" is the stash that
1364 has been assigned. "oldstash" is the stash it replaces, if any.
1365 "gv" is the glob that is actually being assigned to.
1366 This can also be called with a null first argument to indicate that
1368 "oldstash" has been deleted.
1369 This function invalidates isa caches on the old stash, on all
1371 subpackages nested inside it, and on the subclasses of all those,
1372 including non-existent packages that have corresponding entries in
1373 "stash".
1374 It also sets the effective names ("HvENAME") on all the stashes as
1376 appropriate.
1377 If the "gv" is present and is not in the symbol table, then this
1379 function simply returns. This checked will be skipped if "flags &
1380 1".
1381 void mro_package_moved(HV * const stash, HV * const oldstash,
1383 const GV * const gv, U32 flags)
1384
1386 There are currently no internal API items in Multicall Functions
1387
1389 "isinfnansv"
1390 Checks whether the argument would be either an infinity or "NaN"
1391 when used as a number, but is careful not to trigger non-numeric or
1392 uninitialized warnings. it assumes the caller has done
1393 SvGETMAGIC(sv) already.
1394 Note that this always accepts trailing garbage (similar to
1396 "grok_number_flags" with "PERL_SCAN_TRAILING"), so "inferior" and
1397 "NAND gates" will return true.
1398 bool isinfnansv(SV *sv)
1400
1402 "newATTRSUB_x"
1403 Construct a Perl subroutine, also performing some surrounding jobs.
1404 This function is expected to be called in a Perl compilation
1406 context, and some aspects of the subroutine are taken from global
1407 variables associated with compilation. In particular, "PL_compcv"
1408 represents the subroutine that is currently being compiled. It
1409 must be non-null when this function is called, and some aspects of
1410 the subroutine being constructed are taken from it. The
1411 constructed subroutine may actually be a reuse of the "PL_compcv"
1412 object, but will not necessarily be so.
1413 If "block" is null then the subroutine will have no body, and for
1415 the time being it will be an error to call it. This represents a
1416 forward subroutine declaration such as "sub foo ($$);". If "block"
1417 is non-null then it provides the Perl code of the subroutine body,
1418 which will be executed when the subroutine is called. This body
1419 includes any argument unwrapping code resulting from a subroutine
1420 signature or similar. The pad use of the code must correspond to
1421 the pad attached to "PL_compcv". The code is not expected to
1422 include a "leavesub" or "leavesublv" op; this function will add
1423 such an op. "block" is consumed by this function and will become
1424 part of the constructed subroutine.
1425 "proto" specifies the subroutine's prototype, unless one is
1427 supplied as an attribute (see below). If "proto" is null, then the
1428 subroutine will not have a prototype. If "proto" is non-null, it
1429 must point to a "const" op whose value is a string, and the
1430 subroutine will have that string as its prototype. If a prototype
1431 is supplied as an attribute, the attribute takes precedence over
1432 "proto", but in that case "proto" should preferably be null. In
1433 any case, "proto" is consumed by this function.
1434 "attrs" supplies attributes to be applied the subroutine. A
1436 handful of attributes take effect by built-in means, being applied
1437 to "PL_compcv" immediately when seen. Other attributes are
1438 collected up and attached to the subroutine by this route. "attrs"
1439 may be null to supply no attributes, or point to a "const" op for a
1440 single attribute, or point to a "list" op whose children apart from
1441 the "pushmark" are "const" ops for one or more attributes. Each
1442 "const" op must be a string, giving the attribute name optionally
1443 followed by parenthesised arguments, in the manner in which
1444 attributes appear in Perl source. The attributes will be applied
1445 to the sub by this function. "attrs" is consumed by this function.
1446 If "o_is_gv" is false and "o" is null, then the subroutine will be
1448 anonymous. If "o_is_gv" is false and "o" is non-null, then "o"
1449 must point to a "const" OP, which will be consumed by this
1450 function, and its string value supplies a name for the subroutine.
1451 The name may be qualified or unqualified, and if it is unqualified
1452 then a default stash will be selected in some manner. If "o_is_gv"
1453 is true, then "o" doesn't point to an "OP" at all, but is instead a
1454 cast pointer to a "GV" by which the subroutine will be named.
1455 If there is already a subroutine of the specified name, then the
1457 new sub will either replace the existing one in the glob or be
1458 merged with the existing one. A warning may be generated about
1459 redefinition.
1460 If the subroutine has one of a few special names, such as "BEGIN"
1462 or "END", then it will be claimed by the appropriate queue for
1463 automatic running of phase-related subroutines. In this case the
1464 relevant glob will be left not containing any subroutine, even if
1465 it did contain one before. In the case of "BEGIN", the subroutine
1466 will be executed and the reference to it disposed of before this
1467 function returns.
1468 The function returns a pointer to the constructed subroutine. If
1470 the sub is anonymous then ownership of one counted reference to the
1471 subroutine is transferred to the caller. If the sub is named then
1472 the caller does not get ownership of a reference. In most such
1473 cases, where the sub has a non-phase name, the sub will be alive at
1474 the point it is returned by virtue of being contained in the glob
1475 that names it. A phase-named subroutine will usually be alive by
1476 virtue of the reference owned by the phase's automatic run queue.
1477 But a "BEGIN" subroutine, having already been executed, will quite
1478 likely have been destroyed already by the time this function
1479 returns, making it erroneous for the caller to make any use of the
1480 returned pointer. It is the caller's responsibility to ensure that
1481 it knows which of these situations applies.
1482 CV * newATTRSUB_x(I32 floor, OP *o, OP *proto, OP *attrs,
1484 OP *block, bool o_is_gv)
1485 "newXS_len_flags"
1487 Construct an XS subroutine, also performing some surrounding jobs.
1488 The subroutine will have the entry point "subaddr". It will have
1490 the prototype specified by the nul-terminated string "proto", or no
1491 prototype if "proto" is null. The prototype string is copied; the
1492 caller can mutate the supplied string afterwards. If "filename" is
1493 non-null, it must be a nul-terminated filename, and the subroutine
1494 will have its "CvFILE" set accordingly. By default "CvFILE" is set
1495 to point directly to the supplied string, which must be static. If
1496 "flags" has the "XS_DYNAMIC_FILENAME" bit set, then a copy of the
1497 string will be taken instead.
1498 Other aspects of the subroutine will be left in their default
1500 state. If anything else needs to be done to the subroutine for it
1501 to function correctly, it is the caller's responsibility to do that
1502 after this function has constructed it. However, beware of the
1503 subroutine potentially being destroyed before this function
1504 returns, as described below.
1505 If "name" is null then the subroutine will be anonymous, with its
1507 "CvGV" referring to an "__ANON__" glob. If "name" is non-null then
1508 the subroutine will be named accordingly, referenced by the
1509 appropriate glob. "name" is a string of length "len" bytes giving
1510 a sigilless symbol name, in UTF-8 if "flags" has the "SVf_UTF8" bit
1511 set and in Latin-1 otherwise. The name may be either qualified or
1512 unqualified, with the stash defaulting in the same manner as for
1513 "gv_fetchpvn_flags". "flags" may contain flag bits understood by
1514 "gv_fetchpvn_flags" with the same meaning as they have there, such
1515 as "GV_ADDWARN". The symbol is always added to the stash if
1516 necessary, with "GV_ADDMULTI" semantics.
1517 If there is already a subroutine of the specified name, then the
1519 new sub will replace the existing one in the glob. A warning may
1520 be generated about the redefinition. If the old subroutine was
1521 "CvCONST" then the decision about whether to warn is influenced by
1522 an expectation about whether the new subroutine will become a
1523 constant of similar value. That expectation is determined by
1524 "const_svp". (Note that the call to this function doesn't make the
1525 new subroutine "CvCONST" in any case; that is left to the caller.)
1526 If "const_svp" is null then it indicates that the new subroutine
1527 will not become a constant. If "const_svp" is non-null then it
1528 indicates that the new subroutine will become a constant, and it
1529 points to an "SV*" that provides the constant value that the
1530 subroutine will have.
1531 If the subroutine has one of a few special names, such as "BEGIN"
1533 or "END", then it will be claimed by the appropriate queue for
1534 automatic running of phase-related subroutines. In this case the
1535 relevant glob will be left not containing any subroutine, even if
1536 it did contain one before. In the case of "BEGIN", the subroutine
1537 will be executed and the reference to it disposed of before this
1538 function returns, and also before its prototype is set. If a
1539 "BEGIN" subroutine would not be sufficiently constructed by this
1540 function to be ready for execution then the caller must prevent
1541 this happening by giving the subroutine a different name.
1542 The function returns a pointer to the constructed subroutine. If
1544 the sub is anonymous then ownership of one counted reference to the
1545 subroutine is transferred to the caller. If the sub is named then
1546 the caller does not get ownership of a reference. In most such
1547 cases, where the sub has a non-phase name, the sub will be alive at
1548 the point it is returned by virtue of being contained in the glob
1549 that names it. A phase-named subroutine will usually be alive by
1550 virtue of the reference owned by the phase's automatic run queue.
1551 But a "BEGIN" subroutine, having already been executed, will quite
1552 likely have been destroyed already by the time this function
1553 returns, making it erroneous for the caller to make any use of the
1554 returned pointer. It is the caller's responsibility to ensure that
1555 it knows which of these situations applies.
1556 CV * newXS_len_flags(const char *name, STRLEN len,
1558 XSUBADDR_t subaddr,
1559 const char * const filename,
1560 const char * const proto, SV ** const_svp,
1561 U32 flags)
1562 "op_refcnt_lock"
1564 Implements the "OP_REFCNT_LOCK" macro which you should use instead.
1565 void op_refcnt_lock()
1567 "op_refcnt_unlock"
1569 Implements the "OP_REFCNT_UNLOCK" macro which you should use
1570 instead.
1571 void op_refcnt_unlock()
1573 "traverse_op_tree"
1575 Return the next op in a depth-first traversal of the op tree,
1576 returning NULL when the traversal is complete.
1577 The initial call must supply the root of the tree as both top and
1579 o.
1580 For now it's static, but it may be exposed to the API in the
1582 future.
1583 OP * traverse_op_tree(OP *top, OP *o)
1585
1587 There are currently no internal API items in Pack and Unpack
1588
1590 "CX_CURPAD_SAVE"
1591 Save the current pad in the given context block structure.
1592 void CX_CURPAD_SAVE(struct context)
1594 "CX_CURPAD_SV"
1596 Access the SV at offset "po" in the saved current pad in the given
1597 context block structure (can be used as an lvalue).
1598 SV * CX_CURPAD_SV(struct context, PADOFFSET po)
1600 "PAD_BASE_SV"
1602 Get the value from slot "po" in the base (DEPTH=1) pad of a padlist
1603 SV * PAD_BASE_SV(PADLIST padlist, PADOFFSET po)
1605 "PAD_CLONE_VARS"
1607 Clone the state variables associated with running and compiling
1608 pads.
1609 void PAD_CLONE_VARS(PerlInterpreter *proto_perl,
1611 CLONE_PARAMS* param)
1612 "PAD_COMPNAME_FLAGS"
1614 Return the flags for the current compiling pad name at offset "po".
1615 Assumes a valid slot entry.
1616 U32 PAD_COMPNAME_FLAGS(PADOFFSET po)
1618 "PAD_COMPNAME_GEN"
1620 The generation number of the name at offset "po" in the current
1621 compiling pad (lvalue).
1622 STRLEN PAD_COMPNAME_GEN(PADOFFSET po)
1624 "PAD_COMPNAME_GEN_set"
1626 Sets the generation number of the name at offset "po" in the
1627 current ling pad (lvalue) to "gen".
1628 STRLEN PAD_COMPNAME_GEN_set(PADOFFSET po, int gen)
1630 "PAD_COMPNAME_OURSTASH"
1632 Return the stash associated with an "our" variable. Assumes the
1633 slot entry is a valid "our" lexical.
1634 HV * PAD_COMPNAME_OURSTASH(PADOFFSET po)
1636 "PAD_COMPNAME_PV"
1638 Return the name of the current compiling pad name at offset "po".
1639 Assumes a valid slot entry.
1640 char * PAD_COMPNAME_PV(PADOFFSET po)
1642 "PAD_COMPNAME_TYPE"
1644 Return the type (stash) of the current compiling pad name at offset
1645 "po". Must be a valid name. Returns null if not typed.
1646 HV * PAD_COMPNAME_TYPE(PADOFFSET po)
1648 "PadnameIsFIELD"
1650 Whether this is a "field" variable. PADNAMEs where this is true
1651 will have additional information available via "PadnameFIELDINFO".
1652 bool PadnameIsFIELD(PADNAME * pn)
1654 "PadnameIsOUR"
1656 Whether this is an "our" variable.
1657 bool PadnameIsOUR(PADNAME * pn)
1659 "PadnameIsSTATE"
1661 Whether this is a "state" variable.
1662 bool PadnameIsSTATE(PADNAME * pn)
1664 "PadnameOURSTASH"
1666 The stash in which this "our" variable was declared.
1667 HV * PadnameOURSTASH(PADNAME * pn)
1669 "PadnameOUTER"
1671 Whether this entry belongs to an outer pad. Entries for which this
1672 is true are often referred to as 'fake'.
1673 bool PadnameOUTER(PADNAME * pn)
1675 "PadnameTYPE"
1677 The stash associated with a typed lexical. This returns the %Foo::
1678 hash for "my Foo $bar".
1679 HV * PadnameTYPE(PADNAME * pn)
1681 "PAD_RESTORE_LOCAL"
1683 Restore the old pad saved into the local variable "opad" by
1684 PAD_SAVE_LOCAL()
1685 void PAD_RESTORE_LOCAL(PAD *opad)
1687 "PAD_SAVE_LOCAL"
1689 Save the current pad to the local variable "opad", then make the
1690 current pad equal to "npad"
1691 void PAD_SAVE_LOCAL(PAD *opad, PAD *npad)
1693 "PAD_SAVE_SETNULLPAD"
1695 Save the current pad then set it to null.
1696 void PAD_SAVE_SETNULLPAD()
1698 "PAD_SET_CUR"
1700 Set the current pad to be pad "n" in the padlist, saving the
1701 previous current pad. NB currently this macro expands to a string
1702 too long for some compilers, so it's best to replace it with
1703 SAVECOMPPAD();
1705 PAD_SET_CUR_NOSAVE(padlist,n);
1706 void PAD_SET_CUR(PADLIST padlist, I32 n)
1708 "PAD_SET_CUR_NOSAVE"
1710 like PAD_SET_CUR, but without the save
1711 void PAD_SET_CUR_NOSAVE(PADLIST padlist, I32 n)
1713 "PAD_SETSV"
1715 Set the slot at offset "po" in the current pad to "sv"
1716 SV * PAD_SETSV(PADOFFSET po, SV* sv)
1718 "PAD_SV"
1720 Get the value at offset "po" in the current pad
1721 SV * PAD_SV(PADOFFSET po)
1723 "PAD_SVl"
1725 Lightweight and lvalue version of "PAD_SV". Get or set the value
1726 at offset "po" in the current pad. Unlike "PAD_SV", does not print
1727 diagnostics with -DX. For internal use only.
1728 SV * PAD_SVl(PADOFFSET po)
1730 "SAVECLEARSV"
1732 Clear the pointed to pad value on scope exit. (i.e. the runtime
1733 action of "my")
1734 void SAVECLEARSV(SV **svp)
1736 "SAVECOMPPAD"
1738 save "PL_comppad" and "PL_curpad"
1739 void SAVECOMPPAD()
1741 "SAVEPADSV"
1743 Save a pad slot (used to restore after an iteration)
1744 void SAVEPADSV(PADOFFSET po)
1746
1748 There are currently no internal API items in Password and Group access
1749
1751 There are currently no internal API items in Paths to system commands
1752
1754 There are currently no internal API items in Prototype information
1755
1757 "regnode"
1758 Described in perlreguts.
1759
1761 There are currently no internal API items in Reports and Formats
1762
1764 There are currently no internal API items in Signals
1765
1767 There are currently no internal API items in Site configuration
1768
1770 There are currently no internal API items in Sockets configuration
1771 values
1772
1774 There are currently no internal API items in Source Filters
1775
1777 "djSP"
1778 Declare Just "SP". This is actually identical to "dSP", and
1779 declares a local copy of perl's stack pointer, available via the
1780 "SP" macro. See ""SP" in perlapi". (Available for backward source
1781 code compatibility with the old (Perl 5.005) thread model.)
1782 djSP();
1784 "LVRET"
1786 True if this op will be the return value of an lvalue subroutine
1787 "save_alloc"
1789 Implements ""SSNEW"" in perlapi and kin, which should be used
1790 instead of this function.
1791 SSize_t save_alloc(SSize_t size, I32 pad)
1793
1795 "delimcpy_no_escape"
1796 Copy a source buffer to a destination buffer, stopping at (but not
1797 including) the first occurrence in the source of the delimiter
1798 byte, "delim". The source is the bytes between
1799 "from" and "from_end" - 1. Similarly, the dest is "to" up to
1800 "to_end".
1801 The number of bytes copied is written to *retlen.
1803 Returns the position of "delim" in the "from" buffer, but if there
1805 is no such occurrence before "from_end", then "from_end" is
1806 returned, and the entire buffer "from" .. "from_end" - 1 is copied.
1807 If there is room in the destination available after the copy, an
1809 extra terminating safety "NUL" byte is appended (not included in
1810 the returned length).
1811 The error case is if the destination buffer is not large enough to
1813 accommodate everything that should be copied. In this situation, a
1814 value larger than "to_end" - "to" is written to *retlen, and as
1815 much of the source as fits will be written to the destination. Not
1816 having room for the safety "NUL" is not considered an error.
1817 char * delimcpy_no_escape(char *to, const char *to_end,
1819 const char *from, const char *from_end,
1820 const int delim, I32 *retlen)
1821 "my_cxt_init"
1823 Implements the ""MY_CXT_INIT"" in perlxs macro, which you should
1824 use instead.
1825 The first time a module is loaded, the global "PL_my_cxt_index" is
1827 incremented, and that value is assigned to that module's static
1828 "my_cxt_index" (whose address is passed as an arg). Then, for each
1829 interpreter this function is called for, it makes sure a "void*"
1830 slot is available to hang the static data off, by allocating or
1831 extending the interpreter's "PL_my_cxt_list" array
1832 NOTE: "my_cxt_init" must be explicitly called as "Perl_my_cxt_init"
1834 with an "aTHX_" parameter.
1835 void * Perl_my_cxt_init(pTHX_ int *indexp, size_t size)
1837 "quadmath_format_needed"
1839 quadmath_format_needed() returns true if the "format" string seems
1840 to contain at least one non-Q-prefixed "%[efgaEFGA]" format
1841 specifier, or returns false otherwise.
1842 The format specifier detection is not complete printf-syntax
1844 detection, but it should catch most common cases.
1845 If true is returned, those arguments should in theory be processed
1847 with quadmath_snprintf(), but in case there is more than one such
1848 format specifier (see "quadmath_format_valid"), and if there is
1849 anything else beyond that one (even just a single byte), they
1850 cannot be processed because quadmath_snprintf() is very strict,
1851 accepting only one format spec, and nothing else. In this case,
1852 the code should probably fail.
1853 bool quadmath_format_needed(const char *format)
1855 "quadmath_format_valid"
1857 quadmath_snprintf() is very strict about its "format" string and
1858 will fail, returning -1, if the format is invalid. It accepts
1859 exactly one format spec.
1860 quadmath_format_valid() checks that the intended single spec looks
1862 sane: begins with "%", has only one "%", ends with "[efgaEFGA]",
1863 and has "Q" before it. This is not a full "printf syntax check",
1864 just the basics.
1865 Returns true if it is valid, false if not.
1867 See also "quadmath_format_needed".
1869 bool quadmath_format_valid(const char *format)
1871
1873 "SVt_INVLIST"
1874 Type flag for scalars. See "svtype" in perlapi.
1875
1877 "PL_Sv"
1878 A scratch pad SV for whatever temporary use you need. Chiefly used
1879 as a fallback by macros on platforms where
1880 "PERL_USE_GCC_BRACE_GROUPS" in perlapi> is unavailable, and which
1881 would otherwise evaluate their SV parameter more than once.
1882 BUT BEWARE, if this is used in a situation where something that is
1884 using it is in a call stack with something else that is using it,
1885 this variable would get zapped, leading to hard-to-diagnose errors.
1886 PL_Sv
1888 "sv_add_arena"
1890 Given a chunk of memory, link it to the head of the list of arenas,
1891 and split it into a list of free SVs.
1892 void sv_add_arena(char * const ptr, const U32 size,
1894 const U32 flags)
1895 "sv_2bool"
1897 This macro is only used by sv_true() or its macro equivalent, and
1898 only if the latter's argument is neither "SvPOK", "SvIOK" nor
1899 "SvNOK". It calls "sv_2bool_flags" with the "SV_GMAGIC" flag.
1900 bool sv_2bool(SV * const sv)
1902 "sv_2bool_flags"
1904 This function is only used by sv_true() and friends, and only if
1905 the latter's argument is neither "SvPOK", "SvIOK" nor "SvNOK". If
1906 the flags contain "SV_GMAGIC", then it does an mg_get() first.
1907 bool sv_2bool_flags(SV *sv, I32 flags)
1909 "sv_clean_all"
1911 Decrement the refcnt of each remaining SV, possibly triggering a
1912 cleanup. This function may have to be called multiple times to
1913 free SVs which are in complex self-referential hierarchies.
1914 I32 sv_clean_all()
1916 "sv_clean_objs"
1918 Attempt to destroy all objects not yet freed.
1919 void sv_clean_objs()
1921 "sv_free_arenas"
1923 Deallocate the memory used by all arenas. Note that all the
1924 individual SV heads and bodies within the arenas must already have
1925 been freed.
1926 void sv_free_arenas()
1928 "sv_grow"
1930 Expands the character buffer in the SV. If necessary, uses
1931 "sv_unref" and upgrades the SV to "SVt_PV". Returns a pointer to
1932 the character buffer. Use the "SvGROW" wrapper instead.
1933 char * sv_grow(SV * const sv, STRLEN newlen)
1935 "sv_grow_fresh"
1937 A cut-down version of sv_grow intended only for when sv is a
1938 freshly-minted SVt_PV, SVt_PVIV, SVt_PVNV, or SVt_PVMG. i.e. sv has
1939 the default flags, has never been any other type, and does not have
1940 an existing string. Basically, just assigns a char buffer and
1941 returns a pointer to it.
1942 char * sv_grow_fresh(SV * const sv, STRLEN newlen)
1944 "sv_newref"
1946 Increment an SV's reference count. Use the SvREFCNT_inc() wrapper
1947 instead.
1948 SV * sv_newref(SV * const sv)
1950 "sv_2num"
1952 NOTE: "sv_2num" is experimental and may change or be removed
1953 without notice.
1954 Return an SV with the numeric value of the source SV, doing any
1956 necessary reference or overload conversion. The caller is expected
1957 to have handled get-magic already.
1958 SV * sv_2num(SV * const sv)
1960 "sv_pv"
1962 Use the "SvPV_nolen" macro instead
1963 char * sv_pv(SV *sv)
1965 "sv_pvbyte"
1967 Use "SvPVbyte_nolen" instead.
1968 char * sv_pvbyte(SV *sv)
1970 "sv_pvbyten_force"
1972 The backend for the "SvPVbytex_force" macro. Always use the macro
1973 instead. If the SV cannot be downgraded from UTF-8, this croaks.
1974 char * sv_pvbyten_force(SV * const sv, STRLEN * const lp)
1976 "sv_2pvbyte_nolen"
1978 Return a pointer to the byte-encoded representation of the SV. May
1979 cause the SV to be downgraded from UTF-8 as a side-effect.
1980 Usually accessed via the "SvPVbyte_nolen" macro.
1982 char * sv_2pvbyte_nolen(SV *sv)
1984 "sv_pvn_force"
1986 Get a sensible string out of the SV somehow. A private
1987 implementation of the "SvPV_force" macro for compilers which can't
1988 cope with complex macro expressions. Always use the macro instead.
1989 char * sv_pvn_force(SV *sv, STRLEN *lp)
1991 "sv_2pv_nolen"
1993 Like sv_2pv(), but doesn't return the length too. You should
1994 usually use the macro wrapper SvPV_nolen(sv) instead.
1995 char * sv_2pv_nolen(SV *sv)
1997 "sv_pvutf8n_force"
1999 The backend for the "SvPVutf8x_force" macro. Always use the macro
2000 instead.
2001 char * sv_pvutf8n_force(SV * const sv, STRLEN * const lp)
2003 "sv_2pvutf8_nolen"
2005 Return a pointer to the UTF-8-encoded representation of the SV.
2006 May cause the SV to be upgraded to UTF-8 as a side-effect.
2007 Usually accessed via the "SvPVutf8_nolen" macro.
2009 char * sv_2pvutf8_nolen(SV *sv)
2011 "sv_pvutf8"
2013 Use the "SvPVutf8_nolen" macro instead
2014 char * sv_pvutf8(SV *sv)
2016 "sv_tainted"
2018 Test an SV for taintedness. Use "SvTAINTED" instead.
2019 bool sv_tainted(SV * const sv)
2021 "SvTHINKFIRST"
2023 A quick flag check to see whether an "sv" should be passed to
2024 "sv_force_normal" to be "downgraded" before "SvIVX" or "SvPVX" can
2025 be modified directly.
2026 For example, if your scalar is a reference and you want to modify
2028 the "SvIVX" slot, you can't just do "SvROK_off", as that will leak
2029 the referent.
2030 This is used internally by various sv-modifying functions, such as
2032 "sv_setsv", "sv_setiv" and "sv_pvn_force".
2033 One case that this does not handle is a gv without SvFAKE set.
2035 After
2036 if (SvTHINKFIRST(gv)) sv_force_normal(gv);
2038 it will still be a gv.
2040 "SvTHINKFIRST" sometimes produces false positives. In those cases
2042 "sv_force_normal" does nothing.
2043 U32 SvTHINKFIRST(SV *sv)
2045 "sv_true"
2047 Returns true if the SV has a true value by Perl's rules. Use the
2048 "SvTRUE" macro instead, which may call sv_true() or may instead use
2049 an in-line version.
2050 I32 sv_true(SV * const sv)
2052 "sv_untaint"
2054 Untaint an SV. Use "SvTAINTED_off" instead.
2055 void sv_untaint(SV * const sv)
2057
2059 "sv_taint"
2060 Taint an SV. Use "SvTAINTED_on" instead.
2061 void sv_taint(SV *sv)
2063 "TAINT"
2065 If we aren't in taint checking mode, do nothing; otherwise indicate
2066 to ""TAINT_set"" and ""TAINT_PROPER"" that some unspecified element
2067 is tainted.
2068 void TAINT()
2070 "TAINT_ENV"
2072 Looks at several components of %ENV for taintedness, and calls
2073 ""taint_proper"" if any are tainted. The components it searches
2074 are things like $PATH.
2075 void TAINT_ENV
2077 "taint_env"
2079 Implements the "TAINT_ENV" macro, which you should generally use
2080 instead.
2081 void taint_env()
2083 "TAINT_get"
2085 Returns a boolean as to whether some element is tainted or not.
2086 bool TAINT_get()
2088 "TAINT_IF"
2090 If "c" evaluates to true, call ""TAINT"" to indicate that something
2091 is tainted; otherwise do nothing.
2092 void TAINT_IF(bool c)
2094 "TAINTING_get"
2096 Returns a boolean as to whether taint checking is enabled or not.
2097 bool TAINTING_get()
2099 "TAINTING_set"
2101 Turn taint checking mode off/on
2102 void TAINTING_set(bool s)
2104 "TAINT_NOT"
2106 Remove any taintedness previously set by, e.g., "TAINT".
2107 void TAINT_NOT()
2109 "TAINT_PROPER"
2111 If no element is tainted, do nothing; otherwise output a message
2112 (containing "s") that indicates there is a tainting violation. If
2113 such violations are fatal, it croaks.
2114 void TAINT_PROPER(const char * s)
2116 "taint_proper"
2118 Implements the "TAINT_PROPER" macro, which you should generally use
2119 instead.
2120 void taint_proper(const char *f, const char * const s)
2122 "TAINT_set"
2124 If "s" is true, ""TAINT_get"" returns true; If "s" is false,
2125 ""TAINT_get"" returns false;
2126 void TAINT_set(bool s)
2128 "TAINT_WARN_get"
2130 Returns false if tainting violations are fatal; Returns true if
2131 they're just warnings
2132 bool TAINT_WARN_get()
2134 "TAINT_WARN_set"
2136 "s" being true indicates ""TAINT_WARN_get"" should return that
2137 tainting violations are just warnings
2138 "s" being false indicates ""TAINT_WARN_get"" should return that
2140 tainting violations are fatal.
2141 void TAINT_WARN_set(bool s)
2143
2145 There are currently no internal API items in Time
2146
2148 There are currently no internal API items in Typedef names
2149
2151 "bytes_from_utf8_loc"
2152 NOTE: "bytes_from_utf8_loc" is experimental and may change or be
2153 removed without notice.
2154 Like ""bytes_from_utf8" in perlapi()", but takes an extra
2156 parameter, a pointer to where to store the location of the first
2157 character in "s" that cannot be converted to non-UTF8.
2158 If that parameter is "NULL", this function behaves identically to
2160 "bytes_from_utf8".
2161 Otherwise if *is_utf8p is 0 on input, the function behaves
2163 identically to "bytes_from_utf8", except it also sets
2164 *first_non_downgradable to "NULL".
2165 Otherwise, the function returns a newly created "NUL"-terminated
2167 string containing the non-UTF8 equivalent of the convertible first
2168 portion of "s". *lenp is set to its length, not including the
2169 terminating "NUL". If the entire input string was converted,
2170 *is_utf8p is set to a FALSE value, and *first_non_downgradable is
2171 set to "NULL".
2172 Otherwise, *first_non_downgradable is set to point to the first
2174 byte of the first character in the original string that wasn't
2175 converted. *is_utf8p is unchanged. Note that the new string may
2176 have length 0.
2177 Another way to look at it is, if *first_non_downgradable is
2179 non-"NULL" and *is_utf8p is TRUE, this function starts at the
2180 beginning of "s" and converts as many characters in it as possible
2181 stopping at the first one it finds that can't be converted to
2182 non-UTF-8. *first_non_downgradable is set to point to that. The
2183 function returns the portion that could be converted in a newly
2184 created "NUL"-terminated string, and *lenp is set to its length,
2185 not including the terminating "NUL". If the very first character
2186 in the original could not be converted, *lenp will be 0, and the
2187 new string will contain just a single "NUL". If the entire input
2188 string was converted, *is_utf8p is set to FALSE and
2189 *first_non_downgradable is set to "NULL".
2190 Upon successful return, the number of variants in the converted
2192 portion of the string can be computed by having saved the value of
2193 *lenp before the call, and subtracting the after-call value of
2194 *lenp from it.
2195 U8 * bytes_from_utf8_loc(const U8 *s, STRLEN *lenp,
2197 bool *is_utf8p,
2198 const U8 **first_unconverted)
2199 "find_uninit_var"
2201 NOTE: "find_uninit_var" is experimental and may change or be
2202 removed without notice.
2203 Find the name of the undefined variable (if any) that caused the
2205 operator to issue a "Use of uninitialized value" warning. If match
2206 is true, only return a name if its value matches "uninit_sv". So
2207 roughly speaking, if a unary operator (such as "OP_COS") generates
2208 a warning, then following the direct child of the op may yield an
2209 "OP_PADSV" or "OP_GV" that gives the name of the undefined
2210 variable. On the other hand, with "OP_ADD" there are two branches
2211 to follow, so we only print the variable name if we get an exact
2212 match. "desc_p" points to a string pointer holding the description
2213 of the op. This may be updated if needed.
2214 The name is returned as a mortal SV.
2216 Assumes that "PL_op" is the OP that originally triggered the error,
2218 and that "PL_comppad"/"PL_curpad" points to the currently executing
2219 pad.
2220 SV * find_uninit_var(const OP * const obase,
2222 const SV * const uninit_sv, bool match,
2223 const char **desc_p)
2224 "isSCRIPT_RUN"
2226 Returns a bool as to whether or not the sequence of bytes from "s"
2227 up to but not including "send" form a "script run". "utf8_target"
2228 is TRUE iff the sequence starting at "s" is to be treated as UTF-8.
2229 To be precise, except for two degenerate cases given below, this
2230 function returns TRUE iff all code points in it come from any
2231 combination of three "scripts" given by the Unicode "Script
2232 Extensions" property: Common, Inherited, and possibly one other.
2233 Additionally all decimal digits must come from the same consecutive
2234 sequence of 10.
2235 For example, if all the characters in the sequence are Greek, or
2237 Common, or Inherited, this function will return TRUE, provided any
2238 decimal digits in it are from the same block of digits in Common.
2239 (These are the ASCII digits "0".."9" and additionally a block for
2240 full width forms of these, and several others used in mathematical
2241 notation.) For scripts (unlike Greek) that have their own digits
2242 defined this will accept either digits from that set or from one of
2243 the Common digit sets, but not a combination of the two. Some
2244 scripts, such as Arabic, have more than one set of digits. All
2245 digits must come from the same set for this function to return
2246 TRUE.
2247 *ret_script, if "ret_script" is not NULL, will on return of TRUE
2249 contain the script found, using the "SCX_enum" typedef. Its value
2250 will be "SCX_INVALID" if the function returns FALSE.
2251 If the sequence is empty, TRUE is returned, but *ret_script (if
2253 asked for) will be "SCX_INVALID".
2254 If the sequence contains a single code point which is unassigned to
2256 a character in the version of Unicode being used, the function will
2257 return TRUE, and the script will be "SCX_Unknown". Any other
2258 combination of unassigned code points in the input sequence will
2259 result in the function treating the input as not being a script
2260 run.
2261 The returned script will be "SCX_Inherited" iff all the code points
2263 in it are from the Inherited script.
2264 Otherwise, the returned script will be "SCX_Common" iff all the
2266 code points in it are from the Inherited or Common scripts.
2267 bool isSCRIPT_RUN(const U8 *s, const U8 *send,
2269 const bool utf8_target)
2270 "is_utf8_non_invariant_string"
2272 Returns TRUE if "is_utf8_invariant_string" in perlapi returns FALSE
2273 for the first "len" bytes of the string "s", but they are,
2274 nonetheless, legal Perl-extended UTF-8; otherwise returns FALSE.
2275 A TRUE return means that at least one code point represented by the
2277 sequence either is a wide character not representable as a single
2278 byte, or the representation differs depending on whether the
2279 sequence is encoded in UTF-8 or not.
2280 See also ""is_utf8_invariant_string" in perlapi", ""is_utf8_string"
2282 in perlapi"
2283 bool is_utf8_non_invariant_string(const U8 * const s, STRLEN len)
2285 "utf8n_to_uvuni"
2287 "DEPRECATED!" It is planned to remove "utf8n_to_uvuni" from a
2288 future release of Perl. Do not use it for new code; remove it from
2289 existing code.
2290 Instead use "utf8_to_uvchr_buf" in perlapi, or rarely,
2292 "utf8n_to_uvchr" in perlapi.
2293 This function was useful for code that wanted to handle both EBCDIC
2295 and ASCII platforms with Unicode properties, but starting in Perl
2296 v5.20, the distinctions between the platforms have mostly been made
2297 invisible to most code, so this function is quite unlikely to be
2298 what you want. If you do need this precise functionality, use
2299 instead "NATIVE_TO_UNI(utf8_to_uvchr_buf(...))" or
2300 "NATIVE_TO_UNI(utf8n_to_uvchr(...))".
2301 UV utf8n_to_uvuni(const U8 *s, STRLEN curlen, STRLEN *retlen,
2303 U32 flags)
2304 "utf8_to_uvuni"
2306 "DEPRECATED!" It is planned to remove "utf8_to_uvuni" from a
2307 future release of Perl. Do not use it for new code; remove it from
2308 existing code.
2309 Returns the Unicode code point of the first character in the string
2311 "s" which is assumed to be in UTF-8 encoding; "retlen" will be set
2312 to the length, in bytes, of that character.
2313 Some, but not all, UTF-8 malformations are detected, and in fact,
2315 some malformed input could cause reading beyond the end of the
2316 input buffer, which is one reason why this function is deprecated.
2317 The other is that only in extremely limited circumstances should
2318 the Unicode versus native code point be of any interest to you.
2319 If "s" points to one of the detected malformations, and UTF8
2321 warnings are enabled, zero is returned and *retlen is set (if
2322 "retlen" doesn't point to NULL) to -1. If those warnings are off,
2323 the computed value if well-defined (or the Unicode REPLACEMENT
2324 CHARACTER, if not) is silently returned, and *retlen is set (if
2325 "retlen" isn't NULL) so that ("s" + *retlen) is the next possible
2326 position in "s" that could begin a non-malformed character. See
2327 "utf8n_to_uvchr" in perlapi for details on when the REPLACEMENT
2328 CHARACTER is returned.
2329 UV utf8_to_uvuni(const U8 *s, STRLEN *retlen)
2331 "uvoffuni_to_utf8_flags"
2333 THIS FUNCTION SHOULD BE USED IN ONLY VERY SPECIALIZED
2334 CIRCUMSTANCES. Instead, Almost all code should use "uvchr_to_utf8"
2335 in perlapi or "uvchr_to_utf8_flags" in perlapi.
2336 This function is like them, but the input is a strict Unicode (as
2338 opposed to native) code point. Only in very rare circumstances
2339 should code not be using the native code point.
2340 For details, see the description for "uvchr_to_utf8_flags" in
2342 perlapi.
2343 U8 * uvoffuni_to_utf8_flags(U8 *d, UV uv, UV flags)
2345 "valid_utf8_to_uvchr"
2347 Like ""utf8_to_uvchr_buf" in perlapi", but should only be called
2348 when it is known that the next character in the input UTF-8 string
2349 "s" is well-formed (e.g., it passes ""isUTF8_CHAR" in perlapi".
2350 Surrogates, non-character code points, and non-Unicode code points
2351 are allowed.
2352 UV valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen)
2354 "variant_under_utf8_count"
2356 This function looks at the sequence of bytes between "s" and "e",
2357 which are assumed to be encoded in ASCII/Latin1, and returns how
2358 many of them would change should the string be translated into
2359 UTF-8. Due to the nature of UTF-8, each of these would occupy two
2360 bytes instead of the single one in the input string. Thus, this
2361 function returns the precise number of bytes the string would
2362 expand by when translated to UTF-8.
2363 Unlike most of the other functions that have "utf8" in their name,
2365 the input to this function is NOT a UTF-8-encoded string. The
2366 function name is slightly odd to emphasize this.
2367 This function is internal to Perl because khw thinks that any XS
2369 code that would want this is probably operating too close to the
2370 internals. Presenting a valid use case could change that.
2371 See also ""is_utf8_invariant_string" in perlapi" and
2373 ""is_utf8_invariant_string_loc" in perlapi",
2374 Size_t variant_under_utf8_count(const U8 * const s,
2376 const U8 * const e)
2377
2379 "my_popen_list"
2380 Implementing function on some systems for PerlProc_popen_list()
2381 PerlIO * my_popen_list(const char *mode, int n, SV **args)
2383 "my_socketpair"
2385 Emulates socketpair(2) on systems that don't have it, but which do
2386 have enough functionality for the emulation.
2387 int my_socketpair(int family, int type, int protocol, int fd[2])
2389
2391 There are currently no internal API items in Versioning
2392
2394 "deprecate"
2395 Wrapper around Perl_ck_warner_d() to produce a deprecated warning
2396 in the given category with an appropriate message. The "message"
2397 argument must be a C string. The string " is deprecated" will
2398 automatically be added to the end of the "message".
2399 deprecate(U32 category, "message")
2401 "deprecate_disappears_in"
2403 Wrapper around Perl_ck_warner_d() to produce a deprecated warning
2404 in the given category with an appropriate message that the
2405 construct referred to by the message will disappear in a specific
2406 release. The "when" and "message" arguments must be a C string.
2407 The "when" string is expected to be of the form "5.40", with no
2408 minor element in the version. The actual message output will be
2409 the result of the following expression "message " is deprecated,
2410 and will disappear in Perl " when" which is why "message" and
2411 "when" must be literal C strings.
2412 deprecate_disappears_in(U32 category, "when", "message")
2414 "deprecate_fatal_in"
2416 Wrapper around Perl_ck_warner_d() to produce a deprecated warning
2417 in the given category with an appropriate message that the
2418 construct referred to by the message will become fatal in a
2419 specific release. The "when" and "message" arguments must be a C
2420 string. The "when" string is expected to be of the form "5.40",
2421 with no minor element in the version. The actual message output
2422 will be the result of the following expression "message " is
2423 deprecated, and will become fatal in Perl " when" which is why
2424 "message" and "when" must be literal C strings.
2425 deprecate_fatal_in(U32 category, "when", "message")
2427 "PL_dowarn"
2429 The C variable that roughly corresponds to Perl's $^W warning
2430 variable. However, $^W is treated as a boolean, whereas
2431 "PL_dowarn" is a collection of flag bits.
2432 On threaded perls, each thread has an independent copy of this
2434 variable; each initialized at creation time with the current value
2435 of the creating thread's copy.
2436 U8 PL_dowarn
2438 "report_uninit"
2440 Print appropriate "Use of uninitialized variable" warning.
2441 void report_uninit(const SV *uninit_sv)
2443
2445 There are currently no internal API items in XS
2446
2448 This section lists the elements that are otherwise undocumented. If
2449 you use any of them, please consider creating and submitting
2450 documentation for it.
2451 Experimental and deprecated undocumented elements are listed separately
2453 at the end.
2454 abort_execution
2456 add_above_Latin1_folds
2457 add_cp_to_invlist
2458 _add_range_to_invlist
2459 allocmy
2460 amagic_cmp
2461 amagic_cmp_desc
2462 amagic_cmp_locale
2463 amagic_cmp_locale_desc
2464 amagic_i_ncmp
2465 amagic_i_ncmp_desc
2466 amagic_is_enabled
2467 amagic_ncmp
2468 amagic_ncmp_desc
2469 any_dup
2470 append_utf8_from_native_byte
2471 apply
2472 atfork_lock
2473 atfork_unlock
2474 av_arylen_p
2475 av_extend_guts
2476 av_iter_p
2477 av_nonelem
2478 av_reify
2479 bind_match
2480 block_gimme
2481 boot_core_builtin
2482 boot_core_mro
2483 boot_core_PerlIO
2484 boot_core_UNIVERSAL
2485 build_infix_plugin
2486 _byte_dump_string
2487 call_list
2488 cando
2489 capture_clear
2490 cast_iv
2491 cast_i32
2492 cast_ulong
2493 cast_uv
2494 check_hash_fields_and_hekify
2495 check_regnode_after
2496 check_utf8_print
2497 ck_anoncode
2498 ck_backtick
2499 ck_bitop
2500 ck_cmp
2501 ck_concat
2502 ck_defined
2503 ck_delete
2504 ck_each
2505 ck_entersub_args_core
2506 ck_eof
2507 ck_eval
2508 ck_exec
2509 ck_exists
2510 ck_ftst
2511 ck_fun
2512 ck_glob
2513 ck_grep
2514 ck_helemexistsor
2515 ck_index
2516 ck_isa
2517 ck_join
2518 ck_length
2519 ck_lfun
2520 ck_listiob
2521 ck_match
2522 ck_method
2523 ck_null
2524 ck_open
2525 ck_prototype
2526 ck_readline
2527 ck_refassign
2528 ck_repeat
2529 ck_require
2530 ck_return
2531 ck_rfun
2532 ck_rvconst
2533 ck_sassign
2534 ck_select
2535 ck_shift
2536 ck_smartmatch
2537 ck_sort
2538 ck_spair
2539 ck_split
2540 ck_stringify
2541 ck_subr
2542 ck_substr
2543 ck_svconst
2544 ck_tell
2545 ck_trunc
2546 ck_trycatch
2547 ckwarn
2548 ckwarn_d
2549 class_add_ADJUST
2550 class_add_field
2551 class_apply_attributes
2552 class_apply_field_attributes
2553 class_prepare_initfield_parse
2554 class_prepare_method_parse
2555 class_seal_stash
2556 class_set_field_defop
2557 class_setup_stash
2558 class_wrap_method_body
2559 clear_defarray
2560 closest_cop
2561 cmpchain_extend
2562 cmpchain_finish
2563 cmpchain_start
2564 cmp_desc
2565 cmp_locale_desc
2566 cntrl_to_mnemonic
2567 construct_ahocorasick_from_trie
2568 cop_file_avn
2569 coresub_op
2570 croak_caller
2571 croak_kw_unless_class
2572 croak_memory_wrap
2573 croak_no_mem
2574 croak_popstack
2575 csighandler
2576 csighandler1
2577 csighandler3
2578 current_re_engine
2579 custom_op_get_field
2580 cv_clone_into
2581 cv_const_sv_or_av
2582 cvgv_from_hek
2583 cvgv_set
2584 cvstash_set
2585 cv_undef_flags
2586 cx_dump
2587 cx_dup
2588 cxinc
2589 deb_stack_all
2590 debstackptrs
2591 debug_hash_seed
2592 debug_peep
2593 debug_show_study_flags
2594 debug_studydata
2595 defelem_target
2596 despatch_signals
2597 die_unwind
2598 do_aexec
2599 do_aexec5
2600 do_aspawn
2601 do_eof
2602 does_utf8_overflow
2603 do_exec
2604 do_exec3
2605 dofile
2606 do_gv_dump
2607 do_gvgv_dump
2608 do_hv_dump
2609 doing_taint
2610 do_ipcctl
2611 do_ipcget
2612 do_magic_dump
2613 do_msgrcv
2614 do_msgsnd
2615 do_ncmp
2616 do_op_dump
2617 do_pmop_dump
2618 do_print
2619 do_readline
2620 doref
2621 do_seek
2622 do_semop
2623 do_shmio
2624 do_spawn
2625 do_spawn_nowait
2626 do_sv_dump
2627 do_sysseek
2628 do_tell
2629 do_trans
2630 do_uniprop_match
2631 do_vecget
2632 do_vecset
2633 do_vop
2634 drand48_init_r
2635 drand48_r
2636 dtrace_probe_call
2637 dtrace_probe_load
2638 dtrace_probe_op
2639 dtrace_probe_phase
2640 dump_all_perl
2641 dump_indent
2642 dump_packsubs_perl
2643 dump_sub_perl
2644 dump_sv_child
2645 dumpuntil
2646 dump_vindent
2647 dup_warnings
2648 find_first_differing_byte_pos
2649 find_lexical_cv
2650 find_runcv_where
2651 find_script
2652 foldEQ_latin1_s2_folded
2653 foldEQ_latin1
2654 foldEQ_utf8_flags
2655 force_locale_unlock
2656 _force_out_malformed_utf8_message
2657 form_alien_digit_msg
2658 form_cp_too_large_msg
2659 free_tied_hv_pool
2660 free_tmps
2661 get_and_check_backslash_N_name
2662 get_ANYOFHbbm_contents
2663 get_ANYOFM_contents
2664 get_db_sub
2665 get_debug_opts
2666 get_deprecated_property_msg
2667 getenv_len
2668 get_extended_os_errno
2669 get_hash_seed
2670 get_invlist_iter_addr
2671 get_invlist_offset_addr
2672 get_invlist_previous_index_addr
2673 get_mstats
2674 get_prop_definition
2675 get_prop_values
2676 get_regclass_aux_data
2677 get_re_gclass_aux_data
2678 get_regex_charset_name
2679 get_win32_message_utf8ness
2680 gp_free
2681 gp_ref
2682 grok_bin_oct_hex
2683 grok_bslash_c
2684 grok_bslash_o
2685 grok_bslash_x
2686 gv_check
2687 gv_fetchmeth_internal
2688 gv_override
2689 gv_setref
2690 gv_stashpvn_internal
2691 he_dup
2692 hek_dup
2693 hfree_next_entry
2694 hv_auxalloc
2695 hv_common
2696 hv_common_key_len
2697 hv_delayfree_ent
2698 hv_free_ent
2699 hv_placeholders_p
2700 hv_pushkv
2701 hv_rand_set
2702 hv_undef_flags
2703 infix_plugin_standard
2704 init_argv_symbols
2705 init_constants
2706 init_dbargs
2707 init_debugger
2708 init_i18nl10n
2709 init_named_cv
2710 init_stacks
2711 init_tm
2712 init_uniprops
2713 _inverse_folds
2714 invert
2715 invlist_array
2716 _invlist_array_init
2717 invlist_clear
2718 invlist_clone
2719 _invlist_contains_cp
2720 invlist_contents
2721 _invlist_dump
2722 _invlistEQ
2723 invlist_extend
2724 invlist_highest
2725 _invlist_intersection
2726 _invlist_intersection_maybe_complement_2nd
2727 _invlist_invert
2728 invlist_is_iterating
2729 invlist_iterfinish
2730 invlist_iterinit
2731 invlist_iternext
2732 _invlist_len
2733 invlist_max
2734 invlist_previous_index
2735 _invlist_search
2736 invlist_set_len
2737 invlist_set_previous_index
2738 _invlist_subtract
2739 invlist_trim
2740 _invlist_union
2741 _invlist_union_maybe_complement_2nd
2742 invmap_dump
2743 invoke_exception_hook
2744 io_close
2745 isFF_overlong
2746 is_grapheme
2747 _is_in_locale_category
2748 is_invlist
2749 is_ssc_worth_it
2750 _is_uni_FOO
2751 _is_uni_perl_idcont
2752 _is_uni_perl_idstart
2753 is_utf8_char_helper_
2754 is_utf8_common
2755 is_utf8_FF_helper_
2756 _is_utf8_FOO
2757 is_utf8_overlong
2758 _is_utf8_perl_idcont
2759 _is_utf8_perl_idstart
2760 jmaybe
2761 join_exact
2762 keyword
2763 keyword_plugin_standard
2764 list
2765 load_charnames
2766 locale_panic
2767 localize
2768 lossless_NV_to_IV
2769 lsbit_pos32
2770 lsbit_pos64
2771 magic_clear_all_env
2772 magic_cleararylen_p
2773 magic_clearenv
2774 magic_clearhook
2775 magic_clearhookall
2776 magic_clearisa
2777 magic_clearpack
2778 magic_clearsig
2779 magic_copycallchecker
2780 magic_existspack
2781 magic_freearylen_p
2782 magic_freecollxfrm
2783 magic_freemglob
2784 magic_freeovrld
2785 magic_freeutf8
2786 magic_get
2787 magic_getarylen
2788 magic_getdebugvar
2789 magic_getdefelem
2790 magic_getnkeys
2791 magic_getpack
2792 magic_getpos
2793 magic_getsig
2794 magic_getsubstr
2795 magic_gettaint
2796 magic_getuvar
2797 magic_getvec
2798 magic_killbackrefs
2799 magic_nextpack
2800 magic_regdata_cnt
2801 magic_regdatum_get
2802 magic_regdatum_set
2803 magic_scalarpack
2804 magic_set
2805 magic_set_all_env
2806 magic_setarylen
2807 magic_setcollxfrm
2808 magic_setdbline
2809 magic_setdebugvar
2810 magic_setdefelem
2811 magic_setenv
2812 magic_sethook
2813 magic_sethookall
2814 magic_setisa
2815 magic_setlvref
2816 magic_setmglob
2817 magic_setnkeys
2818 magic_setnonelem
2819 magic_setpack
2820 magic_setpos
2821 magic_setregexp
2822 magic_setsig
2823 magic_setsigall
2824 magic_setsubstr
2825 magic_settaint
2826 magic_setutf8
2827 magic_setuvar
2828 magic_setvec
2829 magic_sizepack
2830 magic_wipepack
2831 make_trie
2832 malloced_size
2833 malloc_good_size
2834 markstack_grow
2835 mbtowc_
2836 mem_collxfrm_
2837 mem_log_alloc
2838 mem_log_del_sv
2839 mem_log_free
2840 mem_log_new_sv
2841 mem_log_realloc
2842 mg_find_mglob
2843 mg_size
2844 mode_from_discipline
2845 more_bodies
2846 more_sv
2847 moreswitches
2848 mortal_getenv
2849 mortalized_pv_copy
2850 mro_get_private_data
2851 mro_meta_dup
2852 mro_meta_init
2853 msbit_pos32
2854 msbit_pos64
2855 multiconcat_stringify
2856 multideref_stringify
2857 my_atof2
2858 my_atof3
2859 my_attrs
2860 my_clearenv
2861 my_lstat
2862 my_lstat_flags
2863 my_memrchr
2864 my_mkostemp_cloexec
2865 my_mkstemp_cloexec
2866 my_stat
2867 my_stat_flags
2868 my_strerror
2869 my_strftime8_temp
2870 my_unexec
2871 newFORM
2872 _new_invlist
2873 _new_invlist_C_array
2874 newMETHOP_internal
2875 newMYSUB
2876 newPROG
2877 new_stackinfo
2878 newSTUB
2879 newSVavdefelem
2880 newXS_deffile
2881 nextargv
2882 no_bareword_allowed
2883 no_bareword_filehandle
2884 noperl_die
2885 notify_parser_that_changed_to_utf8
2886 oopsAV
2887 oopsHV
2888 op_clear
2889 op_integerize
2890 op_lvalue_flags
2891 opmethod_stash
2892 op_prune_chain_head
2893 op_relocate_sv
2894 opslab_force_free
2895 opslab_free
2896 opslab_free_nopad
2897 op_std_init
2898 op_varname
2899 package
2900 package_version
2901 pad_add_weakref
2902 padlist_store
2903 padname_free
2904 PadnameIN_SCOPE
2905 padnamelist_free
2906 parser_dup
2907 parser_free
2908 parser_free_nexttoke_ops
2909 parse_unicode_opts
2910 path_is_searchable
2911 peep
2912 perl_alloc_using
2913 perl_clone_using
2914 PerlEnv_putenv
2915 PerlIO_context_layers
2916 PerlIO_restore_errno
2917 PerlIO_save_errno
2918 PerlLIO_dup_cloexec
2919 PerlLIO_dup2_cloexec
2920 PerlLIO_open_cloexec
2921 PerlLIO_open3_cloexec
2922 PerlProc_pipe_cloexec
2923 PerlSock_accept_cloexec
2924 PerlSock_socket_cloexec
2925 PerlSock_socketpair_cloexec
2926 perly_sighandler
2927 pmruntime
2928 POPMARK
2929 populate_anyof_bitmap_from_invlist
2930 populate_bitmap_from_invlist
2931 populate_invlist_from_bitmap
2932 populate_isa
2933 pregfree
2934 pregfree2
2935 ptr_hash
2936 qerror
2937 ReANY
2938 reentrant_free
2939 reentrant_init
2940 reentrant_retry
2941 reentrant_size
2942 re_exec_indentf
2943 ref
2944 reg_add_data
2945 regcurly
2946 regdump
2947 regdupe_internal
2948 regexec_flags
2949 regfree_internal
2950 reginitcolors
2951 reg_named_buff
2952 reg_named_buff_all
2953 reg_named_buff_exists
2954 reg_named_buff_fetch
2955 reg_named_buff_firstkey
2956 reg_named_buff_iter
2957 reg_named_buff_nextkey
2958 reg_named_buff_scalar
2959 regnext
2960 regnode_after
2961 reg_numbered_buff_fetch
2962 reg_numbered_buff_fetch_flags
2963 reg_numbered_buff_length
2964 reg_numbered_buff_store
2965 regprop
2966 reg_qr_package
2967 reg_skipcomment
2968 reg_temp_copy
2969 re_indentf
2970 re_intuit_start
2971 re_intuit_string
2972 re_op_compile
2973 report_evil_fh
2974 report_redefined_cv
2975 report_wrongway_fh
2976 re_printf
2977 rpeep
2978 rsignal_restore
2979 rsignal_save
2980 rvpv_dup
2981 rxres_save
2982 same_dirent
2983 save_bool
2984 save_clearsv
2985 save_delete
2986 save_destructor
2987 save_destructor_x
2988 save_freeop
2989 save_freepv
2990 save_freesv
2991 save_int
2992 save_iv
2993 save_I8
2994 save_I16
2995 save_I32
2996 save_mortalizesv
2997 save_pptr
2998 save_pushi32ptr
2999 save_pushptrptr
3000 save_re_context
3001 save_sptr
3002 savestack_grow
3003 savestack_grow_cnt
3004 save_strlen
3005 sawparens
3006 scalar
3007 scalarvoid
3008 scan_commit
3009 scan_num
3010 seed
3011 set_ANYOF_arg
3012 set_caret_X
3013 setfd_cloexec
3014 setfd_cloexec_for_nonsysfd
3015 setfd_cloexec_or_inhexec_by_sysfdness
3016 setfd_inhexec
3017 setfd_inhexec_for_sysfd
3018 set_numeric_standard
3019 set_numeric_underlying
3020 set_padlist
3021 _setup_canned_invlist
3022 share_hek
3023 should_warn_nl
3024 should_we_output_Debug_r
3025 sighandler
3026 sighandler1
3027 sighandler3
3028 single_1bit_pos32
3029 single_1bit_pos64
3030 Slab_Alloc
3031 Slab_Free
3032 Slab_to_ro
3033 Slab_to_rw
3034 softref2xv
3035 sortsv_flags_impl
3036 ssc_finalize
3037 ssc_init
3038 stack_grow
3039 str_to_version
3040 strxfrm
3041 study_chunk
3042 sub_crush_depth
3043 sv_add_backref
3044 sv_buf_to_ro
3045 sv_del_backref
3046 sv_i_ncmp
3047 sv_i_ncmp_desc
3048 sv_2iv
3049 sv_magicext_mglob
3050 sv_ncmp
3051 sv_ncmp_desc
3052 sv_only_taint_gmagic
3053 sv_or_pv_pos_u2b
3054 sv_pvbyten_force_wrapper
3055 sv_pvutf8n_force_wrapper
3056 sv_resetpvn
3057 sv_sethek
3058 SvTRUE_common
3059 sv_unglob
3060 sv_2uv
3061 switch_locale_context
3062 sys_init
3063 sys_init3
3064 sys_intern_clear
3065 sys_intern_dup
3066 sys_intern_init
3067 sys_term
3068 tied_method
3069 tmps_grow_p
3070 _to_fold_latin1
3071 TOPMARK
3072 to_uni_fold
3073 _to_uni_fold_flags
3074 to_uni_lower
3075 to_uni_title
3076 to_uni_upper
3077 _to_upper_title_latin1
3078 _to_utf8_fold_flags
3079 _to_utf8_lower_flags
3080 _to_utf8_title_flags
3081 _to_utf8_upper_flags
3082 translate_substr_offsets
3083 try_amagic_bin
3084 try_amagic_un
3085 uiv_2buf
3086 unlnk
3087 unshare_hek
3088 unwind_paren
3089 _utf8n_to_uvchr_msgs_helper
3090 utf16_to_utf8_base
3091 utf16_to_utf8_reversed
3092 utf16_to_utf8
3093 utf8_to_uvchr_buf_helper
3094 utilize
3095 uvoffuni_to_utf8_flags_msgs
3096 uvuni_to_utf8
3097 variant_byte_number
3098 varname
3099 vivify_defelem
3100 vivify_ref
3101 wait4pid
3102 warn_elem_scalar_context
3103 _warn_problematic_locale
3104 was_lvalue_sub
3105 watch
3106 win32_croak_not_implemented
3107 write_to_stderr
3108 xs_boot_epilog
3109 xs_handshake
3110 yyerror
3111 yyerror_pv
3112 yyerror_pvn
3113 yylex
3114 yyparse
3115 yyquit
3116 yyunlex
3117 Next are the experimental undocumented elements
3119 alloc_LOGOP cx_pushloop_for invlist_lowest
3121 create_eval_scope cx_pushloop_plain newGP
3122 cv_ckproto_len_flags cx_pushsub new_warnings_bitfield
3123 cx_popblock cx_pushtry op_refcnt_dec
3124 cx_popeval cx_pushwhen op_refcnt_inc
3125 cx_popformat cx_topblock op_unscope
3126 cx_popgiven delete_eval_scope scan_str
3127 cx_poploop do_open_raw scan_word
3128 cx_popsub do_open6 scan_word6
3129 cx_popsub_args emulate_cop_io skipspace_flags
3130 cx_popsub_common get_re_arg sv_free2
3131 cx_popwhen get_vtbl sv_kill_backrefs
3132 cx_pushblock gimme_V sv_setpv_freshbuf
3133 cx_pusheval hv_backreferences_p sv_setsv_cow
3134 cx_pushformat hv_kill_backrefs utf8_to_utf16_base
3135 cx_pushgiven invlist_highest_range_start
3136 Finally are the deprecated undocumented elements. Do not use any for
3138 new code; remove all occurrences of all of these from existing code.
3139 get_no_modify get_opargs get_ppaddr
3141
3143 The autodocumentation system was originally added to the Perl core by
3144 Benjamin Stuhl. Documentation is by whoever was kind enough to
3145 document their functions.
3146
3148 config.h, perlapi, perlapio, perlcall, perlclib, perlembed, perlfilter,
3149 perlguts, perlhacktips, perlinterp, perliol, perlmroapi, perlreapi,
3150 perlreguts, perlxs
3151perl v5.38.2 2023-11-30 PERLINTERN(1)