diff options
Diffstat (limited to 'Master/tlpkg/tlperl/lib/pods/perlintern.pod')
-rw-r--r-- | Master/tlpkg/tlperl/lib/pods/perlintern.pod | 1125 |
1 files changed, 661 insertions, 464 deletions
diff --git a/Master/tlpkg/tlperl/lib/pods/perlintern.pod b/Master/tlpkg/tlperl/lib/pods/perlintern.pod index b26ba099c34..5f09dcdc6d0 100644 --- a/Master/tlpkg/tlperl/lib/pods/perlintern.pod +++ b/Master/tlpkg/tlperl/lib/pods/perlintern.pod @@ -18,6 +18,56 @@ format but are not marked as part of the Perl API. In other words, B<they are not for use in extensions>! +=head1 Compile-time scope hooks + +=over 8 + +=item BhkENTRY +X<BhkENTRY> + +Return an entry from the BHK structure. I<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) + +=for hackers +Found in file op.h + +=item BhkFLAGS +X<BhkFLAGS> + +Return the BHK's flags. + +NOTE: this function is experimental and may change or be +removed without notice. + + U32 BhkFLAGS(BHK *hk) + +=for hackers +Found in file op.h + +=item CALL_BLOCK_HOOKS +X<CALL_BLOCK_HOOKS> + +Call all the registered block hooks for type I<which>. I<which> is a +preprocessing token; the type of I<arg> depends on I<which>. + +NOTE: this function is experimental and may change or be +removed without notice. + + void CALL_BLOCK_HOOKS(which, arg) + +=for hackers +Found in file op.h + + +=back + =head1 CV reference counts and CvOUTSIDE =over 8 @@ -80,6 +130,236 @@ Found in file cv.h =back +=head1 Embedding Functions + +=over 8 + +=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 +any outer lexicals. + + CV* cv_clone(CV* proto) + +=for hackers +Found in file pad.c + +=item cv_dump +X<cv_dump> + +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<do_dump_pad> + +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<intro_my> + +"Introduce" my variables to visible status. + + U32 intro_my() + +=for hackers +Found in file pad.c + +=item pad_add_anon +X<pad_add_anon> + +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<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 +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<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 no active value. + + PADOFFSET pad_alloc(I32 optype, U32 tmptype) + +=for hackers +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 + + void pad_block_start(int full) + +=for hackers +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; + * an our (anywhere in the pad) with the same name and the same stash + as C<ourstash> +C<is_our> 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<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. + +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<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 +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<pad_free> + +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<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. + + void pad_leavemy() + +=for hackers +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 +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<pad_reset> + +Mark all the current temporaries for reuse + + void pad_reset() + +=for hackers +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. + + void pad_setsv(PADOFFSET po, SV* sv) + +=for hackers +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. + + void pad_swipe(PADOFFSET po, bool refadjust) + +=for hackers +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; + * give it a @_; + * mark tmps as such. + + void pad_tidy(padtidy_type type) + +=for hackers +Found in file pad.c + + +=back + =head1 Functions in file pad.h @@ -411,16 +691,91 @@ Found in file gv.c =over 8 +=item hv_ename_add +X<hv_ename_add> + +Adds a name to a stash's internal list of effective names. See +C<hv_ename_delete>. + +This is called when a stash is assigned to a new location in the symbol +table. + + void hv_ename_add(HV *hv, const char *name, U32 len, U32 flags) + +=for hackers +Found in file hv.c + +=item hv_ename_delete +X<hv_ename_delete> + +Removes a name from a stash's internal list of effective names. If this is +the name returned by C<HvENAME>, then another name in the list will take +its place (C<HvENAME> will use it). + +This is called when a stash is deleted from the symbol table. + + void hv_ename_delete(HV *hv, const char *name, U32 len, U32 flags) + +=for hackers +Found in file hv.c + =item refcounted_he_chain_2hv X<refcounted_he_chain_2hv> -Generates and returns a C<HV *> by walking up the tree starting at the passed -in C<struct refcounted_he *>. +Generates and returns a C<HV *> representing the content of a +C<refcounted_he> chain. +I<flags> is currently unused and must be zero. -NOTE: this function is experimental and may change or be -removed without notice. + HV * refcounted_he_chain_2hv(const struct refcounted_he *c, U32 flags) + +=for hackers +Found in file hv.c + +=item refcounted_he_fetch_pv +X<refcounted_he_fetch_pv> + +Like L</refcounted_he_fetch_pvn>, but takes a nul-terminated string +instead of a string/length pair. + + SV * refcounted_he_fetch_pv(const struct refcounted_he *chain, const char *key, U32 hash, U32 flags) + +=for hackers +Found in file hv.c - HV * refcounted_he_chain_2hv(const struct refcounted_he *c) +=item refcounted_he_fetch_pvn +X<refcounted_he_fetch_pvn> + +Search along a C<refcounted_he> chain for an entry with the key specified +by I<keypv> and I<keylen>. If I<flags> has the C<REFCOUNTED_HE_KEY_UTF8> +bit set, the key octets are interpreted as UTF-8, otherwise they +are interpreted as Latin-1. I<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 C<&PL_sv_placeholder> +if there is no value associated with the key. + + SV * refcounted_he_fetch_pvn(const struct refcounted_he *chain, const char *keypv, STRLEN keylen, U32 hash, U32 flags) + +=for hackers +Found in file hv.c + +=item refcounted_he_fetch_pvs +X<refcounted_he_fetch_pvs> + +Like L</refcounted_he_fetch_pvn>, but takes a literal string instead of +a string/length pair, and no precomputed hash. + + SV * refcounted_he_fetch_pvs(const struct refcounted_he *chain, const char *key, U32 flags) + +=for hackers +Found in file hv.h + +=item refcounted_he_fetch_sv +X<refcounted_he_fetch_sv> + +Like L</refcounted_he_fetch_pvn>, but takes a Perl scalar instead of a +string/length pair. + + SV * refcounted_he_fetch_sv(const struct refcounted_he *chain, SV *key, U32 hash, U32 flags) =for hackers Found in file hv.c @@ -428,29 +783,93 @@ 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. - -NOTE: this function is experimental and may change or be -removed without notice. +Decrements the reference count of a C<refcounted_he> by one. If the +reference count reaches zero the structure's memory is freed, which +(recursively) causes a reduction of its parent C<refcounted_he>'s +reference count. It is safe to pass a null pointer to this function: +no action occurs in this case. void refcounted_he_free(struct refcounted_he *he) =for hackers Found in file hv.c -=item refcounted_he_new -X<refcounted_he_new> +=item refcounted_he_inc +X<refcounted_he_inc> -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. +Increment the reference count of a C<refcounted_he>. The pointer to the +C<refcounted_he> is also returned. It is safe to pass a null pointer +to this function: no action occurs and a null pointer is returned. -NOTE: this function is experimental and may change or be -removed without notice. + struct refcounted_he * refcounted_he_inc(struct refcounted_he *he) + +=for hackers +Found in file hv.c + +=item refcounted_he_new_pv +X<refcounted_he_new_pv> - struct refcounted_he * refcounted_he_new(struct refcounted_he *const parent, SV *const key, SV *const value) +Like L</refcounted_he_new_pvn>, but takes a nul-terminated string instead +of a string/length pair. + + struct refcounted_he * refcounted_he_new_pv(struct refcounted_he *parent, const char *key, U32 hash, SV *value, U32 flags) + +=for hackers +Found in file hv.c + +=item refcounted_he_new_pvn +X<refcounted_he_new_pvn> + +Creates a new C<refcounted_he>. This consists of a single key/value +pair and a reference to an existing C<refcounted_he> 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 I<keypv> and I<keylen>. If I<flags> has +the C<REFCOUNTED_HE_KEY_UTF8> bit set, the key octets are interpreted +as UTF-8, otherwise they are interpreted as Latin-1. I<hash> is +a precomputed hash of the key string, or zero if it has not been +precomputed. + +I<value> is the scalar value to store for this key. I<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 C<refcounted_he>. Complex types of scalar will not +be stored with referential integrity, but will be coerced to strings. +I<value> may be either null or C<&PL_sv_placeholder> 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. + +I<parent> points to the rest of the C<refcounted_he> chain to be +attached to the new C<refcounted_he>. This function takes ownership +of one reference to I<parent>, and returns one reference to the new +C<refcounted_he>. + + struct refcounted_he * refcounted_he_new_pvn(struct refcounted_he *parent, const char *keypv, STRLEN keylen, U32 hash, SV *value, U32 flags) + +=for hackers +Found in file hv.c + +=item refcounted_he_new_pvs +X<refcounted_he_new_pvs> + +Like L</refcounted_he_new_pvn>, but takes a literal string instead of +a string/length pair, and no precomputed hash. + + struct refcounted_he * refcounted_he_new_pvs(struct refcounted_he *parent, const char *key, SV *value, U32 flags) + +=for hackers +Found in file hv.h + +=item refcounted_he_new_sv +X<refcounted_he_new_sv> + +Like L</refcounted_he_new_pvn>, but takes a Perl scalar instead of a +string/length pair. + + struct refcounted_he * refcounted_he_new_sv(struct refcounted_he *parent, SV *key, U32 hash, SV *value, U32 flags) =for hackers Found in file hv.c @@ -506,6 +925,27 @@ Triggered by clearing %^H, resets C<PL_compiling.cop_hints_hash>. =for hackers Found in file mg.c +=item magic_methcall +X<magic_methcall> + +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 args themselves are any values following the argc argument. +* flags: + G_DISCARD: invoke method with G_DISCARD flag and don't return a value + G_UNDEF_FILL: fill the stack with argc pointers to PL_sv_undef. + +Returns the SV (if any) returned by the method, or NULL on failure. + + + SV* magic_methcall(SV *sv, const MAGIC *mg, const char *meth, U32 flags, U32 argc, ...) + +=for hackers +Found in file mg.c + =item magic_sethint X<magic_sethint> @@ -573,6 +1013,32 @@ by the C<setisa> magic, should not need to invoke directly. =for hackers Found in file mro.c +=item mro_package_moved +X<mro_package_moved> + +Call this function to signal to a stash that it has been assigned to +another spot in the stash hierarchy. C<stash> is the stash that has been +assigned. C<oldstash> is the stash it replaces, if any. C<gv> is the glob +that is actually being assigned to. + +This can also be called with a null first argument to +indicate that C<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 C<stash>. + +It also sets the effective names (C<HvENAME>) on all the stashes as +appropriate. + +If the C<gv> is present and is not in the symbol table, then this function +simply returns. This checked will be skipped if C<flags & 1>. + + void mro_package_moved(HV * const stash, HV * const oldstash, const GV * const gv, U32 flags) + +=for hackers +Found in file mro.c + =back @@ -628,7 +1094,17 @@ 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 +which the name is valid (accessed through the macros COP_SEQ_RANGE_LOW and +_HIGH). During compilation, these fields may hold the special value +PERL_PADSEQ_INTRO to indicate various stages: + + COP_SEQ_RANGE_LOW _HIGH + ----------------- ----- + PERL_PADSEQ_INTRO 0 variable not yet introduced: { my ($x + valid-seq# PERL_PADSEQ_INTRO variable in scope: { my ($x) + valid-seq# valid-seq# compilation of scope complete: { my ($x) } + +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 @@ -664,172 +1140,6 @@ For state vars, SVs_PADSTALE is overloaded to mean 'not yet initialised' =for hackers 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 -any outer lexicals. - - CV* cv_clone(CV* proto) - -=for hackers -Found in file pad.c - -=item cv_dump -X<cv_dump> - -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<do_dump_pad> - -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<intro_my> - -"Introduce" my variables to visible status. - - U32 intro_my() - -=for hackers -Found in file pad.c - -=item pad_add_anon -X<pad_add_anon> - -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<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 -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<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 no active value. - - PADOFFSET pad_alloc(I32 optype, U32 tmptype) - -=for hackers -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 - - void pad_block_start(int full) - -=for hackers -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; - * an our (anywhere in the pad) with the same name and the same stash - as C<ourstash> -C<is_our> 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<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. - -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<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 -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<pad_free> - -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<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. - - void pad_leavemy() - -=for hackers -Found in file pad.c - =item pad_new X<pad_new> @@ -846,80 +1156,6 @@ can be OR'ed together: =for hackers 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 -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<pad_reset> - -Mark all the current temporaries for reuse - - void pad_reset() - -=for hackers -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. - - void pad_setsv(PADOFFSET po, SV* sv) - -=for hackers -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. - - void pad_swipe(PADOFFSET po, bool refadjust) - -=for hackers -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; - * give it a @_; - * mark tmps as such. - - void pad_tidy(padtidy_type type) - -=for hackers -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 -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 @@ -1154,7 +1390,13 @@ Found in file sv.c =head1 Undocumented functions -These functions are currently undocumented: +The following functions have been flagged as part of the public API, +but are currently undocumented. Use them at your own risk, as the +interfaces are subject to change. + +If you use one of them, you may wish to consider creating and submitting +documentation for it. If your patch is accepted, this will indicate that +the interface is stable (unless it is explicitly marked otherwise). =over @@ -1164,9 +1406,30 @@ X<F0convert> =item Slab_to_rw X<Slab_to_rw> +=item _append_range_to_invlist +X<_append_range_to_invlist> + +=item _new_invlist +X<_new_invlist> + +=item _swash_inversion_hash +X<_swash_inversion_hash> + +=item _swash_to_invlist +X<_swash_to_invlist> + +=item add_alternate +X<add_alternate> + +=item add_cp_to_invlist +X<add_cp_to_invlist> + =item add_data X<add_data> +=item add_range_to_invlist +X<add_range_to_invlist> + =item add_utf16_textfilter X<add_utf16_textfilter> @@ -1188,18 +1451,12 @@ X<amagic_i_ncmp> =item amagic_ncmp X<amagic_ncmp> -=item anonymise_cv -X<anonymise_cv> +=item anonymise_cv_maybe +X<anonymise_cv_maybe> =item ao X<ao> -=item append_elem -X<append_elem> - -=item append_list -X<append_list> - =item append_madprops X<append_madprops> @@ -1212,6 +1469,9 @@ X<apply_attrs> =item apply_attrs_my X<apply_attrs_my> +=item assert_uft8_cache_coherent +X<assert_uft8_cache_coherent> + =item av_reify X<av_reify> @@ -1248,135 +1508,15 @@ X<check_type_and_open> =item check_uni X<check_uni> +=item check_utf8_print +X<check_utf8_print> + =item checkcomma X<checkcomma> =item checkposixcc X<checkposixcc> -=item ck_anoncode -X<ck_anoncode> - -=item ck_bitop -X<ck_bitop> - -=item ck_concat -X<ck_concat> - -=item ck_defined -X<ck_defined> - -=item ck_delete -X<ck_delete> - -=item ck_die -X<ck_die> - -=item ck_each -X<ck_each> - -=item ck_eof -X<ck_eof> - -=item ck_eval -X<ck_eval> - -=item ck_exec -X<ck_exec> - -=item ck_exists -X<ck_exists> - -=item ck_exit -X<ck_exit> - -=item ck_ftst -X<ck_ftst> - -=item ck_fun -X<ck_fun> - -=item ck_glob -X<ck_glob> - -=item ck_grep -X<ck_grep> - -=item ck_index -X<ck_index> - -=item ck_join -X<ck_join> - -=item ck_lfun -X<ck_lfun> - -=item ck_listiob -X<ck_listiob> - -=item ck_match -X<ck_match> - -=item ck_method -X<ck_method> - -=item ck_null -X<ck_null> - -=item ck_open -X<ck_open> - -=item ck_readline -X<ck_readline> - -=item ck_repeat -X<ck_repeat> - -=item ck_require -X<ck_require> - -=item ck_return -X<ck_return> - -=item ck_rfun -X<ck_rfun> - -=item ck_rvconst -X<ck_rvconst> - -=item ck_sassign -X<ck_sassign> - -=item ck_select -X<ck_select> - -=item ck_shift -X<ck_shift> - -=item ck_sort -X<ck_sort> - -=item ck_spair -X<ck_spair> - -=item ck_split -X<ck_split> - -=item ck_subr -X<ck_subr> - -=item ck_substr -X<ck_substr> - -=item ck_svconst -X<ck_svconst> - -=item ck_trunc -X<ck_trunc> - -=item ck_unpack -X<ck_unpack> - =item ckwarn_common X<ckwarn_common> @@ -1389,9 +1529,6 @@ X<cl_anything> =item cl_init X<cl_init> -=item cl_init_zero -X<cl_init_zero> - =item cl_is_anything X<cl_is_anything> @@ -1419,9 +1556,18 @@ X<create_eval_scope> =item curmad X<curmad> +=item curse +X<curse> + =item cv_ckproto_len X<cv_ckproto_len> +=item cvgv_set +X<cvgv_set> + +=item cvstash_set +X<cvstash_set> + =item deb_curcv X<deb_curcv> @@ -1449,8 +1595,8 @@ X<deprecate_commaless_var_list> =item destroy_matcher X<destroy_matcher> -=item die_where -X<die_where> +=item die_unwind +X<die_unwind> =item div128 X<div128> @@ -1464,9 +1610,6 @@ X<do_aexec5> =item do_chomp X<do_chomp> -=item do_chop -X<do_chop> - =item do_delete_local X<do_delete_local> @@ -1488,9 +1631,6 @@ X<do_ipcctl> =item do_ipcget X<do_ipcget> -=item do_kv -X<do_kv> - =item do_msgrcv X<do_msgrcv> @@ -1701,9 +1841,6 @@ X<free_tied_hv_pool> =item gen_constant_list X<gen_constant_list> -=item get_arena -X<get_arena> - =item get_aux_mg X<get_aux_mg> @@ -1716,9 +1853,6 @@ X<get_debug_opts> =item get_hash_seed X<get_hash_seed> -=item get_isa_hash -X<get_isa_hash> - =item get_no_modify X<get_no_modify> @@ -1743,6 +1877,12 @@ X<glob_assign_glob> =item glob_assign_ref X<glob_assign_ref> +=item grok_bslash_c +X<grok_bslash_c> + +=item grok_bslash_o +X<grok_bslash_o> + =item group_end X<group_end> @@ -1755,6 +1895,12 @@ X<gv_get_super_pkg> =item gv_init_sv X<gv_init_sv> +=item gv_magicalize_isa +X<gv_magicalize_isa> + +=item gv_magicalize_overload +X<gv_magicalize_overload> + =item hfreeentries X<hfreeentries> @@ -1767,9 +1913,6 @@ X<hv_auxinit> =item hv_backreferences_p X<hv_backreferences_p> -=item hv_copy_hints_hv -X<hv_copy_hints_hv> - =item hv_delete_common X<hv_delete_common> @@ -1782,6 +1925,9 @@ X<hv_magic_check> =item hv_notallowed X<hv_notallowed> +=item hv_undef_flags +X<hv_undef_flags> + =item incline X<incline> @@ -1833,6 +1979,39 @@ X<intuit_more> =item invert X<invert> +=item invlist_array +X<invlist_array> + +=item invlist_destroy +X<invlist_destroy> + +=item invlist_extend +X<invlist_extend> + +=item invlist_intersection +X<invlist_intersection> + +=item invlist_len +X<invlist_len> + +=item invlist_max +X<invlist_max> + +=item invlist_set_len +X<invlist_set_len> + +=item invlist_set_max +X<invlist_set_max> + +=item invlist_trim +X<invlist_trim> + +=item invlist_union +X<invlist_union> + +=item invoke_exception_hook +X<invoke_exception_hook> + =item io_close X<io_close> @@ -1899,15 +2078,6 @@ X<keyword> =item keyword_plugin_standard X<keyword_plugin_standard> -=item lex_end -X<lex_end> - -=item lex_start -X<lex_start> - -=item linklist -X<linklist> - =item list X<list> @@ -1995,8 +2165,8 @@ X<magic_killbackrefs> =item magic_len X<magic_len> -=item magic_methcall -X<magic_methcall> +=item magic_methcall1 +X<magic_methcall1> =item magic_methpack X<magic_methpack> @@ -2133,6 +2303,12 @@ X<more_bodies> =item more_sv X<more_sv> +=item mro_clean_isarev +X<mro_clean_isarev> + +=item mro_gather_and_rename +X<mro_gather_and_rename> + =item mro_meta_dup X<mro_meta_dup> @@ -2145,6 +2321,9 @@ X<mul128> =item mulexp10 X<mulexp10> +=item munge_qwlist_to_paren_list +X<munge_qwlist_to_paren_list> + =item my_attrs X<my_attrs> @@ -2229,6 +2408,12 @@ X<my_letohl> =item my_letohs X<my_letohs> +=item my_lstat_flags +X<my_lstat_flags> + +=item my_stat_flags +X<my_stat_flags> + =item my_swabn X<my_swabn> @@ -2295,9 +2480,6 @@ X<nuke_stacks> =item num_overflow X<num_overflow> -=item offer_nice_chunk -X<offer_nice_chunk> - =item oopsAV X<oopsAV> @@ -2349,6 +2531,9 @@ X<pad_compname_type> =item pad_peg X<pad_peg> +=item padlist_dup +X<padlist_dup> + =item parse_body X<parse_body> @@ -2373,9 +2558,6 @@ X<pidgone> =item pm_description X<pm_description> -=item pmflag -X<pmflag> - =item pmop_xmldump X<pmop_xmldump> @@ -2385,8 +2567,8 @@ X<pmruntime> =item pmtrans X<pmtrans> -=item prepend_elem -X<prepend_elem> +=item populate_isa +X<populate_isa> =item prepend_madprops X<prepend_madprops> @@ -2418,12 +2600,6 @@ X<readpipe_override> =item ref_array_or_hash X<ref_array_or_hash> -=item refcounted_he_fetch -X<refcounted_he_fetch> - -=item refcounted_he_new_common -X<refcounted_he_new_common> - =item refcounted_he_value X<refcounted_he_value> @@ -2547,12 +2723,18 @@ X<regwhite> =item report_evil_fh X<report_evil_fh> +=item report_wrongway_fh +X<report_wrongway_fh> + =item require_tie_mod X<require_tie_mod> =item restore_magic X<restore_magic> +=item rpeep +X<rpeep> + =item rsignal_restore X<rsignal_restore> @@ -2577,33 +2759,18 @@ X<rxres_save> =item same_dirent X<same_dirent> -=item save_freeop -X<save_freeop> - =item save_hek_flags X<save_hek_flags> -=item save_hints -X<save_hints> - =item save_lines X<save_lines> =item save_magic X<save_magic> -=item save_op -X<save_op> - -=item save_pushi32ptr -X<save_pushi32ptr> - =item save_pushptri32ptr X<save_pushptri32ptr> -=item save_pushptrptr -X<save_pushptrptr> - =item save_scalar_at X<save_scalar_at> @@ -2661,9 +2828,6 @@ X<scan_trans> =item scan_word X<scan_word> -=item scope -X<scope> - =item search_const X<search_const> @@ -2676,6 +2840,12 @@ X<sequence_num> =item sequence_tail X<sequence_tail> +=item set_regclass_bit +X<set_regclass_bit> + +=item set_regclass_bit_fold +X<set_regclass_bit_fold> + =item share_hek_flags X<share_hek_flags> @@ -2748,15 +2918,24 @@ X<sv_2iuv_non_preserve> =item sv_add_backref X<sv_add_backref> +=item sv_catxmlpv +X<sv_catxmlpv> + =item sv_catxmlpvn X<sv_catxmlpvn> =item sv_catxmlsv X<sv_catxmlsv> +=item sv_compile_2op_is_broken +X<sv_compile_2op_is_broken> + =item sv_del_backref X<sv_del_backref> +=item sv_dup_common +X<sv_dup_common> + =item sv_dup_inc_multiple X<sv_dup_inc_multiple> @@ -2805,6 +2984,9 @@ X<swallow_bom> =item swash_get X<swash_get> +=item tied_method +X<tied_method> + =item to_byte_substr X<to_byte_substr> @@ -2832,12 +3014,21 @@ X<too_few_arguments> =item too_many_arguments X<too_many_arguments> +=item try_amagic_bin +X<try_amagic_bin> + +=item try_amagic_un +X<try_amagic_un> + =item uiv_2buf X<uiv_2buf> =item unpack_rec X<unpack_rec> +=item unreferenced_to_tmp_stack +X<unreferenced_to_tmp_stack> + =item unshare_hek X<unshare_hek> @@ -2856,6 +3047,9 @@ X<usage> =item utf16_textfilter X<utf16_textfilter> +=item utf8_mg_len_cache_update +X<utf8_mg_len_cache_update> + =item utf8_mg_pos_cache_update X<utf8_mg_pos_cache_update> @@ -2868,15 +3062,6 @@ X<validate_suid> =item varname X<varname> -=item vdie -X<vdie> - -=item vdie_common -X<vdie_common> - -=item vdie_croak_common -X<vdie_croak_common> - =item visit X<visit> @@ -2892,6 +3077,9 @@ X<wait4pid> =item watch X<watch> +=item with_queued_errors +X<with_queued_errors> + =item write_no_mem X<write_no_mem> @@ -2931,6 +3119,12 @@ X<xmldump_sub_perl> =item xmldump_vindent X<xmldump_vindent> +=item xs_apiversion_bootcheck +X<xs_apiversion_bootcheck> + +=item xs_version_bootcheck +X<xs_version_bootcheck> + =item yyerror X<yyerror> @@ -2940,6 +3134,9 @@ X<yylex> =item yyparse X<yyparse> +=item yyunlex +X<yyunlex> + =item yywarn X<yywarn> |