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 #ifdef PERL_DEBUG_COW
 932 #define SvRV(sv) (0 + (sv)->sv_u.svu_rv)
 933 #else
 934 #define SvRV(sv) ((sv)->sv_u.svu_rv)
 935 #endif
 936 #define SvRVx(sv) SvRV(sv)
 937
 938 #ifdef PERL_DEBUG_COW
 939 /* Need -0.0 for SvNVX to preserve IEEE FP "negative zero" because
 940    +0.0 + -0.0 => +0.0 but -0.0 + -0.0 => -0.0 */
 941 #  define SvIVX(sv) (0 + ((XPVIV*) SvANY(sv))->xiv_iv)
 942 #  define SvUVX(sv) (0 + ((XPVUV*) SvANY(sv))->xuv_uv)
 943 #  define SvNVX(sv) (-0.0 + ((XPVNV*) SvANY(sv))->xnv_nv)
 944 /* Don't test the core XS code yet.  */
 945 #  if defined (PERL_CORE) && PERL_DEBUG_COW > 1
 946 #    define SvPVX(sv) (0 + (assert(!SvREADONLY(sv)), (sv)->sv_u.svu_pv))
 947 #  else
 948 #  define SvPVX(sv) SvPVX_mutable(sv)
 949 #  endif
 950 #  define SvCUR(sv) (0 + ((XPV*) SvANY(sv))->xpv_cur)
 951 #  define SvLEN(sv) (0 + ((XPV*) SvANY(sv))->xpv_len)
 952 #  define SvEND(sv) ((sv)->sv_u.svu_pv + ((XPV*)SvANY(sv))->xpv_cur)
 953
 954 #  ifdef DEBUGGING
 955 #    ifdef PERL_IN_SV_C
 956 /* Can't make this RVALUE because of Perl_sv_unmagic.  */
 957 #      define SvMAGIC(sv)       (*(assert(SvTYPE(sv) >= SVt_PVMG), &((XPVMG*)  SvANY(sv))->xmg_magic))
 958 #    else
 959 #      define SvMAGIC(sv)       (0 + *(assert(SvTYPE(sv) >= SVt_PVMG), &((XPVMG*)  SvANY(sv))->xmg_magic))
 960 #    endif
 961 #  define SvSTASH(sv)   (0 + *(assert(SvTYPE(sv) >= SVt_PVMG), &((XPVMG*)  SvANY(sv))->xmg_stash))
 962 #  else
 963 #    ifdef PERL_IN_SV_C
 964 #      define SvMAGIC(sv) ((XPVMG*)  SvANY(sv))->xmg_magic
 965 #    else
 966 #      define SvMAGIC(sv) (0 + ((XPVMG*)  SvANY(sv))->xmg_magic)
 967 #    endif
 968 #  define SvSTASH(sv)     (0 + ((XPVMG*)  SvANY(sv))->xmg_stash)
 969 #  endif
 970 #else
 971 #  define SvPVX(sv) ((sv)->sv_u.svu_pv)
 972 #  define SvCUR(sv) ((XPV*) SvANY(sv))->xpv_cur
 973 #  define SvLEN(sv) ((XPV*) SvANY(sv))->xpv_len
 974 #  define SvEND(sv) ((sv)->sv_u.svu_pv + ((XPV*)SvANY(sv))->xpv_cur)
 975
 976 #  if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
 977 /* These get expanded inside other macros that already use a variable _sv  */
 978 #    define SvIVX(sv)                                                   \
 979         (*({ SV *const _svi = (SV *) sv;                                \
 980             assert(SvTYPE(_svi) == SVt_IV || SvTYPE(_svi) >= SVt_PVIV); \
 981             assert(SvTYPE(_svi) != SVt_PVAV);                           \
 982             assert(SvTYPE(_svi) != SVt_PVHV);                           \
 983             assert(SvTYPE(_svi) != SVt_PVCV);                           \
 984             &(((XPVIV*) SvANY(_svi))->xiv_iv);                          \
 985          }))
 986 #    define SvUVX(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             &(((XPVUV*) SvANY(_svi))->xuv_uv);                          \
 993          }))
 994 #    define SvNVX(sv)                                                   \
 995         (*({ SV *const _svi = (SV *) sv;                                \
 996             assert(SvTYPE(_svi) == SVt_NV || SvTYPE(_svi) >= SVt_PVNV); \
 997             assert(SvTYPE(_svi) != SVt_PVAV);                           \
 998             assert(SvTYPE(_svi) != SVt_PVHV);                           \
 999             assert(SvTYPE(_svi) != SVt_PVFM);                           \
1000            &(((XPVNV*) SvANY(_svi))->xnv_nv);                           \
1001          }))
1002 #    define SvMAGIC(sv)                                                 \
1003         (*({ SV *const _svi = (SV *) sv;                                \
1004             assert(SvTYPE(_svi) >= SVt_PVMG);                           \
1005             &(((XPVMG*) SvANY(_svi))->xmg_magic);                       \
1006           }))
1007 #    define SvSTASH(sv)                                                 \
1008         (*({ SV *const _svi = (SV *) sv;                                \
1009             assert(SvTYPE(_svi) >= SVt_PVMG);                           \
1010             &(((XPVMG*) SvANY(_svi))->xmg_stash);                       \
1011           }))
1012 #  else
1013 #    define SvIVX(sv) ((XPVIV*) SvANY(sv))->xiv_iv
1014 #    define SvUVX(sv) ((XPVUV*) SvANY(sv))->xuv_uv
1015 #    define SvNVX(sv) ((XPVNV*) SvANY(sv))->xnv_nv
1016 #    define SvMAGIC(sv) ((XPVMG*)  SvANY(sv))->xmg_magic
1017 #    define SvSTASH(sv) ((XPVMG*)  SvANY(sv))->xmg_stash
1018 #  endif
1019 #endif
1020
1021 #ifndef PERL_POISON
1022 /* Given that these two are new, there can't be any existing code using them
1023  *  as LVALUEs  */
1024 #  define SvPVX_mutable(sv)     (0 + (sv)->sv_u.svu_pv)
1025 #  define SvPVX_const(sv)       ((const char*)(0 + (sv)->sv_u.svu_pv))
1026 #else
1027 /* Except for the poison code, which uses & to scribble over the pointer after
1028    free() is called.  */
1029 #  define SvPVX_mutable(sv)     ((sv)->sv_u.svu_pv)
1030 #  define SvPVX_const(sv)       ((const char*)((sv)->sv_u.svu_pv))
1031 #endif
1032
1033 #define SvIVXx(sv) SvIVX(sv)
1034 #define SvUVXx(sv) SvUVX(sv)
1035 #define SvNVXx(sv) SvNVX(sv)
1036 #define SvPVXx(sv) SvPVX(sv)
1037 #define SvLENx(sv) SvLEN(sv)
1038 #define SvENDx(sv) ((PL_Sv = (sv)), SvEND(PL_Sv))
1039
1040
1041 /* Ask a scalar nicely to try to become an IV, if possible.
1042    Not guaranteed to stay returning void */
1043 /* Macro won't actually call sv_2iv if already IOK */
1044 #define SvIV_please(sv) \
1045         STMT_START {if (!SvIOKp(sv) && (SvNOK(sv) || SvPOK(sv))) \
1046                 (void) SvIV(sv); } STMT_END
1047 #define SvIV_set(sv, val) \
1048         STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
1049                 (((XPVIV*)  SvANY(sv))->xiv_iv = (val)); } STMT_END
1050 #define SvNV_set(sv, val) \
1051         STMT_START { assert(SvTYPE(sv) == SVt_NV || SvTYPE(sv) >= SVt_PVNV); \
1052             assert(SvTYPE(sv) != SVt_PVAV); assert(SvTYPE(sv) != SVt_PVHV); \
1053                 (((XPVNV*)SvANY(sv))->xnv_nv = (val)); } STMT_END
1054 #define SvPV_set(sv, val) \
1055         STMT_START { assert(SvTYPE(sv) >= SVt_PV); \
1056                 ((sv)->sv_u.svu_pv = (val)); } STMT_END
1057 #define SvUV_set(sv, val) \
1058         STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
1059                 (((XPVUV*)SvANY(sv))->xuv_uv = (val)); } STMT_END
1060 #define SvRV_set(sv, val) \
1061         STMT_START { assert(SvTYPE(sv) >=  SVt_RV); \
1062                 ((sv)->sv_u.svu_rv = (val)); } STMT_END
1063 #define SvMAGIC_set(sv, val) \
1064         STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
1065                 (((XPVMG*)SvANY(sv))->xmg_magic = (val)); } STMT_END
1066 #define SvSTASH_set(sv, val) \
1067         STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
1068                 (((XPVMG*)  SvANY(sv))->xmg_stash = (val)); } STMT_END
1069 #define SvCUR_set(sv, val) \
1070         STMT_START { assert(SvTYPE(sv) >= SVt_PV); \
1071                 (((XPV*)  SvANY(sv))->xpv_cur = (val)); } STMT_END
1072 #define SvLEN_set(sv, val) \
1073         STMT_START { assert(SvTYPE(sv) >= SVt_PV); \
1074                 (((XPV*)  SvANY(sv))->xpv_len = (val)); } STMT_END
1075 #define SvEND_set(sv, val) \
1076         STMT_START { assert(SvTYPE(sv) >= SVt_PV); \
1077                 (SvCUR(sv) = (val) - SvPVX(sv)); } STMT_END
1078
1079 #define SvPV_renew(sv,n) \
1080         STMT_START { SvLEN_set(sv, n); \
1081                 SvPV_set((sv), (MEM_WRAP_CHECK_(n,char)                 \
1082                                 (char*)saferealloc((Malloc_t)SvPVX(sv), \
1083                                                    (MEM_SIZE)((n)))));  \
1084                  } STMT_END
1085
1086 #define SvPV_shrink_to_cur(sv) STMT_START { \
1087                    const STRLEN _lEnGtH = SvCUR(sv) + 1; \
1088                    SvPV_renew(sv, _lEnGtH); \
1089                  } STMT_END
1090
1091 #define SvPV_free(sv)                                                   \
1092     STMT_START {                                                        \
1093                      assert(SvTYPE(sv) >= SVt_PV);                      \
1094                      if (SvLEN(sv)) {                                   \
1095                          if(SvOOK(sv)) {                                \
1096                              SvPV_set(sv, SvPVX_mutable(sv) - SvIVX(sv)); \
1097                              SvFLAGS(sv) &= ~SVf_OOK;                   \
1098                          }                                              \
1099                          Safefree(SvPVX(sv));                           \
1100                      }                                                  \
1101                  } STMT_END
1102
1103 #define BmRARE(sv)      ((XPVBM*)  SvANY(sv))->xbm_rare
1104 #define BmUSEFUL(sv)    ((XPVBM*)  SvANY(sv))->xbm_useful
1105 #define BmPREVIOUS(sv)  ((XPVBM*)  SvANY(sv))->xbm_previous
1106
1107 #define FmLINES(sv)     ((XPVFM*)  SvANY(sv))->xfm_lines
1108
1109 #define LvTYPE(sv)      ((XPVLV*)  SvANY(sv))->xlv_type
1110 #define LvTARG(sv)      ((XPVLV*)  SvANY(sv))->xlv_targ
1111 #define LvTARGOFF(sv)   ((XPVLV*)  SvANY(sv))->xlv_targoff
1112 #define LvTARGLEN(sv)   ((XPVLV*)  SvANY(sv))->xlv_targlen
1113
1114 #define IoIFP(sv)       ((XPVIO*)  SvANY(sv))->xio_ifp
1115 #define IoOFP(sv)       ((XPVIO*)  SvANY(sv))->xio_ofp
1116 #define IoDIRP(sv)      ((XPVIO*)  SvANY(sv))->xio_dirp
1117 #define IoANY(sv)       ((XPVIO*)  SvANY(sv))->xio_any
1118 #define IoLINES(sv)     ((XPVIO*)  SvANY(sv))->xio_lines
1119 #define IoPAGE(sv)      ((XPVIO*)  SvANY(sv))->xio_page
1120 #define IoPAGE_LEN(sv)  ((XPVIO*)  SvANY(sv))->xio_page_len
1121 #define IoLINES_LEFT(sv)((XPVIO*)  SvANY(sv))->xio_lines_left
1122 #define IoTOP_NAME(sv)  ((XPVIO*)  SvANY(sv))->xio_top_name
1123 #define IoTOP_GV(sv)    ((XPVIO*)  SvANY(sv))->xio_top_gv
1124 #define IoFMT_NAME(sv)  ((XPVIO*)  SvANY(sv))->xio_fmt_name
1125 #define IoFMT_GV(sv)    ((XPVIO*)  SvANY(sv))->xio_fmt_gv
1126 #define IoBOTTOM_NAME(sv)((XPVIO*) SvANY(sv))->xio_bottom_name
1127 #define IoBOTTOM_GV(sv) ((XPVIO*)  SvANY(sv))->xio_bottom_gv
1128 #define IoSUBPROCESS(sv)((XPVIO*)  SvANY(sv))->xio_subprocess
1129 #define IoTYPE(sv)      ((XPVIO*)  SvANY(sv))->xio_type
1130 #define IoFLAGS(sv)     ((XPVIO*)  SvANY(sv))->xio_flags
1131
1132 /* IoTYPE(sv) is a single character telling the type of I/O connection. */
1133 #define IoTYPE_RDONLY           '<'
1134 #define IoTYPE_WRONLY           '>'
1135 #define IoTYPE_RDWR             '+'
1136 #define IoTYPE_APPEND           'a'
1137 #define IoTYPE_PIPE             '|'
1138 #define IoTYPE_STD              '-'     /* stdin or stdout */
1139 #define IoTYPE_SOCKET           's'
1140 #define IoTYPE_CLOSED           ' '
1141 #define IoTYPE_IMPLICIT         'I'     /* stdin or stdout or stderr */
1142 #define IoTYPE_NUMERIC          '#'     /* fdopen */
1143
1144 /*
1145 =for apidoc Am|bool|SvTAINTED|SV* sv
1146 Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if
1147 not.
1148
1149 =for apidoc Am|void|SvTAINTED_on|SV* sv
1150 Marks an SV as tainted if tainting is enabled.
1151
1152 =for apidoc Am|void|SvTAINTED_off|SV* sv
1153 Untaints an SV. Be I<very> careful with this routine, as it short-circuits
1154 some of Perl's fundamental security features. XS module authors should not
1155 use this function unless they fully understand all the implications of
1156 unconditionally untainting the value. Untainting should be done in the
1157 standard perl fashion, via a carefully crafted regexp, rather than directly
1158 untainting variables.
1159
1160 =for apidoc Am|void|SvTAINT|SV* sv
1161 Taints an SV if tainting is enabled.
1162
1163 =cut
1164 */
1165
1166 #define sv_taint(sv)      sv_magic((sv), NULL, PERL_MAGIC_taint, NULL, 0)
1167
1168 #define SvTAINTED(sv)     (SvMAGICAL(sv) && sv_tainted(sv))
1169 #define SvTAINTED_on(sv)  STMT_START{ if(PL_tainting){sv_taint(sv);}   }STMT_END
1170 #define SvTAINTED_off(sv) STMT_START{ if(PL_tainting){sv_untaint(sv);} }STMT_END
1171
1172 #define SvTAINT(sv)                     \
1173     STMT_START {                        \
1174         if (PL_tainting) {              \
1175             if (PL_tainted)             \
1176                 SvTAINTED_on(sv);       \
1177         }                               \
1178     } STMT_END
1179
1180 /*
1181 =for apidoc Am|char*|SvPV_force|SV* sv|STRLEN len
1182 Like C<SvPV> but will force the SV into containing just a string
1183 (C<SvPOK_only>).  You want force if you are going to update the C<SvPVX>
1184 directly.
1185
1186 =for apidoc Am|char*|SvPV_force_nomg|SV* sv|STRLEN len
1187 Like C<SvPV> but will force the SV into containing just a string
1188 (C<SvPOK_only>).  You want force if you are going to update the C<SvPVX>
1189 directly. Doesn't process magic.
1190
1191 =for apidoc Am|char*|SvPV|SV* sv|STRLEN len
1192 Returns a pointer to the string in the SV, or a stringified form of
1193 the SV if the SV does not contain a string.  The SV may cache the
1194 stringified version becoming C<SvPOK>.  Handles 'get' magic. See also
1195 C<SvPVx> for a version which guarantees to evaluate sv only once.
1196
1197 =for apidoc Am|char*|SvPVx|SV* sv|STRLEN len
1198 A version of C<SvPV> which guarantees to evaluate sv only once.
1199
1200 =for apidoc Am|char*|SvPV_nomg|SV* sv|STRLEN len
1201 Like C<SvPV> but doesn't process magic.
1202
1203 =for apidoc Am|char*|SvPV_nolen|SV* sv
1204 Returns a pointer to the string in the SV, or a stringified form of
1205 the SV if the SV does not contain a string.  The SV may cache the
1206 stringified form becoming C<SvPOK>.  Handles 'get' magic.
1207
1208 =for apidoc Am|IV|SvIV|SV* sv
1209 Coerces the given SV to an integer and returns it. See  C<SvIVx> for a
1210 version which guarantees to evaluate sv only once.
1211
1212 =for apidoc Am|IV|SvIV_nomg|SV* sv
1213 Like C<SvIV> but doesn't process magic.
1214
1215 =for apidoc Am|IV|SvIVx|SV* sv
1216 Coerces the given SV to an integer and returns it. Guarantees to evaluate
1217 sv only once. Use the more efficient C<SvIV> otherwise.
1218
1219 =for apidoc Am|NV|SvNV|SV* sv
1220 Coerce the given SV to a double and return it. See  C<SvNVx> for a version
1221 which guarantees to evaluate sv only once.
1222
1223 =for apidoc Am|NV|SvNVx|SV* sv
1224 Coerces the given SV to a double and returns it. Guarantees to evaluate
1225 sv only once. Use the more efficient C<SvNV> otherwise.
1226
1227 =for apidoc Am|UV|SvUV|SV* sv
1228 Coerces the given SV to an unsigned integer and returns it.  See C<SvUVx>
1229 for a version which guarantees to evaluate sv only once.
1230
1231 =for apidoc Am|UV|SvUV_nomg|SV* sv
1232 Like C<SvUV> but doesn't process magic.
1233
1234 =for apidoc Am|UV|SvUVx|SV* sv
1235 Coerces the given SV to an unsigned integer and returns it. Guarantees to
1236 evaluate sv only once. Use the more efficient C<SvUV> otherwise.
1237
1238 =for apidoc Am|bool|SvTRUE|SV* sv
1239 Returns a boolean indicating whether Perl would evaluate the SV as true or
1240 false, defined or undefined.  Does not handle 'get' magic.
1241
1242 =for apidoc Am|char*|SvPVutf8_force|SV* sv|STRLEN len
1243 Like C<SvPV_force>, but converts sv to utf8 first if necessary.
1244
1245 =for apidoc Am|char*|SvPVutf8|SV* sv|STRLEN len
1246 Like C<SvPV>, but converts sv to utf8 first if necessary.
1247
1248 =for apidoc Am|char*|SvPVutf8_nolen|SV* sv
1249 Like C<SvPV_nolen>, but converts sv to utf8 first if necessary.
1250
1251 =for apidoc Am|char*|SvPVbyte_force|SV* sv|STRLEN len
1252 Like C<SvPV_force>, but converts sv to byte representation first if necessary.
1253
1254 =for apidoc Am|char*|SvPVbyte|SV* sv|STRLEN len
1255 Like C<SvPV>, but converts sv to byte representation first if necessary.
1256
1257 =for apidoc Am|char*|SvPVbyte_nolen|SV* sv
1258 Like C<SvPV_nolen>, but converts sv to byte representation first if necessary.
1259
1260 =for apidoc Am|char*|SvPVutf8x_force|SV* sv|STRLEN len
1261 Like C<SvPV_force>, but converts sv to utf8 first if necessary.
1262 Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8_force>
1263 otherwise.
1264
1265 =for apidoc Am|char*|SvPVutf8x|SV* sv|STRLEN len
1266 Like C<SvPV>, but converts sv to utf8 first if necessary.
1267 Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8>
1268 otherwise.
1269
1270 =for apidoc Am|char*|SvPVbytex_force|SV* sv|STRLEN len
1271 Like C<SvPV_force>, but converts sv to byte representation first if necessary.
1272 Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte_force>
1273 otherwise.
1274
1275 =for apidoc Am|char*|SvPVbytex|SV* sv|STRLEN len
1276 Like C<SvPV>, but converts sv to byte representation first if necessary.
1277 Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte>
1278 otherwise.
1279
1280 =for apidoc Am|bool|SvIsCOW|SV* sv
1281 Returns a boolean indicating whether the SV is Copy-On-Write. (either shared
1282 hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for
1283 COW)
1284
1285 =for apidoc Am|bool|SvIsCOW_shared_hash|SV* sv
1286 Returns a boolean indicating whether the SV is Copy-On-Write shared hash key
1287 scalar.
1288
1289 =for apidoc Am|void|sv_catpvn_nomg|SV* sv|const char* ptr|STRLEN len
1290 Like C<sv_catpvn> but doesn't process magic.
1291
1292 =for apidoc Am|void|sv_setsv_nomg|SV* dsv|SV* ssv
1293 Like C<sv_setsv> but doesn't process magic.
1294
1295 =for apidoc Am|void|sv_catsv_nomg|SV* dsv|SV* ssv
1296 Like C<sv_catsv> but doesn't process magic.
1297
1298 =cut
1299 */
1300
1301 /* Let us hope that bitmaps for UV and IV are the same */
1302 #define SvIV(sv) (SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv))
1303 #define SvUV(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv))
1304 #define SvNV(sv) (SvNOK(sv) ? SvNVX(sv) : sv_2nv(sv))
1305
1306 #define SvIV_nomg(sv) (SvIOK(sv) ? SvIVX(sv) : sv_2iv_flags(sv, 0))
1307 #define SvUV_nomg(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv_flags(sv, 0))
1308
1309 /* ----*/
1310
1311 #define SvPV(sv, lp) SvPV_flags(sv, lp, SV_GMAGIC)
1312 #define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC)
1313 #define SvPV_mutable(sv, lp) SvPV_flags_mutable(sv, lp, SV_GMAGIC)
1314
1315 #define SvPV_flags(sv, lp, flags) \
1316     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1317      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags))
1318 #define SvPV_flags_const(sv, lp, flags) \
1319     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1320      ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \
1321      (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN))
1322 #define SvPV_flags_const_nolen(sv, flags) \
1323     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1324      ? SvPVX_const(sv) : \
1325      (const char*) sv_2pv_flags(sv, 0, flags|SV_CONST_RETURN))
1326 #define SvPV_flags_mutable(sv, lp, flags) \
1327     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1328      ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \
1329      sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
1330
1331 #define SvPV_force(sv, lp) SvPV_force_flags(sv, lp, SV_GMAGIC)
1332 #define SvPV_force_nolen(sv) SvPV_force_flags_nolen(sv, SV_GMAGIC)
1333 #define SvPV_force_mutable(sv, lp) SvPV_force_flags_mutable(sv, lp, SV_GMAGIC)
1334
1335 #define SvPV_force_nomg(sv, lp) SvPV_force_flags(sv, lp, 0)
1336 #define SvPV_force_nomg_nolen(sv) SvPV_force_flags_nolen(sv, 0)
1337
1338 #define SvPV_force_flags(sv, lp, flags) \
1339     ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
1340     ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags))
1341 #define SvPV_force_flags_nolen(sv, flags) \
1342     ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
1343     ? SvPVX(sv) : sv_pvn_force_flags(sv, 0, flags))
1344 #define SvPV_force_flags_mutable(sv, lp, flags) \
1345     ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
1346     ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \
1347      : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
1348
1349 #define SvPV_nolen(sv) \
1350     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1351      ? SvPVX(sv) : sv_2pv_flags(sv, 0, SV_GMAGIC))
1352
1353 #define SvPV_nolen_const(sv) \
1354     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1355      ? SvPVX_const(sv) : sv_2pv_flags(sv, 0, SV_GMAGIC|SV_CONST_RETURN))
1356
1357 #define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0)
1358 #define SvPV_nomg_const(sv, lp) SvPV_flags_const(sv, lp, 0)
1359 #define SvPV_nomg_const_nolen(sv) SvPV_flags_const_nolen(sv, 0)
1360
1361 /* ----*/
1362
1363 #define SvPVutf8(sv, lp) \
1364     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK|SVf_UTF8) \
1365      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvutf8(sv, &lp))
1366
1367 #define SvPVutf8_force(sv, lp) \
1368     ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == (SVf_POK|SVf_UTF8) \
1369      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvutf8n_force(sv, &lp))
1370
1371
1372 #define SvPVutf8_nolen(sv) \
1373     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK|SVf_UTF8)\
1374      ? SvPVX(sv) : sv_2pvutf8(sv, 0))
1375
1376 /* ----*/
1377
1378 #define SvPVbyte(sv, lp) \
1379     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \
1380      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp))
1381
1382 #define SvPVbyte_force(sv, lp) \
1383     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_THINKFIRST)) == (SVf_POK) \
1384      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvbyten_force(sv, &lp))
1385
1386 #define SvPVbyte_nolen(sv) \
1387     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK)\
1388      ? SvPVX(sv) : sv_2pvbyte(sv, 0))
1389
1390
1391
1392 /* define FOOx(): idempotent versions of FOO(). If possible, use a local
1393  * var to evaluate the arg once; failing that, use a global if possible;
1394  * failing that, call a function to do the work
1395  */
1396
1397 #define SvPVx_force(sv, lp) sv_pvn_force(sv, &lp)
1398 #define SvPVutf8x_force(sv, lp) sv_pvutf8n_force(sv, &lp)
1399 #define SvPVbytex_force(sv, lp) sv_pvbyten_force(sv, &lp)
1400
1401 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
1402
1403 #  define SvIVx(sv) ({SV *_sv = (SV*)(sv); SvIV(_sv); })
1404 #  define SvUVx(sv) ({SV *_sv = (SV*)(sv); SvUV(_sv); })
1405 #  define SvNVx(sv) ({SV *_sv = (SV*)(sv); SvNV(_sv); })
1406 #  define SvPVx(sv, lp) ({SV *_sv = (sv); SvPV(_sv, lp); })
1407 #  define SvPVx_const(sv, lp) ({SV *_sv = (sv); SvPV_const(_sv, lp); })
1408 #  define SvPVx_nolen(sv) ({SV *_sv = (sv); SvPV_nolen(_sv); })
1409 #  define SvPVx_nolen_const(sv) ({SV *_sv = (sv); SvPV_nolen_const(_sv); })
1410 #  define SvPVutf8x(sv, lp) ({SV *_sv = (sv); SvPVutf8(_sv, lp); })
1411 #  define SvPVbytex(sv, lp) ({SV *_sv = (sv); SvPVbyte(_sv, lp); })
1412 #  define SvPVbytex_nolen(sv) ({SV *_sv = (sv); SvPVbyte_nolen(_sv); })
1413 #  define SvTRUE(sv) (                                          \
1414     !sv                                                         \
1415     ? 0                                                         \
1416     :    SvPOK(sv)                                              \
1417         ?   (({XPV *nxpv = (XPV*)SvANY(sv);                     \
1418              nxpv &&                                            \
1419              (nxpv->xpv_cur > 1 ||                              \
1420               (nxpv->xpv_cur && *(sv)->sv_u.svu_pv != '0')); }) \
1421              ? 1                                                \
1422              : 0)                                               \
1423         :                                                       \
1424             SvIOK(sv)                                           \
1425             ? SvIVX(sv) != 0                                    \
1426             :   SvNOK(sv)                                       \
1427                 ? SvNVX(sv) != 0.0                              \
1428                 : sv_2bool(sv) )
1429 #  define SvTRUEx(sv) ({SV *_sv = (sv); SvTRUE(_sv); })
1430
1431 #else /* __GNUC__ */
1432
1433 /* These inlined macros use globals, which will require a thread
1434  * declaration in user code, so we avoid them under threads */
1435
1436 #  define SvIVx(sv) ((PL_Sv = (sv)), SvIV(PL_Sv))
1437 #  define SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv))
1438 #  define SvNVx(sv) ((PL_Sv = (sv)), SvNV(PL_Sv))
1439 #  define SvPVx(sv, lp) ((PL_Sv = (sv)), SvPV(PL_Sv, lp))
1440 #  define SvPVx_const(sv, lp) ((PL_Sv = (sv)), SvPV_const(PL_Sv, lp))
1441 #  define SvPVx_nolen(sv) ((PL_Sv = (sv)), SvPV_nolen(PL_Sv))
1442 #  define SvPVx_nolen_const(sv) ((PL_Sv = (sv)), SvPV_nolen_const(PL_Sv))
1443 #  define SvPVutf8x(sv, lp) ((PL_Sv = (sv)), SvPVutf8(PL_Sv, lp))
1444 #  define SvPVbytex(sv, lp) ((PL_Sv = (sv)), SvPVbyte(PL_Sv, lp))
1445 #  define SvPVbytex_nolen(sv) ((PL_Sv = (sv)), SvPVbyte_nolen(PL_Sv))
1446 #  define SvTRUE(sv) (                                          \
1447     !sv                                                         \
1448     ? 0                                                         \
1449     :    SvPOK(sv)                                              \
1450         ?   ((PL_Xpv = (XPV*)SvANY(PL_Sv = (sv))) &&            \
1451              (PL_Xpv->xpv_cur > 1 ||                            \
1452               (PL_Xpv->xpv_cur && *PL_Sv->sv_u.svu_pv != '0'))  \
1453              ? 1                                                \
1454              : 0)                                               \
1455         :                                                       \
1456             SvIOK(sv)                                           \
1457             ? SvIVX(sv) != 0                                    \
1458             :   SvNOK(sv)                                       \
1459                 ? SvNVX(sv) != 0.0                              \
1460                 : sv_2bool(sv) )
1461 #  define SvTRUEx(sv) ((PL_Sv = (sv)), SvTRUE(PL_Sv))
1462 #endif /* __GNU__ */
1463
1464 #define SvIsCOW(sv)             ((SvFLAGS(sv) & (SVf_FAKE | SVf_READONLY)) == \
1465                                     (SVf_FAKE | SVf_READONLY))
1466 #define SvIsCOW_shared_hash(sv) (SvIsCOW(sv) && SvLEN(sv) == 0)
1467
1468 #define SvSHARED_HEK_FROM_PV(pvx) \
1469         ((struct hek*)(pvx - STRUCT_OFFSET(struct hek, hek_key)))
1470 #define SvSHARED_HASH(sv) (0 + SvSHARED_HEK_FROM_PV(SvPVX_const(sv))->hek_hash)
1471
1472 /* flag values for sv_*_flags functions */
1473 #define SV_IMMEDIATE_UNREF      1
1474 #define SV_GMAGIC               2
1475 #define SV_COW_DROP_PV          4
1476 #define SV_UTF8_NO_ENCODING     8
1477 #define SV_NOSTEAL              16
1478 #define SV_CONST_RETURN         32
1479 #define SV_MUTABLE_RETURN       64
1480 #define SV_SMAGIC               128
1481
1482 #define sv_unref(sv)            sv_unref_flags(sv, 0)
1483 #define sv_force_normal(sv)     sv_force_normal_flags(sv, 0)
1484
1485 /* We are about to replace the SV's current value. So if it's copy on write
1486    we need to normalise it. Use the SV_COW_DROP_PV flag hint to say that
1487    the value is about to get thrown away, so drop the PV rather than go to
1488    the effort of making a read-write copy only for it to get immediately
1489    discarded.  */
1490
1491 #define SV_CHECK_THINKFIRST_COW_DROP(sv) if (SvTHINKFIRST(sv)) \
1492                                     sv_force_normal_flags(sv, SV_COW_DROP_PV)
1493
1494 #ifdef PERL_OLD_COPY_ON_WRITE
1495 #  define SvRELEASE_IVX(sv)   ((void)((SvFLAGS(sv) & (SVf_OOK|SVf_READONLY|SVf_FAKE)) \
1496                                 && Perl_sv_release_IVX(aTHX_ sv)))
1497 #  define SvIsCOW_normal(sv)    (SvIsCOW(sv) && SvLEN(sv))
1498 #else
1499 #  define SvRELEASE_IVX(sv)   SvOOK_off(sv)
1500 #endif /* PERL_OLD_COPY_ON_WRITE */
1501
1502 #define CAN_COW_MASK    (SVs_OBJECT|SVs_GMG|SVs_SMG|SVs_RMG|SVf_IOK|SVf_NOK| \
1503                          SVf_POK|SVf_ROK|SVp_IOK|SVp_NOK|SVp_POK|SVf_FAKE| \
1504                          SVf_OOK|SVf_BREAK|SVf_READONLY|SVf_AMAGIC)
1505 #define CAN_COW_FLAGS   (SVp_POK|SVf_POK)
1506
1507 #define SV_CHECK_THINKFIRST(sv) if (SvTHINKFIRST(sv)) \
1508                                     sv_force_normal_flags(sv, 0)
1509
1510
1511 /* all these 'functions' are now just macros */
1512
1513 #define sv_pv(sv) SvPV_nolen(sv)
1514 #define sv_pvutf8(sv) SvPVutf8_nolen(sv)
1515 #define sv_pvbyte(sv) SvPVbyte_nolen(sv)
1516
1517 #define sv_pvn_force_nomg(sv, lp) sv_pvn_force_flags(sv, lp, 0)
1518 #define sv_utf8_upgrade_nomg(sv) sv_utf8_upgrade_flags(sv, 0)
1519 #define sv_catpvn_nomg(dsv, sstr, slen) sv_catpvn_flags(dsv, sstr, slen, 0)
1520 #define sv_setsv(dsv, ssv) sv_setsv_flags(dsv, ssv, SV_GMAGIC)
1521 #define sv_setsv_nomg(dsv, ssv) sv_setsv_flags(dsv, ssv, 0)
1522 #define sv_catsv(dsv, ssv) sv_catsv_flags(dsv, ssv, SV_GMAGIC)
1523 #define sv_catsv_nomg(dsv, ssv) sv_catsv_flags(dsv, ssv, 0)
1524 #define sv_catsv_mg(dsv, ssv) sv_catsv_flags(dsv, ssv, SV_GMAGIC|SV_SMAGIC)
1525 #define sv_catpvn(dsv, sstr, slen) sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC)
1526 #define sv_catpvn_mg(sv, sstr, slen) \
1527         sv_catpvn_flags(sv, sstr, slen, SV_GMAGIC|SV_SMAGIC);
1528 #define sv_2pv(sv, lp) sv_2pv_flags(sv, lp, SV_GMAGIC)
1529 #define sv_2pv_nolen(sv) sv_2pv(sv, 0)
1530 #define sv_2pvbyte_nolen(sv) sv_2pvbyte(sv, 0)
1531 #define sv_2pvutf8_nolen(sv) sv_2pvutf8(sv, 0)
1532 #define sv_2pv_nomg(sv, lp) sv_2pv_flags(sv, lp, 0)
1533 #define sv_pvn_force(sv, lp) sv_pvn_force_flags(sv, lp, SV_GMAGIC)
1534 #define sv_utf8_upgrade(sv) sv_utf8_upgrade_flags(sv, SV_GMAGIC)
1535 #define sv_2iv(sv) sv_2iv_flags(sv, SV_GMAGIC)
1536 #define sv_2uv(sv) sv_2uv_flags(sv, SV_GMAGIC)
1537
1538 /* Should be named SvCatPVN_utf8_upgrade? */
1539 #define sv_catpvn_utf8_upgrade(dsv, sstr, slen, nsv)    \
1540         STMT_START {                                    \
1541             if (!(nsv))                                 \
1542                 nsv = sv_2mortal(newSVpvn(sstr, slen)); \
1543             else                                        \
1544                 sv_setpvn(nsv, sstr, slen);             \
1545             SvUTF8_off(nsv);                            \
1546             sv_utf8_upgrade(nsv);                       \
1547             sv_catsv(dsv, nsv); \
1548         } STMT_END
1549
1550 /*
1551 =for apidoc Am|SV*|newRV_inc|SV* sv
1552
1553 Creates an RV wrapper for an SV.  The reference count for the original SV is
1554 incremented.
1555
1556 =cut
1557 */
1558
1559 #define newRV_inc(sv)   newRV(sv)
1560
1561 /* the following macros update any magic values this sv is associated with */
1562
1563 /*
1564 =head1 Magical Functions
1565
1566 =for apidoc Am|void|SvGETMAGIC|SV* sv
1567 Invokes C<mg_get> on an SV if it has 'get' magic.  This macro evaluates its
1568 argument more than once.
1569
1570 =for apidoc Am|void|SvSETMAGIC|SV* sv
1571 Invokes C<mg_set> on an SV if it has 'set' magic.  This macro evaluates its
1572 argument more than once.
1573
1574 =for apidoc Am|void|SvSetSV|SV* dsb|SV* ssv
1575 Calls C<sv_setsv> if dsv is not the same as ssv.  May evaluate arguments
1576 more than once.
1577
1578 =for apidoc Am|void|SvSetSV_nosteal|SV* dsv|SV* ssv
1579 Calls a non-destructive version of C<sv_setsv> if dsv is not the same as
1580 ssv. May evaluate arguments more than once.
1581
1582 =for apidoc Am|void|SvSetMagicSV|SV* dsb|SV* ssv
1583 Like C<SvSetSV>, but does any set magic required afterwards.
1584
1585 =for apidoc Am|void|SvSetMagicSV_nosteal|SV* dsv|SV* ssv
1586 Like C<SvSetSV_nosteal>, but does any set magic required afterwards.
1587
1588 =for apidoc Am|void|SvSHARE|SV* sv
1589 Arranges for sv to be shared between threads if a suitable module
1590 has been loaded.
1591
1592 =for apidoc Am|void|SvLOCK|SV* sv
1593 Arranges for a mutual exclusion lock to be obtained on sv if a suitable module
1594 has been loaded.
1595
1596 =for apidoc Am|void|SvUNLOCK|SV* sv
1597 Releases a mutual exclusion lock on sv if a suitable module
1598 has been loaded.
1599
1600 =head1 SV Manipulation Functions
1601
1602 =for apidoc Am|char *|SvGROW|SV* sv|STRLEN len
1603 Expands the character buffer in the SV so that it has room for the
1604 indicated number of bytes (remember to reserve space for an extra trailing
1605 NUL character).  Calls C<sv_grow> to perform the expansion if necessary.
1606 Returns a pointer to the character buffer.
1607
1608 =cut
1609 */
1610
1611 #define SvSHARE(sv) CALL_FPTR(PL_sharehook)(aTHX_ sv)
1612 #define SvLOCK(sv) CALL_FPTR(PL_lockhook)(aTHX_ sv)
1613 #define SvUNLOCK(sv) CALL_FPTR(PL_unlockhook)(aTHX_ sv)
1614
1615 #define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
1616 #define SvSETMAGIC(x) STMT_START { if (SvSMAGICAL(x)) mg_set(x); } STMT_END
1617
1618 #define SvSetSV_and(dst,src,finally) \
1619         STMT_START {                                    \
1620             if ((dst) != (src)) {                       \
1621                 sv_setsv(dst, src);                     \
1622                 finally;                                \
1623             }                                           \
1624         } STMT_END
1625 #define SvSetSV_nosteal_and(dst,src,finally) \
1626         STMT_START {                                    \
1627             if ((dst) != (src)) {                       \
1628                 sv_setsv_flags(dst, src, SV_GMAGIC | SV_NOSTEAL);       \
1629                 finally;                                \
1630             }                                           \
1631         } STMT_END
1632
1633 #define SvSetSV(dst,src) \
1634                 SvSetSV_and(dst,src,/*nothing*/;)
1635 #define SvSetSV_nosteal(dst,src) \
1636                 SvSetSV_nosteal_and(dst,src,/*nothing*/;)
1637
1638 #define SvSetMagicSV(dst,src) \
1639                 SvSetSV_and(dst,src,SvSETMAGIC(dst))
1640 #define SvSetMagicSV_nosteal(dst,src) \
1641                 SvSetSV_nosteal_and(dst,src,SvSETMAGIC(dst))
1642
1643
1644 #if !defined(SKIP_DEBUGGING)
1645 #define SvPEEK(sv) sv_peek(sv)
1646 #else
1647 #define SvPEEK(sv) ""
1648 #endif
1649
1650 #define SvIMMORTAL(sv) ((sv)==&PL_sv_undef || (sv)==&PL_sv_yes || (sv)==&PL_sv_no || (sv)==&PL_sv_placeholder)
1651
1652 #define boolSV(b) ((b) ? &PL_sv_yes : &PL_sv_no)
1653
1654 #define isGV(sv) (SvTYPE(sv) == SVt_PVGV)
1655
1656 #define SvGROW(sv,len) (SvLEN(sv) < (len) ? sv_grow(sv,len) : SvPVX(sv))
1657 #define SvGROW_mutable(sv,len) \
1658     (SvLEN(sv) < (len) ? sv_grow(sv,len) : SvPVX_mutable(sv))
1659 #define Sv_Grow sv_grow
1660
1661 #define CLONEf_COPY_STACKS 1
1662 #define CLONEf_KEEP_PTR_TABLE 2
1663 #define CLONEf_CLONE_HOST 4
1664 #define CLONEf_JOIN_IN 8
1665
1666 struct clone_params {
1667   AV* stashes;
1668   UV  flags;
1669   PerlInterpreter *proto_perl;
1670 };
1671
1672 /*
1673  * Local variables:
1674  * c-indentation-style: bsd
1675  * c-basic-offset: 4
1676  * indent-tabs-mode: t
1677  * End:
1678  *
1679  * ex: set ts=8 sts=4 sw=4 noet:
1680  */