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