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