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