X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/b37c2d43c8bccbefe3985273e9661833102148d0..e92c6be8349ad1d36d6df1dcb526fd37421e9970:/sv.h diff --git a/sv.h b/sv.h index fc49f23..a1e990a 100644 --- a/sv.h +++ b/sv.h @@ -1,7 +1,7 @@ /* sv.h * - * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, - * 2000, 2001, 2002, 2003, 2004, 2005, 2006, by Larry Wall and others + * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, + * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. @@ -45,14 +45,16 @@ Type flag for code refs. See C. typedef enum { SVt_NULL, /* 0 */ - SVt_IV, /* 1 */ - SVt_NV, /* 2 */ - SVt_RV, /* 3 */ + SVt_BIND, /* 1 */ + SVt_IV, /* 2 */ + SVt_NV, /* 3 */ + /* RV was here, before it was merged with IV. */ SVt_PV, /* 4 */ SVt_PVIV, /* 5 */ SVt_PVNV, /* 6 */ SVt_PVMG, /* 7 */ - SVt_PVBM, /* 8 */ + SVt_REGEXP, /* 8 */ + /* PVBM was here, before BIND replaced it. */ SVt_PVGV, /* 9 */ SVt_PVLV, /* 10 */ SVt_PVAV, /* 11 */ @@ -63,6 +65,16 @@ typedef enum { SVt_LAST /* keep last in enum. used to size arrays */ } svtype; +#ifndef PERL_CORE +/* Although Fast Boyer Moore tables are now being stored in PVGVs, for most + purposes eternal code wanting to consider PVBM probably needs to think of + PVMG instead. */ +# define SVt_PVBM SVt_PVMG +/* Anything wanting to create a reference from clean should ensure that it has + a scalar of type SVt_IV now: */ +# define SVt_RV SVt_IV +#endif + /* There is collusion here with sv_clear - sv_clear exits early for SVt_NULL and SVt_IV, so never reaches the clause at the end that uses sv_type_details->body_size to determine whether to call safefree(). Hence @@ -105,10 +117,11 @@ struct STRUCT_SV { /* struct sv { */ _SV_HEAD(void*); _SV_HEAD_UNION; #ifdef DEBUG_LEAKING_SCALARS - unsigned sv_debug_optype:9; /* the type of OP that allocated us */ - unsigned sv_debug_inpad:1; /* was allocated in a pad for an OP */ - unsigned sv_debug_cloned:1; /* was cloned for an ithread */ - unsigned sv_debug_line:16; /* the line where we were allocated */ + PERL_BITFIELD32 sv_debug_optype:9; /* the type of OP that allocated us */ + PERL_BITFIELD32 sv_debug_inpad:1; /* was allocated in a pad for an OP */ + PERL_BITFIELD32 sv_debug_cloned:1; /* was cloned for an ithread */ + PERL_BITFIELD32 sv_debug_line:16; /* the line where we were allocated */ + U32 sv_debug_serial; /* serial number of sv allocation */ char * sv_debug_file; /* the file where we were allocated */ #endif }; @@ -138,6 +151,11 @@ struct io { _SV_HEAD_UNION; }; +struct p5rx { + _SV_HEAD(struct regexp*); /* pointer to regexp body */ + _SV_HEAD_UNION; +}; + #undef _SV_HEAD #undef _SV_HEAD_UNION /* ensure no pollution */ @@ -158,32 +176,34 @@ Same as SvREFCNT_inc, but can only be used if you know I is not NULL. Since we don't have to check the NULLness, it's faster and smaller. -=for apidoc Am|SV*|SvREFCNT_inc_void|SV* sv +=for apidoc Am|void|SvREFCNT_inc_void|SV* sv Same as SvREFCNT_inc, but can only be used if you don't need the return value. The macro doesn't need to return a meaningful value. -=for apidoc Am|SV*|SvREFCNT_inc_void_NN|SV* sv +=for apidoc Am|void|SvREFCNT_inc_void_NN|SV* sv Same as SvREFCNT_inc, but can only be used if you don't need the return value, and you know that I is not NULL. The macro doesn't need to return a meaningful value, or check for NULLness, so it's smaller and faster. =for apidoc Am|SV*|SvREFCNT_inc_simple|SV* sv -Same as SvREFCNT_inc, but can only be used with simple variables, not -expressions or pointer dereferences. Since we don't have to store a -temporary value, it's faster. +Same as SvREFCNT_inc, but can only be used with expressions without side +effects. Since we don't have to store a temporary value, it's faster. =for apidoc Am|SV*|SvREFCNT_inc_simple_NN|SV* sv Same as SvREFCNT_inc_simple, but can only be used if you know I is not NULL. Since we don't have to check the NULLness, it's faster and smaller. -=for apidoc Am|SV*|SvREFCNT_inc_simple_void|SV* sv +=for apidoc Am|void|SvREFCNT_inc_simple_void|SV* sv Same as SvREFCNT_inc_simple, but can only be used if you don't need the return value. The macro doesn't need to return a meaningful value. -=for apidoc Am|SV*|SvREFCNT_inc|SV* sv -Increments the reference count of the given SV. +=for apidoc Am|void|SvREFCNT_inc_simple_void_NN|SV* sv +Same as SvREFCNT_inc, but can only be used if you don't need the return +value, and you know that I is not NULL. The macro doesn't need +to return a meaningful value, or check for NULLness, so it's smaller +and faster. =for apidoc Am|void|SvREFCNT_dec|SV* sv Decrements the reference count of the given SV. @@ -202,10 +222,10 @@ perform the upgrade if necessary. See C. #define SvFLAGS(sv) (sv)->sv_flags #define SvREFCNT(sv) (sv)->sv_refcnt -#if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) +#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define SvREFCNT_inc(sv) \ ({ \ - SV * const _sv = (SV*)(sv); \ + SV * const _sv = MUTABLE_SV(sv); \ if (_sv) \ (SvREFCNT(_sv))++; \ _sv; \ @@ -214,41 +234,41 @@ perform the upgrade if necessary. See C. ({ \ if (sv) \ (SvREFCNT(sv))++; \ - sv; \ + MUTABLE_SV(sv); \ }) # define SvREFCNT_inc_NN(sv) \ ({ \ - SV * const _sv = (SV*)(sv); \ + SV * const _sv = MUTABLE_SV(sv); \ SvREFCNT(_sv)++; \ _sv; \ }) # define SvREFCNT_inc_void(sv) \ ({ \ - SV * const _sv = (SV*)(sv); \ + SV * const _sv = MUTABLE_SV(sv); \ if (_sv) \ (void)(SvREFCNT(_sv)++); \ }) #else # define SvREFCNT_inc(sv) \ - ((PL_Sv=(SV*)(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL) + ((PL_Sv=MUTABLE_SV(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL) # define SvREFCNT_inc_simple(sv) \ - ((sv) ? (SvREFCNT(sv)++,(SV*)(sv)) : NULL) + ((sv) ? (SvREFCNT(sv)++,MUTABLE_SV(sv)) : NULL) # define SvREFCNT_inc_NN(sv) \ - (PL_Sv=(SV*)(sv),++(SvREFCNT(PL_Sv)),PL_Sv) + (PL_Sv=MUTABLE_SV(sv),++(SvREFCNT(PL_Sv)),PL_Sv) # define SvREFCNT_inc_void(sv) \ - (void)((PL_Sv=(SV*)(sv)) ? ++(SvREFCNT(PL_Sv)) : 0) + (void)((PL_Sv=MUTABLE_SV(sv)) ? ++(SvREFCNT(PL_Sv)) : 0) #endif /* These guys don't need the curly blocks */ -#define SvREFCNT_inc_simple_void(sv) if (sv) (SvREFCNT(sv)++); -#define SvREFCNT_inc_simple_NN(sv) (++(SvREFCNT(sv)),(SV*)(sv)) -#define SvREFCNT_inc_void_NN(sv) (void)(++SvREFCNT((SV*)(sv))) -#define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv))) +#define SvREFCNT_inc_simple_void(sv) STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END +#define SvREFCNT_inc_simple_NN(sv) (++(SvREFCNT(sv)),MUTABLE_SV(sv)) +#define SvREFCNT_inc_void_NN(sv) (void)(++SvREFCNT(MUTABLE_SV(sv))) +#define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT(MUTABLE_SV(sv))) -#if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) +#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define SvREFCNT_dec(sv) \ ({ \ - SV * const _sv = (SV*)(sv); \ + SV * const _sv = MUTABLE_SV(sv); \ if (_sv) { \ if (SvREFCNT(_sv)) { \ if (--(SvREFCNT(_sv)) == 0) \ @@ -259,11 +279,11 @@ perform the upgrade if necessary. See C. } \ }) #else -#define SvREFCNT_dec(sv) sv_free((SV*)(sv)) +#define SvREFCNT_dec(sv) sv_free(MUTABLE_SV(sv)) #endif #define SVTYPEMASK 0xff -#define SvTYPE(sv) ((sv)->sv_flags & SVTYPEMASK) +#define SvTYPE(sv) ((svtype)((sv)->sv_flags & SVTYPEMASK)) /* Sadly there are some parts of the core that have pointers to already-freed SV heads, and rely on being able to tell that they are now free. So mark @@ -272,50 +292,56 @@ perform the upgrade if necessary. See C. #define SvUPGRADE(sv, mt) (SvTYPE(sv) >= (mt) || (sv_upgrade(sv, mt), 1)) -#define SVf_IOK 0x00000100 /* has valid public integer value */ -#define SVf_NOK 0x00000200 /* has valid public numeric value */ -#define SVf_POK 0x00000400 /* has valid public pointer value */ -#define SVf_ROK 0x00000800 /* has a valid reference pointer */ - -#define SVp_IOK 0x00001000 /* has valid non-public integer value */ -#define SVp_NOK 0x00002000 /* has valid non-public numeric value */ -#define SVp_POK 0x00004000 /* has valid non-public pointer value */ -#define SVp_SCREAM 0x00008000 /* has been studied? */ -#define SVphv_CLONEABLE 0x00008000 /* PVHV (stashes) clone its objects */ - -#define SVs_PADSTALE 0x00010000 /* lexical has gone out of scope */ -#define SVs_PADTMP 0x00020000 /* in use as tmp */ -#define SVpad_TYPED 0x00020000 /* pad name is a Typed Lexical */ -#define SVs_PADMY 0x00040000 /* in use a "my" variable */ -#define SVpad_OUR 0x00040000 /* pad name is "our" instead of "my" */ -#define SVs_TEMP 0x00080000 /* string is stealable? */ -#define SVs_OBJECT 0x00100000 /* is "blessed" */ -#define SVs_GMG 0x00200000 /* has magical get method */ -#define SVs_SMG 0x00400000 /* has magical set method */ -#define SVs_RMG 0x00800000 /* has random magical methods */ - -#define SVf_FAKE 0x01000000 /* 0: glob or lexical is just a copy - 1: SV head arena wasn't malloc()ed - 2: in conjunction with SVf_READONLY - marks a shared hash key scalar - (SvLEN == 0) or a copy on write - string (SvLEN != 0) [SvIsCOW(sv)] - 3: For PVCV, whether CvUNIQUE(cv) - refers to an eval or once only - [CvEVAL(cv), CvSPECIAL(cv)] - 4: Whether the regexp pointer is in - fact an offset [SvREPADTMP(sv)] - 5: On a pad name SV, that slot in the - frame AV is a REFCNT'ed reference - to a lexical from "outside". - */ -#define SVf_OOK 0x02000000 /* has valid offset value - For a PVHV this means that a - hv_aux struct is present after the - main array */ -#define SVf_BREAK 0x04000000 /* refcnt is artificially low - used - * by SV's in final arena cleanup */ -#define SVf_READONLY 0x08000000 /* may not be modified */ +#define SVf_IOK 0x00000100 /* has valid public integer value */ +#define SVf_NOK 0x00000200 /* has valid public numeric value */ +#define SVf_POK 0x00000400 /* has valid public pointer value */ +#define SVf_ROK 0x00000800 /* has a valid reference pointer */ + +#define SVp_IOK 0x00001000 /* has valid non-public integer value */ +#define SVp_NOK 0x00002000 /* has valid non-public numeric value */ +#define SVp_POK 0x00004000 /* has valid non-public pointer value */ +#define SVp_SCREAM 0x00008000 /* has been studied? */ +#define SVphv_CLONEABLE SVp_SCREAM /* PVHV (stashes) clone its objects */ +#define SVpgv_GP SVp_SCREAM /* GV has a valid GP */ +#define SVprv_PCS_IMPORTED SVp_SCREAM /* RV is a proxy for a constant + subroutine in another package. Set the + CvIMPORTED_CV_ON() if it needs to be + expanded to a real GV */ + +#define SVs_PADSTALE 0x00010000 /* lexical has gone out of scope */ +#define SVpad_STATE 0x00010000 /* pad name is a "state" var */ +#define SVs_PADTMP 0x00020000 /* in use as tmp */ +#define SVpad_TYPED 0x00020000 /* pad name is a Typed Lexical */ +#define SVs_PADMY 0x00040000 /* in use a "my" variable */ +#define SVpad_OUR 0x00040000 /* pad name is "our" instead of "my" */ +#define SVs_TEMP 0x00080000 /* string is stealable? */ +#define SVs_OBJECT 0x00100000 /* is "blessed" */ +#define SVs_GMG 0x00200000 /* has magical get method */ +#define SVs_SMG 0x00400000 /* has magical set method */ +#define SVs_RMG 0x00800000 /* has random magical methods */ + +#define SVf_FAKE 0x01000000 /* 0: glob or lexical is just a copy + 1: SV head arena wasn't malloc()ed + 2: in conjunction with SVf_READONLY + marks a shared hash key scalar + (SvLEN == 0) or a copy on write + string (SvLEN != 0) [SvIsCOW(sv)] + 3: For PVCV, whether CvUNIQUE(cv) + refers to an eval or once only + [CvEVAL(cv), CvSPECIAL(cv)] + 4: On a pad name SV, that slot in the + frame AV is a REFCNT'ed reference + to a lexical from "outside". */ +#define SVphv_REHASH SVf_FAKE /* 5: On a PVHV, hash values are being + recalculated */ +#define SVf_OOK 0x02000000 /* has valid offset value. For a PVHV this + means that a hv_aux struct is present + after the main array */ +#define SVf_BREAK 0x04000000 /* refcnt is artificially low - used by + SVs in final arena cleanup. + Set in S_regtry on PL_reg_curpm, so that + perl_destruct will skip it. */ +#define SVf_READONLY 0x08000000 /* may not be modified */ @@ -323,172 +349,138 @@ perform the upgrade if necessary. See C. #define SVf_THINKFIRST (SVf_READONLY|SVf_ROK|SVf_FAKE) #define SVf_OK (SVf_IOK|SVf_NOK|SVf_POK|SVf_ROK| \ - SVp_IOK|SVp_NOK|SVp_POK|SVp_SCREAM) + SVp_IOK|SVp_NOK|SVp_POK|SVpgv_GP) #define PRIVSHIFT 4 /* (SVp_?OK >> PRIVSHIFT) == SVf_?OK */ -#define SVf_AMAGIC 0x10000000 /* has magical overloaded methods */ -#define SVf_UTF8 0x20000000 /* SvPV is UTF-8 encoded */ -/* Ensure this value does not clash with the GV_ADD* flags in gv.h */ +#define SVf_AMAGIC 0x10000000 /* has magical overloaded methods */ + +/* Ensure this value does not clash with the GV_ADD* flags in gv.h: */ +#define SVf_UTF8 0x20000000 /* SvPV is UTF-8 encoded + This is also set on RVs whose overloaded + stringification is UTF-8. This might + only happen as a side effect of SvPV() */ + /* Some private flags. */ +/* PVAV could probably use 0x2000000 without conflict. I assume that PVFM can + be UTF-8 encoded, and PVCVs could well have UTF-8 prototypes. PVIOs haven't + been restructured, so sometimes get used as string buffers. */ + /* PVHV */ -#define SVphv_REHASH 0x10000000 /* PVHV is recalculating hash values */ -/* PVHV */ -#define SVphv_SHAREKEYS 0x20000000 /* PVHV - keys live on shared string table */ -/* PVNV, PVMG, PVGV, presumably only inside pads */ -#define SVpad_NAME 0x40000000 /* This SV is a name in the PAD, so - SVpad_TYPED and SVpad_OUR apply */ +#define SVphv_SHAREKEYS 0x20000000 /* PVHV keys live on shared string table */ +/* PVNV, PVMG, presumably only inside pads */ +#define SVpad_NAME 0x40000000 /* This SV is a name in the PAD, so + SVpad_TYPED, SVpad_OUR and SVpad_STATE + apply */ /* PVAV */ -#define SVpav_REAL 0x40000000 /* free old entries */ +#define SVpav_REAL 0x40000000 /* free old entries */ /* PVHV */ -#define SVphv_LAZYDEL 0x40000000 /* entry in xhv_eiter must be deleted */ -/* PVBM */ -#define SVpbm_TAIL 0x40000000 +#define SVphv_LAZYDEL 0x40000000 /* entry in xhv_eiter must be deleted */ +/* This is only set true on a PVGV when it's playing "PVBM", but is tested for + on any regular scalar (anything <= PVLV) */ +#define SVpbm_VALID 0x40000000 /* ??? */ -#define SVrepl_EVAL 0x40000000 /* Replacement part of s///e */ +#define SVrepl_EVAL 0x40000000 /* Replacement part of s///e */ /* IV, PVIV, PVNV, PVMG, PVGV and (I assume) PVLV */ /* Presumably IVs aren't stored in pads */ -#define SVf_IVisUV 0x80000000 /* use XPVUV instead of XPVIV */ +#define SVf_IVisUV 0x80000000 /* use XPVUV instead of XPVIV */ /* PVAV */ -#define SVpav_REIFY 0x80000000 /* can become real */ +#define SVpav_REIFY 0x80000000 /* can become real */ /* PVHV */ -#define SVphv_HASKFLAGS 0x80000000 /* keys have flag byte after hash */ +#define SVphv_HASKFLAGS 0x80000000 /* keys have flag byte after hash */ /* PVFM */ -#define SVpfm_COMPILED 0x80000000 /* FORMLINE is compiled */ -/* PVBM */ -#define SVpbm_VALID 0x80000000 +#define SVpfm_COMPILED 0x80000000 /* FORMLINE is compiled */ +/* PVGV when SVpbm_VALID is true */ +#define SVpbm_TAIL 0x80000000 /* RV upwards. However, SVf_ROK and SVp_IOK are exclusive */ -#define SVprv_WEAKREF 0x80000000 /* Weak reference */ +#define SVprv_WEAKREF 0x80000000 /* Weak reference */ + +#define _XPV_ALLOCATED_HEAD \ + STRLEN xpv_cur; /* length of svu_pv as a C string */ \ + STRLEN xpv_len /* allocated size */ + +#define _XPV_HEAD \ + union _xnvu xnv_u; \ + _XPV_ALLOCATED_HEAD + +union _xnvu { + NV xnv_nv; /* numeric value, if any */ + HV * xgv_stash; + struct { + U32 xlow; + U32 xhigh; + } xpad_cop_seq; /* used by pad.c for cop_sequence */ + struct { + U32 xbm_previous; /* how many characters in string before rare? */ + U8 xbm_flags; + U8 xbm_rare; /* rarest character in string */ + } xbm_s; /* fields from PVBM */ +}; + +union _xivu { + IV xivu_iv; /* integer value */ + /* xpvfm: lines */ + UV xivu_uv; + void * xivu_p1; + I32 xivu_i32; + HEK * xivu_namehek; /* xpvlv, xpvgv: GvNAME */ + HV * xivu_hv; /* regexp: paren_names */ +}; +union _xmgu { + MAGIC* xmg_magic; /* linked list of magicalness */ + HV* xmg_ourstash; /* Stash for our (when SvPAD_OUR is true) */ +}; struct xpv { - union { - NV xnv_nv; /* numeric value, if any */ - HV * xgv_stash; - } xnv_u; - STRLEN xpv_cur; /* length of svu_pv as a C string */ - STRLEN xpv_len; /* allocated size */ + _XPV_HEAD; }; -#if 0 -typedef struct xpv xpv_allocated; -#else typedef struct { - STRLEN xpv_cur; /* length of svu_pv as a C string */ - STRLEN xpv_len; /* allocated size */ + _XPV_ALLOCATED_HEAD; } xpv_allocated; -#endif struct xpviv { - union { - NV xnv_nv; /* numeric value, if any */ - HV * xgv_stash; - } xnv_u; - STRLEN xpv_cur; /* length of svu_pv as a C string */ - STRLEN xpv_len; /* allocated size */ - union { - IV xivu_iv; /* integer value or pv offset */ - UV xivu_uv; - void * xivu_p1; - I32 xivu_i32; - } xiv_u; + _XPV_HEAD; + union _xivu xiv_u; }; -#if 0 -typedef struct xpviv xpviv_allocated; -#else typedef struct { - STRLEN xpv_cur; /* length of svu_pv as a C string */ - STRLEN xpv_len; /* allocated size */ - union { - IV xivu_iv; /* integer value or pv offset */ - UV xivu_uv; - void * xivu_p1; - I32 xivu_i32; - } xiv_u; + _XPV_ALLOCATED_HEAD; + union _xivu xiv_u; } xpviv_allocated; -#endif #define xiv_iv xiv_u.xivu_iv struct xpvuv { - union { - NV xnv_nv; /* numeric value, if any */ - HV * xgv_stash; - } xnv_u; - STRLEN xpv_cur; /* length of svu_pv as a C string */ - STRLEN xpv_len; /* allocated size */ - union { - IV xuvu_iv; - UV xuvu_uv; /* unsigned value or pv offset */ - void * xuvu_p1; - } xuv_u; + _XPV_HEAD; + union _xivu xuv_u; }; -#define xuv_uv xuv_u.xuvu_uv +#define xuv_uv xuv_u.xivu_uv struct xpvnv { - union { - NV xnv_nv; /* numeric value, if any */ - HV * xgv_stash; - } xnv_u; - STRLEN xpv_cur; /* length of svu_pv as a C string */ - STRLEN xpv_len; /* allocated size */ - union { - IV xivu_iv; /* integer value or pv offset */ - UV xivu_uv; - void * xivu_p1; - I32 xivu_i32; - } xiv_u; + _XPV_HEAD; + union _xivu xiv_u; }; +#define _XPVMG_HEAD \ + union _xivu xiv_u; \ + union _xmgu xmg_u; \ + HV* xmg_stash /* class package */ + /* These structure must match the beginning of struct xpvhv in hv.h. */ struct xpvmg { - union { - NV xnv_nv; /* numeric value, if any */ - HV * xgv_stash; - } xnv_u; - STRLEN xpv_cur; /* length of svu_pv as a C string */ - STRLEN xpv_len; /* allocated size */ - union { - IV xivu_iv; /* integer value or pv offset */ - UV xivu_uv; - void * xivu_p1; - I32 xivu_i32; - } xiv_u; - union { - MAGIC* xmg_magic; /* linked list of magicalness */ - HV* xmg_ourstash; /* Stash for our (when SvPAD_OUR is true) */ - } xmg_u; - HV* xmg_stash; /* class package */ + _XPV_HEAD; + _XPVMG_HEAD; }; struct xpvlv { - union { - NV xnv_nv; /* numeric value, if any */ - HV * xgv_stash; - } xnv_u; - STRLEN xpv_cur; /* length of svu_pv as a C string */ - STRLEN xpv_len; /* allocated size */ - union { - IV xivu_iv; /* integer value or pv offset */ - UV xivu_uv; - void * xivu_p1; - I32 xivu_i32; - } xiv_u; - union { - MAGIC* xmg_magic; /* linked list of magicalness */ - HV* xmg_ourstash; /* Stash for our (when SvPAD_OUR is true) */ - } xmg_u; - HV* xmg_stash; /* class package */ - - /* a full glob fits into this */ - char* xgv_name; - STRLEN xgv_namelen; + _XPV_HEAD; + _XPVMG_HEAD; STRLEN xlv_targoff; STRLEN xlv_targlen; @@ -497,179 +489,90 @@ struct xpvlv { * y=alem/helem/iter t=tie T=tied HE */ }; +/* This structure works in 3 ways - regular scalar, GV with GP, or fast + Boyer-Moore. */ struct xpvgv { - union { - NV xnv_nv; - HV * xgv_stash; /* The stash of this GV */ - } xnv_u; - STRLEN xpv_cur; /* xgv_flags */ - STRLEN xpv_len; /* 0 */ - union { - IV xivu_iv; /* integer value or pv offset */ - UV xivu_uv; - void * xivu_p1; - I32 xivu_i32; - } xiv_u; - union { - MAGIC* xmg_magic; /* linked list of magicalness */ - HV* xmg_ourstash; /* Stash for our (when SvPAD_OUR is true) */ - } xmg_u; - HV* xmg_stash; /* class package */ - - char* xgv_name; - STRLEN xgv_namelen; -}; - -struct xpvbm { - union { - NV xnv_nv; /* numeric value, if any */ - HV * xgv_stash; - } xnv_u; - STRLEN xpv_cur; /* length of svu_pv as a C string */ - STRLEN xpv_len; /* allocated size */ - union { - IV xivu_iv; /* integer value or pv offset */ - UV xivu_uv; - void * xivu_p1; - I32 xivu_i32; - } xiv_u; - union { - MAGIC* xmg_magic; /* linked list of magicalness */ - HV* xmg_ourstash; /* Stash for our (when SvPAD_OUR is true) */ - } xmg_u; - HV* xmg_stash; /* class package */ - - I32 xbm_useful; /* is this constant pattern being useful? */ - U16 xbm_previous; /* how many characters in string before rare? */ - U8 xbm_rare; /* rarest character in string */ + _XPV_HEAD; + _XPVMG_HEAD; }; /* This structure must match XPVCV in cv.h */ typedef U16 cv_flags_t; +#define _XPVCV_COMMON \ + HV * xcv_stash; \ + union { \ + OP * xcv_start; \ + ANY xcv_xsubany; \ + } xcv_start_u; \ + union { \ + OP * xcv_root; \ + void (*xcv_xsub) (pTHX_ CV*); \ + } xcv_root_u; \ + GV * xcv_gv; \ + char * xcv_file; \ + AV * xcv_padlist; \ + CV * xcv_outside; \ + U32 xcv_outside_seq; /* the COP sequence (at the point of our \ + * compilation) in the lexically enclosing \ + * sub */ \ + cv_flags_t xcv_flags + struct xpvfm { - union { - NV xnv_nv; /* numeric value, if any */ - HV * xgv_stash; - } xnv_u; - STRLEN xpv_cur; /* length of svu_pv as a C string */ - STRLEN xpv_len; /* allocated size */ - union { - IV xivu_iv; /* PVFMs use the pv offset */ - UV xivu_uv; - void * xivu_p1; - I32 xivu_i32; - } xiv_u; - union { - MAGIC* xmg_magic; /* linked list of magicalness */ - HV* xmg_ourstash; /* Stash for our (when SvPAD_OUR is true) */ - } xmg_u; - HV* xmg_stash; /* class package */ - - HV * xcv_stash; - union { - OP * xcv_start; - ANY xcv_xsubany; - } xcv_start_u; - union { - OP * xcv_root; - void (*xcv_xsub) (pTHX_ CV*); - } xcv_root_u; - GV * xcv_gv; - char * xcv_file; - AV * xcv_padlist; - CV * xcv_outside; - U32 xcv_outside_seq; /* the COP sequence (at the point of our - * compilation) in the lexically enclosing - * sub */ - cv_flags_t xcv_flags; - IV xfm_lines; + _XPV_HEAD; + _XPVMG_HEAD; + _XPVCV_COMMON; }; typedef struct { - STRLEN xpv_cur; /* length of svu_pv as a C string */ - STRLEN xpv_len; /* allocated size */ - union { - IV xivu_iv; /* PVFMs use the pv offset */ - UV xivu_uv; - void * xivu_p1; - I32 xivu_i32; - } xiv_u; - union { - MAGIC* xmg_magic; /* linked list of magicalness */ - HV* xmg_ourstash; /* Stash for our (when SvPAD_OUR is true) */ - } xmg_u; - HV* xmg_stash; /* class package */ - - HV * xcv_stash; - union { - OP * xcv_start; - ANY xcv_xsubany; - } xcv_start_u; - union { - OP * xcv_root; - void (*xcv_xsub) (pTHX_ CV*); - } xcv_root_u; - GV * xcv_gv; - char * xcv_file; - AV * xcv_padlist; - CV * xcv_outside; - U32 xcv_outside_seq; /* the COP sequence (at the point of our - * compilation) in the lexically enclosing - * sub */ - cv_flags_t xcv_flags; - IV xfm_lines; + _XPV_ALLOCATED_HEAD; + _XPVMG_HEAD; + _XPVCV_COMMON; } xpvfm_allocated; +#define _XPVIO_TAIL \ + PerlIO * xio_ifp; /* ifp and ofp are normally the same */ \ + PerlIO * xio_ofp; /* but sockets need separate streams */ \ + /* Cray addresses everything by word boundaries (64 bits) and \ + * code and data pointers cannot be mixed (which is exactly what \ + * Perl_filter_add() tries to do with the dirp), hence the \ + * following union trick (as suggested by Gurusamy Sarathy). \ + * For further information see Geir Johansen's problem report \ + * titled [ID 20000612.002] Perl problem on Cray system \ + * The any pointer (known as IoANY()) will also be a good place \ + * to hang any IO disciplines to. \ + */ \ + union { \ + DIR * xiou_dirp; /* for opendir, readdir, etc */ \ + void * xiou_any; /* for alignment */ \ + } xio_dirpu; \ + IV xio_lines; /* $. */ \ + IV xio_page; /* $% */ \ + IV xio_page_len; /* $= */ \ + IV xio_lines_left; /* $- */ \ + char * xio_top_name; /* $^ */ \ + GV * xio_top_gv; /* $^ */ \ + char * xio_fmt_name; /* $~ */ \ + GV * xio_fmt_gv; /* $~ */ \ + char * xio_bottom_name;/* $^B */ \ + GV * xio_bottom_gv; /* $^B */ \ + char xio_type; \ + U8 xio_flags + + struct xpvio { - union { - NV xnv_nv; /* numeric value, if any */ - HV * xgv_stash; - } xnv_u; - STRLEN xpv_cur; /* length of svu_pv as a C string */ - STRLEN xpv_len; /* allocated size */ - union { - IV xivu_iv; /* integer value or pv offset */ - UV xivu_uv; - void * xivu_p1; - I32 xivu_i32; - } xiv_u; - union { - MAGIC* xmg_magic; /* linked list of magicalness */ - HV* xmg_ourstash; /* Stash for our (when SvPAD_OUR is true) */ - } xmg_u; - HV* xmg_stash; /* class package */ - - PerlIO * xio_ifp; /* ifp and ofp are normally the same */ - PerlIO * xio_ofp; /* but sockets need separate streams */ - /* Cray addresses everything by word boundaries (64 bits) and - * code and data pointers cannot be mixed (which is exactly what - * Perl_filter_add() tries to do with the dirp), hence the following - * union trick (as suggested by Gurusamy Sarathy). - * For further information see Geir Johansen's problem report titled - [ID 20000612.002] Perl problem on Cray system - * The any pointer (known as IoANY()) will also be a good place - * to hang any IO disciplines to. - */ - union { - DIR * xiou_dirp; /* for opendir, readdir, etc */ - void * xiou_any; /* for alignment */ - } xio_dirpu; - IV xio_lines; /* $. */ - IV xio_page; /* $% */ - IV xio_page_len; /* $= */ - IV xio_lines_left; /* $- */ - char * xio_top_name; /* $^ */ - GV * xio_top_gv; /* $^ */ - char * xio_fmt_name; /* $~ */ - GV * xio_fmt_gv; /* $~ */ - char * xio_bottom_name;/* $^B */ - GV * xio_bottom_gv; /* $^B */ - short xio_subprocess; /* -| or |- */ - char xio_type; - char xio_flags; + _XPV_HEAD; + _XPVMG_HEAD; + _XPVIO_TAIL; }; + +typedef struct { + _XPV_ALLOCATED_HEAD; + _XPVMG_HEAD; + _XPVIO_TAIL; +} xpvio_allocated; + #define xio_dirp xio_dirpu.xiou_dirp #define xio_any xio_dirpu.xiou_any @@ -684,35 +587,35 @@ struct xpvio { /* The following macros define implementation-independent predicates on SVs. */ /* -=for apidoc Am|bool|SvNIOK|SV* sv -Returns a boolean indicating whether the SV contains a number, integer or +=for apidoc Am|U32|SvNIOK|SV* sv +Returns a U32 value indicating whether the SV contains a number, integer or double. -=for apidoc Am|bool|SvNIOKp|SV* sv -Returns a boolean indicating whether the SV contains a number, integer or -double. Checks the B setting. Use C. +=for apidoc Am|U32|SvNIOKp|SV* sv +Returns a U32 value indicating whether the SV contains a number, integer or +double. Checks the B setting. Use C instead. =for apidoc Am|void|SvNIOK_off|SV* sv Unsets the NV/IV status of an SV. -=for apidoc Am|bool|SvOK|SV* sv -Returns a boolean indicating whether the value is an SV. It also tells +=for apidoc Am|U32|SvOK|SV* sv +Returns a U32 value indicating whether the value is an SV. It also tells whether the value is defined or not. -=for apidoc Am|bool|SvIOKp|SV* sv -Returns a boolean indicating whether the SV contains an integer. Checks -the B setting. Use C. +=for apidoc Am|U32|SvIOKp|SV* sv +Returns a U32 value indicating whether the SV contains an integer. Checks +the B setting. Use C instead. -=for apidoc Am|bool|SvNOKp|SV* sv -Returns a boolean indicating whether the SV contains a double. Checks the -B setting. Use C. +=for apidoc Am|U32|SvNOKp|SV* sv +Returns a U32 value indicating whether the SV contains a double. Checks the +B setting. Use C instead. -=for apidoc Am|bool|SvPOKp|SV* sv -Returns a boolean indicating whether the SV contains a character string. -Checks the B setting. Use C. +=for apidoc Am|U32|SvPOKp|SV* sv +Returns a U32 value indicating whether the SV contains a character string. +Checks the B setting. Use C instead. -=for apidoc Am|bool|SvIOK|SV* sv -Returns a boolean indicating whether the SV contains an integer. +=for apidoc Am|U32|SvIOK|SV* sv +Returns a U32 value indicating whether the SV contains an integer. =for apidoc Am|void|SvIOK_on|SV* sv Tells an SV that it is an integer. @@ -729,14 +632,14 @@ Tells and SV that it is an unsigned integer and disables all other OK bits. =for apidoc Am|bool|SvIOK_UV|SV* sv Returns a boolean indicating whether the SV contains an unsigned integer. -=for apidoc Am|void|SvUOK|SV* sv +=for apidoc Am|bool|SvUOK|SV* sv Returns a boolean indicating whether the SV contains an unsigned integer. =for apidoc Am|bool|SvIOK_notUV|SV* sv Returns a boolean indicating whether the SV contains a signed integer. -=for apidoc Am|bool|SvNOK|SV* sv -Returns a boolean indicating whether the SV contains a double. +=for apidoc Am|U32|SvNOK|SV* sv +Returns a U32 value indicating whether the SV contains a double. =for apidoc Am|void|SvNOK_on|SV* sv Tells an SV that it is a double. @@ -747,8 +650,8 @@ Unsets the NV status of an SV. =for apidoc Am|void|SvNOK_only|SV* sv Tells an SV that it is a double and disables all other OK bits. -=for apidoc Am|bool|SvPOK|SV* sv -Returns a boolean indicating whether the SV contains a character +=for apidoc Am|U32|SvPOK|SV* sv +Returns a U32 value indicating whether the SV contains a character string. =for apidoc Am|void|SvPOK_on|SV* sv @@ -764,13 +667,15 @@ Will also turn off the UTF-8 status. =for apidoc Am|bool|SvVOK|SV* sv Returns a boolean indicating whether the SV contains a v-string. -=for apidoc Am|bool|SvOOK|SV* sv -Returns a boolean indicating whether the SvIVX is a valid offset value for -the SvPVX. This hack is used internally to speed up removal of characters -from the beginning of a SvPV. When SvOOK is true, then the start of the -allocated string buffer is really (SvPVX - SvIVX). +=for apidoc Am|U32|SvOOK|SV* sv +Returns a U32 indicating whether the pointer to the string buffer is offset. +This hack is used internally to speed up removal of characters from the +beginning of a SvPV. When SvOOK is true, then the start of the +allocated string buffer is actually C bytes before SvPVX. +This offset used to be stored in SvIVX, but is now stored within the spare +part of the buffer. -=for apidoc Am|bool|SvROK|SV* sv +=for apidoc Am|U32|SvROK|SV* sv Tests if the SV is an RV. =for apidoc Am|void|SvROK_on|SV* sv @@ -833,7 +738,7 @@ Set the value of the RV pointer in sv to val. See C. =for apidoc Am|void|SvMAGIC_set|SV* sv|MAGIC* val Set the value of the MAGIC pointer in sv to val. See C. -=for apidoc Am|void|SvSTASH_set|SV* sv|STASH* val +=for apidoc Am|void|SvSTASH_set|SV* sv|HV* val Set the value of the STASH pointer in sv to val. See C. =for apidoc Am|void|SvCUR_set|SV* sv|STRLEN len @@ -859,19 +764,21 @@ Set the actual length of the string which is in the SV. See C. #define assert_not_glob(sv) #endif -#define SvOK(sv) (SvFLAGS(sv) & SVf_OK) +#define SvOK(sv) ((SvTYPE(sv) == SVt_BIND) \ + ? (SvFLAGS(SvRV(sv)) & SVf_OK) \ + : (SvFLAGS(sv) & SVf_OK)) #define SvOK_off(sv) (assert_not_ROK(sv) assert_not_glob(sv) \ - SvFLAGS(sv) &= ~(SVf_OK|SVf_AMAGIC| \ + SvFLAGS(sv) &= ~(SVf_OK| \ SVf_IVisUV|SVf_UTF8), \ SvOOK_off(sv)) #define SvOK_off_exc_UV(sv) (assert_not_ROK(sv) \ - SvFLAGS(sv) &= ~(SVf_OK|SVf_AMAGIC| \ + SvFLAGS(sv) &= ~(SVf_OK| \ SVf_UTF8), \ SvOOK_off(sv)) #define SvOKp(sv) (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK)) #define SvIOKp(sv) (SvFLAGS(sv) & SVp_IOK) -#define SvIOKp_on(sv) (assert_not_glob(sv) SvRELEASE_IVX(sv), \ +#define SvIOKp_on(sv) (assert_not_glob(sv) SvRELEASE_IVX_(sv) \ SvFLAGS(sv) |= SVp_IOK) #define SvNOKp(sv) (SvFLAGS(sv) & SVp_NOK) #define SvNOKp_on(sv) (assert_not_glob(sv) SvFLAGS(sv) |= SVp_NOK) @@ -880,7 +787,7 @@ Set the actual length of the string which is in the SV. See C. SvFLAGS(sv) |= SVp_POK) #define SvIOK(sv) (SvFLAGS(sv) & SVf_IOK) -#define SvIOK_on(sv) (assert_not_glob(sv) SvRELEASE_IVX(sv), \ +#define SvIOK_on(sv) (assert_not_glob(sv) SvRELEASE_IVX_(sv) \ SvFLAGS(sv) |= (SVf_IOK|SVp_IOK)) #define SvIOK_off(sv) (SvFLAGS(sv) &= ~(SVf_IOK|SVp_IOK|SVf_IVisUV)) #define SvIOK_only(sv) (SvOK_off(sv), \ @@ -906,8 +813,10 @@ Set the actual length of the string which is in the SV. See C. SvFLAGS(sv) |= (SVf_NOK|SVp_NOK)) /* -=for apidoc Am|bool|SvUTF8|SV* sv -Returns a boolean indicating whether the SV contains UTF-8 encoded data. +=for apidoc Am|U32|SvUTF8|SV* sv +Returns a U32 value indicating whether the SV contains UTF-8 encoded data. +Call this after SvPV() in case any call to string overloading updates the +internal flag. =for apidoc Am|void|SvUTF8_on|SV *sv Turn on the UTF-8 status of an SV (the data is not changed, just the flag). @@ -934,16 +843,20 @@ in gv.h: */ SvFLAGS(sv) |= (SVf_POK|SVp_POK)) #define SvPOK_off(sv) (SvFLAGS(sv) &= ~(SVf_POK|SVp_POK)) #define SvPOK_only(sv) (assert_not_ROK(sv) assert_not_glob(sv) \ - SvFLAGS(sv) &= ~(SVf_OK|SVf_AMAGIC| \ + SvFLAGS(sv) &= ~(SVf_OK| \ SVf_IVisUV|SVf_UTF8), \ SvFLAGS(sv) |= (SVf_POK|SVp_POK)) #define SvPOK_only_UTF8(sv) (assert_not_ROK(sv) assert_not_glob(sv) \ - SvFLAGS(sv) &= ~(SVf_OK|SVf_AMAGIC| \ + SvFLAGS(sv) &= ~(SVf_OK| \ SVf_IVisUV), \ SvFLAGS(sv) |= (SVf_POK|SVp_POK)) #define SvVOK(sv) (SvMAGICAL(sv) \ + && mg_find(sv,PERL_MAGIC_vstring)) +/* returns the vstring magic, if any */ +#define SvVSTRING_mg(sv) (SvMAGICAL(sv) \ ? mg_find(sv,PERL_MAGIC_vstring) : NULL) + #define SvOOK(sv) (SvFLAGS(sv) & SVf_OOK) #define SvOOK_on(sv) ((void)SvIOK_off(sv), SvFLAGS(sv) |= SVf_OOK) #define SvOOK_off(sv) ((void)(SvOOK(sv) && sv_backoff(sv))) @@ -954,7 +867,7 @@ in gv.h: */ #define SvROK(sv) (SvFLAGS(sv) & SVf_ROK) #define SvROK_on(sv) (SvFLAGS(sv) |= SVf_ROK) -#define SvROK_off(sv) (SvFLAGS(sv) &= ~(SVf_ROK|SVf_AMAGIC)) +#define SvROK_off(sv) (SvFLAGS(sv) &= ~(SVf_ROK)) #define SvMAGICAL(sv) (SvFLAGS(sv) & (SVs_GMG|SVs_SMG|SVs_RMG)) #define SvMAGICAL_on(sv) (SvFLAGS(sv) |= (SVs_GMG|SVs_SMG|SVs_RMG)) @@ -972,17 +885,36 @@ in gv.h: */ #define SvRMAGICAL_on(sv) (SvFLAGS(sv) |= SVs_RMG) #define SvRMAGICAL_off(sv) (SvFLAGS(sv) &= ~SVs_RMG) -#define SvAMAGIC(sv) (SvFLAGS(sv) & SVf_AMAGIC) -#define SvAMAGIC_on(sv) (SvFLAGS(sv) |= SVf_AMAGIC) -#define SvAMAGIC_off(sv) (SvFLAGS(sv) &= ~SVf_AMAGIC) - -#define SvGAMAGIC(sv) (SvFLAGS(sv) & (SVs_GMG|SVf_AMAGIC)) +#define SvAMAGIC(sv) (SvROK(sv) && (SvFLAGS(SvRV(sv)) & SVf_AMAGIC)) +#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) +# define SvAMAGIC_on(sv) ({ SV * const kloink = sv; \ + assert(SvROK(kloink)); \ + SvFLAGS(SvRV(kloink)) |= SVf_AMAGIC; \ + }) +# define SvAMAGIC_off(sv) ({ SV * const kloink = sv; \ + if(SvROK(kloink)) \ + SvFLAGS(SvRV(kloink)) &= ~SVf_AMAGIC;\ + }) +#else +# define SvAMAGIC_on(sv) (SvFLAGS(SvRV(sv)) |= SVf_AMAGIC) +# define SvAMAGIC_off(sv) \ + (SvROK(sv) && (SvFLAGS(SvRV(sv)) &= ~SVf_AMAGIC)) +#endif /* -#define Gv_AMG(stash) \ - (HV_AMAGICmb(stash) && \ - ((!HV_AMAGICbad(stash) && HV_AMAGIC(stash)) || Gv_AMupdate(stash))) +=for apidoc Am|char*|SvGAMAGIC|SV* sv + +Returns true if the SV has get magic or overloading. If either is true then +the scalar is active data, and has the potential to return a new value every +time it is accessed. Hence you must be careful to only read it once per user +logical operation and work with that returned value. If neither is true then +the scalar's value cannot change unless written to. + +=cut */ + +#define SvGAMAGIC(sv) (SvGMAGICAL(sv) || SvAMAGIC(sv)) + #define Gv_AMG(stash) (PL_amagic_generation && Gv_AMupdate(stash)) #define SvWEAKREF(sv) ((SvFLAGS(sv) & (SVf_ROK|SVprv_WEAKREF)) \ @@ -990,6 +922,11 @@ in gv.h: */ #define SvWEAKREF_on(sv) (SvFLAGS(sv) |= (SVf_ROK|SVprv_WEAKREF)) #define SvWEAKREF_off(sv) (SvFLAGS(sv) &= ~(SVf_ROK|SVprv_WEAKREF)) +#define SvPCS_IMPORTED(sv) ((SvFLAGS(sv) & (SVf_ROK|SVprv_PCS_IMPORTED)) \ + == (SVf_ROK|SVprv_PCS_IMPORTED)) +#define SvPCS_IMPORTED_on(sv) (SvFLAGS(sv) |= (SVf_ROK|SVprv_PCS_IMPORTED)) +#define SvPCS_IMPORTED_off(sv) (SvFLAGS(sv) &= ~(SVf_ROK|SVprv_PCS_IMPORTED)) + #define SvTHINKFIRST(sv) (SvFLAGS(sv) & SVf_THINKFIRST) #define SvPADSTALE(sv) (SvFLAGS(sv) & SVs_PADSTALE) @@ -1027,42 +964,80 @@ in gv.h: */ #define SvEVALED_on(sv) (SvFLAGS(sv) |= SVrepl_EVAL) #define SvEVALED_off(sv) (SvFLAGS(sv) &= ~SVrepl_EVAL) -#define SvTAIL(sv) (SvFLAGS(sv) & SVpbm_TAIL) +#if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) +# define SvVALID(sv) ({ const SV *const _svvalid = (const SV*)(sv); \ + if (SvFLAGS(_svvalid) & SVpbm_VALID) \ + assert(!isGV_with_GP(_svvalid)); \ + (SvFLAGS(_svvalid) & SVpbm_VALID); \ + }) +# define SvVALID_on(sv) ({ SV *const _svvalid = MUTABLE_SV(sv); \ + assert(!isGV_with_GP(_svvalid)); \ + (SvFLAGS(_svvalid) |= SVpbm_VALID); \ + }) +# define SvVALID_off(sv) ({ SV *const _svvalid = MUTABLE_SV(sv); \ + assert(!isGV_with_GP(_svvalid)); \ + (SvFLAGS(_svvalid) &= ~SVpbm_VALID); \ + }) + +# define SvTAIL(sv) ({ const SV *const _svtail = (const SV *)(sv); \ + assert(SvTYPE(_svtail) != SVt_PVAV); \ + assert(SvTYPE(_svtail) != SVt_PVHV); \ + (SvFLAGS(sv) & (SVpbm_TAIL|SVpbm_VALID)) \ + == (SVpbm_TAIL|SVpbm_VALID); \ + }) +#else +# define SvVALID(sv) (SvFLAGS(sv) & SVpbm_VALID) +# define SvVALID_on(sv) (SvFLAGS(sv) |= SVpbm_VALID) +# define SvVALID_off(sv) (SvFLAGS(sv) &= ~SVpbm_VALID) +# define SvTAIL(sv) ((SvFLAGS(sv) & (SVpbm_TAIL|SVpbm_VALID)) \ + == (SVpbm_TAIL|SVpbm_VALID)) + +#endif #define SvTAIL_on(sv) (SvFLAGS(sv) |= SVpbm_TAIL) #define SvTAIL_off(sv) (SvFLAGS(sv) &= ~SVpbm_TAIL) -#define SvVALID(sv) (SvFLAGS(sv) & SVpbm_VALID) -#define SvVALID_on(sv) (SvFLAGS(sv) |= SVpbm_VALID) -#define SvVALID_off(sv) (SvFLAGS(sv) &= ~SVpbm_VALID) - -#ifdef USE_ITHREADS -/* The following uses the FAKE flag to show that a regex pointer is infact - its own offset in the regexpad for ithreads */ -#define SvREPADTMP(sv) (SvFLAGS(sv) & SVf_FAKE) -#define SvREPADTMP_on(sv) (SvFLAGS(sv) |= SVf_FAKE) -#define SvREPADTMP_off(sv) (SvFLAGS(sv) &= ~SVf_FAKE) -#endif #define SvPAD_TYPED(sv) \ ((SvFLAGS(sv) & (SVpad_NAME|SVpad_TYPED)) == (SVpad_NAME|SVpad_TYPED)) -#define SvPAD_TYPED_on(sv) (SvFLAGS(sv) |= SVpad_NAME|SVpad_TYPED) #define SvPAD_OUR(sv) \ ((SvFLAGS(sv) & (SVpad_NAME|SVpad_OUR)) == (SVpad_NAME|SVpad_OUR)) -#define SvPAD_OUR_on(sv) (SvFLAGS(sv) |= SVpad_NAME|SVpad_OUR) -#define OURSTASH(sv) \ +#define SvPAD_STATE(sv) \ + ((SvFLAGS(sv) & (SVpad_NAME|SVpad_STATE)) == (SVpad_NAME|SVpad_STATE)) + +#if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) +# define SvPAD_TYPED_on(sv) ({ \ + SV *const _svpad = MUTABLE_SV(sv); \ + assert(SvTYPE(_svpad) == SVt_PVMG); \ + (SvFLAGS(_svpad) |= SVpad_NAME|SVpad_TYPED); \ + }) +#define SvPAD_OUR_on(sv) ({ \ + SV *const _svpad = MUTABLE_SV(sv); \ + assert(SvTYPE(_svpad) == SVt_PVMG); \ + (SvFLAGS(_svpad) |= SVpad_NAME|SVpad_OUR); \ + }) +#define SvPAD_STATE_on(sv) ({ \ + SV *const _svpad = MUTABLE_SV(sv); \ + assert(SvTYPE(_svpad) == SVt_PVNV || SvTYPE(_svpad) == SVt_PVMG); \ + (SvFLAGS(_svpad) |= SVpad_NAME|SVpad_STATE); \ + }) +#else +# define SvPAD_TYPED_on(sv) (SvFLAGS(sv) |= SVpad_NAME|SVpad_TYPED) +# define SvPAD_OUR_on(sv) (SvFLAGS(sv) |= SVpad_NAME|SVpad_OUR) +# define SvPAD_STATE_on(sv) (SvFLAGS(sv) |= SVpad_NAME|SVpad_STATE) +#endif + +#define SvOURSTASH(sv) \ (SvPAD_OUR(sv) ? ((XPVMG*) SvANY(sv))->xmg_u.xmg_ourstash : NULL) -#define OURSTASH_set(sv, st) \ +#define SvOURSTASH_set(sv, st) \ STMT_START { \ assert(SvTYPE(sv) == SVt_PVMG); \ ((XPVMG*) SvANY(sv))->xmg_u.xmg_ourstash = st; \ } STMT_END #ifdef PERL_DEBUG_COW -#define SvRV(sv) (0 + (sv)->sv_u.svu_rv) #else -#define SvRV(sv) ((sv)->sv_u.svu_rv) #endif #define SvRVx(sv) SvRV(sv) @@ -1072,6 +1047,8 @@ in gv.h: */ # define SvIVX(sv) (0 + ((XPVIV*) SvANY(sv))->xiv_iv) # define SvUVX(sv) (0 + ((XPVUV*) SvANY(sv))->xuv_uv) # define SvNVX(sv) (-0.0 + ((XPVNV*) SvANY(sv))->xnv_u.xnv_nv) +# define SvRV(sv) (0 + (sv)->sv_u.svu_rv) +# define SvRV_const(sv) (0 + (sv)->sv_u.svu_rv) /* Don't test the core XS code yet. */ # if defined (PERL_CORE) && PERL_DEBUG_COW > 1 # define SvPVX(sv) (0 + (assert(!SvREADONLY(sv)), (sv)->sv_u.svu_pv)) @@ -1096,57 +1073,83 @@ in gv.h: */ # if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) /* These get expanded inside other macros that already use a variable _sv */ # define SvPVX(sv) \ - (*({ SV *const _svi = (SV *) sv; \ - assert(SvTYPE(_svi) >= SVt_PV); \ - assert(SvTYPE(_svi) != SVt_PVAV); \ - assert(SvTYPE(_svi) != SVt_PVHV); \ - assert(!isGV_with_GP(_svi)); \ - &((_svi)->sv_u.svu_pv); \ + (*({ SV *const _svpvx = MUTABLE_SV(sv); \ + assert(SvTYPE(_svpvx) >= SVt_PV); \ + assert(SvTYPE(_svpvx) != SVt_PVAV); \ + assert(SvTYPE(_svpvx) != SVt_PVHV); \ + assert(!isGV_with_GP(_svpvx)); \ + &((_svpvx)->sv_u.svu_pv); \ })) # define SvCUR(sv) \ - (*({ SV *const _svi = (SV *) sv; \ - assert(SvTYPE(_svi) >= SVt_PV); \ - assert(SvTYPE(_svi) != SVt_PVAV); \ - assert(SvTYPE(_svi) != SVt_PVHV); \ - assert(!isGV_with_GP(_svi)); \ - &(((XPV*) SvANY(_svi))->xpv_cur); \ + (*({ const SV *const _svcur = (const SV *)(sv); \ + assert(SvTYPE(_svcur) >= SVt_PV); \ + assert(SvTYPE(_svcur) != SVt_PVAV); \ + assert(SvTYPE(_svcur) != SVt_PVHV); \ + assert(!isGV_with_GP(_svcur)); \ + &(((XPV*) MUTABLE_PTR(SvANY(_svcur)))->xpv_cur); \ })) # define SvIVX(sv) \ - (*({ SV *const _svi = (SV *) sv; \ - assert(SvTYPE(_svi) == SVt_IV || SvTYPE(_svi) >= SVt_PVIV); \ - assert(SvTYPE(_svi) != SVt_PVAV); \ - assert(SvTYPE(_svi) != SVt_PVHV); \ - assert(SvTYPE(_svi) != SVt_PVCV); \ - assert(!isGV_with_GP(_svi)); \ - &(((XPVIV*) SvANY(_svi))->xiv_iv); \ + (*({ const SV *const _svivx = (const SV *)(sv); \ + assert(SvTYPE(_svivx) == SVt_IV || SvTYPE(_svivx) >= SVt_PVIV); \ + assert(SvTYPE(_svivx) != SVt_PVAV); \ + assert(SvTYPE(_svivx) != SVt_PVHV); \ + assert(SvTYPE(_svivx) != SVt_PVCV); \ + assert(SvTYPE(_svivx) != SVt_PVFM); \ + assert(!isGV_with_GP(_svivx)); \ + &(((XPVIV*) MUTABLE_PTR(SvANY(_svivx)))->xiv_iv); \ })) # define SvUVX(sv) \ - (*({ SV *const _svi = (SV *) sv; \ - assert(SvTYPE(_svi) == SVt_IV || SvTYPE(_svi) >= SVt_PVIV); \ - assert(SvTYPE(_svi) != SVt_PVAV); \ - assert(SvTYPE(_svi) != SVt_PVHV); \ - assert(SvTYPE(_svi) != SVt_PVCV); \ - assert(!isGV_with_GP(_svi)); \ - &(((XPVUV*) SvANY(_svi))->xuv_uv); \ + (*({ const SV *const _svuvx = (const SV *)(sv); \ + assert(SvTYPE(_svuvx) == SVt_IV || SvTYPE(_svuvx) >= SVt_PVIV); \ + assert(SvTYPE(_svuvx) != SVt_PVAV); \ + assert(SvTYPE(_svuvx) != SVt_PVHV); \ + assert(SvTYPE(_svuvx) != SVt_PVCV); \ + assert(SvTYPE(_svuvx) != SVt_PVFM); \ + assert(!isGV_with_GP(_svuvx)); \ + &(((XPVUV*) MUTABLE_PTR(SvANY(_svuvx)))->xuv_uv); \ })) # define SvNVX(sv) \ - (*({ SV *const _svi = (SV *) sv; \ - assert(SvTYPE(_svi) == SVt_NV || SvTYPE(_svi) >= SVt_PVNV); \ - assert(SvTYPE(_svi) != SVt_PVAV); \ - assert(SvTYPE(_svi) != SVt_PVHV); \ - assert(SvTYPE(_svi) != SVt_PVFM); \ - assert(!isGV_with_GP(_svi)); \ - &(((XPVNV*) SvANY(_svi))->xnv_u.xnv_nv); \ + (*({ const SV *const _svnvx = (const SV *)(sv); \ + assert(SvTYPE(_svnvx) == SVt_NV || SvTYPE(_svnvx) >= SVt_PVNV); \ + assert(SvTYPE(_svnvx) != SVt_PVAV); \ + assert(SvTYPE(_svnvx) != SVt_PVHV); \ + assert(SvTYPE(_svnvx) != SVt_PVCV); \ + assert(SvTYPE(_svnvx) != SVt_PVFM); \ + assert(SvTYPE(_svnvx) != SVt_PVIO); \ + assert(!isGV_with_GP(_svnvx)); \ + &(((XPVNV*) MUTABLE_PTR(SvANY(_svnvx)))->xnv_u.xnv_nv); \ + })) +# define SvRV(sv) \ + (*({ SV *const _svrv = MUTABLE_SV(sv); \ + assert(SvTYPE(_svrv) >= SVt_PV || SvTYPE(_svrv) == SVt_IV); \ + assert(SvTYPE(_svrv) != SVt_PVAV); \ + assert(SvTYPE(_svrv) != SVt_PVHV); \ + assert(SvTYPE(_svrv) != SVt_PVCV); \ + assert(SvTYPE(_svrv) != SVt_PVFM); \ + assert(!isGV_with_GP(_svrv)); \ + &((_svrv)->sv_u.svu_rv); \ })) +# define SvRV_const(sv) \ + ({ const SV *const _svrv = (const SV *)(sv); \ + assert(SvTYPE(_svrv) >= SVt_PV || SvTYPE(_svrv) == SVt_IV); \ + assert(SvTYPE(_svrv) != SVt_PVAV); \ + assert(SvTYPE(_svrv) != SVt_PVHV); \ + assert(SvTYPE(_svrv) != SVt_PVCV); \ + assert(SvTYPE(_svrv) != SVt_PVFM); \ + assert(!isGV_with_GP(_svrv)); \ + (_svrv)->sv_u.svu_rv; \ + }) # define SvMAGIC(sv) \ - (*({ SV *const _svi = (SV *) sv; \ - assert(SvTYPE(_svi) >= SVt_PVMG); \ - &(((XPVMG*) SvANY(_svi))->xmg_u.xmg_magic); \ + (*({ const SV *const _svmagic = (const SV *)(sv); \ + assert(SvTYPE(_svmagic) >= SVt_PVMG); \ + if(SvTYPE(_svmagic) == SVt_PVMG) \ + assert(!SvPAD_OUR(_svmagic)); \ + &(((XPVMG*) MUTABLE_PTR(SvANY(_svmagic)))->xmg_u.xmg_magic); \ })) # define SvSTASH(sv) \ - (*({ SV *const _svi = (SV *) sv; \ - assert(SvTYPE(_svi) >= SVt_PVMG); \ - &(((XPVMG*) SvANY(_svi))->xmg_stash); \ + (*({ const SV *const _svstash = (const SV *)(sv); \ + assert(SvTYPE(_svstash) >= SVt_PVMG); \ + &(((XPVMG*) MUTABLE_PTR(SvANY(_svstash)))->xmg_stash); \ })) # else # define SvPVX(sv) ((sv)->sv_u.svu_pv) @@ -1154,6 +1157,8 @@ in gv.h: */ # define SvIVX(sv) ((XPVIV*) SvANY(sv))->xiv_iv # define SvUVX(sv) ((XPVUV*) SvANY(sv))->xuv_uv # define SvNVX(sv) ((XPVNV*) SvANY(sv))->xnv_u.xnv_nv +# define SvRV(sv) ((sv)->sv_u.svu_rv) +# define SvRV_const(sv) (0 + (sv)->sv_u.svu_rv) # define SvMAGIC(sv) ((XPVMG*) SvANY(sv))->xmg_u.xmg_magic # define SvSTASH(sv) ((XPVMG*) SvANY(sv))->xmg_stash # endif @@ -1187,23 +1192,37 @@ in gv.h: */ (void) SvIV(sv); } STMT_END #define SvIV_set(sv, val) \ STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \ + assert(SvTYPE(sv) != SVt_PVAV); \ + assert(SvTYPE(sv) != SVt_PVHV); \ + assert(SvTYPE(sv) != SVt_PVCV); \ assert(!isGV_with_GP(sv)); \ (((XPVIV*) SvANY(sv))->xiv_iv = (val)); } STMT_END #define SvNV_set(sv, val) \ STMT_START { assert(SvTYPE(sv) == SVt_NV || SvTYPE(sv) >= SVt_PVNV); \ assert(SvTYPE(sv) != SVt_PVAV); assert(SvTYPE(sv) != SVt_PVHV); \ + assert(SvTYPE(sv) != SVt_PVCV); assert(SvTYPE(sv) != SVt_PVFM); \ + assert(SvTYPE(sv) != SVt_PVIO); \ assert(!isGV_with_GP(sv)); \ (((XPVNV*)SvANY(sv))->xnv_u.xnv_nv = (val)); } STMT_END #define SvPV_set(sv, val) \ STMT_START { assert(SvTYPE(sv) >= SVt_PV); \ + assert(SvTYPE(sv) != SVt_PVAV); \ + assert(SvTYPE(sv) != SVt_PVHV); \ assert(!isGV_with_GP(sv)); \ ((sv)->sv_u.svu_pv = (val)); } STMT_END #define SvUV_set(sv, val) \ STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \ + assert(SvTYPE(sv) != SVt_PVAV); \ + assert(SvTYPE(sv) != SVt_PVHV); \ + assert(SvTYPE(sv) != SVt_PVCV); \ assert(!isGV_with_GP(sv)); \ (((XPVUV*)SvANY(sv))->xuv_uv = (val)); } STMT_END #define SvRV_set(sv, val) \ - STMT_START { assert(SvTYPE(sv) >= SVt_RV); \ + STMT_START { assert(SvTYPE(sv) >= SVt_PV || SvTYPE(sv) == SVt_IV); \ + assert(SvTYPE(sv) != SVt_PVAV); \ + assert(SvTYPE(sv) != SVt_PVHV); \ + assert(SvTYPE(sv) != SVt_PVCV); \ + assert(SvTYPE(sv) != SVt_PVFM); \ assert(!isGV_with_GP(sv)); \ ((sv)->sv_u.svu_rv = (val)); } STMT_END #define SvMAGIC_set(sv, val) \ @@ -1214,15 +1233,19 @@ in gv.h: */ (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END #define SvCUR_set(sv, val) \ STMT_START { assert(SvTYPE(sv) >= SVt_PV); \ + assert(SvTYPE(sv) != SVt_PVAV); \ + assert(SvTYPE(sv) != SVt_PVHV); \ assert(!isGV_with_GP(sv)); \ (((XPV*) SvANY(sv))->xpv_cur = (val)); } STMT_END #define SvLEN_set(sv, val) \ STMT_START { assert(SvTYPE(sv) >= SVt_PV); \ + assert(SvTYPE(sv) != SVt_PVAV); \ + assert(SvTYPE(sv) != SVt_PVHV); \ assert(!isGV_with_GP(sv)); \ (((XPV*) SvANY(sv))->xpv_len = (val)); } STMT_END #define SvEND_set(sv, val) \ STMT_START { assert(SvTYPE(sv) >= SVt_PV); \ - (SvCUR(sv) = (val) - SvPVX(sv)); } STMT_END + SvCUR_set(sv, (val) - SvPVX(sv)); } STMT_END #define SvPV_renew(sv,n) \ STMT_START { SvLEN_set(sv, n); \ @@ -1240,19 +1263,72 @@ in gv.h: */ STMT_START { \ assert(SvTYPE(sv) >= SVt_PV); \ if (SvLEN(sv)) { \ + assert(!SvROK(sv)); \ if(SvOOK(sv)) { \ - SvPV_set(sv, SvPVX_mutable(sv) - SvIVX(sv)); \ + STRLEN zok; \ + SvOOK_offset(sv, zok); \ + SvPV_set(sv, SvPVX_mutable(sv) - zok); \ SvFLAGS(sv) &= ~SVf_OOK; \ } \ Safefree(SvPVX(sv)); \ } \ } STMT_END -#define BmRARE(sv) ((XPVBM*) SvANY(sv))->xbm_rare -#define BmUSEFUL(sv) ((XPVBM*) SvANY(sv))->xbm_useful -#define BmPREVIOUS(sv) ((XPVBM*) SvANY(sv))->xbm_previous +#ifdef PERL_CORE +/* Code that crops up in three places to take a scalar and ready it to hold + a reference */ +# define prepare_SV_for_RV(sv) \ + STMT_START { \ + if (SvTYPE(sv) < SVt_PV && SvTYPE(sv) != SVt_IV) \ + sv_upgrade(sv, SVt_IV); \ + else if (SvTYPE(sv) >= SVt_PV) { \ + SvPV_free(sv); \ + SvLEN_set(sv, 0); \ + SvCUR_set(sv, 0); \ + } \ + } STMT_END +#endif + +#define PERL_FBM_TABLE_OFFSET 1 /* Number of bytes between EOS and table */ + +/* SvPOKp not SvPOK in the assertion because the string can be tainted! eg + perl -T -e '/$^X/' +*/ +#if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) +# define BmFLAGS(sv) \ + (*({ SV *const _bmflags = MUTABLE_SV(sv); \ + assert(SvTYPE(_bmflags) == SVt_PVGV); \ + assert(SvVALID(_bmflags)); \ + &(((XPVGV*) SvANY(_bmflags))->xnv_u.xbm_s.xbm_flags); \ + })) +# define BmRARE(sv) \ + (*({ SV *const _bmrare = MUTABLE_SV(sv); \ + assert(SvTYPE(_bmrare) == SVt_PVGV); \ + assert(SvVALID(_bmrare)); \ + &(((XPVGV*) SvANY(_bmrare))->xnv_u.xbm_s.xbm_rare); \ + })) +# define BmUSEFUL(sv) \ + (*({ SV *const _bmuseful = MUTABLE_SV(sv); \ + assert(SvTYPE(_bmuseful) == SVt_PVGV); \ + assert(SvVALID(_bmuseful)); \ + assert(!SvIOK(_bmuseful)); \ + &(((XPVGV*) SvANY(_bmuseful))->xiv_u.xivu_i32); \ + })) +# define BmPREVIOUS(sv) \ + (*({ SV *const _bmprevious = MUTABLE_SV(sv); \ + assert(SvTYPE(_bmprevious) == SVt_PVGV); \ + assert(SvVALID(_bmprevious)); \ + &(((XPVGV*) SvANY(_bmprevious))->xnv_u.xbm_s.xbm_previous); \ + })) +#else +# define BmFLAGS(sv) ((XPVGV*) SvANY(sv))->xnv_u.xbm_s.xbm_flags +# define BmRARE(sv) ((XPVGV*) SvANY(sv))->xnv_u.xbm_s.xbm_rare +# define BmUSEFUL(sv) ((XPVGV*) SvANY(sv))->xiv_u.xivu_i32 +# define BmPREVIOUS(sv) ((XPVGV*) SvANY(sv))->xnv_u.xbm_s.xbm_previous + +#endif -#define FmLINES(sv) ((XPVFM*) SvANY(sv))->xfm_lines +#define FmLINES(sv) ((XPVFM*) SvANY(sv))->xiv_u.xivu_iv #define LvTYPE(sv) ((XPVLV*) SvANY(sv))->xlv_type #define LvTARG(sv) ((XPVLV*) SvANY(sv))->xlv_targ @@ -1273,7 +1349,6 @@ in gv.h: */ #define IoFMT_GV(sv) ((XPVIO*) SvANY(sv))->xio_fmt_gv #define IoBOTTOM_NAME(sv)((XPVIO*) SvANY(sv))->xio_bottom_name #define IoBOTTOM_GV(sv) ((XPVIO*) SvANY(sv))->xio_bottom_gv -#define IoSUBPROCESS(sv)((XPVIO*) SvANY(sv))->xio_subprocess #define IoTYPE(sv) ((XPVIO*) SvANY(sv))->xio_type #define IoFLAGS(sv) ((XPVIO*) SvANY(sv))->xio_flags @@ -1343,7 +1418,9 @@ stringified version becoming C. Handles 'get' magic. See also C for a version which guarantees to evaluate sv only once. =for apidoc Am|char*|SvPVx|SV* sv|STRLEN len -A version of C which guarantees to evaluate sv only once. +A version of C which guarantees to evaluate C only once. +Only use this if C is an expression with side effects, otherwise use the +more efficient C. =for apidoc Am|char*|SvPV_nomg|SV* sv|STRLEN len Like C but doesn't process magic. @@ -1354,7 +1431,7 @@ the SV if the SV does not contain a string. The SV may cache the stringified form becoming C. Handles 'get' magic. =for apidoc Am|IV|SvIV|SV* sv -Coerces the given SV to an integer and returns it. See C for a +Coerces the given SV to an integer and returns it. See C for a version which guarantees to evaluate sv only once. =for apidoc Am|IV|SvIV_nomg|SV* sv @@ -1362,15 +1439,17 @@ Like C but doesn't process magic. =for apidoc Am|IV|SvIVx|SV* sv Coerces the given SV to an integer and returns it. Guarantees to evaluate -sv only once. Use the more efficient C otherwise. +C only once. Only use this if C is an expression with side effects, +otherwise use the more efficient C. =for apidoc Am|NV|SvNV|SV* sv -Coerce the given SV to a double and return it. See C for a version +Coerce the given SV to a double and return it. See C for a version which guarantees to evaluate sv only once. =for apidoc Am|NV|SvNVx|SV* sv Coerces the given SV to a double and returns it. Guarantees to evaluate -sv only once. Use the more efficient C otherwise. +C only once. Only use this if C is an expression with side effects, +otherwise use the more efficient C. =for apidoc Am|UV|SvUV|SV* sv Coerces the given SV to an unsigned integer and returns it. See C @@ -1381,7 +1460,8 @@ Like C but doesn't process magic. =for apidoc Am|UV|SvUVx|SV* sv Coerces the given SV to an unsigned integer and returns it. Guarantees to -evaluate sv only once. Use the more efficient C otherwise. +C only once. Only use this if C is an expression with side effects, +otherwise use the more efficient C. =for apidoc Am|bool|SvTRUE|SV* sv Returns a boolean indicating whether Perl would evaluate the SV as true or @@ -1443,6 +1523,10 @@ Like C but doesn't process magic. =for apidoc Am|void|sv_catsv_nomg|SV* dsv|SV* ssv Like C but doesn't process magic. +=for apidoc Amdb|STRLEN|sv_utf8_upgrade_nomg|NN SV *sv + +Like sv_utf8_upgrade, but doesn't do magic on C + =cut */ @@ -1513,7 +1597,7 @@ Like C but doesn't process magic. ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvutf8(sv, &lp)) #define SvPVutf8_force(sv, lp) \ - ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == (SVf_POK|SVf_UTF8) \ + ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_THINKFIRST)) == (SVf_POK|SVf_UTF8) \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvutf8n_force(sv, &lp)) @@ -1548,9 +1632,9 @@ Like C but doesn't process magic. #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) -# define SvIVx(sv) ({SV *_sv = (SV*)(sv); SvIV(_sv); }) -# define SvUVx(sv) ({SV *_sv = (SV*)(sv); SvUV(_sv); }) -# define SvNVx(sv) ({SV *_sv = (SV*)(sv); SvNV(_sv); }) +# define SvIVx(sv) ({SV *_sv = MUTABLE_SV(sv); SvIV(_sv); }) +# define SvUVx(sv) ({SV *_sv = MUTABLE_SV(sv); SvUV(_sv); }) +# define SvNVx(sv) ({SV *_sv = MUTABLE_SV(sv); SvNV(_sv); }) # define SvPVx(sv, lp) ({SV *_sv = (sv); SvPV(_sv, lp); }) # define SvPVx_const(sv, lp) ({SV *_sv = (sv); SvPV_const(_sv, lp); }) # define SvPVx_nolen(sv) ({SV *_sv = (sv); SvPV_nolen(_sv); }) @@ -1626,9 +1710,35 @@ Like C but doesn't process magic. #define SV_CONST_RETURN 32 #define SV_MUTABLE_RETURN 64 #define SV_SMAGIC 128 +#define SV_HAS_TRAILING_NUL 256 +#define SV_COW_SHARED_HASH_KEYS 512 +/* This one is only enabled for PERL_OLD_COPY_ON_WRITE */ +#define SV_COW_OTHER_PVS 1024 +/* Make sv_2pv_flags return NULL if something is undefined. */ +#define SV_UNDEF_RETURNS_NULL 2048 +/* Tell sv_utf8_upgrade() to not check to see if an upgrade is really needed. + * This is used when the caller has already determined it is, and avoids + * redundant work */ +#define SV_FORCE_UTF8_UPGRADE 4096 + +/* The core is safe for this COW optimisation. XS code on CPAN may not be. + So only default to doing the COW setup if we're in the core. + */ +#ifdef PERL_CORE +# ifndef SV_DO_COW_SVSETSV +# define SV_DO_COW_SVSETSV SV_COW_SHARED_HASH_KEYS|SV_COW_OTHER_PVS +# endif +#endif + +#ifndef SV_DO_COW_SVSETSV +# define SV_DO_COW_SVSETSV 0 +#endif + #define sv_unref(sv) sv_unref_flags(sv, 0) #define sv_force_normal(sv) sv_force_normal_flags(sv, 0) +#define sv_usepvn(sv, p, l) sv_usepvn_flags(sv, p, l, 0) +#define sv_usepvn_mg(sv, p, l) sv_usepvn_flags(sv, p, l, SV_SMAGIC) /* We are about to replace the SV's current value. So if it's copy on write we need to normalise it. Use the SV_COW_DROP_PV flag hint to say that @@ -1640,16 +1750,22 @@ Like C but doesn't process magic. sv_force_normal_flags(sv, SV_COW_DROP_PV) #ifdef PERL_OLD_COPY_ON_WRITE -# define SvRELEASE_IVX(sv) ((void)((SvFLAGS(sv) & (SVf_OOK|SVf_READONLY|SVf_FAKE)) \ - && Perl_sv_release_IVX(aTHX_ sv))) +#define SvRELEASE_IVX(sv) \ + ((SvIsCOW(sv) ? sv_force_normal_flags(sv, 0) : (void) 0), 0) # define SvIsCOW_normal(sv) (SvIsCOW(sv) && SvLEN(sv)) +# define SvRELEASE_IVX_(sv) SvRELEASE_IVX(sv), #else -# define SvRELEASE_IVX(sv) SvOOK_off(sv) +# define SvRELEASE_IVX(sv) 0 +/* This little game brought to you by the need to shut this warning up: +mg.c: In function `Perl_magic_get': +mg.c:1024: warning: left-hand operand of comma expression has no effect +*/ +# define SvRELEASE_IVX_(sv) /**/ #endif /* PERL_OLD_COPY_ON_WRITE */ #define CAN_COW_MASK (SVs_OBJECT|SVs_GMG|SVs_SMG|SVs_RMG|SVf_IOK|SVf_NOK| \ SVf_POK|SVf_ROK|SVp_IOK|SVp_NOK|SVp_POK|SVf_FAKE| \ - SVf_OOK|SVf_BREAK|SVf_READONLY|SVf_AMAGIC) + SVf_OOK|SVf_BREAK|SVf_READONLY) #define CAN_COW_FLAGS (SVp_POK|SVf_POK) #define SV_CHECK_THINKFIRST(sv) if (SvTHINKFIRST(sv)) \ @@ -1663,10 +1779,12 @@ Like C but doesn't process magic. #define sv_pvbyte(sv) SvPVbyte_nolen(sv) #define sv_pvn_force_nomg(sv, lp) sv_pvn_force_flags(sv, lp, 0) +#define sv_utf8_upgrade_flags(sv, flags) sv_utf8_upgrade_flags_grow(sv, flags, 0) #define sv_utf8_upgrade_nomg(sv) sv_utf8_upgrade_flags(sv, 0) #define sv_catpvn_nomg(dsv, sstr, slen) sv_catpvn_flags(dsv, sstr, slen, 0) -#define sv_setsv(dsv, ssv) sv_setsv_flags(dsv, ssv, SV_GMAGIC) -#define sv_setsv_nomg(dsv, ssv) sv_setsv_flags(dsv, ssv, 0) +#define sv_setsv(dsv, ssv) \ + sv_setsv_flags(dsv, ssv, SV_GMAGIC|SV_DO_COW_SVSETSV) +#define sv_setsv_nomg(dsv, ssv) sv_setsv_flags(dsv, ssv, SV_DO_COW_SVSETSV) #define sv_catsv(dsv, ssv) sv_catsv_flags(dsv, ssv, SV_GMAGIC) #define sv_catsv_nomg(dsv, ssv) sv_catsv_flags(dsv, ssv, 0) #define sv_catsv_mg(dsv, ssv) sv_catsv_flags(dsv, ssv, SV_GMAGIC|SV_SMAGIC) @@ -1682,12 +1800,15 @@ Like C but doesn't process magic. #define sv_utf8_upgrade(sv) sv_utf8_upgrade_flags(sv, SV_GMAGIC) #define sv_2iv(sv) sv_2iv_flags(sv, SV_GMAGIC) #define sv_2uv(sv) sv_2uv_flags(sv, SV_GMAGIC) +#define sv_insert(bigstr, offset, len, little, littlelen) \ + Perl_sv_insert_flags(aTHX_ (bigstr),(offset), (len), (little), \ + (littlelen), SV_GMAGIC) /* Should be named SvCatPVN_utf8_upgrade? */ #define sv_catpvn_utf8_upgrade(dsv, sstr, slen, nsv) \ STMT_START { \ if (!(nsv)) \ - nsv = sv_2mortal(newSVpvn(sstr, slen)); \ + nsv = newSVpvn_flags(sstr, slen, SVs_TEMP); \ else \ sv_setpvn(nsv, sstr, slen); \ SvUTF8_off(nsv); \ @@ -1759,6 +1880,7 @@ Returns a pointer to the character buffer. #define SvSHARE(sv) CALL_FPTR(PL_sharehook)(aTHX_ sv) #define SvLOCK(sv) CALL_FPTR(PL_lockhook)(aTHX_ sv) #define SvUNLOCK(sv) CALL_FPTR(PL_unlockhook)(aTHX_ sv) +#define SvDESTROYABLE(sv) CALL_FPTR(PL_destroyhook)(aTHX_ sv) #define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END #define SvSETMAGIC(x) STMT_START { if (SvSMAGICAL(x)) mg_set(x); } STMT_END @@ -1773,7 +1895,7 @@ Returns a pointer to the character buffer. #define SvSetSV_nosteal_and(dst,src,finally) \ STMT_START { \ if ((dst) != (src)) { \ - sv_setsv_flags(dst, src, SV_GMAGIC | SV_NOSTEAL); \ + sv_setsv_flags(dst, src, SV_GMAGIC | SV_NOSTEAL | SV_DO_COW_SVSETSV); \ finally; \ } \ } STMT_END @@ -1803,8 +1925,21 @@ Returns a pointer to the character buffer. /* If I give every macro argument a different name, then there won't be bugs where nested macros get confused. Been there, done that. */ #define isGV_with_GP(pwadak) \ - (((SvFLAGS(pwadak) & (SVp_POK|SVp_SCREAM)) == SVp_SCREAM) \ + (((SvFLAGS(pwadak) & (SVp_POK|SVpgv_GP)) == SVpgv_GP) \ && (SvTYPE(pwadak) == SVt_PVGV || SvTYPE(pwadak) == SVt_PVLV)) +#define isGV_with_GP_on(sv) STMT_START { \ + assert (SvTYPE(sv) == SVt_PVGV || SvTYPE(sv) == SVt_PVLV); \ + assert (!SvPOKp(sv)); \ + assert (!SvIOKp(sv)); \ + (SvFLAGS(sv) |= SVpgv_GP); \ + } STMT_END +#define isGV_with_GP_off(sv) STMT_START { \ + assert (SvTYPE(sv) == SVt_PVGV || SvTYPE(sv) == SVt_PVLV); \ + assert (!SvPOKp(sv)); \ + assert (!SvIOKp(sv)); \ + (SvFLAGS(sv) &= ~SVpgv_GP); \ + } STMT_END + #define SvGROW(sv,len) (SvLEN(sv) < (len) ? sv_grow(sv,len) : SvPVX(sv)) #define SvGROW_mutable(sv,len) \ @@ -1823,6 +1958,71 @@ struct clone_params { }; /* +=for apidoc Am|SV*|newSVpvn_utf8|NULLOK const char* s|STRLEN len|U32 utf8 + +Creates a new SV and copies a string into it. If utf8 is true, calls +C on the new SV. Implemented as a wrapper around C. + +=cut +*/ + +#define newSVpvn_utf8(s, len, u) newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0) + +/* +=for apidoc Am|void|SvOOK_offset|NN SV*sv|STRLEN len + +Reads into I the offset from SvPVX back to the true start of the +allocated buffer, which will be non-zero if C has been used to +efficiently remove characters from start of the buffer. Implemented as a +macro, which takes the address of I, which must be of type C. +Evaluates I more than once. Sets I to 0 if C is false. + +=cut +*/ + +#ifdef DEBUGGING +/* Does the bot know something I don't? +10:28 <@Nicholas> metabatman +10:28 <+meta> Nicholas: crash +*/ +# define SvOOK_offset(sv, offset) STMT_START { \ + assert(sizeof(offset) == sizeof(STRLEN)); \ + if (SvOOK(sv)) { \ + const U8 *crash = (U8*)SvPVX_const(sv); \ + offset = *--crash; \ + if (!offset) { \ + crash -= sizeof(STRLEN); \ + Copy(crash, (U8 *)&offset, sizeof(STRLEN), U8); \ + } \ + { \ + /* Validate the preceding buffer's sentinels to \ + verify that no-one is using it. */ \ + const U8 *const bonk = (U8 *) SvPVX_const(sv) - offset; \ + while (crash > bonk) { \ + --crash; \ + assert (*crash == (U8)PTR2UV(crash)); \ + } \ + } \ + } else { \ + offset = 0; \ + } \ + } STMT_END +#else + /* This is the same code, but avoids using any temporary variables: */ +# define SvOOK_offset(sv, offset) STMT_START { \ + assert(sizeof(offset) == sizeof(STRLEN)); \ + if (SvOOK(sv)) { \ + offset = ((U8*)SvPVX_const(sv))[-1]; \ + if (!offset) { \ + Copy(SvPVX_const(sv) - 1 - sizeof(STRLEN), \ + (U8 *)&offset, sizeof(STRLEN), U8); \ + } \ + } else { \ + offset = 0; \ + } \ + } STMT_END +#endif +/* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4