This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
135f1d2143596d66cd7dd28e9bed7e6cbec97624
[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.  Entries for which this is true
250 are often referred to as 'fake'.
251
252 =for apidoc m|bool|PadnameIsSTATE|PADNAME pn
253 Whether this is a "state" variable.
254
255 =for apidoc m|HV *|PadnameTYPE|PADNAME pn
256 The stash associated with a typed lexical.  This returns the %Foo:: hash
257 for C<my Foo $bar>.
258
259
260 =for apidoc m|SV *|PAD_SETSV    |PADOFFSET po|SV* sv
261 Set the slot at offset C<po> in the current pad to C<sv>
262
263 =for apidoc m|SV *|PAD_SV       |PADOFFSET po
264 Get the value at offset C<po> in the current pad
265
266 =for apidoc m|SV *|PAD_SVl      |PADOFFSET po
267 Lightweight and lvalue version of C<PAD_SV>.
268 Get or set the value at offset C<po> in the current pad.
269 Unlike C<PAD_SV>, does not print diagnostics with -DX.
270 For internal use only.
271
272 =for apidoc m|SV *|PAD_BASE_SV  |PADLIST padlist|PADOFFSET po
273 Get the value from slot C<po> in the base (DEPTH=1) pad of a padlist
274
275 =for apidoc m|void|PAD_SET_CUR  |PADLIST padlist|I32 n
276 Set the current pad to be pad C<n> in the padlist, saving
277 the previous current pad.  NB currently this macro expands to a string too
278 long for some compilers, so it's best to replace it with
279
280     SAVECOMPPAD();
281     PAD_SET_CUR_NOSAVE(padlist,n);
282
283
284 =for apidoc m|void|PAD_SET_CUR_NOSAVE   |PADLIST padlist|I32 n
285 like PAD_SET_CUR, but without the save
286
287 =for apidoc m|void|PAD_SAVE_SETNULLPAD
288 Save the current pad then set it to null.
289
290 =for apidoc m|void|PAD_SAVE_LOCAL|PAD *opad|PAD *npad
291 Save the current pad to the local variable opad, then make the
292 current pad equal to npad
293
294 =for apidoc m|void|PAD_RESTORE_LOCAL|PAD *opad
295 Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL()
296
297 =cut
298 */
299
300 #define PadlistARRAY(pl)        (pl)->xpadl_alloc
301 #define PadlistMAX(pl)          (pl)->xpadl_max
302 #define PadlistNAMES(pl)        ((PADNAMELIST *)*PadlistARRAY(pl))
303 #define PadlistNAMESARRAY(pl)   PadnamelistARRAY(PadlistNAMES(pl))
304 #define PadlistNAMESMAX(pl)     PadnamelistMAX(PadlistNAMES(pl))
305 #define PadlistREFCNT(pl)       1       /* reserved for future use */
306
307 #define PadnamelistARRAY(pnl)           (pnl)->xpadnl_alloc
308 #define PadnamelistMAX(pnl)             (pnl)->xpadnl_fill
309 #define PadnamelistMAXNAMED(pnl)        (pnl)->xpadnl_max_named
310 #define PadnamelistREFCNT(pnl)          (pnl)->xpadnl_refcnt
311 #define PadnamelistREFCNT_dec(pnl)      Perl_padnamelist_free(aTHX_ pnl)
312
313 #define PadARRAY(pad)           AvARRAY(pad)
314 #define PadMAX(pad)             AvFILLp(pad)
315
316 #define PadnamePV(pn)           (SvPOKp(pn) ? SvPVX_const(pn) : NULL)
317 #define PadnameLEN(pn)          ((SV*)(pn) == &PL_sv_undef ? 0 : SvCUR(pn))
318 #define PadnameUTF8(pn)         (assert_(SvUTF8(pn)) 1)
319 #define PadnameSV(pn)           pn
320 #define PadnameIsOUR(pn)        !!SvPAD_OUR(pn)
321 #define PadnameOURSTASH(pn)     SvOURSTASH(pn)
322 #define PadnameOUTER(pn)        !!SvFAKE(pn)
323 #define PadnameIsSTATE(pn)      !!SvPAD_STATE(pn)
324 #define PadnameTYPE(pn)         (SvPAD_TYPED(pn) ? SvSTASH(pn) : NULL)
325 #define PadnameLVALUE(pn) \
326     ((SvFLAGS(pn) & (SVpad_NAME|SVpad_LVALUE))==(SVpad_NAME|SVpad_LVALUE))
327
328 #define PadnameLVALUE_on(pn)    (SvFLAGS(pn) |= SVpad_NAME|SVpad_LVALUE)
329
330 #ifdef DEBUGGING
331 #  define PAD_SV(po)       pad_sv(po)
332 #  define PAD_SETSV(po,sv) pad_setsv(po,sv)
333 #else
334 #  define PAD_SV(po)       (PL_curpad[po])
335 #  define PAD_SETSV(po,sv) PL_curpad[po] = (sv)
336 #endif
337
338 #define PAD_SVl(po)       (PL_curpad[po])
339
340 #define PAD_BASE_SV(padlist, po) \
341         (PadlistARRAY(padlist)[1])                                      \
342             ? AvARRAY(MUTABLE_AV((PadlistARRAY(padlist)[1])))[po] \
343             : NULL;
344
345
346 #define PAD_SET_CUR_NOSAVE(padlist,nth) \
347         PL_comppad = (PAD*) (PadlistARRAY(padlist)[nth]);       \
348         PL_curpad = AvARRAY(PL_comppad);                        \
349         DEBUG_Xv(PerlIO_printf(Perl_debug_log,                  \
350               "Pad 0x%" UVxf "[0x%" UVxf "] set_cur    depth=%d\n",     \
351               PTR2UV(PL_comppad), PTR2UV(PL_curpad), (int)(nth)));
352
353
354 #define PAD_SET_CUR(padlist,nth) \
355         SAVECOMPPAD();                                          \
356         PAD_SET_CUR_NOSAVE(padlist,nth);
357
358
359 #define PAD_SAVE_SETNULLPAD()   SAVECOMPPAD(); \
360         PL_comppad = NULL; PL_curpad = NULL;    \
361         DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad set_null\n"));
362
363 #define PAD_SAVE_LOCAL(opad,npad) \
364         opad = PL_comppad;                                      \
365         PL_comppad = (npad);                                    \
366         PL_curpad =  PL_comppad ? AvARRAY(PL_comppad) : NULL;   \
367         DEBUG_Xv(PerlIO_printf(Perl_debug_log,                  \
368               "Pad 0x%" UVxf "[0x%" UVxf "] save_local\n",              \
369               PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
370
371 #define PAD_RESTORE_LOCAL(opad) \
372         assert(!opad || !SvIS_FREED(opad));                                     \
373         PL_comppad = opad;                                              \
374         PL_curpad =  PL_comppad ? AvARRAY(PL_comppad) : NULL;   \
375         DEBUG_Xv(PerlIO_printf(Perl_debug_log,                  \
376               "Pad 0x%" UVxf "[0x%" UVxf "] restore_local\n",   \
377               PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
378
379
380 /*
381 =for apidoc m|void|CX_CURPAD_SAVE|struct context
382 Save the current pad in the given context block structure.
383
384 =for apidoc m|SV *|CX_CURPAD_SV|struct context|PADOFFSET po
385 Access the SV at offset po in the saved current pad in the given
386 context block structure (can be used as an lvalue).
387
388 =cut
389 */
390
391 #define CX_CURPAD_SAVE(block)  (block).oldcomppad = PL_comppad
392 #define CX_CURPAD_SV(block,po) (AvARRAY(MUTABLE_AV(((block).oldcomppad)))[po])
393
394
395 /*
396 =for apidoc m|U32|PAD_COMPNAME_FLAGS|PADOFFSET po
397 Return the flags for the current compiling pad name
398 at offset C<po>.  Assumes a valid slot entry.
399
400 =for apidoc m|char *|PAD_COMPNAME_PV|PADOFFSET po
401 Return the name of the current compiling pad name
402 at offset C<po>.  Assumes a valid slot entry.
403
404 =for apidoc m|HV *|PAD_COMPNAME_TYPE|PADOFFSET po
405 Return the type (stash) of the current compiling pad name at offset
406 C<po>.  Must be a valid name.  Returns null if not typed.
407
408 =for apidoc m|HV *|PAD_COMPNAME_OURSTASH|PADOFFSET po
409 Return the stash associated with an C<our> variable.
410 Assumes the slot entry is a valid C<our> lexical.
411
412 =for apidoc m|STRLEN|PAD_COMPNAME_GEN|PADOFFSET po
413 The generation number of the name at offset C<po> in the current
414 compiling pad (lvalue).  Note that C<SvUVX> is hijacked for this purpose.
415
416 =for apidoc m|STRLEN|PAD_COMPNAME_GEN_set|PADOFFSET po|int gen
417 Sets the generation number of the name at offset C<po> in the current
418 ling pad (lvalue) to C<gen>.  Note that C<SvUV_set> is hijacked for this purpose.
419
420 =cut
421
422 */
423
424 #define PAD_COMPNAME(po)        PAD_COMPNAME_SV(po)
425 #define PAD_COMPNAME_SV(po)     (PadnamelistARRAY(PL_comppad_name)[(po)])
426 #define PAD_COMPNAME_FLAGS(po) SvFLAGS(PAD_COMPNAME_SV(po))
427 #define PAD_COMPNAME_FLAGS_isOUR(po) SvPAD_OUR(PAD_COMPNAME_SV(po))
428 #define PAD_COMPNAME_PV(po)     PadnamePV(PAD_COMPNAME(po))
429
430 #define PAD_COMPNAME_TYPE(po)   PadnameTYPE(PAD_COMPNAME(po))
431
432 #define PAD_COMPNAME_OURSTASH(po) \
433     (SvOURSTASH(PAD_COMPNAME_SV(po)))
434
435 #define PAD_COMPNAME_GEN(po) \
436     ((STRLEN)SvUVX(PadnamelistARRAY(PL_comppad_name)[po]))
437
438 #define PAD_COMPNAME_GEN_set(po, gen) \
439     SvUV_set(PadnamelistARRAY(PL_comppad_name)[po], (UV)(gen))
440
441
442 /*
443 =for apidoc m|void|PAD_CLONE_VARS|PerlInterpreter *proto_perl|CLONE_PARAMS* param
444 Clone the state variables associated with running and compiling pads.
445
446 =cut
447 */
448
449 /* NB - we set PL_comppad to null unless it points at a value that
450  * has already been dup'ed, ie it points to part of an active padlist.
451  * Otherwise PL_comppad ends up being a leaked scalar in code like
452  * the following:
453  *     threads->create(sub { threads->create(sub {...} ) } );
454  * where the second thread dups the outer sub's comppad but not the
455  * sub's CV or padlist. */
456
457 #define PAD_CLONE_VARS(proto_perl, param)                               \
458     PL_comppad                  = av_dup(proto_perl->Icomppad, param);  \
459     PL_curpad = PL_comppad ?  AvARRAY(PL_comppad) : NULL;               \
460     PL_comppad_name             =                                       \
461                   padnamelist_dup(proto_perl->Icomppad_name, param);    \
462     PL_comppad_name_fill        = proto_perl->Icomppad_name_fill;       \
463     PL_comppad_name_floor       = proto_perl->Icomppad_name_floor;      \
464     PL_min_intro_pending        = proto_perl->Imin_intro_pending;       \
465     PL_max_intro_pending        = proto_perl->Imax_intro_pending;       \
466     PL_padix                    = proto_perl->Ipadix;                   \
467     PL_padix_floor              = proto_perl->Ipadix_floor;             \
468     PL_pad_reset_pending        = proto_perl->Ipad_reset_pending;       \
469     PL_cop_seqmax               = proto_perl->Icop_seqmax;
470
471 /*
472 =for apidoc Am|PADOFFSET|pad_add_name_pvs|const char *name|U32 flags|HV *typestash|HV *ourstash
473
474 Exactly like L</pad_add_name_pvn>, but takes a literal string instead
475 of a string/length pair.
476
477 =cut
478 */
479
480 #define pad_add_name_pvs(name,flags,typestash,ourstash) \
481     Perl_pad_add_name_pvn(aTHX_ STR_WITH_LEN(name), flags, typestash, ourstash)
482
483 /*
484 =for apidoc Am|PADOFFSET|pad_findmy_pvs|const char *name|U32 flags
485
486 Exactly like L</pad_findmy_pvn>, but takes a literal string instead
487 of a string/length pair.
488
489 =cut
490 */
491
492 #define pad_findmy_pvs(name,flags) \
493     Perl_pad_findmy_pvn(aTHX_ STR_WITH_LEN(name), flags)
494
495 /*
496  * Local variables:
497  * c-indentation-style: bsd
498  * c-basic-offset: 4
499  * indent-tabs-mode: nil
500  * End:
501  *
502  * ex: set ts=8 sts=4 sw=4 et:
503  */