perl.h: White-space, comment
[perl.git] / 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|"literal string" name|U32 flags|HV *typestash|HV *ourstash
496
497 Exactly like L</pad_add_name_pvn>, but takes a 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|"literal string" name|U32 flags
508
509 Exactly like L</pad_findmy_pvn>, but takes a 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  */