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