sv.h

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