1 /* pad.h 2 * 3 * Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008, 4 * 2009, 2010, 2011 by Larry Wall and others 5 * 6 * You may distribute under the terms of either the GNU General Public 7 * License or the Artistic License, as specified in the README file. 8 * 9 * This file defines the types and macros associated with the API for 10 * manipulating scratchpads, which are used by perl to store lexical 11 * variables, op targets and constants. 12 */ 13 14 /* 15 =head1 Pad Data Structures 16 */ 17 18 19 /* offsets within a pad */ 20 21 #if PTRSIZE == 4 22 typedef U32TYPE PADOFFSET; 23 #else 24 # if PTRSIZE == 8 25 typedef U64TYPE PADOFFSET; 26 # endif 27 #endif 28 #define NOT_IN_PAD ((PADOFFSET) -1) 29 30 31 struct padlist { 32 SSize_t xpadl_max; /* max index for which array has space */ 33 PAD ** xpadl_alloc; /* pointer to beginning of array of AVs */ 34 PADNAMELIST*xpadl_outid; /* Padnamelist of outer pad; used as ID */ 35 }; 36 37 38 /* a value that PL_cop_seqmax is guaranteed never to be, 39 * flagging that a lexical is being introduced, or has not yet left scope 40 */ 41 #define PERL_PADSEQ_INTRO U32_MAX 42 43 44 /* B.xs needs these for the benefit of B::Deparse */ 45 /* Low range end is exclusive (valid from the cop seq after this one) */ 46 /* High range end is inclusive (valid up to this cop seq) */ 47 48 #if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) 49 # define COP_SEQ_RANGE_LOW(sv) \ 50 (({ const SV *const _sv_cop_seq_range_low = (const SV *) (sv); \ 51 assert(SvTYPE(_sv_cop_seq_range_low) == SVt_NV \ 52 || SvTYPE(_sv_cop_seq_range_low) >= SVt_PVNV); \ 53 assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVAV); \ 54 assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVHV); \ 55 assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVCV); \ 56 assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVFM); \ 57 assert(!isGV_with_GP(_sv_cop_seq_range_low)); \ 58 ((XPVNV*) MUTABLE_PTR(SvANY(_sv_cop_seq_range_low)))->xnv_u.xpad_cop_seq.xlow; \ 59 })) 60 # define COP_SEQ_RANGE_HIGH(sv) \ 61 (({ const SV *const _sv_cop_seq_range_high = (const SV *) (sv); \ 62 assert(SvTYPE(_sv_cop_seq_range_high) == SVt_NV \ 63 || SvTYPE(_sv_cop_seq_range_high) >= SVt_PVNV); \ 64 assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVAV); \ 65 assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVHV); \ 66 assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVCV); \ 67 assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVFM); \ 68 assert(!isGV_with_GP(_sv_cop_seq_range_high)); \ 69 ((XPVNV*) MUTABLE_PTR(SvANY(_sv_cop_seq_range_high)))->xnv_u.xpad_cop_seq.xhigh; \ 70 })) 71 # define PARENT_PAD_INDEX(sv) \ 72 (({ const SV *const _sv_parent_pad_index = (const SV *) (sv); \ 73 assert(SvTYPE(_sv_parent_pad_index) == SVt_NV \ 74 || SvTYPE(_sv_parent_pad_index) >= SVt_PVNV); \ 75 assert(SvTYPE(_sv_parent_pad_index) != SVt_PVAV); \ 76 assert(SvTYPE(_sv_parent_pad_index) != SVt_PVHV); \ 77 assert(SvTYPE(_sv_parent_pad_index) != SVt_PVCV); \ 78 assert(SvTYPE(_sv_parent_pad_index) != SVt_PVFM); \ 79 assert(!isGV_with_GP(_sv_parent_pad_index)); \ 80 ((XPVNV*) MUTABLE_PTR(SvANY(_sv_parent_pad_index)))->xnv_u.xpad_cop_seq.xlow; \ 81 })) 82 # define PARENT_FAKELEX_FLAGS(sv) \ 83 (({ const SV *const _sv_parent_fakelex_flags = (const SV *) (sv); \ 84 assert(SvTYPE(_sv_parent_fakelex_flags) == SVt_NV \ 85 || SvTYPE(_sv_parent_fakelex_flags) >= SVt_PVNV); \ 86 assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVAV); \ 87 assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVHV); \ 88 assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVCV); \ 89 assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVFM); \ 90 assert(!isGV_with_GP(_sv_parent_fakelex_flags)); \ 91 ((XPVNV*) MUTABLE_PTR(SvANY(_sv_parent_fakelex_flags)))->xnv_u.xpad_cop_seq.xhigh; \ 92 })) 93 #else 94 # define COP_SEQ_RANGE_LOW(sv) \ 95 (0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xlow)) 96 # define COP_SEQ_RANGE_HIGH(sv) \ 97 (0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xhigh)) 98 99 100 # define PARENT_PAD_INDEX(sv) \ 101 (0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xlow)) 102 # define PARENT_FAKELEX_FLAGS(sv) \ 103 (0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xhigh)) 104 #endif 105 106 /* Flags set in the SvIVX field of FAKE namesvs */ 107 108 #define PAD_FAKELEX_ANON 1 /* the lex is declared in an ANON, or ... */ 109 #define PAD_FAKELEX_MULTI 2 /* the lex can be instantiated multiple times */ 110 111 /* flags for the pad_new() function */ 112 113 #define padnew_CLONE 1 /* this pad is for a cloned CV */ 114 #define padnew_SAVE 2 /* save old globals */ 115 #define padnew_SAVESUB 4 /* also save extra stuff for start of sub */ 116 117 /* values for the pad_tidy() function */ 118 119 typedef enum { 120 padtidy_SUB, /* tidy up a pad for a sub, */ 121 padtidy_SUBCLONE, /* a cloned sub, */ 122 padtidy_FORMAT /* or a format */ 123 } padtidy_type; 124 125 /* flags for pad_add_name_pvn. */ 126 127 #define padadd_OUR 0x01 /* our declaration. */ 128 #define padadd_STATE 0x02 /* state declaration. */ 129 #define padadd_NO_DUP_CHECK 0x04 /* skip warning on dups. */ 130 #define padadd_STALEOK 0x08 /* allow stale lexical in active 131 * sub, but only one level up */ 132 #define padadd_UTF8_NAME SVf_UTF8 /* name is UTF-8 encoded. */ 133 134 /* ASSERT_CURPAD_LEGAL and ASSERT_CURPAD_ACTIVE respectively determine 135 * whether PL_comppad and PL_curpad are consistent and whether they have 136 * active values */ 137 138 #ifndef PERL_MAD 139 # define pad_peg(label) 140 #endif 141 142 #ifdef DEBUGGING 143 # define ASSERT_CURPAD_LEGAL(label) \ 144 pad_peg(label); \ 145 if (PL_comppad ? (AvARRAY(PL_comppad) != PL_curpad) : (PL_curpad != 0)) \ 146 Perl_croak(aTHX_ "panic: illegal pad in %s: 0x%" UVxf "[0x%" UVxf "]",\ 147 label, PTR2UV(PL_comppad), PTR2UV(PL_curpad)); 148 149 150 # define ASSERT_CURPAD_ACTIVE(label) \ 151 pad_peg(label); \ 152 if (!PL_comppad || (AvARRAY(PL_comppad) != PL_curpad)) \ 153 Perl_croak(aTHX_ "panic: invalid pad in %s: 0x%" UVxf "[0x%" UVxf "]",\ 154 label, PTR2UV(PL_comppad), PTR2UV(PL_curpad)); 155 #else 156 # define ASSERT_CURPAD_LEGAL(label) 157 # define ASSERT_CURPAD_ACTIVE(label) 158 #endif 159 160 161 162 /* Note: the following three macros are actually defined in scope.h, but 163 * they are documented here for completeness, since they directly or 164 * indirectly affect pads. 165 166 =for apidoc m|void|SAVEPADSV |PADOFFSET po 167 Save a pad slot (used to restore after an iteration) 168 169 XXX DAPM it would make more sense to make the arg a PADOFFSET 170 =for apidoc m|void|SAVECLEARSV |SV **svp 171 Clear the pointed to pad value on scope exit. (i.e. the runtime action of 172 'my') 173 174 =for apidoc m|void|SAVECOMPPAD 175 save PL_comppad and PL_curpad 176 177 178 =for apidoc Amx|PAD **|PadlistARRAY|PADLIST padlist 179 The C array of a padlist, containing the pads. Only subscript it with 180 numbers >= 1, as the 0th entry is not guaranteed to remain usable. 181 182 =for apidoc Amx|SSize_t|PadlistMAX|PADLIST padlist 183 The index of the last allocated space in the padlist. Note that the last 184 pad may be in an earlier slot. Any entries following it will be NULL in 185 that case. 186 187 =for apidoc Amx|PADNAMELIST *|PadlistNAMES|PADLIST padlist 188 The names associated with pad entries. 189 190 =for apidoc Amx|PADNAME **|PadlistNAMESARRAY|PADLIST padlist 191 The C array of pad names. 192 193 =for apidoc Amx|SSize_t|PadlistNAMESMAX|PADLIST padlist 194 The index of the last pad name. 195 196 =for apidoc Amx|U32|PadlistREFCNT|PADLIST padlist 197 The reference count of the padlist. Currently this is always 1. 198 199 =for apidoc Amx|PADNAME **|PadnamelistARRAY|PADNAMELIST pnl 200 The C array of pad names. 201 202 =for apidoc Amx|SSize_t|PadnamelistMAX|PADNAMELIST pnl 203 The index of the last pad name. 204 205 =for apidoc Amx|SV **|PadARRAY|PAD pad 206 The C array of pad entries. 207 208 =for apidoc Amx|SSize_t|PadMAX|PAD pad 209 The index of the last pad entry. 210 211 =for apidoc Amx|char *|PadnamePV|PADNAME pn 212 The name stored in the pad name struct. This returns NULL for a target or 213 GV slot. 214 215 =for apidoc Amx|STRLEN|PadnameLEN|PADNAME pn 216 The length of the name. 217 218 =for apidoc Amx|bool|PadnameUTF8|PADNAME pn 219 Whether PadnamePV is in UTF8. 220 221 =for apidoc Amx|SV *|PadnameSV|PADNAME pn 222 Returns the pad name as an SV. This is currently just C<pn>. It will 223 begin returning a new mortal SV if pad names ever stop being SVs. 224 225 =for apidoc m|bool|PadnameIsOUR|PADNAME pn 226 Whether this is an "our" variable. 227 228 =for apidoc m|HV *|PadnameOURSTASH 229 The stash in which this "our" variable was declared. 230 231 =for apidoc m|bool|PadnameOUTER|PADNAME pn 232 Whether this entry belongs to an outer pad. 233 234 =for apidoc m|bool|PadnameIsSTATE|PADNAME pn 235 Whether this is a "state" variable. 236 237 =for apidoc m|HV *|PadnameTYPE|PADNAME pn 238 The stash associated with a typed lexical. This returns the %Foo:: hash 239 for C<my Foo $bar>. 240 241 242 =for apidoc m|SV *|PAD_SETSV |PADOFFSET po|SV* sv 243 Set the slot at offset C<po> in the current pad to C<sv> 244 245 =for apidoc m|SV *|PAD_SV |PADOFFSET po 246 Get the value at offset C<po> in the current pad 247 248 =for apidoc m|SV *|PAD_SVl |PADOFFSET po 249 Lightweight and lvalue version of C<PAD_SV>. 250 Get or set the value at offset C<po> in the current pad. 251 Unlike C<PAD_SV>, does not print diagnostics with -DX. 252 For internal use only. 253 254 =for apidoc m|SV *|PAD_BASE_SV |PADLIST padlist|PADOFFSET po 255 Get the value from slot C<po> in the base (DEPTH=1) pad of a padlist 256 257 =for apidoc m|void|PAD_SET_CUR |PADLIST padlist|I32 n 258 Set the current pad to be pad C<n> in the padlist, saving 259 the previous current pad. NB currently this macro expands to a string too 260 long for some compilers, so it's best to replace it with 261 262 SAVECOMPPAD(); 263 PAD_SET_CUR_NOSAVE(padlist,n); 264 265 266 =for apidoc m|void|PAD_SET_CUR_NOSAVE |PADLIST padlist|I32 n 267 like PAD_SET_CUR, but without the save 268 269 =for apidoc m|void|PAD_SAVE_SETNULLPAD 270 Save the current pad then set it to null. 271 272 =for apidoc m|void|PAD_SAVE_LOCAL|PAD *opad|PAD *npad 273 Save the current pad to the local variable opad, then make the 274 current pad equal to npad 275 276 =for apidoc m|void|PAD_RESTORE_LOCAL|PAD *opad 277 Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL() 278 279 =cut 280 */ 281 282 #define PadlistARRAY(pl) (pl)->xpadl_alloc 283 #define PadlistMAX(pl) (pl)->xpadl_max 284 #define PadlistNAMES(pl) (*PadlistARRAY(pl)) 285 #define PadlistNAMESARRAY(pl) PadnamelistARRAY(PadlistNAMES(pl)) 286 #define PadlistNAMESMAX(pl) PadnamelistMAX(PadlistNAMES(pl)) 287 #define PadlistREFCNT(pl) 1 /* reserved for future use */ 288 289 #define PadnamelistARRAY(pnl) AvARRAY(pnl) 290 #define PadnamelistMAX(pnl) AvFILLp(pnl) 291 #define PadnamelistMAXNAMED(pnl) \ 292 ((XPVAV*) SvANY(pnl))->xmg_u.xmg_hash_index 293 294 #define PadARRAY(pad) AvARRAY(pad) 295 #define PadMAX(pad) AvFILLp(pad) 296 297 #define PadnamePV(pn) (SvPOKp(pn) ? SvPVX(pn) : NULL) 298 #define PadnameLEN(pn) ((pn) == &PL_sv_undef ? 0 : SvCUR(pn)) 299 #define PadnameUTF8(pn) !!SvUTF8(pn) 300 #define PadnameSV(pn) pn 301 #define PadnameIsOUR(pn) !!SvPAD_OUR(pn) 302 #define PadnameOURSTASH(pn) SvOURSTASH(pn) 303 #define PadnameOUTER(pn) !!SvFAKE(pn) 304 #define PadnameIsSTATE(pn) !!SvPAD_STATE(pn) 305 #define PadnameTYPE(pn) (SvPAD_TYPED(pn) ? SvSTASH(pn) : NULL) 306 307 308 #ifdef DEBUGGING 309 # define PAD_SV(po) pad_sv(po) 310 # define PAD_SETSV(po,sv) pad_setsv(po,sv) 311 #else 312 # define PAD_SV(po) (PL_curpad[po]) 313 # define PAD_SETSV(po,sv) PL_curpad[po] = (sv) 314 #endif 315 316 #define PAD_SVl(po) (PL_curpad[po]) 317 318 #define PAD_BASE_SV(padlist, po) \ 319 (PadlistARRAY(padlist)[1]) \ 320 ? AvARRAY(MUTABLE_AV((PadlistARRAY(padlist)[1])))[po] \ 321 : NULL; 322 323 324 #define PAD_SET_CUR_NOSAVE(padlist,nth) \ 325 PL_comppad = (PAD*) (PadlistARRAY(padlist)[nth]); \ 326 PL_curpad = AvARRAY(PL_comppad); \ 327 DEBUG_Xv(PerlIO_printf(Perl_debug_log, \ 328 "Pad 0x%" UVxf "[0x%" UVxf "] set_cur depth=%d\n", \ 329 PTR2UV(PL_comppad), PTR2UV(PL_curpad), (int)(nth))); 330 331 332 #define PAD_SET_CUR(padlist,nth) \ 333 SAVECOMPPAD(); \ 334 PAD_SET_CUR_NOSAVE(padlist,nth); 335 336 337 #define PAD_SAVE_SETNULLPAD() SAVECOMPPAD(); \ 338 PL_comppad = NULL; PL_curpad = NULL; \ 339 DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad set_null\n")); 340 341 #define PAD_SAVE_LOCAL(opad,npad) \ 342 opad = PL_comppad; \ 343 PL_comppad = (npad); \ 344 PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \ 345 DEBUG_Xv(PerlIO_printf(Perl_debug_log, \ 346 "Pad 0x%" UVxf "[0x%" UVxf "] save_local\n", \ 347 PTR2UV(PL_comppad), PTR2UV(PL_curpad))); 348 349 #define PAD_RESTORE_LOCAL(opad) \ 350 assert(!opad || !SvIS_FREED(opad)); \ 351 PL_comppad = opad; \ 352 PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \ 353 DEBUG_Xv(PerlIO_printf(Perl_debug_log, \ 354 "Pad 0x%" UVxf "[0x%" UVxf "] restore_local\n", \ 355 PTR2UV(PL_comppad), PTR2UV(PL_curpad))); 356 357 358 /* 359 =for apidoc m|void|CX_CURPAD_SAVE|struct context 360 Save the current pad in the given context block structure. 361 362 =for apidoc m|SV *|CX_CURPAD_SV|struct context|PADOFFSET po 363 Access the SV at offset po in the saved current pad in the given 364 context block structure (can be used as an lvalue). 365 366 =cut 367 */ 368 369 #define CX_CURPAD_SAVE(block) (block).oldcomppad = PL_comppad 370 #define CX_CURPAD_SV(block,po) (AvARRAY(MUTABLE_AV(((block).oldcomppad)))[po]) 371 372 373 /* 374 =for apidoc m|U32|PAD_COMPNAME_FLAGS|PADOFFSET po 375 Return the flags for the current compiling pad name 376 at offset C<po>. Assumes a valid slot entry. 377 378 =for apidoc m|char *|PAD_COMPNAME_PV|PADOFFSET po 379 Return the name of the current compiling pad name 380 at offset C<po>. Assumes a valid slot entry. 381 382 =for apidoc m|HV *|PAD_COMPNAME_TYPE|PADOFFSET po 383 Return the type (stash) of the current compiling pad name at offset 384 C<po>. Must be a valid name. Returns null if not typed. 385 386 =for apidoc m|HV *|PAD_COMPNAME_OURSTASH|PADOFFSET po 387 Return the stash associated with an C<our> variable. 388 Assumes the slot entry is a valid C<our> lexical. 389 390 =for apidoc m|STRLEN|PAD_COMPNAME_GEN|PADOFFSET po 391 The generation number of the name at offset C<po> in the current 392 compiling pad (lvalue). Note that C<SvUVX> is hijacked for this purpose. 393 394 =for apidoc m|STRLEN|PAD_COMPNAME_GEN_set|PADOFFSET po|int gen 395 Sets the generation number of the name at offset C<po> in the current 396 ling pad (lvalue) to C<gen>. Note that C<SvUV_set> is hijacked for this purpose. 397 398 =cut 399 400 */ 401 402 #define PAD_COMPNAME(po) PAD_COMPNAME_SV(po) 403 #define PAD_COMPNAME_SV(po) (*av_fetch(PL_comppad_name, (po), FALSE)) 404 #define PAD_COMPNAME_FLAGS(po) SvFLAGS(PAD_COMPNAME_SV(po)) 405 #define PAD_COMPNAME_FLAGS_isOUR(po) SvPAD_OUR(PAD_COMPNAME_SV(po)) 406 #define PAD_COMPNAME_PV(po) SvPV_nolen(PAD_COMPNAME_SV(po)) 407 408 #define PAD_COMPNAME_TYPE(po) pad_compname_type(po) 409 410 #define PAD_COMPNAME_OURSTASH(po) \ 411 (SvOURSTASH(PAD_COMPNAME_SV(po))) 412 413 #define PAD_COMPNAME_GEN(po) ((STRLEN)SvUVX(AvARRAY(PL_comppad_name)[po])) 414 415 #define PAD_COMPNAME_GEN_set(po, gen) SvUV_set(AvARRAY(PL_comppad_name)[po], (UV)(gen)) 416 417 418 /* 419 =for apidoc m|void|PAD_CLONE_VARS|PerlInterpreter *proto_perl|CLONE_PARAMS* param 420 Clone the state variables associated with running and compiling pads. 421 422 =cut 423 */ 424 425 /* NB - we set PL_comppad to null unless it points at a value that 426 * has already been dup'ed, ie it points to part of an active padlist. 427 * Otherwise PL_comppad ends up being a leaked scalar in code like 428 * the following: 429 * threads->create(sub { threads->create(sub {...} ) } ); 430 * where the second thread dups the outer sub's comppad but not the 431 * sub's CV or padlist. */ 432 433 #define PAD_CLONE_VARS(proto_perl, param) \ 434 PL_comppad = av_dup(proto_perl->Icomppad, param); \ 435 PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \ 436 PL_comppad_name = av_dup(proto_perl->Icomppad_name, param); \ 437 PL_comppad_name_fill = proto_perl->Icomppad_name_fill; \ 438 PL_comppad_name_floor = proto_perl->Icomppad_name_floor; \ 439 PL_min_intro_pending = proto_perl->Imin_intro_pending; \ 440 PL_max_intro_pending = proto_perl->Imax_intro_pending; \ 441 PL_padix = proto_perl->Ipadix; \ 442 PL_padix_floor = proto_perl->Ipadix_floor; \ 443 PL_pad_reset_pending = proto_perl->Ipad_reset_pending; \ 444 PL_cop_seqmax = proto_perl->Icop_seqmax; 445 446 /* 447 =for apidoc Am|PADOFFSET|pad_add_name_pvs|const char *name|U32 flags|HV *typestash|HV *ourstash 448 449 Exactly like L</pad_add_name_pvn>, but takes a literal string instead 450 of a string/length pair. 451 452 =cut 453 */ 454 455 #define pad_add_name_pvs(name,flags,typestash,ourstash) \ 456 Perl_pad_add_name_pvn(aTHX_ STR_WITH_LEN(name), flags, typestash, ourstash) 457 458 /* 459 =for apidoc Am|PADOFFSET|pad_findmy_pvs|const char *name|U32 flags 460 461 Exactly like L</pad_findmy_pvn>, but takes a literal string instead 462 of a string/length pair. 463 464 =cut 465 */ 466 467 #define pad_findmy_pvs(name,flags) \ 468 Perl_pad_findmy_pvn(aTHX_ STR_WITH_LEN(name), flags) 469 470 /* 471 * Local variables: 472 * c-indentation-style: bsd 473 * c-basic-offset: 4 474 * indent-tabs-mode: nil 475 * End: 476 * 477 * ex: set ts=8 sts=4 sw=4 et: 478 */ 479