sv.h

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