sv.h

   1 /*    sv.h
   2  *
   3  *    Copyright (c) 1991-2003, Larry Wall
   4  *
   5  *    You may distribute under the terms of either the GNU General Public
   6  *    License or the Artistic License, as specified in the README file.
   7  *
   8  */
   9
  10 #ifdef sv_flags
  11 #undef sv_flags         /* Convex has this in <signal.h> for sigvec() */
  12 #endif
  13
  14 /*
  15 =head1 SV Flags
  16
  17 =for apidoc AmU||svtype
  18 An enum of flags for Perl types.  These are found in the file B<sv.h>
  19 in the C<svtype> enum.  Test these flags with the C<SvTYPE> macro.
  20
  21 =for apidoc AmU||SVt_PV
  22 Pointer type flag for scalars.  See C<svtype>.
  23
  24 =for apidoc AmU||SVt_IV
  25 Integer type flag for scalars.  See C<svtype>.
  26
  27 =for apidoc AmU||SVt_NV
  28 Double type flag for scalars.  See C<svtype>.
  29
  30 =for apidoc AmU||SVt_PVMG
  31 Type flag for blessed scalars.  See C<svtype>.
  32
  33 =for apidoc AmU||SVt_PVAV
  34 Type flag for arrays.  See C<svtype>.
  35
  36 =for apidoc AmU||SVt_PVHV
  37 Type flag for hashes.  See C<svtype>.
  38
  39 =for apidoc AmU||SVt_PVCV
  40 Type flag for code refs.  See C<svtype>.
  41
  42 =cut
  43 */
  44
  45 typedef enum {
  46         SVt_NULL,       /* 0 */
  47         SVt_IV,         /* 1 */
  48         SVt_NV,         /* 2 */
  49         SVt_RV,         /* 3 */
  50         SVt_PV,         /* 4 */
  51         SVt_PVIV,       /* 5 */
  52         SVt_PVNV,       /* 6 */
  53         SVt_PVMG,       /* 7 */
  54         SVt_PVBM,       /* 8 */
  55         SVt_PVLV,       /* 9 */
  56         SVt_PVAV,       /* 10 */
  57         SVt_PVHV,       /* 11 */
  58         SVt_PVCV,       /* 12 */
  59         SVt_PVGV,       /* 13 */
  60         SVt_PVFM,       /* 14 */
  61         SVt_PVIO        /* 15 */
  62 } svtype;
  63
  64 /* Using C's structural equivalence to help emulate C++ inheritance here... */
  65
  66 struct STRUCT_SV {              /* struct sv { */
  67     void*       sv_any;         /* pointer to something */
  68     U32         sv_refcnt;      /* how many references to us */
  69     U32         sv_flags;       /* what we are */
  70 };
  71
  72 struct gv {
  73     XPVGV*      sv_any;         /* pointer to something */
  74     U32         sv_refcnt;      /* how many references to us */
  75     U32         sv_flags;       /* what we are */
  76 };
  77
  78 struct cv {
  79     XPVCV*      sv_any;         /* pointer to something */
  80     U32         sv_refcnt;      /* how many references to us */
  81     U32         sv_flags;       /* what we are */
  82 };
  83
  84 struct av {
  85     XPVAV*      sv_any;         /* pointer to something */
  86     U32         sv_refcnt;      /* how many references to us */
  87     U32         sv_flags;       /* what we are */
  88 };
  89
  90 struct hv {
  91     XPVHV*      sv_any;         /* pointer to something */
  92     U32         sv_refcnt;      /* how many references to us */
  93     U32         sv_flags;       /* what we are */
  94 };
  95
  96 struct io {
  97     XPVIO*      sv_any;         /* pointer to something */
  98     U32         sv_refcnt;      /* how many references to us */
  99     U32         sv_flags;       /* what we are */
 100 };
 101
 102 /*
 103 =head1 SV Manipulation Functions
 104
 105 =for apidoc Am|U32|SvREFCNT|SV* sv
 106 Returns the value of the object's reference count.
 107
 108 =for apidoc Am|SV*|SvREFCNT_inc|SV* sv
 109 Increments the reference count of the given SV.
 110
 111 =for apidoc Am|void|SvREFCNT_dec|SV* sv
 112 Decrements the reference count of the given SV.
 113
 114 =for apidoc Am|svtype|SvTYPE|SV* sv
 115 Returns the type of the SV.  See C<svtype>.
 116
 117 =for apidoc Am|void|SvUPGRADE|SV* sv|svtype type
 118 Used to upgrade an SV to a more complex form.  Uses C<sv_upgrade> to
 119 perform the upgrade if necessary.  See C<svtype>.
 120
 121 =cut
 122 */
 123
 124 #define SvANY(sv)       (sv)->sv_any
 125 #define SvFLAGS(sv)     (sv)->sv_flags
 126 #define SvREFCNT(sv)    (sv)->sv_refcnt
 127
 128 #if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC)
 129 #  define SvREFCNT_inc(sv)              \
 130     ({                                  \
 131         SV *nsv = (SV*)(sv);            \
 132         if (nsv)                        \
 133              (SvREFCNT(nsv))++;         \
 134         nsv;                            \
 135     })
 136 #else
 137 #  define SvREFCNT_inc(sv)      \
 138         ((PL_Sv=(SV*)(sv)), (PL_Sv && ++(SvREFCNT(PL_Sv))), (SV*)PL_Sv)
 139 #endif
 140
 141 #if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC)
 142 #  define SvREFCNT_dec(sv)              \
 143     ({                                  \
 144         SV *nsv = (SV*)(sv);            \
 145         if (nsv) {                      \
 146             if (SvREFCNT(nsv)) {        \
 147                 if (--(SvREFCNT(nsv)) == 0) \
 148                     Perl_sv_free2(aTHX_ nsv);   \
 149             } else {                    \
 150                 sv_free(nsv);           \
 151             }                           \
 152         }                               \
 153     })
 154 #else
 155 #define SvREFCNT_dec(sv)        sv_free((SV*)(sv))
 156 #endif
 157
 158 #define SVTYPEMASK      0xff
 159 #define SvTYPE(sv)      ((sv)->sv_flags & SVTYPEMASK)
 160
 161 #define SvUPGRADE(sv, mt) (SvTYPE(sv) >= mt || sv_upgrade(sv, mt))
 162
 163 #define SVs_PADSTALE    0x00000100      /* lexical has gone out of scope */
 164 #define SVs_PADTMP      0x00000200      /* in use as tmp */
 165 #define SVs_PADMY       0x00000400      /* in use a "my" variable */
 166 #define SVs_TEMP        0x00000800      /* string is stealable? */
 167 #define SVs_OBJECT      0x00001000      /* is "blessed" */
 168 #define SVs_GMG         0x00002000      /* has magical get method */
 169 #define SVs_SMG         0x00004000      /* has magical set method */
 170 #define SVs_RMG         0x00008000      /* has random magical methods */
 171
 172 #define SVf_IOK         0x00010000      /* has valid public integer value */
 173 #define SVf_NOK         0x00020000      /* has valid public numeric value */
 174 #define SVf_POK         0x00040000      /* has valid public pointer value */
 175 #define SVf_ROK         0x00080000      /* has a valid reference pointer */
 176
 177 #define SVf_FAKE        0x00100000      /* glob or lexical is just a copy */
 178 #define SVf_OOK         0x00200000      /* has valid offset value */
 179 #define SVf_BREAK       0x00400000      /* refcnt is artificially low - used
 180                                          * by SV's in final arena  cleanup */
 181 #define SVf_READONLY    0x00800000      /* may not be modified */
 182
 183
 184 #define SVp_IOK         0x01000000      /* has valid non-public integer value */
 185 #define SVp_NOK         0x02000000      /* has valid non-public numeric value */
 186 #define SVp_POK         0x04000000      /* has valid non-public pointer value */
 187 #define SVp_SCREAM      0x08000000      /* has been studied? */
 188
 189 #define SVf_UTF8        0x20000000      /* SvPV is UTF-8 encoded */
 190
 191 #define SVf_THINKFIRST  (SVf_READONLY|SVf_ROK|SVf_FAKE)
 192
 193 #define SVf_OK          (SVf_IOK|SVf_NOK|SVf_POK|SVf_ROK| \
 194                          SVp_IOK|SVp_NOK|SVp_POK)
 195
 196 #define SVf_AMAGIC      0x10000000      /* has magical overloaded methods */
 197
 198 #define PRIVSHIFT 8     /* (SVp_?OK >> PRIVSHIFT) == SVf_?OK */
 199
 200 /* Some private flags. */
 201
 202 /* SVpad_OUR may be set on SVt_PV{NV,MG,GV} types */
 203 #define SVpad_OUR       0x80000000      /* pad name is "our" instead of "my" */
 204 #define SVpad_TYPED     0x40000000      /* Typed Lexical */
 205
 206 #define SVf_IVisUV      0x80000000      /* use XPVUV instead of XPVIV */
 207
 208 #define SVpfm_COMPILED  0x80000000      /* FORMLINE is compiled */
 209
 210 #define SVpbm_VALID     0x80000000
 211 #define SVpbm_TAIL      0x40000000
 212
 213 #define SVrepl_EVAL     0x40000000      /* Replacement part of s///e */
 214
 215 #define SVphv_SHAREKEYS 0x20000000      /* keys live on shared string table */
 216 #define SVphv_LAZYDEL   0x40000000      /* entry in xhv_eiter must be deleted */
 217 #define SVphv_HASKFLAGS 0x80000000      /* keys have flag byte after hash */
 218
 219 #define SVprv_WEAKREF   0x80000000      /* Weak reference */
 220
 221 struct xrv {
 222     SV *        xrv_rv;         /* pointer to another SV */
 223 };
 224
 225 struct xpv {
 226     char *      xpv_pv;         /* pointer to malloced string */
 227     STRLEN      xpv_cur;        /* length of xpv_pv as a C string */
 228     STRLEN      xpv_len;        /* allocated size */
 229 };
 230
 231 struct xpviv {
 232     char *      xpv_pv;         /* pointer to malloced string */
 233     STRLEN      xpv_cur;        /* length of xpv_pv as a C string */
 234     STRLEN      xpv_len;        /* allocated size */
 235     IV          xiv_iv;         /* integer value or pv offset */
 236 };
 237
 238 struct xpvuv {
 239     char *      xpv_pv;         /* pointer to malloced string */
 240     STRLEN      xpv_cur;        /* length of xpv_pv as a C string */
 241     STRLEN      xpv_len;        /* allocated size */
 242     UV          xuv_uv;         /* unsigned value or pv offset */
 243 };
 244
 245 struct xpvnv {
 246     char *      xpv_pv;         /* pointer to malloced string */
 247     STRLEN      xpv_cur;        /* length of xpv_pv as a C string */
 248     STRLEN      xpv_len;        /* allocated size */
 249     IV          xiv_iv;         /* integer value or pv offset */
 250     NV          xnv_nv;         /* numeric value, if any */
 251 };
 252
 253 /* These structure must match the beginning of struct xpvhv in hv.h. */
 254 struct xpvmg {
 255     char *      xpv_pv;         /* pointer to malloced string */
 256     STRLEN      xpv_cur;        /* length of xpv_pv as a C string */
 257     STRLEN      xpv_len;        /* allocated size */
 258     IV          xiv_iv;         /* integer value or pv offset */
 259     NV          xnv_nv;         /* numeric value, if any */
 260     MAGIC*      xmg_magic;      /* linked list of magicalness */
 261     HV*         xmg_stash;      /* class package */
 262 };
 263
 264 struct xpvlv {
 265     char *      xpv_pv;         /* pointer to malloced string */
 266     STRLEN      xpv_cur;        /* length of xpv_pv as a C string */
 267     STRLEN      xpv_len;        /* allocated size */
 268     IV          xiv_iv;         /* integer value or pv offset */
 269     NV          xnv_nv;         /* numeric value, if any */
 270     MAGIC*      xmg_magic;      /* linked list of magicalness */
 271     HV*         xmg_stash;      /* class package */
 272
 273     STRLEN      xlv_targoff;
 274     STRLEN      xlv_targlen;
 275     SV*         xlv_targ;
 276     char        xlv_type;
 277 };
 278
 279 struct xpvgv {
 280     char *      xpv_pv;         /* pointer to malloced string */
 281     STRLEN      xpv_cur;        /* length of xpv_pv as a C string */
 282     STRLEN      xpv_len;        /* allocated size */
 283     IV          xiv_iv;         /* integer value or pv offset */
 284     NV          xnv_nv;         /* numeric value, if any */
 285     MAGIC*      xmg_magic;      /* linked list of magicalness */
 286     HV*         xmg_stash;      /* class package */
 287
 288     GP*         xgv_gp;
 289     char*       xgv_name;
 290     STRLEN      xgv_namelen;
 291     HV*         xgv_stash;
 292     U8          xgv_flags;
 293 };
 294
 295 struct xpvbm {
 296     char *      xpv_pv;         /* pointer to malloced string */
 297     STRLEN      xpv_cur;        /* length of xpv_pv as a C string */
 298     STRLEN      xpv_len;        /* allocated size */
 299     IV          xiv_iv;         /* integer value or pv offset */
 300     NV          xnv_nv;         /* numeric value, if any */
 301     MAGIC*      xmg_magic;      /* linked list of magicalness */
 302     HV*         xmg_stash;      /* class package */
 303
 304     I32         xbm_useful;     /* is this constant pattern being useful? */
 305     U16         xbm_previous;   /* how many characters in string before rare? */
 306     U8          xbm_rare;       /* rarest character in string */
 307 };
 308
 309 /* This structure much match XPVCV in cv.h */
 310
 311 typedef U16 cv_flags_t;
 312
 313 struct xpvfm {
 314     char *      xpv_pv;         /* pointer to malloced string */
 315     STRLEN      xpv_cur;        /* length of xpv_pv as a C string */
 316     STRLEN      xpv_len;        /* allocated size */
 317     IV          xiv_iv;         /* integer value or pv offset */
 318     NV          xnv_nv;         /* numeric value, if any */
 319     MAGIC*      xmg_magic;      /* linked list of magicalness */
 320     HV*         xmg_stash;      /* class package */
 321
 322     HV *        xcv_stash;
 323     OP *        xcv_start;
 324     OP *        xcv_root;
 325     void      (*xcv_xsub)(pTHX_ CV*);
 326     ANY         xcv_xsubany;
 327     GV *        xcv_gv;
 328     char *      xcv_file;
 329     long        xcv_depth;      /* >= 2 indicates recursive call */
 330     AV *        xcv_padlist;
 331     CV *        xcv_outside;
 332     cv_flags_t  xcv_flags;
 333     U32         xcv_outside_seq; /* the COP sequence (at the point of our
 334                                   * compilation) in the lexically enclosing
 335                                   * sub */
 336     IV          xfm_lines;
 337 };
 338
 339 struct xpvio {
 340     char *      xpv_pv;         /* pointer to malloced string */
 341     STRLEN      xpv_cur;        /* length of xpv_pv as a C string */
 342     STRLEN      xpv_len;        /* allocated size */
 343     IV          xiv_iv;         /* integer value or pv offset */
 344     NV          xnv_nv;         /* numeric value, if any */
 345     MAGIC*      xmg_magic;      /* linked list of magicalness */
 346     HV*         xmg_stash;      /* class package */
 347
 348     PerlIO *    xio_ifp;        /* ifp and ofp are normally the same */
 349     PerlIO *    xio_ofp;        /* but sockets need separate streams */
 350     /* Cray addresses everything by word boundaries (64 bits) and
 351      * code and data pointers cannot be mixed (which is exactly what
 352      * Perl_filter_add() tries to do with the dirp), hence the following
 353      * union trick (as suggested by Gurusamy Sarathy).
 354      * For further information see Geir Johansen's problem report titled
 355        [ID 20000612.002] Perl problem on Cray system
 356      * The any pointer (known as IoANY()) will also be a good place
 357      * to hang any IO disciplines to.
 358      */
 359     union {
 360         DIR *   xiou_dirp;      /* for opendir, readdir, etc */
 361         void *  xiou_any;       /* for alignment */
 362     } xio_dirpu;
 363     IV          xio_lines;      /* $. */
 364     IV          xio_page;       /* $% */
 365     IV          xio_page_len;   /* $= */
 366     IV          xio_lines_left; /* $- */
 367     char *      xio_top_name;   /* $^ */
 368     GV *        xio_top_gv;     /* $^ */
 369     char *      xio_fmt_name;   /* $~ */
 370     GV *        xio_fmt_gv;     /* $~ */
 371     char *      xio_bottom_name;/* $^B */
 372     GV *        xio_bottom_gv;  /* $^B */
 373     short       xio_subprocess; /* -| or |- */
 374     char        xio_type;
 375     char        xio_flags;
 376 };
 377 #define xio_dirp        xio_dirpu.xiou_dirp
 378 #define xio_any         xio_dirpu.xiou_any
 379
 380 #define IOf_ARGV        1       /* this fp iterates over ARGV */
 381 #define IOf_START       2       /* check for null ARGV and substitute '-' */
 382 #define IOf_FLUSH       4       /* this fp wants a flush after write op */
 383 #define IOf_DIDTOP      8       /* just did top of form */
 384 #define IOf_UNTAINT     16      /* consider this fp (and its data) "safe" */
 385 #define IOf_NOLINE      32      /* slurped a pseudo-line from empty file */
 386 #define IOf_FAKE_DIRP   64      /* xio_dirp is fake (source filters kludge) */
 387
 388 /* The following macros define implementation-independent predicates on SVs. */
 389
 390 /*
 391 =for apidoc Am|bool|SvNIOK|SV* sv
 392 Returns a boolean indicating whether the SV contains a number, integer or
 393 double.
 394
 395 =for apidoc Am|bool|SvNIOKp|SV* sv
 396 Returns a boolean indicating whether the SV contains a number, integer or
 397 double.  Checks the B<private> setting.  Use C<SvNIOK>.
 398
 399 =for apidoc Am|void|SvNIOK_off|SV* sv
 400 Unsets the NV/IV status of an SV.
 401
 402 =for apidoc Am|bool|SvOK|SV* sv
 403 Returns a boolean indicating whether the value is an SV.
 404
 405 =for apidoc Am|bool|SvIOKp|SV* sv
 406 Returns a boolean indicating whether the SV contains an integer.  Checks
 407 the B<private> setting.  Use C<SvIOK>.
 408
 409 =for apidoc Am|bool|SvNOKp|SV* sv
 410 Returns a boolean indicating whether the SV contains a double.  Checks the
 411 B<private> setting.  Use C<SvNOK>.
 412
 413 =for apidoc Am|bool|SvPOKp|SV* sv
 414 Returns a boolean indicating whether the SV contains a character string.
 415 Checks the B<private> setting.  Use C<SvPOK>.
 416
 417 =for apidoc Am|bool|SvIOK|SV* sv
 418 Returns a boolean indicating whether the SV contains an integer.
 419
 420 =for apidoc Am|void|SvIOK_on|SV* sv
 421 Tells an SV that it is an integer.
 422
 423 =for apidoc Am|void|SvIOK_off|SV* sv
 424 Unsets the IV status of an SV.
 425
 426 =for apidoc Am|void|SvIOK_only|SV* sv
 427 Tells an SV that it is an integer and disables all other OK bits.
 428
 429 =for apidoc Am|void|SvIOK_only_UV|SV* sv
 430 Tells and SV that it is an unsigned integer and disables all other OK bits.
 431
 432 =for apidoc Am|void|SvIOK_UV|SV* sv
 433 Returns a boolean indicating whether the SV contains an unsigned integer.
 434
 435 =for apidoc Am|void|SvUOK|SV* sv
 436 Returns a boolean indicating whether the SV contains an unsigned integer.
 437
 438 =for apidoc Am|void|SvIOK_notUV|SV* sv
 439 Returns a boolean indicating whether the SV contains a signed integer.
 440
 441 =for apidoc Am|bool|SvNOK|SV* sv
 442 Returns a boolean indicating whether the SV contains a double.
 443
 444 =for apidoc Am|void|SvNOK_on|SV* sv
 445 Tells an SV that it is a double.
 446
 447 =for apidoc Am|void|SvNOK_off|SV* sv
 448 Unsets the NV status of an SV.
 449
 450 =for apidoc Am|void|SvNOK_only|SV* sv
 451 Tells an SV that it is a double and disables all other OK bits.
 452
 453 =for apidoc Am|bool|SvPOK|SV* sv
 454 Returns a boolean indicating whether the SV contains a character
 455 string.
 456
 457 =for apidoc Am|void|SvPOK_on|SV* sv
 458 Tells an SV that it is a string.
 459
 460 =for apidoc Am|void|SvPOK_off|SV* sv
 461 Unsets the PV status of an SV.
 462
 463 =for apidoc Am|void|SvPOK_only|SV* sv
 464 Tells an SV that it is a string and disables all other OK bits.
 465 Will also turn off the UTF8 status.
 466
 467 =for apidoc Am|bool|SvVOK|SV* sv
 468 Returns a boolean indicating whether the SV contains a v-string.
 469
 470 =for apidoc Am|bool|SvOOK|SV* sv
 471 Returns a boolean indicating whether the SvIVX is a valid offset value for
 472 the SvPVX.  This hack is used internally to speed up removal of characters
 473 from the beginning of a SvPV.  When SvOOK is true, then the start of the
 474 allocated string buffer is really (SvPVX - SvIVX).
 475
 476 =for apidoc Am|bool|SvROK|SV* sv
 477 Tests if the SV is an RV.
 478
 479 =for apidoc Am|void|SvROK_on|SV* sv
 480 Tells an SV that it is an RV.
 481
 482 =for apidoc Am|void|SvROK_off|SV* sv
 483 Unsets the RV status of an SV.
 484
 485 =for apidoc Am|SV*|SvRV|SV* sv
 486 Dereferences an RV to return the SV.
 487
 488 =for apidoc Am|IV|SvIVX|SV* sv
 489 Returns the raw value in the SV's IV slot, without checks or conversions.
 490 Only use when you are sure SvIOK is true. See also C<SvIV()>.
 491
 492 =for apidoc Am|UV|SvUVX|SV* sv
 493 Returns the raw value in the SV's UV slot, without checks or conversions.
 494 Only use when you are sure SvIOK is true. See also C<SvUV()>.
 495
 496 =for apidoc Am|NV|SvNVX|SV* sv
 497 Returns the raw value in the SV's NV slot, without checks or conversions.
 498 Only use when you are sure SvNOK is true. See also C<SvNV()>.
 499
 500 =for apidoc Am|char*|SvPVX|SV* sv
 501 Returns a pointer to the physical string in the SV.  The SV must contain a
 502 string.
 503
 504 =for apidoc Am|STRLEN|SvCUR|SV* sv
 505 Returns the length of the string which is in the SV.  See C<SvLEN>.
 506
 507 =for apidoc Am|STRLEN|SvLEN|SV* sv
 508 Returns the size of the string buffer in the SV, not including any part
 509 attributable to C<SvOOK>.  See C<SvCUR>.
 510
 511 =for apidoc Am|char*|SvEND|SV* sv
 512 Returns a pointer to the last character in the string which is in the SV.
 513 See C<SvCUR>.  Access the character as *(SvEND(sv)).
 514
 515 =for apidoc Am|HV*|SvSTASH|SV* sv
 516 Returns the stash of the SV.
 517
 518 =for apidoc Am|void|SvCUR_set|SV* sv|STRLEN len
 519 Set the length of the string which is in the SV.  See C<SvCUR>.
 520
 521 =cut
 522 */
 523
 524 #define SvNIOK(sv)              (SvFLAGS(sv) & (SVf_IOK|SVf_NOK))
 525 #define SvNIOKp(sv)             (SvFLAGS(sv) & (SVp_IOK|SVp_NOK))
 526 #define SvNIOK_off(sv)          (SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK| \
 527                                                   SVp_IOK|SVp_NOK|SVf_IVisUV))
 528
 529 #ifdef __GNUC__
 530 #define assert_not_ROK(sv)      ({assert(!SvROK(sv) || !SvRV(sv))}),
 531 #else
 532 #define assert_not_ROK(sv)
 533 #endif
 534
 535 #define SvOK(sv)                (SvFLAGS(sv) & SVf_OK)
 536 #define SvOK_off(sv)            (assert_not_ROK(sv)                     \
 537                                  SvFLAGS(sv) &= ~(SVf_OK|SVf_AMAGIC|    \
 538                                                   SVf_IVisUV|SVf_UTF8), \
 539                                                         SvOOK_off(sv))
 540 #define SvOK_off_exc_UV(sv)     (assert_not_ROK(sv)                     \
 541                                  SvFLAGS(sv) &= ~(SVf_OK|SVf_AMAGIC|    \
 542                                                   SVf_UTF8),            \
 543                                                         SvOOK_off(sv))
 544
 545 #define SvOKp(sv)               (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK))
 546 #define SvIOKp(sv)              (SvFLAGS(sv) & SVp_IOK)
 547 #define SvIOKp_on(sv)           (SvRELEASE_IVX(sv), \
 548                                     SvFLAGS(sv) |= SVp_IOK)
 549 #define SvNOKp(sv)              (SvFLAGS(sv) & SVp_NOK)
 550 #define SvNOKp_on(sv)           (SvFLAGS(sv) |= SVp_NOK)
 551 #define SvPOKp(sv)              (SvFLAGS(sv) & SVp_POK)
 552 #define SvPOKp_on(sv)           (assert_not_ROK(sv)                     \
 553                                  SvFLAGS(sv) |= SVp_POK)
 554
 555 #define SvIOK(sv)               (SvFLAGS(sv) & SVf_IOK)
 556 #define SvIOK_on(sv)            (SvRELEASE_IVX(sv), \
 557                                     SvFLAGS(sv) |= (SVf_IOK|SVp_IOK))
 558 #define SvIOK_off(sv)           (SvFLAGS(sv) &= ~(SVf_IOK|SVp_IOK|SVf_IVisUV))
 559 #define SvIOK_only(sv)          ((void)SvOK_off(sv), \
 560                                     SvFLAGS(sv) |= (SVf_IOK|SVp_IOK))
 561 #define SvIOK_only_UV(sv)       ((void)SvOK_off_exc_UV(sv), \
 562                                     SvFLAGS(sv) |= (SVf_IOK|SVp_IOK))
 563
 564 #define SvIOK_UV(sv)            ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV))   \
 565                                  == (SVf_IOK|SVf_IVisUV))
 566 #define SvUOK(sv)               SvIOK_UV(sv)
 567 #define SvIOK_notUV(sv)         ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV))   \
 568                                  == SVf_IOK)
 569
 570 #define SvIsUV(sv)              (SvFLAGS(sv) & SVf_IVisUV)
 571 #define SvIsUV_on(sv)           (SvFLAGS(sv) |= SVf_IVisUV)
 572 #define SvIsUV_off(sv)          (SvFLAGS(sv) &= ~SVf_IVisUV)
 573
 574 #define SvNOK(sv)               (SvFLAGS(sv) & SVf_NOK)
 575 #define SvNOK_on(sv)            (SvFLAGS(sv) |= (SVf_NOK|SVp_NOK))
 576 #define SvNOK_off(sv)           (SvFLAGS(sv) &= ~(SVf_NOK|SVp_NOK))
 577 #define SvNOK_only(sv)          ((void)SvOK_off(sv), \
 578                                     SvFLAGS(sv) |= (SVf_NOK|SVp_NOK))
 579
 580 /*
 581 =for apidoc Am|void|SvUTF8|SV* sv
 582 Returns a boolean indicating whether the SV contains UTF-8 encoded data.
 583
 584 =for apidoc Am|void|SvUTF8_on|SV *sv
 585 Turn on the UTF8 status of an SV (the data is not changed, just the flag).
 586 Do not use frivolously.
 587
 588 =for apidoc Am|void|SvUTF8_off|SV *sv
 589 Unsets the UTF8 status of an SV.
 590
 591 =for apidoc Am|void|SvPOK_only_UTF8|SV* sv
 592 Tells an SV that it is a string and disables all other OK bits,
 593 and leaves the UTF8 status as it was.
 594
 595 =cut
 596  */
 597
 598 #define SvUTF8(sv)              (SvFLAGS(sv) & SVf_UTF8)
 599 #define SvUTF8_on(sv)           (SvFLAGS(sv) |= (SVf_UTF8))
 600 #define SvUTF8_off(sv)          (SvFLAGS(sv) &= ~(SVf_UTF8))
 601
 602 #define SvPOK(sv)               (SvFLAGS(sv) & SVf_POK)
 603 #define SvPOK_on(sv)            (assert_not_ROK(sv)                     \
 604                                  SvFLAGS(sv) |= (SVf_POK|SVp_POK))
 605 #define SvPOK_off(sv)           (SvFLAGS(sv) &= ~(SVf_POK|SVp_POK))
 606 #define SvPOK_only(sv)          (assert_not_ROK(sv)                     \
 607                                  SvFLAGS(sv) &= ~(SVf_OK|SVf_AMAGIC|    \
 608                                                   SVf_IVisUV|SVf_UTF8), \
 609                                     SvFLAGS(sv) |= (SVf_POK|SVp_POK))
 610 #define SvPOK_only_UTF8(sv)     (assert_not_ROK(sv)                     \
 611                                  SvFLAGS(sv) &= ~(SVf_OK|SVf_AMAGIC|    \
 612                                                   SVf_IVisUV),          \
 613                                     SvFLAGS(sv) |= (SVf_POK|SVp_POK))
 614
 615 #define SvVOK(sv)               (SvMAGICAL(sv) && mg_find(sv,'V'))
 616 #define SvOOK(sv)               (SvFLAGS(sv) & SVf_OOK)
 617 #define SvOOK_on(sv)            ((void)SvIOK_off(sv), SvFLAGS(sv) |= SVf_OOK)
 618 #define SvOOK_off(sv)           (SvOOK(sv) && sv_backoff(sv))
 619
 620 #define SvFAKE(sv)              (SvFLAGS(sv) & SVf_FAKE)
 621 #define SvFAKE_on(sv)           (SvFLAGS(sv) |= SVf_FAKE)
 622 #define SvFAKE_off(sv)          (SvFLAGS(sv) &= ~SVf_FAKE)
 623
 624 #define SvROK(sv)               (SvFLAGS(sv) & SVf_ROK)
 625 #define SvROK_on(sv)            (SvFLAGS(sv) |= SVf_ROK)
 626 #define SvROK_off(sv)           (SvFLAGS(sv) &= ~(SVf_ROK|SVf_AMAGIC))
 627
 628 #define SvMAGICAL(sv)           (SvFLAGS(sv) & (SVs_GMG|SVs_SMG|SVs_RMG))
 629 #define SvMAGICAL_on(sv)        (SvFLAGS(sv) |= (SVs_GMG|SVs_SMG|SVs_RMG))
 630 #define SvMAGICAL_off(sv)       (SvFLAGS(sv) &= ~(SVs_GMG|SVs_SMG|SVs_RMG))
 631
 632 #define SvGMAGICAL(sv)          (SvFLAGS(sv) & SVs_GMG)
 633 #define SvGMAGICAL_on(sv)       (SvFLAGS(sv) |= SVs_GMG)
 634 #define SvGMAGICAL_off(sv)      (SvFLAGS(sv) &= ~SVs_GMG)
 635
 636 #define SvSMAGICAL(sv)          (SvFLAGS(sv) & SVs_SMG)
 637 #define SvSMAGICAL_on(sv)       (SvFLAGS(sv) |= SVs_SMG)
 638 #define SvSMAGICAL_off(sv)      (SvFLAGS(sv) &= ~SVs_SMG)
 639
 640 #define SvRMAGICAL(sv)          (SvFLAGS(sv) & SVs_RMG)
 641 #define SvRMAGICAL_on(sv)       (SvFLAGS(sv) |= SVs_RMG)
 642 #define SvRMAGICAL_off(sv)      (SvFLAGS(sv) &= ~SVs_RMG)
 643
 644 #define SvAMAGIC(sv)            (SvFLAGS(sv) & SVf_AMAGIC)
 645 #define SvAMAGIC_on(sv)         (SvFLAGS(sv) |= SVf_AMAGIC)
 646 #define SvAMAGIC_off(sv)        (SvFLAGS(sv) &= ~SVf_AMAGIC)
 647
 648 #define SvGAMAGIC(sv)           (SvFLAGS(sv) & (SVs_GMG|SVf_AMAGIC))
 649
 650 /*
 651 #define Gv_AMG(stash) \
 652         (HV_AMAGICmb(stash) && \
 653          ((!HV_AMAGICbad(stash) && HV_AMAGIC(stash)) || Gv_AMupdate(stash)))
 654 */
 655 #define Gv_AMG(stash)           (PL_amagic_generation && Gv_AMupdate(stash))
 656
 657 #define SvWEAKREF(sv)           ((SvFLAGS(sv) & (SVf_ROK|SVprv_WEAKREF)) \
 658                                   == (SVf_ROK|SVprv_WEAKREF))
 659 #define SvWEAKREF_on(sv)        (SvFLAGS(sv) |=  (SVf_ROK|SVprv_WEAKREF))
 660 #define SvWEAKREF_off(sv)       (SvFLAGS(sv) &= ~(SVf_ROK|SVprv_WEAKREF))
 661
 662 #define SvTHINKFIRST(sv)        (SvFLAGS(sv) & SVf_THINKFIRST)
 663
 664 #define SvPADSTALE(sv)          (SvFLAGS(sv) & SVs_PADSTALE)
 665 #define SvPADSTALE_on(sv)       (SvFLAGS(sv) |= SVs_PADSTALE)
 666 #define SvPADSTALE_off(sv)      (SvFLAGS(sv) &= ~SVs_PADSTALE)
 667
 668 #define SvPADTMP(sv)            (SvFLAGS(sv) & SVs_PADTMP)
 669 #define SvPADTMP_on(sv)         (SvFLAGS(sv) |= SVs_PADTMP)
 670 #define SvPADTMP_off(sv)        (SvFLAGS(sv) &= ~SVs_PADTMP)
 671
 672 #define SvPADMY(sv)             (SvFLAGS(sv) & SVs_PADMY)
 673 #define SvPADMY_on(sv)          (SvFLAGS(sv) |= SVs_PADMY)
 674
 675 #define SvTEMP(sv)              (SvFLAGS(sv) & SVs_TEMP)
 676 #define SvTEMP_on(sv)           (SvFLAGS(sv) |= SVs_TEMP)
 677 #define SvTEMP_off(sv)          (SvFLAGS(sv) &= ~SVs_TEMP)
 678
 679 #define SvOBJECT(sv)            (SvFLAGS(sv) & SVs_OBJECT)
 680 #define SvOBJECT_on(sv)         (SvFLAGS(sv) |= SVs_OBJECT)
 681 #define SvOBJECT_off(sv)        (SvFLAGS(sv) &= ~SVs_OBJECT)
 682
 683 #define SvREADONLY(sv)          (SvFLAGS(sv) & SVf_READONLY)
 684 #define SvREADONLY_on(sv)       (SvFLAGS(sv) |= SVf_READONLY)
 685 #define SvREADONLY_off(sv)      (SvFLAGS(sv) &= ~SVf_READONLY)
 686
 687 #define SvSCREAM(sv)            (SvFLAGS(sv) & SVp_SCREAM)
 688 #define SvSCREAM_on(sv)         (SvFLAGS(sv) |= SVp_SCREAM)
 689 #define SvSCREAM_off(sv)        (SvFLAGS(sv) &= ~SVp_SCREAM)
 690
 691 #define SvCOMPILED(sv)          (SvFLAGS(sv) & SVpfm_COMPILED)
 692 #define SvCOMPILED_on(sv)       (SvFLAGS(sv) |= SVpfm_COMPILED)
 693 #define SvCOMPILED_off(sv)      (SvFLAGS(sv) &= ~SVpfm_COMPILED)
 694
 695 #define SvEVALED(sv)            (SvFLAGS(sv) & SVrepl_EVAL)
 696 #define SvEVALED_on(sv)         (SvFLAGS(sv) |= SVrepl_EVAL)
 697 #define SvEVALED_off(sv)        (SvFLAGS(sv) &= ~SVrepl_EVAL)
 698
 699 #define SvTAIL(sv)              (SvFLAGS(sv) & SVpbm_TAIL)
 700 #define SvTAIL_on(sv)           (SvFLAGS(sv) |= SVpbm_TAIL)
 701 #define SvTAIL_off(sv)          (SvFLAGS(sv) &= ~SVpbm_TAIL)
 702
 703 #define SvVALID(sv)             (SvFLAGS(sv) & SVpbm_VALID)
 704 #define SvVALID_on(sv)          (SvFLAGS(sv) |= SVpbm_VALID)
 705 #define SvVALID_off(sv)         (SvFLAGS(sv) &= ~SVpbm_VALID)
 706
 707 #ifdef USE_ITHREADS
 708 /* The following uses the FAKE flag to show that a regex pointer is infact
 709    its own offset in the regexpad for ithreads */
 710 #define SvREPADTMP(sv)          (SvFLAGS(sv) & SVf_FAKE)
 711 #define SvREPADTMP_on(sv)       (SvFLAGS(sv) |= SVf_FAKE)
 712 #define SvREPADTMP_off(sv)      (SvFLAGS(sv) &= ~SVf_FAKE)
 713 #endif
 714
 715 #define SvRV(sv) ((XRV*)  SvANY(sv))->xrv_rv
 716 #define SvRVx(sv) SvRV(sv)
 717
 718 #define SvIVX(sv) ((XPVIV*)  SvANY(sv))->xiv_iv
 719 #define SvIVXx(sv) SvIVX(sv)
 720 #define SvUVX(sv) ((XPVUV*)  SvANY(sv))->xuv_uv
 721 #define SvUVXx(sv) SvUVX(sv)
 722 #define SvNVX(sv)  ((XPVNV*)SvANY(sv))->xnv_nv
 723 #define SvNVXx(sv) SvNVX(sv)
 724 #define SvPVX(sv)  ((XPV*)  SvANY(sv))->xpv_pv
 725 #define SvPVXx(sv) SvPVX(sv)
 726 #define SvCUR(sv) ((XPV*)  SvANY(sv))->xpv_cur
 727 #define SvLEN(sv) ((XPV*)  SvANY(sv))->xpv_len
 728 #define SvLENx(sv) SvLEN(sv)
 729 #define SvEND(sv)(((XPV*)  SvANY(sv))->xpv_pv + ((XPV*)SvANY(sv))->xpv_cur)
 730 #define SvENDx(sv) ((PL_Sv = (sv)), SvEND(PL_Sv))
 731 #define SvMAGIC(sv)     ((XPVMG*)  SvANY(sv))->xmg_magic
 732 #define SvSTASH(sv)     ((XPVMG*)  SvANY(sv))->xmg_stash
 733
 734 /* Ask a scalar nicely to try to become an IV, if possible.
 735    Not guaranteed to stay returning void */
 736 /* Macro won't actually call sv_2iv if already IOK */
 737 #define SvIV_please(sv) \
 738         STMT_START {if (!SvIOKp(sv) && (SvNOK(sv) || SvPOK(sv))) \
 739                 (void) SvIV(sv); } STMT_END
 740 #define SvIV_set(sv, val) \
 741         STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
 742                 (((XPVIV*)  SvANY(sv))->xiv_iv = val); } STMT_END
 743 #define SvNV_set(sv, val) \
 744         STMT_START { assert(SvTYPE(sv) == SVt_NV || SvTYPE(sv) >= SVt_PVNV); \
 745                 (((XPVNV*)  SvANY(sv))->xnv_nv = val); } STMT_END
 746 #define SvPV_set(sv, val) \
 747         STMT_START { assert(SvTYPE(sv) >= SVt_PV); \
 748                 (((XPV*)  SvANY(sv))->xpv_pv = val); } STMT_END
 749 #define SvCUR_set(sv, val) \
 750         STMT_START { assert(SvTYPE(sv) >= SVt_PV); \
 751                 (((XPV*)  SvANY(sv))->xpv_cur = val); } STMT_END
 752 #define SvLEN_set(sv, val) \
 753         STMT_START { assert(SvTYPE(sv) >= SVt_PV); \
 754                 (((XPV*)  SvANY(sv))->xpv_len = val); } STMT_END
 755 #define SvEND_set(sv, val) \
 756         STMT_START { assert(SvTYPE(sv) >= SVt_PV); \
 757                 (((XPV*)  SvANY(sv))->xpv_cur = val - SvPVX(sv)); } STMT_END
 758
 759 #define BmRARE(sv)      ((XPVBM*)  SvANY(sv))->xbm_rare
 760 #define BmUSEFUL(sv)    ((XPVBM*)  SvANY(sv))->xbm_useful
 761 #define BmPREVIOUS(sv)  ((XPVBM*)  SvANY(sv))->xbm_previous
 762
 763 #define FmLINES(sv)     ((XPVFM*)  SvANY(sv))->xfm_lines
 764
 765 #define LvTYPE(sv)      ((XPVLV*)  SvANY(sv))->xlv_type
 766 #define LvTARG(sv)      ((XPVLV*)  SvANY(sv))->xlv_targ
 767 #define LvTARGOFF(sv)   ((XPVLV*)  SvANY(sv))->xlv_targoff
 768 #define LvTARGLEN(sv)   ((XPVLV*)  SvANY(sv))->xlv_targlen
 769
 770 #define IoIFP(sv)       ((XPVIO*)  SvANY(sv))->xio_ifp
 771 #define IoOFP(sv)       ((XPVIO*)  SvANY(sv))->xio_ofp
 772 #define IoDIRP(sv)      ((XPVIO*)  SvANY(sv))->xio_dirp
 773 #define IoANY(sv)       ((XPVIO*)  SvANY(sv))->xio_any
 774 #define IoLINES(sv)     ((XPVIO*)  SvANY(sv))->xio_lines
 775 #define IoPAGE(sv)      ((XPVIO*)  SvANY(sv))->xio_page
 776 #define IoPAGE_LEN(sv)  ((XPVIO*)  SvANY(sv))->xio_page_len
 777 #define IoLINES_LEFT(sv)((XPVIO*)  SvANY(sv))->xio_lines_left
 778 #define IoTOP_NAME(sv)  ((XPVIO*)  SvANY(sv))->xio_top_name
 779 #define IoTOP_GV(sv)    ((XPVIO*)  SvANY(sv))->xio_top_gv
 780 #define IoFMT_NAME(sv)  ((XPVIO*)  SvANY(sv))->xio_fmt_name
 781 #define IoFMT_GV(sv)    ((XPVIO*)  SvANY(sv))->xio_fmt_gv
 782 #define IoBOTTOM_NAME(sv)((XPVIO*) SvANY(sv))->xio_bottom_name
 783 #define IoBOTTOM_GV(sv) ((XPVIO*)  SvANY(sv))->xio_bottom_gv
 784 #define IoSUBPROCESS(sv)((XPVIO*)  SvANY(sv))->xio_subprocess
 785 #define IoTYPE(sv)      ((XPVIO*)  SvANY(sv))->xio_type
 786 #define IoFLAGS(sv)     ((XPVIO*)  SvANY(sv))->xio_flags
 787
 788 /* IoTYPE(sv) is a single character telling the type of I/O connection. */
 789 #define IoTYPE_RDONLY   '<'
 790 #define IoTYPE_WRONLY   '>'
 791 #define IoTYPE_RDWR     '+'
 792 #define IoTYPE_APPEND   'a'
 793 #define IoTYPE_PIPE     '|'
 794 #define IoTYPE_STD      '-'     /* stdin or stdout */
 795 #define IoTYPE_SOCKET   's'
 796 #define IoTYPE_CLOSED   ' '
 797
 798 /*
 799 =for apidoc Am|bool|SvTAINTED|SV* sv
 800 Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if
 801 not.
 802
 803 =for apidoc Am|void|SvTAINTED_on|SV* sv
 804 Marks an SV as tainted.
 805
 806 =for apidoc Am|void|SvTAINTED_off|SV* sv
 807 Untaints an SV. Be I<very> careful with this routine, as it short-circuits
 808 some of Perl's fundamental security features. XS module authors should not
 809 use this function unless they fully understand all the implications of
 810 unconditionally untainting the value. Untainting should be done in the
 811 standard perl fashion, via a carefully crafted regexp, rather than directly
 812 untainting variables.
 813
 814 =for apidoc Am|void|SvTAINT|SV* sv
 815 Taints an SV if tainting is enabled
 816
 817 =cut
 818 */
 819
 820 #define SvTAINTED(sv)     (SvMAGICAL(sv) && sv_tainted(sv))
 821 #define SvTAINTED_on(sv)  STMT_START{ if(PL_tainting){sv_taint(sv);}   }STMT_END
 822 #define SvTAINTED_off(sv) STMT_START{ if(PL_tainting){sv_untaint(sv);} }STMT_END
 823
 824 #define SvTAINT(sv)                     \
 825     STMT_START {                        \
 826         if (PL_tainting) {              \
 827             if (PL_tainted)             \
 828                 SvTAINTED_on(sv);       \
 829         }                               \
 830     } STMT_END
 831
 832 /*
 833 =for apidoc Am|char*|SvPV_force|SV* sv|STRLEN len
 834 Like C<SvPV> but will force the SV into containing just a string
 835 (C<SvPOK_only>).  You want force if you are going to update the C<SvPVX>
 836 directly.
 837
 838 =for apidoc Am|char*|SvPV_force_nomg|SV* sv|STRLEN len
 839 Like C<SvPV> but will force the SV into containing just a string
 840 (C<SvPOK_only>).  You want force if you are going to update the C<SvPVX>
 841 directly. Doesn't process magic.
 842
 843 =for apidoc Am|char*|SvPV|SV* sv|STRLEN len
 844 Returns a pointer to the string in the SV, or a stringified form of
 845 the SV if the SV does not contain a string.  The SV may cache the
 846 stringified version becoming C<SvPOK>.  Handles 'get' magic. See also
 847 C<SvPVx> for a version which guarantees to evaluate sv only once.
 848
 849 =for apidoc Am|char*|SvPVx|SV* sv|STRLEN len
 850 A version of C<SvPV> which guarantees to evaluate sv only once.
 851
 852 =for apidoc Am|char*|SvPV_nolen|SV* sv
 853 Returns a pointer to the string in the SV, or a stringified form of
 854 the SV if the SV does not contain a string.  The SV may cache the
 855 stringified form becoming C<SvPOK>.  Handles 'get' magic.
 856
 857 =for apidoc Am|IV|SvIV|SV* sv
 858 Coerces the given SV to an integer and returns it. See  C<SvIVx> for a
 859 version which guarantees to evaluate sv only once.
 860
 861 =for apidoc Am|IV|SvIVx|SV* sv
 862 Coerces the given SV to an integer and returns it. Guarantees to evaluate
 863 sv only once. Use the more efficient C<SvIV> otherwise.
 864
 865 =for apidoc Am|NV|SvNV|SV* sv
 866 Coerce the given SV to a double and return it. See  C<SvNVx> for a version
 867 which guarantees to evaluate sv only once.
 868
 869 =for apidoc Am|NV|SvNVx|SV* sv
 870 Coerces the given SV to a double and returns it. Guarantees to evaluate
 871 sv only once. Use the more efficient C<SvNV> otherwise.
 872
 873 =for apidoc Am|UV|SvUV|SV* sv
 874 Coerces the given SV to an unsigned integer and returns it.  See C<SvUVx>
 875 for a version which guarantees to evaluate sv only once.
 876
 877 =for apidoc Am|UV|SvUVx|SV* sv
 878 Coerces the given SV to an unsigned integer and returns it. Guarantees to
 879 evaluate sv only once. Use the more efficient C<SvUV> otherwise.
 880
 881 =for apidoc Am|bool|SvTRUE|SV* sv
 882 Returns a boolean indicating whether Perl would evaluate the SV as true or
 883 false, defined or undefined.  Does not handle 'get' magic.
 884
 885 =for apidoc Am|char*|SvPVutf8_force|SV* sv|STRLEN len
 886 Like C<SvPV_force>, but converts sv to utf8 first if necessary.
 887
 888 =for apidoc Am|char*|SvPVutf8|SV* sv|STRLEN len
 889 Like C<SvPV>, but converts sv to utf8 first if necessary.
 890
 891 =for apidoc Am|char*|SvPVutf8_nolen|SV* sv
 892 Like C<SvPV_nolen>, but converts sv to utf8 first if necessary.
 893
 894 =for apidoc Am|char*|SvPVbyte_force|SV* sv|STRLEN len
 895 Like C<SvPV_force>, but converts sv to byte representation first if necessary.
 896
 897 =for apidoc Am|char*|SvPVbyte|SV* sv|STRLEN len
 898 Like C<SvPV>, but converts sv to byte representation first if necessary.
 899
 900 =for apidoc Am|char*|SvPVbyte_nolen|SV* sv
 901 Like C<SvPV_nolen>, but converts sv to byte representation first if necessary.
 902
 903 =for apidoc Am|char*|SvPVutf8x_force|SV* sv|STRLEN len
 904 Like C<SvPV_force>, but converts sv to utf8 first if necessary.
 905 Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8_force>
 906 otherwise.
 907
 908 =for apidoc Am|char*|SvPVutf8x|SV* sv|STRLEN len
 909 Like C<SvPV>, but converts sv to utf8 first if necessary.
 910 Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8>
 911 otherwise.
 912
 913 =for apidoc Am|char*|SvPVbytex_force|SV* sv|STRLEN len
 914 Like C<SvPV_force>, but converts sv to byte representation first if necessary.
 915 Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte_force>
 916 otherwise.
 917
 918 =for apidoc Am|char*|SvPVbytex|SV* sv|STRLEN len
 919 Like C<SvPV>, but converts sv to byte representation first if necessary.
 920 Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte>
 921 otherwise.
 922
 923
 924 =cut
 925 */
 926
 927 /* Let us hope that bitmaps for UV and IV are the same */
 928 #define SvIV(sv) (SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv))
 929 #define SvUV(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv))
 930 #define SvNV(sv) (SvNOK(sv) ? SvNVX(sv) : sv_2nv(sv))
 931
 932 /* ----*/
 933
 934 #define SvPV(sv, lp) SvPV_flags(sv, lp, SV_GMAGIC)
 935
 936 #define SvPV_flags(sv, lp, flags) \
 937     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
 938      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags))
 939
 940 #define SvPV_force(sv, lp) SvPV_force_flags(sv, lp, SV_GMAGIC)
 941
 942 #define SvPV_force_nomg(sv, lp) SvPV_force_flags(sv, lp, 0)
 943
 944 #define SvPV_force_flags(sv, lp, flags) \
 945     ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
 946     ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags))
 947
 948 #define SvPV_nolen(sv) \
 949     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
 950      ? SvPVX(sv) : sv_2pv_nolen(sv))
 951
 952 #define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0)
 953
 954 /* ----*/
 955
 956 #define SvPVutf8(sv, lp) \
 957     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK|SVf_UTF8) \
 958      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvutf8(sv, &lp))
 959
 960 #define SvPVutf8_force(sv, lp) \
 961     ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == (SVf_POK|SVf_UTF8) \
 962      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvutf8n_force(sv, &lp))
 963
 964
 965 #define SvPVutf8_nolen(sv) \
 966     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK|SVf_UTF8)\
 967      ? SvPVX(sv) : sv_2pvutf8_nolen(sv))
 968
 969 /* ----*/
 970
 971 #define SvPVbyte(sv, lp) \
 972     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \
 973      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp))
 974
 975 #define SvPVbyte_force(sv, lp) \
 976     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_THINKFIRST)) == (SVf_POK) \
 977      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvbyte_force(sv, &lp))
 978
 979 #define SvPVbyte_nolen(sv) \
 980     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK)\
 981      ? SvPVX(sv) : sv_2pvbyte_nolen(sv))
 982
 983
 984
 985 /* define FOOx(): idempotent versions of FOO(). If possible, use a local
 986  * var to evaluate the arg once; failing that, use a global if possible;
 987  * failing that, call a function to do the work
 988  */
 989
 990 #define SvPVx_force(sv, lp) sv_pvn_force(sv, &lp)
 991 #define SvPVutf8x_force(sv, lp) sv_pvutf8n_force(sv, &lp)
 992 #define SvPVbytex_force(sv, lp) sv_pvbyten_force(sv, &lp)
 993
 994 #if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC)
 995
 996 #  define SvIVx(sv) ({SV *nsv = (SV*)(sv); SvIV(nsv); })
 997 #  define SvUVx(sv) ({SV *nsv = (SV*)(sv); SvUV(nsv); })
 998 #  define SvNVx(sv) ({SV *nsv = (SV*)(sv); SvNV(nsv); })
 999 #  define SvPVx(sv, lp) ({SV *nsv = (sv); SvPV(nsv, lp); })
1000 #  define SvPVutf8x(sv, lp) ({SV *nsv = (sv); SvPVutf8(nsv, lp); })
1001 #  define SvPVbytex(sv, lp) ({SV *nsv = (sv); SvPVbyte(nsv, lp); })
1002 #  define SvTRUE(sv) (                                          \
1003     !sv                                                         \
1004     ? 0                                                         \
1005     :    SvPOK(sv)                                              \
1006         ?   (({XPV *nxpv = (XPV*)SvANY(sv);                     \
1007              nxpv &&                                            \
1008              (nxpv->xpv_cur > 1 ||                              \
1009               (nxpv->xpv_cur && *nxpv->xpv_pv != '0')); })      \
1010              ? 1                                                \
1011              : 0)                                               \
1012         :                                                       \
1013             SvIOK(sv)                                           \
1014             ? SvIVX(sv) != 0                                    \
1015             :   SvNOK(sv)                                       \
1016                 ? SvNVX(sv) != 0.0                              \
1017                 : sv_2bool(sv) )
1018 #  define SvTRUEx(sv) ({SV *nsv = (sv); SvTRUE(nsv); })
1019
1020 #else /* __GNUC__ */
1021
1022 /* These inlined macros use globals, which will require a thread
1023  * declaration in user code, so we avoid them under threads */
1024
1025 #  define SvIVx(sv) ((PL_Sv = (sv)), SvIV(PL_Sv))
1026 #  define SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv))
1027 #  define SvNVx(sv) ((PL_Sv = (sv)), SvNV(PL_Sv))
1028 #  define SvPVx(sv, lp) ((PL_Sv = (sv)), SvPV(PL_Sv, lp))
1029 #  define SvPVutf8x(sv, lp) ((PL_Sv = (sv)), SvPVutf8(PL_Sv, lp))
1030 #  define SvPVbytex(sv, lp) ((PL_Sv = (sv)), SvPVbyte(PL_Sv, lp))
1031 #  define SvTRUE(sv) (                                          \
1032     !sv                                                         \
1033     ? 0                                                         \
1034     :    SvPOK(sv)                                              \
1035         ?   ((PL_Xpv = (XPV*)SvANY(sv)) &&                      \
1036              (PL_Xpv->xpv_cur > 1 ||                            \
1037               (PL_Xpv->xpv_cur && *PL_Xpv->xpv_pv != '0'))      \
1038              ? 1                                                \
1039              : 0)                                               \
1040         :                                                       \
1041             SvIOK(sv)                                           \
1042             ? SvIVX(sv) != 0                                    \
1043             :   SvNOK(sv)                                       \
1044                 ? SvNVX(sv) != 0.0                              \
1045                 : sv_2bool(sv) )
1046 #  define SvTRUEx(sv) ((PL_Sv = (sv)), SvTRUE(PL_Sv))
1047 #endif /* __GNU__ */
1048
1049 #define SvIsCOW(sv)             ((SvFLAGS(sv) & (SVf_FAKE | SVf_READONLY)) == \
1050                                     (SVf_FAKE | SVf_READONLY))
1051 #define SvIsCOW_shared_hash(sv) (SvIsCOW(sv) && SvLEN(sv) == 0)
1052
1053 /* flag values for sv_*_flags functions */
1054 #define SV_IMMEDIATE_UNREF      1
1055 #define SV_GMAGIC               2
1056 #define SV_COW_DROP_PV          4
1057 #define SV_UTF8_NO_ENCODING     8
1058
1059 /* We are about to replace the SV's current value. So if it's copy on write
1060    we need to normalise it. Use the SV_COW_DROP_PV flag hint to say that
1061    the value is about to get thrown away, so drop the PV rather than go to
1062    the effort of making a read-write copy only for it to get immediately
1063    discarded.  */
1064
1065 #define SV_CHECK_THINKFIRST_COW_DROP(sv) if (SvTHINKFIRST(sv)) \
1066                                     sv_force_normal_flags(sv, SV_COW_DROP_PV)
1067
1068 #ifdef PERL_COPY_ON_WRITE
1069 #  define SvRELEASE_IVX(sv)   ((void)((SvFLAGS(sv) & (SVf_OOK|SVf_READONLY|SVf_FAKE)) \
1070                                 && Perl_sv_release_IVX(aTHX_ sv)))
1071 #  define SvIsCOW_normal(sv)    (SvIsCOW(sv) && SvLEN(sv))
1072
1073 #define CAN_COW_MASK    (SVs_OBJECT|SVs_GMG|SVs_SMG|SVs_RMG|SVf_IOK|SVf_NOK| \
1074                          SVf_POK|SVf_ROK|SVp_IOK|SVp_NOK|SVp_POK|SVf_FAKE| \
1075                          SVf_OOK|SVf_BREAK|SVf_READONLY|SVf_AMAGIC)
1076 #define CAN_COW_FLAGS   (SVp_POK|SVf_POK)
1077
1078 #else
1079 #  define SvRELEASE_IVX(sv)   ((void)SvOOK_off(sv))
1080 #endif /* PERL_COPY_ON_WRITE */
1081
1082 #define SV_CHECK_THINKFIRST(sv) if (SvTHINKFIRST(sv)) \
1083                                     sv_force_normal_flags(sv, 0)
1084
1085
1086 /* all these 'functions' are now just macros */
1087
1088 #define sv_pv(sv) SvPV_nolen(sv)
1089 #define sv_pvutf8(sv) SvPVutf8_nolen(sv)
1090 #define sv_pvbyte(sv) SvPVbyte_nolen(sv)
1091
1092 #define sv_pvn_force_nomg(sv, lp) sv_pvn_force_flags(sv, lp, 0)
1093 #define sv_utf8_upgrade_nomg(sv) sv_utf8_upgrade_flags(sv, 0)
1094 #define sv_catpvn_nomg(dsv, sstr, slen) sv_catpvn_flags(dsv, sstr, slen, 0)
1095 #define sv_setsv(dsv, ssv) sv_setsv_flags(dsv, ssv, SV_GMAGIC)
1096 #define sv_setsv_nomg(dsv, ssv) sv_setsv_flags(dsv, ssv, 0)
1097 #define sv_catsv(dsv, ssv) sv_catsv_flags(dsv, ssv, SV_GMAGIC)
1098 #define sv_catsv_nomg(dsv, ssv) sv_catsv_flags(dsv, ssv, 0)
1099 #define sv_catpvn(dsv, sstr, slen) sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC)
1100 #define sv_2pv(sv, lp) sv_2pv_flags(sv, lp, SV_GMAGIC)
1101 #define sv_2pv_nomg(sv, lp) sv_2pv_flags(sv, lp, 0)
1102 #define sv_pvn_force(sv, lp) sv_pvn_force_flags(sv, lp, SV_GMAGIC)
1103 #define sv_utf8_upgrade(sv) sv_utf8_upgrade_flags(sv, SV_GMAGIC)
1104
1105 /* Should be named SvCatPVN_utf8_upgrade? */
1106 #define sv_catpvn_utf8_upgrade(dsv, sstr, slen, nsv)    \
1107         STMT_START {                                    \
1108             if (!(nsv))                                 \
1109                 nsv = sv_2mortal(newSVpvn(sstr, slen)); \
1110             else                                        \
1111                 sv_setpvn(nsv, sstr, slen);             \
1112             SvUTF8_off(nsv);                            \
1113             sv_utf8_upgrade(nsv);                       \
1114             sv_catsv(dsv, nsv); \
1115         } STMT_END
1116
1117 /*
1118 =for apidoc Am|SV*|newRV_inc|SV* sv
1119
1120 Creates an RV wrapper for an SV.  The reference count for the original SV is
1121 incremented.
1122
1123 =cut
1124 */
1125
1126 #define newRV_inc(sv)   newRV(sv)
1127
1128 /* the following macros update any magic values this sv is associated with */
1129
1130 /*
1131 =head1 Magical Functions
1132
1133 =for apidoc Am|void|SvGETMAGIC|SV* sv
1134 Invokes C<mg_get> on an SV if it has 'get' magic.  This macro evaluates its
1135 argument more than once.
1136
1137 =for apidoc Am|void|SvSETMAGIC|SV* sv
1138 Invokes C<mg_set> on an SV if it has 'set' magic.  This macro evaluates its
1139 argument more than once.
1140
1141 =for apidoc Am|void|SvSetSV|SV* dsb|SV* ssv
1142 Calls C<sv_setsv> if dsv is not the same as ssv.  May evaluate arguments
1143 more than once.
1144
1145 =for apidoc Am|void|SvSetSV_nosteal|SV* dsv|SV* ssv
1146 Calls a non-destructive version of C<sv_setsv> if dsv is not the same as
1147 ssv. May evaluate arguments more than once.
1148
1149 =for apidoc Am|void|SvSetMagicSV|SV* dsb|SV* ssv
1150 Like C<SvSetSV>, but does any set magic required afterwards.
1151
1152 =for apidoc Am|void|SvSetMagicSV_nosteal|SV* dsv|SV* ssv
1153 Like C<SvSetMagicSV>, but does any set magic required afterwards.
1154
1155 =for apidoc Am|void|SvSHARE|SV* sv
1156 Arranges for sv to be shared between threads if a suitable module
1157 has been loaded.
1158
1159 =for apidoc Am|void|SvLOCK|SV* sv
1160 Arranges for a mutual exclusion lock to be obtained on sv if a suitable module
1161 has been loaded.
1162
1163 =for apidoc Am|void|SvUNLOCK|SV* sv
1164 Releases a mutual exclusion lock on sv if a suitable module
1165 has been loaded.
1166
1167 =head1 SV Manipulation Functions
1168
1169 =for apidoc Am|char *|SvGROW|SV* sv|STRLEN len
1170 Expands the character buffer in the SV so that it has room for the
1171 indicated number of bytes (remember to reserve space for an extra trailing
1172 NUL character).  Calls C<sv_grow> to perform the expansion if necessary.
1173 Returns a pointer to the character buffer.
1174
1175 =cut
1176 */
1177
1178 #define SvSHARE(sv) CALL_FPTR(PL_sharehook)(aTHX_ sv)
1179 #define SvLOCK(sv) CALL_FPTR(PL_lockhook)(aTHX_ sv)
1180 #define SvUNLOCK(sv) CALL_FPTR(PL_unlockhook)(aTHX_ sv)
1181
1182 #define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
1183 #define SvSETMAGIC(x) STMT_START { if (SvSMAGICAL(x)) mg_set(x); } STMT_END
1184
1185 #define SvSetSV_and(dst,src,finally) \
1186         STMT_START {                                    \
1187             if ((dst) != (src)) {                       \
1188                 sv_setsv(dst, src);                     \
1189                 finally;                                \
1190             }                                           \
1191         } STMT_END
1192 #define SvSetSV_nosteal_and(dst,src,finally) \
1193         STMT_START {                                    \
1194             if ((dst) != (src)) {                       \
1195                 U32 tMpF = SvFLAGS(src) & SVs_TEMP;     \
1196                 SvTEMP_off(src);                        \
1197                 sv_setsv(dst, src);                     \
1198                 SvFLAGS(src) |= tMpF;                   \
1199                 finally;                                \
1200             }                                           \
1201         } STMT_END
1202
1203 #define SvSetSV(dst,src) \
1204                 SvSetSV_and(dst,src,/*nothing*/;)
1205 #define SvSetSV_nosteal(dst,src) \
1206                 SvSetSV_nosteal_and(dst,src,/*nothing*/;)
1207
1208 #define SvSetMagicSV(dst,src) \
1209                 SvSetSV_and(dst,src,SvSETMAGIC(dst))
1210 #define SvSetMagicSV_nosteal(dst,src) \
1211                 SvSetSV_nosteal_and(dst,src,SvSETMAGIC(dst))
1212
1213
1214 #if !defined(SKIP_DEBUGGING)
1215 #define SvPEEK(sv) sv_peek(sv)
1216 #else
1217 #define SvPEEK(sv) ""
1218 #endif
1219
1220 #define SvIMMORTAL(sv) ((sv)==&PL_sv_undef || (sv)==&PL_sv_yes || (sv)==&PL_sv_no)
1221
1222 #define boolSV(b) ((b) ? &PL_sv_yes : &PL_sv_no)
1223
1224 #define isGV(sv) (SvTYPE(sv) == SVt_PVGV)
1225
1226 #define SvGROW(sv,len) (SvLEN(sv) < (len) ? sv_grow(sv,len) : SvPVX(sv))
1227 #define Sv_Grow sv_grow
1228
1229 #define CLONEf_COPY_STACKS 1
1230 #define CLONEf_KEEP_PTR_TABLE 2
1231 #define CLONEf_CLONE_HOST 4
1232 #define CLONEf_JOIN_IN 8
1233
1234 struct clone_params {
1235   AV* stashes;
1236   UV  flags;
1237   PerlInterpreter *proto_perl;
1238 };