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