-*- 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 Perl functions =head1 DESCRIPTION X X 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, B! =head1 CV reference counts and CvOUTSIDE =over 8 =item CvWEAKOUTSIDE X Each CV has a pointer, C, to its lexically enclosing CV (if any). Because pointers to anonymous sub prototypes are stored in C<&> 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 C in the I that the parent has a C<&> pad slot pointing back to us. In this case, we set the C 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 C 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 C causes the chain of Cs to be followed, and the freed BEGIN is accessed. To avoid this, whenever a CV and its associated pad is freed, any C<&> 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 C 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 C<$a> above). One other thing to consider is that a CV may be merely undefined rather than freed, eg C. In this case, its refcount may not have reached zero, but we still delete its pad and its C etc. Since various children may still have their C pointing at this undefined CV, we keep its own C 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) =for hackers Found in file cv.h =back =head1 Functions in file pad.h =over 8 =item CX_CURPAD_SAVE X Save the current pad in the given context block structure. void CX_CURPAD_SAVE(struct context) =for hackers Found in file pad.h =item CX_CURPAD_SV X Access the SV at offset po in the saved current pad in the given context block structure (can be used as an lvalue). SV * CX_CURPAD_SV(struct context, PADOFFSET po) =for hackers Found in file pad.h =item PAD_BASE_SV X Get the value from slot C in the base (DEPTH=1) pad of a padlist SV * PAD_BASE_SV(PADLIST padlist, PADOFFSET po) =for hackers Found in file pad.h =item PAD_CLONE_VARS X Clone the state variables associated with running and compiling pads. void PAD_CLONE_VARS(PerlInterpreter *proto_perl, CLONE_PARAMS* param) =for hackers Found in file pad.h =item PAD_COMPNAME_FLAGS X Return the flags for the current compiling pad name at offset C. Assumes a valid slot entry. U32 PAD_COMPNAME_FLAGS(PADOFFSET po) =for hackers Found in file pad.h =item PAD_COMPNAME_GEN X The generation number of the name at offset C in the current compiling pad (lvalue). Note that C is hijacked for this purpose. STRLEN PAD_COMPNAME_GEN(PADOFFSET po) =for hackers Found in file pad.h =item PAD_COMPNAME_GEN_set X Sets the generation number of the name at offset C in the current ling pad (lvalue) to C. Note that C 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 Return the stash associated with an C variable. Assumes the slot entry is a valid C lexical. HV * PAD_COMPNAME_OURSTASH(PADOFFSET po) =for hackers Found in file pad.h =item PAD_COMPNAME_PV X Return the name of the current compiling pad name at offset C. Assumes a valid slot entry. char * PAD_COMPNAME_PV(PADOFFSET po) =for hackers Found in file pad.h =item PAD_COMPNAME_TYPE X Return the type (stash) of the current compiling pad name at offset C. Must be a valid name. Returns null if not typed. HV * PAD_COMPNAME_TYPE(PADOFFSET po) =for hackers Found in file pad.h =item PAD_DUP X Clone a padlist. void PAD_DUP(PADLIST dstpad, PADLIST srcpad, CLONE_PARAMS* param) =for hackers Found in file pad.h =item PAD_RESTORE_LOCAL X Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL() void PAD_RESTORE_LOCAL(PAD *opad) =for hackers Found in file pad.h =item PAD_SAVE_LOCAL X Save the current pad to the local variable opad, then make the current pad equal to npad void PAD_SAVE_LOCAL(PAD *opad, PAD *npad) =for hackers Found in file pad.h =item PAD_SAVE_SETNULLPAD X Save the current pad then set it to null. void PAD_SAVE_SETNULLPAD() =for hackers Found in file pad.h =item PAD_SETSV X Set the slot at offset C in the current pad to C SV * PAD_SETSV(PADOFFSET po, SV* sv) =for hackers Found in file pad.h =item PAD_SET_CUR X Set the current pad to be pad C 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(); 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 X like PAD_SET_CUR, but without the save void PAD_SET_CUR_NOSAVE(PADLIST padlist, I32 n) =for hackers Found in file pad.h =item PAD_SV X Get the value at offset C in the current pad void PAD_SV(PADOFFSET po) =for hackers Found in file pad.h =item PAD_SVl X Lightweight and lvalue version of C. Get or set the value at offset C in the current pad. Unlike C, does not print diagnostics with -DX. For internal use only. SV * PAD_SVl(PADOFFSET po) =for hackers Found in file pad.h =item SAVECLEARSV X Clear the pointed to pad value on scope exit. (i.e. the runtime action of 'my') void SAVECLEARSV(SV **svp) =for hackers Found in file pad.h =item SAVECOMPPAD X save PL_comppad and PL_curpad void SAVECOMPPAD() =for hackers Found in file pad.h =item SAVEPADSV X 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) =for hackers Found in file pad.h =back =head1 Functions in file pp_ctl.c =over 8 =item docatch X Check for the cases 0 or 3 of cur_env.je_ret, 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: je_mustcatch, when set at any runlevel to TRUE, means eval ops must establish a local jmpenv to handle exception traps. OP* docatch(OP *o) =for hackers Found in file pp_ctl.c =back =head1 GV Functions =over 8 =item gv_try_downgrade X If the typeglob C 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 C 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 C is a completely empty typeglob, it is deleted from the stash. If C 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 gv_try_downgrade(GV* gv) =for hackers Found in file gv.c =item is_gv_magical_sv X Returns C if given the name of a magical GV. Currently only useful internally when determining if a GV should be created even in rvalue contexts. C is not used at present but available for future extension to allow selecting particular classes of magical variable. Currently assumes that C is NUL terminated (as well as len being valid). This assumption is met by all callers within the perl core, which all pass pointers returned by SvPV. bool is_gv_magical_sv(SV *const name_sv, U32 flags) =for hackers Found in file gv.c =back =head1 Hash Manipulation Functions =over 8 =item refcounted_he_chain_2hv X Generates and returns a C by walking up the tree starting at the passed in C. NOTE: this function is experimental and may change or be removed without notice. HV * refcounted_he_chain_2hv(const struct refcounted_he *c) =for hackers Found in file hv.c =item refcounted_he_free X Decrements the reference count of the passed in C by one. If the reference count reaches zero the structure's memory is freed, and C iterates onto the parent node. NOTE: this function is experimental and may change or be removed without notice. void refcounted_he_free(struct refcounted_he *he) =for hackers Found in file hv.c =item refcounted_he_new X Creates a new C. As S is copied, and value is stored in a compact form, all references remain the property of the caller. The C is returned with a reference count of 1. NOTE: this function is experimental and may change or be removed without notice. 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 Function called by C to spawn a glob (or do the glob inside perl on VMS). This code used to be inline, but now perl uses C this glob starter is only used by miniperl during the build process. Moving it away shrinks pp_hot.c; shrinking pp_hot.c helps speed perl up. NOTE: this function is experimental and may change or be removed without notice. PerlIO* start_glob(SV *tmpglob, IO *io) =for hackers Found in file doio.c =back =head1 Magical Functions =over 8 =item magic_clearhint X Triggered by a delete from %^H, records the key to C. int magic_clearhint(SV* sv, MAGIC* mg) =for hackers Found in file mg.c =item magic_clearhints X Triggered by clearing %^H, resets C. int magic_clearhints(SV* sv, MAGIC* mg) =for hackers Found in file mg.c =item magic_sethint X Triggered by a store to %^H, records the key/value pair to C. 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 magic_sethint(SV* sv, MAGIC* mg) =for hackers Found in file mg.c =item mg_localize X 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 mg_localize(SV* sv, SV* nsv, bool setmagic) =for hackers Found in file mg.c =back =head1 MRO Functions =over 8 =item mro_get_linear_isa_dfs X Returns the Depth-First Search linearization of @ISA the given stash. The return value is a read-only AV*. C should be 0 (it is used internally in this function's recursion). You are responsible for C 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* mro_get_linear_isa_dfs(HV* stash, U32 level) =for hackers Found in file mro.c =item mro_isa_changed_in X Takes the necessary steps (cache invalidations, mostly) when the @ISA of the given package has changed. Invoked by the C magic, should not need to invoke directly. void mro_isa_changed_in(HV* stash) =for hackers Found in file mro.c =back =head1 Pad Data Structures =over 8 =item CvPADLIST X CV's can have CvPADLIST(cv) set to point to an AV. For these purposes "forms" are a kind-of CV, eval""s are too (except they're not callable at will and are always thrown away after the eval"" is done executing). Require'd files are simply evals without any outer lexical scope. XSUBs don't have CvPADLIST set - dXSTARG fetches values from PL_curpad, but that is really the callers pad (a slot of which is allocated by every entersub). The CvPADLIST AV has does not have AvREAL set, so REFCNT of component items is managed "manual" (mostly in pad.c) rather than normal av.c rules. The items in the AV are not SVs as for a normal AV, but other AVs: 0'th Entry of the CvPADLIST is an AV which represents the "names" or rather the "static type information" for lexicals. The CvDEPTH'th entry of CvPADLIST AV is an AV which is the stack frame at that depth of recursion into the CV. The 0'th slot of a frame AV is an AV which is @_. other entries are storage for variables and op targets. During compilation: C is set to the names AV. C is set to the frame AV for the frame CvDEPTH == 1. C is set to the body of the frame AV (i.e. AvARRAY(PL_comppad)). During execution, C and C refer to the live frame of the currently executing sub. Iterating over the names AV iterates over all possible pad items. Pad slots that are SVs_PADTMP (targets/GVs/constants) end up having &PL_sv_undef "names" (see pad_alloc()). Only my/our variable (SVs_PADMY/SVs_PADOUR) slots get valid names. The rest are op targets/GVs/constants which are statically allocated or resolved at compile time. These don't have names by which they can be looked up from Perl code at run time through eval"" like my/our variables can be. Since they can't be looked up by "name" but only by their index allocated at compile time (which is usually 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. 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 lexicals, the type is also SVt_PVMG, with the SvOURSTASH slot pointing at the stash of the associated global (so that duplicate C 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 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, xlow contains the index within the parent's pad where the lexical's value is stored, to make cloning quicker. If the 'name' is '&' the corresponding entry in frame AV is a CV representing a possible closure. (SvFAKE and name of '&' is not a meaningful combination currently but could become so if C is implemented.) Note that formats are treated as anon subs, and are cloned each time write is called (if necessary). The flag SVs_PADSTALE is cleared on lexicals each time the my() is executed, and set on scope exit. This allows the 'Variable $x is not available' warning to be generated in evals, such as { my $x = 1; sub f { eval '$x'} } f(); For state vars, SVs_PADSTALE is overloaded to mean 'not yet initialised' AV * CvPADLIST(CV *cv) =for hackers Found in file pad.c =item cv_clone X 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 any outer lexicals. CV* cv_clone(CV* proto) =for hackers Found in file pad.c =item cv_dump X dump the contents of a CV void cv_dump(const CV *cv, const char *title) =for hackers Found in file pad.c =item do_dump_pad X Dump the contents of a padlist void do_dump_pad(I32 level, PerlIO *file, PADLIST *padlist, int full) =for hackers Found in file pad.c =item intro_my X "Introduce" my variables to visible status. U32 intro_my() =for hackers Found in file pad.c =item pad_add_anon X Add an anon code entry to the current compiling pad PADOFFSET pad_add_anon(SV* sv, OPCODE op_type) =for hackers Found in file pad.c =item pad_add_name X Create a new name and associated PADMY SV in the current pad; return the offset. If C is valid, the name is for a typed lexical; set the name's stash to that value. If C is valid, it's an our lexical, set the name's SvOURSTASH to that value If fake, it means we're cloning an existing entry NOTE: this function is experimental and may change or be removed without notice. PADOFFSET pad_add_name(const char *name, const STRLEN len, const U32 flags, HV *typestash, HV *ourstash) =for hackers Found in file pad.c =item pad_alloc X 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 no active value. PADOFFSET pad_alloc(I32 optype, U32 tmptype) =for hackers Found in file pad.c =item pad_block_start X Update the pad compilation state variables on entry to a new block void pad_block_start(int full) =for hackers Found in file pad.c =item pad_check_dup X 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 C indicates that the name to check is an 'our' declaration void pad_check_dup(SV *name, const U32 flags, const HV *ourstash) =for hackers Found in file pad.c =item pad_findlex X 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 cop_seq 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. out_capture, if non-null, requests that the innermost instance of the lexical is captured; out_name_sv is set to the innermost matched namesv or fake namesv; out_flags returns the flags normally associated with the IVX field of a fake namesv. 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 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) =for hackers Found in file pad.c =item pad_fixup_inner_anons X 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 moved to a pre-existing CV struct. void pad_fixup_inner_anons(PADLIST *padlist, CV *old_cv, CV *new_cv) =for hackers Found in file pad.c =item pad_free X Free the SV at offset po in the current pad. void pad_free(PADOFFSET po) =for hackers Found in file pad.c =item pad_leavemy X 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 pad_leavemy() =for hackers Found in file pad.c =item pad_new X Create a new compiling padlist, saving and updating the various global vars at the same time as creating the pad itself. The following flags can be OR'ed together: padnew_CLONE this pad is for a cloned CV padnew_SAVE save old globals padnew_SAVESUB also save extra stuff for start of sub PADLIST* pad_new(int flags) =for hackers Found in file pad.c =item pad_push X 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 pad_push(PADLIST *padlist, int depth) =for hackers Found in file pad.c =item pad_reset X Mark all the current temporaries for reuse void pad_reset() =for hackers Found in file pad.c =item pad_setsv X Set the entry at offset po in the current pad to sv. Use the macro PAD_SETSV() rather than calling this function directly. void pad_setsv(PADOFFSET po, SV* sv) =for hackers Found in file pad.c =item pad_swipe X Abandon the tmp in the current pad at offset po and replace with a new one. void pad_swipe(PADOFFSET po, bool refadjust) =for hackers Found in file pad.c =item pad_tidy X Tidy up a pad after we've finished compiling it: * remove most stuff from the pads of anonsub prototypes; * give it a @_; * mark tmps as such. void pad_tidy(padtidy_type type) =for hackers Found in file pad.c =item pad_undef X Free the padlist associated with a CV. If parts of it happen to be current, we null the relevant PL_*pad* global vars so that we don't have any dangling references left. We also repoint the CvOUTSIDE of any about-to-be-orphaned inner subs to the outer of this cv. (This function should really be called pad_free, but the name was already taken) void pad_undef(CV* cv) =for hackers Found in file pad.c =back =head1 Per-Interpreter Variables =over 8 =item PL_DBsingle X 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. Single-stepping is automatically turned on after every step. This is the C variable which corresponds to Perl's $DB::single variable. See C. SV * PL_DBsingle =for hackers Found in file intrpvar.h =item PL_DBsub X 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 variable which corresponds to Perl's $DB::sub variable. See C. GV * PL_DBsub =for hackers Found in file intrpvar.h =item PL_DBtrace X 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 variable. See C. SV * PL_DBtrace =for hackers Found in file intrpvar.h =item PL_dowarn X The C variable which corresponds to Perl's $^W warning variable. bool PL_dowarn =for hackers Found in file intrpvar.h =item PL_last_in_gv X The GV which was last used for a filehandle input operation. (C<< >>) GV* PL_last_in_gv =for hackers Found in file intrpvar.h =item PL_ofsgv X The glob containing the output field separator - C<*,> in Perl space. GV* PL_ofsgv =for hackers Found in file intrpvar.h =item PL_rs X The input record separator - C<$/> in Perl space. SV* PL_rs =for hackers Found in file intrpvar.h =back =head1 Stack Manipulation Macros =over 8 =item djSP X Declare Just C. This is actually identical to C, and declares a local copy of perl's stack pointer, available via the C macro. See C. (Available for backward source code compatibility with the old (Perl 5.005) thread model.) djSP; =for hackers Found in file pp.h =item LVRET X True if this op will be the return value of an lvalue subroutine =for hackers Found in file pp.h =back =head1 SV Manipulation Functions =over 8 =item sv_add_arena X 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 sv_add_arena(char *const ptr, const U32 size, const U32 flags) =for hackers Found in file sv.c =item sv_clean_all X 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 sv_clean_all() =for hackers Found in file sv.c =item sv_clean_objs X Attempt to destroy all objects not yet freed void sv_clean_objs() =for hackers Found in file sv.c =item sv_free_arenas X 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 sv_free_arenas() =for hackers Found in file sv.c =back =head1 SV-Body Allocation =over 8 =item sv_2num X Return an SV with the numeric value of the source SV, doing any necessary reference or overload conversion. You must use the C macro to access this function. NOTE: this function is experimental and may change or be removed without notice. SV* sv_2num(SV *const sv) =for hackers Found in file sv.c =back =head1 Unicode Support =over 8 =item find_uninit_var X 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. NOTE: this function is experimental and may change or be removed without notice. SV* find_uninit_var(const OP *const obase, const SV *const uninit_sv, bool top) =for hackers Found in file sv.c =item report_uninit X Print appropriate "Use of uninitialized variable" warning void report_uninit(const SV *uninit_sv) =for hackers Found in file sv.c =back =head1 Undocumented functions These functions are currently undocumented: =over =item F0convert X =item Slab_to_rw X =item add_data X =item add_utf16_textfilter X =item addmad X =item allocmy X =item amagic_cmp X =item amagic_cmp_locale X =item amagic_i_ncmp X =item amagic_ncmp X =item anonymise_cv X =item ao X =item append_elem X =item append_list X =item append_madprops X =item apply X =item apply_attrs X =item apply_attrs_my X =item av_reify X =item bad_type X =item bind_match X =item block_end X =item block_start X =item boot_core_PerlIO X =item boot_core_UNIVERSAL X =item boot_core_mro X =item bytes_to_uni X =item cando X =item check_type_and_open X =item check_uni X =item checkcomma X =item checkposixcc X =item ck_anoncode X =item ck_bitop X =item ck_concat X =item ck_defined X =item ck_delete X =item ck_die X =item ck_each X =item ck_eof X =item ck_eval X =item ck_exec X =item ck_exists X =item ck_exit X =item ck_ftst X =item ck_fun X =item ck_glob X =item ck_grep X =item ck_index X =item ck_join X =item ck_lfun X =item ck_listiob X =item ck_match X =item ck_method X =item ck_null X =item ck_open X =item ck_readline X =item ck_repeat X =item ck_require X =item ck_return X =item ck_rfun X =item ck_rvconst X =item ck_sassign X =item ck_select X =item ck_shift X =item ck_sort X =item ck_spair X =item ck_split X =item ck_subr X =item ck_substr X =item ck_svconst X =item ck_trunc X =item ck_unpack X =item ckwarn_common X =item cl_and X =item cl_anything X =item cl_init X =item cl_init_zero X =item cl_is_anything X =item cl_or X =item clear_placeholders X =item closest_cop X =item convert X =item cop_free X =item cr_textfilter X =item create_eval_scope X =item curmad X =item cv_ckproto_len X =item deb_curcv X =item deb_stack_all X =item deb_stack_n X =item debprof X =item debug_start_match X =item del_sv X =item delete_eval_scope X =item deprecate_commaless_var_list X =item destroy_matcher X =item die_where X =item div128 X =item do_aexec X =item do_aexec5 X =item do_chomp X =item do_chop X =item do_delete_local X =item do_eof X =item do_exec X =item do_exec3 X =item do_execfree X =item do_ipcctl X =item do_ipcget X =item do_kv X =item do_msgrcv X =item do_msgsnd X =item do_oddball X =item do_op_xmldump X =item do_pmop_xmldump X =item do_print X =item do_readline X =item do_seek X =item do_semop X =item do_shmio X =item do_smartmatch X =item do_sysseek X =item do_tell X =item do_trans X =item do_trans_complex X =item do_trans_complex_utf8 X =item do_trans_count X =item do_trans_count_utf8 X =item do_trans_simple X =item do_trans_simple_utf8 X =item do_vecget X =item do_vecset X =item do_vop X =item doeval X =item dofile X =item dofindlabel X =item doform X =item dooneliner X =item doopen_pm X =item doparseform X =item dopoptoeval X =item dopoptogiven X =item dopoptolabel X =item dopoptoloop X =item dopoptosub_at X =item dopoptowhen X =item dump_all_perl X =item dump_exec_pos X =item dump_packsubs_perl X =item dump_sub_perl X =item dump_sv_child X =item dump_trie X =item dump_trie_interim_list X =item dump_trie_interim_table X =item dumpuntil X =item dup_attrlist X =item emulate_cop_io X =item exec_failed X =item expect_number X =item feature_is_enabled X =item filter_gets X =item find_and_forget_pmops X =item find_array_subscript X =item find_beginning X =item find_byclass X =item find_hash_subscript X =item find_in_my_stash X =item find_script X =item first_symbol X =item fold_constants X =item forbid_setid X =item force_ident X =item force_list X =item force_next X =item force_strict_version X =item force_version X =item force_word X =item forget_pmop X =item free_tied_hv_pool X =item gen_constant_list X =item get_arena X =item get_aux_mg X =item get_db_sub X =item get_debug_opts X =item get_hash_seed X =item get_isa_hash X =item get_no_modify X =item get_num X =item get_opargs X =item get_re_arg X =item getenv_len X =item glob_2number X =item glob_assign_glob X =item glob_assign_ref X =item group_end X =item gv_ename X =item gv_get_super_pkg X =item gv_init_sv X =item hfreeentries X =item hsplit X =item hv_auxinit X =item hv_backreferences_p X =item hv_copy_hints_hv X =item hv_delete_common X =item hv_kill_backrefs X =item hv_magic_check X =item hv_notallowed X =item incline X =item incpush X =item incpush_if_exists X =item incpush_use_sep X =item ingroup X =item init_argv_symbols X =item init_dbargs X =item init_debugger X =item init_ids X =item init_interp X =item init_main_stash X =item init_perllib X =item init_postdump_symbols X =item init_predump_symbols X =item intuit_method X =item intuit_more X =item invert X =item io_close X =item is_an_int X =item is_handle_constructor X =item is_inplace_av X =item is_list_assignment X =item is_utf8_X_L X =item is_utf8_X_LV X =item is_utf8_X_LVT X =item is_utf8_X_LV_LVT_V X =item is_utf8_X_T X =item is_utf8_X_V X =item is_utf8_X_begin X =item is_utf8_X_extend X =item is_utf8_X_non_hangul X =item is_utf8_X_prepend X =item is_utf8_char_slow X =item is_utf8_common X =item isa_lookup X =item jmaybe X =item join_exact X =item keyword X =item keyword_plugin_standard X =item lex_end X =item lex_start X =item linklist X =item list X =item listkids X =item localize X =item looks_like_bool X =item lop X =item mad_free X =item madlex X =item madparse X =item magic_clear_all_env X =item magic_clearenv X =item magic_clearisa X =item magic_clearpack X =item magic_clearsig X =item magic_existspack X =item magic_freearylen_p X =item magic_freeovrld X =item magic_get X =item magic_getarylen X =item magic_getdefelem X =item magic_getnkeys X =item magic_getpack X =item magic_getpos X =item magic_getsig X =item magic_getsubstr X =item magic_gettaint X =item magic_getuvar X =item magic_getvec X =item magic_killbackrefs X =item magic_len X =item magic_methcall X =item magic_methpack X =item magic_nextpack X =item magic_regdata_cnt X =item magic_regdatum_get X =item magic_regdatum_set X =item magic_scalarpack X =item magic_set X =item magic_set_all_env X =item magic_setamagic X =item magic_setarylen X =item magic_setcollxfrm X =item magic_setdbline X =item magic_setdefelem X =item magic_setenv X =item magic_setisa X =item magic_setmglob X =item magic_setnkeys X =item magic_setpack X =item magic_setpos X =item magic_setregexp X =item magic_setsig X =item magic_setsubstr X =item magic_settaint X =item magic_setutf8 X =item magic_setuvar X =item magic_setvec X =item magic_sizepack X =item magic_wipepack X =item make_matcher X =item make_trie X =item make_trie_failtable X =item malloc_good_size X =item malloced_size X =item matcher_matches_sv X =item measure_struct X =item mem_collxfrm X =item mem_log_common X =item mess_alloc X =item method_common X =item missingterm X =item mod X =item mode_from_discipline X =item modkids X =item more_bodies X =item more_sv X =item mro_meta_dup X =item mro_meta_init X =item mul128 X =item mulexp10 X =item my_attrs X =item my_betoh16 X =item my_betoh32 X =item my_betoh64 X =item my_betohi X =item my_betohl X =item my_betohs X =item my_clearenv X =item my_exit_jump X =item my_htobe16 X =item my_htobe32 X =item my_htobe64 X =item my_htobei X =item my_htobel X =item my_htobes X =item my_htole16 X =item my_htole32 X =item my_htole64 X =item my_htolei X =item my_htolel X =item my_htoles X =item my_kid X =item my_letoh16 X =item my_letoh32 X =item my_letoh64 X =item my_letohi X =item my_letohl X =item my_letohs X =item my_swabn X =item my_unexec X =item need_utf8 X =item newDEFSVOP X =item newGIVWHENOP X =item newGP X =item newMADPROP X =item newMADsv X =item newTOKEN X =item new_constant X =item new_he X =item new_logop X =item new_warnings_bitfield X =item next_symbol X =item nextargv X =item nextchar X =item no_bareword_allowed X =item no_fh_allowed X =item no_op X =item not_a_number X =item nuke_stacks X =item num_overflow X =item offer_nice_chunk X =item oopsAV X =item oopsHV X =item op_clear X =item op_const_sv X =item op_getmad X =item op_getmad_weak X =item op_refcnt_dec X =item op_refcnt_inc X =item op_xmldump X =item open_script X =item opt_scalarhv X =item pack_rec X =item package X =item package_version X =item pad_add_name_sv X =item pad_compname_type X =item pad_peg X =item parse_body X =item parse_unicode_opts X =item parser_free X =item path_is_absolute X =item peep X =item pending_Slabs_to_ro X =item pidgone X =item pm_description X =item pmflag X =item pmop_xmldump X =item pmruntime X =item pmtrans X =item prepend_elem X =item prepend_madprops X =item printbuf X =item process_special_blocks X =item ptr_table_find X =item put_byte X =item qerror X =item qsortsvu X =item re_croak2 X =item readpipe_override X =item ref_array_or_hash X =item refcounted_he_fetch X =item refcounted_he_new_common X =item refcounted_he_value X =item refkids X =item refto X =item reg X =item reg_check_named_buff_matched X =item reg_named_buff X =item reg_named_buff_iter X =item reg_namedseq X =item reg_node X =item reg_numbered_buff_fetch X =item reg_numbered_buff_length X =item reg_numbered_buff_store X =item reg_qr_package X =item reg_recode X =item reg_scan_name X =item reg_skipcomment X =item reg_temp_copy X =item reganode X =item regatom X =item regbranch X =item regclass X =item regcppop X =item regcppush X =item regcurly X =item regdump_extflags X =item reghop3 X =item reghop4 X =item reghopmaybe3 X =item reginclass X =item reginsert X =item regmatch X =item regpiece X =item regpposixcc X =item regprop X =item regrepeat X =item regtail X =item regtail_study X =item regtry X =item reguni X =item regwhite X =item report_evil_fh X =item require_tie_mod X =item restore_magic X =item rsignal_restore X =item rsignal_save X =item run_body X =item run_user_filter X =item rxres_free X =item rxres_restore X =item rxres_save X =item same_dirent X =item save_freeop X =item save_hek_flags X =item save_hints X =item save_lines X =item save_magic X =item save_op X =item save_pushi32ptr X =item save_pushptri32ptr X =item save_pushptrptr X =item save_scalar_at X =item sawparens X =item scalar X =item scalar_mod_type X =item scalarboolean X =item scalarkids X =item scalarseq X =item scalarvoid X =item scan_commit X =item scan_const X =item scan_formline X =item scan_heredoc X =item scan_ident X =item scan_inputsymbol X =item scan_pat X =item scan_str X =item scan_subst X =item scan_trans X =item scan_word X =item scope X =item search_const X =item sequence X =item sequence_num X =item sequence_tail X =item share_hek_flags X =item sighandler X =item simplify_sort X =item skipspace X =item skipspace0 X =item skipspace1 X =item skipspace2 X =item softref2xv X =item sortcv X =item sortcv_stacked X =item sortcv_xsub X =item space_join_names_mortal X =item start_force X =item stdize_locale X =item store_cop_label X =item strip_return X =item study_chunk X =item sub_crush_depth X =item sublex_done X =item sublex_push X =item sublex_start X =item sv_2iuv_common X =item sv_2iuv_non_preserve X =item sv_add_backref X =item sv_catxmlpvn X =item sv_catxmlsv X =item sv_del_backref X =item sv_dup_inc_multiple X =item sv_exp_grow X =item sv_free2 X =item sv_i_ncmp X =item sv_kill_backrefs X =item sv_ncmp X =item sv_pos_b2u_midway X =item sv_pos_u2b_cached X =item sv_pos_u2b_forwards X =item sv_pos_u2b_midway X =item sv_release_COW X =item sv_setsv_cow X =item sv_unglob X =item sv_xmlpeek X =item swallow_bom X =item swash_get X =item to_byte_substr X =item to_utf8_substr X =item token_free X =item token_getmad X =item tokenize_use X =item tokeq X =item tokereport X =item too_few_arguments X =item too_many_arguments X =item uiv_2buf X =item unpack_rec X =item unshare_hek X =item unshare_hek_or_pvn X =item unwind_handler_stack X =item update_debugger_info X =item usage X =item utf16_textfilter X =item utf8_mg_pos_cache_update X =item utilize X =item validate_suid X =item varname X =item vdie X =item vdie_common X =item vdie_croak_common X =item visit X =item vivify_defelem X =item vivify_ref X =item wait4pid X =item watch X =item write_no_mem X =item write_to_stderr X =item xmldump_all X =item xmldump_all_perl X =item xmldump_attr X =item xmldump_eval X =item xmldump_form X =item xmldump_indent X =item xmldump_packsubs X =item xmldump_packsubs_perl X =item xmldump_sub X =item xmldump_sub_perl X =item xmldump_vindent X =item yyerror X =item yylex X =item yyparse X =item yywarn X =back =head1 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. =head1 SEE ALSO L, L =cut ex: set ro: