pad.h

   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 /* B.xs expects the first members of these two structs to line up
  31    (xpadl_max with xpadnl_fill).
  32  */
  33
  34 struct padlist {
  35     SSize_t     xpadl_max;      /* max index for which array has space */
  36     union {
  37         PAD **  xpadlarr_alloc; /* Pointer to beginning of array of AVs.
  38                                    index 0 is a padnamelist *          */
  39         struct {
  40             PADNAMELIST * padnl;
  41             PAD * pad_1;        /* this slice of PAD * array always alloced */
  42             PAD * pad_2;        /* maybe unalloced */
  43         } * xpadlarr_dbg;       /* for use with a C debugger only */
  44     } xpadl_arr;
  45     U32         xpadl_id;       /* Semi-unique ID, shared between clones */
  46     U32         xpadl_outid;    /* ID of outer pad */
  47 };
  48
  49 struct padnamelist {
  50     SSize_t     xpadnl_fill;    /* max index in use */
  51     PADNAME **  xpadnl_alloc;   /* pointer to beginning of array */
  52     SSize_t     xpadnl_max;     /* max index for which array has space */
  53     PADOFFSET   xpadnl_max_named; /* highest index with len > 0 */
  54     U32         xpadnl_refcnt;
  55 };
  56
  57 /* PERL_PADNAME_MINIMAL uses less memory, but on some platforms
  58    PERL_PADNAME_ALIGNED may be faster, so platform-specific hints can
  59    define one or the other.  */
  60 #if defined(PERL_PADNAME_MINIMAL) && defined (PERL_PADNAME_ALIGNED)
  61 #  error PERL_PADNAME_MINIMAL and PERL_PADNAME_ALIGNED are exclusive
  62 #endif
  63
  64 #if !defined(PERL_PADNAME_MINIMAL) && !defined(PERL_PADNAME_ALIGNED)
  65 #  define PERL_PADNAME_MINIMAL
  66 #endif
  67
  68 #define _PADNAME_BASE \
  69     char *      xpadn_pv;               \
  70     HV *        xpadn_ourstash;         \
  71     union {                             \
  72         HV *    xpadn_typestash;        \
  73         CV *    xpadn_protocv;          \
  74     } xpadn_type_u;                     \
  75     U32         xpadn_low;              \
  76     U32         xpadn_high;             \
  77     U32         xpadn_refcnt;           \
  78     int         xpadn_gen;              \
  79     U8          xpadn_len;              \
  80     U8          xpadn_flags
  81
  82 struct padname {
  83     _PADNAME_BASE;
  84 };
  85
  86 struct padname_with_str {
  87 #ifdef PERL_PADNAME_MINIMAL
  88     _PADNAME_BASE;
  89 #else
  90     struct padname      xpadn_padname;
  91 #endif
  92     char                xpadn_str[1];
  93 };
  94
  95 #undef _PADNAME_BASE
  96
  97 #define PADNAME_FROM_PV(s) \
  98     ((PADNAME *)((s) - STRUCT_OFFSET(struct padname_with_str, xpadn_str)))
  99
 100
 101 /* a value that PL_cop_seqmax is guaranteed never to be,
 102  * flagging that a lexical is being introduced, or has not yet left scope
 103  */
 104 #define PERL_PADSEQ_INTRO  U32_MAX
 105 #define COP_SEQMAX_INC \
 106         (PL_cop_seqmax++, \
 107          (void)(PL_cop_seqmax == PERL_PADSEQ_INTRO && PL_cop_seqmax++))
 108
 109
 110 /* B.xs needs these for the benefit of B::Deparse */
 111 /* Low range end is exclusive (valid from the cop seq after this one) */
 112 /* High range end is inclusive (valid up to this cop seq) */
 113
 114 #define COP_SEQ_RANGE_LOW(pn)           (pn)->xpadn_low
 115 #define COP_SEQ_RANGE_HIGH(pn)          (pn)->xpadn_high
 116 #define PARENT_PAD_INDEX(pn)            (pn)->xpadn_low
 117 #define PARENT_FAKELEX_FLAGS(pn)        (pn)->xpadn_high
 118
 119 /* Flags set in the SvIVX field of FAKE namesvs */
 120
 121 #define PAD_FAKELEX_ANON   1 /* the lex is declared in an ANON, or ... */
 122 #define PAD_FAKELEX_MULTI  2 /* the lex can be instantiated multiple times */
 123
 124 /* flags for the pad_new() function */
 125
 126 #define padnew_CLONE    1       /* this pad is for a cloned CV */
 127 #define padnew_SAVE     2       /* save old globals */
 128 #define padnew_SAVESUB  4       /* also save extra stuff for start of sub */
 129
 130 /* values for the pad_tidy() function */
 131
 132 typedef enum {
 133         padtidy_SUB,            /* tidy up a pad for a sub, */
 134         padtidy_SUBCLONE,       /* a cloned sub, */
 135         padtidy_FORMAT          /* or a format */
 136 } padtidy_type;
 137
 138 /* flags for pad_add_name_pvn. */
 139
 140 #define padadd_OUR              0x01       /* our declaration. */
 141 #define padadd_STATE            0x02       /* state declaration. */
 142 #define padadd_NO_DUP_CHECK     0x04       /* skip warning on dups. */
 143 #define padadd_STALEOK          0x08       /* allow stale lexical in active
 144                                             * sub, but only one level up */
 145
 146 /* ASSERT_CURPAD_LEGAL and ASSERT_CURPAD_ACTIVE respectively determine
 147  * whether PL_comppad and PL_curpad are consistent and whether they have
 148  * active values */
 149
 150 #  define pad_peg(label)
 151
 152 #ifdef DEBUGGING
 153 #  define ASSERT_CURPAD_LEGAL(label) \
 154     pad_peg(label); \
 155     if (PL_comppad ? (AvARRAY(PL_comppad) != PL_curpad) : (PL_curpad != 0))  \
 156         Perl_croak(aTHX_ "panic: illegal pad in %s: 0x%" UVxf "[0x%" UVxf "]",\
 157             label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
 158
 159
 160 #  define ASSERT_CURPAD_ACTIVE(label) \
 161     pad_peg(label); \
 162     if (!PL_comppad || (AvARRAY(PL_comppad) != PL_curpad))                \
 163         Perl_croak(aTHX_ "panic: invalid pad in %s: 0x%" UVxf "[0x%" UVxf "]",\
 164             label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
 165 #else
 166 #  define ASSERT_CURPAD_LEGAL(label)
 167 #  define ASSERT_CURPAD_ACTIVE(label)
 168 #endif
 169
 170
 171
 172 /* Note: the following three macros are actually defined in scope.h, but
 173  * they are documented here for completeness, since they directly or
 174  * indirectly affect pads.
 175
 176 =for apidoc m|void|SAVEPADSV    |PADOFFSET po
 177 Save a pad slot (used to restore after an iteration)
 178
 179 XXX DAPM it would make more sense to make the arg a PADOFFSET
 180 =for apidoc m|void|SAVECLEARSV  |SV **svp
 181 Clear the pointed to pad value on scope exit.  (i.e. the runtime action of
 182 C<my>)
 183
 184 =for apidoc m|void|SAVECOMPPAD
 185 save C<PL_comppad> and C<PL_curpad>
 186
 187
 188 =for apidoc Amx|PAD **|PadlistARRAY|PADLIST padlist
 189 The C array of a padlist, containing the pads.  Only subscript it with
 190 numbers >= 1, as the 0th entry is not guaranteed to remain usable.
 191
 192 =for apidoc Amx|SSize_t|PadlistMAX|PADLIST padlist
 193 The index of the last allocated space in the padlist.  Note that the last
 194 pad may be in an earlier slot.  Any entries following it will be C<NULL> in
 195 that case.
 196
 197 =for apidoc Amx|PADNAMELIST *|PadlistNAMES|PADLIST padlist
 198 The names associated with pad entries.
 199
 200 =for apidoc Amx|PADNAME **|PadlistNAMESARRAY|PADLIST padlist
 201 The C array of pad names.
 202
 203 =for apidoc Amx|SSize_t|PadlistNAMESMAX|PADLIST padlist
 204 The index of the last pad name.
 205
 206 =for apidoc Amx|U32|PadlistREFCNT|PADLIST padlist
 207 The reference count of the padlist.  Currently this is always 1.
 208
 209 =for apidoc Amx|PADNAME **|PadnamelistARRAY|PADNAMELIST pnl
 210 The C array of pad names.
 211
 212 =for apidoc Amx|SSize_t|PadnamelistMAX|PADNAMELIST pnl
 213 The index of the last pad name.
 214
 215 =for apidoc Amx|SSize_t|PadnamelistREFCNT|PADNAMELIST pnl
 216 The reference count of the pad name list.
 217
 218 =for apidoc Amx|void|PadnamelistREFCNT_dec|PADNAMELIST pnl
 219 Lowers the reference count of the pad name list.
 220
 221 =for apidoc Amx|SV **|PadARRAY|PAD pad
 222 The C array of pad entries.
 223
 224 =for apidoc Amx|SSize_t|PadMAX|PAD pad
 225 The index of the last pad entry.
 226
 227 =for apidoc Amx|char *|PadnamePV|PADNAME pn
 228 The name stored in the pad name struct.  This returns C<NULL> for a target
 229 slot.
 230
 231 =for apidoc Amx|STRLEN|PadnameLEN|PADNAME pn
 232 The length of the name.
 233
 234 =for apidoc Amx|bool|PadnameUTF8|PADNAME pn
 235 Whether PadnamePV is in UTF-8.  Currently, this is always true.
 236
 237 =for apidoc Amx|SV *|PadnameSV|PADNAME pn
 238 Returns the pad name as a mortal SV.
 239
 240 =for apidoc m|bool|PadnameIsOUR|PADNAME pn
 241 Whether this is an "our" variable.
 242
 243 =for apidoc m|HV *|PadnameOURSTASH
 244 The stash in which this "our" variable was declared.
 245
 246 =for apidoc m|bool|PadnameOUTER|PADNAME pn
 247 Whether this entry belongs to an outer pad.  Entries for which this is true
 248 are often referred to as 'fake'.
 249
 250 =for apidoc m|bool|PadnameIsSTATE|PADNAME pn
 251 Whether this is a "state" variable.
 252
 253 =for apidoc m|HV *|PadnameTYPE|PADNAME pn
 254 The stash associated with a typed lexical.  This returns the C<%Foo::> hash
 255 for C<my Foo $bar>.
 256
 257 =for apidoc Amx|SSize_t|PadnameREFCNT|PADNAME pn
 258 The reference count of the pad name.
 259
 260 =for apidoc Amx|void|PadnameREFCNT_dec|PADNAME pn
 261 Lowers the reference count of the pad name.
 262
 263
 264 =for apidoc m|SV *|PAD_SETSV    |PADOFFSET po|SV* sv
 265 Set the slot at offset C<po> in the current pad to C<sv>
 266
 267 =for apidoc m|SV *|PAD_SV       |PADOFFSET po
 268 Get the value at offset C<po> in the current pad
 269
 270 =for apidoc m|SV *|PAD_SVl      |PADOFFSET po
 271 Lightweight and lvalue version of C<PAD_SV>.
 272 Get or set the value at offset C<po> in the current pad.
 273 Unlike C<PAD_SV>, does not print diagnostics with -DX.
 274 For internal use only.
 275
 276 =for apidoc m|SV *|PAD_BASE_SV  |PADLIST padlist|PADOFFSET po
 277 Get the value from slot C<po> in the base (DEPTH=1) pad of a padlist
 278
 279 =for apidoc m|void|PAD_SET_CUR  |PADLIST padlist|I32 n
 280 Set the current pad to be pad C<n> in the padlist, saving
 281 the previous current pad.  NB currently this macro expands to a string too
 282 long for some compilers, so it's best to replace it with
 283
 284     SAVECOMPPAD();
 285     PAD_SET_CUR_NOSAVE(padlist,n);
 286
 287
 288 =for apidoc m|void|PAD_SET_CUR_NOSAVE   |PADLIST padlist|I32 n
 289 like PAD_SET_CUR, but without the save
 290
 291 =for apidoc m|void|PAD_SAVE_SETNULLPAD
 292 Save the current pad then set it to null.
 293
 294 =for apidoc m|void|PAD_SAVE_LOCAL|PAD *opad|PAD *npad
 295 Save the current pad to the local variable C<opad>, then make the
 296 current pad equal to C<npad>
 297
 298 =for apidoc m|void|PAD_RESTORE_LOCAL|PAD *opad
 299 Restore the old pad saved into the local variable C<opad> by C<PAD_SAVE_LOCAL()>
 300
 301 =cut
 302 */
 303
 304 #define PadlistARRAY(pl)        (pl)->xpadl_arr.xpadlarr_alloc
 305 #define PadlistMAX(pl)          (pl)->xpadl_max
 306 #define PadlistNAMES(pl)        *((PADNAMELIST **)PadlistARRAY(pl))
 307 #define PadlistNAMESARRAY(pl)   PadnamelistARRAY(PadlistNAMES(pl))
 308 #define PadlistNAMESMAX(pl)     PadnamelistMAX(PadlistNAMES(pl))
 309 #define PadlistREFCNT(pl)       1       /* reserved for future use */
 310
 311 #define PadnamelistARRAY(pnl)           (pnl)->xpadnl_alloc
 312 #define PadnamelistMAX(pnl)             (pnl)->xpadnl_fill
 313 #define PadnamelistMAXNAMED(pnl)        (pnl)->xpadnl_max_named
 314 #define PadnamelistREFCNT(pnl)          (pnl)->xpadnl_refcnt
 315 #define PadnamelistREFCNT_dec(pnl)      Perl_padnamelist_free(aTHX_ pnl)
 316
 317 #define PadARRAY(pad)           AvARRAY(pad)
 318 #define PadMAX(pad)             AvFILLp(pad)
 319
 320 #define PadnamePV(pn)           (pn)->xpadn_pv
 321 #define PadnameLEN(pn)          (pn)->xpadn_len
 322 #define PadnameUTF8(pn)         1
 323 #define PadnameSV(pn) \
 324         newSVpvn_flags(PadnamePV(pn), PadnameLEN(pn), SVs_TEMP|SVf_UTF8)
 325 #define PadnameFLAGS(pn)        (pn)->xpadn_flags
 326 #define PadnameIsOUR(pn)        (!!(pn)->xpadn_ourstash)
 327 #define PadnameOURSTASH(pn)     (pn)->xpadn_ourstash
 328 #define PadnameTYPE(pn)         (pn)->xpadn_type_u.xpadn_typestash
 329 #define PadnamePROTOCV(pn)      (pn)->xpadn_type_u.xpadn_protocv
 330 #define PadnameREFCNT(pn)       (pn)->xpadn_refcnt
 331 #define PadnameREFCNT_dec(pn)   Perl_padname_free(aTHX_ pn)
 332 #define PadnameOURSTASH_set(pn,s) (PadnameOURSTASH(pn) = (s))
 333 #define PadnameTYPE_set(pn,s)     (PadnameTYPE(pn) = (s))
 334 #define PadnameOUTER(pn)        (PadnameFLAGS(pn) & PADNAMEt_OUTER)
 335 #define PadnameIsSTATE(pn)      (PadnameFLAGS(pn) & PADNAMEt_STATE)
 336 #define PadnameLVALUE(pn)       (PadnameFLAGS(pn) & PADNAMEt_LVALUE)
 337
 338 #define PadnameLVALUE_on(pn)    (PadnameFLAGS(pn) |= PADNAMEt_LVALUE)
 339 #define PadnameIsSTATE_on(pn)   (PadnameFLAGS(pn) |= PADNAMEt_STATE)
 340
 341 #define PADNAMEt_OUTER  1       /* outer lexical var */
 342 #define PADNAMEt_STATE  2       /* state var */
 343 #define PADNAMEt_LVALUE 4       /* used as lvalue */
 344 #define PADNAMEt_TYPED  8       /* for B; unused by core */
 345 #define PADNAMEt_OUR    16      /* for B; unused by core */
 346
 347 /* backward compatibility */
 348 #define SvPAD_STATE             PadnameIsSTATE
 349 #define SvPAD_TYPED(pn)         (!!PadnameTYPE(pn))
 350 #define SvPAD_OUR(pn)           (!!PadnameOURSTASH(pn))
 351 #define SvPAD_STATE_on          PadnameIsSTATE_on
 352 #define SvPAD_TYPED_on(pn)      (PadnameFLAGS(pn) |= PADNAMEt_TYPED)
 353 #define SvPAD_OUR_on(pn)        (PadnameFLAGS(pn) |= PADNAMEt_OUR)
 354 #define SvOURSTASH              PadnameOURSTASH
 355 #define SvOURSTASH_set          PadnameOURSTASH_set
 356 #define SVpad_STATE             PADNAMEt_STATE
 357 #define SVpad_TYPED             PADNAMEt_TYPED
 358 #define SVpad_OUR               PADNAMEt_OUR
 359
 360 #ifdef DEBUGGING
 361 #  define PAD_SV(po)       pad_sv(po)
 362 #  define PAD_SETSV(po,sv) pad_setsv(po,sv)
 363 #else
 364 #  define PAD_SV(po)       (PL_curpad[po])
 365 #  define PAD_SETSV(po,sv) PL_curpad[po] = (sv)
 366 #endif
 367
 368 #define PAD_SVl(po)       (PL_curpad[po])
 369
 370 #define PAD_BASE_SV(padlist, po) \
 371         (PadlistARRAY(padlist)[1])                                      \
 372             ? AvARRAY(MUTABLE_AV((PadlistARRAY(padlist)[1])))[po] \
 373             : NULL;
 374
 375
 376 #define PAD_SET_CUR_NOSAVE(padlist,nth) \
 377         PL_comppad = (PAD*) (PadlistARRAY(padlist)[nth]);       \
 378         PL_curpad = AvARRAY(PL_comppad);                        \
 379         DEBUG_Xv(PerlIO_printf(Perl_debug_log,                  \
 380               "Pad 0x%" UVxf "[0x%" UVxf "] set_cur    depth=%d\n",     \
 381               PTR2UV(PL_comppad), PTR2UV(PL_curpad), (int)(nth)));
 382
 383
 384 #define PAD_SET_CUR(padlist,nth) \
 385         SAVECOMPPAD();                                          \
 386         PAD_SET_CUR_NOSAVE(padlist,nth);
 387
 388
 389 #define PAD_SAVE_SETNULLPAD()   SAVECOMPPAD(); \
 390         PL_comppad = NULL; PL_curpad = NULL;    \
 391         DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad set_null\n"));
 392
 393 #define PAD_SAVE_LOCAL(opad,npad) \
 394         opad = PL_comppad;                                      \
 395         PL_comppad = (npad);                                    \
 396         PL_curpad =  PL_comppad ? AvARRAY(PL_comppad) : NULL;   \
 397         DEBUG_Xv(PerlIO_printf(Perl_debug_log,                  \
 398               "Pad 0x%" UVxf "[0x%" UVxf "] save_local\n",              \
 399               PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
 400
 401 #define PAD_RESTORE_LOCAL(opad) \
 402         assert(!opad || !SvIS_FREED(opad));                                     \
 403         PL_comppad = opad;                                              \
 404         PL_curpad =  PL_comppad ? AvARRAY(PL_comppad) : NULL;   \
 405         DEBUG_Xv(PerlIO_printf(Perl_debug_log,                  \
 406               "Pad 0x%" UVxf "[0x%" UVxf "] restore_local\n",   \
 407               PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
 408
 409
 410 /*
 411 =for apidoc m|void|CX_CURPAD_SAVE|struct context
 412 Save the current pad in the given context block structure.
 413
 414 =for apidoc m|SV *|CX_CURPAD_SV|struct context|PADOFFSET po
 415 Access the SV at offset C<po> in the saved current pad in the given
 416 context block structure (can be used as an lvalue).
 417
 418 =cut
 419 */
 420
 421 #define CX_CURPAD_SAVE(block)  (block).oldcomppad = PL_comppad
 422 #define CX_CURPAD_SV(block,po) (AvARRAY(MUTABLE_AV(((block).oldcomppad)))[po])
 423
 424
 425 /*
 426 =for apidoc m|U32|PAD_COMPNAME_FLAGS|PADOFFSET po
 427 Return the flags for the current compiling pad name
 428 at offset C<po>.  Assumes a valid slot entry.
 429
 430 =for apidoc m|char *|PAD_COMPNAME_PV|PADOFFSET po
 431 Return the name of the current compiling pad name
 432 at offset C<po>.  Assumes a valid slot entry.
 433
 434 =for apidoc m|HV *|PAD_COMPNAME_TYPE|PADOFFSET po
 435 Return the type (stash) of the current compiling pad name at offset
 436 C<po>.  Must be a valid name.  Returns null if not typed.
 437
 438 =for apidoc m|HV *|PAD_COMPNAME_OURSTASH|PADOFFSET po
 439 Return the stash associated with an C<our> variable.
 440 Assumes the slot entry is a valid C<our> lexical.
 441
 442 =for apidoc m|STRLEN|PAD_COMPNAME_GEN|PADOFFSET po
 443 The generation number of the name at offset C<po> in the current
 444 compiling pad (lvalue).
 445
 446 =for apidoc m|STRLEN|PAD_COMPNAME_GEN_set|PADOFFSET po|int gen
 447 Sets the generation number of the name at offset C<po> in the current
 448 ling pad (lvalue) to C<gen>.
 449 =cut
 450
 451 */
 452
 453 #define PAD_COMPNAME(po)        PAD_COMPNAME_SV(po)
 454 #define PAD_COMPNAME_SV(po)     (PadnamelistARRAY(PL_comppad_name)[(po)])
 455 #define PAD_COMPNAME_FLAGS(po)  PadnameFLAGS(PAD_COMPNAME(po))
 456 #define PAD_COMPNAME_FLAGS_isOUR(po) SvPAD_OUR(PAD_COMPNAME_SV(po))
 457 #define PAD_COMPNAME_PV(po)     PadnamePV(PAD_COMPNAME(po))
 458
 459 #define PAD_COMPNAME_TYPE(po)   PadnameTYPE(PAD_COMPNAME(po))
 460
 461 #define PAD_COMPNAME_OURSTASH(po) \
 462     (SvOURSTASH(PAD_COMPNAME_SV(po)))
 463
 464 #define PAD_COMPNAME_GEN(po) \
 465     ((STRLEN)PadnamelistARRAY(PL_comppad_name)[po]->xpadn_gen)
 466
 467 #define PAD_COMPNAME_GEN_set(po, gen) \
 468     (PadnamelistARRAY(PL_comppad_name)[po]->xpadn_gen = (gen))
 469
 470
 471 /*
 472 =for apidoc m|void|PAD_CLONE_VARS|PerlInterpreter *proto_perl|CLONE_PARAMS* param
 473 Clone the state variables associated with running and compiling pads.
 474
 475 =cut
 476 */
 477
 478 /* NB - we set PL_comppad to null unless it points at a value that
 479  * has already been dup'ed, ie it points to part of an active padlist.
 480  * Otherwise PL_comppad ends up being a leaked scalar in code like
 481  * the following:
 482  *     threads->create(sub { threads->create(sub {...} ) } );
 483  * where the second thread dups the outer sub's comppad but not the
 484  * sub's CV or padlist. */
 485
 486 #define PAD_CLONE_VARS(proto_perl, param)                               \
 487     PL_comppad                  = av_dup(proto_perl->Icomppad, param);  \
 488     PL_curpad = PL_comppad ?  AvARRAY(PL_comppad) : NULL;               \
 489     PL_comppad_name             =                                       \
 490                   padnamelist_dup(proto_perl->Icomppad_name, param);    \
 491     PL_comppad_name_fill        = proto_perl->Icomppad_name_fill;       \
 492     PL_comppad_name_floor       = proto_perl->Icomppad_name_floor;      \
 493     PL_min_intro_pending        = proto_perl->Imin_intro_pending;       \
 494     PL_max_intro_pending        = proto_perl->Imax_intro_pending;       \
 495     PL_padix                    = proto_perl->Ipadix;                   \
 496     PL_padix_floor              = proto_perl->Ipadix_floor;             \
 497     PL_pad_reset_pending        = proto_perl->Ipad_reset_pending;       \
 498     PL_cop_seqmax               = proto_perl->Icop_seqmax;
 499
 500 /*
 501 =for apidoc Am|PADOFFSET|pad_add_name_pvs|const char *name|U32 flags|HV *typestash|HV *ourstash
 502
 503 Exactly like L</pad_add_name_pvn>, but takes a C<NUL>-terminated literal string
 504 instead of a string/length pair.
 505
 506 =cut
 507 */
 508
 509 #define pad_add_name_pvs(name,flags,typestash,ourstash) \
 510     Perl_pad_add_name_pvn(aTHX_ STR_WITH_LEN(name), flags, typestash, ourstash)
 511
 512 /*
 513 =for apidoc Am|PADOFFSET|pad_findmy_pvs|const char *name|U32 flags
 514
 515 Exactly like L</pad_findmy_pvn>, but takes a C<NUL>-terminated literal string
 516 instead of a string/length pair.
 517
 518 =cut
 519 */
 520
 521 #define pad_findmy_pvs(name,flags) \
 522     Perl_pad_findmy_pvn(aTHX_ STR_WITH_LEN(name), flags)
 523
 524 /*
 525  * ex: set ts=8 sts=4 sw=4 et:
 526  */