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|"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|"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 */ 521