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 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_IV,         /* 1 */
  49         SVt_NV,         /* 2 */
  50         SVt_RV,         /* 3 */
  51         SVt_PV,         /* 4 */
  52         SVt_PVIV,       /* 5 */
  53         SVt_PVNV,       /* 6 */
  54         SVt_PVMG,       /* 7 */
  55         SVt_PVBM,       /* 8 */
  56         SVt_PVGV,       /* 9 */
  57         SVt_PVLV,       /* 10 */
  58         SVt_PVAV,       /* 11 */
  59         SVt_PVHV,       /* 12 */
  60         SVt_PVCV,       /* 13 */
  61         SVt_PVFM,       /* 14 */
  62         SVt_PVIO,       /* 15 */
  63         SVt_LAST        /* keep last in enum. used to size arrays */
  64 } svtype;
  65
  66
  67 /* typedefs to eliminate some typing */
  68 typedef struct he HE;
  69 typedef struct hek HEK;
  70
  71 /* Using C's structural equivalence to help emulate C++ inheritance here... */
  72
  73 /* start with 2 sv-head building blocks */
  74 #define _SV_HEAD(ptrtype) \
  75     ptrtype     sv_any;         /* pointer to body */   \
  76     U32         sv_refcnt;      /* how many references to us */ \
  77     U32         sv_flags        /* what we are */
  78
  79 #define _SV_HEAD_UNION \
  80     union {                             \
  81         IV      svu_iv;                 \
  82         UV      svu_uv;                 \
  83         SV*     svu_rv;         /* pointer to another SV */             \
  84         char*   svu_pv;         /* pointer to malloced string */        \
  85         SV**    svu_array;              \
  86         HE**    svu_hash;               \
  87     }   sv_u
  88
  89
  90 struct STRUCT_SV {              /* struct sv { */
  91     _SV_HEAD(void*);
  92     _SV_HEAD_UNION;
  93 #ifdef DEBUG_LEAKING_SCALARS
  94     unsigned    sv_debug_optype:9;      /* the type of OP that allocated us */
  95     unsigned    sv_debug_inpad:1;       /* was allocated in a pad for an OP */
  96     unsigned    sv_debug_cloned:1;      /* was cloned for an ithread */
  97     unsigned    sv_debug_line:16;       /* the line where we were allocated */
  98     char *      sv_debug_file;          /* the file where we were allocated */
  99 #endif
 100 };
 101
 102 struct gv {
 103     _SV_HEAD(XPVGV*);           /* pointer to xpvgv body */
 104     _SV_HEAD_UNION;
 105 };
 106
 107 struct cv {
 108     _SV_HEAD(XPVCV*);           /* pointer to xpvcv body */
 109     _SV_HEAD_UNION;
 110 };
 111
 112 struct av {
 113     _SV_HEAD(XPVAV*);           /* pointer to xpvcv body */
 114     _SV_HEAD_UNION;
 115 };
 116
 117 struct hv {
 118     _SV_HEAD(XPVHV*);           /* pointer to xpvhv body */
 119     _SV_HEAD_UNION;
 120 };
 121
 122 struct io {
 123     _SV_HEAD(XPVIO*);           /* pointer to xpvio body */
 124     _SV_HEAD_UNION;
 125 };
 126
 127 #undef _SV_HEAD
 128 #undef _SV_HEAD_UNION           /* insure no pollution */
 129
 130 /*
 131 =head1 SV Manipulation Functions
 132
 133 =for apidoc Am|U32|SvREFCNT|SV* sv
 134 Returns the value of the object's reference count.
 135
 136 =for apidoc Am|SV*|SvREFCNT_inc|SV* sv
 137 Increments the reference count of the given SV.
 138
 139 =for apidoc Am|void|SvREFCNT_dec|SV* sv
 140 Decrements the reference count of the given SV.
 141
 142 =for apidoc Am|svtype|SvTYPE|SV* sv
 143 Returns the type of the SV.  See C<svtype>.
 144
 145 =for apidoc Am|void|SvUPGRADE|SV* sv|svtype type
 146 Used to upgrade an SV to a more complex form.  Uses C<sv_upgrade> to
 147 perform the upgrade if necessary.  See C<svtype>.
 148
 149 =cut
 150 */
 151
 152 #define SvANY(sv)       (sv)->sv_any
 153 #define SvFLAGS(sv)     (sv)->sv_flags
 154 #define SvREFCNT(sv)    (sv)->sv_refcnt
 155
 156 #if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC)
 157 #  define SvREFCNT_inc(sv)              \
 158     ({                                  \
 159         SV * const _sv = (SV*)(sv);     \
 160         if (_sv)                        \
 161              (SvREFCNT(_sv))++;         \
 162         _sv;                            \
 163     })
 164 #else
 165 #  define SvREFCNT_inc(sv)      \
 166         ((PL_Sv=(SV*)(sv)), (PL_Sv && ++(SvREFCNT(PL_Sv))), (SV*)PL_Sv)
 167 #endif
 168
 169 #if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC)
 170 #  define SvREFCNT_dec(sv)              \
 171     ({                                  \
 172         SV * const _sv = (SV*)(sv);     \
 173         if (_sv) {                      \
 174             if (SvREFCNT(_sv)) {        \
 175                 if (--(SvREFCNT(_sv)) == 0) \
 176                     Perl_sv_free2(aTHX_ _sv);   \
 177             } else {                    \
 178                 sv_free(_sv);           \
 179             }                           \
 180         }                               \
 181     })
 182 #else
 183 #define SvREFCNT_dec(sv)        sv_free((SV*)(sv))
 184 #endif
 185
 186 #define SVTYPEMASK      0xff
 187 #define SvTYPE(sv)      ((sv)->sv_flags & SVTYPEMASK)
 188
 189 /* Sadly there are some parts of the core that have pointers to already-freed
 190    SV heads, and rely on being able to tell that they are now free. So mark
 191    them all by using a consistent macro.  */
 192 #define SvIS_FREED(sv)  ((sv)->sv_flags == SVTYPEMASK)
 193
 194 #define SvUPGRADE(sv, mt) (SvTYPE(sv) >= (mt) || (sv_upgrade(sv, mt), 1))
 195
 196 #define SVs_PADSTALE    0x00000100      /* lexical has gone out of scope */
 197 #define SVs_PADTMP      0x00000200      /* in use as tmp */
 198 #define SVs_PADMY       0x00000400      /* in use a "my" variable */
 199 #define SVs_TEMP        0x00000800      /* string is stealable? */
 200 #define SVs_OBJECT      0x00001000      /* is "blessed" */
 201 #define SVs_GMG         0x00002000      /* has magical get method */
 202 #define SVs_SMG         0x00004000      /* has magical set method */
 203 #define SVs_RMG         0x00008000      /* has random magical methods */
 204
 205 #define SVf_IOK         0x00010000      /* has valid public integer value */
 206 #define SVf_NOK         0x00020000      /* has valid public numeric value */
 207 #define SVf_POK         0x00040000      /* has valid public pointer value */
 208 #define SVf_ROK         0x00080000      /* has a valid reference pointer */
 209
 210 #define SVf_FAKE        0x00100000      /* glob or lexical is just a copy */
 211 #define SVf_OOK         0x00200000      /* has valid offset value
 212                                            For a PVHV this means that a
 213                                            hv_aux struct is present after the
 214                                            main array  */
 215 #define SVf_BREAK       0x00400000      /* refcnt is artificially low - used
 216                                          * by SV's in final arena  cleanup */
 217 #define SVf_READONLY    0x00800000      /* may not be modified */
 218
 219
 220 #define SVp_IOK         0x01000000      /* has valid non-public integer value */
 221 #define SVp_NOK         0x02000000      /* has valid non-public numeric value */
 222 #define SVp_POK         0x04000000      /* has valid non-public pointer value */
 223 #define SVp_SCREAM      0x08000000      /* has been studied? */
 224
 225 #define SVf_UTF8        0x20000000      /* SvPV is UTF-8 encoded */
 226 /* Ensure this value does not clash with the GV_ADD* flags in gv.h */
 227
 228 #define SVf_THINKFIRST  (SVf_READONLY|SVf_ROK|SVf_FAKE)
 229
 230 #define SVf_OK          (SVf_IOK|SVf_NOK|SVf_POK|SVf_ROK| \
 231                          SVp_IOK|SVp_NOK|SVp_POK)
 232
 233 #define SVf_AMAGIC      0x10000000      /* has magical overloaded methods */
 234
 235 #define PRIVSHIFT 8     /* (SVp_?OK >> PRIVSHIFT) == SVf_?OK */
 236
 237 /* Some private flags. */
 238
 239 /* SVpad_OUR may be set on SVt_PV{NV,MG,GV} types */
 240 #define SVpad_OUR       0x80000000      /* pad name is "our" instead of "my" */
 241 #define SVpad_TYPED     0x40000000      /* Typed Lexical */
 242
 243 #define SVf_IVisUV      0x80000000      /* use XPVUV instead of XPVIV */
 244
 245 #define SVpfm_COMPILED  0x80000000      /* FORMLINE is compiled */
 246
 247 #define SVpbm_VALID     0x80000000
 248 #define SVpbm_TAIL      0x40000000
 249
 250 #define SVrepl_EVAL     0x40000000      /* Replacement part of s///e */
 251
 252 #define SVphv_CLONEABLE 0x08000000      /* for stashes: clone its objects */
 253 #define SVphv_REHASH    0x10000000      /* HV is recalculating hash values */
 254 #define SVphv_SHAREKEYS 0x20000000      /* keys live on shared string table */
 255 #define SVphv_LAZYDEL   0x40000000      /* entry in xhv_eiter must be deleted */
 256 #define SVphv_HASKFLAGS 0x80000000      /* keys have flag byte after hash */
 257
 258 #define SVprv_WEAKREF   0x80000000      /* Weak reference */
 259
 260 #define SVpav_REAL      0x40000000      /* free old entries */
 261 #define SVpav_REIFY     0x80000000      /* can become real */
 262
 263 struct xpv {
 264     NV          xnv_nv;         /* numeric value, if any */
 265     STRLEN      xpv_cur;        /* length of svu_pv as a C string */
 266     STRLEN      xpv_len;        /* allocated size */
 267 };
 268
 269 #if 0
 270 typedef struct xpv xpv_allocated;
 271 #else
 272 typedef struct {
 273     STRLEN      xpv_cur;        /* length of svu_pv as a C string */
 274     STRLEN      xpv_len;        /* allocated size */
 275 } xpv_allocated;
 276 #endif
 277
 278 struct xpviv {
 279     NV          xnv_nv;         /* numeric value, if any */
 280     STRLEN      xpv_cur;        /* length of svu_pv as a C string */
 281     STRLEN      xpv_len;        /* allocated size */
 282     union {
 283         IV      xivu_iv;        /* integer value or pv offset */
 284         UV      xivu_uv;
 285         void *  xivu_p1;
 286     }           xiv_u;
 287 };
 288
 289 #if 0
 290 typedef struct xpviv xpviv_allocated;
 291 #else
 292 typedef struct {
 293     STRLEN      xpv_cur;        /* length of svu_pv as a C string */
 294     STRLEN      xpv_len;        /* allocated size */
 295     union {
 296         IV      xivu_iv;        /* integer value or pv offset */
 297         UV      xivu_uv;
 298         void *  xivu_p1;
 299     }           xiv_u;
 300 } xpviv_allocated;
 301 #endif
 302
 303 #define xiv_iv xiv_u.xivu_iv
 304
 305 struct xpvuv {
 306     NV          xnv_nv;         /* numeric value, if any */
 307     STRLEN      xpv_cur;        /* length of svu_pv as a C string */
 308     STRLEN      xpv_len;        /* allocated size */
 309     union {
 310         IV      xuvu_iv;
 311         UV      xuvu_uv;        /* unsigned value or pv offset */
 312         void *  xuvu_p1;
 313     }           xuv_u;
 314 };
 315
 316 #define xuv_uv xuv_u.xuvu_uv
 317
 318 struct xpvnv {
 319     NV          xnv_nv;         /* numeric value, if any */
 320     STRLEN      xpv_cur;        /* length of svu_pv as a C string */
 321     STRLEN      xpv_len;        /* allocated size */
 322     union {
 323         IV      xivu_iv;        /* integer value or pv offset */
 324         UV      xivu_uv;
 325         void *  xivu_p1;
 326     }           xiv_u;
 327 };
 328
 329 /* These structure must match the beginning of struct xpvhv in hv.h. */
 330 struct xpvmg {
 331     NV          xnv_nv;         /* numeric value, if any */
 332     STRLEN      xpv_cur;        /* length of svu_pv as a C string */
 333     STRLEN      xpv_len;        /* allocated size */
 334     union {
 335         IV      xivu_iv;        /* integer value or pv offset */
 336         UV      xivu_uv;
 337         void *  xivu_p1;
 338     }           xiv_u;
 339     MAGIC*      xmg_magic;      /* linked list of magicalness */
 340     HV*         xmg_stash;      /* class package */
 341 };
 342
 343 struct xpvlv {
 344     NV          xnv_nv;         /* numeric value, if any */
 345     STRLEN      xpv_cur;        /* length of svu_pv as a C string */
 346     STRLEN      xpv_len;        /* allocated size */
 347     union {
 348         IV      xivu_iv;        /* integer value or pv offset */
 349         UV      xivu_uv;
 350         void *  xivu_p1;
 351     }           xiv_u;
 352     MAGIC*      xmg_magic;      /* linked list of magicalness */
 353     HV*         xmg_stash;      /* class package */
 354
 355     /* a full glob fits into this */
 356     GP*         xgv_gp;
 357     char*       xgv_name;
 358     STRLEN      xgv_namelen;
 359     HV*         xgv_stash;
 360     U8          xgv_flags;
 361
 362     STRLEN      xlv_targoff;
 363     STRLEN      xlv_targlen;
 364     SV*         xlv_targ;
 365     char        xlv_type;       /* k=keys .=pos x=substr v=vec /=join/re
 366                                  * y=alem/helem/iter t=tie T=tied HE */
 367 };
 368
 369 struct xpvgv {
 370     NV          xnv_nv;         /* numeric value, if any */
 371     STRLEN      xpv_cur;        /* length of svu_pv as a C string */
 372     STRLEN      xpv_len;        /* allocated size */
 373     union {
 374         IV      xivu_iv;        /* integer value or pv offset */
 375         UV      xivu_uv;
 376         void *  xivu_p1;
 377     }           xiv_u;
 378     MAGIC*      xmg_magic;      /* linked list of magicalness */
 379     HV*         xmg_stash;      /* class package */
 380
 381     GP*         xgv_gp;
 382     char*       xgv_name;
 383     STRLEN      xgv_namelen;
 384     HV*         xgv_stash;
 385     U8          xgv_flags;
 386 };
 387
 388 struct xpvbm {
 389     NV          xnv_nv;         /* numeric value, if any */
 390     STRLEN      xpv_cur;        /* length of svu_pv as a C string */
 391     STRLEN      xpv_len;        /* allocated size */
 392     union {
 393         IV      xivu_iv;        /* integer value or pv offset */
 394         UV      xivu_uv;
 395         void *  xivu_p1;
 396     }           xiv_u;
 397     MAGIC*      xmg_magic;      /* linked list of magicalness */
 398     HV*         xmg_stash;      /* class package */
 399
 400     I32         xbm_useful;     /* is this constant pattern being useful? */
 401     U16         xbm_previous;   /* how many characters in string before rare? */
 402     U8          xbm_rare;       /* rarest character in string */
 403 };
 404
 405 /* This structure must match XPVCV in cv.h */
 406
 407 typedef U16 cv_flags_t;
 408
 409 struct xpvfm {
 410     NV          xnv_nv;         /* numeric value, if any */
 411     STRLEN      xpv_cur;        /* length of svu_pv as a C string */
 412     STRLEN      xpv_len;        /* allocated size */
 413     union {
 414         IV      xivu_iv;        /* integer value or pv offset */
 415         UV      xivu_uv;
 416         void *  xivu_p1;
 417     }           xiv_u;
 418     MAGIC*      xmg_magic;      /* linked list of magicalness */
 419     HV*         xmg_stash;      /* class package */
 420
 421     HV *        xcv_stash;
 422     OP *        xcv_start;
 423     OP *        xcv_root;
 424     void      (*xcv_xsub)(pTHX_ CV*);
 425     ANY         xcv_xsubany;
 426     GV *        xcv_gv;
 427     char *      xcv_file;
 428     long        xcv_depth;      /* >= 2 indicates recursive call */
 429     AV *        xcv_padlist;
 430     CV *        xcv_outside;
 431     cv_flags_t  xcv_flags;
 432     U32         xcv_outside_seq; /* the COP sequence (at the point of our
 433                                   * compilation) in the lexically enclosing
 434                                   * sub */
 435     IV          xfm_lines;
 436 };
 437
 438 struct xpvio {
 439     NV          xnv_nv;         /* numeric value, if any */
 440     STRLEN      xpv_cur;        /* length of svu_pv as a C string */
 441     STRLEN      xpv_len;        /* allocated size */
 442     union {
 443         IV      xivu_iv;        /* integer value or pv offset */
 444         UV      xivu_uv;
 445         void *  xivu_p1;
 446     }           xiv_u;
 447     MAGIC*      xmg_magic;      /* linked list of magicalness */
 448     HV*         xmg_stash;      /* class package */
 449
 450     PerlIO *    xio_ifp;        /* ifp and ofp are normally the same */
 451     PerlIO *    xio_ofp;        /* but sockets need separate streams */
 452     /* Cray addresses everything by word boundaries (64 bits) and
 453      * code and data pointers cannot be mixed (which is exactly what
 454      * Perl_filter_add() tries to do with the dirp), hence the following
 455      * union trick (as suggested by Gurusamy Sarathy).
 456      * For further information see Geir Johansen's problem report titled
 457        [ID 20000612.002] Perl problem on Cray system
 458      * The any pointer (known as IoANY()) will also be a good place
 459      * to hang any IO disciplines to.
 460      */
 461     union {
 462         DIR *   xiou_dirp;      /* for opendir, readdir, etc */
 463         void *  xiou_any;       /* for alignment */
 464     } xio_dirpu;
 465     IV          xio_lines;      /* $. */
 466     IV          xio_page;       /* $% */
 467     IV          xio_page_len;   /* $= */
 468     IV          xio_lines_left; /* $- */
 469     char *      xio_top_name;   /* $^ */
 470     GV *        xio_top_gv;     /* $^ */
 471     char *      xio_fmt_name;   /* $~ */
 472     GV *        xio_fmt_gv;     /* $~ */
 473     char *      xio_bottom_name;/* $^B */
 474     GV *        xio_bottom_gv;  /* $^B */
 475     short       xio_subprocess; /* -| or |- */
 476     char        xio_type;
 477     char        xio_flags;
 478 };
 479 #define xio_dirp        xio_dirpu.xiou_dirp
 480 #define xio_any         xio_dirpu.xiou_any
 481
 482 #define IOf_ARGV        1       /* this fp iterates over ARGV */
 483 #define IOf_START       2       /* check for null ARGV and substitute '-' */
 484 #define IOf_FLUSH       4       /* this fp wants a flush after write op */
 485 #define IOf_DIDTOP      8       /* just did top of form */
 486 #define IOf_UNTAINT     16      /* consider this fp (and its data) "safe" */
 487 #define IOf_NOLINE      32      /* slurped a pseudo-line from empty file */
 488 #define IOf_FAKE_DIRP   64      /* xio_dirp is fake (source filters kludge) */
 489
 490 /* The following macros define implementation-independent predicates on SVs. */
 491
 492 /*
 493 =for apidoc Am|bool|SvNIOK|SV* sv
 494 Returns a boolean indicating whether the SV contains a number, integer or
 495 double.
 496
 497 =for apidoc Am|bool|SvNIOKp|SV* sv
 498 Returns a boolean indicating whether the SV contains a number, integer or
 499 double.  Checks the B<private> setting.  Use C<SvNIOK>.
 500
 501 =for apidoc Am|void|SvNIOK_off|SV* sv
 502 Unsets the NV/IV status of an SV.
 503
 504 =for apidoc Am|bool|SvOK|SV* sv
 505 Returns a boolean indicating whether the value is an SV. It also tells
 506 whether the value is defined or not.
 507
 508 =for apidoc Am|bool|SvIOKp|SV* sv
 509 Returns a boolean indicating whether the SV contains an integer.  Checks
 510 the B<private> setting.  Use C<SvIOK>.
 511
 512 =for apidoc Am|bool|SvNOKp|SV* sv
 513 Returns a boolean indicating whether the SV contains a double.  Checks the
 514 B<private> setting.  Use C<SvNOK>.
 515
 516 =for apidoc Am|bool|SvPOKp|SV* sv
 517 Returns a boolean indicating whether the SV contains a character string.
 518 Checks the B<private> setting.  Use C<SvPOK>.
 519
 520 =for apidoc Am|bool|SvIOK|SV* sv
 521 Returns a boolean indicating whether the SV contains an integer.
 522
 523 =for apidoc Am|void|SvIOK_on|SV* sv
 524 Tells an SV that it is an integer.
 525
 526 =for apidoc Am|void|SvIOK_off|SV* sv
 527 Unsets the IV status of an SV.
 528
 529 =for apidoc Am|void|SvIOK_only|SV* sv
 530 Tells an SV that it is an integer and disables all other OK bits.
 531
 532 =for apidoc Am|void|SvIOK_only_UV|SV* sv
 533 Tells and SV that it is an unsigned integer and disables all other OK bits.
 534
 535 =for apidoc Am|bool|SvIOK_UV|SV* sv
 536 Returns a boolean indicating whether the SV contains an unsigned integer.
 537
 538 =for apidoc Am|void|SvUOK|SV* sv
 539 Returns a boolean indicating whether the SV contains an unsigned integer.
 540
 541 =for apidoc Am|bool|SvIOK_notUV|SV* sv
 542 Returns a boolean indicating whether the SV contains a signed integer.
 543
 544 =for apidoc Am|bool|SvNOK|SV* sv
 545 Returns a boolean indicating whether the SV contains a double.
 546
 547 =for apidoc Am|void|SvNOK_on|SV* sv
 548 Tells an SV that it is a double.
 549
 550 =for apidoc Am|void|SvNOK_off|SV* sv
 551 Unsets the NV status of an SV.
 552
 553 =for apidoc Am|void|SvNOK_only|SV* sv
 554 Tells an SV that it is a double and disables all other OK bits.
 555
 556 =for apidoc Am|bool|SvPOK|SV* sv
 557 Returns a boolean indicating whether the SV contains a character
 558 string.
 559
 560 =for apidoc Am|void|SvPOK_on|SV* sv
 561 Tells an SV that it is a string.
 562
 563 =for apidoc Am|void|SvPOK_off|SV* sv
 564 Unsets the PV status of an SV.
 565
 566 =for apidoc Am|void|SvPOK_only|SV* sv
 567 Tells an SV that it is a string and disables all other OK bits.
 568 Will also turn off the UTF-8 status.
 569
 570 =for apidoc Am|bool|SvVOK|SV* sv
 571 Returns a boolean indicating whether the SV contains a v-string.
 572
 573 =for apidoc Am|bool|SvOOK|SV* sv
 574 Returns a boolean indicating whether the SvIVX is a valid offset value for
 575 the SvPVX.  This hack is used internally to speed up removal of characters
 576 from the beginning of a SvPV.  When SvOOK is true, then the start of the
 577 allocated string buffer is really (SvPVX - SvIVX).
 578
 579 =for apidoc Am|bool|SvROK|SV* sv
 580 Tests if the SV is an RV.
 581
 582 =for apidoc Am|void|SvROK_on|SV* sv
 583 Tells an SV that it is an RV.
 584
 585 =for apidoc Am|void|SvROK_off|SV* sv
 586 Unsets the RV status of an SV.
 587
 588 =for apidoc Am|SV*|SvRV|SV* sv
 589 Dereferences an RV to return the SV.
 590
 591 =for apidoc Am|IV|SvIVX|SV* sv
 592 Returns the raw value in the SV's IV slot, without checks or conversions.
 593 Only use when you are sure SvIOK is true. See also C<SvIV()>.
 594
 595 =for apidoc Am|UV|SvUVX|SV* sv
 596 Returns the raw value in the SV's UV slot, without checks or conversions.
 597 Only use when you are sure SvIOK is true. See also C<SvUV()>.
 598
 599 =for apidoc Am|NV|SvNVX|SV* sv
 600 Returns the raw value in the SV's NV slot, without checks or conversions.
 601 Only use when you are sure SvNOK is true. See also C<SvNV()>.
 602
 603 =for apidoc Am|char*|SvPVX|SV* sv
 604 Returns a pointer to the physical string in the SV.  The SV must contain a
 605 string.
 606
 607 =for apidoc Am|STRLEN|SvCUR|SV* sv
 608 Returns the length of the string which is in the SV.  See C<SvLEN>.
 609
 610 =for apidoc Am|STRLEN|SvLEN|SV* sv
 611 Returns the size of the string buffer in the SV, not including any part
 612 attributable to C<SvOOK>.  See C<SvCUR>.
 613
 614 =for apidoc Am|char*|SvEND|SV* sv
 615 Returns a pointer to the last character in the string which is in the SV.
 616 See C<SvCUR>.  Access the character as *(SvEND(sv)).
 617
 618 =for apidoc Am|HV*|SvSTASH|SV* sv
 619 Returns the stash of the SV.
 620
 621 =for apidoc Am|void|SvIV_set|SV* sv|IV val
 622 Set the value of the IV pointer in sv to val.  It is possible to perform
 623 the same function of this macro with an lvalue assignment to C<SvIVX>.
 624 With future Perls, however, it will be more efficient to use
 625 C<SvIV_set> instead of the lvalue assignment to C<SvIVX>.
 626
 627 =for apidoc Am|void|SvNV_set|SV* sv|NV val
 628 Set the value of the NV pointer in sv to val.  See C<SvIV_set>.
 629
 630 =for apidoc Am|void|SvPV_set|SV* sv|char* val
 631 Set the value of the PV pointer in sv to val.  See C<SvIV_set>.
 632
 633 =for apidoc Am|void|SvUV_set|SV* sv|UV val
 634 Set the value of the UV pointer in sv to val.  See C<SvIV_set>.
 635
 636 =for apidoc Am|void|SvRV_set|SV* sv|SV* val
 637 Set the value of the RV pointer in sv to val.  See C<SvIV_set>.
 638
 639 =for apidoc Am|void|SvMAGIC_set|SV* sv|MAGIC* val
 640 Set the value of the MAGIC pointer in sv to val.  See C<SvIV_set>.
 641
 642 =for apidoc Am|void|SvSTASH_set|SV* sv|STASH* val
 643 Set the value of the STASH pointer in sv to val.  See C<SvIV_set>.
 644
 645 =for apidoc Am|void|SvCUR_set|SV* sv|STRLEN len
 646 Set the current length of the string which is in the SV.  See C<SvCUR>
 647 and C<SvIV_set>.
 648
 649 =for apidoc Am|void|SvLEN_set|SV* sv|STRLEN len
 650 Set the actual length of the string which is in the SV.  See C<SvIV_set>.
 651
 652 =cut
 653 */
 654
 655 #define SvNIOK(sv)              (SvFLAGS(sv) & (SVf_IOK|SVf_NOK))
 656 #define SvNIOKp(sv)             (SvFLAGS(sv) & (SVp_IOK|SVp_NOK))
 657 #define SvNIOK_off(sv)          (SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK| \
 658                                                   SVp_IOK|SVp_NOK|SVf_IVisUV))
 659
 660 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
 661 #define assert_not_ROK(sv)      ({assert(!SvROK(sv) || !SvRV(sv));}),
 662 #else
 663 #define assert_not_ROK(sv)
 664 #endif
 665
 666 #define SvOK(sv)                (SvFLAGS(sv) & SVf_OK)
 667 #define SvOK_off(sv)            (assert_not_ROK(sv)                     \
 668                                  SvFLAGS(sv) &= ~(SVf_OK|SVf_AMAGIC|    \
 669                                                   SVf_IVisUV|SVf_UTF8), \
 670                                                         SvOOK_off(sv))
 671 #define SvOK_off_exc_UV(sv)     (assert_not_ROK(sv)                     \
 672                                  SvFLAGS(sv) &= ~(SVf_OK|SVf_AMAGIC|    \
 673                                                   SVf_UTF8),            \
 674                                                         SvOOK_off(sv))
 675
 676 #define SvOKp(sv)               (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK))
 677 #define SvIOKp(sv)              (SvFLAGS(sv) & SVp_IOK)
 678 #define SvIOKp_on(sv)           (SvRELEASE_IVX(sv), \
 679                                     SvFLAGS(sv) |= SVp_IOK)
 680 #define SvNOKp(sv)              (SvFLAGS(sv) & SVp_NOK)
 681 #define SvNOKp_on(sv)           (SvFLAGS(sv) |= SVp_NOK)
 682 #define SvPOKp(sv)              (SvFLAGS(sv) & SVp_POK)
 683 #define SvPOKp_on(sv)           (assert_not_ROK(sv)                     \
 684                                  SvFLAGS(sv) |= SVp_POK)
 685
 686 #define SvIOK(sv)               (SvFLAGS(sv) & SVf_IOK)
 687 #define SvIOK_on(sv)            (SvRELEASE_IVX(sv), \
 688                                     SvFLAGS(sv) |= (SVf_IOK|SVp_IOK))
 689 #define SvIOK_off(sv)           (SvFLAGS(sv) &= ~(SVf_IOK|SVp_IOK|SVf_IVisUV))
 690 #define SvIOK_only(sv)          (SvOK_off(sv), \
 691                                     SvFLAGS(sv) |= (SVf_IOK|SVp_IOK))
 692 #define SvIOK_only_UV(sv)       (SvOK_off_exc_UV(sv), \
 693                                     SvFLAGS(sv) |= (SVf_IOK|SVp_IOK))
 694
 695 #define SvIOK_UV(sv)            ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV))   \
 696                                  == (SVf_IOK|SVf_IVisUV))
 697 #define SvUOK(sv)               SvIOK_UV(sv)
 698 #define SvIOK_notUV(sv)         ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV))   \
 699                                  == SVf_IOK)
 700
 701 #define SvIsUV(sv)              (SvFLAGS(sv) & SVf_IVisUV)
 702 #define SvIsUV_on(sv)           (SvFLAGS(sv) |= SVf_IVisUV)
 703 #define SvIsUV_off(sv)          (SvFLAGS(sv) &= ~SVf_IVisUV)
 704
 705 #define SvNOK(sv)               (SvFLAGS(sv) & SVf_NOK)
 706 #define SvNOK_on(sv)            (SvFLAGS(sv) |= (SVf_NOK|SVp_NOK))
 707 #define SvNOK_off(sv)           (SvFLAGS(sv) &= ~(SVf_NOK|SVp_NOK))
 708 #define SvNOK_only(sv)          (SvOK_off(sv), \
 709                                     SvFLAGS(sv) |= (SVf_NOK|SVp_NOK))
 710
 711 /*
 712 =for apidoc Am|bool|SvUTF8|SV* sv
 713 Returns a boolean indicating whether the SV contains UTF-8 encoded data.
 714
 715 =for apidoc Am|void|SvUTF8_on|SV *sv
 716 Turn on the UTF-8 status of an SV (the data is not changed, just the flag).
 717 Do not use frivolously.
 718
 719 =for apidoc Am|void|SvUTF8_off|SV *sv
 720 Unsets the UTF-8 status of an SV.
 721
 722 =for apidoc Am|void|SvPOK_only_UTF8|SV* sv
 723 Tells an SV that it is a string and disables all other OK bits,
 724 and leaves the UTF-8 status as it was.
 725
 726 =cut
 727  */
 728
 729 /* Ensure the return value of this macro does not clash with the GV_ADD* flags
 730 in gv.h: */
 731 #define SvUTF8(sv)              (SvFLAGS(sv) & SVf_UTF8)
 732 #define SvUTF8_on(sv)           (SvFLAGS(sv) |= (SVf_UTF8))
 733 #define SvUTF8_off(sv)          (SvFLAGS(sv) &= ~(SVf_UTF8))
 734
 735 #define SvPOK(sv)               (SvFLAGS(sv) & SVf_POK)
 736 #define SvPOK_on(sv)            (assert_not_ROK(sv)                     \
 737                                  SvFLAGS(sv) |= (SVf_POK|SVp_POK))
 738 #define SvPOK_off(sv)           (SvFLAGS(sv) &= ~(SVf_POK|SVp_POK))
 739 #define SvPOK_only(sv)          (assert_not_ROK(sv)                     \
 740                                  SvFLAGS(sv) &= ~(SVf_OK|SVf_AMAGIC|    \
 741                                                   SVf_IVisUV|SVf_UTF8), \
 742                                     SvFLAGS(sv) |= (SVf_POK|SVp_POK))
 743 #define SvPOK_only_UTF8(sv)     (assert_not_ROK(sv)                     \
 744                                  SvFLAGS(sv) &= ~(SVf_OK|SVf_AMAGIC|    \
 745                                                   SVf_IVisUV),          \
 746                                     SvFLAGS(sv) |= (SVf_POK|SVp_POK))
 747
 748 #define SvVOK(sv)               (SvMAGICAL(sv) && mg_find(sv,'V'))
 749 #define SvOOK(sv)               (SvFLAGS(sv) & SVf_OOK)
 750 #define SvOOK_on(sv)            ((void)SvIOK_off(sv), SvFLAGS(sv) |= SVf_OOK)
 751 #define SvOOK_off(sv)           ((void)(SvOOK(sv) && sv_backoff(sv)))
 752
 753 #define SvFAKE(sv)              (SvFLAGS(sv) & SVf_FAKE)
 754 #define SvFAKE_on(sv)           (SvFLAGS(sv) |= SVf_FAKE)
 755 #define SvFAKE_off(sv)          (SvFLAGS(sv) &= ~SVf_FAKE)
 756
 757 #define SvROK(sv)               (SvFLAGS(sv) & SVf_ROK)
 758 #define SvROK_on(sv)            (SvFLAGS(sv) |= SVf_ROK)
 759 #define SvROK_off(sv)           (SvFLAGS(sv) &= ~(SVf_ROK|SVf_AMAGIC))
 760
 761 #define SvMAGICAL(sv)           (SvFLAGS(sv) & (SVs_GMG|SVs_SMG|SVs_RMG))
 762 #define SvMAGICAL_on(sv)        (SvFLAGS(sv) |= (SVs_GMG|SVs_SMG|SVs_RMG))
 763 #define SvMAGICAL_off(sv)       (SvFLAGS(sv) &= ~(SVs_GMG|SVs_SMG|SVs_RMG))
 764
 765 #define SvGMAGICAL(sv)          (SvFLAGS(sv) & SVs_GMG)
 766 #define SvGMAGICAL_on(sv)       (SvFLAGS(sv) |= SVs_GMG)
 767 #define SvGMAGICAL_off(sv)      (SvFLAGS(sv) &= ~SVs_GMG)
 768
 769 #define SvSMAGICAL(sv)          (SvFLAGS(sv) & SVs_SMG)
 770 #define SvSMAGICAL_on(sv)       (SvFLAGS(sv) |= SVs_SMG)
 771 #define SvSMAGICAL_off(sv)      (SvFLAGS(sv) &= ~SVs_SMG)
 772
 773 #define SvRMAGICAL(sv)          (SvFLAGS(sv) & SVs_RMG)
 774 #define SvRMAGICAL_on(sv)       (SvFLAGS(sv) |= SVs_RMG)
 775 #define SvRMAGICAL_off(sv)      (SvFLAGS(sv) &= ~SVs_RMG)
 776
 777 #define SvAMAGIC(sv)            (SvFLAGS(sv) & SVf_AMAGIC)
 778 #define SvAMAGIC_on(sv)         (SvFLAGS(sv) |= SVf_AMAGIC)
 779 #define SvAMAGIC_off(sv)        (SvFLAGS(sv) &= ~SVf_AMAGIC)
 780
 781 #define SvGAMAGIC(sv)           (SvFLAGS(sv) & (SVs_GMG|SVf_AMAGIC))
 782
 783 /*
 784 #define Gv_AMG(stash) \
 785         (HV_AMAGICmb(stash) && \
 786          ((!HV_AMAGICbad(stash) && HV_AMAGIC(stash)) || Gv_AMupdate(stash)))
 787 */
 788 #define Gv_AMG(stash)           (PL_amagic_generation && Gv_AMupdate(stash))
 789
 790 #define SvWEAKREF(sv)           ((SvFLAGS(sv) & (SVf_ROK|SVprv_WEAKREF)) \
 791                                   == (SVf_ROK|SVprv_WEAKREF))
 792 #define SvWEAKREF_on(sv)        (SvFLAGS(sv) |=  (SVf_ROK|SVprv_WEAKREF))
 793 #define SvWEAKREF_off(sv)       (SvFLAGS(sv) &= ~(SVf_ROK|SVprv_WEAKREF))
 794
 795 #define SvTHINKFIRST(sv)        (SvFLAGS(sv) & SVf_THINKFIRST)
 796
 797 #define SvPADSTALE(sv)          (SvFLAGS(sv) & SVs_PADSTALE)
 798 #define SvPADSTALE_on(sv)       (SvFLAGS(sv) |= SVs_PADSTALE)
 799 #define SvPADSTALE_off(sv)      (SvFLAGS(sv) &= ~SVs_PADSTALE)
 800
 801 #define SvPADTMP(sv)            (SvFLAGS(sv) & SVs_PADTMP)
 802 #define SvPADTMP_on(sv)         (SvFLAGS(sv) |= SVs_PADTMP)
 803 #define SvPADTMP_off(sv)        (SvFLAGS(sv) &= ~SVs_PADTMP)
 804
 805 #define SvPADMY(sv)             (SvFLAGS(sv) & SVs_PADMY)
 806 #define SvPADMY_on(sv)          (SvFLAGS(sv) |= SVs_PADMY)
 807
 808 #define SvTEMP(sv)              (SvFLAGS(sv) & SVs_TEMP)
 809 #define SvTEMP_on(sv)           (SvFLAGS(sv) |= SVs_TEMP)
 810 #define SvTEMP_off(sv)          (SvFLAGS(sv) &= ~SVs_TEMP)
 811
 812 #define SvOBJECT(sv)            (SvFLAGS(sv) & SVs_OBJECT)
 813 #define SvOBJECT_on(sv)         (SvFLAGS(sv) |= SVs_OBJECT)
 814 #define SvOBJECT_off(sv)        (SvFLAGS(sv) &= ~SVs_OBJECT)
 815
 816 #define SvREADONLY(sv)          (SvFLAGS(sv) & SVf_READONLY)
 817 #define SvREADONLY_on(sv)       (SvFLAGS(sv) |= SVf_READONLY)
 818 #define SvREADONLY_off(sv)      (SvFLAGS(sv) &= ~SVf_READONLY)
 819
 820 #define SvSCREAM(sv)            (SvFLAGS(sv) & SVp_SCREAM)
 821 #define SvSCREAM_on(sv)         (SvFLAGS(sv) |= SVp_SCREAM)
 822 #define SvSCREAM_off(sv)        (SvFLAGS(sv) &= ~SVp_SCREAM)
 823
 824 #define SvCOMPILED(sv)          (SvFLAGS(sv) & SVpfm_COMPILED)
 825 #define SvCOMPILED_on(sv)       (SvFLAGS(sv) |= SVpfm_COMPILED)
 826 #define SvCOMPILED_off(sv)      (SvFLAGS(sv) &= ~SVpfm_COMPILED)
 827
 828 #define SvEVALED(sv)            (SvFLAGS(sv) & SVrepl_EVAL)
 829 #define SvEVALED_on(sv)         (SvFLAGS(sv) |= SVrepl_EVAL)
 830 #define SvEVALED_off(sv)        (SvFLAGS(sv) &= ~SVrepl_EVAL)
 831
 832 #define SvTAIL(sv)              (SvFLAGS(sv) & SVpbm_TAIL)
 833 #define SvTAIL_on(sv)           (SvFLAGS(sv) |= SVpbm_TAIL)
 834 #define SvTAIL_off(sv)          (SvFLAGS(sv) &= ~SVpbm_TAIL)
 835
 836 #define SvVALID(sv)             (SvFLAGS(sv) & SVpbm_VALID)
 837 #define SvVALID_on(sv)          (SvFLAGS(sv) |= SVpbm_VALID)
 838 #define SvVALID_off(sv)         (SvFLAGS(sv) &= ~SVpbm_VALID)
 839
 840 #ifdef USE_ITHREADS
 841 /* The following uses the FAKE flag to show that a regex pointer is infact
 842    its own offset in the regexpad for ithreads */
 843 #define SvREPADTMP(sv)          (SvFLAGS(sv) & SVf_FAKE)
 844 #define SvREPADTMP_on(sv)       (SvFLAGS(sv) |= SVf_FAKE)
 845 #define SvREPADTMP_off(sv)      (SvFLAGS(sv) &= ~SVf_FAKE)
 846 #endif
 847
 848 #ifdef PERL_DEBUG_COW
 849 #define SvRV(sv) (0 + (sv)->sv_u.svu_rv)
 850 #else
 851 #define SvRV(sv) ((sv)->sv_u.svu_rv)
 852 #endif
 853 #define SvRVx(sv) SvRV(sv)
 854
 855 #ifdef PERL_DEBUG_COW
 856 /* Need -0.0 for SvNVX to preserve IEEE FP "negative zero" because
 857    +0.0 + -0.0 => +0.0 but -0.0 + -0.0 => -0.0 */
 858 #  define SvIVX(sv) (0 + ((XPVIV*) SvANY(sv))->xiv_iv)
 859 #  define SvUVX(sv) (0 + ((XPVUV*) SvANY(sv))->xuv_uv)
 860 #  define SvNVX(sv) (-0.0 + ((XPVNV*) SvANY(sv))->xnv_nv)
 861 /* Don't test the core XS code yet.  */
 862 #  if defined (PERL_CORE) && PERL_DEBUG_COW > 1
 863 #    define SvPVX(sv) (0 + (assert(!SvREADONLY(sv)), (sv)->sv_u.svu_pv))
 864 #  else
 865 #  define SvPVX(sv) SvPVX_mutable(sv)
 866 #  endif
 867 #  define SvCUR(sv) (0 + ((XPV*) SvANY(sv))->xpv_cur)
 868 #  define SvLEN(sv) (0 + ((XPV*) SvANY(sv))->xpv_len)
 869 #  define SvEND(sv) ((sv)->sv_u.svu_pv + ((XPV*)SvANY(sv))->xpv_cur)
 870
 871 #  ifdef DEBUGGING
 872 #    ifdef PERL_IN_SV_C
 873 /* Can't make this RVALUE because of Perl_sv_unmagic.  */
 874 #      define SvMAGIC(sv)       (*(assert(SvTYPE(sv) >= SVt_PVMG), &((XPVMG*)  SvANY(sv))->xmg_magic))
 875 #    else
 876 #      define SvMAGIC(sv)       (0 + *(assert(SvTYPE(sv) >= SVt_PVMG), &((XPVMG*)  SvANY(sv))->xmg_magic))
 877 #    endif
 878 #  define SvSTASH(sv)   (0 + *(assert(SvTYPE(sv) >= SVt_PVMG), &((XPVMG*)  SvANY(sv))->xmg_stash))
 879 #  else
 880 #    ifdef PERL_IN_SV_C
 881 #      define SvMAGIC(sv) ((XPVMG*)  SvANY(sv))->xmg_magic
 882 #    else
 883 #      define SvMAGIC(sv) (0 + ((XPVMG*)  SvANY(sv))->xmg_magic)
 884 #    endif
 885 #  define SvSTASH(sv)     (0 + ((XPVMG*)  SvANY(sv))->xmg_stash)
 886 #  endif
 887 #else
 888 #  define SvIVX(sv) ((XPVIV*) SvANY(sv))->xiv_iv
 889 #  define SvUVX(sv) ((XPVUV*) SvANY(sv))->xuv_uv
 890 #  define SvNVX(sv) ((XPVNV*) SvANY(sv))->xnv_nv
 891 #  define SvPVX(sv) ((sv)->sv_u.svu_pv)
 892 #  define SvCUR(sv) ((XPV*) SvANY(sv))->xpv_cur
 893 #  define SvLEN(sv) ((XPV*) SvANY(sv))->xpv_len
 894 #  define SvEND(sv) ((sv)->sv_u.svu_pv + ((XPV*)SvANY(sv))->xpv_cur)
 895
 896 #  ifdef DEBUGGING
 897 #    define SvMAGIC(sv) (*(assert(SvTYPE(sv) >= SVt_PVMG), &((XPVMG*)  SvANY(sv))->xmg_magic))
 898 #    define SvSTASH(sv) (*(assert(SvTYPE(sv) >= SVt_PVMG), &((XPVMG*)  SvANY(sv))->xmg_stash))
 899 #  else
 900 #    define SvMAGIC(sv) ((XPVMG*)  SvANY(sv))->xmg_magic
 901 #    define SvSTASH(sv) ((XPVMG*)  SvANY(sv))->xmg_stash
 902 #  endif
 903 #endif
 904
 905 #ifndef PERL_POISON
 906 /* Given that these two are new, there can't be any existing code using them
 907  *  as LVALUEs  */
 908 #  define SvPVX_mutable(sv)     (0 + (sv)->sv_u.svu_pv)
 909 #  define SvPVX_const(sv)       ((const char*)(0 + (sv)->sv_u.svu_pv))
 910 #else
 911 /* Except for the poison code, which uses & to scribble over the pointer after
 912    free() is called.  */
 913 #  define SvPVX_mutable(sv)     ((sv)->sv_u.svu_pv)
 914 #  define SvPVX_const(sv)       ((const char*)((sv)->sv_u.svu_pv))
 915 #endif
 916
 917 #define SvIVXx(sv) SvIVX(sv)
 918 #define SvUVXx(sv) SvUVX(sv)
 919 #define SvNVXx(sv) SvNVX(sv)
 920 #define SvPVXx(sv) SvPVX(sv)
 921 #define SvLENx(sv) SvLEN(sv)
 922 #define SvENDx(sv) ((PL_Sv = (sv)), SvEND(PL_Sv))
 923
 924
 925 /* Ask a scalar nicely to try to become an IV, if possible.
 926    Not guaranteed to stay returning void */
 927 /* Macro won't actually call sv_2iv if already IOK */
 928 #define SvIV_please(sv) \
 929         STMT_START {if (!SvIOKp(sv) && (SvNOK(sv) || SvPOK(sv))) \
 930                 (void) SvIV(sv); } STMT_END
 931 #define SvIV_set(sv, val) \
 932         STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
 933                 (((XPVIV*)  SvANY(sv))->xiv_iv = (val)); } STMT_END
 934 #define SvNV_set(sv, val) \
 935         STMT_START { assert(SvTYPE(sv) == SVt_NV || SvTYPE(sv) >= SVt_PVNV); \
 936             assert(SvTYPE(sv) != SVt_PVAV); assert(SvTYPE(sv) != SVt_PVHV); \
 937                 (((XPVNV*)SvANY(sv))->xnv_nv = (val)); } STMT_END
 938 #define SvPV_set(sv, val) \
 939         STMT_START { assert(SvTYPE(sv) >= SVt_PV); \
 940                 ((sv)->sv_u.svu_pv = (val)); } STMT_END
 941 #define SvUV_set(sv, val) \
 942         STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
 943                 (((XPVUV*)SvANY(sv))->xuv_uv = (val)); } STMT_END
 944 #define SvRV_set(sv, val) \
 945         STMT_START { assert(SvTYPE(sv) >=  SVt_RV); \
 946                 ((sv)->sv_u.svu_rv = (val)); } STMT_END
 947 #define SvMAGIC_set(sv, val) \
 948         STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
 949                 (((XPVMG*)SvANY(sv))->xmg_magic = (val)); } STMT_END
 950 #define SvSTASH_set(sv, val) \
 951         STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
 952                 (((XPVMG*)  SvANY(sv))->xmg_stash = (val)); } STMT_END
 953 #define SvCUR_set(sv, val) \
 954         STMT_START { assert(SvTYPE(sv) >= SVt_PV); \
 955                 (((XPV*)  SvANY(sv))->xpv_cur = (val)); } STMT_END
 956 #define SvLEN_set(sv, val) \
 957         STMT_START { assert(SvTYPE(sv) >= SVt_PV); \
 958                 (((XPV*)  SvANY(sv))->xpv_len = (val)); } STMT_END
 959 #define SvEND_set(sv, val) \
 960         STMT_START { assert(SvTYPE(sv) >= SVt_PV); \
 961                 (SvCUR(sv) = (val) - SvPVX(sv)); } STMT_END
 962
 963 #define SvPV_renew(sv,n) \
 964         STMT_START { SvLEN_set(sv, n); \
 965                 SvPV_set((sv), (MEM_WRAP_CHECK_(n,char)                 \
 966                                 (char*)saferealloc((Malloc_t)SvPVX(sv), \
 967                                                    (MEM_SIZE)((n)))));  \
 968                  } STMT_END
 969
 970 #define SvPV_shrink_to_cur(sv) STMT_START { \
 971                    const STRLEN _lEnGtH = SvCUR(sv) + 1; \
 972                    SvPV_renew(sv, _lEnGtH); \
 973                  } STMT_END
 974
 975 #define SvPV_free(sv)                                                   \
 976     STMT_START {                                                        \
 977                      assert(SvTYPE(sv) >= SVt_PV);                      \
 978                      if (SvLEN(sv)) {                                   \
 979                          if(SvOOK(sv)) {                                \
 980                              SvPV_set(sv, SvPVX_mutable(sv) - SvIVX(sv)); \
 981                              SvFLAGS(sv) &= ~SVf_OOK;                   \
 982                          }                                              \
 983                          Safefree(SvPVX(sv));                           \
 984                      }                                                  \
 985                  } STMT_END
 986
 987 #define BmRARE(sv)      ((XPVBM*)  SvANY(sv))->xbm_rare
 988 #define BmUSEFUL(sv)    ((XPVBM*)  SvANY(sv))->xbm_useful
 989 #define BmPREVIOUS(sv)  ((XPVBM*)  SvANY(sv))->xbm_previous
 990
 991 #define FmLINES(sv)     ((XPVFM*)  SvANY(sv))->xfm_lines
 992
 993 #define LvTYPE(sv)      ((XPVLV*)  SvANY(sv))->xlv_type
 994 #define LvTARG(sv)      ((XPVLV*)  SvANY(sv))->xlv_targ
 995 #define LvTARGOFF(sv)   ((XPVLV*)  SvANY(sv))->xlv_targoff
 996 #define LvTARGLEN(sv)   ((XPVLV*)  SvANY(sv))->xlv_targlen
 997
 998 #define IoIFP(sv)       ((XPVIO*)  SvANY(sv))->xio_ifp
 999 #define IoOFP(sv)       ((XPVIO*)  SvANY(sv))->xio_ofp
1000 #define IoDIRP(sv)      ((XPVIO*)  SvANY(sv))->xio_dirp
1001 #define IoANY(sv)       ((XPVIO*)  SvANY(sv))->xio_any
1002 #define IoLINES(sv)     ((XPVIO*)  SvANY(sv))->xio_lines
1003 #define IoPAGE(sv)      ((XPVIO*)  SvANY(sv))->xio_page
1004 #define IoPAGE_LEN(sv)  ((XPVIO*)  SvANY(sv))->xio_page_len
1005 #define IoLINES_LEFT(sv)((XPVIO*)  SvANY(sv))->xio_lines_left
1006 #define IoTOP_NAME(sv)  ((XPVIO*)  SvANY(sv))->xio_top_name
1007 #define IoTOP_GV(sv)    ((XPVIO*)  SvANY(sv))->xio_top_gv
1008 #define IoFMT_NAME(sv)  ((XPVIO*)  SvANY(sv))->xio_fmt_name
1009 #define IoFMT_GV(sv)    ((XPVIO*)  SvANY(sv))->xio_fmt_gv
1010 #define IoBOTTOM_NAME(sv)((XPVIO*) SvANY(sv))->xio_bottom_name
1011 #define IoBOTTOM_GV(sv) ((XPVIO*)  SvANY(sv))->xio_bottom_gv
1012 #define IoSUBPROCESS(sv)((XPVIO*)  SvANY(sv))->xio_subprocess
1013 #define IoTYPE(sv)      ((XPVIO*)  SvANY(sv))->xio_type
1014 #define IoFLAGS(sv)     ((XPVIO*)  SvANY(sv))->xio_flags
1015
1016 /* IoTYPE(sv) is a single character telling the type of I/O connection. */
1017 #define IoTYPE_RDONLY           '<'
1018 #define IoTYPE_WRONLY           '>'
1019 #define IoTYPE_RDWR             '+'
1020 #define IoTYPE_APPEND           'a'
1021 #define IoTYPE_PIPE             '|'
1022 #define IoTYPE_STD              '-'     /* stdin or stdout */
1023 #define IoTYPE_SOCKET           's'
1024 #define IoTYPE_CLOSED           ' '
1025 #define IoTYPE_IMPLICIT         'I'     /* stdin or stdout or stderr */
1026 #define IoTYPE_NUMERIC          '#'     /* fdopen */
1027
1028 /*
1029 =for apidoc Am|bool|SvTAINTED|SV* sv
1030 Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if
1031 not.
1032
1033 =for apidoc Am|void|SvTAINTED_on|SV* sv
1034 Marks an SV as tainted if tainting is enabled.
1035
1036 =for apidoc Am|void|SvTAINTED_off|SV* sv
1037 Untaints an SV. Be I<very> careful with this routine, as it short-circuits
1038 some of Perl's fundamental security features. XS module authors should not
1039 use this function unless they fully understand all the implications of
1040 unconditionally untainting the value. Untainting should be done in the
1041 standard perl fashion, via a carefully crafted regexp, rather than directly
1042 untainting variables.
1043
1044 =for apidoc Am|void|SvTAINT|SV* sv
1045 Taints an SV if tainting is enabled.
1046
1047 =cut
1048 */
1049
1050 #define sv_taint(sv)      sv_magic((sv), Nullsv, PERL_MAGIC_taint, Nullch, 0)
1051
1052 #define SvTAINTED(sv)     (SvMAGICAL(sv) && sv_tainted(sv))
1053 #define SvTAINTED_on(sv)  STMT_START{ if(PL_tainting){sv_taint(sv);}   }STMT_END
1054 #define SvTAINTED_off(sv) STMT_START{ if(PL_tainting){sv_untaint(sv);} }STMT_END
1055
1056 #define SvTAINT(sv)                     \
1057     STMT_START {                        \
1058         if (PL_tainting) {              \
1059             if (PL_tainted)             \
1060                 SvTAINTED_on(sv);       \
1061         }                               \
1062     } STMT_END
1063
1064 /*
1065 =for apidoc Am|char*|SvPV_force|SV* sv|STRLEN len
1066 Like C<SvPV> but will force the SV into containing just a string
1067 (C<SvPOK_only>).  You want force if you are going to update the C<SvPVX>
1068 directly.
1069
1070 =for apidoc Am|char*|SvPV_force_nomg|SV* sv|STRLEN len
1071 Like C<SvPV> but will force the SV into containing just a string
1072 (C<SvPOK_only>).  You want force if you are going to update the C<SvPVX>
1073 directly. Doesn't process magic.
1074
1075 =for apidoc Am|char*|SvPV|SV* sv|STRLEN len
1076 Returns a pointer to the string in the SV, or a stringified form of
1077 the SV if the SV does not contain a string.  The SV may cache the
1078 stringified version becoming C<SvPOK>.  Handles 'get' magic. See also
1079 C<SvPVx> for a version which guarantees to evaluate sv only once.
1080
1081 =for apidoc Am|char*|SvPVx|SV* sv|STRLEN len
1082 A version of C<SvPV> which guarantees to evaluate sv only once.
1083
1084 =for apidoc Am|char*|SvPV_nomg|SV* sv|STRLEN len
1085 Like C<SvPV> but doesn't process magic.
1086
1087 =for apidoc Am|char*|SvPV_nolen|SV* sv
1088 Returns a pointer to the string in the SV, or a stringified form of
1089 the SV if the SV does not contain a string.  The SV may cache the
1090 stringified form becoming C<SvPOK>.  Handles 'get' magic.
1091
1092 =for apidoc Am|IV|SvIV|SV* sv
1093 Coerces the given SV to an integer and returns it. See  C<SvIVx> for a
1094 version which guarantees to evaluate sv only once.
1095
1096 =for apidoc Am|IV|SvIV_nomg|SV* sv
1097 Like C<SvIV> but doesn't process magic.
1098
1099 =for apidoc Am|IV|SvIVx|SV* sv
1100 Coerces the given SV to an integer and returns it. Guarantees to evaluate
1101 sv only once. Use the more efficient C<SvIV> otherwise.
1102
1103 =for apidoc Am|NV|SvNV|SV* sv
1104 Coerce the given SV to a double and return it. See  C<SvNVx> for a version
1105 which guarantees to evaluate sv only once.
1106
1107 =for apidoc Am|NV|SvNVx|SV* sv
1108 Coerces the given SV to a double and returns it. Guarantees to evaluate
1109 sv only once. Use the more efficient C<SvNV> otherwise.
1110
1111 =for apidoc Am|UV|SvUV|SV* sv
1112 Coerces the given SV to an unsigned integer and returns it.  See C<SvUVx>
1113 for a version which guarantees to evaluate sv only once.
1114
1115 =for apidoc Am|UV|SvUV_nomg|SV* sv
1116 Like C<SvUV> but doesn't process magic.
1117
1118 =for apidoc Am|UV|SvUVx|SV* sv
1119 Coerces the given SV to an unsigned integer and returns it. Guarantees to
1120 evaluate sv only once. Use the more efficient C<SvUV> otherwise.
1121
1122 =for apidoc Am|bool|SvTRUE|SV* sv
1123 Returns a boolean indicating whether Perl would evaluate the SV as true or
1124 false, defined or undefined.  Does not handle 'get' magic.
1125
1126 =for apidoc Am|char*|SvPVutf8_force|SV* sv|STRLEN len
1127 Like C<SvPV_force>, but converts sv to utf8 first if necessary.
1128
1129 =for apidoc Am|char*|SvPVutf8|SV* sv|STRLEN len
1130 Like C<SvPV>, but converts sv to utf8 first if necessary.
1131
1132 =for apidoc Am|char*|SvPVutf8_nolen|SV* sv
1133 Like C<SvPV_nolen>, but converts sv to utf8 first if necessary.
1134
1135 =for apidoc Am|char*|SvPVbyte_force|SV* sv|STRLEN len
1136 Like C<SvPV_force>, but converts sv to byte representation first if necessary.
1137
1138 =for apidoc Am|char*|SvPVbyte|SV* sv|STRLEN len
1139 Like C<SvPV>, but converts sv to byte representation first if necessary.
1140
1141 =for apidoc Am|char*|SvPVbyte_nolen|SV* sv
1142 Like C<SvPV_nolen>, but converts sv to byte representation first if necessary.
1143
1144 =for apidoc Am|char*|SvPVutf8x_force|SV* sv|STRLEN len
1145 Like C<SvPV_force>, but converts sv to utf8 first if necessary.
1146 Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8_force>
1147 otherwise.
1148
1149 =for apidoc Am|char*|SvPVutf8x|SV* sv|STRLEN len
1150 Like C<SvPV>, but converts sv to utf8 first if necessary.
1151 Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8>
1152 otherwise.
1153
1154 =for apidoc Am|char*|SvPVbytex_force|SV* sv|STRLEN len
1155 Like C<SvPV_force>, but converts sv to byte representation first if necessary.
1156 Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte_force>
1157 otherwise.
1158
1159 =for apidoc Am|char*|SvPVbytex|SV* sv|STRLEN len
1160 Like C<SvPV>, but converts sv to byte representation first if necessary.
1161 Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte>
1162 otherwise.
1163
1164 =for apidoc Am|bool|SvIsCOW|SV* sv
1165 Returns a boolean indicating whether the SV is Copy-On-Write. (either shared
1166 hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for
1167 COW)
1168
1169 =for apidoc Am|bool|SvIsCOW_shared_hash|SV* sv
1170 Returns a boolean indicating whether the SV is Copy-On-Write shared hash key
1171 scalar.
1172
1173 =for apidoc Am|void|sv_catpvn_nomg|SV* sv|const char* ptr|STRLEN len
1174 Like C<sv_catpvn> but doesn't process magic.
1175
1176 =for apidoc Am|void|sv_setsv_nomg|SV* dsv|SV* ssv
1177 Like C<sv_setsv> but doesn't process magic.
1178
1179 =for apidoc Am|void|sv_catsv_nomg|SV* dsv|SV* ssv
1180 Like C<sv_catsv> but doesn't process magic.
1181
1182 =cut
1183 */
1184
1185 /* Let us hope that bitmaps for UV and IV are the same */
1186 #define SvIV(sv) (SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv))
1187 #define SvUV(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv))
1188 #define SvNV(sv) (SvNOK(sv) ? SvNVX(sv) : sv_2nv(sv))
1189
1190 #define SvIV_nomg(sv) (SvIOK(sv) ? SvIVX(sv) : sv_2iv_flags(sv, 0))
1191 #define SvUV_nomg(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv_flags(sv, 0))
1192
1193 /* ----*/
1194
1195 #define SvPV(sv, lp) SvPV_flags(sv, lp, SV_GMAGIC)
1196 #define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC)
1197 #define SvPV_mutable(sv, lp) SvPV_flags_mutable(sv, lp, SV_GMAGIC)
1198
1199 #define SvPV_flags(sv, lp, flags) \
1200     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1201      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags))
1202 #define SvPV_flags_const(sv, lp, flags) \
1203     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1204      ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \
1205      (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN))
1206 #define SvPV_flags_const_nolen(sv, flags) \
1207     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1208      ? SvPVX_const(sv) : \
1209      (const char*) sv_2pv_flags(sv, 0, flags|SV_CONST_RETURN))
1210 #define SvPV_flags_mutable(sv, lp, flags) \
1211     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1212      ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \
1213      sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
1214
1215 #define SvPV_force(sv, lp) SvPV_force_flags(sv, lp, SV_GMAGIC)
1216 #define SvPV_force_nolen(sv) SvPV_force_flags_nolen(sv, SV_GMAGIC)
1217 #define SvPV_force_mutable(sv, lp) SvPV_force_flags_mutable(sv, lp, SV_GMAGIC)
1218
1219 #define SvPV_force_nomg(sv, lp) SvPV_force_flags(sv, lp, 0)
1220 #define SvPV_force_nomg_nolen(sv) SvPV_force_flags_nolen(sv, 0)
1221
1222 #define SvPV_force_flags(sv, lp, flags) \
1223     ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
1224     ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags))
1225 #define SvPV_force_flags_nolen(sv, flags) \
1226     ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
1227     ? SvPVX(sv) : sv_pvn_force_flags(sv, 0, flags))
1228 #define SvPV_force_flags_mutable(sv, lp, flags) \
1229     ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
1230     ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \
1231      : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
1232
1233 #define SvPV_nolen(sv) \
1234     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1235      ? SvPVX(sv) : sv_2pv_flags(sv, 0, SV_GMAGIC))
1236
1237 #define SvPV_nolen_const(sv) \
1238     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1239      ? SvPVX_const(sv) : sv_2pv_flags(sv, 0, SV_GMAGIC|SV_CONST_RETURN))
1240
1241 #define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0)
1242 #define SvPV_nomg_const(sv, lp) SvPV_flags_const(sv, lp, 0)
1243 #define SvPV_nomg_const_nolen(sv) SvPV_flags_const_nolen(sv, 0)
1244
1245 /* ----*/
1246
1247 #define SvPVutf8(sv, lp) \
1248     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK|SVf_UTF8) \
1249      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvutf8(sv, &lp))
1250
1251 #define SvPVutf8_force(sv, lp) \
1252     ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == (SVf_POK|SVf_UTF8) \
1253      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvutf8n_force(sv, &lp))
1254
1255
1256 #define SvPVutf8_nolen(sv) \
1257     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK|SVf_UTF8)\
1258      ? SvPVX(sv) : sv_2pvutf8(sv, 0))
1259
1260 /* ----*/
1261
1262 #define SvPVbyte(sv, lp) \
1263     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \
1264      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp))
1265
1266 #define SvPVbyte_force(sv, lp) \
1267     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_THINKFIRST)) == (SVf_POK) \
1268      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvbyten_force(sv, &lp))
1269
1270 #define SvPVbyte_nolen(sv) \
1271     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK)\
1272      ? SvPVX(sv) : sv_2pvbyte(sv, 0))
1273
1274
1275
1276 /* define FOOx(): idempotent versions of FOO(). If possible, use a local
1277  * var to evaluate the arg once; failing that, use a global if possible;
1278  * failing that, call a function to do the work
1279  */
1280
1281 #define SvPVx_force(sv, lp) sv_pvn_force(sv, &lp)
1282 #define SvPVutf8x_force(sv, lp) sv_pvutf8n_force(sv, &lp)
1283 #define SvPVbytex_force(sv, lp) sv_pvbyten_force(sv, &lp)
1284
1285 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
1286
1287 #  define SvIVx(sv) ({SV *_sv = (SV*)(sv); SvIV(_sv); })
1288 #  define SvUVx(sv) ({SV *_sv = (SV*)(sv); SvUV(_sv); })
1289 #  define SvNVx(sv) ({SV *_sv = (SV*)(sv); SvNV(_sv); })
1290 #  define SvPVx(sv, lp) ({SV *_sv = (sv); SvPV(_sv, lp); })
1291 #  define SvPVx_const(sv, lp) ({SV *_sv = (sv); SvPV_const(_sv, lp); })
1292 #  define SvPVx_nolen(sv) ({SV *_sv = (sv); SvPV_nolen(_sv); })
1293 #  define SvPVx_nolen_const(sv) ({SV *_sv = (sv); SvPV_nolen_const(_sv); })
1294 #  define SvPVutf8x(sv, lp) ({SV *_sv = (sv); SvPVutf8(_sv, lp); })
1295 #  define SvPVbytex(sv, lp) ({SV *_sv = (sv); SvPVbyte(_sv, lp); })
1296 #  define SvPVbytex_nolen(sv) ({SV *_sv = (sv); SvPVbyte_nolen(_sv); })
1297 #  define SvTRUE(sv) (                                          \
1298     !sv                                                         \
1299     ? 0                                                         \
1300     :    SvPOK(sv)                                              \
1301         ?   (({XPV *nxpv = (XPV*)SvANY(sv);                     \
1302              nxpv &&                                            \
1303              (nxpv->xpv_cur > 1 ||                              \
1304               (nxpv->xpv_cur && *(sv)->sv_u.svu_pv != '0')); }) \
1305              ? 1                                                \
1306              : 0)                                               \
1307         :                                                       \
1308             SvIOK(sv)                                           \
1309             ? SvIVX(sv) != 0                                    \
1310             :   SvNOK(sv)                                       \
1311                 ? SvNVX(sv) != 0.0                              \
1312                 : sv_2bool(sv) )
1313 #  define SvTRUEx(sv) ({SV *_sv = (sv); SvTRUE(_sv); })
1314
1315 #else /* __GNUC__ */
1316
1317 /* These inlined macros use globals, which will require a thread
1318  * declaration in user code, so we avoid them under threads */
1319
1320 #  define SvIVx(sv) ((PL_Sv = (sv)), SvIV(PL_Sv))
1321 #  define SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv))
1322 #  define SvNVx(sv) ((PL_Sv = (sv)), SvNV(PL_Sv))
1323 #  define SvPVx(sv, lp) ((PL_Sv = (sv)), SvPV(PL_Sv, lp))
1324 #  define SvPVx_const(sv, lp) ((PL_Sv = (sv)), SvPV_const(PL_Sv, lp))
1325 #  define SvPVx_nolen(sv) ((PL_Sv = (sv)), SvPV_nolen(PL_Sv))
1326 #  define SvPVx_nolen_const(sv) ((PL_Sv = (sv)), SvPV_nolen_const(PL_Sv))
1327 #  define SvPVutf8x(sv, lp) ((PL_Sv = (sv)), SvPVutf8(PL_Sv, lp))
1328 #  define SvPVbytex(sv, lp) ((PL_Sv = (sv)), SvPVbyte(PL_Sv, lp))
1329 #  define SvPVbytex_nolen(sv) ((PL_Sv = (sv)), SvPVbyte_nolen(PL_Sv))
1330 #  define SvTRUE(sv) (                                          \
1331     !sv                                                         \
1332     ? 0                                                         \
1333     :    SvPOK(sv)                                              \
1334         ?   ((PL_Xpv = (XPV*)SvANY(PL_Sv = (sv))) &&            \
1335              (PL_Xpv->xpv_cur > 1 ||                            \
1336               (PL_Xpv->xpv_cur && *PL_Sv->sv_u.svu_pv != '0'))  \
1337              ? 1                                                \
1338              : 0)                                               \
1339         :                                                       \
1340             SvIOK(sv)                                           \
1341             ? SvIVX(sv) != 0                                    \
1342             :   SvNOK(sv)                                       \
1343                 ? SvNVX(sv) != 0.0                              \
1344                 : sv_2bool(sv) )
1345 #  define SvTRUEx(sv) ((PL_Sv = (sv)), SvTRUE(PL_Sv))
1346 #endif /* __GNU__ */
1347
1348 #define SvIsCOW(sv)             ((SvFLAGS(sv) & (SVf_FAKE | SVf_READONLY)) == \
1349                                     (SVf_FAKE | SVf_READONLY))
1350 #define SvIsCOW_shared_hash(sv) (SvIsCOW(sv) && SvLEN(sv) == 0)
1351
1352 #define SvSHARED_HEK_FROM_PV(pvx) \
1353         ((struct hek*)(pvx - STRUCT_OFFSET(struct hek, hek_key)))
1354 #define SvSHARED_HASH(sv) (0 + SvSHARED_HEK_FROM_PV(SvPVX_const(sv))->hek_hash)
1355
1356 /* flag values for sv_*_flags functions */
1357 #define SV_IMMEDIATE_UNREF      1
1358 #define SV_GMAGIC               2
1359 #define SV_COW_DROP_PV          4
1360 #define SV_UTF8_NO_ENCODING     8
1361 #define SV_NOSTEAL              16
1362 #define SV_CONST_RETURN         32
1363 #define SV_MUTABLE_RETURN       64
1364 #define SV_SMAGIC               128
1365
1366 #define sv_unref(sv)            sv_unref_flags(sv, 0)
1367 #define sv_force_normal(sv)     sv_force_normal_flags(sv, 0)
1368
1369 /* We are about to replace the SV's current value. So if it's copy on write
1370    we need to normalise it. Use the SV_COW_DROP_PV flag hint to say that
1371    the value is about to get thrown away, so drop the PV rather than go to
1372    the effort of making a read-write copy only for it to get immediately
1373    discarded.  */
1374
1375 #define SV_CHECK_THINKFIRST_COW_DROP(sv) if (SvTHINKFIRST(sv)) \
1376                                     sv_force_normal_flags(sv, SV_COW_DROP_PV)
1377
1378 #ifdef PERL_OLD_COPY_ON_WRITE
1379 #  define SvRELEASE_IVX(sv)   ((void)((SvFLAGS(sv) & (SVf_OOK|SVf_READONLY|SVf_FAKE)) \
1380                                 && Perl_sv_release_IVX(aTHX_ sv)))
1381 #  define SvIsCOW_normal(sv)    (SvIsCOW(sv) && SvLEN(sv))
1382 #else
1383 #  define SvRELEASE_IVX(sv)   SvOOK_off(sv)
1384 #endif /* PERL_OLD_COPY_ON_WRITE */
1385
1386 #define CAN_COW_MASK    (SVs_OBJECT|SVs_GMG|SVs_SMG|SVs_RMG|SVf_IOK|SVf_NOK| \
1387                          SVf_POK|SVf_ROK|SVp_IOK|SVp_NOK|SVp_POK|SVf_FAKE| \
1388                          SVf_OOK|SVf_BREAK|SVf_READONLY|SVf_AMAGIC)
1389 #define CAN_COW_FLAGS   (SVp_POK|SVf_POK)
1390
1391 #define SV_CHECK_THINKFIRST(sv) if (SvTHINKFIRST(sv)) \
1392                                     sv_force_normal_flags(sv, 0)
1393
1394
1395 /* all these 'functions' are now just macros */
1396
1397 #define sv_pv(sv) SvPV_nolen(sv)
1398 #define sv_pvutf8(sv) SvPVutf8_nolen(sv)
1399 #define sv_pvbyte(sv) SvPVbyte_nolen(sv)
1400
1401 #define sv_pvn_force_nomg(sv, lp) sv_pvn_force_flags(sv, lp, 0)
1402 #define sv_utf8_upgrade_nomg(sv) sv_utf8_upgrade_flags(sv, 0)
1403 #define sv_catpvn_nomg(dsv, sstr, slen) sv_catpvn_flags(dsv, sstr, slen, 0)
1404 #define sv_setsv(dsv, ssv) sv_setsv_flags(dsv, ssv, SV_GMAGIC)
1405 #define sv_setsv_nomg(dsv, ssv) sv_setsv_flags(dsv, ssv, 0)
1406 #define sv_catsv(dsv, ssv) sv_catsv_flags(dsv, ssv, SV_GMAGIC)
1407 #define sv_catsv_nomg(dsv, ssv) sv_catsv_flags(dsv, ssv, 0)
1408 #define sv_catsv_mg(dsv, ssv) sv_catsv_flags(dsv, ssv, SV_GMAGIC|SV_SMAGIC)
1409 #define sv_catpvn(dsv, sstr, slen) sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC)
1410 #define sv_catpvn_mg(sv, sstr, slen) \
1411         sv_catpvn_flags(sv, sstr, slen, SV_GMAGIC|SV_SMAGIC);
1412 #define sv_2pv(sv, lp) sv_2pv_flags(sv, lp, SV_GMAGIC)
1413 #define sv_2pv_nolen(sv) sv_2pv(sv, 0)
1414 #define sv_2pvbyte_nolen(sv) sv_2pvbyte(sv, 0)
1415 #define sv_2pvutf8_nolen(sv) sv_2pvutf8(sv, 0)
1416 #define sv_2pv_nomg(sv, lp) sv_2pv_flags(sv, lp, 0)
1417 #define sv_pvn_force(sv, lp) sv_pvn_force_flags(sv, lp, SV_GMAGIC)
1418 #define sv_utf8_upgrade(sv) sv_utf8_upgrade_flags(sv, SV_GMAGIC)
1419 #define sv_2iv(sv) sv_2iv_flags(sv, SV_GMAGIC)
1420 #define sv_2uv(sv) sv_2uv_flags(sv, SV_GMAGIC)
1421
1422 /* Should be named SvCatPVN_utf8_upgrade? */
1423 #define sv_catpvn_utf8_upgrade(dsv, sstr, slen, nsv)    \
1424         STMT_START {                                    \
1425             if (!(nsv))                                 \
1426                 nsv = sv_2mortal(newSVpvn(sstr, slen)); \
1427             else                                        \
1428                 sv_setpvn(nsv, sstr, slen);             \
1429             SvUTF8_off(nsv);                            \
1430             sv_utf8_upgrade(nsv);                       \
1431             sv_catsv(dsv, nsv); \
1432         } STMT_END
1433
1434 /*
1435 =for apidoc Am|SV*|newRV_inc|SV* sv
1436
1437 Creates an RV wrapper for an SV.  The reference count for the original SV is
1438 incremented.
1439
1440 =cut
1441 */
1442
1443 #define newRV_inc(sv)   newRV(sv)
1444
1445 /* the following macros update any magic values this sv is associated with */
1446
1447 /*
1448 =head1 Magical Functions
1449
1450 =for apidoc Am|void|SvGETMAGIC|SV* sv
1451 Invokes C<mg_get> on an SV if it has 'get' magic.  This macro evaluates its
1452 argument more than once.
1453
1454 =for apidoc Am|void|SvSETMAGIC|SV* sv
1455 Invokes C<mg_set> on an SV if it has 'set' magic.  This macro evaluates its
1456 argument more than once.
1457
1458 =for apidoc Am|void|SvSetSV|SV* dsb|SV* ssv
1459 Calls C<sv_setsv> if dsv is not the same as ssv.  May evaluate arguments
1460 more than once.
1461
1462 =for apidoc Am|void|SvSetSV_nosteal|SV* dsv|SV* ssv
1463 Calls a non-destructive version of C<sv_setsv> if dsv is not the same as
1464 ssv. May evaluate arguments more than once.
1465
1466 =for apidoc Am|void|SvSetMagicSV|SV* dsb|SV* ssv
1467 Like C<SvSetSV>, but does any set magic required afterwards.
1468
1469 =for apidoc Am|void|SvSetMagicSV_nosteal|SV* dsv|SV* ssv
1470 Like C<SvSetSV_nosteal>, but does any set magic required afterwards.
1471
1472 =for apidoc Am|void|SvSHARE|SV* sv
1473 Arranges for sv to be shared between threads if a suitable module
1474 has been loaded.
1475
1476 =for apidoc Am|void|SvLOCK|SV* sv
1477 Arranges for a mutual exclusion lock to be obtained on sv if a suitable module
1478 has been loaded.
1479
1480 =for apidoc Am|void|SvUNLOCK|SV* sv
1481 Releases a mutual exclusion lock on sv if a suitable module
1482 has been loaded.
1483
1484 =head1 SV Manipulation Functions
1485
1486 =for apidoc Am|char *|SvGROW|SV* sv|STRLEN len
1487 Expands the character buffer in the SV so that it has room for the
1488 indicated number of bytes (remember to reserve space for an extra trailing
1489 NUL character).  Calls C<sv_grow> to perform the expansion if necessary.
1490 Returns a pointer to the character buffer.
1491
1492 =cut
1493 */
1494
1495 #define SvSHARE(sv) CALL_FPTR(PL_sharehook)(aTHX_ sv)
1496 #define SvLOCK(sv) CALL_FPTR(PL_lockhook)(aTHX_ sv)
1497 #define SvUNLOCK(sv) CALL_FPTR(PL_unlockhook)(aTHX_ sv)
1498
1499 #define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
1500 #define SvSETMAGIC(x) STMT_START { if (SvSMAGICAL(x)) mg_set(x); } STMT_END
1501
1502 #define SvSetSV_and(dst,src,finally) \
1503         STMT_START {                                    \
1504             if ((dst) != (src)) {                       \
1505                 sv_setsv(dst, src);                     \
1506                 finally;                                \
1507             }                                           \
1508         } STMT_END
1509 #define SvSetSV_nosteal_and(dst,src,finally) \
1510         STMT_START {                                    \
1511             if ((dst) != (src)) {                       \
1512                 sv_setsv_flags(dst, src, SV_GMAGIC | SV_NOSTEAL);       \
1513                 finally;                                \
1514             }                                           \
1515         } STMT_END
1516
1517 #define SvSetSV(dst,src) \
1518                 SvSetSV_and(dst,src,/*nothing*/;)
1519 #define SvSetSV_nosteal(dst,src) \
1520                 SvSetSV_nosteal_and(dst,src,/*nothing*/;)
1521
1522 #define SvSetMagicSV(dst,src) \
1523                 SvSetSV_and(dst,src,SvSETMAGIC(dst))
1524 #define SvSetMagicSV_nosteal(dst,src) \
1525                 SvSetSV_nosteal_and(dst,src,SvSETMAGIC(dst))
1526
1527
1528 #if !defined(SKIP_DEBUGGING)
1529 #define SvPEEK(sv) sv_peek(sv)
1530 #else
1531 #define SvPEEK(sv) ""
1532 #endif
1533
1534 #define SvIMMORTAL(sv) ((sv)==&PL_sv_undef || (sv)==&PL_sv_yes || (sv)==&PL_sv_no || (sv)==&PL_sv_placeholder)
1535
1536 #define boolSV(b) ((b) ? &PL_sv_yes : &PL_sv_no)
1537
1538 #define isGV(sv) (SvTYPE(sv) == SVt_PVGV)
1539
1540 #define SvGROW(sv,len) (SvLEN(sv) < (len) ? sv_grow(sv,len) : SvPVX(sv))
1541 #define SvGROW_mutable(sv,len) \
1542     (SvLEN(sv) < (len) ? sv_grow(sv,len) : SvPVX_mutable(sv))
1543 #define Sv_Grow sv_grow
1544
1545 #define CLONEf_COPY_STACKS 1
1546 #define CLONEf_KEEP_PTR_TABLE 2
1547 #define CLONEf_CLONE_HOST 4
1548 #define CLONEf_JOIN_IN 8
1549
1550 struct clone_params {
1551   AV* stashes;
1552   UV  flags;
1553   PerlInterpreter *proto_perl;
1554 };
1555
1556 /*
1557  * Local variables:
1558  * c-indentation-style: bsd
1559  * c-basic-offset: 4
1560  * indent-tabs-mode: t
1561  * End:
1562  *
1563  * ex: set ts=8 sts=4 sw=4 noet:
1564  */