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