sv.h

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