+-*- 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
circumstances we should decrement the refcount of the parent when freeing
the child.
-There is a further complication with non-closure anonymous subs (ie those
+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
=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)
=for hackers
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<SvUV_set> is hijacked for this purpose.
+
+ STRLEN PAD_COMPNAME_GEN_set(PADOFFSET po, int gen)
+
+=for hackers
+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.
+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
- void PAD_SET_CUR (PADLIST padlist, I32 n)
+ SAVECOMPPAD();
+ PAD_SET_CUR_NOSAVE(padlist,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. (ie the runtime action of 'my')
+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>
=back
+=head1 Magical Functions
+
+=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
+doesn't (eg taint, pos).
+
+ void mg_localize(SV* sv, SV* nsv)
+
+=for hackers
+Found in file mg.c
+
+
+=back
+
=head1 Pad Data Structures
=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: