sv.h

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