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