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