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