Skip to content
This repository

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
branch: smoke-me/remov…
Fetching contributors…

Cannot retrieve contributors at this time

file 376 lines (286 sloc) 12.877 kb
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376
/* pad.h
*
* Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008 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.
*
* This file defines the types and macros associated with the API for
* manipulating scratchpads, which are used by perl to store lexical
* variables, op targets and constants.
*/




/* a padlist is currently just an AV; but that might change,
* so hide the type. Ditto a pad. */

typedef AV PADLIST;
typedef AV PAD;


/* offsets within a pad */

#if PTRSIZE == 4
typedef U32TYPE PADOFFSET;
#else
# if PTRSIZE == 8
typedef U64TYPE PADOFFSET;
# endif
#endif
#define NOT_IN_PAD ((PADOFFSET) -1)

/* a value that PL_cop_seqmax is guaranteed never to be,
* flagging that a lexical is being introduced, or has not yet left scope
*/
#define PERL_PADSEQ_INTRO U32_MAX


/* B.xs needs these for the benefit of B::Deparse */
/* Low range end is exclusive (valid from the cop seq after this one) */
/* High range end is inclusive (valid up to this cop seq) */

#if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
# define COP_SEQ_RANGE_LOW(sv) \
(({ const SV *const _sv_cop_seq_range_low = (const SV *) (sv); \
assert(SvTYPE(_sv_cop_seq_range_low) == SVt_NV \
|| SvTYPE(_sv_cop_seq_range_low) >= SVt_PVNV); \
assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVAV); \
assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVHV); \
assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVCV); \
assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVFM); \
assert(!isGV_with_GP(_sv_cop_seq_range_low)); \
((XPVNV*) MUTABLE_PTR(SvANY(_sv_cop_seq_range_low)))->xnv_u.xpad_cop_seq.xlow; \
}))
# define COP_SEQ_RANGE_HIGH(sv) \
(({ const SV *const _sv_cop_seq_range_high = (const SV *) (sv); \
assert(SvTYPE(_sv_cop_seq_range_high) == SVt_NV \
|| SvTYPE(_sv_cop_seq_range_high) >= SVt_PVNV); \
assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVAV); \
assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVHV); \
assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVCV); \
assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVFM); \
assert(!isGV_with_GP(_sv_cop_seq_range_high)); \
((XPVNV*) MUTABLE_PTR(SvANY(_sv_cop_seq_range_high)))->xnv_u.xpad_cop_seq.xhigh; \
}))
# define PARENT_PAD_INDEX(sv) \
(({ const SV *const _sv_parent_pad_index = (const SV *) (sv); \
assert(SvTYPE(_sv_parent_pad_index) == SVt_NV \
|| SvTYPE(_sv_parent_pad_index) >= SVt_PVNV); \
assert(SvTYPE(_sv_parent_pad_index) != SVt_PVAV); \
assert(SvTYPE(_sv_parent_pad_index) != SVt_PVHV); \
assert(SvTYPE(_sv_parent_pad_index) != SVt_PVCV); \
assert(SvTYPE(_sv_parent_pad_index) != SVt_PVFM); \
assert(!isGV_with_GP(_sv_parent_pad_index)); \
((XPVNV*) MUTABLE_PTR(SvANY(_sv_parent_pad_index)))->xnv_u.xpad_cop_seq.xlow; \
}))
# define PARENT_FAKELEX_FLAGS(sv) \
(({ const SV *const _sv_parent_fakelex_flags = (const SV *) (sv); \
assert(SvTYPE(_sv_parent_fakelex_flags) == SVt_NV \
|| SvTYPE(_sv_parent_fakelex_flags) >= SVt_PVNV); \
assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVAV); \
assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVHV); \
assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVCV); \
assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVFM); \
assert(!isGV_with_GP(_sv_parent_fakelex_flags)); \
((XPVNV*) MUTABLE_PTR(SvANY(_sv_parent_fakelex_flags)))->xnv_u.xpad_cop_seq.xhigh; \
}))
#else
# define COP_SEQ_RANGE_LOW(sv) \
(0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xlow))
# define COP_SEQ_RANGE_HIGH(sv) \
(0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xhigh))


# define PARENT_PAD_INDEX(sv) \
(0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xlow))
# define PARENT_FAKELEX_FLAGS(sv) \
(0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xhigh))
#endif

/* Flags set in the SvIVX field of FAKE namesvs */

#define PAD_FAKELEX_ANON 1 /* the lex is declared in an ANON, or ... */
#define PAD_FAKELEX_MULTI 2 /* the lex can be instantiated multiple times */

/* flags for the pad_new() function */

#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 */

typedef enum {
padtidy_SUB, /* tidy up a pad for a sub, */
padtidy_SUBCLONE, /* a cloned sub, */
padtidy_FORMAT /* or a format */
} padtidy_type;

#ifdef PERL_CORE

/* flags for pad_add_name. SVf_UTF8 will also be valid in the future. */

# define padadd_OUR 0x01 /* our declaration. */
# define padadd_STATE 0x02 /* state declaration. */
# define padadd_NO_DUP_CHECK 0x04 /* skip warning on dups. */

#endif

/* 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

#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. (i.e. the runtime action of 'my')

=for apidoc m|void|SAVECOMPPAD
save PL_comppad and PL_curpad





=for apidoc m|SV *|PAD_SETSV |PADOFFSET po|SV* sv
Set the slot at offset C<po> in the current pad to C<sv>

=for apidoc m|void|PAD_SV |PADOFFSET po
Get the value at offset C<po> in the current pad

=for apidoc m|SV *|PAD_SVl |PADOFFSET po
Lightweight and lvalue version of C<PAD_SV>.
Get or set the value at offset C<po> in the current pad.
Unlike C<PAD_SV>, does not print diagnostics with -DX.
For internal use only.

=for apidoc m|SV *|PAD_BASE_SV |PADLIST padlist|PADOFFSET po
Get the value from slot C<po> 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<n> in the padlist, saving
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_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
*/

#ifdef DEBUGGING
# define PAD_SV(po) pad_sv(po)
# define PAD_SETSV(po,sv) pad_setsv(po,sv)
#else
# define PAD_SV(po) (PL_curpad[po])
# define PAD_SETSV(po,sv) PL_curpad[po] = (sv)
#endif

#define PAD_SVl(po) (PL_curpad[po])

#define PAD_BASE_SV(padlist, po) \
(AvARRAY(padlist)[1]) \
? AvARRAY(MUTABLE_AV((AvARRAY(padlist)[1])))[po] : NULL;


#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() SAVECOMPPAD(); \
PL_comppad = NULL; PL_curpad = NULL; \
DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad set_null\n"));

#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) \
assert(!opad || !SvIS_FREED(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|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).oldcomppad = PL_comppad
#define CX_CURPAD_SV(block,po) (AvARRAY(MUTABLE_AV(((block).oldcomppad)))[po])


/*
=for apidoc m|U32|PAD_COMPNAME_FLAGS|PADOFFSET po
Return the flags for the current compiling pad name
at offset C<po>. Assumes a valid slot entry.

=for apidoc m|char *|PAD_COMPNAME_PV|PADOFFSET po
Return the name of the current compiling pad name
at offset C<po>. Assumes a valid slot entry.

=for apidoc m|HV *|PAD_COMPNAME_TYPE|PADOFFSET po
Return the type (stash) of the current compiling pad name at offset
C<po>. Must be a valid name. Returns null if not typed.

=for apidoc m|HV *|PAD_COMPNAME_OURSTASH|PADOFFSET po
Return the stash associated with an C<our> variable.
Assumes the slot entry is a valid C<our> lexical.

=for apidoc m|STRLEN|PAD_COMPNAME_GEN|PADOFFSET po
The generation number of the name at offset C<po> in the current
compiling pad (lvalue). Note that C<SvUVX> 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<po> in the current
ling pad (lvalue) to C<gen>. Note that C<SvUV_set> is hijacked for this purpose.

=cut

*/

#define PAD_COMPNAME_SV(po) (*av_fetch(PL_comppad_name, (po), FALSE))
#define PAD_COMPNAME_FLAGS(po) SvFLAGS(PAD_COMPNAME_SV(po))
#define PAD_COMPNAME_FLAGS_isOUR(po) SvPAD_OUR(PAD_COMPNAME_SV(po))
#define PAD_COMPNAME_PV(po) SvPV_nolen(PAD_COMPNAME_SV(po))

#define PAD_COMPNAME_TYPE(po) pad_compname_type(po)

#define PAD_COMPNAME_OURSTASH(po) \
(SvOURSTASH(PAD_COMPNAME_SV(po)))

#define PAD_COMPNAME_GEN(po) ((STRLEN)SvUVX(AvARRAY(PL_comppad_name)[po]))

#define PAD_COMPNAME_GEN_set(po, gen) SvUV_set(AvARRAY(PL_comppad_name)[po], (UV)(gen))


/*
=for apidoc m|void|PAD_DUP|PADLIST dstpad|PADLIST srcpad|CLONE_PARAMS* param
Clone a padlist.

=for apidoc m|void|PAD_CLONE_VARS|PerlInterpreter *proto_perl|CLONE_PARAMS* param
Clone the state variables associated with running and compiling pads.

=cut
*/


#define PAD_DUP(dstpad, srcpad, param) \
if ((srcpad) && !AvREAL(srcpad)) { \
/* XXX padlists are real, but pretend to be not */ \
AvREAL_on(srcpad); \
(dstpad) = av_dup_inc((srcpad), param); \
AvREAL_off(srcpad); \
AvREAL_off(dstpad); \
} \
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 = MUTABLE_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_min_intro_pending = proto_perl->Imin_intro_pending; \
PL_max_intro_pending = proto_perl->Imax_intro_pending; \
PL_padix = proto_perl->Ipadix; \
PL_padix_floor = proto_perl->Ipadix_floor; \
PL_pad_reset_pending = proto_perl->Ipad_reset_pending; \
PL_cop_seqmax = proto_perl->Icop_seqmax;

/*
* Local variables:
* c-indentation-style: bsd
* c-basic-offset: 4
* indent-tabs-mode: t
* End:
*
* ex: set ts=8 sts=4 sw=4 noet:
*/
Something went wrong with that request. Please try again.