1 /* sv.h 2 * 3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 4 * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 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 */ 10 11 #ifdef sv_flags 12 #undef sv_flags /* Convex has this in <signal.h> for sigvec() */ 13 #endif 14 15 /* 16 =head1 SV Flags 17 18 =for apidoc AmU||svtype 19 An enum of flags for Perl types. These are found in the file B<sv.h> 20 in the C<svtype> enum. Test these flags with the C<SvTYPE> macro. 21 22 The types are: 23 24 SVt_NULL 25 SVt_IV 26 SVt_NV 27 SVt_RV 28 SVt_PV 29 SVt_PVIV 30 SVt_PVNV 31 SVt_PVMG 32 SVt_INVLIST 33 SVt_REGEXP 34 SVt_PVGV 35 SVt_PVLV 36 SVt_PVAV 37 SVt_PVHV 38 SVt_PVCV 39 SVt_PVFM 40 SVt_PVIO 41 42 These are most easily explained from the bottom up. 43 44 SVt_PVIO is for I/O objects, SVt_PVFM for formats, SVt_PVCV for 45 subroutines, SVt_PVHV for hashes and SVt_PVAV for arrays. 46 47 All the others are scalar types, that is, things that can be bound to a 48 C<$> variable. For these, the internal types are mostly orthogonal to 49 types in the Perl language. 50 51 Hence, checking C<< SvTYPE(sv) < SVt_PVAV >> is the best way to see whether 52 something is a scalar. 53 54 SVt_PVGV represents a typeglob. If !SvFAKE(sv), then it is a real, 55 incoercible typeglob. If SvFAKE(sv), then it is a scalar to which a 56 typeglob has been assigned. Assigning to it again will stop it from being 57 a typeglob. SVt_PVLV represents a scalar that delegates to another scalar 58 behind the scenes. It is used, e.g., for the return value of C<substr> and 59 for tied hash and array elements. It can hold any scalar value, including 60 a typeglob. SVt_REGEXP is for regular 61 expressions. SVt_INVLIST is for Perl 62 core internal use only. 63 64 SVt_PVMG represents a "normal" scalar (not a typeglob, regular expression, 65 or delegate). Since most scalars do not need all the internal fields of a 66 PVMG, we save memory by allocating smaller structs when possible. All the 67 other types are just simpler forms of SVt_PVMG, with fewer internal fields. 68 SVt_NULL can only hold undef. SVt_IV can hold undef, an integer, or a 69 reference. (SVt_RV is an alias for SVt_IV, which exists for backward 70 compatibility.) SVt_NV can hold any of those or a double. SVt_PV can only 71 hold undef or a string. SVt_PVIV is a superset of SVt_PV and SVt_IV. 72 SVt_PVNV is similar. SVt_PVMG can hold anything SVt_PVNV can hold, but it 73 can, but does not have to, be blessed or magical. 74 75 =for apidoc AmU||SVt_NULL 76 Type flag for scalars. See L</svtype>. 77 78 =for apidoc AmU||SVt_IV 79 Type flag for scalars. See L</svtype>. 80 81 =for apidoc AmU||SVt_NV 82 Type flag for scalars. See L</svtype>. 83 84 =for apidoc AmU||SVt_PV 85 Type flag for scalars. See L</svtype>. 86 87 =for apidoc AmU||SVt_PVIV 88 Type flag for scalars. See L</svtype>. 89 90 =for apidoc AmU||SVt_PVNV 91 Type flag for scalars. See L</svtype>. 92 93 =for apidoc AmU||SVt_PVMG 94 Type flag for scalars. See L</svtype>. 95 96 =for apidoc AmU||SVt_INVLIST 97 Type flag for scalars. See L</svtype>. 98 99 =for apidoc AmU||SVt_REGEXP 100 Type flag for regular expressions. See L</svtype>. 101 102 =for apidoc AmU||SVt_PVGV 103 Type flag for typeglobs. See L</svtype>. 104 105 =for apidoc AmU||SVt_PVLV 106 Type flag for scalars. See L</svtype>. 107 108 =for apidoc AmU||SVt_PVAV 109 Type flag for arrays. See L</svtype>. 110 111 =for apidoc AmU||SVt_PVHV 112 Type flag for hashes. See L</svtype>. 113 114 =for apidoc AmU||SVt_PVCV 115 Type flag for subroutines. See L</svtype>. 116 117 =for apidoc AmU||SVt_PVFM 118 Type flag for formats. See L</svtype>. 119 120 =for apidoc AmU||SVt_PVIO 121 Type flag for I/O objects. See L</svtype>. 122 123 =cut 124 125 These are ordered so that the simpler types have a lower value; SvUPGRADE 126 doesn't allow you to upgrade from a higher numbered type to a lower numbered 127 one; also there is code that assumes that anything that has as a PV component 128 has a type numbered >= SVt_PV. 129 */ 130 131 132 typedef enum { 133 SVt_NULL, /* 0 */ 134 /* BIND was here, before INVLIST replaced it. */ 135 SVt_IV, /* 1 */ 136 SVt_NV, /* 2 */ 137 /* RV was here, before it was merged with IV. */ 138 SVt_PV, /* 3 */ 139 SVt_INVLIST, /* 4, implemented as a PV */ 140 SVt_PVIV, /* 5 */ 141 SVt_PVNV, /* 6 */ 142 SVt_PVMG, /* 7 */ 143 SVt_REGEXP, /* 8 */ 144 /* PVBM was here, before BIND replaced it. */ 145 SVt_PVGV, /* 9 */ 146 SVt_PVLV, /* 10 */ 147 SVt_PVAV, /* 11 */ 148 SVt_PVHV, /* 12 */ 149 SVt_PVCV, /* 13 */ 150 SVt_PVFM, /* 14 */ 151 SVt_PVIO, /* 15 */ 152 SVt_LAST /* keep last in enum. used to size arrays */ 153 } svtype; 154 155 /* *** any alterations to the SV types above need to be reflected in 156 * SVt_MASK and the various PL_valid_types_* tables. As of this writing those 157 * tables are in perl.h. There are also two affected names tables in dump.c, 158 * one in B.xs, and 'bodies_by_type[]' in sv.c */ 159 160 #define SVt_MASK 0xf /* smallest bitmask that covers all types */ 161 162 #ifndef PERL_CORE 163 /* Although Fast Boyer Moore tables are now being stored in PVGVs, for most 164 purposes external code wanting to consider PVBM probably needs to think of 165 PVMG instead. */ 166 # define SVt_PVBM SVt_PVMG 167 /* Anything wanting to create a reference from clean should ensure that it has 168 a scalar of type SVt_IV now: */ 169 # define SVt_RV SVt_IV 170 #endif 171 172 /* There is collusion here with sv_clear - sv_clear exits early for SVt_NULL 173 so never reaches the clause at the end that uses sv_type_details->body_size 174 to determine whether to call safefree(). Hence body_size can be set 175 non-zero to record the size of HEs, without fear of bogus frees. */ 176 #if defined(PERL_IN_HV_C) || defined(PERL_IN_XS_APITEST) 177 #define HE_SVSLOT SVt_NULL 178 #endif 179 180 #define PERL_ARENA_ROOTS_SIZE (SVt_LAST) 181 182 /* typedefs to eliminate some typing */ 183 typedef struct he HE; 184 typedef struct hek HEK; 185 186 /* Using C's structural equivalence to help emulate C++ inheritance here... */ 187 188 /* start with 2 sv-head building blocks */ 189 #define _SV_HEAD(ptrtype) \ 190 ptrtype sv_any; /* pointer to body */ \ 191 U32 sv_refcnt; /* how many references to us */ \ 192 U32 sv_flags /* what we are */ 193 194 #define _SV_HEAD_UNION \ 195 union { \ 196 char* svu_pv; /* pointer to malloced string */ \ 197 IV svu_iv; \ 198 UV svu_uv; \ 199 SV* svu_rv; /* pointer to another SV */ \ 200 struct regexp* svu_rx; \ 201 SV** svu_array; \ 202 HE** svu_hash; \ 203 GP* svu_gp; \ 204 PerlIO *svu_fp; \ 205 } sv_u 206 207 208 struct STRUCT_SV { /* struct sv { */ 209 _SV_HEAD(void*); 210 _SV_HEAD_UNION; 211 #ifdef DEBUG_LEAKING_SCALARS 212 PERL_BITFIELD32 sv_debug_optype:9; /* the type of OP that allocated us */ 213 PERL_BITFIELD32 sv_debug_inpad:1; /* was allocated in a pad for an OP */ 214 PERL_BITFIELD32 sv_debug_line:16; /* the line where we were allocated */ 215 UV sv_debug_serial; /* serial number of sv allocation */ 216 char * sv_debug_file; /* the file where we were allocated */ 217 SV * sv_debug_parent; /* what we were cloned from (ithreads)*/ 218 #endif 219 }; 220 221 struct gv { 222 _SV_HEAD(XPVGV*); /* pointer to xpvgv body */ 223 _SV_HEAD_UNION; 224 }; 225 226 struct cv { 227 _SV_HEAD(XPVCV*); /* pointer to xpvcv body */ 228 _SV_HEAD_UNION; 229 }; 230 231 struct av { 232 _SV_HEAD(XPVAV*); /* pointer to xpvav body */ 233 _SV_HEAD_UNION; 234 }; 235 236 struct hv { 237 _SV_HEAD(XPVHV*); /* pointer to xpvhv body */ 238 _SV_HEAD_UNION; 239 }; 240 241 struct io { 242 _SV_HEAD(XPVIO*); /* pointer to xpvio body */ 243 _SV_HEAD_UNION; 244 }; 245 246 struct p5rx { 247 _SV_HEAD(struct regexp*); /* pointer to regexp body */ 248 _SV_HEAD_UNION; 249 }; 250 251 #undef _SV_HEAD 252 #undef _SV_HEAD_UNION /* ensure no pollution */ 253 254 /* 255 =head1 SV Manipulation Functions 256 257 =for apidoc Am|U32|SvREFCNT|SV* sv 258 Returns the value of the object's reference count. 259 260 =for apidoc Am|SV*|SvREFCNT_inc|SV* sv 261 Increments the reference count of the given SV, returning the SV. 262 263 All of the following SvREFCNT_inc* macros are optimized versions of 264 SvREFCNT_inc, and can be replaced with SvREFCNT_inc. 265 266 =for apidoc Am|SV*|SvREFCNT_inc_NN|SV* sv 267 Same as SvREFCNT_inc, but can only be used if you know I<sv> 268 is not NULL. Since we don't have to check the NULLness, it's faster 269 and smaller. 270 271 =for apidoc Am|void|SvREFCNT_inc_void|SV* sv 272 Same as SvREFCNT_inc, but can only be used if you don't need the 273 return value. The macro doesn't need to return a meaningful value. 274 275 =for apidoc Am|void|SvREFCNT_inc_void_NN|SV* sv 276 Same as SvREFCNT_inc, but can only be used if you don't need the return 277 value, and you know that I<sv> is not NULL. The macro doesn't need 278 to return a meaningful value, or check for NULLness, so it's smaller 279 and faster. 280 281 =for apidoc Am|SV*|SvREFCNT_inc_simple|SV* sv 282 Same as SvREFCNT_inc, but can only be used with expressions without side 283 effects. Since we don't have to store a temporary value, it's faster. 284 285 =for apidoc Am|SV*|SvREFCNT_inc_simple_NN|SV* sv 286 Same as SvREFCNT_inc_simple, but can only be used if you know I<sv> 287 is not NULL. Since we don't have to check the NULLness, it's faster 288 and smaller. 289 290 =for apidoc Am|void|SvREFCNT_inc_simple_void|SV* sv 291 Same as SvREFCNT_inc_simple, but can only be used if you don't need the 292 return value. The macro doesn't need to return a meaningful value. 293 294 =for apidoc Am|void|SvREFCNT_inc_simple_void_NN|SV* sv 295 Same as SvREFCNT_inc, but can only be used if you don't need the return 296 value, and you know that I<sv> is not NULL. The macro doesn't need 297 to return a meaningful value, or check for NULLness, so it's smaller 298 and faster. 299 300 =for apidoc Am|void|SvREFCNT_dec|SV* sv 301 Decrements the reference count of the given SV. I<sv> may be NULL. 302 303 =for apidoc Am|void|SvREFCNT_dec_NN|SV* sv 304 Same as SvREFCNT_dec, but can only be used if you know I<sv> 305 is not NULL. Since we don't have to check the NULLness, it's faster 306 and smaller. 307 308 =for apidoc Am|svtype|SvTYPE|SV* sv 309 Returns the type of the SV. See C<svtype>. 310 311 =for apidoc Am|void|SvUPGRADE|SV* sv|svtype type 312 Used to upgrade an SV to a more complex form. Uses C<sv_upgrade> to 313 perform the upgrade if necessary. See C<svtype>. 314 315 =cut 316 */ 317 318 #define SvANY(sv) (sv)->sv_any 319 #define SvFLAGS(sv) (sv)->sv_flags 320 #define SvREFCNT(sv) (sv)->sv_refcnt 321 322 #define SvREFCNT_inc(sv) S_SvREFCNT_inc(MUTABLE_SV(sv)) 323 #define SvREFCNT_inc_simple(sv) SvREFCNT_inc(sv) 324 #define SvREFCNT_inc_NN(sv) S_SvREFCNT_inc_NN(MUTABLE_SV(sv)) 325 #define SvREFCNT_inc_void(sv) S_SvREFCNT_inc_void(MUTABLE_SV(sv)) 326 327 /* These guys don't need the curly blocks */ 328 #define SvREFCNT_inc_simple_void(sv) STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END 329 #define SvREFCNT_inc_simple_NN(sv) (++(SvREFCNT(sv)),MUTABLE_SV(sv)) 330 #define SvREFCNT_inc_void_NN(sv) (void)(++SvREFCNT(MUTABLE_SV(sv))) 331 #define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT(MUTABLE_SV(sv))) 332 333 #define SvREFCNT_dec(sv) S_SvREFCNT_dec(aTHX_ MUTABLE_SV(sv)) 334 #define SvREFCNT_dec_NN(sv) S_SvREFCNT_dec_NN(aTHX_ MUTABLE_SV(sv)) 335 336 #define SVTYPEMASK 0xff 337 #define SvTYPE(sv) ((svtype)((sv)->sv_flags & SVTYPEMASK)) 338 339 /* Sadly there are some parts of the core that have pointers to already-freed 340 SV heads, and rely on being able to tell that they are now free. So mark 341 them all by using a consistent macro. */ 342 #define SvIS_FREED(sv) ((sv)->sv_flags == SVTYPEMASK) 343 344 /* this is defined in this peculiar way to avoid compiler warnings. 345 * See the <20121213131428.GD1842@iabyn.com> thread in p5p */ 346 #define SvUPGRADE(sv, mt) \ 347 ((void)(SvTYPE(sv) >= (mt) || (sv_upgrade(sv, mt),1))) 348 349 #define SVf_IOK 0x00000100 /* has valid public integer value */ 350 #define SVf_NOK 0x00000200 /* has valid public numeric value */ 351 #define SVf_POK 0x00000400 /* has valid public pointer value */ 352 #define SVf_ROK 0x00000800 /* has a valid reference pointer */ 353 354 #define SVp_IOK 0x00001000 /* has valid non-public integer value */ 355 #define SVp_NOK 0x00002000 /* has valid non-public numeric value */ 356 #define SVp_POK 0x00004000 /* has valid non-public pointer value */ 357 #define SVp_SCREAM 0x00008000 /* method name is DOES */ 358 #define SVphv_CLONEABLE SVp_SCREAM /* PVHV (stashes) clone its objects */ 359 #define SVpgv_GP SVp_SCREAM /* GV has a valid GP */ 360 #define SVprv_PCS_IMPORTED SVp_SCREAM /* RV is a proxy for a constant 361 subroutine in another package. Set the 362 GvIMPORTED_CV_on() if it needs to be 363 expanded to a real GV */ 364 #define SVpad_NAMELIST SVp_SCREAM /* AV is a padnamelist */ 365 #define SVf_IsCOW 0x00010000 /* copy on write (shared hash key if 366 SvLEN == 0) */ 367 #define SVs_PADTMP 0x00020000 /* in use as tmp; only if ! SVs_PADMY */ 368 #define SVs_PADSTALE 0x00020000 /* lexical has gone out of scope; 369 only valid for SVs_PADMY */ 370 #define SVpad_TYPED 0x00020000 /* pad name is a Typed Lexical */ 371 #define SVs_PADMY 0x00040000 /* in use a "my" variable */ 372 #define SVpad_OUR 0x00040000 /* pad name is "our" instead of "my" */ 373 #define SVs_TEMP 0x00080000 /* string is stealable? */ 374 #define SVs_OBJECT 0x00100000 /* is "blessed" */ 375 #define SVs_GMG 0x00200000 /* has magical get method */ 376 #define SVs_SMG 0x00400000 /* has magical set method */ 377 #define SVs_RMG 0x00800000 /* has random magical methods */ 378 379 #define SVf_FAKE 0x01000000 /* 0: glob is just a copy 380 1: SV head arena wasn't malloc()ed 381 2: For PVCV, whether CvUNIQUE(cv) 382 refers to an eval or once only 383 [CvEVAL(cv), CvSPECIAL(cv)] 384 3: On a pad name SV, that slot in the 385 frame AV is a REFCNT'ed reference 386 to a lexical from "outside". */ 387 #define SVf_OOK 0x02000000 /* has valid offset value. For a PVHV this 388 means that a hv_aux struct is present 389 after the main array */ 390 #define SVf_BREAK 0x04000000 /* refcnt is artificially low - used by 391 SVs in final arena cleanup. 392 Set in S_regtry on PL_reg_curpm, so that 393 perl_destruct will skip it. */ 394 #define SVf_READONLY 0x08000000 /* may not be modified */ 395 396 397 398 399 #define SVf_THINKFIRST (SVf_READONLY|SVf_ROK|SVf_FAKE|SVs_RMG|SVf_IsCOW) 400 401 #define SVf_OK (SVf_IOK|SVf_NOK|SVf_POK|SVf_ROK| \ 402 SVp_IOK|SVp_NOK|SVp_POK|SVpgv_GP) 403 404 #define PRIVSHIFT 4 /* (SVp_?OK >> PRIVSHIFT) == SVf_?OK */ 405 406 #define SVf_AMAGIC 0x10000000 /* has magical overloaded methods */ 407 408 /* note that SVf_AMAGIC is now only set on stashes, so this bit is free 409 * for non-HV SVs */ 410 411 /* Ensure this value does not clash with the GV_ADD* flags in gv.h: */ 412 #define SVf_UTF8 0x20000000 /* SvPV is UTF-8 encoded 413 This is also set on RVs whose overloaded 414 stringification is UTF-8. This might 415 only happen as a side effect of SvPV() */ 416 /* PVHV */ 417 #define SVphv_SHAREKEYS 0x20000000 /* PVHV keys live on shared string table */ 418 419 /* PVAV could probably use 0x2000000 without conflict. I assume that PVFM can 420 be UTF-8 encoded, and PVCVs could well have UTF-8 prototypes. PVIOs haven't 421 been restructured, so sometimes get used as string buffers. */ 422 423 424 /* Some private flags. */ 425 426 427 /* PVNV, PVMG only, and only used in pads. Should be safe to test on any scalar 428 SV, as the core is careful to avoid setting both. 429 430 SVf_POK, SVp_POK also set: 431 0x00004400 Normal 432 0x0000C400 method name for DOES (SvSCREAM) 433 0x40004400 FBM compiled (SvVALID) 434 0x4000C400 pad name. 435 436 0x00008000 GV with GP 437 0x00008800 RV with PCS imported 438 */ 439 #define SVpad_NAME (SVp_SCREAM|SVpbm_VALID) 440 /* This SV is a name in the PAD, so 441 SVpad_TYPED, SVpad_OUR and SVpad_STATE 442 apply */ 443 /* PVAV */ 444 #define SVpav_REAL 0x40000000 /* free old entries */ 445 /* PVHV */ 446 #define SVphv_LAZYDEL 0x40000000 /* entry in xhv_eiter must be deleted */ 447 /* This is only set true on a PVGV when it's playing "PVBM", but is tested for 448 on any regular scalar (anything <= PVLV) */ 449 #define SVpbm_VALID 0x40000000 450 /* Only used in toke.c on an SV stored in PL_lex_repl */ 451 #define SVrepl_EVAL 0x40000000 /* Replacement part of s///e */ 452 453 /* IV, PVIV, PVNV, PVMG, PVGV and (I assume) PVLV */ 454 #define SVf_IVisUV 0x80000000 /* use XPVUV instead of XPVIV */ 455 /* PVAV */ 456 #define SVpav_REIFY 0x80000000 /* can become real */ 457 /* PVHV */ 458 #define SVphv_HASKFLAGS 0x80000000 /* keys have flag byte after hash */ 459 /* PVGV when SVpbm_VALID is true */ 460 #define SVpbm_TAIL 0x80000000 461 /* RV upwards. However, SVf_ROK and SVp_IOK are exclusive */ 462 #define SVprv_WEAKREF 0x80000000 /* Weak reference */ 463 /* pad name vars only */ 464 #define SVpad_STATE 0x80000000 /* pad name is a "state" var */ 465 466 #define _XPV_HEAD \ 467 HV* xmg_stash; /* class package */ \ 468 union _xmgu xmg_u; \ 469 STRLEN xpv_cur; /* length of svu_pv as a C string */ \ 470 union { \ 471 STRLEN xpvlenu_len; /* allocated size */ \ 472 char * xpvlenu_pv; /* regexp string */ \ 473 } xpv_len_u 474 475 #define xpv_len xpv_len_u.xpvlenu_len 476 477 union _xnvu { 478 NV xnv_nv; /* numeric value, if any */ 479 HV * xgv_stash; 480 struct { 481 U32 xlow; 482 U32 xhigh; 483 } xpad_cop_seq; /* used by pad.c for cop_sequence */ 484 }; 485 486 union _xivu { 487 IV xivu_iv; /* integer value */ 488 UV xivu_uv; 489 HEK * xivu_namehek; /* xpvlv, xpvgv: GvNAME */ 490 }; 491 492 union _xmgu { 493 MAGIC* xmg_magic; /* linked list of magicalness */ 494 HV* xmg_ourstash; /* Stash for our (when SvPAD_OUR is true) */ 495 STRLEN xmg_hash_index; /* used while freeing hash entries */ 496 }; /* also used by PadnamelistMAXNAMED */ 497 498 struct xpv { 499 _XPV_HEAD; 500 }; 501 502 struct xpviv { 503 _XPV_HEAD; 504 union _xivu xiv_u; 505 }; 506 507 #define xiv_iv xiv_u.xivu_iv 508 509 struct xpvuv { 510 _XPV_HEAD; 511 union _xivu xuv_u; 512 }; 513 514 #define xuv_uv xuv_u.xivu_uv 515 516 struct xpvnv { 517 _XPV_HEAD; 518 union _xivu xiv_u; 519 union _xnvu xnv_u; 520 }; 521 522 /* This structure must match the beginning of struct xpvhv in hv.h. */ 523 struct xpvmg { 524 _XPV_HEAD; 525 union _xivu xiv_u; 526 union _xnvu xnv_u; 527 }; 528 529 struct xpvlv { 530 _XPV_HEAD; 531 union _xivu xiv_u; 532 union _xnvu xnv_u; 533 union { 534 STRLEN xlvu_targoff; 535 SSize_t xlvu_stargoff; 536 } xlv_targoff_u; 537 STRLEN xlv_targlen; 538 SV* xlv_targ; 539 char xlv_type; /* k=keys .=pos x=substr v=vec /=join/re 540 * y=alem/helem/iter t=tie T=tied HE */ 541 char xlv_flags; /* 1 = negative offset 2 = negative len */ 542 }; 543 544 #define xlv_targoff xlv_targoff_u.xlvu_targoff 545 546 struct xpvinvlist { 547 _XPV_HEAD; 548 IV prev_index; 549 STRLEN iterator; 550 bool is_offset; /* */ 551 }; 552 553 /* This structure works in 3 ways - regular scalar, GV with GP, or fast 554 Boyer-Moore. */ 555 struct xpvgv { 556 _XPV_HEAD; 557 union _xivu xiv_u; 558 union _xnvu xnv_u; 559 }; 560 561 typedef U32 cv_flags_t; 562 563 #define _XPVCV_COMMON \ 564 HV * xcv_stash; \ 565 union { \ 566 OP * xcv_start; \ 567 ANY xcv_xsubany; \ 568 } xcv_start_u; \ 569 union { \ 570 OP * xcv_root; \ 571 void (*xcv_xsub) (pTHX_ CV*); \ 572 } xcv_root_u; \ 573 union { \ 574 GV * xcv_gv; \ 575 HEK * xcv_hek; \ 576 } xcv_gv_u; \ 577 char * xcv_file; \ 578 PADLIST * xcv_padlist; \ 579 CV * xcv_outside; \ 580 U32 xcv_outside_seq; /* the COP sequence (at the point of our \ 581 * compilation) in the lexically enclosing \ 582 * sub */ \ 583 cv_flags_t xcv_flags; \ 584 I32 xcv_depth /* >= 2 indicates recursive call */ 585 586 /* This structure must match XPVCV in cv.h */ 587 588 struct xpvfm { 589 _XPV_HEAD; 590 _XPVCV_COMMON; 591 }; 592 593 594 struct xpvio { 595 _XPV_HEAD; 596 union _xivu xiv_u; 597 /* ifp and ofp are normally the same, but sockets need separate streams */ 598 PerlIO * xio_ofp; 599 /* Cray addresses everything by word boundaries (64 bits) and 600 * code and data pointers cannot be mixed (which is exactly what 601 * Perl_filter_add() tries to do with the dirp), hence the 602 * following union trick (as suggested by Gurusamy Sarathy). 603 * For further information see Geir Johansen's problem report 604 * titled [ID 20000612.002] Perl problem on Cray system 605 * The any pointer (known as IoANY()) will also be a good place 606 * to hang any IO disciplines to. 607 */ 608 union { 609 DIR * xiou_dirp; /* for opendir, readdir, etc */ 610 void * xiou_any; /* for alignment */ 611 } xio_dirpu; 612 /* IV xio_lines is now in IVX $. */ 613 IV xio_page; /* $% */ 614 IV xio_page_len; /* $= */ 615 IV xio_lines_left; /* $- */ 616 char * xio_top_name; /* $^ */ 617 GV * xio_top_gv; /* $^ */ 618 char * xio_fmt_name; /* $~ */ 619 GV * xio_fmt_gv; /* $~ */ 620 char * xio_bottom_name;/* $^B */ 621 GV * xio_bottom_gv; /* $^B */ 622 char xio_type; 623 U8 xio_flags; 624 }; 625 626 #define xio_dirp xio_dirpu.xiou_dirp 627 #define xio_any xio_dirpu.xiou_any 628 629 #define IOf_ARGV 1 /* this fp iterates over ARGV */ 630 #define IOf_START 2 /* check for null ARGV and substitute '-' */ 631 #define IOf_FLUSH 4 /* this fp wants a flush after write op */ 632 #define IOf_DIDTOP 8 /* just did top of form */ 633 #define IOf_UNTAINT 16 /* consider this fp (and its data) "safe" */ 634 #define IOf_NOLINE 32 /* slurped a pseudo-line from empty file */ 635 #define IOf_FAKE_DIRP 64 /* xio_dirp is fake (source filters kludge) 636 Also, when this is set, SvPVX() is valid */ 637 638 /* The following macros define implementation-independent predicates on SVs. */ 639 640 /* 641 =for apidoc Am|U32|SvNIOK|SV* sv 642 Returns a U32 value indicating whether the SV contains a number, integer or 643 double. 644 645 =for apidoc Am|U32|SvNIOKp|SV* sv 646 Returns a U32 value indicating whether the SV contains a number, integer or 647 double. Checks the B<private> setting. Use C<SvNIOK> instead. 648 649 =for apidoc Am|void|SvNIOK_off|SV* sv 650 Unsets the NV/IV status of an SV. 651 652 =for apidoc Am|U32|SvOK|SV* sv 653 Returns a U32 value indicating whether the value is defined. This is 654 only meaningful for scalars. 655 656 =for apidoc Am|U32|SvIOKp|SV* sv 657 Returns a U32 value indicating whether the SV contains an integer. Checks 658 the B<private> setting. Use C<SvIOK> instead. 659 660 =for apidoc Am|U32|SvNOKp|SV* sv 661 Returns a U32 value indicating whether the SV contains a double. Checks the 662 B<private> setting. Use C<SvNOK> instead. 663 664 =for apidoc Am|U32|SvPOKp|SV* sv 665 Returns a U32 value indicating whether the SV contains a character string. 666 Checks the B<private> setting. Use C<SvPOK> instead. 667 668 =for apidoc Am|U32|SvIOK|SV* sv 669 Returns a U32 value indicating whether the SV contains an integer. 670 671 =for apidoc Am|void|SvIOK_on|SV* sv 672 Tells an SV that it is an integer. 673 674 =for apidoc Am|void|SvIOK_off|SV* sv 675 Unsets the IV status of an SV. 676 677 =for apidoc Am|void|SvIOK_only|SV* sv 678 Tells an SV that it is an integer and disables all other OK bits. 679 680 =for apidoc Am|void|SvIOK_only_UV|SV* sv 681 Tells an SV that it is an unsigned integer and disables all other OK bits. 682 683 =for apidoc Am|bool|SvIOK_UV|SV* sv 684 Returns a boolean indicating whether the SV contains an integer that must be 685 interpreted as unsigned. A non-negative integer whose value is within the 686 range of both an IV and a UV may be be flagged as either SvUOK or SVIOK. 687 688 =for apidoc Am|bool|SvUOK|SV* sv 689 Returns a boolean indicating whether the SV contains an integer that must be 690 interpreted as unsigned. A non-negative integer whose value is within the 691 range of both an IV and a UV may be be flagged as either SvUOK or SVIOK. 692 693 =for apidoc Am|bool|SvIOK_notUV|SV* sv 694 Returns a boolean indicating whether the SV contains a signed integer. 695 696 =for apidoc Am|U32|SvNOK|SV* sv 697 Returns a U32 value indicating whether the SV contains a double. 698 699 =for apidoc Am|void|SvNOK_on|SV* sv 700 Tells an SV that it is a double. 701 702 =for apidoc Am|void|SvNOK_off|SV* sv 703 Unsets the NV status of an SV. 704 705 =for apidoc Am|void|SvNOK_only|SV* sv 706 Tells an SV that it is a double and disables all other OK bits. 707 708 =for apidoc Am|U32|SvPOK|SV* sv 709 Returns a U32 value indicating whether the SV contains a character 710 string. 711 712 =for apidoc Am|void|SvPOK_on|SV* sv 713 Tells an SV that it is a string. 714 715 =for apidoc Am|void|SvPOK_off|SV* sv 716 Unsets the PV status of an SV. 717 718 =for apidoc Am|void|SvPOK_only|SV* sv 719 Tells an SV that it is a string and disables all other OK bits. 720 Will also turn off the UTF-8 status. 721 722 =for apidoc Am|bool|SvVOK|SV* sv 723 Returns a boolean indicating whether the SV contains a v-string. 724 725 =for apidoc Am|U32|SvOOK|SV* sv 726 Returns a U32 indicating whether the pointer to the string buffer is offset. 727 This hack is used internally to speed up removal of characters from the 728 beginning of a SvPV. When SvOOK is true, then the start of the 729 allocated string buffer is actually C<SvOOK_offset()> bytes before SvPVX. 730 This offset used to be stored in SvIVX, but is now stored within the spare 731 part of the buffer. 732 733 =for apidoc Am|U32|SvROK|SV* sv 734 Tests if the SV is an RV. 735 736 =for apidoc Am|void|SvROK_on|SV* sv 737 Tells an SV that it is an RV. 738 739 =for apidoc Am|void|SvROK_off|SV* sv 740 Unsets the RV status of an SV. 741 742 =for apidoc Am|SV*|SvRV|SV* sv 743 Dereferences an RV to return the SV. 744 745 =for apidoc Am|IV|SvIVX|SV* sv 746 Returns the raw value in the SV's IV slot, without checks or conversions. 747 Only use when you are sure SvIOK is true. See also C<SvIV()>. 748 749 =for apidoc Am|UV|SvUVX|SV* sv 750 Returns the raw value in the SV's UV slot, without checks or conversions. 751 Only use when you are sure SvIOK is true. See also C<SvUV()>. 752 753 =for apidoc Am|NV|SvNVX|SV* sv 754 Returns the raw value in the SV's NV slot, without checks or conversions. 755 Only use when you are sure SvNOK is true. See also C<SvNV()>. 756 757 =for apidoc Am|char*|SvPVX|SV* sv 758 Returns a pointer to the physical string in the SV. The SV must contain a 759 string. Prior to 5.9.3 it is not safe 760 to execute this macro unless the SV's 761 type >= SVt_PV. 762 763 This is also used to store the name of an autoloaded subroutine in an XS 764 AUTOLOAD routine. See L<perlguts/Autoloading with XSUBs>. 765 766 =for apidoc Am|STRLEN|SvCUR|SV* sv 767 Returns the length of the string which is in the SV. See C<SvLEN>. 768 769 =for apidoc Am|STRLEN|SvLEN|SV* sv 770 Returns the size of the string buffer in the SV, not including any part 771 attributable to C<SvOOK>. See C<SvCUR>. 772 773 =for apidoc Am|char*|SvEND|SV* sv 774 Returns a pointer to the spot just after the last character in 775 the string which is in the SV, where there is usually a trailing 776 C<NUL> character (even though Perl scalars do not strictly require it). 777 See C<SvCUR>. Access the character as *(SvEND(sv)). 778 779 Warning: If C<SvCUR> is equal to C<SvLEN>, then C<SvEND> points to 780 unallocated memory. 781 782 =for apidoc Am|HV*|SvSTASH|SV* sv 783 Returns the stash of the SV. 784 785 =for apidoc Am|void|SvIV_set|SV* sv|IV val 786 Set the value of the IV pointer in sv to val. It is possible to perform 787 the same function of this macro with an lvalue assignment to C<SvIVX>. 788 With future Perls, however, it will be more efficient to use 789 C<SvIV_set> instead of the lvalue assignment to C<SvIVX>. 790 791 =for apidoc Am|void|SvNV_set|SV* sv|NV val 792 Set the value of the NV pointer in sv to val. See C<SvIV_set>. 793 794 =for apidoc Am|void|SvPV_set|SV* sv|char* val 795 This is probably not what you want to use, you probably wanted 796 L</sv_usepvn_flags> or L</sv_setpvn> or L</sv_setpvs>. 797 798 Set the value of the PV pointer in C<sv> to the Perl allocated 799 C<NUL>-terminated string C<val>. See also C<SvIV_set>. 800 801 Remember to free the previous PV buffer. There are many things to check. 802 Beware that the existing pointer may be involved in copy-on-write or other 803 mischief, so do C<SvOOK_off(sv)> and use C<sv_force_normal> or 804 C<SvPV_force> (or check the SvIsCOW flag) first to make sure this 805 modification is safe. Then finally, if it is not a COW, call C<SvPV_free> to 806 free the previous PV buffer. 807 808 =for apidoc Am|void|SvUV_set|SV* sv|UV val 809 Set the value of the UV pointer in sv to val. See C<SvIV_set>. 810 811 =for apidoc Am|void|SvRV_set|SV* sv|SV* val 812 Set the value of the RV pointer in sv to val. See C<SvIV_set>. 813 814 =for apidoc Am|void|SvMAGIC_set|SV* sv|MAGIC* val 815 Set the value of the MAGIC pointer in sv to val. See C<SvIV_set>. 816 817 =for apidoc Am|void|SvSTASH_set|SV* sv|HV* val 818 Set the value of the STASH pointer in sv to val. See C<SvIV_set>. 819 820 =for apidoc Am|void|SvCUR_set|SV* sv|STRLEN len 821 Set the current length of the string which is in the SV. See C<SvCUR> 822 and C<SvIV_set>. 823 824 =for apidoc Am|void|SvLEN_set|SV* sv|STRLEN len 825 Set the actual length of the string which is in the SV. See C<SvIV_set>. 826 827 =cut 828 */ 829 830 #define SvNIOK(sv) (SvFLAGS(sv) & (SVf_IOK|SVf_NOK)) 831 #define SvNIOKp(sv) (SvFLAGS(sv) & (SVp_IOK|SVp_NOK)) 832 #define SvNIOK_off(sv) (SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK| \ 833 SVp_IOK|SVp_NOK|SVf_IVisUV)) 834 835 #define assert_not_ROK(sv) assert_(!SvROK(sv) || !SvRV(sv)) 836 #define assert_not_glob(sv) assert_(!isGV_with_GP(sv)) 837 838 #define SvOK(sv) (SvFLAGS(sv) & SVf_OK || isREGEXP(sv)) 839 #define SvOK_off(sv) (assert_not_ROK(sv) assert_not_glob(sv) \ 840 SvFLAGS(sv) &= ~(SVf_OK| \ 841 SVf_IVisUV|SVf_UTF8), \ 842 SvOOK_off(sv)) 843 #define SvOK_off_exc_UV(sv) (assert_not_ROK(sv) \ 844 SvFLAGS(sv) &= ~(SVf_OK| \ 845 SVf_UTF8), \ 846 SvOOK_off(sv)) 847 848 #define SvOKp(sv) (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK)) 849 #define SvIOKp(sv) (SvFLAGS(sv) & SVp_IOK) 850 #define SvIOKp_on(sv) (assert_not_glob(sv) SvRELEASE_IVX_(sv) \ 851 SvFLAGS(sv) |= SVp_IOK) 852 #define SvNOKp(sv) (SvFLAGS(sv) & SVp_NOK) 853 #define SvNOKp_on(sv) (assert_not_glob(sv) SvFLAGS(sv) |= SVp_NOK) 854 #define SvPOKp(sv) (SvFLAGS(sv) & SVp_POK) 855 #define SvPOKp_on(sv) (assert_not_ROK(sv) assert_not_glob(sv) \ 856 SvFLAGS(sv) |= SVp_POK) 857 858 #define SvIOK(sv) (SvFLAGS(sv) & SVf_IOK) 859 #define SvIOK_on(sv) (assert_not_glob(sv) SvRELEASE_IVX_(sv) \ 860 SvFLAGS(sv) |= (SVf_IOK|SVp_IOK)) 861 #define SvIOK_off(sv) (SvFLAGS(sv) &= ~(SVf_IOK|SVp_IOK|SVf_IVisUV)) 862 #define SvIOK_only(sv) (SvOK_off(sv), \ 863 SvFLAGS(sv) |= (SVf_IOK|SVp_IOK)) 864 #define SvIOK_only_UV(sv) (assert_not_glob(sv) SvOK_off_exc_UV(sv), \ 865 SvFLAGS(sv) |= (SVf_IOK|SVp_IOK)) 866 867 #define SvIOK_UV(sv) ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV)) \ 868 == (SVf_IOK|SVf_IVisUV)) 869 #define SvUOK(sv) SvIOK_UV(sv) 870 #define SvIOK_notUV(sv) ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV)) \ 871 == SVf_IOK) 872 873 #define SvIsUV(sv) (SvFLAGS(sv) & SVf_IVisUV) 874 #define SvIsUV_on(sv) (SvFLAGS(sv) |= SVf_IVisUV) 875 #define SvIsUV_off(sv) (SvFLAGS(sv) &= ~SVf_IVisUV) 876 877 #define SvNOK(sv) (SvFLAGS(sv) & SVf_NOK) 878 #define SvNOK_on(sv) (assert_not_glob(sv) \ 879 SvFLAGS(sv) |= (SVf_NOK|SVp_NOK)) 880 #define SvNOK_off(sv) (SvFLAGS(sv) &= ~(SVf_NOK|SVp_NOK)) 881 #define SvNOK_only(sv) (SvOK_off(sv), \ 882 SvFLAGS(sv) |= (SVf_NOK|SVp_NOK)) 883 884 /* 885 =for apidoc Am|U32|SvUTF8|SV* sv 886 Returns a U32 value indicating the UTF-8 status of an SV. If things are set-up 887 properly, this indicates whether or not the SV contains UTF-8 encoded data. 888 You should use this I<after> a call to SvPV() or one of its variants, in 889 case any call to string overloading updates the internal flag. 890 891 =for apidoc Am|void|SvUTF8_on|SV *sv 892 Turn on the UTF-8 status of an SV (the data is not changed, just the flag). 893 Do not use frivolously. 894 895 =for apidoc Am|void|SvUTF8_off|SV *sv 896 Unsets the UTF-8 status of an SV (the data is not changed, just the flag). 897 Do not use frivolously. 898 899 =for apidoc Am|void|SvPOK_only_UTF8|SV* sv 900 Tells an SV that it is a string and disables all other OK bits, 901 and leaves the UTF-8 status as it was. 902 903 =cut 904 */ 905 906 /* Ensure the return value of this macro does not clash with the GV_ADD* flags 907 in gv.h: */ 908 #define SvUTF8(sv) (SvFLAGS(sv) & SVf_UTF8) 909 #define SvUTF8_on(sv) (SvFLAGS(sv) |= (SVf_UTF8)) 910 #define SvUTF8_off(sv) (SvFLAGS(sv) &= ~(SVf_UTF8)) 911 912 #define SvPOK(sv) (SvFLAGS(sv) & SVf_POK) 913 #define SvPOK_on(sv) (assert_not_ROK(sv) assert_not_glob(sv) \ 914 SvFLAGS(sv) |= (SVf_POK|SVp_POK)) 915 #define SvPOK_off(sv) (SvFLAGS(sv) &= ~(SVf_POK|SVp_POK)) 916 #define SvPOK_only(sv) (assert_not_ROK(sv) assert_not_glob(sv) \ 917 SvFLAGS(sv) &= ~(SVf_OK| \ 918 SVf_IVisUV|SVf_UTF8), \ 919 SvFLAGS(sv) |= (SVf_POK|SVp_POK)) 920 #define SvPOK_only_UTF8(sv) (assert_not_ROK(sv) assert_not_glob(sv) \ 921 SvFLAGS(sv) &= ~(SVf_OK| \ 922 SVf_IVisUV), \ 923 SvFLAGS(sv) |= (SVf_POK|SVp_POK)) 924 925 #define SvVOK(sv) (SvMAGICAL(sv) \ 926 && mg_find(sv,PERL_MAGIC_vstring)) 927 /* returns the vstring magic, if any */ 928 #define SvVSTRING_mg(sv) (SvMAGICAL(sv) \ 929 ? mg_find(sv,PERL_MAGIC_vstring) : NULL) 930 931 #define SvOOK(sv) (SvFLAGS(sv) & SVf_OOK) 932 #define SvOOK_on(sv) (SvFLAGS(sv) |= SVf_OOK) 933 #define SvOOK_off(sv) ((void)(SvOOK(sv) && sv_backoff(sv))) 934 935 #define SvFAKE(sv) (SvFLAGS(sv) & SVf_FAKE) 936 #define SvFAKE_on(sv) (SvFLAGS(sv) |= SVf_FAKE) 937 #define SvFAKE_off(sv) (SvFLAGS(sv) &= ~SVf_FAKE) 938 939 #define SvROK(sv) (SvFLAGS(sv) & SVf_ROK) 940 #define SvROK_on(sv) (SvFLAGS(sv) |= SVf_ROK) 941 #define SvROK_off(sv) (SvFLAGS(sv) &= ~(SVf_ROK)) 942 943 #define SvMAGICAL(sv) (SvFLAGS(sv) & (SVs_GMG|SVs_SMG|SVs_RMG)) 944 #define SvMAGICAL_on(sv) (SvFLAGS(sv) |= (SVs_GMG|SVs_SMG|SVs_RMG)) 945 #define SvMAGICAL_off(sv) (SvFLAGS(sv) &= ~(SVs_GMG|SVs_SMG|SVs_RMG)) 946 947 #define SvGMAGICAL(sv) (SvFLAGS(sv) & SVs_GMG) 948 #define SvGMAGICAL_on(sv) (SvFLAGS(sv) |= SVs_GMG) 949 #define SvGMAGICAL_off(sv) (SvFLAGS(sv) &= ~SVs_GMG) 950 951 #define SvSMAGICAL(sv) (SvFLAGS(sv) & SVs_SMG) 952 #define SvSMAGICAL_on(sv) (SvFLAGS(sv) |= SVs_SMG) 953 #define SvSMAGICAL_off(sv) (SvFLAGS(sv) &= ~SVs_SMG) 954 955 #define SvRMAGICAL(sv) (SvFLAGS(sv) & SVs_RMG) 956 #define SvRMAGICAL_on(sv) (SvFLAGS(sv) |= SVs_RMG) 957 #define SvRMAGICAL_off(sv) (SvFLAGS(sv) &= ~SVs_RMG) 958 959 #define SvAMAGIC(sv) (SvROK(sv) && SvOBJECT(SvRV(sv)) && \ 960 HvAMAGIC(SvSTASH(SvRV(sv)))) 961 962 /* To be used on the stashes themselves: */ 963 #define HvAMAGIC(hv) (SvFLAGS(hv) & SVf_AMAGIC) 964 #define HvAMAGIC_on(hv) (SvFLAGS(hv) |= SVf_AMAGIC) 965 #define HvAMAGIC_off(hv) (SvFLAGS(hv) &=~ SVf_AMAGIC) 966 967 968 /* "nog" means "doesn't have get magic" */ 969 #define SvPOK_nog(sv) ((SvFLAGS(sv) & (SVf_POK|SVs_GMG)) == SVf_POK) 970 #define SvIOK_nog(sv) ((SvFLAGS(sv) & (SVf_IOK|SVs_GMG)) == SVf_IOK) 971 #define SvUOK_nog(sv) ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV|SVs_GMG)) == (SVf_IOK|SVf_IVisUV)) 972 #define SvNOK_nog(sv) ((SvFLAGS(sv) & (SVf_NOK|SVs_GMG)) == SVf_NOK) 973 #define SvNIOK_nog(sv) (SvNIOK(sv) && !(SvFLAGS(sv) & SVs_GMG)) 974 975 #define SvPOK_nogthink(sv) ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST|SVs_GMG)) == SVf_POK) 976 #define SvIOK_nogthink(sv) ((SvFLAGS(sv) & (SVf_IOK|SVf_THINKFIRST|SVs_GMG)) == SVf_IOK) 977 #define SvUOK_nogthink(sv) ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV|SVf_THINKFIRST|SVs_GMG)) == (SVf_IOK|SVf_IVisUV)) 978 #define SvNOK_nogthink(sv) ((SvFLAGS(sv) & (SVf_NOK|SVf_THINKFIRST|SVs_GMG)) == SVf_NOK) 979 #define SvNIOK_nogthink(sv) (SvNIOK(sv) && !(SvFLAGS(sv) & (SVf_THINKFIRST|SVs_GMG))) 980 981 #define SvPOK_utf8_nog(sv) ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVs_GMG)) == (SVf_POK|SVf_UTF8)) 982 #define SvPOK_utf8_nogthink(sv) ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_THINKFIRST|SVs_GMG)) == (SVf_POK|SVf_UTF8)) 983 984 #define SvPOK_byte_nog(sv) ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVs_GMG)) == SVf_POK) 985 #define SvPOK_byte_nogthink(sv) ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_THINKFIRST|SVs_GMG)) == SVf_POK) 986 987 #define SvPOK_pure_nogthink(sv) \ 988 ((SvFLAGS(sv) & (SVf_POK|SVf_IOK|SVf_NOK|SVf_ROK|SVpgv_GP|SVf_THINKFIRST|SVs_GMG)) == SVf_POK) 989 #define SvPOK_utf8_pure_nogthink(sv) \ 990 ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_IOK|SVf_NOK|SVf_ROK|SVpgv_GP|SVf_THINKFIRST|SVs_GMG)) == (SVf_POK|SVf_UTF8)) 991 #define SvPOK_byte_pure_nogthink(sv) \ 992 ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_IOK|SVf_NOK|SVf_ROK|SVpgv_GP|SVf_THINKFIRST|SVs_GMG)) == SVf_POK) 993 994 /* 995 =for apidoc Am|U32|SvGAMAGIC|SV* sv 996 997 Returns true if the SV has get magic or 998 overloading. If either is true then 999 the scalar is active data, and has the potential to return a new value every 1000 time it is accessed. Hence you must be careful to 1001 only read it once per user logical operation and work 1002 with that returned value. If neither is true then 1003 the scalar's value cannot change unless written to. 1004 1005 =cut 1006 */ 1007 1008 #define SvGAMAGIC(sv) (SvGMAGICAL(sv) || SvAMAGIC(sv)) 1009 1010 #define Gv_AMG(stash) \ 1011 (HvNAME(stash) && Gv_AMupdate(stash,FALSE) \ 1012 ? 1 \ 1013 : (HvAMAGIC_off(stash), 0)) 1014 1015 #define SvWEAKREF(sv) ((SvFLAGS(sv) & (SVf_ROK|SVprv_WEAKREF)) \ 1016 == (SVf_ROK|SVprv_WEAKREF)) 1017 #define SvWEAKREF_on(sv) (SvFLAGS(sv) |= (SVf_ROK|SVprv_WEAKREF)) 1018 #define SvWEAKREF_off(sv) (SvFLAGS(sv) &= ~(SVf_ROK|SVprv_WEAKREF)) 1019 1020 #define SvPCS_IMPORTED(sv) ((SvFLAGS(sv) & (SVf_ROK|SVprv_PCS_IMPORTED)) \ 1021 == (SVf_ROK|SVprv_PCS_IMPORTED)) 1022 #define SvPCS_IMPORTED_on(sv) (SvFLAGS(sv) |= (SVf_ROK|SVprv_PCS_IMPORTED)) 1023 #define SvPCS_IMPORTED_off(sv) (SvFLAGS(sv) &= ~(SVf_ROK|SVprv_PCS_IMPORTED)) 1024 1025 /* 1026 =for apidoc m|U32|SvTHINKFIRST|SV *sv 1027 1028 A quick flag check to see whether an sv should be passed to sv_force_normal 1029 to be "downgraded" before SvIVX or SvPVX can be modified directly. 1030 1031 For example, if your scalar is a reference and you want to modify the SvIVX 1032 slot, you can't just do SvROK_off, as that will leak the referent. 1033 1034 This is used internally by various sv-modifying functions, such as 1035 sv_setsv, sv_setiv and sv_pvn_force. 1036 1037 One case that this does not handle is a gv without SvFAKE set. After 1038 1039 if (SvTHINKFIRST(gv)) sv_force_normal(gv); 1040 1041 it will still be a gv. 1042 1043 SvTHINKFIRST sometimes produces false positives. In those cases 1044 sv_force_normal does nothing. 1045 1046 =cut 1047 */ 1048 1049 #define SvTHINKFIRST(sv) (SvFLAGS(sv) & SVf_THINKFIRST) 1050 1051 #define SvPADMY(sv) (SvFLAGS(sv) & SVs_PADMY) 1052 #define SvPADMY_on(sv) (SvFLAGS(sv) |= SVs_PADMY) 1053 1054 /* SVs_PADTMP and SVs_PADSTALE share the same bit, mediated by SVs_PADMY */ 1055 1056 #define SvPADTMP(sv) ((SvFLAGS(sv) & (SVs_PADMY|SVs_PADTMP)) == SVs_PADTMP) 1057 #define SvPADSTALE(sv) ((SvFLAGS(sv) & (SVs_PADMY|SVs_PADSTALE)) \ 1058 == (SVs_PADMY|SVs_PADSTALE)) 1059 1060 #define SvPADTMP_on(sv) S_SvPADTMP_on(MUTABLE_SV(sv)) 1061 #define SvPADTMP_off(sv) S_SvPADTMP_off(MUTABLE_SV(sv)) 1062 #define SvPADSTALE_on(sv) S_SvPADSTALE_on(MUTABLE_SV(sv)) 1063 #define SvPADSTALE_off(sv) S_SvPADSTALE_off(MUTABLE_SV(sv)) 1064 1065 #define SvTEMP(sv) (SvFLAGS(sv) & SVs_TEMP) 1066 #define SvTEMP_on(sv) (SvFLAGS(sv) |= SVs_TEMP) 1067 #define SvTEMP_off(sv) (SvFLAGS(sv) &= ~SVs_TEMP) 1068 1069 #define SvOBJECT(sv) (SvFLAGS(sv) & SVs_OBJECT) 1070 #define SvOBJECT_on(sv) (SvFLAGS(sv) |= SVs_OBJECT) 1071 #define SvOBJECT_off(sv) (SvFLAGS(sv) &= ~SVs_OBJECT) 1072 1073 #define SvREADONLY(sv) (SvFLAGS(sv) & SVf_READONLY) 1074 #define SvREADONLY_on(sv) (SvFLAGS(sv) |= SVf_READONLY) 1075 #define SvREADONLY_off(sv) (SvFLAGS(sv) &= ~SVf_READONLY) 1076 1077 #define SvSCREAM(sv) ((SvFLAGS(sv) & (SVp_SCREAM|SVp_POK)) == (SVp_SCREAM|SVp_POK)) 1078 #define SvSCREAM_on(sv) (SvFLAGS(sv) |= SVp_SCREAM) 1079 #define SvSCREAM_off(sv) (SvFLAGS(sv) &= ~SVp_SCREAM) 1080 1081 #ifndef PERL_CORE 1082 # define SvCOMPILED(sv) 0 1083 # define SvCOMPILED_on(sv) 1084 # define SvCOMPILED_off(sv) 1085 #endif 1086 1087 #define SvEVALED(sv) (SvFLAGS(sv) & SVrepl_EVAL) 1088 #define SvEVALED_on(sv) (SvFLAGS(sv) |= SVrepl_EVAL) 1089 #define SvEVALED_off(sv) (SvFLAGS(sv) &= ~SVrepl_EVAL) 1090 1091 #if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) 1092 # define SvVALID(sv) ({ const SV *const _svvalid = (const SV*)(sv); \ 1093 if (SvFLAGS(_svvalid) & SVpbm_VALID && !SvSCREAM(_svvalid)) \ 1094 assert(!isGV_with_GP(_svvalid)); \ 1095 (SvFLAGS(_svvalid) & SVpbm_VALID); \ 1096 }) 1097 # define SvVALID_on(sv) ({ SV *const _svvalid = MUTABLE_SV(sv); \ 1098 assert(!isGV_with_GP(_svvalid)); \ 1099 assert(!SvSCREAM(_svvalid)); \ 1100 (SvFLAGS(_svvalid) |= SVpbm_VALID); \ 1101 }) 1102 # define SvVALID_off(sv) ({ SV *const _svvalid = MUTABLE_SV(sv); \ 1103 assert(!isGV_with_GP(_svvalid)); \ 1104 assert(!SvSCREAM(_svvalid)); \ 1105 (SvFLAGS(_svvalid) &= ~SVpbm_VALID); \ 1106 }) 1107 1108 # define SvTAIL(sv) ({ const SV *const _svtail = (const SV *)(sv); \ 1109 assert(SvTYPE(_svtail) != SVt_PVAV); \ 1110 assert(SvTYPE(_svtail) != SVt_PVHV); \ 1111 assert(!SvSCREAM(_svtail)); \ 1112 (SvFLAGS(sv) & (SVpbm_TAIL|SVpbm_VALID)) \ 1113 == (SVpbm_TAIL|SVpbm_VALID); \ 1114 }) 1115 #else 1116 # define SvVALID(sv) ((SvFLAGS(sv) & SVpbm_VALID) && !SvSCREAM(sv)) 1117 # define SvVALID_on(sv) (SvFLAGS(sv) |= SVpbm_VALID) 1118 # define SvVALID_off(sv) (SvFLAGS(sv) &= ~SVpbm_VALID) 1119 # define SvTAIL(sv) ((SvFLAGS(sv) & (SVpbm_TAIL|SVpbm_VALID)) \ 1120 == (SVpbm_TAIL|SVpbm_VALID)) 1121 1122 #endif 1123 #define SvTAIL_on(sv) (SvFLAGS(sv) |= SVpbm_TAIL) 1124 #define SvTAIL_off(sv) (SvFLAGS(sv) &= ~SVpbm_TAIL) 1125 1126 1127 #define SvPAD_TYPED(sv) \ 1128 ((SvFLAGS(sv) & (SVpad_NAME|SVpad_TYPED)) == (SVpad_NAME|SVpad_TYPED)) 1129 1130 #define SvPAD_OUR(sv) \ 1131 ((SvFLAGS(sv) & (SVpad_NAME|SVpad_OUR)) == (SVpad_NAME|SVpad_OUR)) 1132 1133 #define SvPAD_STATE(sv) \ 1134 ((SvFLAGS(sv) & (SVpad_NAME|SVpad_STATE)) == (SVpad_NAME|SVpad_STATE)) 1135 1136 #if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) 1137 # define SvPAD_TYPED_on(sv) ({ \ 1138 SV *const _svpad = MUTABLE_SV(sv); \ 1139 assert(SvTYPE(_svpad) == SVt_PVMG); \ 1140 (SvFLAGS(_svpad) |= SVpad_NAME|SVpad_TYPED); \ 1141 }) 1142 #define SvPAD_OUR_on(sv) ({ \ 1143 SV *const _svpad = MUTABLE_SV(sv); \ 1144 assert(SvTYPE(_svpad) == SVt_PVMG); \ 1145 (SvFLAGS(_svpad) |= SVpad_NAME|SVpad_OUR); \ 1146 }) 1147 #define SvPAD_STATE_on(sv) ({ \ 1148 SV *const _svpad = MUTABLE_SV(sv); \ 1149 assert(SvTYPE(_svpad) == SVt_PVNV || SvTYPE(_svpad) == SVt_PVMG); \ 1150 (SvFLAGS(_svpad) |= SVpad_NAME|SVpad_STATE); \ 1151 }) 1152 #else 1153 # define SvPAD_TYPED_on(sv) (SvFLAGS(sv) |= SVpad_NAME|SVpad_TYPED) 1154 # define SvPAD_OUR_on(sv) (SvFLAGS(sv) |= SVpad_NAME|SVpad_OUR) 1155 # define SvPAD_STATE_on(sv) (SvFLAGS(sv) |= SVpad_NAME|SVpad_STATE) 1156 #endif 1157 1158 #define SvOURSTASH(sv) \ 1159 (SvPAD_OUR(sv) ? ((XPVMG*) SvANY(sv))->xmg_u.xmg_ourstash : NULL) 1160 #define SvOURSTASH_set(sv, st) \ 1161 STMT_START { \ 1162 assert(SvTYPE(sv) == SVt_PVMG); \ 1163 ((XPVMG*) SvANY(sv))->xmg_u.xmg_ourstash = st; \ 1164 } STMT_END 1165 1166 #define SvRVx(sv) SvRV(sv) 1167 1168 #ifdef PERL_DEBUG_COW 1169 /* Need -0.0 for SvNVX to preserve IEEE FP "negative zero" because 1170 +0.0 + -0.0 => +0.0 but -0.0 + -0.0 => -0.0 */ 1171 # define SvIVX(sv) (0 + ((XPVIV*) SvANY(sv))->xiv_iv) 1172 # define SvUVX(sv) (0 + ((XPVUV*) SvANY(sv))->xuv_uv) 1173 # define SvNVX(sv) (-0.0 + ((XPVNV*) SvANY(sv))->xnv_u.xnv_nv) 1174 # define SvRV(sv) (0 + (sv)->sv_u.svu_rv) 1175 # define SvRV_const(sv) (0 + (sv)->sv_u.svu_rv) 1176 /* Don't test the core XS code yet. */ 1177 # if defined (PERL_CORE) && PERL_DEBUG_COW > 1 1178 # define SvPVX(sv) (0 + (assert_(!SvREADONLY(sv)) (sv)->sv_u.svu_pv)) 1179 # else 1180 # define SvPVX(sv) SvPVX_mutable(sv) 1181 # endif 1182 # define SvCUR(sv) (0 + ((XPV*) SvANY(sv))->xpv_cur) 1183 # define SvLEN(sv) (0 + ((XPV*) SvANY(sv))->xpv_len) 1184 # define SvEND(sv) ((sv)->sv_u.svu_pv + ((XPV*)SvANY(sv))->xpv_cur) 1185 1186 # define SvMAGIC(sv) (0 + *(assert_(SvTYPE(sv) >= SVt_PVMG) &((XPVMG*) SvANY(sv))->xmg_u.xmg_magic)) 1187 # define SvSTASH(sv) (0 + *(assert_(SvTYPE(sv) >= SVt_PVMG) &((XPVMG*) SvANY(sv))->xmg_stash)) 1188 #else 1189 # define SvLEN(sv) ((XPV*) SvANY(sv))->xpv_len 1190 # define SvEND(sv) ((sv)->sv_u.svu_pv + ((XPV*)SvANY(sv))->xpv_cur) 1191 1192 # if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) 1193 /* These get expanded inside other macros that already use a variable _sv */ 1194 # define SvPVX(sv) \ 1195 (*({ SV *const _svpvx = MUTABLE_SV(sv); \ 1196 assert(PL_valid_types_PVX[SvTYPE(_svpvx) & SVt_MASK]); \ 1197 assert(!isGV_with_GP(_svpvx)); \ 1198 assert(!(SvTYPE(_svpvx) == SVt_PVIO \ 1199 && !(IoFLAGS(_svpvx) & IOf_FAKE_DIRP))); \ 1200 &((_svpvx)->sv_u.svu_pv); \ 1201 })) 1202 # define SvCUR(sv) \ 1203 (*({ const SV *const _svcur = (const SV *)(sv); \ 1204 assert(PL_valid_types_PVX[SvTYPE(_svcur) & SVt_MASK] \ 1205 || SvTYPE(_svcur) == SVt_REGEXP); \ 1206 assert(!isGV_with_GP(_svcur)); \ 1207 assert(!(SvTYPE(_svcur) == SVt_PVIO \ 1208 && !(IoFLAGS(_svcur) & IOf_FAKE_DIRP))); \ 1209 &(((XPV*) MUTABLE_PTR(SvANY(_svcur)))->xpv_cur); \ 1210 })) 1211 # define SvIVX(sv) \ 1212 (*({ const SV *const _svivx = (const SV *)(sv); \ 1213 assert(PL_valid_types_IVX[SvTYPE(_svivx) & SVt_MASK]); \ 1214 assert(!isGV_with_GP(_svivx)); \ 1215 &(((XPVIV*) MUTABLE_PTR(SvANY(_svivx)))->xiv_iv); \ 1216 })) 1217 # define SvUVX(sv) \ 1218 (*({ const SV *const _svuvx = (const SV *)(sv); \ 1219 assert(PL_valid_types_IVX[SvTYPE(_svuvx) & SVt_MASK]); \ 1220 assert(!isGV_with_GP(_svuvx)); \ 1221 &(((XPVUV*) MUTABLE_PTR(SvANY(_svuvx)))->xuv_uv); \ 1222 })) 1223 # define SvNVX(sv) \ 1224 (*({ const SV *const _svnvx = (const SV *)(sv); \ 1225 assert(PL_valid_types_NVX[SvTYPE(_svnvx) & SVt_MASK]); \ 1226 assert(!isGV_with_GP(_svnvx)); \ 1227 &(((XPVNV*) MUTABLE_PTR(SvANY(_svnvx)))->xnv_u.xnv_nv); \ 1228 })) 1229 # define SvRV(sv) \ 1230 (*({ SV *const _svrv = MUTABLE_SV(sv); \ 1231 assert(PL_valid_types_RV[SvTYPE(_svrv) & SVt_MASK]); \ 1232 assert(!isGV_with_GP(_svrv)); \ 1233 assert(!(SvTYPE(_svrv) == SVt_PVIO \ 1234 && !(IoFLAGS(_svrv) & IOf_FAKE_DIRP))); \ 1235 &((_svrv)->sv_u.svu_rv); \ 1236 })) 1237 # define SvRV_const(sv) \ 1238 ({ const SV *const _svrv = (const SV *)(sv); \ 1239 assert(PL_valid_types_RV[SvTYPE(_svrv) & SVt_MASK]); \ 1240 assert(!isGV_with_GP(_svrv)); \ 1241 assert(!(SvTYPE(_svrv) == SVt_PVIO \ 1242 && !(IoFLAGS(_svrv) & IOf_FAKE_DIRP))); \ 1243 (_svrv)->sv_u.svu_rv; \ 1244 }) 1245 # define SvMAGIC(sv) \ 1246 (*({ const SV *const _svmagic = (const SV *)(sv); \ 1247 assert(SvTYPE(_svmagic) >= SVt_PVMG); \ 1248 if(SvTYPE(_svmagic) == SVt_PVMG) \ 1249 assert(!SvPAD_OUR(_svmagic)); \ 1250 &(((XPVMG*) MUTABLE_PTR(SvANY(_svmagic)))->xmg_u.xmg_magic); \ 1251 })) 1252 # define SvSTASH(sv) \ 1253 (*({ const SV *const _svstash = (const SV *)(sv); \ 1254 assert(SvTYPE(_svstash) >= SVt_PVMG); \ 1255 &(((XPVMG*) MUTABLE_PTR(SvANY(_svstash)))->xmg_stash); \ 1256 })) 1257 # else 1258 # define SvPVX(sv) ((sv)->sv_u.svu_pv) 1259 # define SvCUR(sv) ((XPV*) SvANY(sv))->xpv_cur 1260 # define SvIVX(sv) ((XPVIV*) SvANY(sv))->xiv_iv 1261 # define SvUVX(sv) ((XPVUV*) SvANY(sv))->xuv_uv 1262 # define SvNVX(sv) ((XPVNV*) SvANY(sv))->xnv_u.xnv_nv 1263 # define SvRV(sv) ((sv)->sv_u.svu_rv) 1264 # define SvRV_const(sv) (0 + (sv)->sv_u.svu_rv) 1265 # define SvMAGIC(sv) ((XPVMG*) SvANY(sv))->xmg_u.xmg_magic 1266 # define SvSTASH(sv) ((XPVMG*) SvANY(sv))->xmg_stash 1267 # endif 1268 #endif 1269 1270 #ifndef PERL_POISON 1271 /* Given that these two are new, there can't be any existing code using them 1272 * as LVALUEs */ 1273 # define SvPVX_mutable(sv) (0 + (sv)->sv_u.svu_pv) 1274 # define SvPVX_const(sv) ((const char*)(0 + (sv)->sv_u.svu_pv)) 1275 #else 1276 /* Except for the poison code, which uses & to scribble over the pointer after 1277 free() is called. */ 1278 # define SvPVX_mutable(sv) ((sv)->sv_u.svu_pv) 1279 # define SvPVX_const(sv) ((const char*)((sv)->sv_u.svu_pv)) 1280 #endif 1281 1282 #define SvIVXx(sv) SvIVX(sv) 1283 #define SvUVXx(sv) SvUVX(sv) 1284 #define SvNVXx(sv) SvNVX(sv) 1285 #define SvPVXx(sv) SvPVX(sv) 1286 #define SvLENx(sv) SvLEN(sv) 1287 #define SvENDx(sv) ((PL_Sv = (sv)), SvEND(PL_Sv)) 1288 1289 1290 /* Ask a scalar nicely to try to become an IV, if possible. 1291 Not guaranteed to stay returning void */ 1292 /* Macro won't actually call sv_2iv if already IOK */ 1293 #define SvIV_please(sv) \ 1294 STMT_START {if (!SvIOKp(sv) && (SvNOK(sv) || SvPOK(sv))) \ 1295 (void) SvIV(sv); } STMT_END 1296 #define SvIV_please_nomg(sv) \ 1297 (!SvIOKp(sv) && (SvNOK(sv) || SvPOK(sv)) \ 1298 ? (SvIV_nomg(sv), SvIOK(sv)) \ 1299 : SvIOK(sv)) 1300 #define SvIV_set(sv, val) \ 1301 STMT_START { \ 1302 assert(PL_valid_types_IV_set[SvTYPE(sv) & SVt_MASK]); \ 1303 assert(!isGV_with_GP(sv)); \ 1304 (((XPVIV*) SvANY(sv))->xiv_iv = (val)); } STMT_END 1305 #define SvNV_set(sv, val) \ 1306 STMT_START { \ 1307 assert(PL_valid_types_NV_set[SvTYPE(sv) & SVt_MASK]); \ 1308 assert(!isGV_with_GP(sv)); \ 1309 (((XPVNV*)SvANY(sv))->xnv_u.xnv_nv = (val)); } STMT_END 1310 #define SvPV_set(sv, val) \ 1311 STMT_START { \ 1312 assert(PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]); \ 1313 assert(!isGV_with_GP(sv)); \ 1314 assert(!(SvTYPE(sv) == SVt_PVIO \ 1315 && !(IoFLAGS(sv) & IOf_FAKE_DIRP))); \ 1316 ((sv)->sv_u.svu_pv = (val)); } STMT_END 1317 #define SvUV_set(sv, val) \ 1318 STMT_START { \ 1319 assert(PL_valid_types_IV_set[SvTYPE(sv) & SVt_MASK]); \ 1320 assert(!isGV_with_GP(sv)); \ 1321 (((XPVUV*)SvANY(sv))->xuv_uv = (val)); } STMT_END 1322 #define SvRV_set(sv, val) \ 1323 STMT_START { \ 1324 assert(PL_valid_types_RV[SvTYPE(sv) & SVt_MASK]); \ 1325 assert(!isGV_with_GP(sv)); \ 1326 assert(!(SvTYPE(sv) == SVt_PVIO \ 1327 && !(IoFLAGS(sv) & IOf_FAKE_DIRP))); \ 1328 ((sv)->sv_u.svu_rv = (val)); } STMT_END 1329 #define SvMAGIC_set(sv, val) \ 1330 STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \ 1331 (((XPVMG*)SvANY(sv))->xmg_u.xmg_magic = (val)); } STMT_END 1332 #define SvSTASH_set(sv, val) \ 1333 STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \ 1334 (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END 1335 #define SvCUR_set(sv, val) \ 1336 STMT_START { \ 1337 assert(PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK] \ 1338 || SvTYPE(sv) == SVt_REGEXP); \ 1339 assert(!isGV_with_GP(sv)); \ 1340 assert(!(SvTYPE(sv) == SVt_PVIO \ 1341 && !(IoFLAGS(sv) & IOf_FAKE_DIRP))); \ 1342 (((XPV*) SvANY(sv))->xpv_cur = (val)); } STMT_END 1343 #define SvLEN_set(sv, val) \ 1344 STMT_START { \ 1345 assert(PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]); \ 1346 assert(!isGV_with_GP(sv)); \ 1347 assert(!(SvTYPE(sv) == SVt_PVIO \ 1348 && !(IoFLAGS(sv) & IOf_FAKE_DIRP))); \ 1349 (((XPV*) SvANY(sv))->xpv_len = (val)); } STMT_END 1350 #define SvEND_set(sv, val) \ 1351 STMT_START { assert(SvTYPE(sv) >= SVt_PV); \ 1352 SvCUR_set(sv, (val) - SvPVX(sv)); } STMT_END 1353 1354 #define SvPV_renew(sv,n) \ 1355 STMT_START { SvLEN_set(sv, n); \ 1356 SvPV_set((sv), (MEM_WRAP_CHECK_(n,char) \ 1357 (char*)saferealloc((Malloc_t)SvPVX(sv), \ 1358 (MEM_SIZE)((n))))); \ 1359 } STMT_END 1360 1361 #define SvPV_shrink_to_cur(sv) STMT_START { \ 1362 const STRLEN _lEnGtH = SvCUR(sv) + 1; \ 1363 SvPV_renew(sv, _lEnGtH); \ 1364 } STMT_END 1365 1366 #define SvPV_free(sv) \ 1367 STMT_START { \ 1368 assert(SvTYPE(sv) >= SVt_PV); \ 1369 if (SvLEN(sv)) { \ 1370 assert(!SvROK(sv)); \ 1371 if(UNLIKELY(SvOOK(sv))) { \ 1372 STRLEN zok; \ 1373 SvOOK_offset(sv, zok); \ 1374 SvPV_set(sv, SvPVX_mutable(sv) - zok); \ 1375 SvFLAGS(sv) &= ~SVf_OOK; \ 1376 } \ 1377 Safefree(SvPVX(sv)); \ 1378 } \ 1379 } STMT_END 1380 1381 #ifdef PERL_CORE 1382 /* Code that crops up in three places to take a scalar and ready it to hold 1383 a reference */ 1384 # define prepare_SV_for_RV(sv) \ 1385 STMT_START { \ 1386 if (SvTYPE(sv) < SVt_PV && SvTYPE(sv) != SVt_IV) \ 1387 sv_upgrade(sv, SVt_IV); \ 1388 else if (SvTYPE(sv) >= SVt_PV) { \ 1389 SvPV_free(sv); \ 1390 SvLEN_set(sv, 0); \ 1391 SvCUR_set(sv, 0); \ 1392 } \ 1393 } STMT_END 1394 #endif 1395 1396 #ifndef PERL_CORE 1397 # define BmFLAGS(sv) (SvTAIL(sv) ? FBMcf_TAIL : 0) 1398 #endif 1399 1400 #if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) 1401 # define BmUSEFUL(sv) \ 1402 (*({ SV *const _bmuseful = MUTABLE_SV(sv); \ 1403 assert(SvTYPE(_bmuseful) >= SVt_PVIV); \ 1404 assert(SvVALID(_bmuseful)); \ 1405 assert(!SvIOK(_bmuseful)); \ 1406 &(((XPVIV*) SvANY(_bmuseful))->xiv_u.xivu_iv); \ 1407 })) 1408 #else 1409 # define BmUSEFUL(sv) ((XPVIV*) SvANY(sv))->xiv_u.xivu_iv 1410 1411 #endif 1412 1413 #ifndef PERL_CORE 1414 # define BmRARE(sv) 0 1415 # define BmPREVIOUS(sv) 0 1416 #endif 1417 1418 #define FmLINES(sv) ((XPVIV*) SvANY(sv))->xiv_iv 1419 1420 #define LvTYPE(sv) ((XPVLV*) SvANY(sv))->xlv_type 1421 #define LvTARG(sv) ((XPVLV*) SvANY(sv))->xlv_targ 1422 #define LvTARGOFF(sv) ((XPVLV*) SvANY(sv))->xlv_targoff 1423 #define LvSTARGOFF(sv) ((XPVLV*) SvANY(sv))->xlv_targoff_u.xlvu_stargoff 1424 #define LvTARGLEN(sv) ((XPVLV*) SvANY(sv))->xlv_targlen 1425 #define LvFLAGS(sv) ((XPVLV*) SvANY(sv))->xlv_flags 1426 1427 #define IoIFP(sv) (sv)->sv_u.svu_fp 1428 #define IoOFP(sv) ((XPVIO*) SvANY(sv))->xio_ofp 1429 #define IoDIRP(sv) ((XPVIO*) SvANY(sv))->xio_dirp 1430 #define IoANY(sv) ((XPVIO*) SvANY(sv))->xio_any 1431 #define IoLINES(sv) ((XPVIO*) SvANY(sv))->xiv_u.xivu_iv 1432 #define IoPAGE(sv) ((XPVIO*) SvANY(sv))->xio_page 1433 #define IoPAGE_LEN(sv) ((XPVIO*) SvANY(sv))->xio_page_len 1434 #define IoLINES_LEFT(sv)((XPVIO*) SvANY(sv))->xio_lines_left 1435 #define IoTOP_NAME(sv) ((XPVIO*) SvANY(sv))->xio_top_name 1436 #define IoTOP_GV(sv) ((XPVIO*) SvANY(sv))->xio_top_gv 1437 #define IoFMT_NAME(sv) ((XPVIO*) SvANY(sv))->xio_fmt_name 1438 #define IoFMT_GV(sv) ((XPVIO*) SvANY(sv))->xio_fmt_gv 1439 #define IoBOTTOM_NAME(sv)((XPVIO*) SvANY(sv))->xio_bottom_name 1440 #define IoBOTTOM_GV(sv) ((XPVIO*) SvANY(sv))->xio_bottom_gv 1441 #define IoTYPE(sv) ((XPVIO*) SvANY(sv))->xio_type 1442 #define IoFLAGS(sv) ((XPVIO*) SvANY(sv))->xio_flags 1443 1444 /* IoTYPE(sv) is a single character telling the type of I/O connection. */ 1445 #define IoTYPE_RDONLY '<' 1446 #define IoTYPE_WRONLY '>' 1447 #define IoTYPE_RDWR '+' 1448 #define IoTYPE_APPEND 'a' 1449 #define IoTYPE_PIPE '|' 1450 #define IoTYPE_STD '-' /* stdin or stdout */ 1451 #define IoTYPE_SOCKET 's' 1452 #define IoTYPE_CLOSED ' ' 1453 #define IoTYPE_IMPLICIT 'I' /* stdin or stdout or stderr */ 1454 #define IoTYPE_NUMERIC '#' /* fdopen */ 1455 1456 /* 1457 =for apidoc Am|bool|SvTAINTED|SV* sv 1458 Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if 1459 not. 1460 1461 =for apidoc Am|void|SvTAINTED_on|SV* sv 1462 Marks an SV as tainted if tainting is enabled. 1463 1464 =for apidoc Am|void|SvTAINTED_off|SV* sv 1465 Untaints an SV. Be I<very> careful with this routine, as it short-circuits 1466 some of Perl's fundamental security features. XS module authors should not 1467 use this function unless they fully understand all the implications of 1468 unconditionally untainting the value. Untainting should be done in the 1469 standard perl fashion, via a carefully crafted regexp, rather than directly 1470 untainting variables. 1471 1472 =for apidoc Am|void|SvTAINT|SV* sv 1473 Taints an SV if tainting is enabled, and if some input to the current 1474 expression is tainted--usually a variable, but possibly also implicit 1475 inputs such as locale settings. C<SvTAINT> propagates that taintedness to 1476 the outputs of an expression in a pessimistic fashion; i.e., without paying 1477 attention to precisely which outputs are influenced by which inputs. 1478 1479 =cut 1480 */ 1481 1482 #define sv_taint(sv) sv_magic((sv), NULL, PERL_MAGIC_taint, NULL, 0) 1483 1484 #ifdef NO_TAINT_SUPPORT 1485 # define SvTAINTED(sv) 0 1486 #else 1487 # define SvTAINTED(sv) (SvMAGICAL(sv) && sv_tainted(sv)) 1488 #endif 1489 #define SvTAINTED_on(sv) STMT_START{ if(UNLIKELY(TAINTING_get)){sv_taint(sv);} }STMT_END 1490 #define SvTAINTED_off(sv) STMT_START{ if(UNLIKELY(TAINTING_get)){sv_untaint(sv);} }STMT_END 1491 1492 #define SvTAINT(sv) \ 1493 STMT_START { \ 1494 if (UNLIKELY(TAINTING_get)) { \ 1495 if (UNLIKELY(TAINT_get)) \ 1496 SvTAINTED_on(sv); \ 1497 } \ 1498 } STMT_END 1499 1500 /* 1501 =for apidoc Am|char*|SvPV_force|SV* sv|STRLEN len 1502 Like C<SvPV> but will force the SV into containing a string (C<SvPOK>), and 1503 only a string (C<SvPOK_only>), by hook or by crook. You need force if you are 1504 going to update the C<SvPVX> directly. Processes get magic. 1505 1506 Note that coercing an arbitrary scalar into a plain PV will potentially 1507 strip useful data from it. For example if the SV was C<SvROK>, then the 1508 referent will have its reference count decremented, and the SV itself may 1509 be converted to an C<SvPOK> scalar with a string buffer containing a value 1510 such as C<"ARRAY(0x1234)">. 1511 1512 =for apidoc Am|char*|SvPV_force_nomg|SV* sv|STRLEN len 1513 Like C<SvPV_force>, but doesn't process get magic. 1514 1515 =for apidoc Am|char*|SvPV|SV* sv|STRLEN len 1516 Returns a pointer to the string in the SV, or a stringified form of 1517 the SV if the SV does not contain a string. The SV may cache the 1518 stringified version becoming C<SvPOK>. Handles 'get' magic. The 1519 C<len> variable will be set to the length of the string (this is a macro, so 1520 don't use C<&len>). See also C<SvPVx> for a version which guarantees to 1521 evaluate sv only once. 1522 1523 Note that there is no guarantee that the return value of C<SvPV()> is 1524 equal to C<SvPVX(sv)>, or that C<SvPVX(sv)> contains valid data, or that 1525 successive calls to C<SvPV(sv)> will return the same pointer value each 1526 time. This is due to the way that things like overloading and 1527 Copy-On-Write are handled. In these cases, the return value may point to 1528 a temporary buffer or similar. If you absolutely need the SvPVX field to 1529 be valid (for example, if you intend to write to it), then see 1530 L</SvPV_force>. 1531 1532 =for apidoc Am|char*|SvPVx|SV* sv|STRLEN len 1533 A version of C<SvPV> which guarantees to evaluate C<sv> only once. 1534 Only use this if C<sv> is an expression with side effects, otherwise use the 1535 more efficient C<SvPV>. 1536 1537 =for apidoc Am|char*|SvPV_nomg|SV* sv|STRLEN len 1538 Like C<SvPV> but doesn't process magic. 1539 1540 =for apidoc Am|char*|SvPV_nolen|SV* sv 1541 Like C<SvPV> but doesn't set a length variable. 1542 1543 =for apidoc Am|char*|SvPV_nomg_nolen|SV* sv 1544 Like C<SvPV_nolen> but doesn't process magic. 1545 1546 =for apidoc Am|IV|SvIV|SV* sv 1547 Coerces the given SV to an integer and returns it. See C<SvIVx> for a 1548 version which guarantees to evaluate sv only once. 1549 1550 =for apidoc Am|IV|SvIV_nomg|SV* sv 1551 Like C<SvIV> but doesn't process magic. 1552 1553 =for apidoc Am|IV|SvIVx|SV* sv 1554 Coerces the given SV to an integer and returns it. 1555 Guarantees to evaluate C<sv> only once. Only use 1556 this if C<sv> is an expression with side effects, 1557 otherwise use the more efficient C<SvIV>. 1558 1559 =for apidoc Am|NV|SvNV|SV* sv 1560 Coerce the given SV to a double and return it. See C<SvNVx> for a version 1561 which guarantees to evaluate sv only once. 1562 1563 =for apidoc Am|NV|SvNV_nomg|SV* sv 1564 Like C<SvNV> but doesn't process magic. 1565 1566 =for apidoc Am|NV|SvNVx|SV* sv 1567 Coerces the given SV to a double and returns it. 1568 Guarantees to evaluate C<sv> only once. Only use 1569 this if C<sv> is an expression with side effects, 1570 otherwise use the more efficient C<SvNV>. 1571 1572 =for apidoc Am|UV|SvUV|SV* sv 1573 Coerces the given SV to an unsigned integer and returns it. See C<SvUVx> 1574 for a version which guarantees to evaluate sv only once. 1575 1576 =for apidoc Am|UV|SvUV_nomg|SV* sv 1577 Like C<SvUV> but doesn't process magic. 1578 1579 =for apidoc Am|UV|SvUVx|SV* sv 1580 Coerces the given SV to an unsigned integer and 1581 returns it. Guarantees to evaluate C<sv> only once. Only 1582 use this if C<sv> is an expression with side effects, 1583 otherwise use the more efficient C<SvUV>. 1584 1585 =for apidoc Am|bool|SvTRUE|SV* sv 1586 Returns a boolean indicating whether Perl would evaluate the SV as true or 1587 false. See SvOK() for a defined/undefined test. Handles 'get' magic 1588 unless the scalar is already SvPOK, SvIOK or SvNOK (the public, not the 1589 private flags). 1590 1591 =for apidoc Am|bool|SvTRUE_nomg|SV* sv 1592 Returns a boolean indicating whether Perl would evaluate the SV as true or 1593 false. See SvOK() for a defined/undefined test. Does not handle 'get' magic. 1594 1595 =for apidoc Am|char*|SvPVutf8_force|SV* sv|STRLEN len 1596 Like C<SvPV_force>, but converts sv to utf8 first if necessary. 1597 1598 =for apidoc Am|char*|SvPVutf8|SV* sv|STRLEN len 1599 Like C<SvPV>, but converts sv to utf8 first if necessary. 1600 1601 =for apidoc Am|char*|SvPVutf8_nolen|SV* sv 1602 Like C<SvPV_nolen>, but converts sv to utf8 first if necessary. 1603 1604 =for apidoc Am|char*|SvPVbyte_force|SV* sv|STRLEN len 1605 Like C<SvPV_force>, but converts sv to byte representation first if necessary. 1606 1607 =for apidoc Am|char*|SvPVbyte|SV* sv|STRLEN len 1608 Like C<SvPV>, but converts sv to byte representation first if necessary. 1609 1610 =for apidoc Am|char*|SvPVbyte_nolen|SV* sv 1611 Like C<SvPV_nolen>, but converts sv to byte representation first if necessary. 1612 1613 =for apidoc Am|char*|SvPVutf8x_force|SV* sv|STRLEN len 1614 Like C<SvPV_force>, but converts sv to utf8 first if necessary. 1615 Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8_force> 1616 otherwise. 1617 1618 =for apidoc Am|char*|SvPVutf8x|SV* sv|STRLEN len 1619 Like C<SvPV>, but converts sv to utf8 first if necessary. 1620 Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8> 1621 otherwise. 1622 1623 =for apidoc Am|char*|SvPVbytex_force|SV* sv|STRLEN len 1624 Like C<SvPV_force>, but converts sv to byte representation first if necessary. 1625 Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte_force> 1626 otherwise. 1627 1628 =for apidoc Am|char*|SvPVbytex|SV* sv|STRLEN len 1629 Like C<SvPV>, but converts sv to byte representation first if necessary. 1630 Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte> 1631 otherwise. 1632 1633 =for apidoc Am|U32|SvIsCOW|SV* sv 1634 Returns a U32 value indicating whether the SV is Copy-On-Write (either shared 1635 hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for 1636 COW). 1637 1638 =for apidoc Am|bool|SvIsCOW_shared_hash|SV* sv 1639 Returns a boolean indicating whether the SV is Copy-On-Write shared hash key 1640 scalar. 1641 1642 =for apidoc Am|void|sv_catpvn_nomg|SV* sv|const char* ptr|STRLEN len 1643 Like C<sv_catpvn> but doesn't process magic. 1644 1645 =for apidoc Am|void|sv_catpv_nomg|SV* sv|const char* ptr 1646 Like C<sv_catpv> but doesn't process magic. 1647 1648 =for apidoc Am|void|sv_setsv_nomg|SV* dsv|SV* ssv 1649 Like C<sv_setsv> but doesn't process magic. 1650 1651 =for apidoc Am|void|sv_catsv_nomg|SV* dsv|SV* ssv 1652 Like C<sv_catsv> but doesn't process magic. 1653 1654 =for apidoc Amdb|STRLEN|sv_utf8_upgrade_nomg|NN SV *sv 1655 1656 Like sv_utf8_upgrade, but doesn't do magic on C<sv>. 1657 1658 =cut 1659 */ 1660 1661 /* Let us hope that bitmaps for UV and IV are the same */ 1662 #define SvIV(sv) (SvIOK_nog(sv) ? SvIVX(sv) : sv_2iv(sv)) 1663 #define SvUV(sv) (SvUOK_nog(sv) ? SvUVX(sv) : sv_2uv(sv)) 1664 #define SvNV(sv) (SvNOK_nog(sv) ? SvNVX(sv) : sv_2nv(sv)) 1665 1666 #define SvIV_nomg(sv) (SvIOK(sv) ? SvIVX(sv) : sv_2iv_flags(sv, 0)) 1667 #define SvUV_nomg(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv_flags(sv, 0)) 1668 #define SvNV_nomg(sv) (SvNOK(sv) ? SvNVX(sv) : sv_2nv_flags(sv, 0)) 1669 1670 /* ----*/ 1671 1672 #define SvPV(sv, lp) SvPV_flags(sv, lp, SV_GMAGIC) 1673 #define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC) 1674 #define SvPV_mutable(sv, lp) SvPV_flags_mutable(sv, lp, SV_GMAGIC) 1675 1676 #define SvPV_flags(sv, lp, flags) \ 1677 (SvPOK_nog(sv) \ 1678 ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags)) 1679 #define SvPV_flags_const(sv, lp, flags) \ 1680 (SvPOK_nog(sv) \ 1681 ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \ 1682 (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN)) 1683 #define SvPV_flags_const_nolen(sv, flags) \ 1684 (SvPOK_nog(sv) \ 1685 ? SvPVX_const(sv) : \ 1686 (const char*) sv_2pv_flags(sv, 0, flags|SV_CONST_RETURN)) 1687 #define SvPV_flags_mutable(sv, lp, flags) \ 1688 (SvPOK_nog(sv) \ 1689 ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \ 1690 sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN)) 1691 1692 #define SvPV_force(sv, lp) SvPV_force_flags(sv, lp, SV_GMAGIC) 1693 #define SvPV_force_nolen(sv) SvPV_force_flags_nolen(sv, SV_GMAGIC) 1694 #define SvPV_force_mutable(sv, lp) SvPV_force_flags_mutable(sv, lp, SV_GMAGIC) 1695 1696 #define SvPV_force_nomg(sv, lp) SvPV_force_flags(sv, lp, 0) 1697 #define SvPV_force_nomg_nolen(sv) SvPV_force_flags_nolen(sv, 0) 1698 1699 #define SvPV_force_flags(sv, lp, flags) \ 1700 (SvPOK_pure_nogthink(sv) \ 1701 ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags)) 1702 1703 #define SvPV_force_flags_nolen(sv, flags) \ 1704 (SvPOK_pure_nogthink(sv) \ 1705 ? SvPVX(sv) : sv_pvn_force_flags(sv, 0, flags)) 1706 1707 #define SvPV_force_flags_mutable(sv, lp, flags) \ 1708 (SvPOK_pure_nogthink(sv) \ 1709 ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \ 1710 : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN)) 1711 1712 #define SvPV_nolen(sv) \ 1713 (SvPOK_nog(sv) \ 1714 ? SvPVX(sv) : sv_2pv_flags(sv, 0, SV_GMAGIC)) 1715 1716 /* "_nomg" in these defines means no mg_get() */ 1717 #define SvPV_nomg_nolen(sv) \ 1718 (SvPOK_nog(sv) \ 1719 ? SvPVX(sv) : sv_2pv_flags(sv, 0, 0)) 1720 1721 #define SvPV_nolen_const(sv) \ 1722 (SvPOK_nog(sv) \ 1723 ? SvPVX_const(sv) : sv_2pv_flags(sv, 0, SV_GMAGIC|SV_CONST_RETURN)) 1724 1725 #define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0) 1726 #define SvPV_nomg_const(sv, lp) SvPV_flags_const(sv, lp, 0) 1727 #define SvPV_nomg_const_nolen(sv) SvPV_flags_const_nolen(sv, 0) 1728 1729 /* ----*/ 1730 1731 #define SvPVutf8(sv, lp) \ 1732 (SvPOK_utf8_nog(sv) \ 1733 ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvutf8(sv, &lp)) 1734 1735 #define SvPVutf8_force(sv, lp) \ 1736 (SvPOK_utf8_pure_nogthink(sv) \ 1737 ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvutf8n_force(sv, &lp)) 1738 1739 #define SvPVutf8_nolen(sv) \ 1740 (SvPOK_utf8_nog(sv) \ 1741 ? SvPVX(sv) : sv_2pvutf8(sv, 0)) 1742 1743 /* ----*/ 1744 1745 #define SvPVbyte(sv, lp) \ 1746 (SvPOK_byte_nog(sv) \ 1747 ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp)) 1748 1749 #define SvPVbyte_force(sv, lp) \ 1750 (SvPOK_byte_pure_nogthink(sv) \ 1751 ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvbyten_force(sv, &lp)) 1752 1753 #define SvPVbyte_nolen(sv) \ 1754 (SvPOK_byte_nog(sv) \ 1755 ? SvPVX(sv) : sv_2pvbyte(sv, 0)) 1756 1757 1758 /* define FOOx(): idempotent versions of FOO(). If possible, use a local 1759 * var to evaluate the arg once; failing that, use a global if possible; 1760 * failing that, call a function to do the work 1761 */ 1762 1763 #define SvPVx_force(sv, lp) sv_pvn_force(sv, &lp) 1764 #define SvPVutf8x_force(sv, lp) sv_pvutf8n_force(sv, &lp) 1765 #define SvPVbytex_force(sv, lp) sv_pvbyten_force(sv, &lp) 1766 1767 #define SvTRUE(sv) (LIKELY(sv) && (UNLIKELY(SvGMAGICAL(sv)) ? sv_2bool(sv) : SvTRUE_common(sv, sv_2bool_nomg(sv)))) 1768 #define SvTRUE_nomg(sv) (LIKELY(sv) && ( SvTRUE_common(sv, sv_2bool_nomg(sv)))) 1769 #define SvTRUE_NN(sv) (UNLIKELY(SvGMAGICAL(sv)) ? sv_2bool(sv) : SvTRUE_common(sv, sv_2bool_nomg(sv))) 1770 #define SvTRUE_nomg_NN(sv) ( SvTRUE_common(sv, sv_2bool_nomg(sv))) 1771 #define SvTRUE_common(sv,fallback) ( \ 1772 !SvOK(sv) \ 1773 ? 0 \ 1774 : SvPOK(sv) \ 1775 ? SvPVXtrue(sv) \ 1776 : (SvFLAGS(sv) & (SVf_IOK|SVf_NOK)) \ 1777 ? ( (SvIOK(sv) && SvIVX(sv) != 0) \ 1778 || (SvNOK(sv) && SvNVX(sv) != 0.0)) \ 1779 : (fallback)) 1780 1781 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) 1782 1783 # define SvIVx(sv) ({SV *_sv = MUTABLE_SV(sv); SvIV(_sv); }) 1784 # define SvUVx(sv) ({SV *_sv = MUTABLE_SV(sv); SvUV(_sv); }) 1785 # define SvNVx(sv) ({SV *_sv = MUTABLE_SV(sv); SvNV(_sv); }) 1786 # define SvPVx(sv, lp) ({SV *_sv = (sv); SvPV(_sv, lp); }) 1787 # define SvPVx_const(sv, lp) ({SV *_sv = (sv); SvPV_const(_sv, lp); }) 1788 # define SvPVx_nolen(sv) ({SV *_sv = (sv); SvPV_nolen(_sv); }) 1789 # define SvPVx_nolen_const(sv) ({SV *_sv = (sv); SvPV_nolen_const(_sv); }) 1790 # define SvPVutf8x(sv, lp) ({SV *_sv = (sv); SvPVutf8(_sv, lp); }) 1791 # define SvPVbytex(sv, lp) ({SV *_sv = (sv); SvPVbyte(_sv, lp); }) 1792 # define SvPVbytex_nolen(sv) ({SV *_sv = (sv); SvPVbyte_nolen(_sv); }) 1793 # define SvTRUEx(sv) ({SV *_sv = (sv); SvTRUE(_sv); }) 1794 # define SvTRUEx_nomg(sv) ({SV *_sv = (sv); SvTRUE_nomg(_sv); }) 1795 1796 #else /* __GNUC__ */ 1797 1798 /* These inlined macros use globals, which will require a thread 1799 * declaration in user code, so we avoid them under threads */ 1800 1801 # define SvIVx(sv) ((PL_Sv = (sv)), SvIV(PL_Sv)) 1802 # define SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv)) 1803 # define SvNVx(sv) ((PL_Sv = (sv)), SvNV(PL_Sv)) 1804 # define SvPVx(sv, lp) ((PL_Sv = (sv)), SvPV(PL_Sv, lp)) 1805 # define SvPVx_const(sv, lp) ((PL_Sv = (sv)), SvPV_const(PL_Sv, lp)) 1806 # define SvPVx_nolen(sv) ((PL_Sv = (sv)), SvPV_nolen(PL_Sv)) 1807 # define SvPVx_nolen_const(sv) ((PL_Sv = (sv)), SvPV_nolen_const(PL_Sv)) 1808 # define SvPVutf8x(sv, lp) ((PL_Sv = (sv)), SvPVutf8(PL_Sv, lp)) 1809 # define SvPVbytex(sv, lp) ((PL_Sv = (sv)), SvPVbyte(PL_Sv, lp)) 1810 # define SvPVbytex_nolen(sv) ((PL_Sv = (sv)), SvPVbyte_nolen(PL_Sv)) 1811 # define SvTRUEx(sv) ((PL_Sv = (sv)), SvTRUE(PL_Sv)) 1812 # define SvTRUEx_nomg(sv) ((PL_Sv = (sv)), SvTRUE_nomg(PL_Sv)) 1813 #endif /* __GNU__ */ 1814 1815 #define SvPVXtrue(sv) ( \ 1816 ((XPV*)SvANY((sv))) \ 1817 && ( \ 1818 ((XPV*)SvANY((sv)))->xpv_cur > 1 \ 1819 || ( \ 1820 ((XPV*)SvANY((sv)))->xpv_cur \ 1821 && *(sv)->sv_u.svu_pv != '0' \ 1822 ) \ 1823 ) \ 1824 ) 1825 1826 #define SvIsCOW(sv) (SvFLAGS(sv) & SVf_IsCOW) 1827 #define SvIsCOW_on(sv) (SvFLAGS(sv) |= SVf_IsCOW) 1828 #define SvIsCOW_off(sv) (SvFLAGS(sv) &= ~SVf_IsCOW) 1829 #define SvIsCOW_shared_hash(sv) (SvIsCOW(sv) && SvLEN(sv) == 0) 1830 1831 #define SvSHARED_HEK_FROM_PV(pvx) \ 1832 ((struct hek*)(pvx - STRUCT_OFFSET(struct hek, hek_key))) 1833 #define SvSHARED_HASH(sv) (0 + SvSHARED_HEK_FROM_PV(SvPVX_const(sv))->hek_hash) 1834 1835 /* flag values for sv_*_flags functions */ 1836 #define SV_IMMEDIATE_UNREF 1 1837 #define SV_GMAGIC 2 1838 #define SV_COW_DROP_PV 4 1839 #define SV_UTF8_NO_ENCODING 8 1840 #define SV_NOSTEAL 16 1841 #define SV_CONST_RETURN 32 1842 #define SV_MUTABLE_RETURN 64 1843 #define SV_SMAGIC 128 1844 #define SV_HAS_TRAILING_NUL 256 1845 #define SV_COW_SHARED_HASH_KEYS 512 1846 /* This one is only enabled for PERL_OLD_COPY_ON_WRITE */ 1847 #define SV_COW_OTHER_PVS 1024 1848 /* Make sv_2pv_flags return NULL if something is undefined. */ 1849 #define SV_UNDEF_RETURNS_NULL 2048 1850 /* Tell sv_utf8_upgrade() to not check to see if an upgrade is really needed. 1851 * This is used when the caller has already determined it is, and avoids 1852 * redundant work */ 1853 #define SV_FORCE_UTF8_UPGRADE 4096 1854 /* if (after resolving magic etc), the SV is found to be overloaded, 1855 * don't call the overload magic, just return as-is */ 1856 #define SV_SKIP_OVERLOAD 8192 1857 /* It is not yet clear whether we want this as an API, or what the 1858 * constants should be named. */ 1859 #ifdef PERL_CORE 1860 # define SV_CATBYTES 16384 1861 # define SV_CATUTF8 32768 1862 #endif 1863 1864 /* The core is safe for this COW optimisation. XS code on CPAN may not be. 1865 So only default to doing the COW setup if we're in the core. 1866 */ 1867 #ifdef PERL_CORE 1868 # ifndef SV_DO_COW_SVSETSV 1869 # define SV_DO_COW_SVSETSV SV_COW_SHARED_HASH_KEYS|SV_COW_OTHER_PVS 1870 # endif 1871 #endif 1872 1873 #ifndef SV_DO_COW_SVSETSV 1874 # define SV_DO_COW_SVSETSV 0 1875 #endif 1876 1877 1878 #define sv_unref(sv) sv_unref_flags(sv, 0) 1879 #define sv_force_normal(sv) sv_force_normal_flags(sv, 0) 1880 #define sv_usepvn(sv, p, l) sv_usepvn_flags(sv, p, l, 0) 1881 #define sv_usepvn_mg(sv, p, l) sv_usepvn_flags(sv, p, l, SV_SMAGIC) 1882 1883 /* We are about to replace the SV's current value. So if it's copy on write 1884 we need to normalise it. Use the SV_COW_DROP_PV flag hint to say that 1885 the value is about to get thrown away, so drop the PV rather than go to 1886 the effort of making a read-write copy only for it to get immediately 1887 discarded. */ 1888 1889 #define SV_CHECK_THINKFIRST_COW_DROP(sv) if (SvTHINKFIRST(sv)) \ 1890 sv_force_normal_flags(sv, SV_COW_DROP_PV) 1891 1892 #ifdef PERL_OLD_COPY_ON_WRITE 1893 #define SvRELEASE_IVX(sv) \ 1894 ((SvIsCOW(sv) ? sv_force_normal_flags(sv, 0) : (void) 0), 0) 1895 # define SvIsCOW_normal(sv) (SvIsCOW(sv) && SvLEN(sv)) 1896 # define SvRELEASE_IVX_(sv) SvRELEASE_IVX(sv), 1897 # define SvCANCOW(sv) \ 1898 (SvIsCOW(sv) || (SvFLAGS(sv) & CAN_COW_MASK) == CAN_COW_FLAGS) 1899 /* This is a pessimistic view. Scalar must be purely a read-write PV to copy- 1900 on-write. */ 1901 # define CAN_COW_MASK (SVs_OBJECT|SVs_GMG|SVs_SMG|SVs_RMG|SVf_IOK|SVf_NOK| \ 1902 SVf_POK|SVf_ROK|SVp_IOK|SVp_NOK|SVp_POK|SVf_FAKE| \ 1903 SVf_OOK|SVf_BREAK|SVf_READONLY) 1904 #else 1905 # define SvRELEASE_IVX(sv) 0 1906 /* This little game brought to you by the need to shut this warning up: 1907 mg.c: In function 'Perl_magic_get': 1908 mg.c:1024: warning: left-hand operand of comma expression has no effect 1909 */ 1910 # define SvRELEASE_IVX_(sv) /**/ 1911 # ifdef PERL_NEW_COPY_ON_WRITE 1912 # define SvCANCOW(sv) \ 1913 (SvIsCOW(sv) \ 1914 ? SvLEN(sv) ? CowREFCNT(sv) != SV_COW_REFCNT_MAX : 1 \ 1915 : (SvFLAGS(sv) & CAN_COW_MASK) == CAN_COW_FLAGS \ 1916 && SvCUR(sv)+1 < SvLEN(sv)) 1917 /* Note: To allow 256 COW "copies", a refcnt of 0 means 1. */ 1918 # define CowREFCNT(sv) (*(U8 *)(SvPVX(sv)+SvLEN(sv)-1)) 1919 # define SV_COW_REFCNT_MAX ((1 << sizeof(U8)*8) - 1) 1920 # define CAN_COW_MASK (SVf_POK|SVf_ROK|SVp_POK|SVf_FAKE| \ 1921 SVf_OOK|SVf_BREAK|SVf_READONLY) 1922 # endif 1923 #endif /* PERL_OLD_COPY_ON_WRITE */ 1924 1925 #define CAN_COW_FLAGS (SVp_POK|SVf_POK) 1926 1927 #define SV_CHECK_THINKFIRST(sv) if (SvTHINKFIRST(sv)) \ 1928 sv_force_normal_flags(sv, 0) 1929 1930 1931 /* all these 'functions' are now just macros */ 1932 1933 #define sv_pv(sv) SvPV_nolen(sv) 1934 #define sv_pvutf8(sv) SvPVutf8_nolen(sv) 1935 #define sv_pvbyte(sv) SvPVbyte_nolen(sv) 1936 1937 #define sv_pvn_force_nomg(sv, lp) sv_pvn_force_flags(sv, lp, 0) 1938 #define sv_utf8_upgrade_flags(sv, flags) sv_utf8_upgrade_flags_grow(sv, flags, 0) 1939 #define sv_utf8_upgrade_nomg(sv) sv_utf8_upgrade_flags(sv, 0) 1940 #define sv_catpvn_nomg(dsv, sstr, slen) sv_catpvn_flags(dsv, sstr, slen, 0) 1941 #define sv_catpv_nomg(dsv, sstr) sv_catpv_flags(dsv, sstr, 0) 1942 #define sv_setsv(dsv, ssv) \ 1943 sv_setsv_flags(dsv, ssv, SV_GMAGIC|SV_DO_COW_SVSETSV) 1944 #define sv_setsv_nomg(dsv, ssv) sv_setsv_flags(dsv, ssv, SV_DO_COW_SVSETSV) 1945 #define sv_catsv(dsv, ssv) sv_catsv_flags(dsv, ssv, SV_GMAGIC) 1946 #define sv_catsv_nomg(dsv, ssv) sv_catsv_flags(dsv, ssv, 0) 1947 #define sv_catsv_mg(dsv, ssv) sv_catsv_flags(dsv, ssv, SV_GMAGIC|SV_SMAGIC) 1948 #define sv_catpvn(dsv, sstr, slen) sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC) 1949 #define sv_catpvn_mg(sv, sstr, slen) sv_catpvn_flags(sv, sstr, slen, SV_GMAGIC|SV_SMAGIC); 1950 #define sv_copypv(dsv, ssv) sv_copypv_flags(dsv, ssv, SV_GMAGIC) 1951 #define sv_copypv_nomg(dsv, ssv) sv_copypv_flags(dsv, ssv, 0) 1952 #define sv_2pv(sv, lp) sv_2pv_flags(sv, lp, SV_GMAGIC) 1953 #define sv_2pv_nolen(sv) sv_2pv(sv, 0) 1954 #define sv_2pvbyte_nolen(sv) sv_2pvbyte(sv, 0) 1955 #define sv_2pvutf8_nolen(sv) sv_2pvutf8(sv, 0) 1956 #define sv_2pv_nomg(sv, lp) sv_2pv_flags(sv, lp, 0) 1957 #define sv_pvn_force(sv, lp) sv_pvn_force_flags(sv, lp, SV_GMAGIC) 1958 #define sv_utf8_upgrade(sv) sv_utf8_upgrade_flags(sv, SV_GMAGIC) 1959 #define sv_2iv(sv) sv_2iv_flags(sv, SV_GMAGIC) 1960 #define sv_2uv(sv) sv_2uv_flags(sv, SV_GMAGIC) 1961 #define sv_2nv(sv) sv_2nv_flags(sv, SV_GMAGIC) 1962 #define sv_eq(sv1, sv2) sv_eq_flags(sv1, sv2, SV_GMAGIC) 1963 #define sv_cmp(sv1, sv2) sv_cmp_flags(sv1, sv2, SV_GMAGIC) 1964 #define sv_cmp_locale(sv1, sv2) sv_cmp_locale_flags(sv1, sv2, SV_GMAGIC) 1965 #define sv_collxfrm(sv, nxp) sv_cmp_flags(sv, nxp, SV_GMAGIC) 1966 #define sv_2bool(sv) sv_2bool_flags(sv, SV_GMAGIC) 1967 #define sv_2bool_nomg(sv) sv_2bool_flags(sv, 0) 1968 #define sv_insert(bigstr, offset, len, little, littlelen) \ 1969 Perl_sv_insert_flags(aTHX_ (bigstr),(offset), (len), (little), \ 1970 (littlelen), SV_GMAGIC) 1971 #define sv_mortalcopy(sv) \ 1972 Perl_sv_mortalcopy_flags(aTHX_ sv, SV_GMAGIC|SV_DO_COW_SVSETSV) 1973 1974 /* Should be named SvCatPVN_utf8_upgrade? */ 1975 #define sv_catpvn_nomg_utf8_upgrade(dsv, sstr, slen, nsv) \ 1976 STMT_START { \ 1977 if (!(nsv)) \ 1978 nsv = newSVpvn_flags(sstr, slen, SVs_TEMP); \ 1979 else \ 1980 sv_setpvn(nsv, sstr, slen); \ 1981 SvUTF8_off(nsv); \ 1982 sv_utf8_upgrade(nsv); \ 1983 sv_catsv_nomg(dsv, nsv); \ 1984 } STMT_END 1985 #define sv_catpvn_nomg_maybeutf8(dsv, sstr, slen, is_utf8) \ 1986 sv_catpvn_flags(dsv, sstr, slen, (is_utf8)?SV_CATUTF8:SV_CATBYTES) 1987 1988 #if defined(PERL_CORE) || defined(PERL_EXT) 1989 # define sv_or_pv_len_utf8(sv, pv, bytelen) \ 1990 (SvGAMAGIC(sv) \ 1991 ? utf8_length((U8 *)(pv), (U8 *)(pv)+(bytelen)) \ 1992 : sv_len_utf8(sv)) 1993 #endif 1994 1995 /* 1996 =for apidoc Am|SV*|newRV_inc|SV* sv 1997 1998 Creates an RV wrapper for an SV. The reference count for the original SV is 1999 incremented. 2000 2001 =cut 2002 */ 2003 2004 #define newRV_inc(sv) newRV(sv) 2005 2006 /* the following macros update any magic values this sv is associated with */ 2007 2008 /* 2009 =head1 Magical Functions 2010 2011 =for apidoc Am|void|SvGETMAGIC|SV* sv 2012 Invokes C<mg_get> on an SV if it has 'get' magic. For example, this 2013 will call C<FETCH> on a tied variable. This macro evaluates its 2014 argument more than once. 2015 2016 =for apidoc Am|void|SvSETMAGIC|SV* sv 2017 Invokes C<mg_set> on an SV if it has 'set' magic. This is necessary 2018 after modifying a scalar, in case it is a magical variable like C<$|> 2019 or a tied variable (it calls C<STORE>). This macro evaluates its 2020 argument more than once. 2021 2022 =for apidoc Am|void|SvSetSV|SV* dsv|SV* ssv 2023 Calls C<sv_setsv> if dsv is not the same as ssv. May evaluate arguments 2024 more than once. Does not handle 'set' magic on the destination SV. 2025 2026 =for apidoc Am|void|SvSetSV_nosteal|SV* dsv|SV* ssv 2027 Calls a non-destructive version of C<sv_setsv> if dsv is not the same as 2028 ssv. May evaluate arguments more than once. 2029 2030 =for apidoc Am|void|SvSetMagicSV|SV* dsv|SV* ssv 2031 Like C<SvSetSV>, but does any set magic required afterwards. 2032 2033 =for apidoc Am|void|SvSetMagicSV_nosteal|SV* dsv|SV* ssv 2034 Like C<SvSetSV_nosteal>, but does any set magic required afterwards. 2035 2036 =for apidoc Am|void|SvSHARE|SV* sv 2037 Arranges for sv to be shared between threads if a suitable module 2038 has been loaded. 2039 2040 =for apidoc Am|void|SvLOCK|SV* sv 2041 Arranges for a mutual exclusion lock to be obtained on sv if a suitable module 2042 has been loaded. 2043 2044 =for apidoc Am|void|SvUNLOCK|SV* sv 2045 Releases a mutual exclusion lock on sv if a suitable module 2046 has been loaded. 2047 2048 =head1 SV Manipulation Functions 2049 2050 =for apidoc Am|char *|SvGROW|SV* sv|STRLEN len 2051 Expands the character buffer in the SV so that it has room for the 2052 indicated number of bytes (remember to reserve space for an extra trailing 2053 C<NUL> character). Calls C<sv_grow> to perform the expansion if necessary. 2054 Returns a pointer to the character 2055 buffer. SV must be of type >= SVt_PV. One 2056 alternative is to call C<sv_grow> if you are not sure of the type of SV. 2057 2058 =cut 2059 */ 2060 2061 #define SvSHARE(sv) PL_sharehook(aTHX_ sv) 2062 #define SvLOCK(sv) PL_lockhook(aTHX_ sv) 2063 #define SvUNLOCK(sv) PL_unlockhook(aTHX_ sv) 2064 #define SvDESTROYABLE(sv) PL_destroyhook(aTHX_ sv) 2065 2066 #define SvGETMAGIC(x) ((void)(UNLIKELY(SvGMAGICAL(x)) && mg_get(x))) 2067 #define SvSETMAGIC(x) STMT_START { if (UNLIKELY(SvSMAGICAL(x))) mg_set(x); } STMT_END 2068 2069 #define SvSetSV_and(dst,src,finally) \ 2070 STMT_START { \ 2071 if (LIKELY((dst) != (src))) { \ 2072 sv_setsv(dst, src); \ 2073 finally; \ 2074 } \ 2075 } STMT_END 2076 #define SvSetSV_nosteal_and(dst,src,finally) \ 2077 STMT_START { \ 2078 if (LIKELY((dst) != (src))) { \ 2079 sv_setsv_flags(dst, src, SV_GMAGIC | SV_NOSTEAL | SV_DO_COW_SVSETSV); \ 2080 finally; \ 2081 } \ 2082 } STMT_END 2083 2084 #define SvSetSV(dst,src) \ 2085 SvSetSV_and(dst,src,/*nothing*/;) 2086 #define SvSetSV_nosteal(dst,src) \ 2087 SvSetSV_nosteal_and(dst,src,/*nothing*/;) 2088 2089 #define SvSetMagicSV(dst,src) \ 2090 SvSetSV_and(dst,src,SvSETMAGIC(dst)) 2091 #define SvSetMagicSV_nosteal(dst,src) \ 2092 SvSetSV_nosteal_and(dst,src,SvSETMAGIC(dst)) 2093 2094 2095 #if !defined(SKIP_DEBUGGING) 2096 #define SvPEEK(sv) sv_peek(sv) 2097 #else 2098 #define SvPEEK(sv) "" 2099 #endif 2100 2101 #define SvIMMORTAL(sv) (SvREADONLY(sv) && ((sv)==&PL_sv_undef || (sv)==&PL_sv_yes || (sv)==&PL_sv_no || (sv)==&PL_sv_placeholder)) 2102 2103 #ifdef DEBUGGING 2104 /* exercise the immortal resurrection code in sv_free2() */ 2105 # define SvREFCNT_IMMORTAL 1000 2106 #else 2107 # define SvREFCNT_IMMORTAL ((~(U32)0)/2) 2108 #endif 2109 2110 /* 2111 =for apidoc Am|SV *|boolSV|bool b 2112 2113 Returns a true SV if C<b> is a true value, or a false SV if C<b> is 0. 2114 2115 See also C<PL_sv_yes> and C<PL_sv_no>. 2116 2117 =cut 2118 */ 2119 2120 #define boolSV(b) ((b) ? &PL_sv_yes : &PL_sv_no) 2121 2122 #define isGV(sv) (SvTYPE(sv) == SVt_PVGV) 2123 /* If I give every macro argument a different name, then there won't be bugs 2124 where nested macros get confused. Been there, done that. */ 2125 #define isGV_with_GP(pwadak) \ 2126 (((SvFLAGS(pwadak) & (SVp_POK|SVpgv_GP)) == SVpgv_GP) \ 2127 && (SvTYPE(pwadak) == SVt_PVGV || SvTYPE(pwadak) == SVt_PVLV)) 2128 #define isGV_with_GP_on(sv) STMT_START { \ 2129 assert (SvTYPE(sv) == SVt_PVGV || SvTYPE(sv) == SVt_PVLV); \ 2130 assert (!SvPOKp(sv)); \ 2131 assert (!SvIOKp(sv)); \ 2132 (SvFLAGS(sv) |= SVpgv_GP); \ 2133 } STMT_END 2134 #define isGV_with_GP_off(sv) STMT_START { \ 2135 assert (SvTYPE(sv) == SVt_PVGV || SvTYPE(sv) == SVt_PVLV); \ 2136 assert (!SvPOKp(sv)); \ 2137 assert (!SvIOKp(sv)); \ 2138 (SvFLAGS(sv) &= ~SVpgv_GP); \ 2139 } STMT_END 2140 #define isREGEXP(sv) \ 2141 (SvTYPE(sv) == SVt_REGEXP \ 2142 || (SvFLAGS(sv) & (SVTYPEMASK|SVp_POK|SVpgv_GP|SVf_FAKE)) \ 2143 == (SVt_PVLV|SVf_FAKE)) 2144 2145 2146 #ifdef PERL_ANY_COW 2147 # define SvGROW(sv,len) \ 2148 (SvIsCOW(sv) || SvLEN(sv) < (len) ? sv_grow(sv,len) : SvPVX(sv)) 2149 #else 2150 # define SvGROW(sv,len) (SvLEN(sv) < (len) ? sv_grow(sv,len) : SvPVX(sv)) 2151 #endif 2152 #define SvGROW_mutable(sv,len) \ 2153 (SvLEN(sv) < (len) ? sv_grow(sv,len) : SvPVX_mutable(sv)) 2154 #define Sv_Grow sv_grow 2155 2156 #define CLONEf_COPY_STACKS 1 2157 #define CLONEf_KEEP_PTR_TABLE 2 2158 #define CLONEf_CLONE_HOST 4 2159 #define CLONEf_JOIN_IN 8 2160 2161 struct clone_params { 2162 AV* stashes; 2163 UV flags; 2164 PerlInterpreter *proto_perl; 2165 PerlInterpreter *new_perl; 2166 AV *unreferenced; 2167 }; 2168 2169 /* 2170 =for apidoc Am|SV*|newSVpvn_utf8|NULLOK const char* s|STRLEN len|U32 utf8 2171 2172 Creates a new SV and copies a string (which may contain C<NUL> (C<\0>) 2173 characters) into it. If utf8 is true, calls 2174 C<SvUTF8_on> on the new SV. Implemented as a wrapper around C<newSVpvn_flags>. 2175 2176 =cut 2177 */ 2178 2179 #define newSVpvn_utf8(s, len, u) newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0) 2180 2181 /* 2182 =for apidoc Amx|SV*|newSVpadname|PADNAME *pn 2183 2184 Creates a new SV containing the pad name. This is currently identical 2185 to C<newSVsv>, but pad names may cease being SVs at some point, so 2186 C<newSVpadname> is preferable. 2187 2188 =cut 2189 */ 2190 2191 #define newSVpadname(pn) newSVsv(pn) 2192 2193 /* 2194 =for apidoc Am|void|SvOOK_offset|NN SV*sv|STRLEN len 2195 2196 Reads into I<len> the offset from SvPVX back to the true start of the 2197 allocated buffer, which will be non-zero if C<sv_chop> has been used to 2198 efficiently remove characters from start of the buffer. Implemented as a 2199 macro, which takes the address of I<len>, which must be of type C<STRLEN>. 2200 Evaluates I<sv> more than once. Sets I<len> to 0 if C<SvOOK(sv)> is false. 2201 2202 =cut 2203 */ 2204 2205 #ifdef DEBUGGING 2206 /* Does the bot know something I don't? 2207 10:28 <@Nicholas> metabatman 2208 10:28 <+meta> Nicholas: crash 2209 */ 2210 # define SvOOK_offset(sv, offset) STMT_START { \ 2211 assert(sizeof(offset) == sizeof(STRLEN)); \ 2212 if (SvOOK(sv)) { \ 2213 const U8 *_crash = (U8*)SvPVX_const(sv); \ 2214 (offset) = *--_crash; \ 2215 if (!(offset)) { \ 2216 _crash -= sizeof(STRLEN); \ 2217 Copy(_crash, (U8 *)&(offset), sizeof(STRLEN), U8); \ 2218 } \ 2219 { \ 2220 /* Validate the preceding buffer's sentinels to \ 2221 verify that no-one is using it. */ \ 2222 const U8 *const _bonk = (U8*)SvPVX_const(sv) - (offset);\ 2223 while (_crash > _bonk) { \ 2224 --_crash; \ 2225 assert (*_crash == (U8)PTR2UV(_crash)); \ 2226 } \ 2227 } \ 2228 } else { \ 2229 (offset) = 0; \ 2230 } \ 2231 } STMT_END 2232 #else 2233 /* This is the same code, but avoids using any temporary variables: */ 2234 # define SvOOK_offset(sv, offset) STMT_START { \ 2235 assert(sizeof(offset) == sizeof(STRLEN)); \ 2236 if (SvOOK(sv)) { \ 2237 (offset) = ((U8*)SvPVX_const(sv))[-1]; \ 2238 if (!(offset)) { \ 2239 Copy(SvPVX_const(sv) - 1 - sizeof(STRLEN), \ 2240 (U8*)&(offset), sizeof(STRLEN), U8); \ 2241 } \ 2242 } else { \ 2243 (offset) = 0; \ 2244 } \ 2245 } STMT_END 2246 #endif 2247 2248 #define newIO() MUTABLE_IO(newSV_type(SVt_PVIO)) 2249 2250 #define SV_CONST(name) \ 2251 PL_sv_consts[SV_CONST_##name] \ 2252 ? PL_sv_consts[SV_CONST_##name] \ 2253 : (PL_sv_consts[SV_CONST_##name] = newSVpv_share(#name, 0)) 2254 2255 #define SV_CONST_TIESCALAR 0 2256 #define SV_CONST_TIEARRAY 1 2257 #define SV_CONST_TIEHASH 2 2258 #define SV_CONST_TIEHANDLE 3 2259 2260 #define SV_CONST_FETCH 4 2261 #define SV_CONST_FETCHSIZE 5 2262 #define SV_CONST_STORE 6 2263 #define SV_CONST_STORESIZE 7 2264 #define SV_CONST_EXISTS 8 2265 2266 #define SV_CONST_PUSH 9 2267 #define SV_CONST_POP 10 2268 #define SV_CONST_SHIFT 11 2269 #define SV_CONST_UNSHIFT 12 2270 #define SV_CONST_SPLICE 13 2271 #define SV_CONST_EXTEND 14 2272 2273 #define SV_CONST_FIRSTKEY 15 2274 #define SV_CONST_NEXTKEY 16 2275 #define SV_CONST_SCALAR 17 2276 2277 #define SV_CONST_OPEN 18 2278 #define SV_CONST_WRITE 19 2279 #define SV_CONST_PRINT 20 2280 #define SV_CONST_PRINTF 21 2281 #define SV_CONST_READ 22 2282 #define SV_CONST_READLINE 23 2283 #define SV_CONST_GETC 24 2284 #define SV_CONST_SEEK 25 2285 #define SV_CONST_TELL 26 2286 #define SV_CONST_EOF 27 2287 #define SV_CONST_BINMODE 28 2288 #define SV_CONST_FILENO 29 2289 #define SV_CONST_CLOSE 30 2290 2291 #define SV_CONST_DELETE 31 2292 #define SV_CONST_CLEAR 32 2293 #define SV_CONST_UNTIE 33 2294 #define SV_CONST_DESTROY 34 2295 2296 #define SV_CONSTS_COUNT 35 2297 2298 /* 2299 * Local variables: 2300 * c-indentation-style: bsd 2301 * c-basic-offset: 4 2302 * indent-tabs-mode: nil 2303 * End: 2304 * 2305 * ex: set ts=8 sts=4 sw=4 et: 2306 */ 2307