*/
/*
-=head1 Pad Data Structures
+=for apidoc_section $pad
=for apidoc Amx|PADLIST *|CvPADLIST|CV *cv
can be looked up from Perl code at run time through eval"" the way
C<my>/C<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 C<PL_op->op_targ>), wasting a name SV for them doesn't make sense.
+in C<< PL_op->op_targ >>), wasting a name SV for them doesn't make sense.
The pad names in the PADNAMELIST have their PV holding the name of
the variable. The C<COP_SEQ_RANGE_LOW> and C<_HIGH> fields form a range
For state vars, C<SVs_PADSTALE> is overloaded to mean 'not yet initialised',
but this internal state is stored in a separate pad entry.
-=for apidoc AmxU|PADNAMELIST *|PL_comppad_name
+=for apidoc Amnh||SVs_PADSTALE
+
+=for apidoc AmnxU|PADNAMELIST *|PL_comppad_name
During compilation, this points to the array containing the names part
of the pad for the currently-compiling code.
-=for apidoc AmxU|PAD *|PL_comppad
+=for apidoc AmnxU|PAD *|PL_comppad
During compilation, this points to the array containing the values
part of the pad for the currently-compiling code. (At runtime a CV may
At runtime, this points to the array containing the currently-relevant
values for the pad for the currently-executing code.
-=for apidoc AmxU|SV **|PL_curpad
+=for apidoc AmnxU|SV **|PL_curpad
Points directly to the body of the L</PL_comppad> array.
-(I.e., this is C<PAD_ARRAY(PL_comppad)>.)
+(I.e., this is C<PadARRAY(PL_comppad)>.)
=cut
*/
#endif
/*
-=for apidoc Am|PADLIST *|pad_new|int flags
+=for apidoc pad_new
Create a new padlist, updating the global variables for the
currently-compiling padlist to point to the new padlist. The following
/*
-=head1 Embedding Functions
+=for apidoc_section $embedding
=for apidoc cv_undef
if (name && PadnamePV(name) && *PadnamePV(name) == '&')
{
CV * const innercv = MUTABLE_CV(curpad[ix]);
- U32 inner_rc = SvREFCNT(innercv);
- assert(inner_rc);
+ U32 inner_rc;
+ assert(innercv);
assert(SvTYPE(innercv) != SVt_PVFM);
+ inner_rc = SvREFCNT(innercv);
+ assert(inner_rc);
if (SvREFCNT(comppad) < 2) { /* allow for /(?{ sub{} })/ */
curpad[ix] = NULL;
}
/*
-=for apidoc m|PADOFFSET|pad_alloc_name|PADNAME *name|U32 flags|HV *typestash|HV *ourstash
+=for apidoc pad_alloc_name
Allocates a place in the currently-compiling
pad (via L<perlapi/pad_alloc>) and
}
/*
-=for apidoc Am|PADOFFSET|pad_add_name_pvn|const char *namepv|STRLEN namelen|U32 flags|HV *typestash|HV *ourstash
+=for apidoc pad_add_name_pvn
Allocates a place in the currently-compiling pad for a named lexical
variable. Stores the name and other metadata in the name part of the
}
/*
-=for apidoc Am|PADOFFSET|pad_add_name_pv|const char *name|U32 flags|HV *typestash|HV *ourstash
+=for apidoc pad_add_name_pv
Exactly like L</pad_add_name_pvn>, but takes a nul-terminated string
instead of a string/length pair.
}
/*
-=for apidoc Am|PADOFFSET|pad_add_name_sv|SV *name|U32 flags|HV *typestash|HV *ourstash
+=for apidoc pad_add_name_sv
Exactly like L</pad_add_name_pvn>, but takes the name string in the form
of an SV instead of a string/length pair.
}
/*
-=for apidoc Amx|PADOFFSET|pad_alloc|I32 optype|U32 tmptype
+=for apidoc pad_alloc
Allocates a place in the currently-compiling pad,
returning the offset of the allocated pad slot.
}
/*
-=for apidoc Am|PADOFFSET|pad_add_anon|CV *func|I32 optype
+=for apidoc pad_add_anon
Allocates a place in the currently-compiling pad (via L</pad_alloc>)
for an anonymous function that is lexically scoped inside the
assert((flags & ~padadd_OUR) == 0);
- if (PadnamelistMAX(PL_comppad_name) < 0 || !ckWARN(WARN_MISC))
+ if (PadnamelistMAX(PL_comppad_name) < 0 || !ckWARN(WARN_SHADOW))
return; /* nothing to check */
svp = PadnamelistARRAY(PL_comppad_name);
if (is_our && (SvPAD_OUR(sv)))
break; /* "our" masking "our" */
/* diag_listed_as: "%s" variable %s masks earlier declaration in same %s */
- Perl_warner(aTHX_ packWARN(WARN_MISC),
+ Perl_warner(aTHX_ packWARN(WARN_SHADOW),
"\"%s\" %s %" PNf " masks earlier declaration in same %s",
( is_our ? "our" :
PL_parser->in_my == KEY_my ? "my" :
&& SvOURSTASH(sv) == ourstash
&& memEQ(PadnamePV(sv), PadnamePV(name), PadnameLEN(name)))
{
- Perl_warner(aTHX_ packWARN(WARN_MISC),
+ Perl_warner(aTHX_ packWARN(WARN_SHADOW),
"\"our\" variable %" PNf " redeclared", PNfARG(sv));
if (off <= PL_comppad_name_floor)
- Perl_warner(aTHX_ packWARN(WARN_MISC),
+ Perl_warner(aTHX_ packWARN(WARN_SHADOW),
"\t(Did you mean \"local\" instead of \"our\"?)\n");
break;
}
/*
-=for apidoc Am|PADOFFSET|pad_findmy_pvn|const char *namepv|STRLEN namelen|U32 flags
+=for apidoc pad_findmy_pvn
Given the name of a lexical variable, find its position in the
currently-compiling pad.
}
/*
-=for apidoc Am|PADOFFSET|pad_findmy_pv|const char *name|U32 flags
+=for apidoc pad_findmy_pv
Exactly like L</pad_findmy_pvn>, but takes a nul-terminated string
instead of a string/length pair.
}
/*
-=for apidoc Am|PADOFFSET|pad_findmy_sv|SV *name|U32 flags
+=for apidoc pad_findmy_sv
Exactly like L</pad_findmy_pvn>, but takes the name string in the form
of an SV instead of a string/length pair.
}
/*
-=for apidoc Amp|PADOFFSET|find_rundefsvoffset
+=for apidoc find_rundefsvoffset
Until the lexical C<$_> feature was removed, this function would
find the position of the lexical C<$_> in the pad of the
}
/*
-=for apidoc Am|SV *|find_rundefsv
+=for apidoc find_rundefsv
Returns the global variable C<$_>.
}
/*
-=for apidoc m|PADOFFSET|pad_findlex|const char *namepv|STRLEN namelen|U32 flags|const CV* cv|U32 seq|int warn|SV** out_capture|PADNAME** out_name|int *out_flags
+=for apidoc 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 C<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 names in anon protoypes have to store in C<xpadn_low> the
+because fake names in anon prototypes have to store in C<xpadn_low> the
index into the parent pad.
=cut
{
/* diag_listed_as: Variable "%s" is not available */
Perl_ck_warner(aTHX_ packWARN(WARN_CLOSURE),
- "%se \"%" PNf "\" is not available",
+ "%s \"%" PNf "\" is not available",
*PadnamePV(name) == '&'
- ? "Subroutin"
- : "Variabl",
+ ? "Subroutine"
+ : "Variable",
PNfARG(name));
}
/* diag_listed_as: Variable "%s" will not stay
shared */
Perl_warner(aTHX_ packWARN(WARN_CLOSURE),
- "%se \"%" UTF8f "\" will not stay shared",
- *namepv == '&' ? "Subroutin" : "Variabl",
+ "%s \"%" UTF8f "\" will not stay shared",
+ *namepv == '&' ? "Subroutine" : "Variable",
UTF8fARG(1, namelen, namepv));
}
#ifdef DEBUGGING
/*
-=for apidoc Am|SV *|pad_sv|PADOFFSET po
+=for apidoc pad_sv
Get the value at offset C<po> in the current (compiling or executing) pad.
Use macro C<PAD_SV> instead of calling this function directly.
}
/*
-=for apidoc Am|void|pad_setsv|PADOFFSET po|SV *sv
+=for apidoc pad_setsv
Set the value at offset C<po> in the current (compiling or executing) pad.
Use the macro C<PAD_SETSV()> rather than calling this function directly.
#endif /* DEBUGGING */
/*
-=for apidoc m|void|pad_block_start|int full
+=for apidoc pad_block_start
Update the pad compilation state variables on entry to a new block.
}
/*
-=for apidoc Am|U32|intro_my
+=for apidoc intro_my
"Introduce" C<my> variables to visible status. This is called during parsing
at the end of each statement to make lexical variables visible to subsequent
}
/*
-=for apidoc m|void|pad_leavemy
+=for apidoc 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.
}
/*
-=for apidoc m|void|pad_swipe|PADOFFSET po|bool refadjust
+=for apidoc pad_swipe
Abandon the tmp in the current pad at offset C<po> and replace with a
new one.
}
/*
-=for apidoc m|void|pad_reset
+=for apidoc pad_reset
Mark all the current temporaries for reuse
}
/*
-=for apidoc Amx|void|pad_tidy|padtidy_type type
+=for apidoc pad_tidy
Tidy up a pad at the end of compilation of the code to which it belongs.
Jobs performed here are: remove most stuff from the pads of anonsub
void
Perl_pad_tidy(pTHX_ padtidy_type type)
{
- dVAR;
ASSERT_CURPAD_ACTIVE("pad_tidy");
}
/*
-=for apidoc m|void|pad_free|PADOFFSET po
+=for apidoc pad_free
Free the SV at offset po in the current pad.
}
/*
-=for apidoc m|void|do_dump_pad|I32 level|PerlIO *file|PADLIST *padlist|int full
+=for apidoc do_dump_pad
Dump the contents of a padlist
#ifdef DEBUGGING
/*
-=for apidoc m|void|cv_dump|CV *cv|const char *title
+=for apidoc cv_dump
dump the contents of a CV
#endif /* DEBUGGING */
/*
-=for apidoc Am|CV *|cv_clone|CV *proto
+=for apidoc cv_clone
Clone a CV, making a lexical closure. C<proto> supplies the prototype
of the function: its code, pad structure, and other attributes.
{
/* my sub */
/* Just provide a stub, but name it. It will be
- upgrade to the real thing on scope entry. */
- dVAR;
+ upgraded to the real thing on scope entry. */
U32 hash;
PERL_HASH(hash, PadnamePV(namesv)+1,
PadnameLEN(namesv) - 1);
* from the parent */
if (const_sv && SvREFCNT(const_sv) == 2) {
const bool was_method = cBOOL(CvMETHOD(cv));
- bool copied = FALSE;
if (outside) {
PADNAME * const pn =
PadlistNAMESARRAY(CvPADLIST(outside))
) == o
&& !OpSIBLING(o))
{
- Perl_ck_warner_d(aTHX_
- packWARN(WARN_DEPRECATED),
- "Constants from lexical "
- "variables potentially "
- "modified elsewhere are "
- "deprecated. This will not "
- "be allowed in Perl 5.32");
- /* We *copy* the lexical variable, and donate the
- copy to newCONSTSUB. Yes, this is ugly, and
- should be killed. We need to do this for the
- time being, however, because turning on SvPADTMP
- on a lexical will have observable effects
- elsewhere. */
- const_sv = newSVsv(const_sv);
- copied = TRUE;
+ Perl_croak(aTHX_
+ "Constants from lexical variables potentially modified "
+ "elsewhere are no longer permitted");
}
else
goto constoff;
}
}
- if (!copied)
- SvREFCNT_inc_simple_void_NN(const_sv);
+ SvREFCNT_inc_simple_void_NN(const_sv);
/* If the lexical is not used elsewhere, it is safe to turn on
SvPADTMP, since it is only when it is used in lvalue con-
text that the difference is observable. */
S_cv_clone(pTHX_ CV *proto, CV *cv, CV *outside, HV *cloned)
{
#ifdef USE_ITHREADS
- dVAR;
#endif
const bool newcv = !cv;
included. If the first argument is neither a CV nor a GV, this flag is
ignored (subject to change).
+=for apidoc Amnh||CV_NAME_NOTQUAL
+
=cut
*/
if (CvLEXICAL(cv) || flags & CV_NAME_NOTQUAL)
sv_sethek(retsv, CvNAME_HEK(cv));
else {
- sv_sethek(retsv, HvNAME_HEK(CvSTASH(cv)));
+ if (CvSTASH(cv) && HvNAME_HEK(CvSTASH(cv)))
+ sv_sethek(retsv, HvNAME_HEK(CvSTASH(cv)));
+ else
+ sv_setpvs(retsv, "__ANON__");
sv_catpvs(retsv, "::");
sv_cathek(retsv, CvNAME_HEK(cv));
}
}
/*
-=for apidoc m|void|pad_fixup_inner_anons|PADLIST *padlist|CV *old_cv|CV *new_cv
+=for apidoc pad_fixup_inner_anons
For any anon CVs in the pad, change C<CvOUTSIDE> of that CV from
C<old_cv> to C<new_cv> if necessary. Needed when a newly-compiled CV has to be
}
/*
-=for apidoc m|void|pad_push|PADLIST *padlist|int depth
+=for apidoc 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 outer pad name that this one mirrors. The returned pad name has the
C<PADNAMEt_OUTER> flag already set.
+=for apidoc Amnh||PADNAMEt_OUTER
+
=cut
*/
https://perl5.git.perl.org / perl5.git / blobdiff