NAME
perlintern - autogenerated documentation of purely internal Perl functions DESCRIPTION This file is the autogenerated documentation of functions in the Perl interpreter that are documented using Perl's internal documentation format but are not marked as part of the Perl API. In other words, they are not for use in extensions!
Compile-time scope hooks BhkENTRY Return an entry from the BHK structure. which is a preprocessor token indicating which entry to return. If the appropriate flag is not set this will return NULL. The type of the return value depends on which entry you ask for. NOTE: this function is experimental and may change or be removed without notice. void * BhkENTRY(BHK *hk, which) BhkFLAGS Return the BHK's flags. NOTE: this function is experimental and may change or be removed without notice. U32 BhkFLAGS(BHK *hk) CALLBLOCKHOOKS Call all the registered block hooks for type which. which is a preprocessing token; the type of arg depends on which. NOTE: this function is experimental and may change or be removed without notice. void CALLBLOCKHOOKS(which, arg) CV reference counts and CvOUTSIDE CvWEAKOUTSIDE Each CV has a pointer, "CvOUTSIDE()", to its lexically enclosing CV (if any). Because pointers to anonymous sub prototypes are stored in "&" pad slots, it is a possible to get a circular reference, with the parent pointing to the child and
vice-versa. To avoid the ensuing memory leak, we do not increment the reference count of the CV pointed to by "CvOUTSIDE" in the one specific instance that the parent has a "&" pad slot pointing back to us. In this case, we set the "CvWEAKOUTSIDE" flag in the child. This allows us to determine under what circumstances we should decrement the refcount of the parent when freeing the child.
There is a further complication with non-closure anonymous subs (i.e. those that do not refer to any lexicals outside that sub). In this case, the anonymous prototype is shared rather than being cloned. This has the consequence that the parent may be freed while there are still active children, eg
BEGIN { $a = sub { eval '$x' } } In this case, the BEGIN is freed immediately after execution since there are no active references to it: the anon sub prototype has "CvWEAKOUTSIDE" set since it's not a closure, and
$a points to the same CV, so it doesn't contribute to BEGIN's
refcount either. When $a is executed, the "eval '$x'" causes the chain of "CvOUTSIDE"s to be followed, and the freed BEGIN is accessed. To avoid this, whenever a CV and its associated pad is freed, any "&" entries in the pad are explicitly removed from the pad,
and if the refcount of the pointed-to anon sub is still positive, then that child's "CvOUTSIDE" is set to point to its grandparent. This will only occur in the single specific case
of a non-closure anon prototype having one or more active
references (such as $a above). One other thing to consider is that a CV may be merely undefined rather than freed, eg "undef &foo". In this case, its refcount may not have reached zero, but we still delete its pad and its "CvROOT" etc. Since various children may still have their "CvOUTSIDE" pointing at this undefined CV, we keep its own "CvOUTSIDE" for the time being, so that the chain of lexical scopes is unbroken. For example, the following should print 123:
my $x = 123;
sub tmp { sub { eval '$x' } }
my $a = tmp(); undef &tmp;
print $a->(); bool CvWEAKOUTSIDE(CV *cv) Embedding Functions cvdump dump the contents of a CV void cvdump(CV *cv, const char *title) dodumppad Dump the contents of a padlist void dodumppad(I32 level, PerlIO *file, PADLIST *padlist, int full) intromy "Introduce" my variables to visible status. U32 intromy() padlistdup Duplicates a pad. AV * padlistdup(AV *srcpad, CLONEPARAMS *param) padallocname
Allocates a place in the currently-compiling pad (via "padalloc" in perlapi) and then stores a name for that entry. namesv is adopted and becomes the name entry; it must already contain the name string and be sufficiently upgraded. typestash and ourstash and the "padaddSTATE" flag get added to namesv. None of the other processing of "padaddnamepvn" in perlapi is done. Returns the offset of the allocated pad slot. PADOFFSET padallocname(SV *namesv, U32 flags, HV *typestash, HV *ourstash) padblockstart Update the pad compilation state variables on entry to a new block void padblockstart(int full) padcheckdup Check for duplicate declarations: report any of: * a my in the current scope with the same name; * an our (anywhere in the pad) with the same name and the same stash as C
"isour" indicates that the name to check is an 'our' declaration. void padcheckdup(SV *name, U32 flags, const HV *ourstash) padfindlex Find a named lexical anywhere in a chain of nested pads. Add fake entries in the inner pads if it's found in an outer one. Returns the offset in the bottom pad of the lex or the fake lex. cv is the CV in which to start the search, and seq is the current copseq to match against. If warn is true, print appropriate warnings. The out* vars return values, and so are pointers to where the returned values should be stored. outcapture, if non-null, requests that the innermost instance of the lexical is captured; outnamesv is set to the innermost matched namesv or fake namesv; outflags returns the flags normally associated with the IVX field of a fake namesv. Note that padfindlex() is recursive; it recurses up the chain of CVs, then comes back down, adding fake entries as it goes. It has to be this way because fake namesvs in anon protoypes have to store in xlow the index into the parent pad. PADOFFSET padfindlex(const char *namepv, STRLEN namelen, U32 flags, const CV* cv, U32 seq, int warn, SV** outcapture, SV** outnamesv, int *outflags) padfixupinneranons For any anon CVs in the pad, change CvOUTSIDE of that CV from
oldcv to newcv if necessary. Needed when a newly-compiled CV
has to be moved to a pre-existing CV struct. void padfixupinneranons(PADLIST *padlist, CV *oldcv, CV *newcv) padfree Free the SV at offset po in the current pad. void padfree(PADOFFSET po) padleavemy Cleanup at end of scope during compilation: set the max seq number for lexicals in this scope and warn of any lexicals that never got introduced. void padleavemy() padpush Push a new pad frame onto the padlist, unless there's already a pad at this depth, in which case don't bother creating a new one. Then give the new pad an @ in slot zero. void padpush(PADLIST *padlist, int depth) padreset Mark all the current temporaries for reuse void padreset() padswipe Abandon the tmp in the current pad at offset po and replace with a new one. void padswipe(PADOFFSET po, bool refadjust) Functions in file op.c coreprototype This function assigns the prototype of the named core function to "sv", or to a new mortal SV if "sv" is NULL. It returns the modified "sv", or NULL if the core function has no prototype. "code" is a code as returned by "keyword()". It must be
negative and unequal to -KEYCORE. SV * coreprototype(SV *sv, const char *name, const int code, int * const opnum) Functions in file ppctl.c docatch Check for the cases 0 or 3 of curenv.jeret, only used inside an eval context. 0 is used as continue inside eval,
3 is used for a die caught by an inner eval - continue inner loop See cop.h: jemustcatch, when set at any runlevel to TRUE, means eval ops must establish a local jmpenv to handle exception traps. OP* docatch(OP *o) GV Functions gvtrydowngrade If the typeglob "gv" can be expressed more succinctly, by having something other than a real GV in its place in the stash, replace it with the optimised form. Basic requirements for this are that "gv" is a real typeglob, is sufficiently ordinary, and is only referenced from its package. This function is meant to be used when a GV has been looked up in part to see what was there, causing upgrading, but based on what was found it turns out that the real GV isn't required after all. If "gv" is a completely empty typeglob, it is deleted from the stash.
If "gv" is a typeglob containing only a sufficiently-ordinary
constant sub, the typeglob is replaced with a scalar-reference placeholder that more compactly represents the same thing. NOTE: this function is experimental and may change or be removed without notice. void gvtrydowngrade(GV* gv) Hash Manipulation Functions hvenameadd Adds a name to a stash's internal list of effective names. See "hvenamedelete". This is called when a stash is assigned to a new location in the symbol table. void hvenameadd(HV *hv, const char *name, U32 len, U32 flags) hvenamedelete Removes a name from a stash's internal list of effective names. If this is the name returned by "HvENAME", then another name in the list will take its place ("HvENAME" will use it). This is called when a stash is deleted from the symbol table. void hvenamedelete(HV *hv, const char *name, U32 len, U32 flags) refcountedhechain2hv Generates and returns a "HV *" representing the content of a "refcountedhe" chain. flags is currently unused and must be zero. HV * refcountedhechain2hv( const struct refcountedhe *c, U32 flags ) refcountedhefetchpv
Like "refcountedhefetchpvn", but takes a nul-terminated string instead of a string/length pair. SV * refcountedhefetchpv( const struct refcountedhe *chain, const char *key, U32 hash, U32 flags ) refcountedhefetchpvn Search along a "refcountedhe" chain for an entry with the key specified by keypv and keylen. If flags has the "REFCOUNTEDHEKEYUTF8" bit set, the key octets are
interpreted as UTF-8, otherwise they are interpreted as
Latin-1. hash is a precomputed hash of the key string, or zero if it has not been precomputed. Returns a mortal scalar representing the value associated with the key, or &PLsvplaceholder if there is no value associated with the key. SV * refcountedhefetchpvn( const struct refcountedhe *chain, const char *keypv, STRLEN keylen, U32 hash, U32 flags ) refcountedhefetchpvs Like "refcountedhefetchpvn", but takes a literal string instead of a string/length pair, and no precomputed hash. SV * refcountedhefetchpvs( const struct refcountedhe *chain, const char *key, U32 flags ) refcountedhefetchsv Like "refcountedhefetchpvn", but takes a Perl scalar instead of a string/length pair. SV * refcountedhefetchsv( const struct refcountedhe *chain, SV *key, U32 hash, U32 flags ) refcountedhefree Decrements the reference count of a "refcountedhe" by one. If the reference count reaches zero the structure's memory is freed, which (recursively) causes a reduction of its parent "refcountedhe"'s reference count. It is safe to pass a null pointer to this function: no action occurs in this case. void refcountedhefree(struct refcountedhe *he) refcountedheinc Increment the reference count of a "refcountedhe". The pointer to the "refcountedhe" is also returned. It is safe to pass a null pointer to this function: no action occurs and a null pointer is returned. struct refcountedhe * refcountedheinc( struct refcountedhe *he ) refcountedhenewpv
Like "refcountedhenewpvn", but takes a nul-terminated string instead of a string/length pair. struct refcountedhe * refcountedhenewpv( struct refcountedhe *parent, const char *key, U32 hash, SV *value, U32 flags ) refcountedhenewpvn Creates a new "refcountedhe". This consists of a single key/value pair and a reference to an existing "refcountedhe" chain (which may be empty), and thus forms a longer chain. When using the longer chain, the new key/value pair takes precedence over any entry for the same key further along the chain. The new key is specified by keypv and keylen. If flags has the "REFCOUNTEDHEKEYUTF8" bit set, the key octets are
interpreted as UTF-8, otherwise they are interpreted as
Latin-1. hash is a precomputed hash of the key string, or zero if it has not been precomputed. value is the scalar value to store for this key. value is copied by this function, which thus does not take ownership of any reference to it, and later changes to the scalar will not be reflected in the value visible in the "refcountedhe". Complex types of scalar will not be stored with referential integrity, but will be coerced to strings. value may be either null or &PLsvplaceholder to indicate that no value is to be
associated with the key; this, as with any non-null value, takes precedence over the existence of a value for the key further along the chain. parent points to the rest of the "refcountedhe" chain to be attached to the new "refcountedhe". This function takes ownership of one reference to parent, and returns one reference to the new "refcountedhe". struct refcountedhe * refcountedhenewpvn( struct refcountedhe *parent, const char *keypv, STRLEN keylen, U32 hash, SV *value, U32 flags ) refcountedhenewpvs Like "refcountedhenewpvn", but takes a literal string instead of a string/length pair, and no precomputed hash. struct refcountedhe * refcountedhenewpvs( struct refcountedhe *parent, const char *key, SV *value, U32 flags ) refcountedhenewsv Like "refcountedhenewpvn", but takes a Perl scalar instead of a string/length pair. struct refcountedhe * refcountedhenewsv( struct refcountedhe *parent, SV *key, U32 hash, SV *value, U32 flags ) IO Functions startglob Function called by "doreadline" to spawn a glob (or do the glob inside perl on VMS). This code used to be inline, but now perl uses "File::Glob" this glob starter is only used by miniperl during the build process. Moving it away shrinks pphot.c; shrinking pphot.c helps speed perl up. NOTE: this function is experimental and may change or be removed without notice. PerlIO* startglob(SV *tmpglob, IO *io) Magical Functions magicclearhint
Triggered by a delete from %^H, records the key to "PLcompiling.cophintshash". int magicclearhint(SV* sv, MAGIC* mg) magicclearhints
Triggered by clearing %^H, resets "PLcompiling.cophintshash". int magicclearhints(SV* sv, MAGIC* mg) magicmethcall Invoke a magic method (like FETCH). "sv" and "mg" are the tied thingy and the tie magic. "meth" is the name of the method to call.
"argc" is the number of args (in addition to $self) to pass to the method. The "flags" can be: GDISCARD invoke method with GDISCARD flag and don't return a value GUNDEFFILL fill the stack with argc pointers to PLsvundef The arguments themselves are any values following the "flags" argument. Returns the SV (if any) returned by the method, or NULL on failure. SV* magicmethcall(SV *sv, const MAGIC *mg, const char *meth, U32 flags, U32 argc, ...) magicsethint
Triggered by a store to %^H, records the key/value pair to "PLcompiling.cophintshash". It is assumed that hints aren't storing anything that would need a deep copy. Maybe we should warn if we find a reference. int magicsethint(SV* sv, MAGIC* mg) mglocalize Copy some of the magic from an existing SV to new localized
version of that SV. Container magic (eg %ENV, $1, tie) gets copied, value magic doesn't (eg taint, pos). If setmagic is false then no set magic will be called on the new (empty) SV. This typically means that assignment will soon
follow (e.g. 'local $x = $y'), and that will handle the magic. void mglocalize(SV* sv, SV* nsv, bool setmagic) MRO Functions mrogetlinearisadfs
Returns the Depth-First Search linearization of @ISA the given
stash. The return value is a read-only AV*. "level" should be 0 (it is used internally in this function's recursion). You are responsible for "SvREFCNTinc()" on the return value if
you plan to store it anywhere semi-permanently (otherwise it might be deleted out from under you the next time the cache is invalidated). AV* mrogetlinearisadfs(HV* stash, U32 level) mroisachangedin Takes the necessary steps (cache invalidations, mostly) when the @ISA of the given package has changed. Invoked by the "setisa" magic, should not need to invoke directly. void mroisachangedin(HV* stash) mropackagemoved Call this function to signal to a stash that it has been assigned to another spot in the stash hierarchy. "stash" is the stash that has been assigned. "oldstash" is the stash it replaces, if any. "gv" is the glob that is actually being assigned to. This can also be called with a null first argument to indicate that "oldstash" has been deleted. This function invalidates isa caches on the old stash, on all subpackages nested inside it, and on the subclasses of all
those, including non-existent packages that have corresponding entries in "stash". It also sets the effective names ("HvENAME") on all the stashes as appropriate. If the "gv" is present and is not in the symbol table, then this function simply returns. This checked will be skipped if "flags & 1". void mropackagemoved(HV * const stash, HV * const oldstash, const GV * const gv, U32 flags) Optree Manipulation Functions finalizeoptree This function finalizes the optree. Should be called directly after the complete optree is built. It does some additional checking which can't be done in the normal ckxxx functions and
makes the tree thread-safe. void finalizeoptree(OP* o) Pad Data Structures CXCURPADSAVE Save the current pad in the given context block structure. void CXCURPADSAVE(struct context) CXCURPADSV Access the SV at offset po in the saved current pad in the given context block structure (can be used as an lvalue). SV * CXCURPADSV(struct context, PADOFFSET po) PADBASESV Get the value from slot "po" in the base (DEPTH=1) pad of a padlist SV * PADBASESV(PADLIST padlist, PADOFFSET po) PADCLONEVARS Clone the state variables associated with running and compiling pads. void PADCLONEVARS(PerlInterpreter *protoperl, CLONEPARAMS* param) PADCOMPNAMEFLAGS Return the flags for the current compiling pad name at offset "po". Assumes a valid slot entry. U32 PADCOMPNAMEFLAGS(PADOFFSET po) PADCOMPNAMEGEN The generation number of the name at offset "po" in the current compiling pad (lvalue). Note that "SvUVX" is hijacked for this purpose. STRLEN PADCOMPNAMEGEN(PADOFFSET po) PADCOMPNAMEGENset Sets the generation number of the name at offset "po" in the current ling pad (lvalue) to "gen". Note that "SvUVset" is hijacked for this purpose. STRLEN PADCOMPNAMEGENset(PADOFFSET po, int gen) PADCOMPNAMEOURSTASH Return the stash associated with an "our" variable. Assumes the slot entry is a valid "our" lexical. HV * PADCOMPNAMEOURSTASH(PADOFFSET po) PADCOMPNAMEPV Return the name of the current compiling pad name at offset "po". Assumes a valid slot entry. char * PADCOMPNAMEPV(PADOFFSET po) PADCOMPNAMETYPE Return the type (stash) of the current compiling pad name at offset "po". Must be a valid name. Returns null if not typed. HV * PADCOMPNAMETYPE(PADOFFSET po)
padpeg When PERLMAD is enabled, this is a small no-op function that
gets called at the start of each pad-related function. It can be breakpointed to track all pad operations. The parameter is a string indicating the type of pad operation being performed. NOTE: this function is experimental and may change or be removed without notice. void padpeg(const char *s) PADRESTORELOCAL Restore the old pad saved into the local variable opad by PADSAVELOCAL() void PADRESTORELOCAL(PAD *opad) PADSAVELOCAL Save the current pad to the local variable opad, then make the current pad equal to npad void PADSAVELOCAL(PAD *opad, PAD *npad) PADSAVESETNULLPAD Save the current pad then set it to null. void PADSAVESETNULLPAD() PADSETSV Set the slot at offset "po" in the current pad to "sv" SV * PADSETSV(PADOFFSET po, SV* sv) PADSETCUR Set the current pad to be pad "n" in the padlist, saving the previous current pad. NB currently this macro expands to a string too long for some compilers, so it's best to replace it with SAVECOMPPAD(); PADSETCURNOSAVE(padlist,n); void PADSETCUR(PADLIST padlist, I32 n) PADSETCURNOSAVE like PADSETCUR, but without the save void PADSETCURNOSAVE(PADLIST padlist, I32 n) PADSV Get the value at offset "po" in the current pad void PADSV(PADOFFSET po) PADSVl Lightweight and lvalue version of "PADSV". Get or set the value at offset "po" in the current pad. Unlike "PADSV", does
not print diagnostics with -DX. For internal use only. SV * PADSVl(PADOFFSET po) SAVECLEARSV Clear the pointed to pad value on scope exit. (i.e. the runtime action of 'my') void SAVECLEARSV(SV **svp) SAVECOMPPAD save PLcomppad and PLcurpad void SAVECOMPPAD() SAVEPADSV Save a pad slot (used to restore after an iteration) XXX DAPM it would make more sense to make the arg a PADOFFSET void SAVEPADSV(PADOFFSET po)
Per-Interpreter Variables PLDBsingle
When Perl is run in debugging mode, with the -d switch, this SV
is a boolean which indicates whether subs are being single-
stepped. Single-stepping is automatically turned on after every step. This is the C variable which corresponds to Perl's
$DB::single variable. See "PLDBsub". SV * PLDBsingle PLDBsub
When Perl is run in debugging mode, with the -d switch, this GV contains the SV which holds the name of the sub being debugged.
This is the C variable which corresponds to Perl's $DB::sub variable. See "PLDBsingle". GV * PLDBsub PLDBtrace Trace variable used when Perl is run in debugging mode, with
the -d switch. This is the C variable which corresponds to
Perl's $DB::trace variable. See "PLDBsingle". SV * PLDBtrace PLdowarn
The C variable which corresponds to Perl's $^W warning variable. bool PLdowarn PLlastingv The GV which was last used for a filehandle input operation. ("
") GV* PLlastingv PLofsgv The glob containing the output field separator - "*," in Perl space. GV* PLofsgv
PLrs The input record separator - $/ in Perl space. SV* PLrs Stack Manipulation Macros djSP Declare Just "SP". This is actually identical to "dSP", and declares a local copy of perl's stack pointer, available via the "SP" macro. See "SP". (Available for backward source code compatibility with the old (Perl 5.005) thread model.) djSP; LVRET True if this op will be the return value of an lvalue subroutine SV Manipulation Functions svaddarena Given a chunk of memory, link it to the head of the list of arenas, and split it into a list of free SVs. void svaddarena(char *const ptr, const U32 size, const U32 flags) svcleanall Decrement the refcnt of each remaining SV, possibly triggering a cleanup. This function may have to be called multiple times
to free SVs which are in complex self-referential hierarchies. I32 svcleanall() svcleanobjs Attempt to destroy all objects not yet freed. void svcleanobjs() svfreearenas Deallocate the memory used by all arenas. Note that all the individual SV heads and bodies within the arenas must already have been freed. void svfreearenas()
SV-Body Allocation sv2num Return an SV with the numeric value of the source SV, doing any necessary reference or overload conversion. You must use the "SvNUM(sv)" macro to access this function. NOTE: this function is experimental and may change or be removed without notice. SV* sv2num(SV *const sv) svref Returns a SV describing what the SV passed in is a reference to. SV* svref(SV *dst, const SV *const sv, const int ob) Unicode Support finduninitvar Find the name of the undefined variable (if any) that caused the operator to issue a "Use of uninitialized value" warning. If match is true, only return a name if its value matches uninitsv. So roughly speaking, if a unary operator (such as OPCOS) generates a warning, then following the direct child of the op may yield an OPPADSV or OPGV that gives the name of the undefined variable. On the other hand, with OPADD there are two branches to follow, so we only print the variable name if we get an exact match. The name is returned as a mortal SV. Assumes that PLop is the op that originally triggered the error, and that PLcomppad/PLcurpad points to the currently executing pad. NOTE: this function is experimental and may change or be removed without notice. SV* finduninitvar(const OP *const obase, const SV *const uninitsv, bool top) reportuninit Print appropriate "Use of uninitialized variable" warning. void reportuninit(const SV *uninitsv) Undocumented functions The following functions are currently undocumented. If you use one of them, you may wish to consider creating and submitting documentation for it. addrangetoinvlist coreswashinit invlistarrayinit invlistcontents invlistintersection invlistintersectionmaybecomplement2nd invlistinvert invlistinvertprop invlistpopulateswatch invlistsubtract invlistunion invlistunionmaybecomplement2nd isutf8perlidstart newinvlist swashinversionhash swashtoinvlist tofoldlatin1 touppertitlelatin1 aassigncommonvars addcptoinvlist addmad allocmy amagicisenabled appendmadprops apply avreify bindmatch blockend blockstart bootcorePerlIO bootcoreUNIVERSAL bootcoremro cando checkutf8print ckentersubargscore convert coresubop createevalscope cvckprotolenflags cvgvset cvstashset debstackall deleteevalscope dieunwind doaexec doaexec5 doeof doexec doexec3 doexecfree doipcctl doipcget domsgrcv domsgsnd doncmp doopxmldump dopmopxmldump doprint doreadline doseek dosemop doshmio dosysseek dotell dotrans dovecget dovecset dovop dofile dumpallperl dumppacksubsperl dumpsubperl dumpsvchild emulatecopio featureisenabled findrundefsv2 findscript freetiedhvpool getdbsub getdebugopts gethashseed getinvlistiteraddr getinvlistlenaddr getinvlistversionidaddr getinvlistzeroaddr getnomodify getopargs getrearg getenvlen hfreenextentry hvbackreferencesp hvkillbackrefs hvundefflags initargvsymbols initdbargs initdebugger invert invlistarray invlistclone invlistiterinit invlistlen invlistmax invlistsetlen invlisttrim ioclose isutf8XL isutf8XLV isutf8XLVT isutf8XLVLVTV isutf8XT isutf8XV isutf8Xbegin isutf8Xextend isutf8Xnonhangul isutf8Xprepend jmaybe keyword keywordpluginstandard list localize madfree madlex madparse magicclearallenv magicclearenv magicclearisa magicclearpack magicclearsig magicexistspack magicfreearylenp magicfreeovrld magicget magicgetarylen magicgetdefelem magicgetnkeys magicgetpack magicgetpos magicgetsig magicgetsubstr magicgettaint magicgetuvar magicgetvec magickillbackrefs magiclen magicnextpack magicregdatacnt magicregdatumget magicregdatumset magicscalarpack magicset magicsetallenv magicsetamagic magicsetarylen magicsetcollxfrm magicsetdbline magicsetdefelem magicsetenv magicsetisa magicsetmglob magicsetnkeys magicsetpack magicsetpos magicsetregexp magicsetsig magicsetsubstr magicsettaint magicsetutf8 magicsetuvar magicsetvec magicsetvstring magicsizepack magicwipepack mallocgoodsize mallocedsize memcollxfrm modefromdiscipline morebodies mrometadup mrometainit mungeqwlisttoparenlist myattrs mybetoh16 mybetoh32 mybetoh64 mybetohi mybetohl mybetohs myclearenv myhtobe16 myhtobe32 myhtobe64 myhtobei myhtobel myhtobes myhtole16 myhtole32 myhtole64 myhtolei myhtolel myhtoles myletoh16 myletoh32 myletoh64 myletohi myletohl myletohs mylstatflags mystatflags myswabn myunexec newATTRSUBflags newGP newMADPROP newMADsv newTOKEN newXSlenflags newwarningsbitfield nextargv oopsAV oopsHV opclear opconstsv opgetmad opgetmadweak opintegerize oplvalueflags oprefcntdec oprefcntinc opstdinit opxmldump package packageversion parseunicodeopts parserfree peep pendingSlabstoro pmopxmldump pmruntime populateisa prependmadprops qerror regnamedbuff regnamedbuffiter regnumberedbufffetch regnumberedbufflength regnumberedbuffstore regqrpackage regtempcopy regcurly regprop reportevilfh reportredefinedcv reportwrongwayfh rpeep rsignalrestore rsignalsave rxressave samedirent sawparens scalar scalarvoid setregclassbit sighandler softref2xv subcrushdepth svaddbackref svcatxmlpv svcatxmlpvn svcatxmlsv svcompile2opisbroken svdelbackref svfree2 svkillbackrefs svsethek svsetsvcow svunglob svxmlpeek tiedmethod tokenfree tokengetmad translatesubstroffsets tryamagicbin tryamagicun unsharehek utilize varname vivifydefelem vivifyref wait4pid waslvaluesub watch writetostderr xmldumpall xmldumpallperl xmldumpeval xmldumpform xmldumpindent xmldumppacksubs xmldumppacksubsperl xmldumpsub xmldumpsubperl xmldumpvindent xsapiversionbootcheck xsversionbootcheck yyerror yyerrorpv yyerrorpvn yylex yyparse yyunlex AUTHORS The autodocumentation system was originally added to the Perl core by Benjamin Stuhl. Documentation is by whoever was kind enough to document their functions. SEE ALSO perlguts, perlapi
perl v5.16.3 2018-10-30 PERLINTERN(1)