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