XS staticing in ext and dist
[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 #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 literal string instead
504 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 literal string instead
516 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  */