sv.h

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