Mercurial > repo
comparison perl-5.22.2/cv.h @ 8045:a16537d2fe07
<xfix> tar xf perl-5.22.2.tar.gz # Ah, whatever, I\'m doing it anyway
author | HackBot |
---|---|
date | Sat, 14 May 2016 14:54:38 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
8044:711c038a7dce | 8045:a16537d2fe07 |
---|---|
1 /* cv.h | |
2 * | |
3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, | |
4 * 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others | |
5 * | |
6 * You may distribute under the terms of either the GNU General Public | |
7 * License or the Artistic License, as specified in the README file. | |
8 * | |
9 */ | |
10 | |
11 /* This structure must match the beginning of XPVFM in sv.h */ | |
12 | |
13 struct xpvcv { | |
14 _XPV_HEAD; | |
15 _XPVCV_COMMON; | |
16 }; | |
17 | |
18 /* | |
19 =head1 Handy Values | |
20 | |
21 =for apidoc AmU||Nullcv | |
22 Null CV pointer. | |
23 | |
24 (deprecated - use C<(CV *)NULL> instead) | |
25 | |
26 =head1 CV Manipulation Functions | |
27 | |
28 This section documents functions to manipulate CVs which are code-values, | |
29 or subroutines. For more information, see L<perlguts>. | |
30 | |
31 =for apidoc Am|HV*|CvSTASH|CV* cv | |
32 Returns the stash of the CV. A stash is the symbol table hash, containing | |
33 the package-scoped variables in the package where the subroutine was defined. | |
34 For more information, see L<perlguts>. | |
35 | |
36 This also has a special use with XS AUTOLOAD subs. | |
37 See L<perlguts/Autoloading with XSUBs>. | |
38 | |
39 =cut | |
40 */ | |
41 | |
42 #ifndef PERL_CORE | |
43 # define Nullcv Null(CV*) | |
44 #endif | |
45 | |
46 #define CvSTASH(sv) (0+((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_stash) | |
47 #define CvSTASH_set(cv,st) Perl_cvstash_set(aTHX_ cv, st) | |
48 #define CvSTART(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_start_u.xcv_start | |
49 #define CvROOT(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_root_u.xcv_root | |
50 #define CvXSUB(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_root_u.xcv_xsub | |
51 #define CvXSUBANY(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_start_u.xcv_xsubany | |
52 #define CvGV(sv) S_CvGV(aTHX_ (CV *)(sv)) | |
53 #define CvGV_set(cv,gv) Perl_cvgv_set(aTHX_ cv, gv) | |
54 #define CvHASGV(cv) cBOOL(SvANY(cv)->xcv_gv_u.xcv_gv) | |
55 #define CvFILE(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_file | |
56 #ifdef USE_ITHREADS | |
57 # define CvFILE_set_from_cop(sv, cop) \ | |
58 (CvFILE(sv) = savepv(CopFILE(cop)), CvDYNFILE_on(sv)) | |
59 #else | |
60 # define CvFILE_set_from_cop(sv, cop) \ | |
61 (CvFILE(sv) = CopFILE(cop), CvDYNFILE_off(sv)) | |
62 #endif | |
63 #define CvFILEGV(sv) (gv_fetchfile(CvFILE(sv))) | |
64 #define CvDEPTH(sv) (*S_CvDEPTHp((const CV *)sv)) | |
65 /* For use when you only have a XPVCV*, not a real CV*. | |
66 Must be assert protected as in S_CvDEPTHp before use. */ | |
67 #define CvDEPTHunsafe(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_depth | |
68 | |
69 /* these CvPADLIST/CvRESERVED asserts can be reverted one day, once stabilized */ | |
70 #define CvPADLIST(sv) (*(assert_(!CvISXSUB((CV*)(sv))) \ | |
71 &(((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_padlist_u.xcv_padlist))) | |
72 /* CvPADLIST_set is not public API, it can be removed one day, once stabilized */ | |
73 #ifdef DEBUGGING | |
74 # define CvPADLIST_set(sv, padlist) Perl_set_padlist((CV*)sv, padlist) | |
75 #else | |
76 # define CvPADLIST_set(sv, padlist) (CvPADLIST(sv) = (padlist)) | |
77 #endif | |
78 #define CvHSCXT(sv) *(assert_(CvISXSUB((CV*)(sv))) \ | |
79 &(((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_padlist_u.xcv_hscxt)) | |
80 #ifdef DEBUGGING | |
81 # if PTRSIZE == 8 | |
82 # define PoisonPADLIST(sv) \ | |
83 (((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_padlist_u.xcv_padlist = (PADLIST *)UINT64_C(0xEFEFEFEFEFEFEFEF)) | |
84 # elif PTRSIZE == 4 | |
85 # define PoisonPADLIST(sv) \ | |
86 (((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_padlist_u.xcv_padlist = (PADLIST *)0xEFEFEFEF) | |
87 # else | |
88 # error unknown pointer size | |
89 # endif | |
90 #else | |
91 # define PoisonPADLIST(sv) NOOP | |
92 #endif | |
93 | |
94 #define CvOUTSIDE(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_outside | |
95 #define CvOUTSIDE_SEQ(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_outside_seq | |
96 #define CvFLAGS(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_flags | |
97 | |
98 /* These two are sometimes called on non-CVs */ | |
99 #define CvPROTO(sv) \ | |
100 ( \ | |
101 SvPOK(sv) \ | |
102 ? SvTYPE(sv) == SVt_PVCV && CvAUTOLOAD(sv) \ | |
103 ? SvEND(sv)+1 : SvPVX_const(sv) \ | |
104 : NULL \ | |
105 ) | |
106 #define CvPROTOLEN(sv) \ | |
107 ( \ | |
108 SvPOK(sv) \ | |
109 ? SvTYPE(sv) == SVt_PVCV && CvAUTOLOAD(sv) \ | |
110 ? SvLEN(sv)-SvCUR(sv)-2 \ | |
111 : SvCUR(sv) \ | |
112 : 0 \ | |
113 ) | |
114 | |
115 #define CVf_METHOD 0x0001 /* CV is explicitly marked as a method */ | |
116 #define CVf_LVALUE 0x0002 /* CV return value can be used as lvalue */ | |
117 #define CVf_CONST 0x0004 /* inlinable sub */ | |
118 #define CVf_ISXSUB 0x0008 /* CV is an XSUB, not pure perl. */ | |
119 | |
120 #define CVf_WEAKOUTSIDE 0x0010 /* CvOUTSIDE isn't ref counted */ | |
121 #define CVf_CLONE 0x0020 /* anon CV uses external lexicals */ | |
122 #define CVf_CLONED 0x0040 /* a clone of one of those */ | |
123 #define CVf_ANON 0x0080 /* CV is not pointed to by a GV */ | |
124 #define CVf_UNIQUE 0x0100 /* sub is only called once (eg PL_main_cv, | |
125 * require, eval). */ | |
126 #define CVf_NODEBUG 0x0200 /* no DB::sub indirection for this CV | |
127 (esp. useful for special XSUBs) */ | |
128 #define CVf_CVGV_RC 0x0400 /* CvGV is reference counted */ | |
129 #ifdef PERL_CORE | |
130 # define CVf_SLABBED 0x0800 /* Holds refcount on op slab */ | |
131 #endif | |
132 #define CVf_DYNFILE 0x1000 /* The filename isn't static */ | |
133 #define CVf_AUTOLOAD 0x2000 /* SvPVX contains AUTOLOADed sub name */ | |
134 #define CVf_HASEVAL 0x4000 /* contains string eval */ | |
135 #define CVf_NAMED 0x8000 /* Has a name HEK */ | |
136 #define CVf_LEXICAL 0x10000 /* Omit package from name */ | |
137 #define CVf_ANONCONST 0x20000 /* :const - create anonconst op */ | |
138 | |
139 /* This symbol for optimised communication between toke.c and op.c: */ | |
140 #define CVf_BUILTIN_ATTRS (CVf_METHOD|CVf_LVALUE|CVf_ANONCONST) | |
141 | |
142 #define CvCLONE(cv) (CvFLAGS(cv) & CVf_CLONE) | |
143 #define CvCLONE_on(cv) (CvFLAGS(cv) |= CVf_CLONE) | |
144 #define CvCLONE_off(cv) (CvFLAGS(cv) &= ~CVf_CLONE) | |
145 | |
146 #define CvCLONED(cv) (CvFLAGS(cv) & CVf_CLONED) | |
147 #define CvCLONED_on(cv) (CvFLAGS(cv) |= CVf_CLONED) | |
148 #define CvCLONED_off(cv) (CvFLAGS(cv) &= ~CVf_CLONED) | |
149 | |
150 #define CvANON(cv) (CvFLAGS(cv) & CVf_ANON) | |
151 #define CvANON_on(cv) (CvFLAGS(cv) |= CVf_ANON) | |
152 #define CvANON_off(cv) (CvFLAGS(cv) &= ~CVf_ANON) | |
153 | |
154 /* CvEVAL or CvSPECIAL */ | |
155 #define CvUNIQUE(cv) (CvFLAGS(cv) & CVf_UNIQUE) | |
156 #define CvUNIQUE_on(cv) (CvFLAGS(cv) |= CVf_UNIQUE) | |
157 #define CvUNIQUE_off(cv) (CvFLAGS(cv) &= ~CVf_UNIQUE) | |
158 | |
159 #define CvNODEBUG(cv) (CvFLAGS(cv) & CVf_NODEBUG) | |
160 #define CvNODEBUG_on(cv) (CvFLAGS(cv) |= CVf_NODEBUG) | |
161 #define CvNODEBUG_off(cv) (CvFLAGS(cv) &= ~CVf_NODEBUG) | |
162 | |
163 #define CvMETHOD(cv) (CvFLAGS(cv) & CVf_METHOD) | |
164 #define CvMETHOD_on(cv) (CvFLAGS(cv) |= CVf_METHOD) | |
165 #define CvMETHOD_off(cv) (CvFLAGS(cv) &= ~CVf_METHOD) | |
166 | |
167 #define CvLVALUE(cv) (CvFLAGS(cv) & CVf_LVALUE) | |
168 #define CvLVALUE_on(cv) (CvFLAGS(cv) |= CVf_LVALUE) | |
169 #define CvLVALUE_off(cv) (CvFLAGS(cv) &= ~CVf_LVALUE) | |
170 | |
171 /* eval or PL_main_cv */ | |
172 #define CvEVAL(cv) (CvUNIQUE(cv) && !SvFAKE(cv)) | |
173 #define CvEVAL_on(cv) (CvUNIQUE_on(cv),SvFAKE_off(cv)) | |
174 #define CvEVAL_off(cv) CvUNIQUE_off(cv) | |
175 | |
176 /* BEGIN|CHECK|INIT|UNITCHECK|END */ | |
177 #define CvSPECIAL(cv) (CvUNIQUE(cv) && SvFAKE(cv)) | |
178 #define CvSPECIAL_on(cv) (CvUNIQUE_on(cv),SvFAKE_on(cv)) | |
179 #define CvSPECIAL_off(cv) (CvUNIQUE_off(cv),SvFAKE_off(cv)) | |
180 | |
181 #define CvCONST(cv) (CvFLAGS(cv) & CVf_CONST) | |
182 #define CvCONST_on(cv) (CvFLAGS(cv) |= CVf_CONST) | |
183 #define CvCONST_off(cv) (CvFLAGS(cv) &= ~CVf_CONST) | |
184 | |
185 #define CvWEAKOUTSIDE(cv) (CvFLAGS(cv) & CVf_WEAKOUTSIDE) | |
186 #define CvWEAKOUTSIDE_on(cv) (CvFLAGS(cv) |= CVf_WEAKOUTSIDE) | |
187 #define CvWEAKOUTSIDE_off(cv) (CvFLAGS(cv) &= ~CVf_WEAKOUTSIDE) | |
188 | |
189 #define CvISXSUB(cv) (CvFLAGS(cv) & CVf_ISXSUB) | |
190 #define CvISXSUB_on(cv) (CvFLAGS(cv) |= CVf_ISXSUB) | |
191 #define CvISXSUB_off(cv) (CvFLAGS(cv) &= ~CVf_ISXSUB) | |
192 | |
193 #define CvCVGV_RC(cv) (CvFLAGS(cv) & CVf_CVGV_RC) | |
194 #define CvCVGV_RC_on(cv) (CvFLAGS(cv) |= CVf_CVGV_RC) | |
195 #define CvCVGV_RC_off(cv) (CvFLAGS(cv) &= ~CVf_CVGV_RC) | |
196 | |
197 #ifdef PERL_CORE | |
198 # define CvSLABBED(cv) (CvFLAGS(cv) & CVf_SLABBED) | |
199 # define CvSLABBED_on(cv) (CvFLAGS(cv) |= CVf_SLABBED) | |
200 # define CvSLABBED_off(cv) (CvFLAGS(cv) &= ~CVf_SLABBED) | |
201 #endif | |
202 | |
203 #define CvDYNFILE(cv) (CvFLAGS(cv) & CVf_DYNFILE) | |
204 #define CvDYNFILE_on(cv) (CvFLAGS(cv) |= CVf_DYNFILE) | |
205 #define CvDYNFILE_off(cv) (CvFLAGS(cv) &= ~CVf_DYNFILE) | |
206 | |
207 #define CvAUTOLOAD(cv) (CvFLAGS(cv) & CVf_AUTOLOAD) | |
208 #define CvAUTOLOAD_on(cv) (CvFLAGS(cv) |= CVf_AUTOLOAD) | |
209 #define CvAUTOLOAD_off(cv) (CvFLAGS(cv) &= ~CVf_AUTOLOAD) | |
210 | |
211 #define CvHASEVAL(cv) (CvFLAGS(cv) & CVf_HASEVAL) | |
212 #define CvHASEVAL_on(cv) (CvFLAGS(cv) |= CVf_HASEVAL) | |
213 #define CvHASEVAL_off(cv) (CvFLAGS(cv) &= ~CVf_HASEVAL) | |
214 | |
215 #define CvNAMED(cv) (CvFLAGS(cv) & CVf_NAMED) | |
216 #define CvNAMED_on(cv) (CvFLAGS(cv) |= CVf_NAMED) | |
217 #define CvNAMED_off(cv) (CvFLAGS(cv) &= ~CVf_NAMED) | |
218 | |
219 #define CvLEXICAL(cv) (CvFLAGS(cv) & CVf_LEXICAL) | |
220 #define CvLEXICAL_on(cv) (CvFLAGS(cv) |= CVf_LEXICAL) | |
221 #define CvLEXICAL_off(cv) (CvFLAGS(cv) &= ~CVf_LEXICAL) | |
222 | |
223 #define CvANONCONST(cv) (CvFLAGS(cv) & CVf_ANONCONST) | |
224 #define CvANONCONST_on(cv) (CvFLAGS(cv) |= CVf_ANONCONST) | |
225 #define CvANONCONST_off(cv) (CvFLAGS(cv) &= ~CVf_ANONCONST) | |
226 | |
227 /* Flags for newXS_flags */ | |
228 #define XS_DYNAMIC_FILENAME 0x01 /* The filename isn't static */ | |
229 | |
230 PERL_STATIC_INLINE HEK * | |
231 CvNAME_HEK(CV *sv) | |
232 { | |
233 return CvNAMED(sv) | |
234 ? ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_gv_u.xcv_hek | |
235 : 0; | |
236 } | |
237 /* This lowers the refernce count of the previous value, but does *not* | |
238 increment the reference count of the new value. */ | |
239 #define CvNAME_HEK_set(cv, hek) ( \ | |
240 CvNAME_HEK((CV *)(cv)) \ | |
241 ? unshare_hek(SvANY((CV *)(cv))->xcv_gv_u.xcv_hek) \ | |
242 : (void)0, \ | |
243 ((XPVCV*)MUTABLE_PTR(SvANY(cv)))->xcv_gv_u.xcv_hek = (hek), \ | |
244 CvNAMED_on(cv) \ | |
245 ) | |
246 | |
247 /* | |
248 =head1 CV reference counts and CvOUTSIDE | |
249 | |
250 =for apidoc m|bool|CvWEAKOUTSIDE|CV *cv | |
251 | |
252 Each CV has a pointer, C<CvOUTSIDE()>, to its lexically enclosing | |
253 CV (if any). Because pointers to anonymous sub prototypes are | |
254 stored in C<&> pad slots, it is a possible to get a circular reference, | |
255 with the parent pointing to the child and vice-versa. To avoid the | |
256 ensuing memory leak, we do not increment the reference count of the CV | |
257 pointed to by C<CvOUTSIDE> in the I<one specific instance> that the parent | |
258 has a C<&> pad slot pointing back to us. In this case, we set the | |
259 C<CvWEAKOUTSIDE> flag in the child. This allows us to determine under what | |
260 circumstances we should decrement the refcount of the parent when freeing | |
261 the child. | |
262 | |
263 There is a further complication with non-closure anonymous subs (i.e. those | |
264 that do not refer to any lexicals outside that sub). In this case, the | |
265 anonymous prototype is shared rather than being cloned. This has the | |
266 consequence that the parent may be freed while there are still active | |
267 children, eg | |
268 | |
269 BEGIN { $a = sub { eval '$x' } } | |
270 | |
271 In this case, the BEGIN is freed immediately after execution since there | |
272 are no active references to it: the anon sub prototype has | |
273 C<CvWEAKOUTSIDE> set since it's not a closure, and $a points to the same | |
274 CV, so it doesn't contribute to BEGIN's refcount either. When $a is | |
275 executed, the C<eval '$x'> causes the chain of C<CvOUTSIDE>s to be followed, | |
276 and the freed BEGIN is accessed. | |
277 | |
278 To avoid this, whenever a CV and its associated pad is freed, any | |
279 C<&> entries in the pad are explicitly removed from the pad, and if the | |
280 refcount of the pointed-to anon sub is still positive, then that | |
281 child's C<CvOUTSIDE> is set to point to its grandparent. This will only | |
282 occur in the single specific case of a non-closure anon prototype | |
283 having one or more active references (such as C<$a> above). | |
284 | |
285 One other thing to consider is that a CV may be merely undefined | |
286 rather than freed, eg C<undef &foo>. In this case, its refcount may | |
287 not have reached zero, but we still delete its pad and its C<CvROOT> etc. | |
288 Since various children may still have their C<CvOUTSIDE> pointing at this | |
289 undefined CV, we keep its own C<CvOUTSIDE> for the time being, so that | |
290 the chain of lexical scopes is unbroken. For example, the following | |
291 should print 123: | |
292 | |
293 my $x = 123; | |
294 sub tmp { sub { eval '$x' } } | |
295 my $a = tmp(); | |
296 undef &tmp; | |
297 print $a->(); | |
298 | |
299 =cut | |
300 */ | |
301 | |
302 typedef OP *(*Perl_call_checker)(pTHX_ OP *, GV *, SV *); | |
303 | |
304 #define CALL_CHECKER_REQUIRE_GV MGf_REQUIRE_GV | |
305 | |
306 #define CV_NAME_NOTQUAL 1 | |
307 | |
308 #ifdef PERL_CORE | |
309 # define CV_UNDEF_KEEP_NAME 1 | |
310 #endif | |
311 | |
312 /* | |
313 * ex: set ts=8 sts=4 sw=4 et: | |
314 */ |