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