| 1 | /* pad.h
|
|---|
| 2 | *
|
|---|
| 3 | * Copyright (C) 2002, 2003, 2005, by Larry Wall and others
|
|---|
| 4 | *
|
|---|
| 5 | * You may distribute under the terms of either the GNU General Public
|
|---|
| 6 | * License or the Artistic License, as specified in the README file.
|
|---|
| 7 | *
|
|---|
| 8 | * This file defines the types and macros associated with the API for
|
|---|
| 9 | * manipulating scratchpads, which are used by perl to store lexical
|
|---|
| 10 | * variables, op targets and constants.
|
|---|
| 11 | */
|
|---|
| 12 |
|
|---|
| 13 |
|
|---|
| 14 |
|
|---|
| 15 |
|
|---|
| 16 | /* a padlist is currently just an AV; but that might change,
|
|---|
| 17 | * so hide the type. Ditto a pad. */
|
|---|
| 18 |
|
|---|
| 19 | typedef AV PADLIST;
|
|---|
| 20 | typedef AV PAD;
|
|---|
| 21 |
|
|---|
| 22 |
|
|---|
| 23 | /* offsets within a pad */
|
|---|
| 24 |
|
|---|
| 25 | #if PTRSIZE == 4
|
|---|
| 26 | typedef U32TYPE PADOFFSET;
|
|---|
| 27 | #else
|
|---|
| 28 | # if PTRSIZE == 8
|
|---|
| 29 | typedef U64TYPE PADOFFSET;
|
|---|
| 30 | # endif
|
|---|
| 31 | #endif
|
|---|
| 32 | #define NOT_IN_PAD ((PADOFFSET) -1)
|
|---|
| 33 |
|
|---|
| 34 |
|
|---|
| 35 | /* flags for the pad_new() function */
|
|---|
| 36 |
|
|---|
| 37 | #define padnew_CLONE 1 /* this pad is for a cloned CV */
|
|---|
| 38 | #define padnew_SAVE 2 /* save old globals */
|
|---|
| 39 | #define padnew_SAVESUB 4 /* also save extra stuff for start of sub */
|
|---|
| 40 |
|
|---|
| 41 | /* values for the pad_tidy() function */
|
|---|
| 42 |
|
|---|
| 43 | typedef enum {
|
|---|
| 44 | padtidy_SUB, /* tidy up a pad for a sub, */
|
|---|
| 45 | padtidy_SUBCLONE, /* a cloned sub, */
|
|---|
| 46 | padtidy_FORMAT /* or a format */
|
|---|
| 47 | } padtidy_type;
|
|---|
| 48 |
|
|---|
| 49 | /* ASSERT_CURPAD_LEGAL and ASSERT_CURPAD_ACTIVE respectively determine
|
|---|
| 50 | * whether PL_comppad and PL_curpad are consistent and whether they have
|
|---|
| 51 | * active values */
|
|---|
| 52 |
|
|---|
| 53 | #ifdef DEBUGGING
|
|---|
| 54 | # define ASSERT_CURPAD_LEGAL(label) \
|
|---|
| 55 | if (PL_comppad ? (AvARRAY(PL_comppad) != PL_curpad) : (PL_curpad != 0)) \
|
|---|
| 56 | Perl_croak(aTHX_ "panic: illegal pad in %s: 0x%"UVxf"[0x%"UVxf"]",\
|
|---|
| 57 | label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
|
|---|
| 58 |
|
|---|
| 59 |
|
|---|
| 60 | # define ASSERT_CURPAD_ACTIVE(label) \
|
|---|
| 61 | if (!PL_comppad || (AvARRAY(PL_comppad) != PL_curpad)) \
|
|---|
| 62 | Perl_croak(aTHX_ "panic: invalid pad in %s: 0x%"UVxf"[0x%"UVxf"]",\
|
|---|
| 63 | label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
|
|---|
| 64 | #else
|
|---|
| 65 | # define ASSERT_CURPAD_LEGAL(label)
|
|---|
| 66 | # define ASSERT_CURPAD_ACTIVE(label)
|
|---|
| 67 | #endif
|
|---|
| 68 |
|
|---|
| 69 |
|
|---|
| 70 |
|
|---|
| 71 | /* Note: the following three macros are actually defined in scope.h, but
|
|---|
| 72 | * they are documented here for completeness, since they directly or
|
|---|
| 73 | * indirectly affect pads.
|
|---|
| 74 |
|
|---|
| 75 | =for apidoc m|void|SAVEPADSV |PADOFFSET po
|
|---|
| 76 | Save a pad slot (used to restore after an iteration)
|
|---|
| 77 |
|
|---|
| 78 | XXX DAPM it would make more sense to make the arg a PADOFFSET
|
|---|
| 79 | =for apidoc m|void|SAVECLEARSV |SV **svp
|
|---|
| 80 | Clear the pointed to pad value on scope exit. (i.e. the runtime action of 'my')
|
|---|
| 81 |
|
|---|
| 82 | =for apidoc m|void|SAVECOMPPAD
|
|---|
| 83 | save PL_comppad and PL_curpad
|
|---|
| 84 |
|
|---|
| 85 |
|
|---|
| 86 |
|
|---|
| 87 |
|
|---|
| 88 |
|
|---|
| 89 | =for apidoc m|SV *|PAD_SETSV |PADOFFSET po|SV* sv
|
|---|
| 90 | Set the slot at offset C<po> in the current pad to C<sv>
|
|---|
| 91 |
|
|---|
| 92 | =for apidoc m|void|PAD_SV |PADOFFSET po
|
|---|
| 93 | Get the value at offset C<po> in the current pad
|
|---|
| 94 |
|
|---|
| 95 | =for apidoc m|SV *|PAD_SVl |PADOFFSET po
|
|---|
| 96 | Lightweight and lvalue version of C<PAD_SV>.
|
|---|
| 97 | Get or set the value at offset C<po> in the current pad.
|
|---|
| 98 | Unlike C<PAD_SV>, does not print diagnostics with -DX.
|
|---|
| 99 | For internal use only.
|
|---|
| 100 |
|
|---|
| 101 | =for apidoc m|SV *|PAD_BASE_SV |PADLIST padlist|PADOFFSET po
|
|---|
| 102 | Get the value from slot C<po> in the base (DEPTH=1) pad of a padlist
|
|---|
| 103 |
|
|---|
| 104 | =for apidoc m|void|PAD_SET_CUR |PADLIST padlist|I32 n
|
|---|
| 105 | Set the current pad to be pad C<n> in the padlist, saving
|
|---|
| 106 | the previous current pad. NB currently this macro expands to a string too
|
|---|
| 107 | long for some compilers, so it's best to replace it with
|
|---|
| 108 |
|
|---|
| 109 | SAVECOMPPAD();
|
|---|
| 110 | PAD_SET_CUR_NOSAVE(padlist,n);
|
|---|
| 111 |
|
|---|
| 112 |
|
|---|
| 113 | =for apidoc m|void|PAD_SET_CUR_NOSAVE |PADLIST padlist|I32 n
|
|---|
| 114 | like PAD_SET_CUR, but without the save
|
|---|
| 115 |
|
|---|
| 116 | =for apidoc m|void|PAD_SAVE_SETNULLPAD
|
|---|
| 117 | Save the current pad then set it to null.
|
|---|
| 118 |
|
|---|
| 119 | =for apidoc m|void|PAD_SAVE_LOCAL|PAD *opad|PAD *npad
|
|---|
| 120 | Save the current pad to the local variable opad, then make the
|
|---|
| 121 | current pad equal to npad
|
|---|
| 122 |
|
|---|
| 123 | =for apidoc m|void|PAD_RESTORE_LOCAL|PAD *opad
|
|---|
| 124 | Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL()
|
|---|
| 125 |
|
|---|
| 126 | =cut
|
|---|
| 127 | */
|
|---|
| 128 |
|
|---|
| 129 | #ifdef DEBUGGING
|
|---|
| 130 | # define PAD_SV(po) pad_sv(po)
|
|---|
| 131 | # define PAD_SETSV(po,sv) pad_setsv(po,sv)
|
|---|
| 132 | #else
|
|---|
| 133 | # define PAD_SV(po) (PL_curpad[po])
|
|---|
| 134 | # define PAD_SETSV(po,sv) PL_curpad[po] = (sv)
|
|---|
| 135 | #endif
|
|---|
| 136 |
|
|---|
| 137 | #define PAD_SVl(po) (PL_curpad[po])
|
|---|
| 138 |
|
|---|
| 139 | #define PAD_BASE_SV(padlist, po) \
|
|---|
| 140 | (AvARRAY(padlist)[1]) \
|
|---|
| 141 | ? AvARRAY((AV*)(AvARRAY(padlist)[1]))[po] : Nullsv;
|
|---|
| 142 |
|
|---|
| 143 |
|
|---|
| 144 | #define PAD_SET_CUR_NOSAVE(padlist,n) \
|
|---|
| 145 | PL_comppad = (PAD*) (AvARRAY(padlist)[n]); \
|
|---|
| 146 | PL_curpad = AvARRAY(PL_comppad); \
|
|---|
| 147 | DEBUG_Xv(PerlIO_printf(Perl_debug_log, \
|
|---|
| 148 | "Pad 0x%"UVxf"[0x%"UVxf"] set_cur depth=%d\n", \
|
|---|
| 149 | PTR2UV(PL_comppad), PTR2UV(PL_curpad), (int)(n)));
|
|---|
| 150 |
|
|---|
| 151 |
|
|---|
| 152 | #define PAD_SET_CUR(padlist,n) \
|
|---|
| 153 | SAVECOMPPAD(); \
|
|---|
| 154 | PAD_SET_CUR_NOSAVE(padlist,n);
|
|---|
| 155 |
|
|---|
| 156 |
|
|---|
| 157 | #define PAD_SAVE_SETNULLPAD() SAVECOMPPAD(); \
|
|---|
| 158 | PL_comppad = Null(PAD*); PL_curpad = Null(SV**); \
|
|---|
| 159 | DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad set_null\n"));
|
|---|
| 160 |
|
|---|
| 161 | #define PAD_SAVE_LOCAL(opad,npad) \
|
|---|
| 162 | opad = PL_comppad; \
|
|---|
| 163 | PL_comppad = (npad); \
|
|---|
| 164 | PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : Null(SV**); \
|
|---|
| 165 | DEBUG_Xv(PerlIO_printf(Perl_debug_log, \
|
|---|
| 166 | "Pad 0x%"UVxf"[0x%"UVxf"] save_local\n", \
|
|---|
| 167 | PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
|
|---|
| 168 |
|
|---|
| 169 | #define PAD_RESTORE_LOCAL(opad) \
|
|---|
| 170 | PL_comppad = opad; \
|
|---|
| 171 | PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : Null(SV**); \
|
|---|
| 172 | DEBUG_Xv(PerlIO_printf(Perl_debug_log, \
|
|---|
| 173 | "Pad 0x%"UVxf"[0x%"UVxf"] restore_local\n", \
|
|---|
| 174 | PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
|
|---|
| 175 |
|
|---|
| 176 |
|
|---|
| 177 | /*
|
|---|
| 178 | =for apidoc m|void|CX_CURPAD_SAVE|struct context
|
|---|
| 179 | Save the current pad in the given context block structure.
|
|---|
| 180 |
|
|---|
| 181 | =for apidoc m|SV *|CX_CURPAD_SV|struct context|PADOFFSET po
|
|---|
| 182 | Access the SV at offset po in the saved current pad in the given
|
|---|
| 183 | context block structure (can be used as an lvalue).
|
|---|
| 184 |
|
|---|
| 185 | =cut
|
|---|
| 186 | */
|
|---|
| 187 |
|
|---|
| 188 | #define CX_CURPAD_SAVE(block) (block).oldcomppad = PL_comppad
|
|---|
| 189 | #define CX_CURPAD_SV(block,po) (AvARRAY((AV*)((block).oldcomppad))[po])
|
|---|
| 190 |
|
|---|
| 191 |
|
|---|
| 192 | /*
|
|---|
| 193 | =for apidoc m|U32|PAD_COMPNAME_FLAGS|PADOFFSET po
|
|---|
| 194 | Return the flags for the current compiling pad name
|
|---|
| 195 | at offset C<po>. Assumes a valid slot entry.
|
|---|
| 196 |
|
|---|
| 197 | =for apidoc m|char *|PAD_COMPNAME_PV|PADOFFSET po
|
|---|
| 198 | Return the name of the current compiling pad name
|
|---|
| 199 | at offset C<po>. Assumes a valid slot entry.
|
|---|
| 200 |
|
|---|
| 201 | =for apidoc m|HV *|PAD_COMPNAME_TYPE|PADOFFSET po
|
|---|
| 202 | Return the type (stash) of the current compiling pad name at offset
|
|---|
| 203 | C<po>. Must be a valid name. Returns null if not typed.
|
|---|
| 204 |
|
|---|
| 205 | =for apidoc m|HV *|PAD_COMPNAME_OURSTASH|PADOFFSET po
|
|---|
| 206 | Return the stash associated with an C<our> variable.
|
|---|
| 207 | Assumes the slot entry is a valid C<our> lexical.
|
|---|
| 208 |
|
|---|
| 209 | =for apidoc m|STRLEN|PAD_COMPNAME_GEN|PADOFFSET po
|
|---|
| 210 | The generation number of the name at offset C<po> in the current
|
|---|
| 211 | compiling pad (lvalue). Note that C<SvCUR> is hijacked for this purpose.
|
|---|
| 212 |
|
|---|
| 213 | =for apidoc m|STRLEN|PAD_COMPNAME_GEN_set|PADOFFSET po|int gen
|
|---|
| 214 | Sets the generation number of the name at offset C<po> in the current
|
|---|
| 215 | ling pad (lvalue) to C<gen>. Note that C<SvCUR_set> is hijacked for this purpose.
|
|---|
| 216 |
|
|---|
| 217 | =cut
|
|---|
| 218 |
|
|---|
| 219 | */
|
|---|
| 220 |
|
|---|
| 221 | #define PAD_COMPNAME_FLAGS(po) SvFLAGS(*av_fetch(PL_comppad_name, (po), FALSE))
|
|---|
| 222 | #define PAD_COMPNAME_PV(po) SvPV_nolen(*av_fetch(PL_comppad_name, (po), FALSE))
|
|---|
| 223 |
|
|---|
| 224 | #define PAD_COMPNAME_TYPE(po) pad_compname_type(po)
|
|---|
| 225 |
|
|---|
| 226 | #define PAD_COMPNAME_OURSTASH(po) \
|
|---|
| 227 | (GvSTASH(*av_fetch(PL_comppad_name, (po), FALSE)))
|
|---|
| 228 |
|
|---|
| 229 | #define PAD_COMPNAME_GEN(po) SvCUR(AvARRAY(PL_comppad_name)[po])
|
|---|
| 230 |
|
|---|
| 231 | #define PAD_COMPNAME_GEN_set(po, gen) SvCUR_set(AvARRAY(PL_comppad_name)[po], gen)
|
|---|
| 232 |
|
|---|
| 233 |
|
|---|
| 234 | /*
|
|---|
| 235 | =for apidoc m|void|PAD_DUP|PADLIST dstpad|PADLIST srcpad|CLONE_PARAMS* param
|
|---|
| 236 | Clone a padlist.
|
|---|
| 237 |
|
|---|
| 238 | =for apidoc m|void|PAD_CLONE_VARS|PerlInterpreter *proto_perl \
|
|---|
| 239 | |CLONE_PARAMS* param
|
|---|
| 240 | Clone the state variables associated with running and compiling pads.
|
|---|
| 241 |
|
|---|
| 242 | =cut
|
|---|
| 243 | */
|
|---|
| 244 |
|
|---|
| 245 |
|
|---|
| 246 | #define PAD_DUP(dstpad, srcpad, param) \
|
|---|
| 247 | if ((srcpad) && !AvREAL(srcpad)) { \
|
|---|
| 248 | /* XXX padlists are real, but pretend to be not */ \
|
|---|
| 249 | AvREAL_on(srcpad); \
|
|---|
| 250 | (dstpad) = av_dup_inc((srcpad), param); \
|
|---|
| 251 | AvREAL_off(srcpad); \
|
|---|
| 252 | AvREAL_off(dstpad); \
|
|---|
| 253 | } \
|
|---|
| 254 | else \
|
|---|
| 255 | (dstpad) = av_dup_inc((srcpad), param);
|
|---|
| 256 |
|
|---|
| 257 | /* NB - we set PL_comppad to null unless it points at a value that
|
|---|
| 258 | * has already been dup'ed, ie it points to part of an active padlist.
|
|---|
| 259 | * Otherwise PL_comppad ends up being a leaked scalar in code like
|
|---|
| 260 | * the following:
|
|---|
| 261 | * threads->create(sub { threads->create(sub {...} ) } );
|
|---|
| 262 | * where the second thread dups the outer sub's comppad but not the
|
|---|
| 263 | * sub's CV or padlist. */
|
|---|
| 264 |
|
|---|
| 265 | #define PAD_CLONE_VARS(proto_perl, param) \
|
|---|
| 266 | PL_comppad = ptr_table_fetch(PL_ptr_table, proto_perl->Tcomppad); \
|
|---|
| 267 | PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : Null(SV**); \
|
|---|
| 268 | PL_comppad_name = av_dup(proto_perl->Icomppad_name, param); \
|
|---|
| 269 | PL_comppad_name_fill = proto_perl->Icomppad_name_fill; \
|
|---|
| 270 | PL_comppad_name_floor = proto_perl->Icomppad_name_floor; \
|
|---|
| 271 | PL_min_intro_pending = proto_perl->Imin_intro_pending; \
|
|---|
| 272 | PL_max_intro_pending = proto_perl->Imax_intro_pending; \
|
|---|
| 273 | PL_padix = proto_perl->Ipadix; \
|
|---|
| 274 | PL_padix_floor = proto_perl->Ipadix_floor; \
|
|---|
| 275 | PL_pad_reset_pending = proto_perl->Ipad_reset_pending; \
|
|---|
| 276 | PL_cop_seqmax = proto_perl->Icop_seqmax;
|
|---|
