+-*- buffer-read-only: t -*-
+
+!!!!!!! DO NOT EDIT THIS FILE !!!!!!!
+This file is built by autodoc.pl extracting documentation from the C source
+files.
+
=head1 NAME
perlintern - autogenerated documentation of purely B<internal>
Perl functions
=head1 DESCRIPTION
+X<internal Perl functions> X<interpreter functions>
This file is the autogenerated documentation of functions in the
Perl interpreter that are documented using Perl's internal documentation
=over 8
=item CvWEAKOUTSIDE
+X<CvWEAKOUTSIDE>
Each CV has a pointer, C<CvOUTSIDE()>, to its lexically enclosing
CV (if any). Because pointers to anonymous sub prototypes are
=over 8
=item CX_CURPAD_SAVE
+X<CX_CURPAD_SAVE>
Save the current pad in the given context block structure.
Found in file pad.h
=item CX_CURPAD_SV
+X<CX_CURPAD_SV>
Access the SV at offset po in the saved current pad in the given
context block structure (can be used as an lvalue).
=for hackers
Found in file pad.h
-=item PAD_BASE_SV
+=item PAD_BASE_SV
+X<PAD_BASE_SV>
Get the value from slot C<po> in the base (DEPTH=1) pad of a padlist
- SV * PAD_BASE_SV (PADLIST padlist, PADOFFSET po)
+ SV * PAD_BASE_SV(PADLIST padlist, PADOFFSET po)
=for hackers
Found in file pad.h
=item PAD_CLONE_VARS
+X<PAD_CLONE_VARS>
|CLONE_PARAMS* param
Clone the state variables associated with running and compiling pads.
Found in file pad.h
=item PAD_COMPNAME_FLAGS
+X<PAD_COMPNAME_FLAGS>
Return the flags for the current compiling pad name
at offset C<po>. Assumes a valid slot entry.
Found in file pad.h
=item PAD_COMPNAME_GEN
+X<PAD_COMPNAME_GEN>
The generation number of the name at offset C<po> in the current
-compiling pad (lvalue). Note that C<SvCUR> is hijacked for this purpose.
+compiling pad (lvalue). Note that C<SvUVX> is hijacked for this purpose.
STRLEN PAD_COMPNAME_GEN(PADOFFSET po)
Found in file pad.h
=item PAD_COMPNAME_GEN_set
+X<PAD_COMPNAME_GEN_set>
Sets the generation number of the name at offset C<po> in the current
-ling pad (lvalue) to C<gen>. Note that C<SvCUR_set> is hijacked for this purpose.
+ling pad (lvalue) to C<gen>. Note that C<SvUV_set> is hijacked for this purpose.
STRLEN PAD_COMPNAME_GEN_set(PADOFFSET po, int gen)
Found in file pad.h
=item PAD_COMPNAME_OURSTASH
+X<PAD_COMPNAME_OURSTASH>
Return the stash associated with an C<our> variable.
Assumes the slot entry is a valid C<our> lexical.
Found in file pad.h
=item PAD_COMPNAME_PV
+X<PAD_COMPNAME_PV>
Return the name of the current compiling pad name
at offset C<po>. Assumes a valid slot entry.
Found in file pad.h
=item PAD_COMPNAME_TYPE
+X<PAD_COMPNAME_TYPE>
Return the type (stash) of the current compiling pad name at offset
C<po>. Must be a valid name. Returns null if not typed.
Found in file pad.h
=item PAD_DUP
+X<PAD_DUP>
Clone a padlist.
Found in file pad.h
=item PAD_RESTORE_LOCAL
+X<PAD_RESTORE_LOCAL>
Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL()
Found in file pad.h
=item PAD_SAVE_LOCAL
+X<PAD_SAVE_LOCAL>
Save the current pad to the local variable opad, then make the
current pad equal to npad
Found in file pad.h
=item PAD_SAVE_SETNULLPAD
+X<PAD_SAVE_SETNULLPAD>
Save the current pad then set it to null.
=for hackers
Found in file pad.h
-=item PAD_SETSV
+=item PAD_SETSV
+X<PAD_SETSV>
Set the slot at offset C<po> in the current pad to C<sv>
- SV * PAD_SETSV (PADOFFSET po, SV* sv)
+ SV * PAD_SETSV(PADOFFSET po, SV* sv)
=for hackers
Found in file pad.h
-=item PAD_SET_CUR
+=item PAD_SET_CUR
+X<PAD_SET_CUR>
Set the current pad to be pad C<n> in the padlist, saving
the previous current pad. NB currently this macro expands to a string too
PAD_SET_CUR_NOSAVE(padlist,n);
- void PAD_SET_CUR (PADLIST padlist, I32 n)
+ void PAD_SET_CUR(PADLIST padlist, I32 n)
=for hackers
Found in file pad.h
-=item PAD_SET_CUR_NOSAVE
+=item PAD_SET_CUR_NOSAVE
+X<PAD_SET_CUR_NOSAVE>
like PAD_SET_CUR, but without the save
- void PAD_SET_CUR_NOSAVE (PADLIST padlist, I32 n)
+ void PAD_SET_CUR_NOSAVE(PADLIST padlist, I32 n)
=for hackers
Found in file pad.h
-=item PAD_SV
+=item PAD_SV
+X<PAD_SV>
Get the value at offset C<po> in the current pad
- void PAD_SV (PADOFFSET po)
+ void PAD_SV(PADOFFSET po)
=for hackers
Found in file pad.h
-=item PAD_SVl
+=item PAD_SVl
+X<PAD_SVl>
Lightweight and lvalue version of C<PAD_SV>.
Get or set the value at offset C<po> in the current pad.
Unlike C<PAD_SV>, does not print diagnostics with -DX.
For internal use only.
- SV * PAD_SVl (PADOFFSET po)
+ SV * PAD_SVl(PADOFFSET po)
=for hackers
Found in file pad.h
-=item SAVECLEARSV
+=item SAVECLEARSV
+X<SAVECLEARSV>
Clear the pointed to pad value on scope exit. (i.e. the runtime action of 'my')
- void SAVECLEARSV (SV **svp)
+ void SAVECLEARSV(SV **svp)
=for hackers
Found in file pad.h
=item SAVECOMPPAD
+X<SAVECOMPPAD>
save PL_comppad and PL_curpad
=for hackers
Found in file pad.h
-=item SAVEPADSV
+=item SAVEPADSV
+X<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)
+ void SAVEPADSV(PADOFFSET po)
=for hackers
Found in file pad.h
=over 8
=item find_runcv
+X<find_runcv>
Locate the CV corresponding to the currently executing sub or eval.
If db_seqp is non_null, skip CVs that are in the DB package and populate
*db_seqp with the cop sequence number at the point that the DB:: code was
entered. (allows debuggers to eval in the scope of the breakpoint rather
-than in in the scope of the debugger itself).
+than in the scope of the debugger itself).
CV* find_runcv(U32 *db_seqp)
=over 8
=item PL_DBsingle
+X<PL_DBsingle>
When Perl is run in debugging mode, with the B<-d> switch, this SV is a
boolean which indicates whether subs are being single-stepped.
Found in file intrpvar.h
=item PL_DBsub
+X<PL_DBsub>
When Perl is run in debugging mode, with the B<-d> switch, this GV contains
the SV which holds the name of the sub being debugged. This is the C
Found in file intrpvar.h
=item PL_DBtrace
+X<PL_DBtrace>
Trace variable used when Perl is run in debugging mode, with the B<-d>
switch. This is the C variable which corresponds to Perl's $DB::trace
Found in file intrpvar.h
=item PL_dowarn
+X<PL_dowarn>
The C variable which corresponds to Perl's $^W warning variable.
Found in file intrpvar.h
=item PL_last_in_gv
+X<PL_last_in_gv>
The GV which was last used for a filehandle input operation. (C<< <FH> >>)
Found in file thrdvar.h
=item PL_ofs_sv
+X<PL_ofs_sv>
The output field separator - C<$,> in Perl space.
Found in file thrdvar.h
=item PL_rs
+X<PL_rs>
The input record separator - C<$/> in Perl space.
=over 8
=item is_gv_magical
+X<is_gv_magical>
Returns C<TRUE> if given the name of a magical GV.
Found in file gv.c
=item is_gv_magical_sv
+X<is_gv_magical_sv>
Returns C<TRUE> if given the name of a magical GV. Calls is_gv_magical.
=back
+=head1 Hash Manipulation Functions
+
+=over 8
+
+=item refcounted_he_chain_2hv
+X<refcounted_he_chain_2hv>
+
+Generates an returns a C<HV *> by walking up the tree starting at the passed
+in C<struct refcounted_he *>.
+
+ HV * refcounted_he_chain_2hv(const struct refcounted_he *c)
+
+=for hackers
+Found in file hv.c
+
+=item refcounted_he_free
+X<refcounted_he_free>
+
+Decrements the reference count of the passed in C<struct refcounted_he *>
+by one. If the reference count reaches zero the structure's memory is freed,
+and C<refcounted_he_free> iterates onto the parent node.
+
+ void refcounted_he_free(struct refcounted_he *he)
+
+=for hackers
+Found in file hv.c
+
+=item refcounted_he_new
+X<refcounted_he_new>
+
+Creates a new C<struct refcounted_he>. As S<key> is copied, and value is
+stored in a compact form, all references remain the property of the caller.
+The C<struct refcounted_he> is returned with a reference count of 1.
+
+ struct refcounted_he * refcounted_he_new(struct refcounted_he *const parent, SV *const key, SV *const value)
+
+=for hackers
+Found in file hv.c
+
+
+=back
+
=head1 IO Functions
=over 8
=item start_glob
+X<start_glob>
Function called by C<do_readline> to spawn a glob (or do the glob inside
perl on VMS). This code used to be inline, but now perl uses C<File::Glob>
=over 8
+=item magic_sethint
+X<magic_sethint>
+
+Triggered by a delete from %^H, records the key to
+C<PL_compiling.cop_hints_hash>.
+
+ int magic_sethint(SV* sv, MAGIC* mg)
+
+=for hackers
+Found in file mg.c
+
=item mg_localize
+X<mg_localize>
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
=over 8
=item CvPADLIST
+X<CvPADLIST>
CV's can have CvPADLIST(cv) set to point to an AV.
in PL_op->op_targ), wasting a name SV for them doesn't make sense.
The SVs in the names AV have their PV being the name of the variable.
-NV+1..IV inclusive is a range of cop_seq numbers for which the name is
-valid. For typed lexicals name SV is SVt_PVMG and SvSTASH points at the
-type. For C<our> lexicals, the type is SVt_PVGV, and GvSTASH points at the
-stash of the associated global (so that duplicate C<our> delarations in the
-same package can be detected). SvCUR is sometimes hijacked to
-store the generation number during compilation.
+xlow+1..xhigh inclusive in the NV union is a range of cop_seq numbers for
+which the name is valid. For typed lexicals name SV is SVt_PVMG and SvSTASH
+points at the type. For C<our> lexicals, the type is also SVt_PVMG, with the
+SvOURSTASH slot pointing at the stash of the associated global (so that
+duplicate C<our> declarations in the same package can be detected). SvUVX is
+sometimes hijacked to store the generation number during compilation.
If SvFAKE is set on the name SV, then that slot in the frame AV is
a REFCNT'ed reference to a lexical from "outside". In this case,
-the name SV does not use NVX and IVX to store a cop_seq range, since it is
-in scope throughout. Instead IVX stores some flags containing info about
+the name SV does not use xlow and xhigh to store a cop_seq range, since it is
+in scope throughout. Instead xhigh stores some flags containing info about
the real lexical (is it declared in an anon, and is it capable of being
-instantiated multiple times?), and for fake ANONs, NVX contains the index
+instantiated multiple times?), and for fake ANONs, xlow contains the index
within the parent's pad where the lexical's value is stored, to make
cloning quicker.
Found in file pad.c
=item cv_clone
+X<cv_clone>
Clone a CV: make a new CV which points to the same code etc, but which
has a newly-created pad built by copying the prototype pad and capturing
Found in file pad.c
=item cv_dump
+X<cv_dump>
dump the contents of a CV
Found in file pad.c
=item do_dump_pad
+X<do_dump_pad>
Dump the contents of a padlist
Found in file pad.c
=item intro_my
+X<intro_my>
"Introduce" my variables to visible status.
Found in file pad.c
=item pad_add_anon
+X<pad_add_anon>
Add an anon code entry to the current compiling pad
Found in file pad.c
=item pad_add_name
+X<pad_add_name>
Create a new name and associated PADMY SV in the current pad; return the
offset.
If C<typestash> is valid, the name is for a typed lexical; set the
name's stash to that value.
If C<ourstash> is valid, it's an our lexical, set the name's
-GvSTASH to that value
+SvOURSTASH to that value
If fake, it means we're cloning an existing entry
- PADOFFSET pad_add_name(const char *name, HV* typestash, HV* ourstash, bool clone)
+ PADOFFSET pad_add_name(const char *name, HV* typestash, HV* ourstash, bool clone, bool state)
=for hackers
Found in file pad.c
=item pad_alloc
+X<pad_alloc>
Allocate a new my or tmp pad entry. For a my, simply push a null SV onto
the end of PL_comppad, but for a tmp, scan the pad from PL_padix upwards
-for a slot which has no name and and no active value.
+for a slot which has no name and no active value.
PADOFFSET pad_alloc(I32 optype, U32 tmptype)
Found in file pad.c
=item pad_block_start
+X<pad_block_start>
Update the pad compilation state variables on entry to a new block
Found in file pad.c
=item pad_check_dup
+X<pad_check_dup>
Check for duplicate declarations: report any of:
* a my in the current scope with the same name;
Found in file pad.c
=item pad_findlex
+X<pad_findlex>
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.
Note that pad_findlex() 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 NVX the index into
+because fake namesvs in anon protoypes have to store in xlow the index into
the parent pad.
PADOFFSET pad_findlex(const char *name, const CV* cv, U32 seq, int warn, SV** out_capture, SV** out_name_sv, int *out_flags)
Found in file pad.c
=item pad_findmy
+X<pad_findmy>
Given a lexical name, try to find its offset, first in the current pad,
or failing that, in the pads of any lexically enclosing subs (including
Found in file pad.c
=item pad_fixup_inner_anons
+X<pad_fixup_inner_anons>
For any anon CVs in the pad, change CvOUTSIDE of that CV from
old_cv to new_cv if necessary. Needed when a newly-compiled CV has to be
Found in file pad.c
=item pad_free
+X<pad_free>
-Free the SV at offet po in the current pad.
+Free the SV at offset po in the current pad.
void pad_free(PADOFFSET po)
Found in file pad.c
=item pad_leavemy
+X<pad_leavemy>
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.
Found in file pad.c
=item pad_new
+X<pad_new>
Create a new compiling padlist, saving and updating the various global
vars at the same time as creating the pad itself. The following flags
Found in file pad.c
=item pad_push
+X<pad_push>
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
Found in file pad.c
=item pad_reset
+X<pad_reset>
Mark all the current temporaries for reuse
Found in file pad.c
=item pad_setsv
+X<pad_setsv>
Set the entry at offset po in the current pad to sv.
Use the macro PAD_SETSV() rather than calling this function directly.
Found in file pad.c
=item pad_swipe
+X<pad_swipe>
Abandon the tmp in the current pad at offset po and replace with a
new one.
Found in file pad.c
=item pad_tidy
+X<pad_tidy>
Tidy up a pad after we've finished compiling it:
* remove most stuff from the pads of anonsub prototypes;
Found in file pad.c
=item pad_undef
+X<pad_undef>
Free the padlist associated with a CV.
If parts of it happen to be current, we null the relevant
=over 8
=item djSP
+X<djSP>
Declare Just C<SP>. This is actually identical to C<dSP>, and declares
a local copy of perl's stack pointer, available via the C<SP> macro.
Found in file pp.h
=item LVRET
+X<LVRET>
True if this op will be the return value of an lvalue subroutine
=over 8
-=item find_uninit_var
-
-Find the name of the undefined variable (if any) that caused the operator o
-to issue a "Use of uninitialized value" warning.
-If match is true, only return a name if it's value matches uninit_sv.
-So roughly speaking, if a unary operator (such as OP_COS) generates a
-warning, then following the direct child of the op may yield an
-OP_PADSV or OP_GV that gives the name of the undefined variable. On the
-other hand, with OP_ADD 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 PL_op is the op that originally triggered the error, and that
-PL_comppad/PL_curpad points to the currently executing pad.
-
- SV* find_uninit_var(OP* obase, SV* uninit_sv, bool top)
-
-=for hackers
-Found in file sv.c
-
-=item report_uninit
-
-Print appropriate "Use of uninitialized variable" warning
-
- void report_uninit(SV* uninit_sv)
-
-=for hackers
-Found in file sv.c
-
=item sv_add_arena
+X<sv_add_arena>
Given a chunk of memory, link it to the head of the list of arenas,
and split it into a list of free SVs.
Found in file sv.c
=item sv_clean_all
+X<sv_clean_all>
Decrement the refcnt of each remaining SV, possibly triggering a
cleanup. This function may have to be called multiple times to free
Found in file sv.c
=item sv_clean_objs
+X<sv_clean_objs>
Attempt to destroy all objects not yet freed
Found in file sv.c
=item sv_free_arenas
+X<sv_free_arenas>
Deallocate the memory used by all arenas. Note that all the individual SV
heads and bodies within the arenas must already have been freed.
=back
+=head1 Unicode Support
+
+=over 8
+
+=item find_uninit_var
+X<find_uninit_var>
+
+Find the name of the undefined variable (if any) that caused the operator o
+to issue a "Use of uninitialized value" warning.
+If match is true, only return a name if it's value matches uninit_sv.
+So roughly speaking, if a unary operator (such as OP_COS) generates a
+warning, then following the direct child of the op may yield an
+OP_PADSV or OP_GV that gives the name of the undefined variable. On the
+other hand, with OP_ADD 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 PL_op is the op that originally triggered the error, and that
+PL_comppad/PL_curpad points to the currently executing pad.
+
+ SV* find_uninit_var(OP* obase, SV* uninit_sv, bool top)
+
+=for hackers
+Found in file sv.c
+
+=item report_uninit
+X<report_uninit>
+
+Print appropriate "Use of uninitialized variable" warning
+
+ void report_uninit(SV* uninit_sv)
+
+=for hackers
+Found in file sv.c
+
+
+=back
+
=head1 AUTHORS
The autodocumentation system was originally added to the Perl core by
perlguts(1), perlapi(1)
+=cut
+
+ ex: set ro: