X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/dd2155a49b710f23bc6d72169e5b1d71d8b3aa03..1a04e7910442e8e0183c57deb03b6804b9774f3c:/pad.h diff --git a/pad.h b/pad.h index abefde5..26d4e7a 100644 --- a/pad.h +++ b/pad.h @@ -1,6 +1,6 @@ /* pad.h * - * Copyright (c) 2002, Larry Wall + * Copyright (C) 2002, 2003, 2005, by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. @@ -17,7 +17,7 @@ * so hide the type. Ditto a pad. */ typedef AV PADLIST; -typedef SV** PAD; +typedef AV PAD; /* offsets within a pad */ @@ -34,11 +34,9 @@ typedef U64TYPE PADOFFSET; /* flags for the pad_new() function */ -typedef enum { - padnew_CLONE = 1, /* this pad is for a cloned CV */ - padnew_SAVE = 2, /* save old globals */ - padnew_SAVESUB = 4, /* also save extra stuff for start of sub */ -} padnew_flags; +#define padnew_CLONE 1 /* this pad is for a cloned CV */ +#define padnew_SAVE 2 /* save old globals */ +#define padnew_SAVESUB 4 /* also save extra stuff for start of sub */ /* values for the pad_tidy() function */ @@ -48,22 +46,48 @@ typedef enum { padtidy_FORMAT /* or a format */ } padtidy_type; +/* ASSERT_CURPAD_LEGAL and ASSERT_CURPAD_ACTIVE respectively determine + * whether PL_comppad and PL_curpad are consistent and whether they have + * active values */ + +#ifndef PERL_MAD +# define pad_peg(label) +#endif -/* Note: the following four macros are actually defined in scope.h, but +#ifdef DEBUGGING +# define ASSERT_CURPAD_LEGAL(label) \ + pad_peg(label); \ + if (PL_comppad ? (AvARRAY(PL_comppad) != PL_curpad) : (PL_curpad != 0)) \ + Perl_croak(aTHX_ "panic: illegal pad in %s: 0x%"UVxf"[0x%"UVxf"]",\ + label, PTR2UV(PL_comppad), PTR2UV(PL_curpad)); + + +# define ASSERT_CURPAD_ACTIVE(label) \ + pad_peg(label); \ + if (!PL_comppad || (AvARRAY(PL_comppad) != PL_curpad)) \ + Perl_croak(aTHX_ "panic: invalid pad in %s: 0x%"UVxf"[0x%"UVxf"]",\ + label, PTR2UV(PL_comppad), PTR2UV(PL_curpad)); +#else +# define ASSERT_CURPAD_LEGAL(label) +# define ASSERT_CURPAD_ACTIVE(label) +#endif + + + +/* Note: the following three macros are actually defined in scope.h, but * they are documented here for completeness, since they directly or * indirectly affect pads. =for apidoc m|void|SAVEPADSV |PADOFFSET po Save a pad slot (used to restore after an iteration) +XXX DAPM it would make more sense to make the arg a PADOFFSET =for apidoc m|void|SAVECLEARSV |SV **svp -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') =for apidoc m|void|SAVECOMPPAD save PL_comppad and PL_curpad -=for apidoc m|void|SAVEFREEOP |OP *o -Free the op on scope exit. At the same time, reset PL_curpad @@ -85,13 +109,25 @@ Get the value from slot C in the base (DEPTH=1) pad of a padlist =for apidoc m|void|PAD_SET_CUR |PADLIST padlist|I32 n Set the current pad to be pad C 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 + + SAVECOMPPAD(); + PAD_SET_CUR_NOSAVE(padlist,n); + + +=for apidoc m|void|PAD_SET_CUR_NOSAVE |PADLIST padlist|I32 n +like PAD_SET_CUR, but without the save =for apidoc m|void|PAD_SAVE_SETNULLPAD Save the current pad then set it to null. -=for apidoc m|void|PAD_UPDATE_CURPAD -Set PL_curpad from the value of PL_comppad. +=for apidoc m|void|PAD_SAVE_LOCAL|PAD *opad|PAD *npad +Save the current pad to the local variable opad, then make the +current pad equal to npad + +=for apidoc m|void|PAD_RESTORE_LOCAL|PAD *opad +Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL() =cut */ @@ -108,32 +144,55 @@ Set PL_curpad from the value of PL_comppad. #define PAD_BASE_SV(padlist, po) \ (AvARRAY(padlist)[1]) \ - ? AvARRAY((AV*)(AvARRAY(padlist)[1]))[po] : Nullsv; + ? AvARRAY((AV*)(AvARRAY(padlist)[1]))[po] : NULL; -#define PAD_SET_CUR(padlist,n) \ - SAVEVPTR(PL_curpad); \ - PL_curpad = AvARRAY((AV*)*av_fetch((padlist),(n),FALSE)) +#define PAD_SET_CUR_NOSAVE(padlist,nth) \ + PL_comppad = (PAD*) (AvARRAY(padlist)[nth]); \ + PL_curpad = AvARRAY(PL_comppad); \ + DEBUG_Xv(PerlIO_printf(Perl_debug_log, \ + "Pad 0x%"UVxf"[0x%"UVxf"] set_cur depth=%d\n", \ + PTR2UV(PL_comppad), PTR2UV(PL_curpad), (int)(nth))); + + +#define PAD_SET_CUR(padlist,nth) \ + SAVECOMPPAD(); \ + PAD_SET_CUR_NOSAVE(padlist,nth); + -#define PAD_SAVE_SETNULLPAD SAVEVPTR(PL_curpad); PL_curpad = 0; +#define PAD_SAVE_SETNULLPAD() SAVECOMPPAD(); \ + PL_comppad = NULL; PL_curpad = NULL; \ + DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad set_null\n")); -#define PAD_UPDATE_CURPAD \ - PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : Null(PAD) +#define PAD_SAVE_LOCAL(opad,npad) \ + opad = PL_comppad; \ + PL_comppad = (npad); \ + PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \ + DEBUG_Xv(PerlIO_printf(Perl_debug_log, \ + "Pad 0x%"UVxf"[0x%"UVxf"] save_local\n", \ + PTR2UV(PL_comppad), PTR2UV(PL_curpad))); + +#define PAD_RESTORE_LOCAL(opad) \ + PL_comppad = opad; \ + PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \ + DEBUG_Xv(PerlIO_printf(Perl_debug_log, \ + "Pad 0x%"UVxf"[0x%"UVxf"] restore_local\n", \ + PTR2UV(PL_comppad), PTR2UV(PL_curpad))); /* =for apidoc m|void|CX_CURPAD_SAVE|struct context Save the current pad in the given context block structure. -=for apidoc m|PAD *|CX_CURPAD_SV|struct context|PADOFFSET po +=for apidoc m|SV *|CX_CURPAD_SV|struct context|PADOFFSET po Access the SV at offset po in the saved current pad in the given context block structure (can be used as an lvalue). =cut */ -#define CX_CURPAD_SAVE(block) (block).oldcurpad = PL_curpad -#define CX_CURPAD_SV(block,po) ((block).oldcurpad[po]) +#define CX_CURPAD_SAVE(block) (block).oldcomppad = PL_comppad +#define CX_CURPAD_SV(block,po) (AvARRAY((AV*)((block).oldcomppad))[po]) /* @@ -157,23 +216,27 @@ Assumes the slot entry is a valid C lexical. The generation number of the name at offset C in the current compiling pad (lvalue). Note that C is hijacked for this purpose. +=for apidoc m|STRLEN|PAD_COMPNAME_GEN_set|PADOFFSET po|int gen +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. + =cut + */ #define PAD_COMPNAME_FLAGS(po) SvFLAGS(*av_fetch(PL_comppad_name, (po), FALSE)) +#define PAD_COMPNAME_FLAGS_isOUR(po) \ + ((PAD_COMPNAME_FLAGS(po) & (SVpad_NAME|SVpad_OUR)) == (SVpad_NAME|SVpad_OUR)) #define PAD_COMPNAME_PV(po) SvPV_nolen(*av_fetch(PL_comppad_name, (po), FALSE)) -/* XXX DAPM yuk - using av_fetch twice. Is there a better way? */ -#define PAD_COMPNAME_TYPE(po) \ - ((SvFLAGS(*av_fetch(PL_comppad_name, (po), FALSE)) & SVpad_TYPED) \ - ? (SvSTASH(*av_fetch(PL_comppad_name, (po), FALSE))) : Nullhv) +#define PAD_COMPNAME_TYPE(po) pad_compname_type(po) #define PAD_COMPNAME_OURSTASH(po) \ - (GvSTASH(*av_fetch(PL_comppad_name, (po), FALSE))) + (OURSTASH(*av_fetch(PL_comppad_name, (po), FALSE))) #define PAD_COMPNAME_GEN(po) SvCUR(AvARRAY(PL_comppad_name)[po]) - +#define PAD_COMPNAME_GEN_set(po, gen) SvCUR_set(AvARRAY(PL_comppad_name)[po], gen) /* @@ -199,13 +262,20 @@ Clone the state variables associated with running and compiling pads. else \ (dstpad) = av_dup_inc((srcpad), param); +/* NB - we set PL_comppad to null unless it points at a value that + * has already been dup'ed, ie it points to part of an active padlist. + * Otherwise PL_comppad ends up being a leaked scalar in code like + * the following: + * threads->create(sub { threads->create(sub {...} ) } ); + * where the second thread dups the outer sub's comppad but not the + * sub's CV or padlist. */ + #define PAD_CLONE_VARS(proto_perl, param) \ - PL_comppad = av_dup(proto_perl->Icomppad, param); \ + PL_comppad = (AV *) ptr_table_fetch(PL_ptr_table, proto_perl->Icomppad); \ + PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \ PL_comppad_name = av_dup(proto_perl->Icomppad_name, param); \ PL_comppad_name_fill = proto_perl->Icomppad_name_fill; \ PL_comppad_name_floor = proto_perl->Icomppad_name_floor; \ - PL_curpad = (SV**)ptr_table_fetch(PL_ptr_table, \ - proto_perl->Tcurpad); \ PL_min_intro_pending = proto_perl->Imin_intro_pending; \ PL_max_intro_pending = proto_perl->Imax_intro_pending; \ PL_padix = proto_perl->Ipadix; \