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