avoid " in Carp.t test programs, due to Win32 shell issues
[perl.git] / sv.h
1 /*    sv.h
2  *
3  *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4  *    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 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_BIND,       /* 1 */
49         SVt_IV,         /* 2 */
50         SVt_NV,         /* 3 */
51         /* RV was here, before it was merged with IV.  */
52         SVt_PV,         /* 4 */
53         SVt_PVIV,       /* 5 */
54         SVt_PVNV,       /* 6 */
55         SVt_PVMG,       /* 7 */
56         SVt_REGEXP,     /* 8 */
57         /* PVBM was here, before BIND replaced it.  */
58         SVt_PVGV,       /* 9 */
59         SVt_PVLV,       /* 10 */
60         SVt_PVAV,       /* 11 */
61         SVt_PVHV,       /* 12 */
62         SVt_PVCV,       /* 13 */
63         SVt_PVFM,       /* 14 */
64         SVt_PVIO,       /* 15 */
65         SVt_LAST        /* keep last in enum. used to size arrays */
66 } svtype;
67
68 /* *** any alterations to the SV types above need to be reflected in
69  * SVt_MASK and the various PL_valid_types_* tables */
70
71 #define SVt_MASK 0xf    /* smallest bitmask that covers all types */
72
73 #ifndef PERL_CORE
74 /* Although Fast Boyer Moore tables are now being stored in PVGVs, for most
75    purposes eternal code wanting to consider PVBM probably needs to think of
76    PVMG instead.  */
77 #  define SVt_PVBM      SVt_PVMG
78 /* Anything wanting to create a reference from clean should ensure that it has
79    a scalar of type SVt_IV now:  */
80 #  define SVt_RV        SVt_IV
81 #endif
82
83 /* There is collusion here with sv_clear - sv_clear exits early for SVt_NULL
84    so never reaches the clause at the end that uses sv_type_details->body_size
85    to determine whether to call safefree(). Hence body_size can be set
86    non-zero to record the size of HEs, without fear of bogus frees.  */
87 #if defined(PERL_IN_HV_C) || defined(PERL_IN_XS_APITEST)
88 #define HE_SVSLOT       SVt_NULL
89 #endif
90
91 #define PERL_ARENA_ROOTS_SIZE   (SVt_LAST)
92
93 /* typedefs to eliminate some typing */
94 typedef struct he HE;
95 typedef struct hek HEK;
96
97 /* Using C's structural equivalence to help emulate C++ inheritance here... */
98
99 /* start with 2 sv-head building blocks */
100 #define _SV_HEAD(ptrtype) \
101     ptrtype     sv_any;         /* pointer to body */   \
102     U32         sv_refcnt;      /* how many references to us */ \
103     U32         sv_flags        /* what we are */
104
105 #define _SV_HEAD_UNION \
106     union {                             \
107         char*   svu_pv;         /* pointer to malloced string */        \
108         IV      svu_iv;                 \
109         UV      svu_uv;                 \
110         SV*     svu_rv;         /* pointer to another SV */             \
111         SV**    svu_array;              \
112         HE**    svu_hash;               \
113         GP*     svu_gp;                 \
114         PerlIO *svu_fp;                 \
115     }   sv_u
116
117
118 struct STRUCT_SV {              /* struct sv { */
119     _SV_HEAD(void*);
120     _SV_HEAD_UNION;
121 #ifdef DEBUG_LEAKING_SCALARS
122     PERL_BITFIELD32 sv_debug_optype:9;  /* the type of OP that allocated us */
123     PERL_BITFIELD32 sv_debug_inpad:1;   /* was allocated in a pad for an OP */
124     PERL_BITFIELD32 sv_debug_line:16;   /* the line where we were allocated */
125     UV              sv_debug_serial;    /* serial number of sv allocation   */
126     char *          sv_debug_file;      /* the file where we were allocated */
127     SV *            sv_debug_parent;    /* what we were cloned from (ithreads)*/
128 #endif
129 };
130
131 struct gv {
132     _SV_HEAD(XPVGV*);           /* pointer to xpvgv body */
133     _SV_HEAD_UNION;
134 };
135
136 struct cv {
137     _SV_HEAD(XPVCV*);           /* pointer to xpvcv body */
138     _SV_HEAD_UNION;
139 };
140
141 struct av {
142     _SV_HEAD(XPVAV*);           /* pointer to xpvav body */
143     _SV_HEAD_UNION;
144 };
145
146 struct hv {
147     _SV_HEAD(XPVHV*);           /* pointer to xpvhv body */
148     _SV_HEAD_UNION;
149 };
150
151 struct io {
152     _SV_HEAD(XPVIO*);           /* pointer to xpvio body */
153     _SV_HEAD_UNION;
154 };
155
156 struct p5rx {
157     _SV_HEAD(struct regexp*);   /* pointer to regexp body */
158     _SV_HEAD_UNION;
159 };
160
161 #undef _SV_HEAD
162 #undef _SV_HEAD_UNION           /* ensure no pollution */
163
164 /*
165 =head1 SV Manipulation Functions
166
167 =for apidoc Am|U32|SvREFCNT|SV* sv
168 Returns the value of the object's reference count.
169
170 =for apidoc Am|SV*|SvREFCNT_inc|SV* sv
171 Increments the reference count of the given SV.
172
173 All of the following SvREFCNT_inc* macros are optimized versions of
174 SvREFCNT_inc, and can be replaced with SvREFCNT_inc.
175
176 =for apidoc Am|SV*|SvREFCNT_inc_NN|SV* sv
177 Same as SvREFCNT_inc, but can only be used if you know I<sv>
178 is not NULL.  Since we don't have to check the NULLness, it's faster
179 and smaller.
180
181 =for apidoc Am|void|SvREFCNT_inc_void|SV* sv
182 Same as SvREFCNT_inc, but can only be used if you don't need the
183 return value.  The macro doesn't need to return a meaningful value.
184
185 =for apidoc Am|void|SvREFCNT_inc_void_NN|SV* sv
186 Same as SvREFCNT_inc, but can only be used if you don't need the return
187 value, and you know that I<sv> is not NULL.  The macro doesn't need
188 to return a meaningful value, or check for NULLness, so it's smaller
189 and faster.
190
191 =for apidoc Am|SV*|SvREFCNT_inc_simple|SV* sv
192 Same as SvREFCNT_inc, but can only be used with expressions without side
193 effects.  Since we don't have to store a temporary value, it's faster.
194
195 =for apidoc Am|SV*|SvREFCNT_inc_simple_NN|SV* sv
196 Same as SvREFCNT_inc_simple, but can only be used if you know I<sv>
197 is not NULL.  Since we don't have to check the NULLness, it's faster
198 and smaller.
199
200 =for apidoc Am|void|SvREFCNT_inc_simple_void|SV* sv
201 Same as SvREFCNT_inc_simple, but can only be used if you don't need the
202 return value.  The macro doesn't need to return a meaningful value.
203
204 =for apidoc Am|void|SvREFCNT_inc_simple_void_NN|SV* sv
205 Same as SvREFCNT_inc, but can only be used if you don't need the return
206 value, and you know that I<sv> is not NULL.  The macro doesn't need
207 to return a meaningful value, or check for NULLness, so it's smaller
208 and faster.
209
210 =for apidoc Am|void|SvREFCNT_dec|SV* sv
211 Decrements the reference count of the given SV.
212
213 =for apidoc Am|svtype|SvTYPE|SV* sv
214 Returns the type of the SV.  See C<svtype>.
215
216 =for apidoc Am|void|SvUPGRADE|SV* sv|svtype type
217 Used to upgrade an SV to a more complex form.  Uses C<sv_upgrade> to
218 perform the upgrade if necessary.  See C<svtype>.
219
220 =cut
221 */
222
223 #define SvANY(sv)       (sv)->sv_any
224 #define SvFLAGS(sv)     (sv)->sv_flags
225 #define SvREFCNT(sv)    (sv)->sv_refcnt
226
227 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
228 #  define SvREFCNT_inc(sv)              \
229     ({                                  \
230         SV * const _sv = MUTABLE_SV(sv);        \
231         if (_sv)                        \
232              (SvREFCNT(_sv))++;         \
233         _sv;                            \
234     })
235 #  define SvREFCNT_inc_simple(sv)       \
236     ({                                  \
237         if (sv)                         \
238              (SvREFCNT(sv))++;          \
239         MUTABLE_SV(sv);                         \
240     })
241 #  define SvREFCNT_inc_NN(sv)           \
242     ({                                  \
243         SV * const _sv = MUTABLE_SV(sv);        \
244         SvREFCNT(_sv)++;                \
245         _sv;                            \
246     })
247 #  define SvREFCNT_inc_void(sv)         \
248     ({                                  \
249         SV * const _sv = MUTABLE_SV(sv);        \
250         if (_sv)                        \
251             (void)(SvREFCNT(_sv)++);    \
252     })
253 #else
254 #  define SvREFCNT_inc(sv)      \
255         ((PL_Sv=MUTABLE_SV(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL)
256 #  define SvREFCNT_inc_simple(sv) \
257         ((sv) ? (SvREFCNT(sv)++,MUTABLE_SV(sv)) : NULL)
258 #  define SvREFCNT_inc_NN(sv) \
259         (PL_Sv=MUTABLE_SV(sv),++(SvREFCNT(PL_Sv)),PL_Sv)
260 #  define SvREFCNT_inc_void(sv) \
261         (void)((PL_Sv=MUTABLE_SV(sv)) ? ++(SvREFCNT(PL_Sv)) : 0)
262 #endif
263
264 /* These guys don't need the curly blocks */
265 #define SvREFCNT_inc_simple_void(sv)    STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END
266 #define SvREFCNT_inc_simple_NN(sv)      (++(SvREFCNT(sv)),MUTABLE_SV(sv))
267 #define SvREFCNT_inc_void_NN(sv)        (void)(++SvREFCNT(MUTABLE_SV(sv)))
268 #define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT(MUTABLE_SV(sv)))
269
270 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
271 #  define SvREFCNT_dec(sv)              \
272     ({                                  \
273         SV * const _sv = MUTABLE_SV(sv);        \
274         if (_sv) {                      \
275             if (SvREFCNT(_sv)) {        \
276                 if (--(SvREFCNT(_sv)) == 0) \
277                     Perl_sv_free2(aTHX_ _sv);   \
278             } else {                    \
279                 sv_free(_sv);           \
280             }                           \
281         }                               \
282     })
283 #else
284 #define SvREFCNT_dec(sv)        sv_free(MUTABLE_SV(sv))
285 #endif
286
287 #define SVTYPEMASK      0xff
288 #define SvTYPE(sv)      ((svtype)((sv)->sv_flags & SVTYPEMASK))
289
290 /* Sadly there are some parts of the core that have pointers to already-freed
291    SV heads, and rely on being able to tell that they are now free. So mark
292    them all by using a consistent macro.  */
293 #define SvIS_FREED(sv)  ((sv)->sv_flags == SVTYPEMASK)
294
295 #define SvUPGRADE(sv, mt) (SvTYPE(sv) >= (mt) || (sv_upgrade(sv, mt), 1))
296
297 #define SVf_IOK         0x00000100  /* has valid public integer value */
298 #define SVf_NOK         0x00000200  /* has valid public numeric value */
299 #define SVf_POK         0x00000400  /* has valid public pointer value */
300 #define SVf_ROK         0x00000800  /* has a valid reference pointer */
301
302 #define SVp_IOK         0x00001000  /* has valid non-public integer value */
303 #define SVp_NOK         0x00002000  /* has valid non-public numeric value */
304 #define SVp_POK         0x00004000  /* has valid non-public pointer value */
305 #define SVp_SCREAM      0x00008000  /* has been studied? */
306 #define SVphv_CLONEABLE SVp_SCREAM  /* PVHV (stashes) clone its objects */
307 #define SVpgv_GP        SVp_SCREAM  /* GV has a valid GP */
308 #define SVprv_PCS_IMPORTED  SVp_SCREAM  /* RV is a proxy for a constant
309                                        subroutine in another package. Set the
310                                        CvIMPORTED_CV_ON() if it needs to be
311                                        expanded to a real GV */
312
313 #define SVs_PADSTALE    0x00010000  /* lexical has gone out of scope */
314 #define SVpad_STATE     0x00010000  /* pad name is a "state" var */
315 #define SVs_PADTMP      0x00020000  /* in use as tmp */
316 #define SVpad_TYPED     0x00020000  /* pad name is a Typed Lexical */
317 #define SVs_PADMY       0x00040000  /* in use a "my" variable */
318 #define SVpad_OUR       0x00040000  /* pad name is "our" instead of "my" */
319 #define SVs_TEMP        0x00080000  /* string is stealable? */
320 #define SVs_OBJECT      0x00100000  /* is "blessed" */
321 #define SVs_GMG         0x00200000  /* has magical get method */
322 #define SVs_SMG         0x00400000  /* has magical set method */
323 #define SVs_RMG         0x00800000  /* has random magical methods */
324
325 #define SVf_FAKE        0x01000000  /* 0: glob or lexical is just a copy
326                                        1: SV head arena wasn't malloc()ed
327                                        2: in conjunction with SVf_READONLY
328                                           marks a shared hash key scalar
329                                           (SvLEN == 0) or a copy on write
330                                           string (SvLEN != 0) [SvIsCOW(sv)]
331                                        3: For PVCV, whether CvUNIQUE(cv)
332                                           refers to an eval or once only
333                                           [CvEVAL(cv), CvSPECIAL(cv)]
334                                        4: On a pad name SV, that slot in the
335                                           frame AV is a REFCNT'ed reference
336                                           to a lexical from "outside". */
337 #define SVphv_REHASH    SVf_FAKE    /* 5: On a PVHV, hash values are being
338                                           recalculated */
339 #define SVf_OOK         0x02000000  /* has valid offset value. For a PVHV this
340                                        means that a hv_aux struct is present
341                                        after the main array */
342 #define SVf_BREAK       0x04000000  /* refcnt is artificially low - used by
343                                        SVs in final arena cleanup.
344                                        Set in S_regtry on PL_reg_curpm, so that
345                                        perl_destruct will skip it. */
346 #define SVf_READONLY    0x08000000  /* may not be modified */
347
348
349
350
351 #define SVf_THINKFIRST  (SVf_READONLY|SVf_ROK|SVf_FAKE)
352
353 #define SVf_OK          (SVf_IOK|SVf_NOK|SVf_POK|SVf_ROK| \
354                          SVp_IOK|SVp_NOK|SVp_POK|SVpgv_GP)
355
356 #define PRIVSHIFT 4     /* (SVp_?OK >> PRIVSHIFT) == SVf_?OK */
357
358 #define SVf_AMAGIC      0x10000000  /* has magical overloaded methods */
359
360 /* Ensure this value does not clash with the GV_ADD* flags in gv.h: */
361 #define SVf_UTF8        0x20000000  /* SvPV is UTF-8 encoded
362                                        This is also set on RVs whose overloaded
363                                        stringification is UTF-8. This might
364                                        only happen as a side effect of SvPV() */
365                                            
366
367 /* Some private flags. */
368
369 /* PVAV could probably use 0x2000000 without conflict. I assume that PVFM can
370    be UTF-8 encoded, and PVCVs could well have UTF-8 prototypes. PVIOs haven't
371    been restructured, so sometimes get used as string buffers.  */
372
373 /* PVHV */
374 #define SVphv_SHAREKEYS 0x20000000  /* PVHV keys live on shared string table */
375
376 /* PVNV, PVMG only, and only used in pads. Should be safe to test on any scalar
377    SV, as the core is careful to avoid setting both.
378
379    SVf_POK, SVp_POK also set:
380    0x00004400   Normal
381    0x0000C400   Studied (SvSCREAM)
382    0x40004400   FBM compiled (SvVALID)
383    0x4000C400   pad name.
384
385    0x00008000   GV with GP
386    0x00008800   RV with PCS imported
387 */
388 #define SVpad_NAME      (SVp_SCREAM|SVpbm_VALID)
389                                     /* This SV is a name in the PAD, so
390                                        SVpad_TYPED, SVpad_OUR and SVpad_STATE
391                                        apply */
392 /* PVAV */
393 #define SVpav_REAL      0x40000000  /* free old entries */
394 /* PVHV */
395 #define SVphv_LAZYDEL   0x40000000  /* entry in xhv_eiter must be deleted */
396 /* This is only set true on a PVGV when it's playing "PVBM", but is tested for
397    on any regular scalar (anything <= PVLV) */
398 #define SVpbm_VALID     0x40000000
399 /* Only used in toke.c on an SV stored in PL_lex_repl */
400 #define SVrepl_EVAL     0x40000000  /* Replacement part of s///e */
401
402 /* IV, PVIV, PVNV, PVMG, PVGV and (I assume) PVLV  */
403 #define SVf_IVisUV      0x80000000  /* use XPVUV instead of XPVIV */
404 /* PVAV */
405 #define SVpav_REIFY     0x80000000  /* can become real */
406 /* PVHV */
407 #define SVphv_HASKFLAGS 0x80000000  /* keys have flag byte after hash */
408 /* PVGV when SVpbm_VALID is true */
409 #define SVpbm_TAIL      0x80000000
410 /* RV upwards. However, SVf_ROK and SVp_IOK are exclusive  */
411 #define SVprv_WEAKREF   0x80000000  /* Weak reference */
412
413 #define _XPV_HEAD                                                       \
414     HV*         xmg_stash;      /* class package */                     \
415     union _xmgu xmg_u;                                                  \
416     STRLEN      xpv_cur;        /* length of svu_pv as a C string */    \
417     STRLEN      xpv_len         /* allocated size */
418
419 union _xnvu {
420     NV      xnv_nv;             /* numeric value, if any */
421     HV *    xgv_stash;
422     struct {
423         U32 xlow;
424         U32 xhigh;
425     }       xpad_cop_seq;       /* used by pad.c for cop_sequence */
426     struct {
427         I32 xbm_useful;
428         U8  xbm_rare;           /* rarest character in string */
429     }       xbm_s;              /* fields from PVBM */
430 };
431
432 union _xivu {
433     IV      xivu_iv;            /* integer value */
434     UV      xivu_uv;
435     HEK *   xivu_namehek;       /* xpvlv, xpvgv: GvNAME */
436 };
437
438 union _xmgu {
439     MAGIC*  xmg_magic;          /* linked list of magicalness */
440     HV*     xmg_ourstash;       /* Stash for our (when SvPAD_OUR is true) */
441 };
442
443 struct xpv {
444     _XPV_HEAD;
445 };
446
447 struct xpviv {
448     _XPV_HEAD;
449     union _xivu xiv_u;
450 };
451
452 #define xiv_iv xiv_u.xivu_iv
453
454 struct xpvuv {
455     _XPV_HEAD;
456     union _xivu xuv_u;
457 };
458
459 #define xuv_uv xuv_u.xivu_uv
460
461 struct xpvnv {
462     _XPV_HEAD;
463     union _xivu xiv_u;
464     union _xnvu xnv_u;
465 };
466
467 /* This structure must match the beginning of struct xpvhv in hv.h. */
468 struct xpvmg {
469     _XPV_HEAD;
470     union _xivu xiv_u;
471     union _xnvu xnv_u;
472 };
473
474 struct xpvlv {
475     _XPV_HEAD;
476     union _xivu xiv_u;
477     union _xnvu xnv_u;
478     STRLEN      xlv_targoff;
479     STRLEN      xlv_targlen;
480     SV*         xlv_targ;
481     char        xlv_type;       /* k=keys .=pos x=substr v=vec /=join/re
482                                  * y=alem/helem/iter t=tie T=tied HE */
483 };
484
485 /* This structure works in 3 ways - regular scalar, GV with GP, or fast
486    Boyer-Moore.  */
487 struct xpvgv {
488     _XPV_HEAD;
489     union _xivu xiv_u;
490     union _xnvu xnv_u;
491 };
492
493 /* This structure must match XPVCV in cv.h */
494
495 typedef U16 cv_flags_t;
496
497 #define _XPVCV_COMMON                                                           \
498     HV *        xcv_stash;                                                      \
499     union {                                                                     \
500         OP *    xcv_start;                                                      \
501         ANY     xcv_xsubany;                                                    \
502     }           xcv_start_u;                                                    \
503     union {                                                                     \
504         OP *    xcv_root;                                                       \
505         void    (*xcv_xsub) (pTHX_ CV*);                                        \
506     }           xcv_root_u;                                                     \
507     GV *        xcv_gv;                                                         \
508     char *      xcv_file;                                                       \
509     AV *        xcv_padlist;                                                    \
510     CV *        xcv_outside;                                                    \
511     U32         xcv_outside_seq; /* the COP sequence (at the point of our       \
512                                   * compilation) in the lexically enclosing     \
513                                   * sub */                                      \
514     cv_flags_t  xcv_flags
515
516 struct xpvfm {
517     _XPV_HEAD;
518     _XPVCV_COMMON;
519     IV          xfm_lines;
520 };
521
522
523 struct xpvio {
524     _XPV_HEAD;
525     union _xivu xiv_u;
526     /* ifp and ofp are normally the same, but sockets need separate streams */
527     PerlIO *    xio_ofp;
528     /* Cray addresses everything by word boundaries (64 bits) and
529      * code and data pointers cannot be mixed (which is exactly what
530      * Perl_filter_add() tries to do with the dirp), hence the
531      *  following union trick (as suggested by Gurusamy Sarathy).
532      * For further information see Geir Johansen's problem report
533      * titled [ID 20000612.002] Perl problem on Cray system
534      * The any pointer (known as IoANY()) will also be a good place
535      * to hang any IO disciplines to.
536      */
537     union {
538         DIR *   xiou_dirp;      /* for opendir, readdir, etc */
539         void *  xiou_any;       /* for alignment */
540     } xio_dirpu;
541     /* IV xio_lines is now in IVX  $. */
542     IV          xio_page;       /* $% */
543     IV          xio_page_len;   /* $= */
544     IV          xio_lines_left; /* $- */
545     char *      xio_top_name;   /* $^ */
546     GV *        xio_top_gv;     /* $^ */
547     char *      xio_fmt_name;   /* $~ */
548     GV *        xio_fmt_gv;     /* $~ */
549     char *      xio_bottom_name;/* $^B */
550     GV *        xio_bottom_gv;  /* $^B */
551     char        xio_type;
552     U8          xio_flags;
553 };
554
555 #define xio_dirp        xio_dirpu.xiou_dirp
556 #define xio_any         xio_dirpu.xiou_any
557
558 #define IOf_ARGV        1       /* this fp iterates over ARGV */
559 #define IOf_START       2       /* check for null ARGV and substitute '-' */
560 #define IOf_FLUSH       4       /* this fp wants a flush after write op */
561 #define IOf_DIDTOP      8       /* just did top of form */
562 #define IOf_UNTAINT     16      /* consider this fp (and its data) "safe" */
563 #define IOf_NOLINE      32      /* slurped a pseudo-line from empty file */
564 #define IOf_FAKE_DIRP   64      /* xio_dirp is fake (source filters kludge)
565                                    Also, when this is set, SvPVX() is valid */
566
567 /* The following macros define implementation-independent predicates on SVs. */
568
569 /*
570 =for apidoc Am|U32|SvNIOK|SV* sv
571 Returns a U32 value indicating whether the SV contains a number, integer or
572 double.
573
574 =for apidoc Am|U32|SvNIOKp|SV* sv
575 Returns a U32 value indicating whether the SV contains a number, integer or
576 double.  Checks the B<private> setting.  Use C<SvNIOK> instead.
577
578 =for apidoc Am|void|SvNIOK_off|SV* sv
579 Unsets the NV/IV status of an SV.
580
581 =for apidoc Am|U32|SvOK|SV* sv
582 Returns a U32 value indicating whether the value is defined. This is
583 only meaningful for scalars.
584
585 =for apidoc Am|U32|SvIOKp|SV* sv
586 Returns a U32 value indicating whether the SV contains an integer.  Checks
587 the B<private> setting.  Use C<SvIOK> instead.
588
589 =for apidoc Am|U32|SvNOKp|SV* sv
590 Returns a U32 value indicating whether the SV contains a double.  Checks the
591 B<private> setting.  Use C<SvNOK> instead.
592
593 =for apidoc Am|U32|SvPOKp|SV* sv
594 Returns a U32 value indicating whether the SV contains a character string.
595 Checks the B<private> setting.  Use C<SvPOK> instead.
596
597 =for apidoc Am|U32|SvIOK|SV* sv
598 Returns a U32 value indicating whether the SV contains an integer.
599
600 =for apidoc Am|void|SvIOK_on|SV* sv
601 Tells an SV that it is an integer.
602
603 =for apidoc Am|void|SvIOK_off|SV* sv
604 Unsets the IV status of an SV.
605
606 =for apidoc Am|void|SvIOK_only|SV* sv
607 Tells an SV that it is an integer and disables all other OK bits.
608
609 =for apidoc Am|void|SvIOK_only_UV|SV* sv
610 Tells and SV that it is an unsigned integer and disables all other OK bits.
611
612 =for apidoc Am|bool|SvIOK_UV|SV* sv
613 Returns a boolean indicating whether the SV contains an unsigned integer.
614
615 =for apidoc Am|bool|SvUOK|SV* sv
616 Returns a boolean indicating whether the SV contains an unsigned integer.
617
618 =for apidoc Am|bool|SvIOK_notUV|SV* sv
619 Returns a boolean indicating whether the SV contains a signed integer.
620
621 =for apidoc Am|U32|SvNOK|SV* sv
622 Returns a U32 value indicating whether the SV contains a double.
623
624 =for apidoc Am|void|SvNOK_on|SV* sv
625 Tells an SV that it is a double.
626
627 =for apidoc Am|void|SvNOK_off|SV* sv
628 Unsets the NV status of an SV.
629
630 =for apidoc Am|void|SvNOK_only|SV* sv
631 Tells an SV that it is a double and disables all other OK bits.
632
633 =for apidoc Am|U32|SvPOK|SV* sv
634 Returns a U32 value indicating whether the SV contains a character
635 string.
636
637 =for apidoc Am|void|SvPOK_on|SV* sv
638 Tells an SV that it is a string.
639
640 =for apidoc Am|void|SvPOK_off|SV* sv
641 Unsets the PV status of an SV.
642
643 =for apidoc Am|void|SvPOK_only|SV* sv
644 Tells an SV that it is a string and disables all other OK bits.
645 Will also turn off the UTF-8 status.
646
647 =for apidoc Am|bool|SvVOK|SV* sv
648 Returns a boolean indicating whether the SV contains a v-string.
649
650 =for apidoc Am|U32|SvOOK|SV* sv
651 Returns a U32 indicating whether the pointer to the string buffer is offset.
652 This hack is used internally to speed up removal of characters from the
653 beginning of a SvPV.  When SvOOK is true, then the start of the
654 allocated string buffer is actually C<SvOOK_offset()> bytes before SvPVX.
655 This offset used to be stored in SvIVX, but is now stored within the spare
656 part of the buffer.
657
658 =for apidoc Am|U32|SvROK|SV* sv
659 Tests if the SV is an RV.
660
661 =for apidoc Am|void|SvROK_on|SV* sv
662 Tells an SV that it is an RV.
663
664 =for apidoc Am|void|SvROK_off|SV* sv
665 Unsets the RV status of an SV.
666
667 =for apidoc Am|SV*|SvRV|SV* sv
668 Dereferences an RV to return the SV.
669
670 =for apidoc Am|IV|SvIVX|SV* sv
671 Returns the raw value in the SV's IV slot, without checks or conversions.
672 Only use when you are sure SvIOK is true. See also C<SvIV()>.
673
674 =for apidoc Am|UV|SvUVX|SV* sv
675 Returns the raw value in the SV's UV slot, without checks or conversions.
676 Only use when you are sure SvIOK is true. See also C<SvUV()>.
677
678 =for apidoc Am|NV|SvNVX|SV* sv
679 Returns the raw value in the SV's NV slot, without checks or conversions.
680 Only use when you are sure SvNOK is true. See also C<SvNV()>.
681
682 =for apidoc Am|char*|SvPVX|SV* sv
683 Returns a pointer to the physical string in the SV.  The SV must contain a
684 string.
685
686 =for apidoc Am|STRLEN|SvCUR|SV* sv
687 Returns the length of the string which is in the SV.  See C<SvLEN>.
688
689 =for apidoc Am|STRLEN|SvLEN|SV* sv
690 Returns the size of the string buffer in the SV, not including any part
691 attributable to C<SvOOK>.  See C<SvCUR>.
692
693 =for apidoc Am|char*|SvEND|SV* sv
694 Returns a pointer to the last character in the string which is in the SV.
695 See C<SvCUR>.  Access the character as *(SvEND(sv)).
696
697 =for apidoc Am|HV*|SvSTASH|SV* sv
698 Returns the stash of the SV.
699
700 =for apidoc Am|void|SvIV_set|SV* sv|IV val
701 Set the value of the IV pointer in sv to val.  It is possible to perform
702 the same function of this macro with an lvalue assignment to C<SvIVX>.
703 With future Perls, however, it will be more efficient to use 
704 C<SvIV_set> instead of the lvalue assignment to C<SvIVX>.
705
706 =for apidoc Am|void|SvNV_set|SV* sv|NV val
707 Set the value of the NV pointer in sv to val.  See C<SvIV_set>.
708
709 =for apidoc Am|void|SvPV_set|SV* sv|char* val
710 Set the value of the PV pointer in sv to val.  See C<SvIV_set>.
711
712 =for apidoc Am|void|SvUV_set|SV* sv|UV val
713 Set the value of the UV pointer in sv to val.  See C<SvIV_set>.
714
715 =for apidoc Am|void|SvRV_set|SV* sv|SV* val
716 Set the value of the RV pointer in sv to val.  See C<SvIV_set>.
717
718 =for apidoc Am|void|SvMAGIC_set|SV* sv|MAGIC* val
719 Set the value of the MAGIC pointer in sv to val.  See C<SvIV_set>.
720
721 =for apidoc Am|void|SvSTASH_set|SV* sv|HV* val
722 Set the value of the STASH pointer in sv to val.  See C<SvIV_set>.
723
724 =for apidoc Am|void|SvCUR_set|SV* sv|STRLEN len
725 Set the current length of the string which is in the SV.  See C<SvCUR>
726 and C<SvIV_set>.
727
728 =for apidoc Am|void|SvLEN_set|SV* sv|STRLEN len
729 Set the actual length of the string which is in the SV.  See C<SvIV_set>.
730
731 =cut
732 */
733
734 #define SvNIOK(sv)              (SvFLAGS(sv) & (SVf_IOK|SVf_NOK))
735 #define SvNIOKp(sv)             (SvFLAGS(sv) & (SVp_IOK|SVp_NOK))
736 #define SvNIOK_off(sv)          (SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK| \
737                                                   SVp_IOK|SVp_NOK|SVf_IVisUV))
738
739 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
740 #define assert_not_ROK(sv)      ({assert(!SvROK(sv) || !SvRV(sv));}),
741 #define assert_not_glob(sv)     ({assert(!isGV_with_GP(sv));}),
742 #else
743 #define assert_not_ROK(sv)      
744 #define assert_not_glob(sv)     
745 #endif
746
747 #define SvOK(sv)                ((SvTYPE(sv) == SVt_BIND)               \
748                                  ? (SvFLAGS(SvRV(sv)) & SVf_OK)         \
749                                  : (SvFLAGS(sv) & SVf_OK))
750 #define SvOK_off(sv)            (assert_not_ROK(sv) assert_not_glob(sv) \
751                                  SvFLAGS(sv) &= ~(SVf_OK|               \
752                                                   SVf_IVisUV|SVf_UTF8), \
753                                                         SvOOK_off(sv))
754 #define SvOK_off_exc_UV(sv)     (assert_not_ROK(sv)                     \
755                                  SvFLAGS(sv) &= ~(SVf_OK|               \
756                                                   SVf_UTF8),            \
757                                                         SvOOK_off(sv))
758
759 #define SvOKp(sv)               (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK))
760 #define SvIOKp(sv)              (SvFLAGS(sv) & SVp_IOK)
761 #define SvIOKp_on(sv)           (assert_not_glob(sv) SvRELEASE_IVX_(sv) \
762                                     SvFLAGS(sv) |= SVp_IOK)
763 #define SvNOKp(sv)              (SvFLAGS(sv) & SVp_NOK)
764 #define SvNOKp_on(sv)           (assert_not_glob(sv) SvFLAGS(sv) |= SVp_NOK)
765 #define SvPOKp(sv)              (SvFLAGS(sv) & SVp_POK)
766 #define SvPOKp_on(sv)           (assert_not_ROK(sv) assert_not_glob(sv) \
767                                  SvFLAGS(sv) |= SVp_POK)
768
769 #define SvIOK(sv)               (SvFLAGS(sv) & SVf_IOK)
770 #define SvIOK_on(sv)            (assert_not_glob(sv) SvRELEASE_IVX_(sv) \
771                                     SvFLAGS(sv) |= (SVf_IOK|SVp_IOK))
772 #define SvIOK_off(sv)           (SvFLAGS(sv) &= ~(SVf_IOK|SVp_IOK|SVf_IVisUV))
773 #define SvIOK_only(sv)          (SvOK_off(sv), \
774                                     SvFLAGS(sv) |= (SVf_IOK|SVp_IOK))
775 #define SvIOK_only_UV(sv)       (assert_not_glob(sv) SvOK_off_exc_UV(sv), \
776                                     SvFLAGS(sv) |= (SVf_IOK|SVp_IOK))
777
778 #define SvIOK_UV(sv)            ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV))   \
779                                  == (SVf_IOK|SVf_IVisUV))
780 #define SvUOK(sv)               SvIOK_UV(sv)
781 #define SvIOK_notUV(sv)         ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV))   \
782                                  == SVf_IOK)
783
784 #define SvIsUV(sv)              (SvFLAGS(sv) & SVf_IVisUV)
785 #define SvIsUV_on(sv)           (SvFLAGS(sv) |= SVf_IVisUV)
786 #define SvIsUV_off(sv)          (SvFLAGS(sv) &= ~SVf_IVisUV)
787
788 #define SvNOK(sv)               (SvFLAGS(sv) & SVf_NOK)
789 #define SvNOK_on(sv)            (assert_not_glob(sv) \
790                                  SvFLAGS(sv) |= (SVf_NOK|SVp_NOK))
791 #define SvNOK_off(sv)           (SvFLAGS(sv) &= ~(SVf_NOK|SVp_NOK))
792 #define SvNOK_only(sv)          (SvOK_off(sv), \
793                                     SvFLAGS(sv) |= (SVf_NOK|SVp_NOK))
794
795 /*
796 =for apidoc Am|U32|SvUTF8|SV* sv
797 Returns a U32 value indicating whether the SV contains UTF-8 encoded data.
798 Call this after SvPV() in case any call to string overloading updates the
799 internal flag.
800
801 =for apidoc Am|void|SvUTF8_on|SV *sv
802 Turn on the UTF-8 status of an SV (the data is not changed, just the flag).
803 Do not use frivolously.
804
805 =for apidoc Am|void|SvUTF8_off|SV *sv
806 Unsets the UTF-8 status of an SV.
807
808 =for apidoc Am|void|SvPOK_only_UTF8|SV* sv
809 Tells an SV that it is a string and disables all other OK bits,
810 and leaves the UTF-8 status as it was.
811
812 =cut
813  */
814
815 /* Ensure the return value of this macro does not clash with the GV_ADD* flags
816 in gv.h: */
817 #define SvUTF8(sv)              (SvFLAGS(sv) & SVf_UTF8)
818 #define SvUTF8_on(sv)           (SvFLAGS(sv) |= (SVf_UTF8))
819 #define SvUTF8_off(sv)          (SvFLAGS(sv) &= ~(SVf_UTF8))
820
821 #define SvPOK(sv)               (SvFLAGS(sv) & SVf_POK)
822 #define SvPOK_on(sv)            (assert_not_ROK(sv) assert_not_glob(sv) \
823                                  SvFLAGS(sv) |= (SVf_POK|SVp_POK))
824 #define SvPOK_off(sv)           (SvFLAGS(sv) &= ~(SVf_POK|SVp_POK))
825 #define SvPOK_only(sv)          (assert_not_ROK(sv) assert_not_glob(sv) \
826                                  SvFLAGS(sv) &= ~(SVf_OK|               \
827                                                   SVf_IVisUV|SVf_UTF8), \
828                                     SvFLAGS(sv) |= (SVf_POK|SVp_POK))
829 #define SvPOK_only_UTF8(sv)     (assert_not_ROK(sv) assert_not_glob(sv) \
830                                  SvFLAGS(sv) &= ~(SVf_OK|               \
831                                                   SVf_IVisUV),          \
832                                     SvFLAGS(sv) |= (SVf_POK|SVp_POK))
833
834 #define SvVOK(sv)               (SvMAGICAL(sv)                          \
835                                  && mg_find(sv,PERL_MAGIC_vstring))
836 /* returns the vstring magic, if any */
837 #define SvVSTRING_mg(sv)        (SvMAGICAL(sv) \
838                                  ? mg_find(sv,PERL_MAGIC_vstring) : NULL)
839
840 #define SvOOK(sv)               (SvFLAGS(sv) & SVf_OOK)
841 #define SvOOK_on(sv)            ((void)SvIOK_off(sv), SvFLAGS(sv) |= SVf_OOK)
842 #define SvOOK_off(sv)           ((void)(SvOOK(sv) && sv_backoff(sv)))
843
844 #define SvFAKE(sv)              (SvFLAGS(sv) & SVf_FAKE)
845 #define SvFAKE_on(sv)           (SvFLAGS(sv) |= SVf_FAKE)
846 #define SvFAKE_off(sv)          (SvFLAGS(sv) &= ~SVf_FAKE)
847
848 #define SvROK(sv)               (SvFLAGS(sv) & SVf_ROK)
849 #define SvROK_on(sv)            (SvFLAGS(sv) |= SVf_ROK)
850 #define SvROK_off(sv)           (SvFLAGS(sv) &= ~(SVf_ROK))
851
852 #define SvMAGICAL(sv)           (SvFLAGS(sv) & (SVs_GMG|SVs_SMG|SVs_RMG))
853 #define SvMAGICAL_on(sv)        (SvFLAGS(sv) |= (SVs_GMG|SVs_SMG|SVs_RMG))
854 #define SvMAGICAL_off(sv)       (SvFLAGS(sv) &= ~(SVs_GMG|SVs_SMG|SVs_RMG))
855
856 #define SvGMAGICAL(sv)          (SvFLAGS(sv) & SVs_GMG)
857 #define SvGMAGICAL_on(sv)       (SvFLAGS(sv) |= SVs_GMG)
858 #define SvGMAGICAL_off(sv)      (SvFLAGS(sv) &= ~SVs_GMG)
859
860 #define SvSMAGICAL(sv)          (SvFLAGS(sv) & SVs_SMG)
861 #define SvSMAGICAL_on(sv)       (SvFLAGS(sv) |= SVs_SMG)
862 #define SvSMAGICAL_off(sv)      (SvFLAGS(sv) &= ~SVs_SMG)
863
864 #define SvRMAGICAL(sv)          (SvFLAGS(sv) & SVs_RMG)
865 #define SvRMAGICAL_on(sv)       (SvFLAGS(sv) |= SVs_RMG)
866 #define SvRMAGICAL_off(sv)      (SvFLAGS(sv) &= ~SVs_RMG)
867
868 #define SvAMAGIC(sv)            (SvROK(sv) && (SvFLAGS(SvRV(sv)) & SVf_AMAGIC))
869 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
870 #  define SvAMAGIC_on(sv)       ({ SV * const kloink = sv;              \
871                                    assert(SvROK(kloink));               \
872                                    SvFLAGS(SvRV(kloink)) |= SVf_AMAGIC; \
873                                 })
874 #  define SvAMAGIC_off(sv)      ({ SV * const kloink = sv;              \
875                                    if(SvROK(kloink))                    \
876                                         SvFLAGS(SvRV(kloink)) &= ~SVf_AMAGIC;\
877                                 })
878 #else
879 #  define SvAMAGIC_on(sv)       (SvFLAGS(SvRV(sv)) |= SVf_AMAGIC)
880 #  define SvAMAGIC_off(sv) \
881         (SvROK(sv) && (SvFLAGS(SvRV(sv)) &= ~SVf_AMAGIC))
882 #endif
883
884 /*
885 =for apidoc Am|U32|SvGAMAGIC|SV* sv
886
887 Returns true if the SV has get magic or overloading. If either is true then
888 the scalar is active data, and has the potential to return a new value every
889 time it is accessed. Hence you must be careful to only read it once per user
890 logical operation and work with that returned value. If neither is true then
891 the scalar's value cannot change unless written to.
892
893 =cut
894 */
895
896 #define SvGAMAGIC(sv)           (SvGMAGICAL(sv) || SvAMAGIC(sv))
897
898 #define Gv_AMG(stash)           (PL_amagic_generation && Gv_AMupdate(stash, FALSE))
899
900 #define SvWEAKREF(sv)           ((SvFLAGS(sv) & (SVf_ROK|SVprv_WEAKREF)) \
901                                   == (SVf_ROK|SVprv_WEAKREF))
902 #define SvWEAKREF_on(sv)        (SvFLAGS(sv) |=  (SVf_ROK|SVprv_WEAKREF))
903 #define SvWEAKREF_off(sv)       (SvFLAGS(sv) &= ~(SVf_ROK|SVprv_WEAKREF))
904
905 #define SvPCS_IMPORTED(sv)      ((SvFLAGS(sv) & (SVf_ROK|SVprv_PCS_IMPORTED)) \
906                                  == (SVf_ROK|SVprv_PCS_IMPORTED))
907 #define SvPCS_IMPORTED_on(sv)   (SvFLAGS(sv) |=  (SVf_ROK|SVprv_PCS_IMPORTED))
908 #define SvPCS_IMPORTED_off(sv)  (SvFLAGS(sv) &= ~(SVf_ROK|SVprv_PCS_IMPORTED))
909
910 #define SvTHINKFIRST(sv)        (SvFLAGS(sv) & SVf_THINKFIRST)
911
912 #define SvPADSTALE(sv)          (SvFLAGS(sv) & SVs_PADSTALE)
913 #define SvPADSTALE_off(sv)      (SvFLAGS(sv) &= ~SVs_PADSTALE)
914
915 #define SvPADTMP(sv)            (SvFLAGS(sv) & SVs_PADTMP)
916 #define SvPADTMP_off(sv)        (SvFLAGS(sv) &= ~SVs_PADTMP)
917
918 #define SvPADMY(sv)             (SvFLAGS(sv) & SVs_PADMY)
919
920 #if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
921 #  define SvPADTMP_on(sv)       ({                                      \
922             SV *const _svpad = MUTABLE_SV(sv);                          \
923             assert(!(SvFLAGS(_svpad) & (SVs_PADMY|SVs_PADSTALE)));      \
924             (SvFLAGS(_svpad) |= SVs_PADTMP);            \
925         })
926 #  define SvPADMY_on(sv)        ({                                      \
927             SV *const _svpad = MUTABLE_SV(sv);                          \
928             assert(!(SvFLAGS(_svpad) & SVs_PADTMP));    \
929             (SvFLAGS(_svpad) |= SVs_PADMY);             \
930         })
931 #  define SvPADSTALE_on(sv)     ({                                      \
932             SV *const _svpad = MUTABLE_SV(sv);                          \
933             assert(!(SvFLAGS(_svpad) & SVs_PADTMP));    \
934             (SvFLAGS(_svpad) |= SVs_PADSTALE);          \
935         })
936 #else
937 #  define SvPADTMP_on(sv)       (SvFLAGS(sv) |= SVs_PADTMP)
938 #  define SvPADMY_on(sv)        (SvFLAGS(sv) |= SVs_PADMY)
939 #  define SvPADSTALE_on(sv)     (SvFLAGS(sv) |= SVs_PADSTALE)
940 #endif
941
942 #define SvTEMP(sv)              (SvFLAGS(sv) & SVs_TEMP)
943 #define SvTEMP_on(sv)           (SvFLAGS(sv) |= SVs_TEMP)
944 #define SvTEMP_off(sv)          (SvFLAGS(sv) &= ~SVs_TEMP)
945
946 #define SvOBJECT(sv)            (SvFLAGS(sv) & SVs_OBJECT)
947 #define SvOBJECT_on(sv)         (SvFLAGS(sv) |= SVs_OBJECT)
948 #define SvOBJECT_off(sv)        (SvFLAGS(sv) &= ~SVs_OBJECT)
949
950 #define SvREADONLY(sv)          (SvFLAGS(sv) & SVf_READONLY)
951 #define SvREADONLY_on(sv)       (SvFLAGS(sv) |= SVf_READONLY)
952 #define SvREADONLY_off(sv)      (SvFLAGS(sv) &= ~SVf_READONLY)
953
954 #define SvSCREAM(sv) ((SvFLAGS(sv) & (SVp_SCREAM|SVp_POK)) == (SVp_SCREAM|SVp_POK))
955 #define SvSCREAM_on(sv)         (SvFLAGS(sv) |= SVp_SCREAM)
956 #define SvSCREAM_off(sv)        (SvFLAGS(sv) &= ~SVp_SCREAM)
957
958 #ifndef PERL_CORE
959 #  define SvCOMPILED(sv)        0
960 #  define SvCOMPILED_on(sv)
961 #  define SvCOMPILED_off(sv)
962 #endif
963
964 #define SvEVALED(sv)            (SvFLAGS(sv) & SVrepl_EVAL)
965 #define SvEVALED_on(sv)         (SvFLAGS(sv) |= SVrepl_EVAL)
966 #define SvEVALED_off(sv)        (SvFLAGS(sv) &= ~SVrepl_EVAL)
967
968 #if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
969 #  define SvVALID(sv)           ({ const SV *const _svvalid = (const SV*)(sv); \
970                                    if (SvFLAGS(_svvalid) & SVpbm_VALID) \
971                                        assert(!isGV_with_GP(_svvalid)); \
972                                    (SvFLAGS(_svvalid) & SVpbm_VALID);   \
973                                 })
974 #  define SvVALID_on(sv)        ({ SV *const _svvalid = MUTABLE_SV(sv); \
975                                    assert(!isGV_with_GP(_svvalid));     \
976                                    (SvFLAGS(_svvalid) |= SVpbm_VALID);  \
977                                 })
978 #  define SvVALID_off(sv)       ({ SV *const _svvalid = MUTABLE_SV(sv); \
979                                    assert(!isGV_with_GP(_svvalid));     \
980                                    (SvFLAGS(_svvalid) &= ~SVpbm_VALID); \
981                                 })
982
983 #  define SvTAIL(sv)    ({ const SV *const _svtail = (const SV *)(sv);  \
984                             assert(SvTYPE(_svtail) != SVt_PVAV);                \
985                             assert(SvTYPE(_svtail) != SVt_PVHV);                \
986                             (SvFLAGS(sv) & (SVpbm_TAIL|SVpbm_VALID))    \
987                                 == (SVpbm_TAIL|SVpbm_VALID);            \
988                         })
989 #else
990 #  define SvVALID(sv)           (SvFLAGS(sv) & SVpbm_VALID)
991 #  define SvVALID_on(sv)        (SvFLAGS(sv) |= SVpbm_VALID)
992 #  define SvVALID_off(sv)       (SvFLAGS(sv) &= ~SVpbm_VALID)
993 #  define SvTAIL(sv)        ((SvFLAGS(sv) & (SVpbm_TAIL|SVpbm_VALID))   \
994                              == (SVpbm_TAIL|SVpbm_VALID))
995
996 #endif
997 #define SvTAIL_on(sv)           (SvFLAGS(sv) |= SVpbm_TAIL)
998 #define SvTAIL_off(sv)          (SvFLAGS(sv) &= ~SVpbm_TAIL)
999
1000
1001 #define SvPAD_TYPED(sv) \
1002         ((SvFLAGS(sv) & (SVpad_NAME|SVpad_TYPED)) == (SVpad_NAME|SVpad_TYPED))
1003
1004 #define SvPAD_OUR(sv)   \
1005         ((SvFLAGS(sv) & (SVpad_NAME|SVpad_OUR)) == (SVpad_NAME|SVpad_OUR))
1006
1007 #define SvPAD_STATE(sv) \
1008         ((SvFLAGS(sv) & (SVpad_NAME|SVpad_STATE)) == (SVpad_NAME|SVpad_STATE))
1009
1010 #if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
1011 #  define SvPAD_TYPED_on(sv)    ({                                      \
1012             SV *const _svpad = MUTABLE_SV(sv);                          \
1013             assert(SvTYPE(_svpad) == SVt_PVMG);                         \
1014             (SvFLAGS(_svpad) |= SVpad_NAME|SVpad_TYPED);                \
1015         })
1016 #define SvPAD_OUR_on(sv)        ({                                      \
1017             SV *const _svpad = MUTABLE_SV(sv);                          \
1018             assert(SvTYPE(_svpad) == SVt_PVMG);                         \
1019             (SvFLAGS(_svpad) |= SVpad_NAME|SVpad_OUR);                  \
1020         })
1021 #define SvPAD_STATE_on(sv)      ({                                      \
1022             SV *const _svpad = MUTABLE_SV(sv);                          \
1023             assert(SvTYPE(_svpad) == SVt_PVNV || SvTYPE(_svpad) == SVt_PVMG); \
1024             (SvFLAGS(_svpad) |= SVpad_NAME|SVpad_STATE);                \
1025         })
1026 #else
1027 #  define SvPAD_TYPED_on(sv)    (SvFLAGS(sv) |= SVpad_NAME|SVpad_TYPED)
1028 #  define SvPAD_OUR_on(sv)      (SvFLAGS(sv) |= SVpad_NAME|SVpad_OUR)
1029 #  define SvPAD_STATE_on(sv)    (SvFLAGS(sv) |= SVpad_NAME|SVpad_STATE)
1030 #endif
1031
1032 #define SvOURSTASH(sv)  \
1033         (SvPAD_OUR(sv) ? ((XPVMG*) SvANY(sv))->xmg_u.xmg_ourstash : NULL)
1034 #define SvOURSTASH_set(sv, st)                                  \
1035         STMT_START {                                            \
1036             assert(SvTYPE(sv) == SVt_PVMG);                     \
1037             ((XPVMG*) SvANY(sv))->xmg_u.xmg_ourstash = st;      \
1038         } STMT_END
1039
1040 #define SvRVx(sv) SvRV(sv)
1041
1042 #ifdef PERL_DEBUG_COW
1043 /* Need -0.0 for SvNVX to preserve IEEE FP "negative zero" because
1044    +0.0 + -0.0 => +0.0 but -0.0 + -0.0 => -0.0 */
1045 #  define SvIVX(sv) (0 + ((XPVIV*) SvANY(sv))->xiv_iv)
1046 #  define SvUVX(sv) (0 + ((XPVUV*) SvANY(sv))->xuv_uv)
1047 #  define SvNVX(sv) (-0.0 + ((XPVNV*) SvANY(sv))->xnv_u.xnv_nv)
1048 #  define SvRV(sv) (0 + (sv)->sv_u.svu_rv)
1049 #  define SvRV_const(sv) (0 + (sv)->sv_u.svu_rv)
1050 /* Don't test the core XS code yet.  */
1051 #  if defined (PERL_CORE) && PERL_DEBUG_COW > 1
1052 #    define SvPVX(sv) (0 + (assert(!SvREADONLY(sv)), (sv)->sv_u.svu_pv))
1053 #  else
1054 #  define SvPVX(sv) SvPVX_mutable(sv)
1055 #  endif
1056 #  define SvCUR(sv) (0 + ((XPV*) SvANY(sv))->xpv_cur)
1057 #  define SvLEN(sv) (0 + ((XPV*) SvANY(sv))->xpv_len)
1058 #  define SvEND(sv) ((sv)->sv_u.svu_pv + ((XPV*)SvANY(sv))->xpv_cur)
1059
1060 #  ifdef DEBUGGING
1061 #    define SvMAGIC(sv) (0 + *(assert(SvTYPE(sv) >= SVt_PVMG), &((XPVMG*)  SvANY(sv))->xmg_u.xmg_magic))
1062 #    define SvSTASH(sv) (0 + *(assert(SvTYPE(sv) >= SVt_PVMG), &((XPVMG*)  SvANY(sv))->xmg_stash))
1063 #  else
1064 #    define SvMAGIC(sv) (0 + ((XPVMG*)  SvANY(sv))->xmg_u.xmg_magic)
1065 #    define SvSTASH(sv) (0 + ((XPVMG*)  SvANY(sv))->xmg_stash)
1066 #  endif
1067 #else
1068 #  define SvLEN(sv) ((XPV*) SvANY(sv))->xpv_len
1069 #  define SvEND(sv) ((sv)->sv_u.svu_pv + ((XPV*)SvANY(sv))->xpv_cur)
1070
1071 #  if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
1072 /* These get expanded inside other macros that already use a variable _sv  */
1073 #    define SvPVX(sv)                                                   \
1074         (*({ SV *const _svpvx = MUTABLE_SV(sv);                         \
1075             assert(PL_valid_types_PVX[SvTYPE(_svpvx) & SVt_MASK]);      \
1076             assert(!isGV_with_GP(_svpvx));                              \
1077             assert(!(SvTYPE(_svpvx) == SVt_PVIO                         \
1078                      && !(IoFLAGS(_svpvx) & IOf_FAKE_DIRP)));           \
1079             &((_svpvx)->sv_u.svu_pv);                                   \
1080          }))
1081 #    define SvCUR(sv)                                                   \
1082         (*({ const SV *const _svcur = (const SV *)(sv);                 \
1083             assert(PL_valid_types_PVX[SvTYPE(_svcur) & SVt_MASK]);      \
1084             assert(!isGV_with_GP(_svcur));                              \
1085             assert(!(SvTYPE(_svcur) == SVt_PVIO                         \
1086                      && !(IoFLAGS(_svcur) & IOf_FAKE_DIRP)));           \
1087             &(((XPV*) MUTABLE_PTR(SvANY(_svcur)))->xpv_cur);            \
1088          }))
1089 #    define SvIVX(sv)                                                   \
1090         (*({ const SV *const _svivx = (const SV *)(sv);                 \
1091             assert(PL_valid_types_IVX[SvTYPE(_svivx) & SVt_MASK]);      \
1092             assert(!isGV_with_GP(_svivx));                              \
1093             &(((XPVIV*) MUTABLE_PTR(SvANY(_svivx)))->xiv_iv);           \
1094          }))
1095 #    define SvUVX(sv)                                                   \
1096         (*({ const SV *const _svuvx = (const SV *)(sv);                 \
1097             assert(PL_valid_types_IVX[SvTYPE(_svuvx) & SVt_MASK]);      \
1098             assert(!isGV_with_GP(_svuvx));                              \
1099             &(((XPVUV*) MUTABLE_PTR(SvANY(_svuvx)))->xuv_uv);           \
1100          }))
1101 #    define SvNVX(sv)                                                   \
1102         (*({ const SV *const _svnvx = (const SV *)(sv);                 \
1103             assert(PL_valid_types_NVX[SvTYPE(_svnvx) & SVt_MASK]);      \
1104             assert(!isGV_with_GP(_svnvx));                              \
1105             &(((XPVNV*) MUTABLE_PTR(SvANY(_svnvx)))->xnv_u.xnv_nv);     \
1106          }))
1107 #    define SvRV(sv)                                                    \
1108         (*({ SV *const _svrv = MUTABLE_SV(sv);                          \
1109             assert(PL_valid_types_RV[SvTYPE(_svrv) & SVt_MASK]);        \
1110             assert(!isGV_with_GP(_svrv));                               \
1111             assert(!(SvTYPE(_svrv) == SVt_PVIO                          \
1112                      && !(IoFLAGS(_svrv) & IOf_FAKE_DIRP)));            \
1113             &((_svrv)->sv_u.svu_rv);                                    \
1114          }))
1115 #    define SvRV_const(sv)                                              \
1116         ({ const SV *const _svrv = (const SV *)(sv);                    \
1117             assert(PL_valid_types_RV[SvTYPE(_svrv) & SVt_MASK]);        \
1118             assert(!isGV_with_GP(_svrv));                               \
1119             assert(!(SvTYPE(_svrv) == SVt_PVIO                          \
1120                      && !(IoFLAGS(_svrv) & IOf_FAKE_DIRP)));            \
1121             (_svrv)->sv_u.svu_rv;                                       \
1122          })
1123 #    define SvMAGIC(sv)                                                 \
1124         (*({ const SV *const _svmagic = (const SV *)(sv);               \
1125             assert(SvTYPE(_svmagic) >= SVt_PVMG);                       \
1126             if(SvTYPE(_svmagic) == SVt_PVMG)                            \
1127                 assert(!SvPAD_OUR(_svmagic));                           \
1128             &(((XPVMG*) MUTABLE_PTR(SvANY(_svmagic)))->xmg_u.xmg_magic); \
1129           }))
1130 #    define SvSTASH(sv)                                                 \
1131         (*({ const SV *const _svstash = (const SV *)(sv);               \
1132             assert(SvTYPE(_svstash) >= SVt_PVMG);                       \
1133             &(((XPVMG*) MUTABLE_PTR(SvANY(_svstash)))->xmg_stash);      \
1134           }))
1135 #  else
1136 #    define SvPVX(sv) ((sv)->sv_u.svu_pv)
1137 #    define SvCUR(sv) ((XPV*) SvANY(sv))->xpv_cur
1138 #    define SvIVX(sv) ((XPVIV*) SvANY(sv))->xiv_iv
1139 #    define SvUVX(sv) ((XPVUV*) SvANY(sv))->xuv_uv
1140 #    define SvNVX(sv) ((XPVNV*) SvANY(sv))->xnv_u.xnv_nv
1141 #    define SvRV(sv) ((sv)->sv_u.svu_rv)
1142 #    define SvRV_const(sv) (0 + (sv)->sv_u.svu_rv)
1143 #    define SvMAGIC(sv) ((XPVMG*)  SvANY(sv))->xmg_u.xmg_magic
1144 #    define SvSTASH(sv) ((XPVMG*)  SvANY(sv))->xmg_stash
1145 #  endif
1146 #endif
1147
1148 #ifndef PERL_POISON
1149 /* Given that these two are new, there can't be any existing code using them
1150  *  as LVALUEs  */
1151 #  define SvPVX_mutable(sv)     (0 + (sv)->sv_u.svu_pv)
1152 #  define SvPVX_const(sv)       ((const char*)(0 + (sv)->sv_u.svu_pv))
1153 #else
1154 /* Except for the poison code, which uses & to scribble over the pointer after
1155    free() is called.  */
1156 #  define SvPVX_mutable(sv)     ((sv)->sv_u.svu_pv)
1157 #  define SvPVX_const(sv)       ((const char*)((sv)->sv_u.svu_pv))
1158 #endif
1159
1160 #define SvIVXx(sv) SvIVX(sv)
1161 #define SvUVXx(sv) SvUVX(sv)
1162 #define SvNVXx(sv) SvNVX(sv)
1163 #define SvPVXx(sv) SvPVX(sv)
1164 #define SvLENx(sv) SvLEN(sv)
1165 #define SvENDx(sv) ((PL_Sv = (sv)), SvEND(PL_Sv))
1166
1167
1168 /* Ask a scalar nicely to try to become an IV, if possible.
1169    Not guaranteed to stay returning void */
1170 /* Macro won't actually call sv_2iv if already IOK */
1171 #define SvIV_please(sv) \
1172         STMT_START {if (!SvIOKp(sv) && (SvNOK(sv) || SvPOK(sv))) \
1173                 (void) SvIV(sv); } STMT_END
1174 #define SvIV_please_nomg(sv) \
1175         STMT_START {if (!SvIOKp(sv) && (SvNOK(sv) || SvPOK(sv))) \
1176                 (void) SvIV_nomg(sv); } STMT_END
1177 #define SvIV_set(sv, val) \
1178         STMT_START { \
1179                 assert(PL_valid_types_IV_set[SvTYPE(sv) & SVt_MASK]);   \
1180                 assert(!isGV_with_GP(sv));              \
1181                 (((XPVIV*)  SvANY(sv))->xiv_iv = (val)); } STMT_END
1182 #define SvNV_set(sv, val) \
1183         STMT_START { \
1184                 assert(PL_valid_types_NV_set[SvTYPE(sv) & SVt_MASK]);   \
1185                 assert(!isGV_with_GP(sv));              \
1186                 (((XPVNV*)SvANY(sv))->xnv_u.xnv_nv = (val)); } STMT_END
1187 #define SvPV_set(sv, val) \
1188         STMT_START { \
1189                 assert(PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]);      \
1190                 assert(!isGV_with_GP(sv));              \
1191                 assert(!(SvTYPE(sv) == SVt_PVIO         \
1192                      && !(IoFLAGS(sv) & IOf_FAKE_DIRP))); \
1193                 ((sv)->sv_u.svu_pv = (val)); } STMT_END
1194 #define SvUV_set(sv, val) \
1195         STMT_START { \
1196                 assert(PL_valid_types_IV_set[SvTYPE(sv) & SVt_MASK]);   \
1197                 assert(!isGV_with_GP(sv));              \
1198                 (((XPVUV*)SvANY(sv))->xuv_uv = (val)); } STMT_END
1199 #define SvRV_set(sv, val) \
1200         STMT_START { \
1201                 assert(PL_valid_types_RV[SvTYPE(sv) & SVt_MASK]);       \
1202                 assert(!isGV_with_GP(sv));              \
1203                 assert(!(SvTYPE(sv) == SVt_PVIO         \
1204                      && !(IoFLAGS(sv) & IOf_FAKE_DIRP))); \
1205                 ((sv)->sv_u.svu_rv = (val)); } STMT_END
1206 #define SvMAGIC_set(sv, val) \
1207         STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
1208                 (((XPVMG*)SvANY(sv))->xmg_u.xmg_magic = (val)); } STMT_END
1209 #define SvSTASH_set(sv, val) \
1210         STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
1211                 (((XPVMG*)  SvANY(sv))->xmg_stash = (val)); } STMT_END
1212 #define SvCUR_set(sv, val) \
1213         STMT_START { \
1214                 assert(PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]);      \
1215                 assert(!isGV_with_GP(sv));              \
1216                 assert(!(SvTYPE(sv) == SVt_PVIO         \
1217                      && !(IoFLAGS(sv) & IOf_FAKE_DIRP))); \
1218                 (((XPV*)  SvANY(sv))->xpv_cur = (val)); } STMT_END
1219 #define SvLEN_set(sv, val) \
1220         STMT_START { \
1221                 assert(PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]);      \
1222                 assert(!isGV_with_GP(sv));      \
1223                 assert(!(SvTYPE(sv) == SVt_PVIO         \
1224                      && !(IoFLAGS(sv) & IOf_FAKE_DIRP))); \
1225                 (((XPV*)  SvANY(sv))->xpv_len = (val)); } STMT_END
1226 #define SvEND_set(sv, val) \
1227         STMT_START { assert(SvTYPE(sv) >= SVt_PV); \
1228                 SvCUR_set(sv, (val) - SvPVX(sv)); } STMT_END
1229
1230 #define SvPV_renew(sv,n) \
1231         STMT_START { SvLEN_set(sv, n); \
1232                 SvPV_set((sv), (MEM_WRAP_CHECK_(n,char)                 \
1233                                 (char*)saferealloc((Malloc_t)SvPVX(sv), \
1234                                                    (MEM_SIZE)((n)))));  \
1235                  } STMT_END
1236
1237 #define SvPV_shrink_to_cur(sv) STMT_START { \
1238                    const STRLEN _lEnGtH = SvCUR(sv) + 1; \
1239                    SvPV_renew(sv, _lEnGtH); \
1240                  } STMT_END
1241
1242 #define SvPV_free(sv)                                                   \
1243     STMT_START {                                                        \
1244                      assert(SvTYPE(sv) >= SVt_PV);                      \
1245                      if (SvLEN(sv)) {                                   \
1246                          assert(!SvROK(sv));                            \
1247                          if(SvOOK(sv)) {                                \
1248                              STRLEN zok;                                \
1249                              SvOOK_offset(sv, zok);                     \
1250                              SvPV_set(sv, SvPVX_mutable(sv) - zok);     \
1251                              SvFLAGS(sv) &= ~SVf_OOK;                   \
1252                          }                                              \
1253                          Safefree(SvPVX(sv));                           \
1254                      }                                                  \
1255                  } STMT_END
1256
1257 #ifdef PERL_CORE
1258 /* Code that crops up in three places to take a scalar and ready it to hold
1259    a reference */
1260 #  define prepare_SV_for_RV(sv)                                         \
1261     STMT_START {                                                        \
1262                     if (SvTYPE(sv) < SVt_PV && SvTYPE(sv) != SVt_IV)    \
1263                         sv_upgrade(sv, SVt_IV);                         \
1264                     else if (SvTYPE(sv) >= SVt_PV) {                    \
1265                         SvPV_free(sv);                                  \
1266                         SvLEN_set(sv, 0);                               \
1267                         SvCUR_set(sv, 0);                               \
1268                     }                                                   \
1269                  } STMT_END
1270 #endif
1271
1272 /* SvPOKp not SvPOK in the assertion because the string can be tainted! eg
1273    perl -T -e '/$^X/'
1274 */
1275
1276 #ifndef PERL_CORE
1277 #  define BmFLAGS(sv)           (SvTAIL(sv) ? FBMcf_TAIL : 0)
1278 #endif
1279
1280 #if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
1281 #  define BmRARE(sv)                                                    \
1282         (*({ SV *const _bmrare = MUTABLE_SV(sv);                        \
1283                 assert(SvTYPE(_bmrare) == SVt_PVMG);                    \
1284                 assert(SvVALID(_bmrare));                               \
1285             &(((XPVMG*) SvANY(_bmrare))->xnv_u.xbm_s.xbm_rare);         \
1286          }))
1287 #  define BmUSEFUL(sv)                                                  \
1288         (*({ SV *const _bmuseful = MUTABLE_SV(sv);                      \
1289             assert(SvTYPE(_bmuseful) == SVt_PVMG);                      \
1290             assert(SvVALID(_bmuseful));                                 \
1291             assert(!SvIOK(_bmuseful));                                  \
1292             &(((XPVMG*) SvANY(_bmuseful))->xnv_u.xbm_s.xbm_useful);     \
1293          }))
1294 #  define BmPREVIOUS(sv)                                                \
1295     (*({ SV *const _bmprevious = MUTABLE_SV(sv);                        \
1296                 assert(SvTYPE(_bmprevious) == SVt_PVMG);                \
1297                 assert(SvVALID(_bmprevious));                           \
1298             &(((XPVMG*) SvANY(_bmprevious))->xiv_u.xivu_uv);            \
1299          }))
1300 #else
1301 #  define BmRARE(sv)            ((XPVMG*) SvANY(sv))->xnv_u.xbm_s.xbm_rare
1302 #  define BmUSEFUL(sv)          ((XPVMG*) SvANY(sv))->xnv_u.xbm_s.xbm_useful
1303 #  define BmPREVIOUS(sv)        ((XPVMG*) SvANY(sv))->xiv_u.xivu_uv
1304
1305 #endif
1306
1307 #define FmLINES(sv)     ((XPVFM*)  SvANY(sv))->xfm_lines
1308
1309 #define LvTYPE(sv)      ((XPVLV*)  SvANY(sv))->xlv_type
1310 #define LvTARG(sv)      ((XPVLV*)  SvANY(sv))->xlv_targ
1311 #define LvTARGOFF(sv)   ((XPVLV*)  SvANY(sv))->xlv_targoff
1312 #define LvTARGLEN(sv)   ((XPVLV*)  SvANY(sv))->xlv_targlen
1313
1314 #define IoIFP(sv)       (sv)->sv_u.svu_fp
1315 #define IoOFP(sv)       ((XPVIO*)  SvANY(sv))->xio_ofp
1316 #define IoDIRP(sv)      ((XPVIO*)  SvANY(sv))->xio_dirp
1317 #define IoANY(sv)       ((XPVIO*)  SvANY(sv))->xio_any
1318 #define IoLINES(sv)     ((XPVIO*)  SvANY(sv))->xiv_u.xivu_iv
1319 #define IoPAGE(sv)      ((XPVIO*)  SvANY(sv))->xio_page
1320 #define IoPAGE_LEN(sv)  ((XPVIO*)  SvANY(sv))->xio_page_len
1321 #define IoLINES_LEFT(sv)((XPVIO*)  SvANY(sv))->xio_lines_left
1322 #define IoTOP_NAME(sv)  ((XPVIO*)  SvANY(sv))->xio_top_name
1323 #define IoTOP_GV(sv)    ((XPVIO*)  SvANY(sv))->xio_top_gv
1324 #define IoFMT_NAME(sv)  ((XPVIO*)  SvANY(sv))->xio_fmt_name
1325 #define IoFMT_GV(sv)    ((XPVIO*)  SvANY(sv))->xio_fmt_gv
1326 #define IoBOTTOM_NAME(sv)((XPVIO*) SvANY(sv))->xio_bottom_name
1327 #define IoBOTTOM_GV(sv) ((XPVIO*)  SvANY(sv))->xio_bottom_gv
1328 #define IoTYPE(sv)      ((XPVIO*)  SvANY(sv))->xio_type
1329 #define IoFLAGS(sv)     ((XPVIO*)  SvANY(sv))->xio_flags
1330
1331 /* IoTYPE(sv) is a single character telling the type of I/O connection. */
1332 #define IoTYPE_RDONLY           '<'
1333 #define IoTYPE_WRONLY           '>'
1334 #define IoTYPE_RDWR             '+'
1335 #define IoTYPE_APPEND           'a'
1336 #define IoTYPE_PIPE             '|'
1337 #define IoTYPE_STD              '-'     /* stdin or stdout */
1338 #define IoTYPE_SOCKET           's'
1339 #define IoTYPE_CLOSED           ' '
1340 #define IoTYPE_IMPLICIT         'I'     /* stdin or stdout or stderr */
1341 #define IoTYPE_NUMERIC          '#'     /* fdopen */
1342
1343 /*
1344 =for apidoc Am|bool|SvTAINTED|SV* sv
1345 Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if
1346 not.
1347
1348 =for apidoc Am|void|SvTAINTED_on|SV* sv
1349 Marks an SV as tainted if tainting is enabled.
1350
1351 =for apidoc Am|void|SvTAINTED_off|SV* sv
1352 Untaints an SV. Be I<very> careful with this routine, as it short-circuits
1353 some of Perl's fundamental security features. XS module authors should not
1354 use this function unless they fully understand all the implications of
1355 unconditionally untainting the value. Untainting should be done in the
1356 standard perl fashion, via a carefully crafted regexp, rather than directly
1357 untainting variables.
1358
1359 =for apidoc Am|void|SvTAINT|SV* sv
1360 Taints an SV if tainting is enabled.
1361
1362 =cut
1363 */
1364
1365 #define sv_taint(sv)      sv_magic((sv), NULL, PERL_MAGIC_taint, NULL, 0)
1366
1367 #define SvTAINTED(sv)     (SvMAGICAL(sv) && sv_tainted(sv))
1368 #define SvTAINTED_on(sv)  STMT_START{ if(PL_tainting){sv_taint(sv);}   }STMT_END
1369 #define SvTAINTED_off(sv) STMT_START{ if(PL_tainting){sv_untaint(sv);} }STMT_END
1370
1371 #define SvTAINT(sv)                     \
1372     STMT_START {                        \
1373         if (PL_tainting) {              \
1374             if (PL_tainted)             \
1375                 SvTAINTED_on(sv);       \
1376         }                               \
1377     } STMT_END
1378
1379 /*
1380 =for apidoc Am|char*|SvPV_force|SV* sv|STRLEN len
1381 Like C<SvPV> but will force the SV into containing just a string
1382 (C<SvPOK_only>).  You want force if you are going to update the C<SvPVX>
1383 directly.
1384
1385 =for apidoc Am|char*|SvPV_force_nomg|SV* sv|STRLEN len
1386 Like C<SvPV> but will force the SV into containing just a string
1387 (C<SvPOK_only>).  You want force if you are going to update the C<SvPVX>
1388 directly. Doesn't process magic.
1389
1390 =for apidoc Am|char*|SvPV|SV* sv|STRLEN len
1391 Returns a pointer to the string in the SV, or a stringified form of
1392 the SV if the SV does not contain a string.  The SV may cache the
1393 stringified version becoming C<SvPOK>.  Handles 'get' magic. See also
1394 C<SvPVx> for a version which guarantees to evaluate sv only once.
1395
1396 =for apidoc Am|char*|SvPVx|SV* sv|STRLEN len
1397 A version of C<SvPV> which guarantees to evaluate C<sv> only once.
1398 Only use this if C<sv> is an expression with side effects, otherwise use the
1399 more efficient C<SvPVX>.
1400
1401 =for apidoc Am|char*|SvPV_nomg|SV* sv|STRLEN len
1402 Like C<SvPV> but doesn't process magic.
1403
1404 =for apidoc Am|char*|SvPV_nolen|SV* sv
1405 Returns a pointer to the string in the SV, or a stringified form of
1406 the SV if the SV does not contain a string.  The SV may cache the
1407 stringified form becoming C<SvPOK>.  Handles 'get' magic.
1408
1409 =for apidoc Am|char*|SvPV_nomg_nolen|SV* sv
1410 Like C<SvPV_nolen> but doesn't process magic.
1411
1412 =for apidoc Am|IV|SvIV|SV* sv
1413 Coerces the given SV to an integer and returns it. See C<SvIVx> for a
1414 version which guarantees to evaluate sv only once.
1415
1416 =for apidoc Am|IV|SvIV_nomg|SV* sv
1417 Like C<SvIV> but doesn't process magic.
1418
1419 =for apidoc Am|IV|SvIVx|SV* sv
1420 Coerces the given SV to an integer and returns it. Guarantees to evaluate
1421 C<sv> only once. Only use this if C<sv> is an expression with side effects,
1422 otherwise use the more efficient C<SvIV>.
1423
1424 =for apidoc Am|NV|SvNV|SV* sv
1425 Coerce the given SV to a double and return it. See C<SvNVx> for a version
1426 which guarantees to evaluate sv only once.
1427
1428 =for apidoc Am|NV|SvNV_nomg|SV* sv
1429 Like C<SvNV> but doesn't process magic.
1430
1431 =for apidoc Am|NV|SvNVx|SV* sv
1432 Coerces the given SV to a double and returns it. Guarantees to evaluate
1433 C<sv> only once. Only use this if C<sv> is an expression with side effects,
1434 otherwise use the more efficient C<SvNV>.
1435
1436 =for apidoc Am|UV|SvUV|SV* sv
1437 Coerces the given SV to an unsigned integer and returns it.  See C<SvUVx>
1438 for a version which guarantees to evaluate sv only once.
1439
1440 =for apidoc Am|UV|SvUV_nomg|SV* sv
1441 Like C<SvUV> but doesn't process magic.
1442
1443 =for apidoc Am|UV|SvUVx|SV* sv
1444 Coerces the given SV to an unsigned integer and returns it. Guarantees to
1445 C<sv> only once. Only use this if C<sv> is an expression with side effects,
1446 otherwise use the more efficient C<SvUV>.
1447
1448 =for apidoc Am|bool|SvTRUE|SV* sv
1449 Returns a boolean indicating whether Perl would evaluate the SV as true or
1450 false.  See SvOK() for a defined/undefined test.  Handles 'get' magic
1451 unless the scalar is already SvPOK, SvIOK or SvNOK (the public, not the
1452 private flags).
1453
1454 =for apidoc Am|bool|SvTRUE_nomg|SV* sv
1455 Returns a boolean indicating whether Perl would evaluate the SV as true or
1456 false.  See SvOK() for a defined/undefined test.  Does not handle 'get' magic.
1457
1458 =for apidoc Am|char*|SvPVutf8_force|SV* sv|STRLEN len
1459 Like C<SvPV_force>, but converts sv to utf8 first if necessary.
1460
1461 =for apidoc Am|char*|SvPVutf8|SV* sv|STRLEN len
1462 Like C<SvPV>, but converts sv to utf8 first if necessary.
1463
1464 =for apidoc Am|char*|SvPVutf8_nolen|SV* sv
1465 Like C<SvPV_nolen>, but converts sv to utf8 first if necessary.
1466
1467 =for apidoc Am|char*|SvPVbyte_force|SV* sv|STRLEN len
1468 Like C<SvPV_force>, but converts sv to byte representation first if necessary.
1469
1470 =for apidoc Am|char*|SvPVbyte|SV* sv|STRLEN len
1471 Like C<SvPV>, but converts sv to byte representation first if necessary.
1472
1473 =for apidoc Am|char*|SvPVbyte_nolen|SV* sv
1474 Like C<SvPV_nolen>, but converts sv to byte representation first if necessary.
1475
1476 =for apidoc Am|char*|SvPVutf8x_force|SV* sv|STRLEN len
1477 Like C<SvPV_force>, but converts sv to utf8 first if necessary.
1478 Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8_force>
1479 otherwise.
1480
1481 =for apidoc Am|char*|SvPVutf8x|SV* sv|STRLEN len
1482 Like C<SvPV>, but converts sv to utf8 first if necessary.
1483 Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8>
1484 otherwise.
1485
1486 =for apidoc Am|char*|SvPVbytex_force|SV* sv|STRLEN len
1487 Like C<SvPV_force>, but converts sv to byte representation first if necessary.
1488 Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte_force>
1489 otherwise.
1490
1491 =for apidoc Am|char*|SvPVbytex|SV* sv|STRLEN len
1492 Like C<SvPV>, but converts sv to byte representation first if necessary.
1493 Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte>
1494 otherwise.
1495
1496 =for apidoc Am|bool|SvIsCOW|SV* sv
1497 Returns a boolean indicating whether the SV is Copy-On-Write. (either shared
1498 hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for
1499 COW)
1500
1501 =for apidoc Am|bool|SvIsCOW_shared_hash|SV* sv
1502 Returns a boolean indicating whether the SV is Copy-On-Write shared hash key
1503 scalar.
1504
1505 =for apidoc Am|void|sv_catpvn_nomg|SV* sv|const char* ptr|STRLEN len
1506 Like C<sv_catpvn> but doesn't process magic.
1507
1508 =for apidoc Am|void|sv_catpv_nomg|SV* sv|const char* ptr
1509 Like C<sv_catpv> but doesn't process magic.
1510
1511 =for apidoc Am|void|sv_setsv_nomg|SV* dsv|SV* ssv
1512 Like C<sv_setsv> but doesn't process magic.
1513
1514 =for apidoc Am|void|sv_catsv_nomg|SV* dsv|SV* ssv
1515 Like C<sv_catsv> but doesn't process magic.
1516
1517 =for apidoc Amdb|STRLEN|sv_utf8_upgrade_nomg|NN SV *sv
1518
1519 Like sv_utf8_upgrade, but doesn't do magic on C<sv>
1520
1521 =cut
1522 */
1523
1524 /* Let us hope that bitmaps for UV and IV are the same */
1525 #define SvIV(sv) (SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv))
1526 #define SvUV(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv))
1527 #define SvNV(sv) (SvNOK(sv) ? SvNVX(sv) : sv_2nv(sv))
1528
1529 #define SvIV_nomg(sv) (SvIOK(sv) ? SvIVX(sv) : sv_2iv_flags(sv, 0))
1530 #define SvUV_nomg(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv_flags(sv, 0))
1531 #define SvNV_nomg(sv) (SvNOK(sv) ? SvNVX(sv) : sv_2nv_flags(sv, 0))
1532
1533 /* ----*/
1534
1535 #define SvPV(sv, lp) SvPV_flags(sv, lp, SV_GMAGIC)
1536 #define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC)
1537 #define SvPV_mutable(sv, lp) SvPV_flags_mutable(sv, lp, SV_GMAGIC)
1538
1539 #define SvPV_flags(sv, lp, flags) \
1540     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1541      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags))
1542 #define SvPV_flags_const(sv, lp, flags) \
1543     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1544      ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \
1545      (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN))
1546 #define SvPV_flags_const_nolen(sv, flags) \
1547     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1548      ? SvPVX_const(sv) : \
1549      (const char*) sv_2pv_flags(sv, 0, flags|SV_CONST_RETURN))
1550 #define SvPV_flags_mutable(sv, lp, flags) \
1551     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1552      ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \
1553      sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
1554
1555 #define SvPV_force(sv, lp) SvPV_force_flags(sv, lp, SV_GMAGIC)
1556 #define SvPV_force_nolen(sv) SvPV_force_flags_nolen(sv, SV_GMAGIC)
1557 #define SvPV_force_mutable(sv, lp) SvPV_force_flags_mutable(sv, lp, SV_GMAGIC)
1558
1559 #define SvPV_force_nomg(sv, lp) SvPV_force_flags(sv, lp, 0)
1560 #define SvPV_force_nomg_nolen(sv) SvPV_force_flags_nolen(sv, 0)
1561
1562 #define SvPV_force_flags(sv, lp, flags) \
1563     ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
1564     ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags))
1565 #define SvPV_force_flags_nolen(sv, flags) \
1566     ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
1567     ? SvPVX(sv) : sv_pvn_force_flags(sv, 0, flags))
1568 #define SvPV_force_flags_mutable(sv, lp, flags) \
1569     ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
1570     ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \
1571      : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
1572
1573 #define SvPV_nolen(sv) \
1574     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1575      ? SvPVX(sv) : sv_2pv_flags(sv, 0, SV_GMAGIC))
1576
1577 #define SvPV_nomg_nolen(sv) \
1578     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1579      ? SvPVX(sv) : sv_2pv_flags(sv, 0, 0))
1580
1581 #define SvPV_nolen_const(sv) \
1582     ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
1583      ? SvPVX_const(sv) : sv_2pv_flags(sv, 0, SV_GMAGIC|SV_CONST_RETURN))
1584
1585 #define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0)
1586 #define SvPV_nomg_const(sv, lp) SvPV_flags_const(sv, lp, 0)
1587 #define SvPV_nomg_const_nolen(sv) SvPV_flags_const_nolen(sv, 0)
1588
1589 /* ----*/
1590
1591 #define SvPVutf8(sv, lp) \
1592     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK|SVf_UTF8) \
1593      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvutf8(sv, &lp))
1594
1595 #define SvPVutf8_force(sv, lp) \
1596     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_THINKFIRST)) == (SVf_POK|SVf_UTF8) \
1597      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvutf8n_force(sv, &lp))
1598
1599
1600 #define SvPVutf8_nolen(sv) \
1601     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK|SVf_UTF8)\
1602      ? SvPVX(sv) : sv_2pvutf8(sv, 0))
1603
1604 /* ----*/
1605
1606 #define SvPVbyte(sv, lp) \
1607     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \
1608      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp))
1609
1610 #define SvPVbyte_force(sv, lp) \
1611     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_THINKFIRST)) == (SVf_POK) \
1612      ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvbyten_force(sv, &lp))
1613
1614 #define SvPVbyte_nolen(sv) \
1615     ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK)\
1616      ? SvPVX(sv) : sv_2pvbyte(sv, 0))
1617
1618
1619     
1620 /* define FOOx(): idempotent versions of FOO(). If possible, use a local
1621  * var to evaluate the arg once; failing that, use a global if possible;
1622  * failing that, call a function to do the work
1623  */
1624
1625 #define SvPVx_force(sv, lp) sv_pvn_force(sv, &lp)
1626 #define SvPVutf8x_force(sv, lp) sv_pvutf8n_force(sv, &lp)
1627 #define SvPVbytex_force(sv, lp) sv_pvbyten_force(sv, &lp)
1628
1629 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
1630
1631 #  define SvIVx(sv) ({SV *_sv = MUTABLE_SV(sv); SvIV(_sv); })
1632 #  define SvUVx(sv) ({SV *_sv = MUTABLE_SV(sv); SvUV(_sv); })
1633 #  define SvNVx(sv) ({SV *_sv = MUTABLE_SV(sv); SvNV(_sv); })
1634 #  define SvPVx(sv, lp) ({SV *_sv = (sv); SvPV(_sv, lp); })
1635 #  define SvPVx_const(sv, lp) ({SV *_sv = (sv); SvPV_const(_sv, lp); })
1636 #  define SvPVx_nolen(sv) ({SV *_sv = (sv); SvPV_nolen(_sv); })
1637 #  define SvPVx_nolen_const(sv) ({SV *_sv = (sv); SvPV_nolen_const(_sv); })
1638 #  define SvPVutf8x(sv, lp) ({SV *_sv = (sv); SvPVutf8(_sv, lp); })
1639 #  define SvPVbytex(sv, lp) ({SV *_sv = (sv); SvPVbyte(_sv, lp); })
1640 #  define SvPVbytex_nolen(sv) ({SV *_sv = (sv); SvPVbyte_nolen(_sv); })
1641 #  define SvTRUE(sv) (                                          \
1642     !sv                                                         \
1643     ? 0                                                         \
1644     :    SvPOK(sv)                                              \
1645         ?   (({XPV *nxpv = (XPV*)SvANY(sv);                     \
1646              nxpv &&                                            \
1647              (nxpv->xpv_cur > 1 ||                              \
1648               (nxpv->xpv_cur && *(sv)->sv_u.svu_pv != '0')); }) \
1649              ? 1                                                \
1650              : 0)                                               \
1651         :                                                       \
1652             SvIOK(sv)                                           \
1653             ? SvIVX(sv) != 0                                    \
1654             :   SvNOK(sv)                                       \
1655                 ? SvNVX(sv) != 0.0                              \
1656                 : sv_2bool(sv) )
1657 #  define SvTRUE_nomg(sv) (                                     \
1658     !sv                                                         \
1659     ? 0                                                         \
1660     :    SvPOK(sv)                                              \
1661         ?   (({XPV *nxpv = (XPV*)SvANY(sv);                     \
1662              nxpv &&                                            \
1663              (nxpv->xpv_cur > 1 ||                              \
1664               (nxpv->xpv_cur && *(sv)->sv_u.svu_pv != '0')); }) \
1665              ? 1                                                \
1666              : 0)                                               \
1667         :                                                       \
1668             SvIOK(sv)                                           \
1669             ? SvIVX(sv) != 0                                    \
1670             :   SvNOK(sv)                                       \
1671                 ? SvNVX(sv) != 0.0                              \
1672                 : sv_2bool_flags(sv,0) )
1673 #  define SvTRUEx(sv) ({SV *_sv = (sv); SvTRUE(_sv); })
1674
1675 #else /* __GNUC__ */
1676
1677 /* These inlined macros use globals, which will require a thread
1678  * declaration in user code, so we avoid them under threads */
1679
1680 #  define SvIVx(sv) ((PL_Sv = (sv)), SvIV(PL_Sv))
1681 #  define SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv))
1682 #  define SvNVx(sv) ((PL_Sv = (sv)), SvNV(PL_Sv))
1683 #  define SvPVx(sv, lp) ((PL_Sv = (sv)), SvPV(PL_Sv, lp))
1684 #  define SvPVx_const(sv, lp) ((PL_Sv = (sv)), SvPV_const(PL_Sv, lp))
1685 #  define SvPVx_nolen(sv) ((PL_Sv = (sv)), SvPV_nolen(PL_Sv))
1686 #  define SvPVx_nolen_const(sv) ((PL_Sv = (sv)), SvPV_nolen_const(PL_Sv))
1687 #  define SvPVutf8x(sv, lp) ((PL_Sv = (sv)), SvPVutf8(PL_Sv, lp))
1688 #  define SvPVbytex(sv, lp) ((PL_Sv = (sv)), SvPVbyte(PL_Sv, lp))
1689 #  define SvPVbytex_nolen(sv) ((PL_Sv = (sv)), SvPVbyte_nolen(PL_Sv))
1690 #  define SvTRUE(sv) (                                          \
1691     !sv                                                         \
1692     ? 0                                                         \
1693     :    SvPOK(sv)                                              \
1694         ?   ((PL_Xpv = (XPV*)SvANY(PL_Sv = (sv))) &&            \
1695              (PL_Xpv->xpv_cur > 1 ||                            \
1696               (PL_Xpv->xpv_cur && *PL_Sv->sv_u.svu_pv != '0'))  \
1697              ? 1                                                \
1698              : 0)                                               \
1699         :                                                       \
1700             SvIOK(sv)                                           \
1701             ? SvIVX(sv) != 0                                    \
1702             :   SvNOK(sv)                                       \
1703                 ? SvNVX(sv) != 0.0                              \
1704                 : sv_2bool(sv) )
1705 #  define SvTRUE_nomg(sv) (                                     \
1706     !sv                                                         \
1707     ? 0                                                         \
1708     :    SvPOK(sv)                                              \
1709         ?   ((PL_Xpv = (XPV*)SvANY(PL_Sv = (sv))) &&            \
1710              (PL_Xpv->xpv_cur > 1 ||                            \
1711               (PL_Xpv->xpv_cur && *PL_Sv->sv_u.svu_pv != '0'))  \
1712              ? 1                                                \
1713              : 0)                                               \
1714         :                                                       \
1715             SvIOK(sv)                                           \
1716             ? SvIVX(sv) != 0                                    \
1717             :   SvNOK(sv)                                       \
1718                 ? SvNVX(sv) != 0.0                              \
1719                 : sv_2bool_flags(sv,0) )
1720 #  define SvTRUEx(sv) ((PL_Sv = (sv)), SvTRUE(PL_Sv))
1721 #endif /* __GNU__ */
1722
1723 #define SvIsCOW(sv)     ((SvFLAGS(sv) & (SVf_FAKE | SVf_READONLY)) == \
1724                            (SVf_FAKE | SVf_READONLY) && !isGV_with_GP(sv))
1725 #define SvIsCOW_shared_hash(sv) (SvIsCOW(sv) && SvLEN(sv) == 0)
1726
1727 #define SvSHARED_HEK_FROM_PV(pvx) \
1728         ((struct hek*)(pvx - STRUCT_OFFSET(struct hek, hek_key)))
1729 #define SvSHARED_HASH(sv) (0 + SvSHARED_HEK_FROM_PV(SvPVX_const(sv))->hek_hash)
1730
1731 /* flag values for sv_*_flags functions */
1732 #define SV_IMMEDIATE_UNREF      1
1733 #define SV_GMAGIC               2
1734 #define SV_COW_DROP_PV          4
1735 #define SV_UTF8_NO_ENCODING     8
1736 #define SV_NOSTEAL              16
1737 #define SV_CONST_RETURN         32
1738 #define SV_MUTABLE_RETURN       64
1739 #define SV_SMAGIC               128
1740 #define SV_HAS_TRAILING_NUL     256
1741 #define SV_COW_SHARED_HASH_KEYS 512
1742 /* This one is only enabled for PERL_OLD_COPY_ON_WRITE */
1743 #define SV_COW_OTHER_PVS        1024
1744 /* Make sv_2pv_flags return NULL if something is undefined.  */
1745 #define SV_UNDEF_RETURNS_NULL   2048
1746 /* Tell sv_utf8_upgrade() to not check to see if an upgrade is really needed.
1747  * This is used when the caller has already determined it is, and avoids
1748  * redundant work */
1749 #define SV_FORCE_UTF8_UPGRADE   4096
1750 /* if (after resolving magic etc), the SV is found to be overloaded,
1751  * don't call the overload magic, just return as-is */
1752 #define SV_SKIP_OVERLOAD        8192
1753
1754 /* The core is safe for this COW optimisation. XS code on CPAN may not be.
1755    So only default to doing the COW setup if we're in the core.
1756  */
1757 #ifdef PERL_CORE
1758 #  ifndef SV_DO_COW_SVSETSV
1759 #    define SV_DO_COW_SVSETSV   SV_COW_SHARED_HASH_KEYS|SV_COW_OTHER_PVS
1760 #  endif
1761 #endif
1762
1763 #ifndef SV_DO_COW_SVSETSV
1764 #  define SV_DO_COW_SVSETSV     0
1765 #endif
1766
1767
1768 #define sv_unref(sv)            sv_unref_flags(sv, 0)
1769 #define sv_force_normal(sv)     sv_force_normal_flags(sv, 0)
1770 #define sv_usepvn(sv, p, l)     sv_usepvn_flags(sv, p, l, 0)
1771 #define sv_usepvn_mg(sv, p, l)  sv_usepvn_flags(sv, p, l, SV_SMAGIC)
1772
1773 /* We are about to replace the SV's current value. So if it's copy on write
1774    we need to normalise it. Use the SV_COW_DROP_PV flag hint to say that
1775    the value is about to get thrown away, so drop the PV rather than go to
1776    the effort of making a read-write copy only for it to get immediately
1777    discarded.  */
1778
1779 #define SV_CHECK_THINKFIRST_COW_DROP(sv) if (SvTHINKFIRST(sv)) \
1780                                     sv_force_normal_flags(sv, SV_COW_DROP_PV)
1781
1782 #ifdef PERL_OLD_COPY_ON_WRITE
1783 #define SvRELEASE_IVX(sv)   \
1784     ((SvIsCOW(sv) ? sv_force_normal_flags(sv, 0) : (void) 0), 0)
1785 #  define SvIsCOW_normal(sv)    (SvIsCOW(sv) && SvLEN(sv))
1786 #  define SvRELEASE_IVX_(sv)    SvRELEASE_IVX(sv),
1787 #else
1788 #  define SvRELEASE_IVX(sv)   0
1789 /* This little game brought to you by the need to shut this warning up:
1790 mg.c: In function `Perl_magic_get':
1791 mg.c:1024: warning: left-hand operand of comma expression has no effect
1792 */
1793 #  define SvRELEASE_IVX_(sv)  /**/
1794 #endif /* PERL_OLD_COPY_ON_WRITE */
1795
1796 #define CAN_COW_MASK    (SVs_OBJECT|SVs_GMG|SVs_SMG|SVs_RMG|SVf_IOK|SVf_NOK| \
1797                          SVf_POK|SVf_ROK|SVp_IOK|SVp_NOK|SVp_POK|SVf_FAKE| \
1798                          SVf_OOK|SVf_BREAK|SVf_READONLY)
1799 #define CAN_COW_FLAGS   (SVp_POK|SVf_POK)
1800
1801 #define SV_CHECK_THINKFIRST(sv) if (SvTHINKFIRST(sv)) \
1802                                     sv_force_normal_flags(sv, 0)
1803
1804
1805 /* all these 'functions' are now just macros */
1806
1807 #define sv_pv(sv) SvPV_nolen(sv)
1808 #define sv_pvutf8(sv) SvPVutf8_nolen(sv)
1809 #define sv_pvbyte(sv) SvPVbyte_nolen(sv)
1810
1811 #define sv_pvn_force_nomg(sv, lp) sv_pvn_force_flags(sv, lp, 0)
1812 #define sv_utf8_upgrade_flags(sv, flags) sv_utf8_upgrade_flags_grow(sv, flags, 0)
1813 #define sv_utf8_upgrade_nomg(sv) sv_utf8_upgrade_flags(sv, 0)
1814 #define sv_catpvn_nomg(dsv, sstr, slen) sv_catpvn_flags(dsv, sstr, slen, 0)
1815 #define sv_catpv_nomg(dsv, sstr) sv_catpv_flags(dsv, sstr, 0)
1816 #define sv_setsv(dsv, ssv) \
1817         sv_setsv_flags(dsv, ssv, SV_GMAGIC|SV_DO_COW_SVSETSV)
1818 #define sv_setsv_nomg(dsv, ssv) sv_setsv_flags(dsv, ssv, SV_DO_COW_SVSETSV)
1819 #define sv_catsv(dsv, ssv) sv_catsv_flags(dsv, ssv, SV_GMAGIC)
1820 #define sv_catsv_nomg(dsv, ssv) sv_catsv_flags(dsv, ssv, 0)
1821 #define sv_catsv_mg(dsv, ssv) sv_catsv_flags(dsv, ssv, SV_GMAGIC|SV_SMAGIC)
1822 #define sv_catpvn(dsv, sstr, slen) sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC)
1823 #define sv_catpvn_mg(sv, sstr, slen) \
1824         sv_catpvn_flags(sv, sstr, slen, SV_GMAGIC|SV_SMAGIC);
1825 #define sv_2pv(sv, lp) sv_2pv_flags(sv, lp, SV_GMAGIC)
1826 #define sv_2pv_nolen(sv) sv_2pv(sv, 0)
1827 #define sv_2pvbyte_nolen(sv) sv_2pvbyte(sv, 0)
1828 #define sv_2pvutf8_nolen(sv) sv_2pvutf8(sv, 0)
1829 #define sv_2pv_nomg(sv, lp) sv_2pv_flags(sv, lp, 0)
1830 #define sv_pvn_force(sv, lp) sv_pvn_force_flags(sv, lp, SV_GMAGIC)
1831 #define sv_utf8_upgrade(sv) sv_utf8_upgrade_flags(sv, SV_GMAGIC)
1832 #define sv_2iv(sv) sv_2iv_flags(sv, SV_GMAGIC)
1833 #define sv_2uv(sv) sv_2uv_flags(sv, SV_GMAGIC)
1834 #define sv_2nv(sv) sv_2nv_flags(sv, SV_GMAGIC)
1835 #define sv_eq(sv1, sv2) sv_eq_flags(sv1, sv2, SV_GMAGIC)
1836 #define sv_cmp(sv1, sv2) sv_cmp_flags(sv1, sv2, SV_GMAGIC)
1837 #define sv_cmp_locale(sv1, sv2) sv_cmp_locale_flags(sv1, sv2, SV_GMAGIC)
1838 #define sv_collxfrm(sv, nxp) sv_cmp_flags(sv, nxp, SV_GMAGIC)
1839 #define sv_2bool(sv) sv_2bool_flags(sv, SV_GMAGIC)
1840 #define sv_insert(bigstr, offset, len, little, littlelen)               \
1841         Perl_sv_insert_flags(aTHX_ (bigstr),(offset), (len), (little),  \
1842                              (littlelen), SV_GMAGIC)
1843
1844 /* Should be named SvCatPVN_utf8_upgrade? */
1845 #define sv_catpvn_utf8_upgrade(dsv, sstr, slen, nsv)    \
1846         STMT_START {                                    \
1847             if (!(nsv))                                 \
1848                 nsv = newSVpvn_flags(sstr, slen, SVs_TEMP);     \
1849             else                                        \
1850                 sv_setpvn(nsv, sstr, slen);             \
1851             SvUTF8_off(nsv);                            \
1852             sv_utf8_upgrade(nsv);                       \
1853             sv_catsv(dsv, nsv); \
1854         } STMT_END
1855
1856 /*
1857 =for apidoc Am|SV*|newRV_inc|SV* sv
1858
1859 Creates an RV wrapper for an SV.  The reference count for the original SV is
1860 incremented.
1861
1862 =cut
1863 */
1864
1865 #define newRV_inc(sv)   newRV(sv)
1866
1867 /* the following macros update any magic values this sv is associated with */
1868
1869 /*
1870 =head1 Magical Functions
1871
1872 =for apidoc Am|void|SvGETMAGIC|SV* sv
1873 Invokes C<mg_get> on an SV if it has 'get' magic.  This macro evaluates its
1874 argument more than once.
1875
1876 =for apidoc Am|void|SvSETMAGIC|SV* sv
1877 Invokes C<mg_set> on an SV if it has 'set' magic.  This macro evaluates its
1878 argument more than once.
1879
1880 =for apidoc Am|void|SvSetSV|SV* dsb|SV* ssv
1881 Calls C<sv_setsv> if dsv is not the same as ssv.  May evaluate arguments
1882 more than once.
1883
1884 =for apidoc Am|void|SvSetSV_nosteal|SV* dsv|SV* ssv
1885 Calls a non-destructive version of C<sv_setsv> if dsv is not the same as
1886 ssv. May evaluate arguments more than once.
1887
1888 =for apidoc Am|void|SvSetMagicSV|SV* dsb|SV* ssv
1889 Like C<SvSetSV>, but does any set magic required afterwards.
1890
1891 =for apidoc Am|void|SvSetMagicSV_nosteal|SV* dsv|SV* ssv
1892 Like C<SvSetSV_nosteal>, but does any set magic required afterwards.
1893
1894 =for apidoc Am|void|SvSHARE|SV* sv
1895 Arranges for sv to be shared between threads if a suitable module
1896 has been loaded.
1897
1898 =for apidoc Am|void|SvLOCK|SV* sv
1899 Arranges for a mutual exclusion lock to be obtained on sv if a suitable module
1900 has been loaded.
1901
1902 =for apidoc Am|void|SvUNLOCK|SV* sv
1903 Releases a mutual exclusion lock on sv if a suitable module
1904 has been loaded.
1905
1906 =head1 SV Manipulation Functions
1907
1908 =for apidoc Am|char *|SvGROW|SV* sv|STRLEN len
1909 Expands the character buffer in the SV so that it has room for the
1910 indicated number of bytes (remember to reserve space for an extra trailing
1911 NUL character).  Calls C<sv_grow> to perform the expansion if necessary.
1912 Returns a pointer to the character buffer.
1913
1914 =cut
1915 */
1916
1917 #define SvSHARE(sv) PL_sharehook(aTHX_ sv)
1918 #define SvLOCK(sv) PL_lockhook(aTHX_ sv)
1919 #define SvUNLOCK(sv) PL_unlockhook(aTHX_ sv)
1920 #define SvDESTROYABLE(sv) PL_destroyhook(aTHX_ sv)
1921
1922 #define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
1923 #define SvSETMAGIC(x) STMT_START { if (SvSMAGICAL(x)) mg_set(x); } STMT_END
1924
1925 #define SvSetSV_and(dst,src,finally) \
1926         STMT_START {                                    \
1927             if ((dst) != (src)) {                       \
1928                 sv_setsv(dst, src);                     \
1929                 finally;                                \
1930             }                                           \
1931         } STMT_END
1932 #define SvSetSV_nosteal_and(dst,src,finally) \
1933         STMT_START {                                    \
1934             if ((dst) != (src)) {                       \
1935                 sv_setsv_flags(dst, src, SV_GMAGIC | SV_NOSTEAL | SV_DO_COW_SVSETSV);   \
1936                 finally;                                \
1937             }                                           \
1938         } STMT_END
1939
1940 #define SvSetSV(dst,src) \
1941                 SvSetSV_and(dst,src,/*nothing*/;)
1942 #define SvSetSV_nosteal(dst,src) \
1943                 SvSetSV_nosteal_and(dst,src,/*nothing*/;)
1944
1945 #define SvSetMagicSV(dst,src) \
1946                 SvSetSV_and(dst,src,SvSETMAGIC(dst))
1947 #define SvSetMagicSV_nosteal(dst,src) \
1948                 SvSetSV_nosteal_and(dst,src,SvSETMAGIC(dst))
1949
1950
1951 #if !defined(SKIP_DEBUGGING)
1952 #define SvPEEK(sv) sv_peek(sv)
1953 #else
1954 #define SvPEEK(sv) ""
1955 #endif
1956
1957 #define SvIMMORTAL(sv) ((sv)==&PL_sv_undef || (sv)==&PL_sv_yes || (sv)==&PL_sv_no || (sv)==&PL_sv_placeholder)
1958
1959 #define boolSV(b) ((b) ? &PL_sv_yes : &PL_sv_no)
1960
1961 #define isGV(sv) (SvTYPE(sv) == SVt_PVGV)
1962 /* If I give every macro argument a different name, then there won't be bugs
1963    where nested macros get confused. Been there, done that.  */
1964 #define isGV_with_GP(pwadak) \
1965         (((SvFLAGS(pwadak) & (SVp_POK|SVpgv_GP)) == SVpgv_GP)   \
1966         && (SvTYPE(pwadak) == SVt_PVGV || SvTYPE(pwadak) == SVt_PVLV))
1967 #define isGV_with_GP_on(sv)     STMT_START {                           \
1968         assert (SvTYPE(sv) == SVt_PVGV || SvTYPE(sv) == SVt_PVLV); \
1969         assert (!SvPOKp(sv));                                          \
1970         assert (!SvIOKp(sv));                                          \
1971         (SvFLAGS(sv) |= SVpgv_GP);                                     \
1972     } STMT_END
1973 #define isGV_with_GP_off(sv)    STMT_START {                           \
1974         assert (SvTYPE(sv) == SVt_PVGV || SvTYPE(sv) == SVt_PVLV); \
1975         assert (!SvPOKp(sv));                                          \
1976         assert (!SvIOKp(sv));                                          \
1977         (SvFLAGS(sv) &= ~SVpgv_GP);                                    \
1978     } STMT_END
1979
1980
1981 #define SvGROW(sv,len) (SvLEN(sv) < (len) ? sv_grow(sv,len) : SvPVX(sv))
1982 #define SvGROW_mutable(sv,len) \
1983     (SvLEN(sv) < (len) ? sv_grow(sv,len) : SvPVX_mutable(sv))
1984 #define Sv_Grow sv_grow
1985
1986 #define CLONEf_COPY_STACKS 1
1987 #define CLONEf_KEEP_PTR_TABLE 2
1988 #define CLONEf_CLONE_HOST 4
1989 #define CLONEf_JOIN_IN 8
1990
1991 struct clone_params {
1992   AV* stashes;
1993   UV  flags;
1994   PerlInterpreter *proto_perl;
1995   PerlInterpreter *new_perl;
1996   AV *unreferenced;
1997 };
1998
1999 /*
2000 =for apidoc Am|SV*|newSVpvn_utf8|NULLOK const char* s|STRLEN len|U32 utf8
2001
2002 Creates a new SV and copies a string into it.  If utf8 is true, calls
2003 C<SvUTF8_on> on the new SV.  Implemented as a wrapper around C<newSVpvn_flags>.
2004
2005 =cut
2006 */
2007
2008 #define newSVpvn_utf8(s, len, u) newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0)
2009
2010 /*
2011 =for apidoc Am|void|SvOOK_offset|NN SV*sv|STRLEN len
2012
2013 Reads into I<len> the offset from SvPVX back to the true start of the
2014 allocated buffer, which will be non-zero if C<sv_chop> has been used to
2015 efficiently remove characters from start of the buffer. Implemented as a
2016 macro, which takes the address of I<len>, which must be of type C<STRLEN>.
2017 Evaluates I<sv> more than once. Sets I<len> to 0 if C<SvOOK(sv)> is false.
2018
2019 =cut
2020 */
2021
2022 #ifdef DEBUGGING
2023 /* Does the bot know something I don't?
2024 10:28 <@Nicholas> metabatman
2025 10:28 <+meta> Nicholas: crash
2026 */
2027 #  define SvOOK_offset(sv, offset) STMT_START {                         \
2028         assert(sizeof(offset) == sizeof(STRLEN));                       \
2029         if (SvOOK(sv)) {                                                \
2030             const U8 *crash = (U8*)SvPVX_const(sv);                     \
2031             offset = *--crash;                                          \
2032             if (!offset) {                                              \
2033                 crash -= sizeof(STRLEN);                                \
2034                 Copy(crash, (U8 *)&offset, sizeof(STRLEN), U8);         \
2035             }                                                           \
2036             {                                                           \
2037                 /* Validate the preceding buffer's sentinels to         \
2038                    verify that no-one is using it.  */                  \
2039                 const U8 *const bonk = (U8 *) SvPVX_const(sv) - offset; \
2040                 while (crash > bonk) {                                  \
2041                     --crash;                                            \
2042                     assert (*crash == (U8)PTR2UV(crash));               \
2043                 }                                                       \
2044             }                                                           \
2045         } else {                                                        \
2046             offset = 0;                                                 \
2047         }                                                               \
2048     } STMT_END
2049 #else
2050     /* This is the same code, but avoids using any temporary variables:  */
2051 #  define SvOOK_offset(sv, offset) STMT_START {                         \
2052         assert(sizeof(offset) == sizeof(STRLEN));                       \
2053         if (SvOOK(sv)) {                                                \
2054             offset = ((U8*)SvPVX_const(sv))[-1];                        \
2055             if (!offset) {                                              \
2056                 Copy(SvPVX_const(sv) - 1 - sizeof(STRLEN),              \
2057                      (U8 *)&offset, sizeof(STRLEN), U8);                \
2058             }                                                           \
2059         } else {                                                        \
2060             offset = 0;                                                 \
2061         }                                                               \
2062     } STMT_END
2063 #endif
2064
2065 #define newIO() MUTABLE_IO(newSV_type(SVt_PVIO))
2066
2067 /*
2068  * Local variables:
2069  * c-indentation-style: bsd
2070  * c-basic-offset: 4
2071  * indent-tabs-mode: t
2072  * End:
2073  *
2074  * ex: set ts=8 sts=4 sw=4 noet:
2075  */