This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
https://perl5.git.perl.org / perl5.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
perl_langinfo.h: Fix typo in comment
[perl5.git] / gv.c
CommitLineData
a0d0e21e 1/* gv.c
79072805 2 *
1129b882 3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
67fbe0e1 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 *
a0d0e21e
LW		 9 */
10
11/*
12 * 'Mercy!' cried Gandalf. 'If the giving of information is to be the cure
4ac71550 13 * of your inquisitiveness, I shall spend all the rest of my days in answering
a0d0e21e
LW		 14 * you. What more do you want to know?'
15 * 'The names of all the stars, and of all living things, and the whole
16 * history of Middle-earth and Over-heaven and of the Sundering Seas,'
17 * laughed Pippin.
4ac71550 18 *
cdad3b53 19 * [p.599 of _The Lord of the Rings_, III/xi: "The Palantír"]
79072805
LW		 20 */
21
ccfc67b7
JH		 22/*
23=head1 GV Functions
166f8a29
DM		 24A GV is a structure which corresponds to to a Perl typeglob, ie *foo.
25It is a structure that holds a pointer to a scalar, an array, a hash etc,
26corresponding to $foo, @foo, %foo.
27
28GVs are usually found as values in stashes (symbol table hashes) where
29Perl stores its global variables.
30
31=cut
ccfc67b7
JH		 32*/
33
79072805 34#include "EXTERN.h"
864dbfa3 35#define PERL_IN_GV_C
79072805 36#include "perl.h"
6ffcffbd 37#include "overload.inc"
4aaa4757 38#include "keywords.h"
2846acbf 39#include "feature.h"
79072805 40
f54cb97a 41static const char S_autoload[] = "AUTOLOAD";
3c81f0b3 42#define S_autolen (sizeof("AUTOLOAD")-1)
5c7983e5 43
13c59d41
MH		 44GV *
45Perl_gv_add_by_type(pTHX_ GV *gv, svtype type)
c69033f2 46{
d5713896 47 SV **where;
7918f24d 48
13c59d41
MH		 49 if (
50 !gv
51 || (
52 SvTYPE((const SV *)gv) != SVt_PVGV
13be902c 53 && SvTYPE((const SV *)gv) != SVt_PVLV
13c59d41 54 )
13be902c 55 ) {
bb85b28a 56 const char *what;
13c59d41 57 if (type == SVt_PVIO) {
bb85b28a
NC		 58 /*
59 * if it walks like a dirhandle, then let's assume that
60 * this is a dirhandle.
61 */
332c2eac 62 what = OP_IS_DIRHOP(PL_op->op_type) ?
bb85b28a 63 "dirhandle" : "filehandle";
13c59d41 64 } else if (type == SVt_PVHV) {
bb85b28a
NC		 65 what = "hash";
66 } else {
13c59d41 67 what = type == SVt_PVAV ? "array" : "scalar";
bb85b28a 68 }
de6f7947 69 /* diag_listed_as: Bad symbol for filehandle */
bb85b28a
NC		 70 Perl_croak(aTHX_ "Bad symbol for %s", what);
71 }
d5713896 72
13c59d41
MH		 73 if (type == SVt_PVHV) {
74 where = (SV **)&GvHV(gv);
75 } else if (type == SVt_PVAV) {
76 where = (SV **)&GvAV(gv);
77 } else if (type == SVt_PVIO) {
78 where = (SV **)&GvIOp(gv);
79 } else {
80 where = &GvSV(gv);
81 }
7918f24d 82
13c59d41
MH		 83 if (!*where)
84 {
85 *where = newSV_type(type);
b59bf0b2
KW		 86 if (type == SVt_PVAV
87 && memEQs(GvNAME(gv), GvNAMELEN(gv), "ISA"))
13c59d41 88 sv_magic(*where, (SV *)gv, PERL_MAGIC_isa, NULL, 0);
e17aed30 89 }
13c59d41 90 return gv;
79072805
LW		 91}
92
93GV *
864dbfa3 94Perl_gv_fetchfile(pTHX_ const char *name)
79072805 95{
7918f24d 96 PERL_ARGS_ASSERT_GV_FETCHFILE;
d9095cec
NC		 97 return gv_fetchfile_flags(name, strlen(name), 0);
98}
99
100GV *
101Perl_gv_fetchfile_flags(pTHX_ const char *const name, const STRLEN namelen,
102 const U32 flags)
103{
4116122e 104 char smallbuf[128];
53d95988 105 char *tmpbuf;
d9095cec 106 const STRLEN tmplen = namelen + 2;
79072805
LW		 107 GV *gv;
108
7918f24d 109 PERL_ARGS_ASSERT_GV_FETCHFILE_FLAGS;
d9095cec
NC		 110 PERL_UNUSED_ARG(flags);
111
1d7c1841 112 if (!PL_defstash)
a0714e2c 113 return NULL;
1d7c1841 114
d9095cec 115 if (tmplen <= sizeof smallbuf)
53d95988
CS		 116 tmpbuf = smallbuf;
117 else
798b63bc 118 Newx(tmpbuf, tmplen, char);
0ac0412a 119 /* This is where the debugger's %{"::_<$filename"} hash is created */
53d95988
CS		 120 tmpbuf[0] = '_';
121 tmpbuf[1] = '<';
d9095cec
NC		 122 memcpy(tmpbuf + 2, name, namelen);
123 gv = *(GV**)hv_fetch(PL_defstash, tmpbuf, tmplen, TRUE);
1d7c1841 124 if (!isGV(gv)) {
d9095cec 125 gv_init(gv, PL_defstash, tmpbuf, tmplen, FALSE);
c69033f2 126#ifdef PERL_DONT_CREATE_GVSV
d9095cec 127 GvSV(gv) = newSVpvn(name, namelen);
c69033f2 128#else
d9095cec 129 sv_setpvn(GvSV(gv), name, namelen);
c69033f2 130#endif
1d7c1841 131 }
c7a622b3 132 if (PERLDB_LINE_OR_SAVESRC && !GvAV(gv))
43e4250a 133 hv_magic(GvHVn(gv), GvAVn(gv), PERL_MAGIC_dbfile);
53d95988
CS		 134 if (tmpbuf != smallbuf)
135 Safefree(tmpbuf);
79072805
LW		 136 return gv;
137}
138
62d55b22
NC		 139/*
140=for apidoc gv_const_sv
141
142If C<gv> is a typeglob whose subroutine entry is a constant sub eligible for
143inlining, or C<gv> is a placeholder reference that would be promoted to such
144a typeglob, then returns the value returned by the sub. Otherwise, returns
796b6530 145C<NULL>.
62d55b22
NC		 146
147=cut
148*/
149
150SV *
151Perl_gv_const_sv(pTHX_ GV *gv)
152{
7918f24d 153 PERL_ARGS_ASSERT_GV_CONST_SV;
23491f1d 154 PERL_UNUSED_CONTEXT;
7918f24d 155
62d55b22
NC		 156 if (SvTYPE(gv) == SVt_PVGV)
157 return cv_const_sv(GvCVu(gv));
16a6e5a4 158 return SvROK(gv) && SvTYPE(SvRV(gv)) != SVt_PVAV && SvTYPE(SvRV(gv)) != SVt_PVCV ? SvRV(gv) : NULL;
62d55b22
NC		 159}
160
12816592
NC		 161GP *
162Perl_newGP(pTHX_ GV *const gv)
163{
164 GP *gp;
19bad673 165 U32 hash;
19bad673
NC		 166 const char *file;
167 STRLEN len;
2639089b 168#ifndef USE_ITHREADS
6b352265 169 GV *filegv;
2639089b 170#endif
c2587955 171 dVAR;
19bad673 172
7918f24d 173 PERL_ARGS_ASSERT_NEWGP;
2639089b
DD		 174 Newxz(gp, 1, GP);
175 gp->gp_egv = gv; /* allow compiler to reuse gv after this */
176#ifndef PERL_DONT_CREATE_GVSV
177 gp->gp_sv = newSV(0);
178#endif
7918f24d 179
c947bc1d
FC		 180 /* PL_curcop may be null here. E.g.,
181 INIT { bless {} and exit }
182 frees INIT before looking up DESTROY (and creating *DESTROY)
183 */
2639089b
DD		 184 if (PL_curcop) {
185 gp->gp_line = CopLINE(PL_curcop); /* 0 otherwise Newxz */
6e314d4f 186#ifdef USE_ITHREADS
2639089b
DD		 187 if (CopFILE(PL_curcop)) {
188 file = CopFILE(PL_curcop);
189 len = strlen(file);
190 }
2639089b 191#else
cb0d3385
FC		 192 filegv = CopFILEGV(PL_curcop);
193 if (filegv) {
194 file = GvNAME(filegv)+2;
195 len = GvNAMELEN(filegv)-2;
196 }
6e314d4f 197#endif
cb0d3385
FC		 198 else goto no_file;
199 }
200 else {
201 no_file:
19bad673
NC		 202 file = "";
203 len = 0;
204 }
f4890806
NC		 205
206 PERL_HASH(hash, file, len);
f4890806 207 gp->gp_file_hek = share_hek(file, len, hash);
12816592
NC		 208 gp->gp_refcnt = 1;
209
210 return gp;
211}
212
803f2748
DM		 213/* Assign CvGV(cv) = gv, handling weak references.
214 * See also S_anonymise_cv_maybe */
215
216void
217Perl_cvgv_set(pTHX_ CV* cv, GV* gv)
218{
ae77754a 219 GV * const oldgv = CvNAMED(cv) ? NULL : SvANY(cv)->xcv_gv_u.xcv_gv;
b290562e 220 HEK *hek;
803f2748
DM		 221 PERL_ARGS_ASSERT_CVGV_SET;
222
223 if (oldgv == gv)
224 return;
225
226 if (oldgv) {
cfc1e951 227 if (CvCVGV_RC(cv)) {
e7881358 228 SvREFCNT_dec_NN(oldgv);
cfc1e951
DM		 229 CvCVGV_RC_off(cv);
230 }
803f2748 231 else {
803f2748
DM		 232 sv_del_backref(MUTABLE_SV(oldgv), MUTABLE_SV(cv));
233 }
234 }
db5cc3ee
FC		 235 else if ((hek = CvNAME_HEK(cv))) {
236 unshare_hek(hek);
f3feca7a 237 CvLEXICAL_off(cv);
db5cc3ee 238 }
803f2748 239
5988f306 240 CvNAMED_off(cv);
b290562e 241 SvANY(cv)->xcv_gv_u.xcv_gv = gv;
c794ca97 242 assert(!CvCVGV_RC(cv));
803f2748
DM		 243
244 if (!gv)
245 return;
246
c794ca97
DM		 247 if (isGV_with_GP(gv) && GvGP(gv) && (GvCV(gv) == cv || GvFORM(gv) == cv))
248 Perl_sv_add_backref(aTHX_ MUTABLE_SV(gv), MUTABLE_SV(cv));
249 else {
cfc1e951 250 CvCVGV_RC_on(cv);
803f2748
DM		 251 SvREFCNT_inc_simple_void_NN(gv);
252 }
803f2748
DM		 253}
254
ae77754a
FC		 255/* Convert CvSTASH + CvNAME_HEK into a GV. Conceptually, all subs have a
256 GV, but for efficiency that GV may not in fact exist. This function,
257 called by CvGV, reifies it. */
258
259GV *
260Perl_cvgv_from_hek(pTHX_ CV *cv)
261{
262 GV *gv;
2eaf799e 263 SV **svp;
ae77754a
FC		 264 PERL_ARGS_ASSERT_CVGV_FROM_HEK;
265 assert(SvTYPE(cv) == SVt_PVCV);
266 if (!CvSTASH(cv)) return NULL;
267 ASSUME(CvNAME_HEK(cv));
2eaf799e
FC		 268 svp = hv_fetchhek(CvSTASH(cv), CvNAME_HEK(cv), 0);
269 gv = MUTABLE_GV(svp && *svp ? *svp : newSV(0));
270 if (!isGV(gv))
271 gv_init_pvn(gv, CvSTASH(cv), HEK_KEY(CvNAME_HEK(cv)),
ae77754a
FC		 272 HEK_LEN(CvNAME_HEK(cv)),
273 SVf_UTF8 * !!HEK_UTF8(CvNAME_HEK(cv)));
2eaf799e
FC		 274 if (!CvNAMED(cv)) { /* gv_init took care of it */
275 assert (SvANY(cv)->xcv_gv_u.xcv_gv == gv);
276 return gv;
277 }
ae77754a
FC		 278 unshare_hek(CvNAME_HEK(cv));
279 CvNAMED_off(cv);
280 SvANY(cv)->xcv_gv_u.xcv_gv = gv;
2eaf799e 281 if (svp && *svp) SvREFCNT_inc_simple_void_NN(gv);
ae77754a
FC		 282 CvCVGV_RC_on(cv);
283 return gv;
284}
285
c68d9564
Z		 286/* Assign CvSTASH(cv) = st, handling weak references. */
287
288void
289Perl_cvstash_set(pTHX_ CV *cv, HV *st)
290{
291 HV *oldst = CvSTASH(cv);
292 PERL_ARGS_ASSERT_CVSTASH_SET;
293 if (oldst == st)
294 return;
295 if (oldst)
296 sv_del_backref(MUTABLE_SV(oldst), MUTABLE_SV(cv));
297 SvANY(cv)->xcv_stash = st;
298 if (st)
299 Perl_sv_add_backref(aTHX_ MUTABLE_SV(st), MUTABLE_SV(cv));
300}
803f2748 301
e1104062
FC		 302/*
303=for apidoc gv_init_pvn
304
305Converts a scalar into a typeglob. This is an incoercible typeglob;
306assigning a reference to it will assign to one of its slots, instead of
796b6530
KW		 307overwriting it as happens with typeglobs created by C<SvSetSV>. Converting
308any scalar that is C<SvOK()> may produce unpredictable results and is reserved
e1104062
FC		 309for perl's internal use.
310
311C<gv> is the scalar to be converted.
312
313C<stash> is the parent stash/package, if any.
314
04ec7e59
FC		 315C<name> and C<len> give the name. The name must be unqualified;
316that is, it must not include the package name. If C<gv> is a
e1104062
FC		 317stash element, it is the caller's responsibility to ensure that the name
318passed to this function matches the name of the element. If it does not
319match, perl's internal bookkeeping will get out of sync.
320
4a4088c4 321C<flags> can be set to C<SVf_UTF8> if C<name> is a UTF-8 string, or
04ec7e59 322the return value of SvUTF8(sv). It can also take the
796b6530 323C<GV_ADDMULTI> flag, which means to pretend that the GV has been
e1104062
FC		 324seen before (i.e., suppress "Used once" warnings).
325
326=for apidoc gv_init
327
4a4088c4 328The old form of C<gv_init_pvn()>. It does not work with UTF-8 strings, as it
04ec7e59 329has no flags parameter. If the C<multi> parameter is set, the
796b6530 330C<GV_ADDMULTI> flag will be passed to C<gv_init_pvn()>.
e1104062
FC		 331
332=for apidoc gv_init_pv
333
796b6530 334Same as C<gv_init_pvn()>, but takes a nul-terminated string for the name
e1104062
FC		 335instead of separate char * and length parameters.
336
337=for apidoc gv_init_sv
338
796b6530 339Same as C<gv_init_pvn()>, but takes an SV * for the name instead of separate
e1104062
FC		 340char * and length parameters. C<flags> is currently unused.
341
342=cut
343*/
344
463ee0b2 345void
04ec7e59 346Perl_gv_init_sv(pTHX_ GV *gv, HV *stash, SV* namesv, U32 flags)
e6066781
BF		 347{
348 char *namepv;
349 STRLEN namelen;
350 PERL_ARGS_ASSERT_GV_INIT_SV;
351 namepv = SvPV(namesv, namelen);
352 if (SvUTF8(namesv))
353 flags |= SVf_UTF8;
04ec7e59 354 gv_init_pvn(gv, stash, namepv, namelen, flags);
e6066781
BF		 355}
356
357void
04ec7e59 358Perl_gv_init_pv(pTHX_ GV *gv, HV *stash, const char *name, U32 flags)
e6066781
BF		 359{
360 PERL_ARGS_ASSERT_GV_INIT_PV;
04ec7e59 361 gv_init_pvn(gv, stash, name, strlen(name), flags);
e6066781
BF		 362}
363
364void
04ec7e59 365Perl_gv_init_pvn(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, U32 flags)
463ee0b2 366{
3b6733bf
NC		 367 const U32 old_type = SvTYPE(gv);
368 const bool doproto = old_type > SVt_NULL;
f9509170 369 char * const proto = (doproto && SvPOK(gv))
dad95a0a 370 ? ((void)(SvIsCOW(gv) && (sv_force_normal((SV *)gv), 0)), SvPVX(gv))
f9509170 371 : NULL;
49a54bbe 372 const STRLEN protolen = proto ? SvCUR(gv) : 0;
e0260a5b 373 const U32 proto_utf8 = proto ? SvUTF8(gv) : 0;
756cb477 374 SV *const has_constant = doproto && SvROK(gv) ? SvRV(gv) : NULL;
1ccdb730 375 const U32 exported_constant = has_constant ? SvPCS_IMPORTED(gv) : 0;
6881372e
FC		 376 const bool really_sub =
377 has_constant && SvTYPE(has_constant) == SVt_PVCV;
378 COP * const old = PL_curcop;
756cb477 379
e6066781 380 PERL_ARGS_ASSERT_GV_INIT_PVN;
756cb477
NC		 381 assert (!(proto && has_constant));
382
383 if (has_constant) {
2eaf799e 384 /* The constant has to be a scalar, array or subroutine. */
5c1f4d79 385 switch (SvTYPE(has_constant)) {
5c1f4d79 386 case SVt_PVHV:
5c1f4d79
NC		 387 case SVt_PVFM:
388 case SVt_PVIO:
389 Perl_croak(aTHX_ "Cannot convert a reference to %s to typeglob",
390 sv_reftype(has_constant, 0));
c9a0dcdc 391 NOT_REACHED; /* NOTREACHED */
4bbde2f7 392 break;
81d52ecd 393
42d0e0b7 394 default: NOOP;
5c1f4d79 395 }
756cb477
NC		 396 SvRV_set(gv, NULL);
397 SvROK_off(gv);
398 }
463ee0b2 399
3b6733bf
NC		 400
401 if (old_type < SVt_PVGV) {
402 if (old_type >= SVt_PV)
403 SvCUR_set(gv, 0);
ad64d0ec 404 sv_upgrade(MUTABLE_SV(gv), SVt_PVGV);
3b6733bf 405 }
55d729e4
GS		 406 if (SvLEN(gv)) {
407 if (proto) {
f880fe2f 408 SvPV_set(gv, NULL);
b162af07 409 SvLEN_set(gv, 0);
55d729e4
GS		 410 SvPOK_off(gv);
411 } else
94010e71 412 Safefree(SvPVX_mutable(gv));
55d729e4 413 }
2e5b91de
NC		 414 SvIOK_off(gv);
415 isGV_with_GP_on(gv);
12816592 416
6881372e
FC		 417 if (really_sub && !CvISXSUB(has_constant) && CvSTART(has_constant)
418 && ( CvSTART(has_constant)->op_type == OP_NEXTSTATE
419 || CvSTART(has_constant)->op_type == OP_DBSTATE))
420 PL_curcop = (COP *)CvSTART(has_constant);
c43ae56f 421 GvGP_set(gv, Perl_newGP(aTHX_ gv));
6881372e 422 PL_curcop = old;
e15faf7d
NC		 423 GvSTASH(gv) = stash;
424 if (stash)
ad64d0ec 425 Perl_sv_add_backref(aTHX_ MUTABLE_SV(stash), MUTABLE_SV(gv));
04f3bf56 426 gv_name_set(gv, name, len, GV_ADD | ( flags & SVf_UTF8 ? SVf_UTF8 : 0 ));
04ec7e59
FC		 427 if (flags & GV_ADDMULTI || doproto) /* doproto means it */
428 GvMULTI_on(gv); /* _was_ mentioned */
6881372e 429 if (really_sub) {
2eaf799e
FC		 430 /* Not actually a constant. Just a regular sub. */
431 CV * const cv = (CV *)has_constant;
432 GvCV_set(gv,cv);
790acdde 433 if (CvNAMED(cv) && CvSTASH(cv) == stash && (
2eaf799e
FC		 434 CvNAME_HEK(cv) == GvNAME_HEK(gv)
435 || ( HEK_LEN(CvNAME_HEK(cv)) == HEK_LEN(GvNAME_HEK(gv))
436 && HEK_FLAGS(CvNAME_HEK(cv)) != HEK_FLAGS(GvNAME_HEK(gv))
437 && HEK_UTF8(CvNAME_HEK(cv)) == HEK_UTF8(GvNAME_HEK(gv))
438 && memEQ(HEK_KEY(CvNAME_HEK(cv)), GvNAME(gv), GvNAMELEN(gv))
439 )
440 ))
441 CvGV_set(cv,gv);
442 }
443 else if (doproto) {
e3d2b9e7 444 CV *cv;
756cb477
NC		 445 if (has_constant) {
446 /* newCONSTSUB takes ownership of the reference from us. */
e38acfd7 447 cv = newCONSTSUB_flags(stash, name, len, flags, has_constant);
75bd28cf
FC		 448 /* In case op.c:S_process_special_blocks stole it: */
449 if (!GvCV(gv))
c43ae56f 450 GvCV_set(gv, (CV *)SvREFCNT_inc_simple_NN(cv));
439cdf38 451 assert(GvCV(gv) == cv); /* newCONSTSUB should have set this */
1ccdb730
NC		 452 /* If this reference was a copy of another, then the subroutine
453 must have been "imported", by a Perl space assignment to a GV
454 from a reference to CV. */
455 if (exported_constant)
456 GvIMPORTED_CV_on(gv);
186a5ba8 457 CvSTASH_set(cv, PL_curstash); /* XXX Why is this needed? */
756cb477 458 } else {
186a5ba8 459 cv = newSTUB(gv,1);
756cb477 460 }
55d729e4 461 if (proto) {
e3d2b9e7 462 sv_usepvn_flags(MUTABLE_SV(cv), proto, protolen,
49a54bbe 463 SV_HAS_TRAILING_NUL);
e0260a5b 464 if ( proto_utf8 ) SvUTF8_on(MUTABLE_SV(cv));
55d729e4
GS		 465 }
466 }
463ee0b2
LW		 467}
468
76e3520e 469STATIC void
e6066781 470S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type)
a0d0e21e 471{
13c59d41
MH		 472 PERL_ARGS_ASSERT_GV_INIT_SVTYPE;
473
474 switch (sv_type) {
475 case SVt_PVIO:
476 (void)GvIOn(gv);
477 break;
478 case SVt_PVAV:
479 (void)GvAVn(gv);
480 break;
481 case SVt_PVHV:
482 (void)GvHVn(gv);
483 break;
c69033f2 484#ifdef PERL_DONT_CREATE_GVSV
13c59d41
MH		 485 case SVt_NULL:
486 case SVt_PVCV:
487 case SVt_PVFM:
488 case SVt_PVGV:
489 break;
490 default:
491 if(GvSVn(gv)) {
492 /* Work round what appears to be a bug in Sun C++ 5.8 2005/10/13
493 If we just cast GvSVn(gv) to void, it ignores evaluating it for
494 its side effect */
495 }
c69033f2 496#endif
a0d0e21e
LW		 497 }
498}
499
0f8d4b5e
FC		 500static void core_xsub(pTHX_ CV* cv);
501
502static GV *
503S_maybe_add_coresub(pTHX_ HV * const stash, GV *gv,
87566176 504 const char * const name, const STRLEN len)
0f8d4b5e
FC		 505{
506 const int code = keyword(name, len, 1);
507 static const char file[] = __FILE__;
97021f77 508 CV *cv, *oldcompcv = NULL;
0f8d4b5e 509 int opnum = 0;
0f8d4b5e 510 bool ampable = TRUE; /* &{}-able */
97021f77
FC		 511 COP *oldcurcop = NULL;
512 yy_parser *oldparser = NULL;
513 I32 oldsavestack_ix = 0;
0f8d4b5e
FC		 514
515 assert(gv || stash);
516 assert(name);
0f8d4b5e 517
88b892d8
FC		 518 if (!code) return NULL; /* Not a keyword */
519 switch (code < 0 ? -code : code) {
0f8d4b5e 520 /* no support for \&CORE::infix;
d885f758 521 no support for funcs that do not parse like funcs */
88b892d8 522 case KEY___DATA__: case KEY___END__: case KEY_and: case KEY_AUTOLOAD:
a96df643 523 case KEY_BEGIN : case KEY_CHECK : case KEY_cmp:
7896dde7 524 case KEY_default : case KEY_DESTROY:
88b892d8 525 case KEY_do : case KEY_dump : case KEY_else : case KEY_elsif :
d51f8b19 526 case KEY_END : case KEY_eq : case KEY_eval :
88b892d8 527 case KEY_for : case KEY_foreach: case KEY_format: case KEY_ge :
498a02d8 528 case KEY_given : case KEY_goto : case KEY_grep :
88b892d8
FC		 529 case KEY_gt : case KEY_if: case KEY_INIT: case KEY_last: case KEY_le:
530 case KEY_local: case KEY_lt: case KEY_m : case KEY_map : case KEY_my:
531 case KEY_ne : case KEY_next : case KEY_no: case KEY_or: case KEY_our:
1efec5ed 532 case KEY_package: case KEY_print: case KEY_printf:
919ad5f7 533 case KEY_q : case KEY_qq : case KEY_qr : case KEY_qw :
88b892d8 534 case KEY_qx : case KEY_redo : case KEY_require: case KEY_return:
d33bb3da 535 case KEY_s : case KEY_say : case KEY_sort :
d80ed303 536 case KEY_state: case KEY_sub :
46bef06f 537 case KEY_tr : case KEY_UNITCHECK: case KEY_unless:
7896dde7 538 case KEY_until: case KEY_use : case KEY_when : case KEY_while :
88b892d8 539 case KEY_x : case KEY_xor : case KEY_y :
0f8d4b5e
FC		 540 return NULL;
541 case KEY_chdir:
eb31eb35 542 case KEY_chomp: case KEY_chop: case KEY_defined: case KEY_delete:
73665bc4 543 case KEY_eof : case KEY_exec: case KEY_exists :
0f8d4b5e 544 case KEY_lstat:
bea284c8 545 case KEY_split:
0f8d4b5e
FC		 546 case KEY_stat:
547 case KEY_system:
548 case KEY_truncate: case KEY_unlink:
0f8d4b5e
FC		 549 ampable = FALSE;
550 }
551 if (!gv) {
552 gv = (GV *)newSV(0);
553 gv_init(gv, stash, name, len, TRUE);
554 }
7e68c38b 555 GvMULTI_on(gv);
0f8d4b5e
FC		 556 if (ampable) {
557 ENTER;
558 oldcurcop = PL_curcop;
559 oldparser = PL_parser;
560 lex_start(NULL, NULL, 0);
561 oldcompcv = PL_compcv;
562 PL_compcv = NULL; /* Prevent start_subparse from setting
563 CvOUTSIDE. */
564 oldsavestack_ix = start_subparse(FALSE,0);
565 cv = PL_compcv;
566 }
567 else {
568 /* Avoid calling newXS, as it calls us, and things start to
569 get hairy. */
570 cv = MUTABLE_CV(newSV_type(SVt_PVCV));
571 GvCV_set(gv,cv);
572 GvCVGEN(gv) = 0;
0f8d4b5e
FC		 573 CvISXSUB_on(cv);
574 CvXSUB(cv) = core_xsub;
eacbb379 575 PoisonPADLIST(cv);
0f8d4b5e
FC		 576 }
577 CvGV_set(cv, gv); /* This stops new ATTRSUB from setting CvFILE
578 from PL_curcop. */
9b669ea1
DD		 579 /* XSUBs can't be perl lang/perl5db.pl debugged
580 if (PERLDB_LINE_OR_SAVESRC)
581 (void)gv_fetchfile(file); */
0f8d4b5e
FC		 582 CvFILE(cv) = (char *)file;
583 /* XXX This is inefficient, as doing things this order causes
584 a prototype check in newATTRSUB. But we have to do
585 it this order as we need an op number before calling
586 new ATTRSUB. */
587 (void)core_prototype((SV *)cv, name, code, &opnum);
87566176 588 if (stash)
73c02f15 589 (void)hv_store(stash,name,len,(SV *)gv,0);
0f8d4b5e 590 if (ampable) {
4428fb0e
TC		 591#ifdef DEBUGGING
592 CV *orig_cv = cv;
593#endif
0f8d4b5e 594 CvLVALUE_on(cv);
4428fb0e
TC		 595 /* newATTRSUB will free the CV and return NULL if we're still
596 compiling after a syntax error */
e8f91c91 597 if ((cv = newATTRSUB_x(
7e68c38b 598 oldsavestack_ix, (OP *)gv,
0f8d4b5e
FC		 599 NULL,NULL,
600 coresub_op(
601 opnum
602 ? newSVuv((UV)opnum)
603 : newSVpvn(name,len),
604 code, opnum
7e68c38b 605 ),
e8f91c91 606 TRUE
4428fb0e
TC		 607 )) != NULL) {
608 assert(GvCV(gv) == orig_cv);
609 if (opnum != OP_VEC && opnum != OP_SUBSTR && opnum != OP_POS
cd642408 610 && opnum != OP_UNDEF && opnum != OP_KEYS)
4428fb0e
TC		 611 CvLVALUE_off(cv); /* Now *that* was a neat trick. */
612 }
0f8d4b5e
FC		 613 LEAVE;
614 PL_parser = oldparser;
615 PL_curcop = oldcurcop;
616 PL_compcv = oldcompcv;
617 }
4428fb0e 618 if (cv) {
a83b92fa
Z		 619 SV *opnumsv = newSViv(
620 (opnum == OP_ENTEREVAL && len == 9 && memEQ(name, "evalbytes", 9)) ?
621 (OP_ENTEREVAL | (1<<16))
622 : opnum ? opnum : (((I32)name[2]) << 16));
623 cv_set_call_checker_flags(cv, Perl_ck_entersub_args_core, opnumsv, 0);
624 SvREFCNT_dec_NN(opnumsv);
4428fb0e
TC		 625 }
626
0f8d4b5e
FC		 627 return gv;
628}
629
954c1994 630/*
6c53d59b
FC		 631=for apidoc gv_fetchmeth
632
633Like L</gv_fetchmeth_pvn>, but lacks a flags parameter.
634
e6919483
BF		 635=for apidoc gv_fetchmeth_sv
636
637Exactly like L</gv_fetchmeth_pvn>, but takes the name string in the form
638of an SV instead of a string/length pair.
639
640=cut
641*/
642
643GV *
644Perl_gv_fetchmeth_sv(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags)
645{
c290e187 646 char *namepv;
647 STRLEN namelen;
648 PERL_ARGS_ASSERT_GV_FETCHMETH_SV;
649 if (LIKELY(SvPOK_nog(namesv))) /* common case */
14062320
FC		 650 return gv_fetchmeth_internal(stash, namesv, NULL, 0, level,
651 flags | SvUTF8(namesv));
c290e187 652 namepv = SvPV(namesv, namelen);
653 if (SvUTF8(namesv)) flags |= SVf_UTF8;
654 return gv_fetchmeth_pvn(stash, namepv, namelen, level, flags);
e6919483
BF		 655}
656
657/*
658=for apidoc gv_fetchmeth_pv
659
660Exactly like L</gv_fetchmeth_pvn>, but takes a nul-terminated string
661instead of a string/length pair.
662
663=cut
664*/
665
666GV *
667Perl_gv_fetchmeth_pv(pTHX_ HV *stash, const char *name, I32 level, U32 flags)
668{
669 PERL_ARGS_ASSERT_GV_FETCHMETH_PV;
c6afe666 670 return gv_fetchmeth_internal(stash, NULL, name, strlen(name), level, flags);
e6919483
BF		 671}
672
673/*
674=for apidoc gv_fetchmeth_pvn
954c1994
GS		 675
676Returns the glob with the given C<name> and a defined subroutine or
677C<NULL>. The glob lives in the given C<stash>, or in the stashes
796b6530 678accessible via C<@ISA> and C<UNIVERSAL::>.
954c1994
GS		 679
680The argument C<level> should be either 0 or -1. If C<level==0>, as a
681side-effect creates a glob with the given C<name> in the given C<stash>
682which in the case of success contains an alias for the subroutine, and sets
e1a479c5 683up caching info for this glob.
954c1994 684
796b6530 685The only significant values for C<flags> are C<GV_SUPER> and C<SVf_UTF8>.
aae43805 686
796b6530 687C<GV_SUPER> indicates that we want to look up the method in the superclasses
aae43805 688of the C<stash>.
e6919483 689
aae43805 690The
954c1994 691GV returned from C<gv_fetchmeth> may be a method cache entry, which is not
4929bf7b 692visible to Perl code. So when calling C<call_sv>, you should not use
954c1994 693the GV directly; instead, you should use the method's CV, which can be
b267980d 694obtained from the GV with the C<GvCV> macro.
954c1994
GS		 695
696=cut
697*/
698
e1a479c5
BB		 699/* NOTE: No support for tied ISA */
700
c6afe666 701PERL_STATIC_INLINE GV*
702S_gv_fetchmeth_internal(pTHX_ HV* stash, SV* meth, const char* name, STRLEN len, I32 level, U32 flags)
79072805 703{
463ee0b2 704 GV** gvp;
c6afe666 705 HE* he;
e1a479c5
BB		 706 AV* linear_av;
707 SV** linear_svp;
708 SV* linear_sv;
aae43805 709 HV* cstash, *cachestash;
e1a479c5
BB		 710 GV* candidate = NULL;
711 CV* cand_cv = NULL;
e1a479c5 712 GV* topgv = NULL;
bfcb3514 713 const char *hvname;
c6afe666 714 I32 create = (level >= 0) ? HV_FETCH_LVALUE : 0;
e1a479c5 715 I32 items;
e1a479c5 716 U32 topgen_cmp;
04f3bf56 717 U32 is_utf8 = flags & SVf_UTF8;
a0d0e21e 718
af09ea45
IK		 719 /* UNIVERSAL methods should be callable without a stash */
720 if (!stash) {
e1a479c5 721 create = 0; /* probably appropriate */
da51bb9b 722 if(!(stash = gv_stashpvs("UNIVERSAL", 0)))
af09ea45
IK		 723 return 0;
724 }
725
e1a479c5
BB		 726 assert(stash);
727
bfcb3514
NC		 728 hvname = HvNAME_get(stash);
729 if (!hvname)
e1a479c5 730 Perl_croak(aTHX_ "Can't use anonymous symbol table for method lookup");
e27ad1f2 731
e1a479c5 732 assert(hvname);
55df6700 733 assert(name || meth);
463ee0b2 734
aae43805 735 DEBUG_o( Perl_deb(aTHX_ "Looking for %smethod %s in package %s\n",
55df6700
FC		 736 flags & GV_SUPER ? "SUPER " : "",
737 name ? name : SvPV_nolen(meth), hvname) );
44a8e56a 738
dd69841b 739 topgen_cmp = HvMROMETA(stash)->cache_gen + PL_sub_generation;
e1a479c5 740
aae43805 741 if (flags & GV_SUPER) {
1a33a059
FC		 742 if (!HvAUX(stash)->xhv_mro_meta->super)
743 HvAUX(stash)->xhv_mro_meta->super = newHV();
744 cachestash = HvAUX(stash)->xhv_mro_meta->super;
aae43805
FC		 745 }
746 else cachestash = stash;
747
e1a479c5 748 /* check locally for a real method or a cache entry */
c6afe666 749 he = (HE*)hv_common(
1cde3371 750 cachestash, meth, name, len, is_utf8 ? HVhek_UTF8 : 0, create, NULL, 0
c6afe666 751 );
752 if (he) gvp = (GV**)&HeVAL(he);
753 else gvp = NULL;
754
e1a479c5
BB		 755 if(gvp) {
756 topgv = *gvp;
0f8d4b5e 757 have_gv:
e1a479c5
BB		 758 assert(topgv);
759 if (SvTYPE(topgv) != SVt_PVGV)
55df6700
FC		 760 {
761 if (!name)
762 name = SvPV_nomg(meth, len);
04ec7e59 763 gv_init_pvn(topgv, stash, name, len, GV_ADDMULTI|is_utf8);
55df6700 764 }
e1a479c5
BB		 765 if ((cand_cv = GvCV(topgv))) {
766 /* If genuine method or valid cache entry, use it */
767 if (!GvCVGEN(topgv) || GvCVGEN(topgv) == topgen_cmp) {
768 return topgv;
769 }
770 else {
771 /* stale cache entry, junk it and move on */
e7881358 772 SvREFCNT_dec_NN(cand_cv);
c43ae56f
DM		 773 GvCV_set(topgv, NULL);
774 cand_cv = NULL;
e1a479c5
BB		 775 GvCVGEN(topgv) = 0;
776 }
777 }
778 else if (GvCVGEN(topgv) == topgen_cmp) {
779 /* cache indicates no such method definitively */
780 return 0;
781 }
aae43805 782 else if (stash == cachestash
b59bf0b2
KW		 783 && len > 1 /* shortest is uc */
784 && memEQs(hvname, HvNAMELEN_get(stash), "CORE")
87566176 785 && S_maybe_add_coresub(aTHX_ NULL,topgv,name,len))
0f8d4b5e 786 goto have_gv;
463ee0b2 787 }
79072805 788
aae43805 789 linear_av = mro_get_linear_isa(stash); /* has ourselves at the top of the list */
e1a479c5
BB		 790 linear_svp = AvARRAY(linear_av) + 1; /* skip over self */
791 items = AvFILLp(linear_av); /* no +1, to skip over self */
792 while (items--) {
793 linear_sv = *linear_svp++;
794 assert(linear_sv);
795 cstash = gv_stashsv(linear_sv, 0);
796
dd69841b 797 if (!cstash) {
ecad31f0 798 Perl_ck_warner(aTHX_ packWARN(WARN_SYNTAX),
147e3846 799 "Can't locate package %" SVf " for @%" HEKf "::ISA",
ecad31f0 800 SVfARG(linear_sv),
d0c0e7dd 801 HEKfARG(HvNAME_HEK(stash)));
e1a479c5
BB		 802 continue;
803 }
9607fc9c 804
e1a479c5
BB		 805 assert(cstash);
806
c60dbbc3 807 gvp = (GV**)hv_fetch(cstash, name, is_utf8 ? -(I32)len : (I32)len, 0);
0f8d4b5e
FC		 808 if (!gvp) {
809 if (len > 1 && HvNAMELEN_get(cstash) == 4) {
810 const char *hvname = HvNAME(cstash); assert(hvname);
c8b388b0 811 if (strBEGINs(hvname, "CORE")
0f8d4b5e 812 && (candidate =
87566176 813 S_maybe_add_coresub(aTHX_ cstash,NULL,name,len)
0f8d4b5e
FC		 814 ))
815 goto have_candidate;
816 }
817 continue;
818 }
819 else candidate = *gvp;
820 have_candidate:
e1a479c5 821 assert(candidate);
04f3bf56 822 if (SvTYPE(candidate) != SVt_PVGV)
04ec7e59 823 gv_init_pvn(candidate, cstash, name, len, GV_ADDMULTI|is_utf8);
e1a479c5
BB		 824 if (SvTYPE(candidate) == SVt_PVGV && (cand_cv = GvCV(candidate)) && !GvCVGEN(candidate)) {
825 /*
826 * Found real method, cache method in topgv if:
827 * 1. topgv has no synonyms (else inheritance crosses wires)
828 * 2. method isn't a stub (else AUTOLOAD fails spectacularly)
829 */
830 if (topgv && (GvREFCNT(topgv) == 1) && (CvROOT(cand_cv) || CvXSUB(cand_cv))) {
9bfbb681
VP		 831 CV *old_cv = GvCV(topgv);
832 SvREFCNT_dec(old_cv);
e1a479c5 833 SvREFCNT_inc_simple_void_NN(cand_cv);
c43ae56f 834 GvCV_set(topgv, cand_cv);
e1a479c5
BB		 835 GvCVGEN(topgv) = topgen_cmp;
836 }
837 return candidate;
838 }
839 }
9607fc9c 840
e1a479c5
BB		 841 /* Check UNIVERSAL without caching */
842 if(level == 0 || level == -1) {
55df6700
FC		 843 candidate = gv_fetchmeth_internal(NULL, meth, name, len, 1,
844 flags &~GV_SUPER);
e1a479c5
BB		 845 if(candidate) {
846 cand_cv = GvCV(candidate);
847 if (topgv && (GvREFCNT(topgv) == 1) && (CvROOT(cand_cv) || CvXSUB(cand_cv))) {
9bfbb681
VP		 848 CV *old_cv = GvCV(topgv);
849 SvREFCNT_dec(old_cv);
e1a479c5 850 SvREFCNT_inc_simple_void_NN(cand_cv);
c43ae56f 851 GvCV_set(topgv, cand_cv);
e1a479c5
BB		 852 GvCVGEN(topgv) = topgen_cmp;
853 }
854 return candidate;
855 }
856 }
857
858 if (topgv && GvREFCNT(topgv) == 1) {
859 /* cache the fact that the method is not defined */
860 GvCVGEN(topgv) = topgen_cmp;
a0d0e21e
LW		 861 }
862
79072805
LW		 863 return 0;
864}
865
c6afe666 866GV *
867Perl_gv_fetchmeth_pvn(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags)
868{
869 PERL_ARGS_ASSERT_GV_FETCHMETH_PVN;
870 return gv_fetchmeth_internal(stash, NULL, name, len, level, flags);
871}
872
954c1994 873/*
460e5730
FC		 874=for apidoc gv_fetchmeth_autoload
875
876This is the old form of L</gv_fetchmeth_pvn_autoload>, which has no flags
877parameter.
878
d21989ed 879=for apidoc gv_fetchmeth_sv_autoload
611c1e95 880
d21989ed
BF		 881Exactly like L</gv_fetchmeth_pvn_autoload>, but takes the name string in the form
882of an SV instead of a string/length pair.
883
884=cut
885*/
886
887GV *
888Perl_gv_fetchmeth_sv_autoload(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags)
889{
890 char *namepv;
891 STRLEN namelen;
892 PERL_ARGS_ASSERT_GV_FETCHMETH_SV_AUTOLOAD;
893 namepv = SvPV(namesv, namelen);
894 if (SvUTF8(namesv))
895 flags |= SVf_UTF8;
896 return gv_fetchmeth_pvn_autoload(stash, namepv, namelen, level, flags);
897}
898
899/*
900=for apidoc gv_fetchmeth_pv_autoload
901
902Exactly like L</gv_fetchmeth_pvn_autoload>, but takes a nul-terminated string
903instead of a string/length pair.
904
905=cut
906*/
907
908GV *
909Perl_gv_fetchmeth_pv_autoload(pTHX_ HV *stash, const char *name, I32 level, U32 flags)
910{
911 PERL_ARGS_ASSERT_GV_FETCHMETH_PV_AUTOLOAD;
912 return gv_fetchmeth_pvn_autoload(stash, name, strlen(name), level, flags);
913}
914
915/*
916=for apidoc gv_fetchmeth_pvn_autoload
917
796b6530 918Same as C<gv_fetchmeth_pvn()>, but looks for autoloaded subroutines too.
611c1e95
IZ		 919Returns a glob for the subroutine.
920
921For an autoloaded subroutine without a GV, will create a GV even
796b6530 922if C<level < 0>. For an autoloaded subroutine without a stub, C<GvCV()>
611c1e95
IZ		 923of the result may be zero.
924
796b6530 925Currently, the only significant value for C<flags> is C<SVf_UTF8>.
d21989ed 926
611c1e95
IZ		 927=cut
928*/
929
930GV *
d21989ed 931Perl_gv_fetchmeth_pvn_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags)
611c1e95 932{
499321d3 933 GV *gv = gv_fetchmeth_pvn(stash, name, len, level, flags);
611c1e95 934
d21989ed 935 PERL_ARGS_ASSERT_GV_FETCHMETH_PVN_AUTOLOAD;
7918f24d 936
611c1e95 937 if (!gv) {
611c1e95
IZ		 938 CV *cv;
939 GV **gvp;
940
941 if (!stash)
6136c704 942 return NULL; /* UNIVERSAL::AUTOLOAD could cause trouble */
7edbdc6b 943 if (len == S_autolen && memEQ(name, S_autoload, S_autolen))
6136c704 944 return NULL;
d21989ed 945 if (!(gv = gv_fetchmeth_pvn(stash, S_autoload, S_autolen, FALSE, flags)))
6136c704 946 return NULL;
611c1e95
IZ		 947 cv = GvCV(gv);
948 if (!(CvROOT(cv) || CvXSUB(cv)))
6136c704 949 return NULL;
611c1e95
IZ		 950 /* Have an autoload */
951 if (level < 0) /* Cannot do without a stub */
d21989ed 952 gv_fetchmeth_pvn(stash, name, len, 0, flags);
c60dbbc3
BF		 953 gvp = (GV**)hv_fetch(stash, name,
954 (flags & SVf_UTF8) ? -(I32)len : (I32)len, (level >= 0));
611c1e95 955 if (!gvp)
6136c704 956 return NULL;
611c1e95
IZ		 957 return *gvp;
958 }
959 return gv;
960}
961
962/*
954c1994
GS		 963=for apidoc gv_fetchmethod_autoload
964
965Returns the glob which contains the subroutine to call to invoke the method
966on the C<stash>. In fact in the presence of autoloading this may be the
796b6530 967glob for "AUTOLOAD". In this case the corresponding variable C<$AUTOLOAD> is
b267980d 968already setup.
954c1994
GS		 969
970The third parameter of C<gv_fetchmethod_autoload> determines whether
971AUTOLOAD lookup is performed if the given method is not present: non-zero
b267980d 972means yes, look for AUTOLOAD; zero means no, don't look for AUTOLOAD.
954c1994 973Calling C<gv_fetchmethod> is equivalent to calling C<gv_fetchmethod_autoload>
b267980d 974with a non-zero C<autoload> parameter.
954c1994 975
cec2d7b1
FC		 976These functions grant C<"SUPER"> token
977as a prefix of the method name. Note
954c1994
GS		 978that if you want to keep the returned glob for a long time, you need to
979check for it being "AUTOLOAD", since at the later time the call may load a
796b6530 980different subroutine due to C<$AUTOLOAD> changing its value. Use the glob
cec2d7b1 981created as a side effect to do this.
954c1994 982
cec2d7b1
FC		 983These functions have the same side-effects as C<gv_fetchmeth> with
984C<level==0>. The warning against passing the GV returned by
985C<gv_fetchmeth> to C<call_sv> applies equally to these functions.
954c1994
GS		 986
987=cut
988*/
989
dc848c6f 990GV *
864dbfa3 991Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload)
dc848c6f 992{
547bb267
NC		 993 PERL_ARGS_ASSERT_GV_FETCHMETHOD_AUTOLOAD;
994
256d1bb2
NC		 995 return gv_fetchmethod_flags(stash, name, autoload ? GV_AUTOLOAD : 0);
996}
997
44130a26
BF		 998GV *
999Perl_gv_fetchmethod_sv_flags(pTHX_ HV *stash, SV *namesv, U32 flags)
1000{
1001 char *namepv;
1002 STRLEN namelen;
1003 PERL_ARGS_ASSERT_GV_FETCHMETHOD_SV_FLAGS;
1004 namepv = SvPV(namesv, namelen);
1005 if (SvUTF8(namesv))
1006 flags |= SVf_UTF8;
1007 return gv_fetchmethod_pvn_flags(stash, namepv, namelen, flags);
1008}
1009
1010GV *
1011Perl_gv_fetchmethod_pv_flags(pTHX_ HV *stash, const char *name, U32 flags)
1012{
1013 PERL_ARGS_ASSERT_GV_FETCHMETHOD_PV_FLAGS;
1014 return gv_fetchmethod_pvn_flags(stash, name, strlen(name), flags);
1015}
1016
256d1bb2 1017GV *
44130a26 1018Perl_gv_fetchmethod_pvn_flags(pTHX_ HV *stash, const char *name, const STRLEN len, U32 flags)
256d1bb2 1019{
65308f87
YO		 1020 const char * const origname = name;
1021 const char * const name_end = name + len;
e2cace1e 1022 const char *last_separator = NULL;
a0d0e21e 1023 GV* gv;
0dae17bd 1024 HV* ostash = stash;
ad64d0ec 1025 SV *const error_report = MUTABLE_SV(stash);
256d1bb2
NC		 1026 const U32 autoload = flags & GV_AUTOLOAD;
1027 const U32 do_croak = flags & GV_CROAK;
14d1dfbd 1028 const U32 is_utf8 = flags & SVf_UTF8;
0dae17bd 1029
44130a26 1030 PERL_ARGS_ASSERT_GV_FETCHMETHOD_PVN_FLAGS;
7918f24d 1031
eff494dd 1032 if (SvTYPE(stash) < SVt_PVHV)
5c284bb0 1033 stash = NULL;
c9bf4021 1034 else {
e2cace1e 1035 /* The only way stash can become NULL later on is if last_separator is set,
c9bf4021
NC		 1036 which in turn means that there is no need for a SVt_PVHV case
1037 the error reporting code. */
1038 }
b267980d 1039
cfb73676
YO		 1040 {
1041 /* check if the method name is fully qualified or
1042 * not, and separate the package name from the actual
1043 * method name.
1044 *
1045 * leaves last_separator pointing to the beginning of the
1046 * last package separator (either ' or ::) or 0
1047 * if none was found.
1048 *
1049 * leaves name pointing at the beginning of the
1050 * method name.
1051 */
1052 const char *name_cursor = name;
1053 const char * const name_em1 = name_end - 1; /* name_end minus 1 */
1054 for (name_cursor = name; name_cursor < name_end ; name_cursor++) {
1055 if (*name_cursor == '\'') {
1056 last_separator = name_cursor;
1057 name = name_cursor + 1;
1058 }
1059 else if (name_cursor < name_em1 && *name_cursor == ':' && name_cursor[1] == ':') {
1060 last_separator = name_cursor++;
1061 name = name_cursor + 1;
1062 }
1063 }
a0d0e21e 1064 }
cfb73676
YO		 1065
1066 /* did we find a separator? */
e2cace1e 1067 if (last_separator) {
9b7f107c
YO		 1068 STRLEN sep_len= last_separator - origname;
1069 if ( memEQs(origname, sep_len, "SUPER")) {
9607fc9c 1070 /* ->SUPER::method should really be looked up in original stash */
aae43805
FC		 1071 stash = CopSTASH(PL_curcop);
1072 flags |= GV_SUPER;
cea2e8a9 1073 DEBUG_o( Perl_deb(aTHX_ "Treating %s as %s::%s\n",
0308a534 1074 origname, HvENAME_get(stash), name) );
4633a7c4 1075 }
47324b4e
KW		 1076 else if ( sep_len >= 7 &&
1077 strBEGINs(last_separator - 7, "::SUPER")) {
aae43805 1078 /* don't autovifify if ->NoSuchStash::SUPER::method */
9b7f107c 1079 stash = gv_stashpvn(origname, sep_len - 7, is_utf8);
aae43805
FC		 1080 if (stash) flags |= GV_SUPER;
1081 }
e189a56d 1082 else {
af09ea45 1083 /* don't autovifify if ->NoSuchStash::method */
9b7f107c 1084 stash = gv_stashpvn(origname, sep_len, is_utf8);
e189a56d 1085 }
0dae17bd 1086 ostash = stash;
4633a7c4
LW		 1087 }
1088
65308f87 1089 gv = gv_fetchmeth_pvn(stash, name, name_end - name, 0, flags);
a0d0e21e 1090 if (!gv) {
7da9d78d
AB		 1091 /* This is the special case that exempts Foo->import and
1092 Foo->unimport from being an error even if there's no
1093 import/unimport subroutine */
0740a29d
Z		 1094 if (strEQ(name,"import") || strEQ(name,"unimport")) {
1095 gv = (GV*)sv_2mortal((SV*)newCONSTSUB_flags(NULL,
1096 NULL, 0, 0, NULL));
1097 } else if (autoload)
c8416c26 1098 gv = gv_autoload_pvn(
65308f87 1099 ostash, name, name_end - name, GV_AUTOLOAD_ISMETHOD|flags
c8416c26 1100 );
256d1bb2
NC		 1101 if (!gv && do_croak) {
1102 /* Right now this is exclusively for the benefit of S_method_common
1103 in pp_hot.c */
1104 if (stash) {
15e6cdd9
DG		 1105 /* If we can't find an IO::File method, it might be a call on
1106 * a filehandle. If IO:File has not been loaded, try to
1107 * require it first instead of croaking */
1108 const char *stash_name = HvNAME_get(stash);
31b05a0f
FR		 1109 if (stash_name && memEQs(stash_name, HvNAMELEN_get(stash), "IO::File")
1110 && !Perl_hv_common(aTHX_ GvHVn(PL_incgv), NULL,
1111 STR_WITH_LEN("IO/File.pm"), 0,
1112 HV_FETCH_ISEXISTS, NULL, 0)
15e6cdd9 1113 ) {
31b05a0f 1114 require_pv("IO/File.pm");
65308f87 1115 gv = gv_fetchmeth_pvn(stash, name, name_end - name, 0, flags);
15e6cdd9
DG		 1116 if (gv)
1117 return gv;
1118 }
256d1bb2 1119 Perl_croak(aTHX_
147e3846
KW		 1120 "Can't locate object method \"%" UTF8f
1121 "\" via package \"%" HEKf "\"",
65308f87 1122 UTF8fARG(is_utf8, name_end - name, name),
d0c0e7dd 1123 HEKfARG(HvNAME_HEK(stash)));
256d1bb2
NC		 1124 }
1125 else {
ecad31f0 1126 SV* packnamesv;
256d1bb2 1127
e2cace1e
YO		 1128 if (last_separator) {
1129 packnamesv = newSVpvn_flags(origname, last_separator - origname,
ecad31f0 1130 SVs_TEMP | is_utf8);
256d1bb2 1131 } else {
017c5e4e 1132 packnamesv = error_report;
256d1bb2
NC		 1133 }
1134
1135 Perl_croak(aTHX_
147e3846
KW		 1136 "Can't locate object method \"%" UTF8f
1137 "\" via package \"%" SVf "\""
1138 " (perhaps you forgot to load \"%" SVf "\"?)",
65308f87 1139 UTF8fARG(is_utf8, name_end - name, name),
ecad31f0 1140 SVfARG(packnamesv), SVfARG(packnamesv));
256d1bb2
NC		 1141 }
1142 }
463ee0b2 1143 }
dc848c6f 1144 else if (autoload) {
9d4ba2ae 1145 CV* const cv = GvCV(gv);
09280a33
CS		 1146 if (!CvROOT(cv) && !CvXSUB(cv)) {
1147 GV* stubgv;
1148 GV* autogv;
1149
0c028dca 1150 if (CvANON(cv) || CvLEXICAL(cv))
09280a33
CS		 1151 stubgv = gv;
1152 else {
1153 stubgv = CvGV(cv);
1154 if (GvCV(stubgv) != cv) /* orphaned import */
1155 stubgv = gv;
1156 }
c8416c26
BF		 1157 autogv = gv_autoload_pvn(GvSTASH(stubgv),
1158 GvNAME(stubgv), GvNAMELEN(stubgv),
1159 GV_AUTOLOAD_ISMETHOD
1160 | (GvNAMEUTF8(stubgv) ? SVf_UTF8 : 0));
dc848c6f 1161 if (autogv)
1162 gv = autogv;
1163 }
1164 }
44a8e56a 1165
1166 return gv;
1167}
1168
1169GV*
0eeb01b9 1170Perl_gv_autoload_sv(pTHX_ HV *stash, SV* namesv, U32 flags)
5fba3c91
BF		 1171{
1172 char *namepv;
1173 STRLEN namelen;
0fe84f7c 1174 PERL_ARGS_ASSERT_GV_AUTOLOAD_SV;
5fba3c91
BF		 1175 namepv = SvPV(namesv, namelen);
1176 if (SvUTF8(namesv))
1177 flags |= SVf_UTF8;
0eeb01b9 1178 return gv_autoload_pvn(stash, namepv, namelen, flags);
5fba3c91
BF		 1179}
1180
1181GV*
0eeb01b9 1182Perl_gv_autoload_pv(pTHX_ HV *stash, const char *namepv, U32 flags)
5fba3c91 1183{
0fe84f7c 1184 PERL_ARGS_ASSERT_GV_AUTOLOAD_PV;
0eeb01b9 1185 return gv_autoload_pvn(stash, namepv, strlen(namepv), flags);
5fba3c91
BF		 1186}
1187
1188GV*
0eeb01b9 1189Perl_gv_autoload_pvn(pTHX_ HV *stash, const char *name, STRLEN len, U32 flags)
44a8e56a 1190{
44a8e56a 1191 GV* gv;
1192 CV* cv;
1193 HV* varstash;
1194 GV* vargv;
1195 SV* varsv;
c8416c26
BF		 1196 SV *packname = NULL;
1197 U32 is_utf8 = flags & SVf_UTF8 ? SVf_UTF8 : 0;
44a8e56a 1198
0fe84f7c 1199 PERL_ARGS_ASSERT_GV_AUTOLOAD_PVN;
7918f24d 1200
7edbdc6b 1201 if (len == S_autolen && memEQ(name, S_autoload, S_autolen))
a0714e2c 1202 return NULL;
0dae17bd
GS		 1203 if (stash) {
1204 if (SvTYPE(stash) < SVt_PVHV) {
c8416c26
BF		 1205 STRLEN packname_len = 0;
1206 const char * const packname_ptr = SvPV_const(MUTABLE_SV(stash), packname_len);
1207 packname = newSVpvn_flags(packname_ptr, packname_len,
1208 SVs_TEMP | SvUTF8(stash));
5c284bb0 1209 stash = NULL;
0dae17bd 1210 }
c8416c26
BF		 1211 else
1212 packname = sv_2mortal(newSVhek(HvNAME_HEK(stash)));
aae43805 1213 if (flags & GV_SUPER) sv_catpvs(packname, "::SUPER");
0dae17bd 1214 }
257dc59d
FC		 1215 if (!(gv = gv_fetchmeth_pvn(stash, S_autoload, S_autolen, FALSE,
1216 is_utf8 | (flags & GV_SUPER))))
a0714e2c 1217 return NULL;
dc848c6f 1218 cv = GvCV(gv);
1219
adb5a9ae 1220 if (!(CvROOT(cv) || CvXSUB(cv)))
a0714e2c 1221 return NULL;
ed850460 1222
dc848c6f 1223 /*
64278e8c 1224 * Inheriting AUTOLOAD for non-methods no longer works
dc848c6f 1225 */
0eeb01b9
FC		 1226 if (
1227 !(flags & GV_AUTOLOAD_ISMETHOD)
1228 && (GvCVGEN(gv) || GvSTASH(gv) != stash)
041457d9 1229 )
64278e8c
A		 1230 Perl_croak(aTHX_ "Use of inherited AUTOLOAD for non-method %" SVf
1231 "::%" UTF8f "() is no longer allowed",
ecad31f0 1232 SVfARG(packname),
b17a0679 1233 UTF8fARG(is_utf8, len, name));
44a8e56a 1234
aed2304a 1235 if (CvISXSUB(cv)) {
bb619f37
FC		 1236 /* Instead of forcing the XSUB do another lookup for $AUTOLOAD
1237 * and split that value on the last '::', pass along the same data
1238 * via the SvPVX field in the CV, and the stash in CvSTASH.
8fa6a409
FC		 1239 *
1240 * Due to an unfortunate accident of history, the SvPVX field
e1fa07e3 1241 * serves two purposes. It is also used for the subroutine's pro-
8fa6a409
FC		 1242 * type. Since SvPVX has been documented as returning the sub name
1243 * for a long time, but not as returning the prototype, we have
1244 * to preserve the SvPVX AUTOLOAD behaviour and put the prototype
1245 * elsewhere.
1246 *
1247 * We put the prototype in the same allocated buffer, but after
1248 * the sub name. The SvPOK flag indicates the presence of a proto-
1249 * type. The CvAUTOLOAD flag indicates the presence of a sub name.
1250 * If both flags are on, then SvLEN is used to indicate the end of
1251 * the prototype (artificially lower than what is actually allo-
1252 * cated), at the risk of having to reallocate a few bytes unneces-
1253 * sarily--but that should happen very rarely, if ever.
1254 *
1255 * We use SvUTF8 for both prototypes and sub names, so if one is
1256 * UTF8, the other must be upgraded.
adb5a9ae 1257 */
c68d9564 1258 CvSTASH_set(cv, stash);
8fa6a409 1259 if (SvPOK(cv)) { /* Ouch! */
e7881358 1260 SV * const tmpsv = newSVpvn_flags(name, len, is_utf8);
8fa6a409
FC		 1261 STRLEN ulen;
1262 const char *proto = CvPROTO(cv);
1263 assert(proto);
1264 if (SvUTF8(cv))
1265 sv_utf8_upgrade_flags_grow(tmpsv, 0, CvPROTOLEN(cv) + 2);
1266 ulen = SvCUR(tmpsv);
1267 SvCUR(tmpsv)++; /* include null in string */
1268 sv_catpvn_flags(
1269 tmpsv, proto, CvPROTOLEN(cv), SV_CATBYTES*!SvUTF8(cv)
1270 );
1271 SvTEMP_on(tmpsv); /* Allow theft */
1272 sv_setsv_nomg((SV *)cv, tmpsv);
05b525f4 1273 SvTEMP_off(tmpsv);
e7881358 1274 SvREFCNT_dec_NN(tmpsv);
59c3c222 1275 SvLEN_set(cv, SvCUR(cv) + 1);
8fa6a409
FC		 1276 SvCUR(cv) = ulen;
1277 }
1278 else {
1279 sv_setpvn((SV *)cv, name, len);
1280 SvPOK_off(cv);
1281 if (is_utf8)
c8416c26 1282 SvUTF8_on(cv);
8fa6a409
FC		 1283 else SvUTF8_off(cv);
1284 }
1285 CvAUTOLOAD_on(cv);
adb5a9ae 1286 }
adb5a9ae 1287
44a8e56a 1288 /*
1289 * Given &FOO::AUTOLOAD, set $FOO::AUTOLOAD to desired function name.
1290 * The subroutine's original name may not be "AUTOLOAD", so we don't
1291 * use that, but for lack of anything better we will use the sub's
1292 * original package to look up $AUTOLOAD.
1293 */
18691622 1294 varstash = CvNAMED(cv) ? CvSTASH(cv) : GvSTASH(CvGV(cv));
5c7983e5 1295 vargv = *(GV**)hv_fetch(varstash, S_autoload, S_autolen, TRUE);
3d35f11b
GS		 1296 ENTER;
1297
c69033f2 1298 if (!isGV(vargv)) {
04ec7e59 1299 gv_init_pvn(vargv, varstash, S_autoload, S_autolen, 0);
c69033f2 1300#ifdef PERL_DONT_CREATE_GVSV
561b68a9 1301 GvSV(vargv) = newSV(0);
c69033f2
NC		 1302#endif
1303 }
3d35f11b 1304 LEAVE;
e203899d 1305 varsv = GvSVn(vargv);
4bac9ae4
CS		 1306 SvTAINTED_off(varsv); /* previous $AUTOLOAD taint is obsolete */
1307 /* XXX: this process is not careful to avoid extra magic gets and sets; tied $AUTOLOAD will get noise */
c8416c26 1308 sv_setsv(varsv, packname);
396482e1 1309 sv_catpvs(varsv, "::");
d40bf27b
NC		 1310 /* Ensure SvSETMAGIC() is called if necessary. In particular, to clear
1311 tainting if $FOO::AUTOLOAD was previously tainted, but is not now. */
61a9130e
FC		 1312 sv_catpvn_flags(
1313 varsv, name, len,
5bcd1ef4 1314 SV_SMAGIC|(is_utf8 ? SV_CATUTF8 : SV_CATBYTES)
61a9130e 1315 );
c8416c26
BF		 1316 if (is_utf8)
1317 SvUTF8_on(varsv);
a0d0e21e
LW		 1318 return gv;
1319}
1320
44a2ac75
YO		 1321
1322/* require_tie_mod() internal routine for requiring a module
486ec47a 1323 * that implements the logic of automatic ties like %! and %-
e94ea821
FC		 1324 * It loads the module and then calls the _tie_it subroutine
1325 * with the passed gv as an argument.
44a2ac75
YO		 1326 *
1327 * The "gv" parameter should be the glob.
ee33cc1a 1328 * "varname" holds the 1-char name of the var, used for error messages.
45cbc99a 1329 * "namesv" holds the module name. Its refcount will be decremented.
45cbc99a 1330 * "flags": if flag & 1 then save the scalar before loading.
44a2ac75
YO		 1331 * For the protection of $! to work (it is set by this routine)
1332 * the sv slot must already be magicalized.
d2c93421 1333 */
e94ea821 1334STATIC void
ee33cc1a 1335S_require_tie_mod(pTHX_ GV *gv, const char varname, const char * name,
a1683482 1336 STRLEN len, const U32 flags)
d2c93421 1337{
e94ea821 1338 const SV * const target = varname == '[' ? GvSV(gv) : (SV *)GvHV(gv);
45cbc99a 1339
7918f24d
NC		 1340 PERL_ARGS_ASSERT_REQUIRE_TIE_MOD;
1341
e94ea821
FC		 1342 /* If it is not tied */
1343 if (!target || !SvRMAGICAL(target)
1344 || !mg_find(target,
1345 varname == '[' ? PERL_MAGIC_tiedscalar : PERL_MAGIC_tied))
1346 {
1347 HV *stash;
1348 GV **gvp;
1349 dSP;
1350
655f5b26 1351 PUSHSTACKi(PERLSI_MAGIC);
e94ea821 1352 ENTER;
e94ea821 1353
6881372e
FC		 1354#define GET_HV_FETCH_TIE_FUNC \
1355 ( (gvp = (GV **)hv_fetchs(stash, "_tie_it", 0)) \
1356 && *gvp \
1357 && ( (isGV(*gvp) && GvCV(*gvp)) \
1358 || (SvROK(*gvp) && SvTYPE(SvRV(*gvp)) == SVt_PVCV) ) \
1359 )
e94ea821
FC		 1360
1361 /* Load the module if it is not loaded. */
360cebfd 1362 if (!(stash = gv_stashpvn(name, len, 0))
6881372e 1363 || ! GET_HV_FETCH_TIE_FUNC)
e94ea821 1364 {
360cebfd 1365 SV * const module = newSVpvn(name, len);
b82b06b8 1366 const char type = varname == '[' ? '$' : '%';
44a2ac75 1367 if ( flags & 1 )
45cbc99a 1368 save_scalar(gv);
5b2ef88e 1369 Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT, module, NULL);
61bac25c 1370 assert(sp == PL_stack_sp);
360cebfd 1371 stash = gv_stashpvn(name, len, 0);
44a2ac75 1372 if (!stash)
360cebfd
FC		 1373 Perl_croak(aTHX_ "panic: Can't use %c%c because %s is not available",
1374 type, varname, name);
6881372e 1375 else if (! GET_HV_FETCH_TIE_FUNC)
360cebfd
FC		 1376 Perl_croak(aTHX_ "panic: Can't use %c%c because %s does not define _tie_it",
1377 type, varname, name);
e94ea821
FC		 1378 }
1379 /* Now call the tie function. It should be in *gvp. */
6881372e 1380 assert(gvp); assert(*gvp);
e94ea821
FC		 1381 PUSHMARK(SP);
1382 XPUSHs((SV *)gv);
1383 PUTBACK;
1384 call_sv((SV *)*gvp, G_VOID|G_DISCARD);
1385 LEAVE;
655f5b26 1386 POPSTACK;
d2c93421
RH		 1387 }
1388}
1389
7c719134
YO		 1390/* add a require_tie_mod_s - the _s suffix is similar to pvs type suffixes,
1391 * IOW it means we do STR_WITH_LEN() ourselves and the user should pass in
1392 * a true string WITHOUT a len.
1393 */
1394#define require_tie_mod_s(gv, varname, name, flags) \
1395 S_require_tie_mod(aTHX_ gv, varname, STR_WITH_LEN(name), flags)
1396
954c1994
GS		 1397/*
1398=for apidoc gv_stashpv
1399
da51bb9b 1400Returns a pointer to the stash for a specified package. Uses C<strlen> to
75c442e4 1401determine the length of C<name>, then calls C<gv_stashpvn()>.
954c1994
GS		 1402
1403=cut
1404*/
1405
a0d0e21e 1406HV*
864dbfa3 1407Perl_gv_stashpv(pTHX_ const char *name, I32 create)
a0d0e21e 1408{
7918f24d 1409 PERL_ARGS_ASSERT_GV_STASHPV;
dc437b57 1410 return gv_stashpvn(name, strlen(name), create);
1411}
1412
bc96cb06
SH		 1413/*
1414=for apidoc gv_stashpvn
1415
da51bb9b
NC		 1416Returns a pointer to the stash for a specified package. The C<namelen>
1417parameter indicates the length of the C<name>, in bytes. C<flags> is passed
1418to C<gv_fetchpvn_flags()>, so if set to C<GV_ADD> then the package will be
1419created if it does not already exist. If the package does not exist and
796b6530 1420C<flags> is 0 (or any other setting that does not create packages) then C<NULL>
da51bb9b
NC		 1421is returned.
1422
566a4718
YO		 1423Flags may be one of:
1424
1425 GV_ADD
1426 SVf_UTF8
1427 GV_NOADD_NOINIT
1428 GV_NOINIT
1429 GV_NOEXPAND
1430 GV_ADDMG
1431
796b6530 1432The most important of which are probably C<GV_ADD> and C<SVf_UTF8>.
bc96cb06 1433
808724c8 1434Note, use of C<gv_stashsv> instead of C<gv_stashpvn> where possible is strongly
1435recommended for performance reasons.
1436
bc96cb06
SH		 1437=cut
1438*/
1439
0eadbdad
YO		 1440/*
1441gv_stashpvn_internal
1442
1443Perform the internal bits of gv_stashsvpvn_cached. You could think of this
1444as being one half of the logic. Not to be called except from gv_stashsvpvn_cached().
1445
1446*/
1447
4e7ebec5 1448PERL_STATIC_INLINE HV*
0eadbdad 1449S_gv_stashpvn_internal(pTHX_ const char *name, U32 namelen, I32 flags)
dc437b57 1450{
0cea0058 1451 char smallbuf[128];
46fc3d4c 1452 char *tmpbuf;
a0d0e21e
LW		 1453 HV *stash;
1454 GV *tmpgv;
add0ecde 1455 U32 tmplen = namelen + 2;
dc437b57 1456
0eadbdad 1457 PERL_ARGS_ASSERT_GV_STASHPVN_INTERNAL;
7918f24d 1458
add0ecde 1459 if (tmplen <= sizeof smallbuf)
46fc3d4c 1460 tmpbuf = smallbuf;
1461 else
add0ecde
VP		 1462 Newx(tmpbuf, tmplen, char);
1463 Copy(name, tmpbuf, namelen, char);
1464 tmpbuf[namelen] = ':';
1465 tmpbuf[namelen+1] = ':';
1466 tmpgv = gv_fetchpvn_flags(tmpbuf, tmplen, flags, SVt_PVHV);
46fc3d4c 1467 if (tmpbuf != smallbuf)
1468 Safefree(tmpbuf);
d2fcb1d6 1469 if (!tmpgv || !isGV_with_GP(tmpgv))
da51bb9b 1470 return NULL;
a0d0e21e 1471 stash = GvHV(tmpgv);
1f656fcf 1472 if (!(flags & ~GV_NOADD_MASK) && !stash) return NULL;
9efb5c72 1473 assert(stash);
1f656fcf 1474 if (!HvNAME_get(stash)) {
0be4d16f 1475 hv_name_set(stash, name, namelen, flags & SVf_UTF8 ? SVf_UTF8 : 0 );
1f656fcf
FC		 1476
1477 /* FIXME: This is a repeat of logic in gv_fetchpvn_flags */
1478 /* If the containing stash has multiple effective
1479 names, see that this one gets them, too. */
1480 if (HvAUX(GvSTASH(tmpgv))->xhv_name_count)
1481 mro_package_moved(stash, NULL, tmpgv, 1);
1482 }
a0d0e21e 1483 return stash;
463ee0b2
LW		 1484}
1485
808724c8 1486/*
1487gv_stashsvpvn_cached
1488
1489Returns a pointer to the stash for a specified package, possibly
48a81373 1490cached. Implements both C<gv_stashpvn> and C<gv_stashsv>.
808724c8 1491
1492Requires one of either namesv or namepv to be non-null.
1493
fbe13c60 1494See C<L</gv_stashpvn>> for details on "flags".
808724c8 1495
1496Note the sv interface is strongly preferred for performance reasons.
1497
1498*/
1499
1500#define PERL_ARGS_ASSERT_GV_STASHSVPVN_CACHED \
1501 assert(namesv || name)
1502
1503PERL_STATIC_INLINE HV*
1504S_gv_stashsvpvn_cached(pTHX_ SV *namesv, const char *name, U32 namelen, I32 flags)
4e7ebec5 1505{
1506 HV* stash;
808724c8 1507 HE* he;
1508
1509 PERL_ARGS_ASSERT_GV_STASHSVPVN_CACHED;
1510
1511 he = (HE *)hv_common(
1512 PL_stashcache, namesv, name, namelen,
4e7ebec5 1513 (flags & SVf_UTF8) ? HVhek_UTF8 : 0, 0, NULL, 0
1514 );
808724c8 1515
78e4f28f
DM		 1516 if (he) {
1517 SV *sv = HeVAL(he);
1518 HV *hv;
1519 assert(SvIOK(sv));
1520 hv = INT2PTR(HV*, SvIVX(sv));
1521 assert(SvTYPE(hv) == SVt_PVHV);
1522 return hv;
1523 }
d283e876 1524 else if (flags & GV_CACHE_ONLY) return NULL;
4e7ebec5 1525
808724c8 1526 if (namesv) {
1527 if (SvOK(namesv)) { /* prevent double uninit warning */
1528 STRLEN len;
1529 name = SvPV_const(namesv, len);
1530 namelen = len;
1531 flags |= SvUTF8(namesv);
1532 } else {
1533 name = ""; namelen = 0;
1534 }
1535 }
0eadbdad
YO		 1536 stash = gv_stashpvn_internal(name, namelen, flags);
1537
4e7ebec5 1538 if (stash && namelen) {
1539 SV* const ref = newSViv(PTR2IV(stash));
0eadbdad 1540 (void)hv_store(PL_stashcache, name,
4e7ebec5 1541 (flags & SVf_UTF8) ? -(I32)namelen : (I32)namelen, ref, 0);
1542 }
808724c8 1543
4e7ebec5 1544 return stash;
1545}
1546
808724c8 1547HV*
1548Perl_gv_stashpvn(pTHX_ const char *name, U32 namelen, I32 flags)
1549{
1550 PERL_ARGS_ASSERT_GV_STASHPVN;
1551 return gv_stashsvpvn_cached(NULL, name, namelen, flags);
1552}
1553
954c1994
GS		 1554/*
1555=for apidoc gv_stashsv
1556
fbe13c60
KW		 1557Returns a pointer to the stash for a specified package. See
1558C<L</gv_stashpvn>>.
954c1994 1559
fbe13c60
KW		 1560Note this interface is strongly preferred over C<gv_stashpvn> for performance
1561reasons.
808724c8 1562
954c1994
GS		 1563=cut
1564*/
1565
a0d0e21e 1566HV*
da51bb9b 1567Perl_gv_stashsv(pTHX_ SV *sv, I32 flags)
a0d0e21e 1568{
7918f24d 1569 PERL_ARGS_ASSERT_GV_STASHSV;
808724c8 1570 return gv_stashsvpvn_cached(sv, NULL, 0, flags);
a0d0e21e
LW		 1571}
1572
1573
463ee0b2 1574GV *
fe9845cc 1575Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 add, const svtype sv_type) {
7918f24d 1576 PERL_ARGS_ASSERT_GV_FETCHPV;
b7787f18 1577 return gv_fetchpvn_flags(nambeg, strlen(nambeg), add, sv_type);
7a5fd60d
NC		 1578}
1579
1580GV *
fe9845cc 1581Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type) {
7a5fd60d 1582 STRLEN len;
77cb3b01
FC		 1583 const char * const nambeg =
1584 SvPV_flags_const(name, len, flags & GV_NO_SVGMAGIC ? 0 : SV_GMAGIC);
7918f24d 1585 PERL_ARGS_ASSERT_GV_FETCHSV;
7a5fd60d
NC		 1586 return gv_fetchpvn_flags(nambeg, len, flags | SvUTF8(name), sv_type);
1587}
1588
90aeefb4 1589PERL_STATIC_INLINE void
290a1700 1590S_gv_magicalize_isa(pTHX_ GV *gv)
ad7cce9f
FR		 1591{
1592 AV* av;
1593
1594 PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA;
1595
1596 av = GvAVn(gv);
1597 GvMULTI_on(gv);
1598 sv_magic(MUTABLE_SV(av), MUTABLE_SV(gv), PERL_MAGIC_isa,
1599 NULL, 0);
ad7cce9f
FR		 1600}
1601
90aeefb4
BF		 1602/* This function grabs name and tries to split a stash and glob
1603 * from its contents. TODO better description, comments
1604 *
1605 * If the function returns TRUE and 'name == name_end', then
1606 * 'gv' can be directly returned to the caller of gv_fetchpvn_flags
1607 */
1608PERL_STATIC_INLINE bool
1609S_parse_gv_stash_name(pTHX_ HV **stash, GV **gv, const char **name,
1610 STRLEN *len, const char *nambeg, STRLEN full_len,
1611 const U32 is_utf8, const I32 add)
1612{
8c573bee 1613 char *tmpfullbuf = NULL; /* only malloc one big chunk of memory when the smallbuff is not large enough */
90aeefb4
BF		 1614 const char *name_cursor;
1615 const char *const name_end = nambeg + full_len;
1616 const char *const name_em1 = name_end - 1;
8c573bee 1617 char smallbuf[64]; /* small buffer to avoid a malloc when possible */
90aeefb4
BF		 1618
1619 PERL_ARGS_ASSERT_PARSE_GV_STASH_NAME;
1620
7a207065
KW		 1621 if ( full_len > 2
1622 && **name == '*'
1623 && isIDFIRST_lazy_if_safe(*name + 1, name_end, is_utf8))
1624 {
90aeefb4
BF		 1625 /* accidental stringify on a GV? */
1626 (*name)++;
1627 }
1628
1629 for (name_cursor = *name; name_cursor < name_end; name_cursor++) {
1630 if (name_cursor < name_em1 &&
1631 ((*name_cursor == ':' && name_cursor[1] == ':')
1632 || *name_cursor == '\''))
1633 {
1634 if (!*stash)
1635 *stash = PL_defstash;
1636 if (!*stash || !SvREFCNT(*stash)) /* symbol table under destruction */
1637 return FALSE;
1638
1639 *len = name_cursor - *name;
1640 if (name_cursor > nambeg) { /* Skip for initial :: or ' */
1641 const char *key;
1642 GV**gvp;
1643 if (*name_cursor == ':') {
1644 key = *name;
1645 *len += 2;
1646 }
f8ac814f 1647 else { /* using ' for package separator */
8c573bee
N		 1648 /* use our pre-allocated buffer when possible to save a malloc */
1649 char *tmpbuf;
1650 if ( *len+2 <= sizeof smallbuf)
1651 tmpbuf = smallbuf;
1652 else {
1653 /* only malloc once if needed */
1654 if (tmpfullbuf == NULL) /* only malloc&free once, a little more than needed */
1655 Newx(tmpfullbuf, full_len+2, char);
1656 tmpbuf = tmpfullbuf;
1657 }
90aeefb4
BF		 1658 Copy(*name, tmpbuf, *len, char);
1659 tmpbuf[(*len)++] = ':';
1660 tmpbuf[(*len)++] = ':';
1661 key = tmpbuf;
1662 }
c161da64 1663 gvp = (GV**)hv_fetch(*stash, key, is_utf8 ? -((I32)*len) : (I32)*len, add);
90aeefb4 1664 *gv = gvp ? *gvp : NULL;
f8ac814f 1665 if (!*gv || *gv == (const GV *)&PL_sv_undef) {
8c573bee 1666 Safefree(tmpfullbuf); /* free our tmpfullbuf if it was used */
90aeefb4 1667 return FALSE;
f8ac814f
N		 1668 }
1669 /* here we know that *gv && *gv != &PL_sv_undef */
1670 if (SvTYPE(*gv) != SVt_PVGV)
1671 gv_init_pvn(*gv, *stash, key, *len, (add & GV_ADDMULTI)|is_utf8);
1672 else
1673 GvMULTI_on(*gv);
90aeefb4
BF		 1674
1675 if (!(*stash = GvHV(*gv))) {
1676 *stash = GvHV(*gv) = newHV();
1677 if (!HvNAME_get(*stash)) {
1678 if (GvSTASH(*gv) == PL_defstash && *len == 6
c8b388b0 1679 && strBEGINs(*name, "CORE"))
4c4f3c46 1680 hv_name_sets(*stash, "CORE", 0);
90aeefb4
BF		 1681 else
1682 hv_name_set(
1683 *stash, nambeg, name_cursor-nambeg, is_utf8
1684 );
1685 /* If the containing stash has multiple effective
1686 names, see that this one gets them, too. */
1687 if (HvAUX(GvSTASH(*gv))->xhv_name_count)
1688 mro_package_moved(*stash, NULL, *gv, 1);
1689 }
1690 }
1691 else if (!HvNAME_get(*stash))
1692 hv_name_set(*stash, nambeg, name_cursor - nambeg, is_utf8);
1693 }
1694
1695 if (*name_cursor == ':')
1696 name_cursor++;
1697 *name = name_cursor+1;
1698 if (*name == name_end) {
120921ac
Z		 1699 if (!*gv) {
1700 *gv = MUTABLE_GV(*hv_fetchs(PL_defstash, "main::", TRUE));
1701 if (SvTYPE(*gv) != SVt_PVGV) {
1702 gv_init_pvn(*gv, PL_defstash, "main::", 6,
1703 GV_ADDMULTI);
1704 GvHV(*gv) =
1705 MUTABLE_HV(SvREFCNT_inc_simple(PL_defstash));
1706 }
1707 }
8c573bee 1708 Safefree(tmpfullbuf); /* free our tmpfullbuf if it was used */
90aeefb4
BF		 1709 return TRUE;
1710 }
1711 }
1712 }
1713 *len = name_cursor - *name;
1714 return TRUE;
1715}
1716
536d1a88 1717/* Checks if an unqualified name is in the main stash */
90aeefb4 1718PERL_STATIC_INLINE bool
536d1a88 1719S_gv_is_in_main(pTHX_ const char *name, STRLEN len, const U32 is_utf8)
90aeefb4 1720{
536d1a88 1721 PERL_ARGS_ASSERT_GV_IS_IN_MAIN;
90aeefb4 1722
90aeefb4 1723 /* If it's an alphanumeric variable */
7a207065 1724 if ( len && isIDFIRST_lazy_if_safe(name, name + len, is_utf8) ) {
90aeefb4
BF		 1725 /* Some "normal" variables are always in main::,
1726 * like INC or STDOUT.
1727 */
1728 switch (len) {
1729 case 1:
1730 if (*name == '_')
536d1a88 1731 return TRUE;
90aeefb4
BF		 1732 break;
1733 case 3:
1734 if ((name[0] == 'I' && name[1] == 'N' && name[2] == 'C')
1735 || (name[0] == 'E' && name[1] == 'N' && name[2] == 'V')
1736 || (name[0] == 'S' && name[1] == 'I' && name[2] == 'G'))
536d1a88 1737 return TRUE;
90aeefb4
BF		 1738 break;
1739 case 4:
1740 if (name[0] == 'A' && name[1] == 'R' && name[2] == 'G'
1741 && name[3] == 'V')
536d1a88 1742 return TRUE;
90aeefb4
BF		 1743 break;
1744 case 5:
1745 if (name[0] == 'S' && name[1] == 'T' && name[2] == 'D'
1746 && name[3] == 'I' && name[4] == 'N')
536d1a88 1747 return TRUE;
90aeefb4
BF		 1748 break;
1749 case 6:
1750 if ((name[0] == 'S' && name[1] == 'T' && name[2] == 'D')
1751 &&((name[3] == 'O' && name[4] == 'U' && name[5] == 'T')
1752 ||(name[3] == 'E' && name[4] == 'R' && name[5] == 'R')))
536d1a88 1753 return TRUE;
90aeefb4
BF		 1754 break;
1755 case 7:
1756 if (name[0] == 'A' && name[1] == 'R' && name[2] == 'G'
1757 && name[3] == 'V' && name[4] == 'O' && name[5] == 'U'
1758 && name[6] == 'T')
536d1a88 1759 return TRUE;
90aeefb4
BF		 1760 break;
1761 }
536d1a88
BF		 1762 }
1763 /* *{""}, or a special variable like $@ */
1764 else
1765 return TRUE;
1766
1767 return FALSE;
1768}
1769
1770
1771/* This function is called if parse_gv_stash_name() failed to
1772 * find a stash, or if GV_NOTQUAL or an empty name was passed
1773 * to gv_fetchpvn_flags.
1774 *
1775 * It returns FALSE if the default stash can't be found nor created,
1776 * which might happen during global destruction.
1777 */
1778PERL_STATIC_INLINE bool
1779S_find_default_stash(pTHX_ HV **stash, const char *name, STRLEN len,
1780 const U32 is_utf8, const I32 add,
1781 const svtype sv_type)
1782{
1783 PERL_ARGS_ASSERT_FIND_DEFAULT_STASH;
1784
1785 /* No stash in name, so see how we can default */
90aeefb4 1786
536d1a88
BF		 1787 if ( gv_is_in_main(name, len, is_utf8) ) {
1788 *stash = PL_defstash;
1789 }
1790 else {
1791 if (IN_PERL_COMPILETIME) {
90aeefb4
BF		 1792 *stash = PL_curstash;
1793 if (add && (PL_hints & HINT_STRICT_VARS) &&
1794 sv_type != SVt_PVCV &&
1795 sv_type != SVt_PVGV &&
1796 sv_type != SVt_PVFM &&
1797 sv_type != SVt_PVIO &&
1798 !(len == 1 && sv_type == SVt_PV &&
1799 (*name == 'a' || *name == 'b')) )
1800 {
c161da64 1801 GV**gvp = (GV**)hv_fetch(*stash,name,is_utf8 ? -(I32)len : (I32)len,0);
90aeefb4
BF		 1802 if (!gvp || *gvp == (const GV *)&PL_sv_undef ||
1803 SvTYPE(*gvp) != SVt_PVGV)
1804 {
1805 *stash = NULL;
1806 }
1807 else if ((sv_type == SVt_PV && !GvIMPORTED_SV(*gvp)) ||
1808 (sv_type == SVt_PVAV && !GvIMPORTED_AV(*gvp)) ||
1809 (sv_type == SVt_PVHV && !GvIMPORTED_HV(*gvp)) )
1810 {
1811 /* diag_listed_as: Variable "%s" is not imported%s */
1812 Perl_ck_warner_d(
1813 aTHX_ packWARN(WARN_MISC),
147e3846 1814 "Variable \"%c%" UTF8f "\" is not imported",
90aeefb4
BF		 1815 sv_type == SVt_PVAV ? '@' :
1816 sv_type == SVt_PVHV ? '%' : '$',
1817 UTF8fARG(is_utf8, len, name));
1818 if (GvCVu(*gvp))
1819 Perl_ck_warner_d(
1820 aTHX_ packWARN(WARN_MISC),
147e3846 1821 "\t(Did you mean &%" UTF8f " instead?)\n",
90aeefb4
BF		 1822 UTF8fARG(is_utf8, len, name)
1823 );
1824 *stash = NULL;
1825 }
1826 }
1827 }
1828 else {
1829 /* Use the current op's stash */
1830 *stash = CopSTASH(PL_curcop);
1831 }
1832 }
90aeefb4
BF		 1833
1834 if (!*stash) {
1835 if (add && !PL_in_clean_all) {
10860bf4
FC		 1836 GV *gv;
1837 qerror(Perl_mess(aTHX_
147e3846 1838 "Global symbol \"%s%" UTF8f
d8c6310a 1839 "\" requires explicit package name (did you forget to "
147e3846 1840 "declare \"my %s%" UTF8f "\"?)",
d8c6310a
FC		 1841 (sv_type == SVt_PV ? "$"
1842 : sv_type == SVt_PVAV ? "@"
1843 : sv_type == SVt_PVHV ? "%"
1844 : ""), UTF8fARG(is_utf8, len, name),
90aeefb4
BF		 1845 (sv_type == SVt_PV ? "$"
1846 : sv_type == SVt_PVAV ? "@"
1847 : sv_type == SVt_PVHV ? "%"
10860bf4 1848 : ""), UTF8fARG(is_utf8, len, name)));
cd164bf8
BF		 1849 /* To maintain the output of errors after the strict exception
1850 * above, and to keep compat with older releases, rather than
1851 * placing the variables in the pad, we place
1852 * them in the <none>:: stash.
1853 */
90aeefb4
BF		 1854 gv = gv_fetchpvs("<none>::", GV_ADDMULTI, SVt_PVHV);
1855 if (!gv) {
1856 /* symbol table under destruction */
1857 return FALSE;
1858 }
1859 *stash = GvHV(gv);
1860 }
1861 else
1862 return FALSE;
1863 }
1864
1865 if (!SvREFCNT(*stash)) /* symbol table under destruction */
1866 return FALSE;
1867
1868 return TRUE;
1869}
1870
8c995aba
FC		 1871/* gv_magicalize only turns on the SVf_READONLY flag, not SVf_PROTECT. So
1872 redefine SvREADONLY_on for that purpose. We don’t use it later on in
1873 this file. */
1874#undef SvREADONLY_on
1875#define SvREADONLY_on(sv) (SvFLAGS(sv) |= SVf_READONLY)
1876
930867a8
BF		 1877/* gv_magicalize() is called by gv_fetchpvn_flags when creating
1878 * a new GV.
1879 * Note that it does not insert the GV into the stash prior to
1880 * magicalization, which some variables require need in order
1881 * to work (like $[, %+, %-, %!), so callers must take care of
1321bbe3 1882 * that.
930867a8 1883 *
1321bbe3
FC		 1884 * It returns true if the gv did turn out to be magical one; i.e.,
1885 * if gv_magicalize actually did something.
930867a8
BF		 1886 */
1887PERL_STATIC_INLINE bool
1888S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len,
1321bbe3 1889 const svtype sv_type)
79072805 1890{
960b831f 1891 SSize_t paren;
79072805 1892
930867a8 1893 PERL_ARGS_ASSERT_GV_MAGICALIZE;
90aeefb4 1894
44428a46 1895 if (stash != PL_defstash) { /* not the main stash */
ea238638 1896 /* We only have to check for a few names here: a, b, EXPORT, ISA
4aaa4757
FC		 1897 and VERSION. All the others apply only to the main stash or to
1898 CORE (which is checked right after this). */
ea238638 1899 if (len) {
cc4c2da6 1900 switch (*name) {
cc4c2da6 1901 case 'E':
3092ee0c
YO		 1902 if (
1903 len >= 6 && name[1] == 'X' &&
1904 (memEQs(name, len, "EXPORT")
eafd371c
YO		 1905 ||memEQs(name, len, "EXPORT_OK")
1906 ||memEQs(name, len, "EXPORT_FAIL")
3092ee0c 1907 ||memEQs(name, len, "EXPORT_TAGS"))
eafd371c 1908 )
cc4c2da6
NC		 1909 GvMULTI_on(gv);
1910 break;
1911 case 'I':
eafd371c 1912 if (memEQs(name, len, "ISA"))
290a1700 1913 gv_magicalize_isa(gv);
cc4c2da6 1914 break;
44428a46 1915 case 'V':
eafd371c 1916 if (memEQs(name, len, "VERSION"))
44428a46
FC		 1917 GvMULTI_on(gv);
1918 break;
ea238638 1919 case 'a':
eafd371c 1920 if (stash == PL_debstash && memEQs(name, len, "args")) {
7bb33634
FC		 1921 GvMULTI_on(gv_AVadd(gv));
1922 break;
eafd371c
YO		 1923 }
1924 /* FALLTHROUGH */
ea238638
FC		 1925 case 'b':
1926 if (len == 1 && sv_type == SVt_PV)
1927 GvMULTI_on(gv);
924ba076 1928 /* FALLTHROUGH */
4aaa4757
FC		 1929 default:
1930 goto try_core;
1931 }
1321bbe3 1932 goto ret;
4aaa4757
FC		 1933 }
1934 try_core:
1935 if (len > 1 /* shortest is uc */ && HvNAMELEN_get(stash) == 4) {
1936 /* Avoid null warning: */
1937 const char * const stashname = HvNAME(stash); assert(stashname);
c8b388b0 1938 if (strBEGINs(stashname, "CORE"))
87566176 1939 S_maybe_add_coresub(aTHX_ 0, gv, name, len);
44428a46
FC		 1940 }
1941 }
1942 else if (len > 1) {
1943#ifndef EBCDIC
1944 if (*name > 'V' ) {
1945 NOOP;
1946 /* Nothing else to do.
1947 The compiler will probably turn the switch statement into a
1948 branch table. Make sure we avoid even that small overhead for
2ae25f5c
KW		 1949 the common case of lower case variable names. (On EBCDIC
1950 platforms, we can't just do:
1951 if (NATIVE_TO_ASCII(*name) > NATIVE_TO_ASCII('V') ) {
1952 because cases like '\027' in the switch statement below are
1953 C1 (non-ASCII) controls on those platforms, so the remapping
1954 would make them larger than 'V')
1955 */
44428a46
FC		 1956 } else
1957#endif
1958 {
44428a46
FC		 1959 switch (*name) {
1960 case 'A':
eafd371c 1961 if (memEQs(name, len, "ARGV")) {
44428a46
FC		 1962 IoFLAGS(GvIOn(gv)) |= IOf_ARGV|IOf_START;
1963 }
eafd371c 1964 else if (memEQs(name, len, "ARGVOUT")) {
44428a46
FC		 1965 GvMULTI_on(gv);
1966 }
1967 break;
1968 case 'E':
3092ee0c
YO		 1969 if (
1970 len >= 6 && name[1] == 'X' &&
1971 (memEQs(name, len, "EXPORT")
055ae706
YO		 1972 ||memEQs(name, len, "EXPORT_OK")
1973 ||memEQs(name, len, "EXPORT_FAIL")
3092ee0c 1974 ||memEQs(name, len, "EXPORT_TAGS"))
055ae706 1975 )
44428a46
FC		 1976 GvMULTI_on(gv);
1977 break;
1978 case 'I':
eafd371c 1979 if (memEQs(name, len, "ISA")) {
290a1700 1980 gv_magicalize_isa(gv);
44428a46
FC		 1981 }
1982 break;
cc4c2da6 1983 case 'S':
eafd371c 1984 if (memEQs(name, len, "SIG")) {
cc4c2da6
NC		 1985 HV *hv;
1986 I32 i;
d525a7b2
NC		 1987 if (!PL_psig_name) {
1988 Newxz(PL_psig_name, 2 * SIG_SIZE, SV*);
a02a5408 1989 Newxz(PL_psig_pend, SIG_SIZE, int);
d525a7b2 1990 PL_psig_ptr = PL_psig_name + SIG_SIZE;
0bdedcb3
NC		 1991 } else {
1992 /* I think that the only way to get here is to re-use an
1993 embedded perl interpreter, where the previous
1994 use didn't clean up fully because
1995 PL_perl_destruct_level was 0. I'm not sure that we
1996 "support" that, in that I suspect in that scenario
1997 there are sufficient other garbage values left in the
1998 interpreter structure that something else will crash
1999 before we get here. I suspect that this is one of
2000 those "doctor, it hurts when I do this" bugs. */
d525a7b2 2001 Zero(PL_psig_name, 2 * SIG_SIZE, SV*);
0bdedcb3 2002 Zero(PL_psig_pend, SIG_SIZE, int);
cc4c2da6
NC		 2003 }
2004 GvMULTI_on(gv);
2005 hv = GvHVn(gv);
a0714e2c 2006 hv_magic(hv, NULL, PERL_MAGIC_sig);
cc4c2da6 2007 for (i = 1; i < SIG_SIZE; i++) {
551405c4 2008 SV * const * const init = hv_fetch(hv, PL_sig_name[i], strlen(PL_sig_name[i]), 1);
cc4c2da6
NC		 2009 if (init)
2010 sv_setsv(*init, &PL_sv_undef);
cc4c2da6
NC		 2011 }
2012 }
2013 break;
2014 case 'V':
eafd371c 2015 if (memEQs(name, len, "VERSION"))
cc4c2da6
NC		 2016 GvMULTI_on(gv);
2017 break;
e5218da5 2018 case '\003': /* $^CHILD_ERROR_NATIVE */
eafd371c 2019 if (memEQs(name, len, "\003HILD_ERROR_NATIVE"))
e5218da5 2020 goto magicalize;
27deb0cf
YO		 2021 /* @{^CAPTURE} %{^CAPTURE} */
2022 if (memEQs(name, len, "\003APTURE")) {
2023 AV* const av = GvAVn(gv);
fa531f32 2024 const Size_t n = *name;
27deb0cf 2025
fa531f32 2026 sv_magic(MUTABLE_SV(av), (SV*)n, PERL_MAGIC_regdata, NULL, 0);
27deb0cf
YO		 2027 SvREADONLY_on(av);
2028
2029 if (sv_type == SVt_PVHV || sv_type == SVt_PVGV)
2030 require_tie_mod_s(gv, '-', "Tie::Hash::NamedCapture",0);
2031
2032 } else /* %{^CAPTURE_ALL} */
2033 if (memEQs(name, len, "\003APTURE_ALL")) {
2034 if (sv_type == SVt_PVHV || sv_type == SVt_PVGV)
2035 require_tie_mod_s(gv, '+', "Tie::Hash::NamedCapture",0);
2036 }
e5218da5 2037 break;
cc4c2da6 2038 case '\005': /* $^ENCODING */
eafd371c 2039 if (memEQs(name, len, "\005NCODING"))
cc4c2da6
NC		 2040 goto magicalize;
2041 break;
9ebf26ad 2042 case '\007': /* $^GLOBAL_PHASE */
eafd371c 2043 if (memEQs(name, len, "\007LOBAL_PHASE"))
9ebf26ad
FR		 2044 goto ro_magicalize;
2045 break;
8561ea1d 2046 case '\014': /* $^LAST_FH */
eafd371c 2047 if (memEQs(name, len, "\014AST_FH"))
8561ea1d
FC		 2048 goto ro_magicalize;
2049 break;
cde0cee5 2050 case '\015': /* $^MATCH */
eafd371c 2051 if (memEQs(name, len, "\015ATCH")) {
960b831f
NC		 2052 paren = RX_BUFF_IDX_CARET_FULLMATCH;
2053 goto storeparen;
2054 }
66230c86 2055 break;
cc4c2da6 2056 case '\017': /* $^OPEN */
eafd371c 2057 if (memEQs(name, len, "\017PEN"))
cc4c2da6
NC		 2058 goto magicalize;
2059 break;
cde0cee5 2060 case '\020': /* $^PREMATCH $^POSTMATCH */
eafd371c 2061 if (memEQs(name, len, "\020REMATCH")) {
960b831f
NC		 2062 paren = RX_BUFF_IDX_CARET_PREMATCH;
2063 goto storeparen;
2064 }
eafd371c 2065 if (memEQs(name, len, "\020OSTMATCH")) {
960b831f
NC		 2066 paren = RX_BUFF_IDX_CARET_POSTMATCH;
2067 goto storeparen;
2068 }
9ebf26ad 2069 break;
f512d242
KW		 2070 case '\023':
2071 if (memEQs(name, len, "\023AFE_LOCALES"))
2072 goto ro_magicalize;
2073 break;
cc4c2da6 2074 case '\024': /* ${^TAINT} */
eafd371c 2075 if (memEQs(name, len, "\024AINT"))
cc4c2da6
NC		 2076 goto ro_magicalize;
2077 break;
7cebcbc0 2078 case '\025': /* ${^UNICODE}, ${^UTF8LOCALE} */
eafd371c 2079 if (memEQs(name, len, "\025NICODE"))
cc4c2da6 2080 goto ro_magicalize;
eafd371c 2081 if (memEQs(name, len, "\025TF8LOCALE"))
7cebcbc0 2082 goto ro_magicalize;
eafd371c 2083 if (memEQs(name, len, "\025TF8CACHE"))
e07ea26a 2084 goto magicalize;
cc4c2da6
NC		 2085 break;
2086 case '\027': /* $^WARNING_BITS */
eafd371c 2087 if (memEQs(name, len, "\027ARNING_BITS"))
cc4c2da6 2088 goto magicalize;
8ca2a5d6 2089#ifdef WIN32
eafd371c 2090 else if (memEQs(name, len, "\027IN32_SLOPPY_STAT"))
8ca2a5d6
DD		 2091 goto magicalize;
2092#endif
cc4c2da6
NC		 2093 break;
2094 case '1':
2095 case '2':
2096 case '3':
2097 case '4':
2098 case '5':
2099 case '6':
2100 case '7':
2101 case '8':
2102 case '9':
85e6fe83 2103 {
2fdbfb4d
AB		 2104 /* Ensures that we have an all-digit variable, ${"1foo"} fails
2105 this test */
22ff3130
HS		 2106 UV uv;
2107 if (!grok_atoUV(name, &uv, NULL) || uv > I32_MAX)
1321bbe3 2108 goto ret;
22ff3130
HS		 2109 /* XXX why are we using a SSize_t? */
2110 paren = (SSize_t)(I32)uv;
960b831f 2111 goto storeparen;
1d7c1841 2112 }
dc437b57 2113 }
93a17b20 2114 }
392db708
NC		 2115 } else {
2116 /* Names of length 1. (Or 0. But name is NUL terminated, so that will
2117 be case '\0' in this switch statement (ie a default case) */
cc4c2da6 2118 switch (*name) {
6361f656 2119 case '&': /* $& */
960b831f
NC		 2120 paren = RX_BUFF_IDX_FULLMATCH;
2121 goto sawampersand;
6361f656 2122 case '`': /* $` */
960b831f
NC		 2123 paren = RX_BUFF_IDX_PREMATCH;
2124 goto sawampersand;
6361f656 2125 case '\'': /* $' */
960b831f
NC		 2126 paren = RX_BUFF_IDX_POSTMATCH;
2127 sawampersand:
1a904fc8 2128#ifdef PERL_SAWAMPERSAND
a289ef89 2129 if (!(
cc4c2da6
NC		 2130 sv_type == SVt_PVAV ||
2131 sv_type == SVt_PVHV ||
2132 sv_type == SVt_PVCV ||
2133 sv_type == SVt_PVFM ||
2134 sv_type == SVt_PVIO
d3b97530
DM		 2135 )) { PL_sawampersand |=
2136 (*name == '`')
2137 ? SAWAMPERSAND_LEFT
2138 : (*name == '&')
2139 ? SAWAMPERSAND_MIDDLE
2140 : SAWAMPERSAND_RIGHT;
2141 }
1a904fc8 2142#endif
960b831f 2143 goto storeparen;
e91d8259
NC		 2144 case '1': /* $1 */
2145 case '2': /* $2 */
2146 case '3': /* $3 */
2147 case '4': /* $4 */
2148 case '5': /* $5 */
2149 case '6': /* $6 */
2150 case '7': /* $7 */
2151 case '8': /* $8 */
2152 case '9': /* $9 */
960b831f
NC		 2153 paren = *name - '0';
2154
2155 storeparen:
e91d8259
NC		 2156 /* Flag the capture variables with a NULL mg_ptr
2157 Use mg_len for the array index to lookup. */
960b831f 2158 sv_magic(GvSVn(gv), MUTABLE_SV(gv), PERL_MAGIC_sv, NULL, paren);
e91d8259 2159 break;
cc4c2da6 2160
6361f656 2161 case ':': /* $: */
c69033f2 2162 sv_setpv(GvSVn(gv),PL_chopset);
cc4c2da6
NC		 2163 goto magicalize;
2164
6361f656 2165 case '?': /* $? */
ff0cee69 2166#ifdef COMPLEX_STATUS
c69033f2 2167 SvUPGRADE(GvSVn(gv), SVt_PVLV);
ff0cee69 2168#endif
cc4c2da6 2169 goto magicalize;
ff0cee69 2170
6361f656 2171 case '!': /* $! */
67261566 2172 GvMULTI_on(gv);
44a2ac75 2173 /* If %! has been used, automatically load Errno.pm. */
d2c93421 2174
ad64d0ec 2175 sv_magic(GvSVn(gv), MUTABLE_SV(gv), PERL_MAGIC_sv, name, len);
d2c93421 2176
7c719134 2177 /* magicalization must be done before require_tie_mod_s is called */
67261566 2178 if (sv_type == SVt_PVHV || sv_type == SVt_PVGV)
7c719134 2179 require_tie_mod_s(gv, '!', "Errno", 1);
d2c93421 2180
6cef1e77 2181 break;
754f85ad
YO		 2182 case '-': /* $-, %-, @- */
2183 case '+': /* $+, %+, @+ */
27deb0cf
YO		 2184 GvMULTI_on(gv); /* no used once warnings here */
2185 { /* $- $+ */
2186 sv_magic(GvSVn(gv), MUTABLE_SV(gv), PERL_MAGIC_sv, name, len);
2187 if (*name == '+')
2188 SvREADONLY_on(GvSVn(gv));
2189 }
2190 { /* %- %+ */
2191 if (sv_type == SVt_PVHV || sv_type == SVt_PVGV)
2192 require_tie_mod_s(gv, *name, "Tie::Hash::NamedCapture",0);
2193 }
2194 { /* @- @+ */
2195 AV* const av = GvAVn(gv);
fa531f32 2196 const Size_t n = *name;
67261566 2197
fa531f32 2198 sv_magic(MUTABLE_SV(av), (SV*)n, PERL_MAGIC_regdata, NULL, 0);
27deb0cf
YO		 2199 SvREADONLY_on(av);
2200 }
80305961 2201 break;
a678626e
A		 2202 case '*': /* $* */
2203 case '#': /* $# */
2204 if (sv_type == SVt_PV)
37398dc1 2205 /* diag_listed_as: $* is no longer supported. Its use will be fatal in Perl 5.30 */
a678626e 2206 Perl_ck_warner_d(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
37398dc1
A		 2207 "$%c is no longer supported. Its use "
2208 "will be fatal in Perl 5.30", *name);
a678626e 2209 break;
b3ca2e83
NC		 2210 case '\010': /* $^H */
2211 {
2212 HV *const hv = GvHVn(gv);
2213 hv_magic(hv, NULL, PERL_MAGIC_hints);
2214 }
2215 goto magicalize;
b82b06b8 2216 case '[': /* $[ */
7d69d4a6 2217 if ((sv_type == SVt_PV || sv_type == SVt_PVGV)
2846acbf 2218 && FEATURE_ARYBASE_IS_ENABLED) {
7c719134 2219 require_tie_mod_s(gv,'[',"arybase",0);
b82b06b8 2220 }
7d69d4a6 2221 else goto magicalize;
b82b06b8 2222 break;
cc4c2da6 2223 case '\023': /* $^S */
2fdbfb4d
AB		 2224 ro_magicalize:
2225 SvREADONLY_on(GvSVn(gv));
924ba076 2226 /* FALLTHROUGH */
6361f656 2227 case '0': /* $0 */
6361f656
AB		 2228 case '^': /* $^ */
2229 case '~': /* $~ */
2230 case '=': /* $= */
2231 case '%': /* $% */
2232 case '.': /* $. */
2233 case '(': /* $( */
2234 case ')': /* $) */
2235 case '<': /* $< */
2236 case '>': /* $> */
2237 case '\\': /* $\ */
2238 case '/': /* $/ */
4505a31f 2239 case '|': /* $| */
9cdac2a2 2240 case '$': /* $$ */
cc4c2da6
NC		 2241 case '\001': /* $^A */
2242 case '\003': /* $^C */
2243 case '\004': /* $^D */
2244 case '\005': /* $^E */
2245 case '\006': /* $^F */
cc4c2da6
NC		 2246 case '\011': /* $^I, NOT \t in EBCDIC */
2247 case '\016': /* $^N */
2248 case '\017': /* $^O */
2249 case '\020': /* $^P */
2250 case '\024': /* $^T */
2251 case '\027': /* $^W */
2252 magicalize:
ad64d0ec 2253 sv_magic(GvSVn(gv), MUTABLE_SV(gv), PERL_MAGIC_sv, name, len);
cc4c2da6 2254 break;
e521374c 2255
cc4c2da6 2256 case '\014': /* $^L */
76f68e9b 2257 sv_setpvs(GvSVn(gv),"\f");
463ee0b2 2258 break;
6361f656 2259 case ';': /* $; */
76f68e9b 2260 sv_setpvs(GvSVn(gv),"\034");
463ee0b2 2261 break;
6361f656 2262 case ']': /* $] */
cc4c2da6 2263 {
3638bf15 2264 SV * const sv = GvSV(gv);
d7aa5382 2265 if (!sv_derived_from(PL_patchlevel, "version"))
ac0e6a2f 2266 upg_version(PL_patchlevel, TRUE);
7d54d38e
SH		 2267 GvSV(gv) = vnumify(PL_patchlevel);
2268 SvREADONLY_on(GvSV(gv));
2269 SvREFCNT_dec(sv);
93a17b20
LW		 2270 }
2271 break;
cc4c2da6
NC		 2272 case '\026': /* $^V */
2273 {
3638bf15 2274 SV * const sv = GvSV(gv);
f9be5ac8
DM		 2275 GvSV(gv) = new_version(PL_patchlevel);
2276 SvREADONLY_on(GvSV(gv));
2277 SvREFCNT_dec(sv);
16070b82
GS		 2278 }
2279 break;
ea238638
FC		 2280 case 'a':
2281 case 'b':
dc3e91f6 2282 if (sv_type == SVt_PV)
ea238638 2283 GvMULTI_on(gv);
cc4c2da6 2284 }
79072805 2285 }
930867a8 2286
1321bbe3
FC		 2287 ret:
2288 /* Return true if we actually did something. */
2289 return GvAV(gv) || GvHV(gv) || GvIO(gv) || GvCV(gv)
2290 || ( GvSV(gv) && (
2291 SvOK(GvSV(gv)) || SvMAGICAL(GvSV(gv))
2292 )
2293 );
71c35c05
BF		 2294}
2295
8c995aba
FC		 2296/* If we do ever start using this later on in the file, we need to make
2297 sure we don’t accidentally use the wrong definition. */
2298#undef SvREADONLY_on
2299
070dc475
BF		 2300/* This function is called when the stash already holds the GV of the magic
2301 * variable we're looking for, but we need to check that it has the correct
2302 * kind of magic. For example, if someone first uses $! and then %!, the
2303 * latter would end up here, and we add the Errno tie to the HASH slot of
2304 * the *! glob.
2305 */
2306PERL_STATIC_INLINE void
2307S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type)
2308{
2309 PERL_ARGS_ASSERT_MAYBE_MULTIMAGIC_GV;
2310
2311 if (sv_type == SVt_PVHV || sv_type == SVt_PVGV) {
2312 if (*name == '!')
7c719134 2313 require_tie_mod_s(gv, '!', "Errno", 1);
070dc475 2314 else if (*name == '-' || *name == '+')
7c719134 2315 require_tie_mod_s(gv, *name, "Tie::Hash::NamedCapture", 0);
a678626e
A		 2316 } else if (sv_type == SVt_PV) {
2317 if (*name == '*' || *name == '#') {
37398dc1 2318 /* diag_listed_as: $# is no longer supported. Its use will be fatal in Perl 5.30 */
a678626e
A		 2319 Perl_ck_warner_d(aTHX_ packWARN2(WARN_DEPRECATED,
2320 WARN_SYNTAX),
37398dc1
A		 2321 "$%c is no longer supported. Its use "
2322 "will be fatal in Perl 5.30", *name);
a678626e 2323 }
070dc475
BF		 2324 }
2325 if (sv_type==SVt_PV || sv_type==SVt_PVGV) {
2326 switch (*name) {
2327 case '[':
7c719134 2328 require_tie_mod_s(gv,'[',"arybase",0);
070dc475
BF		 2329 break;
2330#ifdef PERL_SAWAMPERSAND
2331 case '`':
2332 PL_sawampersand |= SAWAMPERSAND_LEFT;
2333 (void)GvSVn(gv);
2334 break;
2335 case '&':
2336 PL_sawampersand |= SAWAMPERSAND_MIDDLE;
2337 (void)GvSVn(gv);
2338 break;
2339 case '\'':
2340 PL_sawampersand |= SAWAMPERSAND_RIGHT;
2341 (void)GvSVn(gv);
2342 break;
2343#endif
2344 }
2345 }
2346}
2347
71c35c05
BF		 2348GV *
2349Perl_gv_fetchpvn_flags(pTHX_ const char *nambeg, STRLEN full_len, I32 flags,
2350 const svtype sv_type)
2351{
71c35c05
BF		 2352 const char *name = nambeg;
2353 GV *gv = NULL;
2354 GV**gvp;
2355 STRLEN len;
2356 HV *stash = NULL;
2357 const I32 no_init = flags & (GV_NOADD_NOINIT | GV_NOINIT);
2358 const I32 no_expand = flags & GV_NOEXPAND;
2359 const I32 add = flags & ~GV_NOADD_MASK;
2360 const U32 is_utf8 = flags & SVf_UTF8;
930867a8 2361 bool addmg = cBOOL(flags & GV_ADDMG);
71c35c05
BF		 2362 const char *const name_end = nambeg + full_len;
2363 U32 faking_it;
2364
2365 PERL_ARGS_ASSERT_GV_FETCHPVN_FLAGS;
2366
2367 /* If we have GV_NOTQUAL, the caller promised that
2368 * there is no stash, so we can skip the check.
2369 * Similarly if full_len is 0, since then we're
2370 * dealing with something like *{""} or ""->foo()
2371 */
2372 if ((flags & GV_NOTQUAL) || !full_len) {
2373 len = full_len;
2374 }
2375 else if (parse_gv_stash_name(&stash, &gv, &name, &len, nambeg, full_len, is_utf8, add)) {
2376 if (name == name_end) return gv;
2377 }
2378 else {
2379 return NULL;
2380 }
2381
2382 if (!stash && !find_default_stash(&stash, name, len, is_utf8, add, sv_type)) {
2383 return NULL;
2384 }
2385
2386 /* By this point we should have a stash and a name */
c161da64 2387 gvp = (GV**)hv_fetch(stash,name,is_utf8 ? -(I32)len : (I32)len,add);
71c35c05
BF		 2388 if (!gvp || *gvp == (const GV *)&PL_sv_undef) {
2389 if (addmg) gv = (GV *)newSV(0);
2390 else return NULL;
2391 }
2392 else gv = *gvp, addmg = 0;
2393 /* From this point on, addmg means gv has not been inserted in the
2394 symtab yet. */
2395
2396 if (SvTYPE(gv) == SVt_PVGV) {
c002ae9a
BF		 2397 /* The GV already exists, so return it, but check if we need to do
2398 * anything else with it before that.
2399 */
71c35c05 2400 if (add) {
c002ae9a
BF		 2401 /* This is the heuristic that handles if a variable triggers the
2402 * 'used only once' warning. If there's already a GV in the stash
2403 * with this name, then we assume that the variable has been used
2404 * before and turn its MULTI flag on.
2405 * It's a heuristic because it can easily be "tricked", like with
2406 * BEGIN { $a = 1; $::{foo} = *a }; () = $foo
2407 * not warning about $main::foo being used just once
2408 */
71c35c05
BF		 2409 GvMULTI_on(gv);
2410 gv_init_svtype(gv, sv_type);
2411 /* You reach this path once the typeglob has already been created,
2412 either by the same or a different sigil. If this path didn't
2413 exist, then (say) referencing $! first, and %! second would
2414 mean that %! was not handled correctly. */
2415 if (len == 1 && stash == PL_defstash) {
070dc475 2416 maybe_multimagic_gv(gv, name, sv_type);
71c35c05 2417 }
b59bf0b2
KW		 2418 else if (sv_type == SVt_PVAV
2419 && memEQs(name, len, "ISA")
71c35c05
BF		 2420 && (!GvAV(gv) || !SvSMAGICAL(GvAV(gv))))
2421 gv_magicalize_isa(gv);
2422 }
2423 return gv;
2424 } else if (no_init) {
2425 assert(!addmg);
2426 return gv;
c002ae9a
BF		 2427 }
2428 /* If GV_NOEXPAND is true and what we got off the stash is a ref,
2429 * don't expand it to a glob. This is an optimization so that things
2430 * copying constants over, like Exporter, don't have to be rewritten
2431 * to take into account that you can store more than just globs in
2432 * stashes.
2433 */
2434 else if (no_expand && SvROK(gv)) {
71c35c05
BF		 2435 assert(!addmg);
2436 return gv;
2437 }
2438
2439 /* Adding a new symbol.
2440 Unless of course there was already something non-GV here, in which case
2441 we want to behave as if there was always a GV here, containing some sort
2442 of subroutine.
2443 Otherwise we run the risk of creating things like GvIO, which can cause
2444 subtle bugs. eg the one that tripped up SQL::Translator */
2445
2446 faking_it = SvOK(gv);
2447
2448 if (add & GV_ADDWARN)
2449 Perl_ck_warner_d(aTHX_ packWARN(WARN_INTERNAL),
147e3846 2450 "Had to create %" UTF8f " unexpectedly",
71c35c05
BF		 2451 UTF8fARG(is_utf8, name_end-nambeg, nambeg));
2452 gv_init_pvn(gv, stash, name, len, (add & GV_ADDMULTI)|is_utf8);
2453
7a207065
KW		 2454 if ( full_len != 0
2455 && isIDFIRST_lazy_if_safe(name, name + full_len, is_utf8)
2456 && !ckWARN(WARN_ONCE) )
2457 {
71c35c05 2458 GvMULTI_on(gv) ;
7a207065 2459 }
71c35c05
BF		 2460
2461 /* set up magic where warranted */
1321bbe3 2462 if ( gv_magicalize(gv, stash, name, len, sv_type) ) {
930867a8 2463 /* See 23496c6 */
1321bbe3
FC		 2464 if (addmg) {
2465 /* gv_magicalize magicalised this gv, so we want it
930867a8 2466 * stored in the symtab.
1321bbe3
FC		 2467 * Effectively the caller is asking, ‘Does this gv exist?’
2468 * And we respond, ‘Er, *now* it does!’
930867a8
BF		 2469 */
2470 (void)hv_store(stash,name,len,(SV *)gv,0);
1321bbe3
FC		 2471 }
2472 }
2473 else if (addmg) {
2474 /* The temporary GV created above */
930867a8
BF		 2475 SvREFCNT_dec_NN(gv);
2476 gv = NULL;
930867a8 2477 }
71c35c05 2478
e6066781 2479 if (gv) gv_init_svtype(gv, faking_it ? SVt_PVCV : sv_type);
93a17b20 2480 return gv;
79072805
LW		 2481}
2482
2483void
35a4481c 2484Perl_gv_fullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain)
43693395 2485{
ed60a868 2486 const char *name;
35a4481c 2487 const HV * const hv = GvSTASH(gv);
7918f24d
NC		 2488
2489 PERL_ARGS_ASSERT_GV_FULLNAME4;
2490
666ea192 2491 sv_setpv(sv, prefix ? prefix : "");
a0288114 2492
52a6327b 2493 if (hv && (name = HvNAME(hv))) {
ed60a868 2494 const STRLEN len = HvNAMELEN(hv);
61e2287f 2495 if (keepmain || ! memBEGINs(name, len, "main")) {
ed60a868 2496 sv_catpvn_flags(sv,name,len,HvNAMEUTF8(hv)?SV_CATUTF8:SV_CATBYTES);
396482e1 2497 sv_catpvs(sv,"::");
ed60a868 2498 }
43693395 2499 }
ed60a868 2500 else sv_catpvs(sv,"__ANON__::");
04f3bf56 2501 sv_catsv(sv,sv_2mortal(newSVhek(GvNAME_HEK(gv))));
43693395
GS		 2502}
2503
2504void
35a4481c 2505Perl_gv_efullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain)
43693395 2506{
099be4f1 2507 const GV * const egv = GvEGVx(gv);
7918f24d
NC		 2508
2509 PERL_ARGS_ASSERT_GV_EFULLNAME4;
2510
46c461b5 2511 gv_fullname4(sv, egv ? egv : gv, prefix, keepmain);
43693395
GS		 2512}
2513
39a65960
DM		 2514
2515/* recursively scan a stash and any nested stashes looking for entries
2516 * that need the "only used once" warning raised
2517 */
2518
79072805 2519void
51da40ed 2520Perl_gv_check(pTHX_ HV *stash)
79072805 2521{
eb578fdb 2522 I32 i;
463ee0b2 2523
7918f24d
NC		 2524 PERL_ARGS_ASSERT_GV_CHECK;
2525
9e5cda6b 2526 if (!SvOOK(stash))
8990e307 2527 return;
90754377 2528
9e5cda6b 2529 assert(HvARRAY(stash));
90754377 2530
a0d0e21e 2531 for (i = 0; i <= (I32) HvMAX(stash); i++) {
e1ec3a88 2532 const HE *entry;
90754377 2533 /* mark stash is being scanned, to avoid recursing */
339441ef 2534 HvAUX(stash)->xhv_aux_flags |= HvAUXf_SCAN_STASH;
dc437b57 2535 for (entry = HvARRAY(stash)[i]; entry; entry = HeNEXT(entry)) {
eb578fdb 2536 GV *gv;
b7787f18 2537 HV *hv;
e7acdfe9
DM		 2538 STRLEN keylen = HeKLEN(entry);
2539 const char * const key = HeKEY(entry);
2540
2541 if (keylen >= 2 && key[keylen-2] == ':' && key[keylen-1] == ':' &&
159b6efe 2542 (gv = MUTABLE_GV(HeVAL(entry))) && isGV(gv) && (hv = GvHV(gv)))
a0d0e21e 2543 {
90754377
DM		 2544 if (hv != PL_defstash && hv != stash
2545 && !(SvOOK(hv)
2546 && (HvAUX(hv)->xhv_aux_flags & HvAUXf_SCAN_STASH))
2547 )
a0d0e21e
LW		 2548 gv_check(hv); /* nested package */
2549 }
7a207065
KW		 2550 else if ( HeKLEN(entry) != 0
2551 && *HeKEY(entry) != '_'
2552 && isIDFIRST_lazy_if_safe(HeKEY(entry),
2553 HeKEY(entry) + HeKLEN(entry),
2554 HeUTF8(entry)) )
2555 {
e1ec3a88 2556 const char *file;
159b6efe 2557 gv = MUTABLE_GV(HeVAL(entry));
55d729e4 2558 if (SvTYPE(gv) != SVt_PVGV || GvMULTI(gv))
463ee0b2 2559 continue;
1d7c1841 2560 file = GvFILE(gv);
1d7c1841 2561 CopLINE_set(PL_curcop, GvLINE(gv));
1dc74fdb
FC		 2562#ifdef USE_ITHREADS
2563 CopFILE(PL_curcop) = (char *)file; /* set for warning */
2564#else
2565 CopFILEGV(PL_curcop)
2566 = gv_fetchfile_flags(file, HEK_LEN(GvFILE_HEK(gv)), 0);
2567#endif
9014280d 2568 Perl_warner(aTHX_ packWARN(WARN_ONCE),
147e3846 2569 "Name \"%" HEKf "::%" HEKf
d0c0e7dd
FC		 2570 "\" used only once: possible typo",
2571 HEKfARG(HvNAME_HEK(stash)),
2572 HEKfARG(GvNAME_HEK(gv)));
463ee0b2 2573 }
79072805 2574 }
339441ef 2575 HvAUX(stash)->xhv_aux_flags &= ~HvAUXf_SCAN_STASH;
79072805
LW		 2576 }
2577}
2578
2579GV *
9cc50d5b 2580Perl_newGVgen_flags(pTHX_ const char *pack, U32 flags)
79072805 2581{
9cc50d5b 2582 PERL_ARGS_ASSERT_NEWGVGEN_FLAGS;
b17a0679 2583 assert(!(flags & ~SVf_UTF8));
7918f24d 2584
147e3846 2585 return gv_fetchpv(Perl_form(aTHX_ "%" UTF8f "::_GEN_%ld",
b17a0679 2586 UTF8fARG(flags, strlen(pack), pack),
9cc50d5b
BF		 2587 (long)PL_gensym++),
2588 GV_ADD, SVt_PVGV);
79072805
LW		 2589}
2590
2591/* hopefully this is only called on local symbol table entries */
2592
2593GP*
864dbfa3 2594Perl_gp_ref(pTHX_ GP *gp)
79072805 2595{
1d7c1841 2596 if (!gp)
d4c19fe8 2597 return NULL;
79072805 2598 gp->gp_refcnt++;
44a8e56a 2599 if (gp->gp_cv) {
2600 if (gp->gp_cvgen) {
e1a479c5
BB		 2601 /* If the GP they asked for a reference to contains
2602 a method cache entry, clear it first, so that we
2603 don't infect them with our cached entry */
e7881358 2604 SvREFCNT_dec_NN(gp->gp_cv);
601f1833 2605 gp->gp_cv = NULL;
44a8e56a 2606 gp->gp_cvgen = 0;
2607 }
44a8e56a 2608 }
79072805 2609 return gp;
79072805
LW		 2610}
2611
2612void
864dbfa3 2613Perl_gp_free(pTHX_ GV *gv)
79072805 2614{
79072805 2615 GP* gp;
b0d55c99 2616 int attempts = 100;
79072805 2617
f7877b28 2618 if (!gv || !isGV_with_GP(gv) || !(gp = GvGP(gv)))
79072805 2619 return;
f248d071 2620 if (gp->gp_refcnt == 0) {
9b387841
NC		 2621 Perl_ck_warner_d(aTHX_ packWARN(WARN_INTERNAL),
2622 "Attempt to free unreferenced glob pointers"
2623 pTHX__FORMAT pTHX__VALUE);
79072805
LW		 2624 return;
2625 }
4571f4a7 2626 if (gp->gp_refcnt > 1) {
bc81b34d 2627 borrowed:
748a9306
LW		 2628 if (gp->gp_egv == gv)
2629 gp->gp_egv = 0;
4571f4a7 2630 gp->gp_refcnt--;
c43ae56f 2631 GvGP_set(gv, NULL);
79072805 2632 return;
748a9306 2633 }
79072805 2634
b0d55c99
FC		 2635 while (1) {
2636 /* Copy and null out all the glob slots, so destructors do not see
2637 freed SVs. */
2638 HEK * const file_hek = gp->gp_file_hek;
2639 SV * const sv = gp->gp_sv;
2640 AV * const av = gp->gp_av;
2641 HV * const hv = gp->gp_hv;
2642 IO * const io = gp->gp_io;
2643 CV * const cv = gp->gp_cv;
2644 CV * const form = gp->gp_form;
2645
2646 gp->gp_file_hek = NULL;
2647 gp->gp_sv = NULL;
2648 gp->gp_av = NULL;
2649 gp->gp_hv = NULL;
2650 gp->gp_io = NULL;
2651 gp->gp_cv = NULL;
2652 gp->gp_form = NULL;
2653
2654 if (file_hek)
2655 unshare_hek(file_hek);
2656
2657 SvREFCNT_dec(sv);
2658 SvREFCNT_dec(av);
2659 /* FIXME - another reference loop GV -> symtab -> GV ?
2660 Somehow gp->gp_hv can end up pointing at freed garbage. */
2661 if (hv && SvTYPE(hv) == SVt_PVHV) {
c2242065 2662 const HEK *hvname_hek = HvNAME_HEK(hv);
923ed580
FC		 2663 if (PL_stashcache && hvname_hek) {
2664 DEBUG_o(Perl_deb(aTHX_
147e3846 2665 "gp_free clearing PL_stashcache for '%" HEKf "'\n",
923ed580 2666 HEKfARG(hvname_hek)));
0ca9877d 2667 (void)hv_deletehek(PL_stashcache, hvname_hek, G_DISCARD);
923ed580 2668 }
b0d55c99
FC		 2669 SvREFCNT_dec(hv);
2670 }
96d7c888
FC		 2671 if (io && SvREFCNT(io) == 1 && IoIFP(io)
2672 && (IoTYPE(io) == IoTYPE_WRONLY ||
2673 IoTYPE(io) == IoTYPE_RDWR ||
2674 IoTYPE(io) == IoTYPE_APPEND)
2675 && ckWARN_d(WARN_IO)
2676 && IoIFP(io) != PerlIO_stdin()
2677 && IoIFP(io) != PerlIO_stdout()
2678 && IoIFP(io) != PerlIO_stderr()
2679 && !(IoFLAGS(io) & IOf_FAKE_DIRP))
2680 io_close(io, gv, FALSE, TRUE);
b0d55c99
FC		 2681 SvREFCNT_dec(io);
2682 SvREFCNT_dec(cv);
2683 SvREFCNT_dec(form);
2684
bc81b34d
FC		 2685 /* Possibly reallocated by a destructor */
2686 gp = GvGP(gv);
2687
b0d55c99
FC		 2688 if (!gp->gp_file_hek
2689 && !gp->gp_sv
2690 && !gp->gp_av
2691 && !gp->gp_hv
2692 && !gp->gp_io
2693 && !gp->gp_cv
2694 && !gp->gp_form) break;
2695
2696 if (--attempts == 0) {
2697 Perl_die(aTHX_
2698 "panic: gp_free failed to free glob pointer - "
2699 "something is repeatedly re-creating entries"
2700 );
2701 }
13207a71 2702 }
748a9306 2703
bc81b34d
FC		 2704 /* Possibly incremented by a destructor doing glob assignment */
2705 if (gp->gp_refcnt > 1) goto borrowed;
79072805 2706 Safefree(gp);
c43ae56f 2707 GvGP_set(gv, NULL);
79072805
LW		 2708}
2709
d460ef45
NIS		 2710int
2711Perl_magic_freeovrld(pTHX_ SV *sv, MAGIC *mg)
2712{
53c1dcc0
AL		 2713 AMT * const amtp = (AMT*)mg->mg_ptr;
2714 PERL_UNUSED_ARG(sv);
dd374669 2715
7918f24d
NC		 2716 PERL_ARGS_ASSERT_MAGIC_FREEOVRLD;
2717
d460ef45
NIS		 2718 if (amtp && AMT_AMAGIC(amtp)) {
2719 int i;
2720 for (i = 1; i < NofAMmeth; i++) {
53c1dcc0 2721 CV * const cv = amtp->table[i];
b37c2d43 2722 if (cv) {
e7881358 2723 SvREFCNT_dec_NN(MUTABLE_SV(cv));
601f1833 2724 amtp->table[i] = NULL;
d460ef45
NIS		 2725 }
2726 }
2727 }
2728 return 0;
2729}
2730
a0d0e21e 2731/* Updates and caches the CV's */
c3a9a790
RGS		 2732/* Returns:
2733 * 1 on success and there is some overload
2734 * 0 if there is no overload
2735 * -1 if some error occurred and it couldn't croak
2736 */
a0d0e21e 2737
c3a9a790 2738int
242f8760 2739Perl_Gv_AMupdate(pTHX_ HV *stash, bool destructing)
a0d0e21e 2740{
ad64d0ec 2741 MAGIC* const mg = mg_find((const SV *)stash, PERL_MAGIC_overload_table);
a6006777 2742 AMT amt;
9b439311 2743 const struct mro_meta* stash_meta = HvMROMETA(stash);
e1a479c5 2744 U32 newgen;
a0d0e21e 2745
7918f24d
NC		 2746 PERL_ARGS_ASSERT_GV_AMUPDATE;
2747
9b439311 2748 newgen = PL_sub_generation + stash_meta->pkg_gen + stash_meta->cache_gen;
14899595
NC		 2749 if (mg) {
2750 const AMT * const amtp = (AMT*)mg->mg_ptr;
66978156 2751 if (amtp->was_ok_sub == newgen) {
8c34e50d 2752 return AMT_AMAGIC(amtp) ? 1 : 0;
14899595 2753 }
ad64d0ec 2754 sv_unmagic(MUTABLE_SV(stash), PERL_MAGIC_overload_table);
14899595 2755 }
a0d0e21e 2756
bfcb3514 2757 DEBUG_o( Perl_deb(aTHX_ "Recalcing overload magic in package %s\n",HvNAME_get(stash)) );
a0d0e21e 2758
d460ef45 2759 Zero(&amt,1,AMT);
e1a479c5 2760 amt.was_ok_sub = newgen;
a6006777 2761 amt.fallback = AMGfallNO;
2762 amt.flags = 0;
2763
a6006777 2764 {
8c34e50d
FC		 2765 int filled = 0;
2766 int i;
3d147ac2
DM		 2767 bool deref_seen = 0;
2768
a6006777 2769
3866ea3b 2770 /* Work with "fallback" key, which we assume to be first in PL_AMG_names */
a6006777 2771
89ffc314 2772 /* Try to find via inheritance. */
e6919483 2773 GV *gv = gv_fetchmeth_pvn(stash, PL_AMG_names[0], 2, -1, 0);
3866ea3b 2774 SV * const sv = gv ? GvSV(gv) : NULL;
53c1dcc0 2775 CV* cv;
89ffc314
IZ		 2776
2777 if (!gv)
3866ea3b
FC		 2778 {
2779 if (!gv_fetchmeth_pvn(stash, "((", 2, -1, 0))
8c34e50d 2780 goto no_table;
3866ea3b
FC		 2781 }
2782#ifdef PERL_DONT_CREATE_GVSV
2783 else if (!sv) {
6f207bd3 2784 NOOP; /* Equivalent to !SvTRUE and !SvOK */
3866ea3b
FC		 2785 }
2786#endif
79c9643d
JL		 2787 else if (SvTRUE(sv))
2788 /* don't need to set overloading here because fallback => 1
2789 * is the default setting for classes without overloading */
89ffc314 2790 amt.fallback=AMGfallYES;
79c9643d
JL		 2791 else if (SvOK(sv)) {
2792 amt.fallback=AMGfallNEVER;
386a5489 2793 filled = 1;
386a5489 2794 }
79c9643d 2795 else {
386a5489 2796 filled = 1;
386a5489 2797 }
a6006777 2798
3d147ac2 2799 assert(SvOOK(stash));
3d147ac2 2800 /* initially assume the worst */
339441ef 2801 HvAUX(stash)->xhv_aux_flags &= ~HvAUXf_NO_DEREF;
3d147ac2 2802
8c34e50d 2803 for (i = 1; i < NofAMmeth; i++) {
6136c704 2804 const char * const cooky = PL_AMG_names[i];
32251b26 2805 /* Human-readable form, for debugging: */
8c34e50d 2806 const char * const cp = AMG_id2name(i);
d279ab82 2807 const STRLEN l = PL_AMG_namelens[i];
89ffc314 2808
a0288114 2809 DEBUG_o( Perl_deb(aTHX_ "Checking overloading of \"%s\" in package \"%.256s\"\n",
bfcb3514 2810 cp, HvNAME_get(stash)) );
611c1e95
IZ		 2811 /* don't fill the cache while looking up!
2812 Creation of inheritance stubs in intermediate packages may
2813 conflict with the logic of runtime method substitution.
2814 Indeed, for inheritance A -> B -> C, if C overloads "+0",
2815 then we could have created stubs for "(+0" in A and C too.
2816 But if B overloads "bool", we may want to use it for
2817 numifying instead of C's "+0". */
8c34e50d 2818 gv = Perl_gv_fetchmeth_pvn(aTHX_ stash, cooky, l, -1, 0);
46fc3d4c 2819 cv = 0;
c3ad4e54 2820 if (gv && (cv = GvCV(gv)) && CvHASGV(cv)) {
79656330 2821 const HEK * const gvhek = CvGvNAME_HEK(cv);
c3ad4e54
FC		 2822 const HEK * const stashek =
2823 HvNAME_HEK(CvNAMED(cv) ? CvSTASH(cv) : GvSTASH(CvGV(cv)));
b59bf0b2
KW		 2824 if (memEQs(HEK_KEY(gvhek), HEK_LEN(gvhek), "nil")
2825 && stashek
2826 && memEQs(HEK_KEY(stashek), HEK_LEN(stashek), "overload")) {
611c1e95
IZ		 2827 /* This is a hack to support autoloading..., while
2828 knowing *which* methods were declared as overloaded. */
44a8e56a 2829 /* GvSV contains the name of the method. */
6136c704 2830 GV *ngv = NULL;
c69033f2 2831 SV *gvsv = GvSV(gv);
a0288114 2832
147e3846 2833 DEBUG_o( Perl_deb(aTHX_ "Resolving method \"%" SVf256\
a0288114 2834 "\" for overloaded \"%s\" in package \"%.256s\"\n",
f0e9f182 2835 (void*)GvSV(gv), cp, HvNAME(stash)) );
c69033f2 2836 if (!gvsv || !SvPOK(gvsv)
7f415459 2837 || !(ngv = gv_fetchmethod_sv_flags(stash, gvsv, 0)))
dc848c6f 2838 {
a0288114 2839 /* Can be an import stub (created by "can"). */
242f8760 2840 if (destructing) {
c3a9a790 2841 return -1;
242f8760
RGS		 2842 }
2843 else {
d66cca07
BF		 2844 const SV * const name = (gvsv && SvPOK(gvsv))
2845 ? gvsv
2846 : newSVpvs_flags("???", SVs_TEMP);
dcbac5bb 2847 /* diag_listed_as: Can't resolve method "%s" overloading "%s" in package "%s" */
147e3846 2848 Perl_croak(aTHX_ "%s method \"%" SVf256
d66cca07 2849 "\" overloading \"%s\" "\
147e3846 2850 "in package \"%" HEKf256 "\"",
242f8760
RGS		 2851 (GvCVGEN(gv) ? "Stub found while resolving"
2852 : "Can't resolve"),
d66cca07 2853 SVfARG(name), cp,
d0c0e7dd 2854 HEKfARG(
d66cca07 2855 HvNAME_HEK(stash)
d0c0e7dd 2856 ));
242f8760 2857 }
44a8e56a 2858 }
dc848c6f 2859 cv = GvCV(gv = ngv);
44a8e56a 2860 }
b464bac0 2861 DEBUG_o( Perl_deb(aTHX_ "Overloading \"%s\" in package \"%.256s\" via \"%.256s::%.256s\"\n",
bfcb3514 2862 cp, HvNAME_get(stash), HvNAME_get(GvSTASH(CvGV(cv))),
44a8e56a 2863 GvNAME(CvGV(cv))) );
2864 filled = 1;
611c1e95 2865 } else if (gv) { /* Autoloaded... */
ea726b52 2866 cv = MUTABLE_CV(gv);
611c1e95 2867 filled = 1;
44a8e56a 2868 }
ea726b52 2869 amt.table[i]=MUTABLE_CV(SvREFCNT_inc_simple(cv));
3d147ac2
DM		 2870
2871 if (gv) {
2872 switch (i) {
2873 case to_sv_amg:
2874 case to_av_amg:
2875 case to_hv_amg:
2876 case to_gv_amg:
2877 case to_cv_amg:
2878 case nomethod_amg:
2879 deref_seen = 1;
2880 break;
2881 }
2882 }
a0d0e21e 2883 }
3d147ac2 2884 if (!deref_seen)
45479970
DM		 2885 /* none of @{} etc overloaded; we can do $obj->[N] quicker.
2886 * NB - aux var invalid here, HvARRAY() could have been
2887 * reallocated since it was assigned to */
2888 HvAUX(stash)->xhv_aux_flags |= HvAUXf_NO_DEREF;
3d147ac2 2889
a0d0e21e 2890 if (filled) {
a6006777 2891 AMT_AMAGIC_on(&amt);
ad64d0ec 2892 sv_magic(MUTABLE_SV(stash), 0, PERL_MAGIC_overload_table,
14befaf4 2893 (char*)&amt, sizeof(AMT));
8c34e50d 2894 return TRUE;
a0d0e21e
LW		 2895 }
2896 }
a6006777 2897 /* Here we have no table: */
8c34e50d 2898 no_table:
a6006777 2899 AMT_AMAGIC_off(&amt);
ad64d0ec 2900 sv_magic(MUTABLE_SV(stash), 0, PERL_MAGIC_overload_table,
14befaf4 2901 (char*)&amt, sizeof(AMTS));
c3a9a790 2902 return 0;
a0d0e21e
LW		 2903}
2904
32251b26
IZ		 2905
2906CV*
2907Perl_gv_handler(pTHX_ HV *stash, I32 id)
2908{
3f8f4626 2909 MAGIC *mg;
32251b26 2910 AMT *amtp;
e1a479c5 2911 U32 newgen;
9b439311 2912 struct mro_meta* stash_meta;
32251b26 2913
bfcb3514 2914 if (!stash || !HvNAME_get(stash))
601f1833 2915 return NULL;
e1a479c5 2916
9b439311
BB		 2917 stash_meta = HvMROMETA(stash);
2918 newgen = PL_sub_generation + stash_meta->pkg_gen + stash_meta->cache_gen;
e1a479c5 2919
ad64d0ec 2920 mg = mg_find((const SV *)stash, PERL_MAGIC_overload_table);
32251b26
IZ		 2921 if (!mg) {
2922 do_update:
8c34e50d 2923 if (Gv_AMupdate(stash, 0) == -1)
242f8760 2924 return NULL;
ad64d0ec 2925 mg = mg_find((const SV *)stash, PERL_MAGIC_overload_table);
32251b26 2926 }
a9fd4e40 2927 assert(mg);
32251b26 2928 amtp = (AMT*)mg->mg_ptr;
66978156 2929 if ( amtp->was_ok_sub != newgen )
32251b26 2930 goto do_update;
3ad83ce7 2931 if (AMT_AMAGIC(amtp)) {
b7787f18 2932 CV * const ret = amtp->table[id];
3ad83ce7
AMS		 2933 if (ret && isGV(ret)) { /* Autoloading stab */
2934 /* Passing it through may have resulted in a warning
2935 "Inherited AUTOLOAD for a non-method deprecated", since
2936 our caller is going through a function call, not a method call.
2937 So return the CV for AUTOLOAD, setting $AUTOLOAD. */
890ce7af 2938 GV * const gv = gv_fetchmethod(stash, PL_AMG_names[id]);
3ad83ce7
AMS		 2939
2940 if (gv && GvCV(gv))
2941 return GvCV(gv);
2942 }
2943 return ret;
2944 }
a0288114 2945
601f1833 2946 return NULL;
32251b26
IZ		 2947}
2948
2949
6f1401dc
DM		 2950/* Implement tryAMAGICun_MG macro.
2951 Do get magic, then see if the stack arg is overloaded and if so call it.
2952 Flags:
2953 AMGf_set return the arg using SETs rather than assigning to
2954 the targ
2955 AMGf_numeric apply sv_2num to the stack arg.
2956*/
2957
2958bool
2959Perl_try_amagic_un(pTHX_ int method, int flags) {
6f1401dc
DM		 2960 dSP;
2961 SV* tmpsv;
2962 SV* const arg = TOPs;
2963
2964 SvGETMAGIC(arg);
2965
9f8bf298 2966 if (SvAMAGIC(arg) && (tmpsv = amagic_call(arg, &PL_sv_undef, method,
636ac8fc
FC		 2967 AMGf_noright | AMGf_unary
2968 | (flags & AMGf_numarg))))
2969 {
6f1401dc
DM		 2970 if (flags & AMGf_set) {
2971 SETs(tmpsv);
2972 }
2973 else {
2974 dTARGET;
2975 if (SvPADMY(TARG)) {
2976 sv_setsv(TARG, tmpsv);
2977 SETTARG;
2978 }
2979 else
2980 SETs(tmpsv);
2981 }
2982 PUTBACK;
2983 return TRUE;
2984 }
2985
2986 if ((flags & AMGf_numeric) && SvROK(arg))
2987 *sp = sv_2num(arg);
2988 return FALSE;
2989}
2990
2991
2992/* Implement tryAMAGICbin_MG macro.
2993 Do get magic, then see if the two stack args are overloaded and if so
2994 call it.
2995 Flags:
2996 AMGf_set return the arg using SETs rather than assigning to
2997 the targ
2998 AMGf_assign op may be called as mutator (eg +=)
2999 AMGf_numeric apply sv_2num to the stack arg.
3000*/
3001
3002bool
3003Perl_try_amagic_bin(pTHX_ int method, int flags) {
6f1401dc
DM		 3004 dSP;
3005 SV* const left = TOPm1s;
3006 SV* const right = TOPs;
3007
3008 SvGETMAGIC(left);
3009 if (left != right)
3010 SvGETMAGIC(right);
3011
3012 if (SvAMAGIC(left) || SvAMAGIC(right)) {
3013 SV * const tmpsv = amagic_call(left, right, method,
636ac8fc
FC		 3014 ((flags & AMGf_assign) && opASSIGN ? AMGf_assign: 0)
3015 | (flags & AMGf_numarg));
6f1401dc
DM		 3016 if (tmpsv) {
3017 if (flags & AMGf_set) {
3018 (void)POPs;
3019 SETs(tmpsv);
3020 }
3021 else {
3022 dATARGET;
3023 (void)POPs;
3024 if (opASSIGN || SvPADMY(TARG)) {
3025 sv_setsv(TARG, tmpsv);
3026 SETTARG;
3027 }
3028 else
3029 SETs(tmpsv);
3030 }
3031 PUTBACK;
3032 return TRUE;
3033 }
3034 }
75ea7a12
FC		 3035 if(left==right && SvGMAGICAL(left)) {
3036 SV * const left = sv_newmortal();
3037 *(sp-1) = left;
3038 /* Print the uninitialized warning now, so it includes the vari-
3039 able name. */
3040 if (!SvOK(right)) {
3041 if (ckWARN(WARN_UNINITIALIZED)) report_uninit(right);
3042 sv_setsv_flags(left, &PL_sv_no, 0);
3043 }
3044 else sv_setsv_flags(left, right, 0);
3045 SvGETMAGIC(right);
3046 }
6f1401dc 3047 if (flags & AMGf_numeric) {
75ea7a12
FC		 3048 if (SvROK(TOPm1s))
3049 *(sp-1) = sv_2num(TOPm1s);
6f1401dc
DM		 3050 if (SvROK(right))
3051 *sp = sv_2num(right);
3052 }
3053 return FALSE;
3054}
3055
25a9ffce
NC		 3056SV *
3057Perl_amagic_deref_call(pTHX_ SV *ref, int method) {
3058 SV *tmpsv = NULL;
3d147ac2 3059 HV *stash;
25a9ffce
NC		 3060
3061 PERL_ARGS_ASSERT_AMAGIC_DEREF_CALL;
3062
3d147ac2
DM		 3063 if (!SvAMAGIC(ref))
3064 return ref;
3065 /* return quickly if none of the deref ops are overloaded */
3066 stash = SvSTASH(SvRV(ref));
3067 assert(SvOOK(stash));
3068 if (HvAUX(stash)->xhv_aux_flags & HvAUXf_NO_DEREF)
3069 return ref;
3070
3071 while ((tmpsv = amagic_call(ref, &PL_sv_undef, method,
25a9ffce
NC		 3072 AMGf_noright | AMGf_unary))) {
3073 if (!SvROK(tmpsv))
3074 Perl_croak(aTHX_ "Overloaded dereference did not return a reference");
3075 if (tmpsv == ref || SvRV(tmpsv) == SvRV(ref)) {
3076 /* Bail out if it returns us the same reference. */
3077 return tmpsv;
3078 }
3079 ref = tmpsv;
3d147ac2
DM		 3080 if (!SvAMAGIC(ref))
3081 break;
25a9ffce
NC		 3082 }
3083 return tmpsv ? tmpsv : ref;
3084}
6f1401dc 3085
8d569291
FC		 3086bool
3087Perl_amagic_is_enabled(pTHX_ int method)
3088{
3089 SV *lex_mask = cop_hints_fetch_pvs(PL_curcop, "overloading", 0);
3090
3091 assert(PL_curcop->cop_hints & HINT_NO_AMAGIC);
3092
3093 if ( !lex_mask || !SvOK(lex_mask) )
3094 /* overloading lexically disabled */
3095 return FALSE;
3096 else if ( lex_mask && SvPOK(lex_mask) ) {
3097 /* we have an entry in the hints hash, check if method has been
3098 * masked by overloading.pm */
3099 STRLEN len;
3100 const int offset = method / 8;
3101 const int bit = method % 8;
3102 char *pv = SvPV(lex_mask, len);
3103
3104 /* Bit set, so this overloading operator is disabled */
3105 if ( (STRLEN)offset < len && pv[offset] & ( 1 << bit ) )
3106 return FALSE;
3107 }
3108 return TRUE;
3109}
3110
a0d0e21e 3111SV*
864dbfa3 3112Perl_amagic_call(pTHX_ SV *left, SV *right, int method, int flags)
a0d0e21e 3113{
27da23d5 3114 dVAR;
b267980d 3115 MAGIC *mg;
9c5ffd7c 3116 CV *cv=NULL;
a0d0e21e 3117 CV **cvp=NULL, **ocvp=NULL;
9c5ffd7c 3118 AMT *amtp=NULL, *oamtp=NULL;
b464bac0
AL		 3119 int off = 0, off1, lr = 0, notfound = 0;
3120 int postpr = 0, force_cpy = 0;
3121 int assign = AMGf_assign & flags;
3122 const int assignshift = assign ? 1 : 0;
bf5522a1 3123 int use_default_op = 0;
67288365 3124 int force_scalar = 0;
497b47a8
JH		 3125#ifdef DEBUGGING
3126 int fl=0;
497b47a8 3127#endif
25716404 3128 HV* stash=NULL;
7918f24d
NC		 3129
3130 PERL_ARGS_ASSERT_AMAGIC_CALL;
3131
e46c382e 3132 if ( PL_curcop->cop_hints & HINT_NO_AMAGIC ) {
8d569291 3133 if (!amagic_is_enabled(method)) return NULL;
e46c382e
YK		 3134 }
3135
a0d0e21e 3136 if (!(AMGf_noleft & flags) && SvAMAGIC(left)
0a2c84ab 3137 && (stash = SvSTASH(SvRV(left))) && Gv_AMG(stash)
ad64d0ec 3138 && (mg = mg_find((const SV *)stash, PERL_MAGIC_overload_table))
b267980d 3139 && (ocvp = cvp = (AMT_AMAGIC((AMT*)mg->mg_ptr)
a6006777 3140 ? (oamtp = amtp = (AMT*)mg->mg_ptr)->table
d4c19fe8 3141 : NULL))
b267980d 3142 && ((cv = cvp[off=method+assignshift])
748a9306
LW		 3143 || (assign && amtp->fallback > AMGfallNEVER && /* fallback to
3144 * usual method */
497b47a8
JH		 3145 (
3146#ifdef DEBUGGING
3147 fl = 1,
a0288114 3148#endif
497b47a8 3149 cv = cvp[off=method])))) {
a0d0e21e
LW		 3150 lr = -1; /* Call method for left argument */
3151 } else {
3152 if (cvp && amtp->fallback > AMGfallNEVER && flags & AMGf_unary) {
3153 int logic;
3154
3155 /* look for substituted methods */
ee239bfe 3156 /* In all the covered cases we should be called with assign==0. */
a0d0e21e
LW		 3157 switch (method) {
3158 case inc_amg:
ee239bfe
IZ		 3159 force_cpy = 1;
3160 if ((cv = cvp[off=add_ass_amg])
3161 || ((cv = cvp[off = add_amg]) && (force_cpy = 0, postpr = 1))) {
3280af22 3162 right = &PL_sv_yes; lr = -1; assign = 1;
a0d0e21e
LW		 3163 }
3164 break;
3165 case dec_amg:
ee239bfe
IZ		 3166 force_cpy = 1;
3167 if ((cv = cvp[off = subtr_ass_amg])
3168 || ((cv = cvp[off = subtr_amg]) && (force_cpy = 0, postpr=1))) {
3280af22 3169 right = &PL_sv_yes; lr = -1; assign = 1;
a0d0e21e
LW		 3170 }
3171 break;
3172 case bool__amg:
3173 (void)((cv = cvp[off=numer_amg]) || (cv = cvp[off=string_amg]));
3174 break;
3175 case numer_amg:
3176 (void)((cv = cvp[off=string_amg]) || (cv = cvp[off=bool__amg]));
3177 break;
3178 case string_amg:
3179 (void)((cv = cvp[off=numer_amg]) || (cv = cvp[off=bool__amg]));
3180 break;
b7787f18
AL		 3181 case not_amg:
3182 (void)((cv = cvp[off=bool__amg])
3183 || (cv = cvp[off=numer_amg])
3184 || (cv = cvp[off=string_amg]));
2ab54efd
MB		 3185 if (cv)
3186 postpr = 1;
b7787f18 3187 break;
748a9306
LW		 3188 case copy_amg:
3189 {
76e3520e
GS		 3190 /*
3191 * SV* ref causes confusion with the interpreter variable of
3192 * the same name
3193 */
890ce7af 3194 SV* const tmpRef=SvRV(left);
76e3520e 3195 if (!SvROK(tmpRef) && SvTYPE(tmpRef) <= SVt_PVMG) {
fc36a67e 3196 /*
3197 * Just to be extra cautious. Maybe in some
3198 * additional cases sv_setsv is safe, too.
3199 */
890ce7af 3200 SV* const newref = newSVsv(tmpRef);
748a9306 3201 SvOBJECT_on(newref);
a1cd65be
FC		 3202 /* No need to do SvAMAGIC_on here, as SvAMAGIC macros
3203 delegate to the stash. */
85fbaab2 3204 SvSTASH_set(newref, MUTABLE_HV(SvREFCNT_inc(SvSTASH(tmpRef))));
748a9306
LW		 3205 return newref;
3206 }
3207 }
3208 break;
a0d0e21e 3209 case abs_amg:
b267980d 3210 if ((cvp[off1=lt_amg] || cvp[off1=ncmp_amg])
a0d0e21e 3211 && ((cv = cvp[off=neg_amg]) || (cv = cvp[off=subtr_amg]))) {
725c44f9 3212 SV* const nullsv=&PL_sv_zero;
a0d0e21e 3213 if (off1==lt_amg) {
890ce7af 3214 SV* const lessp = amagic_call(left,nullsv,
a0d0e21e 3215 lt_amg,AMGf_noright);
f4c975aa 3216 logic = SvTRUE_NN(lessp);
a0d0e21e 3217 } else {
890ce7af 3218 SV* const lessp = amagic_call(left,nullsv,
a0d0e21e
LW		 3219 ncmp_amg,AMGf_noright);
3220 logic = (SvNV(lessp) < 0);
3221 }
3222 if (logic) {
3223 if (off==subtr_amg) {
3224 right = left;
748a9306 3225 left = nullsv;
a0d0e21e
LW		 3226 lr = 1;
3227 }
3228 } else {
3229 return left;
3230 }
3231 }
3232 break;
3233 case neg_amg:
155aba94 3234 if ((cv = cvp[off=subtr_amg])) {
a0d0e21e 3235 right = left;
725c44f9 3236 left = &PL_sv_zero;
a0d0e21e
LW		 3237 lr = 1;
3238 }
3239 break;
f216259d 3240 case int_amg:
f5284f61 3241 case iter_amg: /* XXXX Eventually should do to_gv. */
c4c7412c 3242 case ftest_amg: /* XXXX Eventually should do to_gv. */
d4b87e75 3243 case regexp_amg:
b267980d
NIS		 3244 /* FAIL safe */
3245 return NULL; /* Delegate operation to standard mechanisms. */
81d52ecd 3246
f5284f61
IZ		 3247 case to_sv_amg:
3248 case to_av_amg:
3249 case to_hv_amg:
3250 case to_gv_amg:
3251 case to_cv_amg:
3252 /* FAIL safe */
b267980d 3253 return left; /* Delegate operation to standard mechanisms. */
81d52ecd 3254
a0d0e21e
LW		 3255 default:
3256 goto not_found;
3257 }
3258 if (!cv) goto not_found;
3259 } else if (!(AMGf_noright & flags) && SvAMAGIC(right)
0a2c84ab 3260 && (stash = SvSTASH(SvRV(right))) && Gv_AMG(stash)
ad64d0ec 3261 && (mg = mg_find((const SV *)stash, PERL_MAGIC_overload_table))
b267980d 3262 && (cvp = (AMT_AMAGIC((AMT*)mg->mg_ptr)
a6006777 3263 ? (amtp = (AMT*)mg->mg_ptr)->table
d4c19fe8 3264 : NULL))
69815d08
RS		 3265 && (cv = cvp[off=method])) { /* Method for right
3266 * argument found */
3267 lr=1;
bf5522a1
MB		 3268 } else if (((cvp && amtp->fallback > AMGfallNEVER)
3269 || (ocvp && oamtp->fallback > AMGfallNEVER))
a0d0e21e
LW		 3270 && !(flags & AMGf_unary)) {
3271 /* We look for substitution for
3272 * comparison operations and
fc36a67e 3273 * concatenation */
a0d0e21e
LW		 3274 if (method==concat_amg || method==concat_ass_amg
3275 || method==repeat_amg || method==repeat_ass_amg) {
3276 return NULL; /* Delegate operation to string conversion */
3277 }
3278 off = -1;
3279 switch (method) {
3280 case lt_amg:
3281 case le_amg:
3282 case gt_amg:
3283 case ge_amg:
3284 case eq_amg:
3285 case ne_amg:
2ab54efd
MB		 3286 off = ncmp_amg;
3287 break;
a0d0e21e
LW		 3288 case slt_amg:
3289 case sle_amg:
3290 case sgt_amg:
3291 case sge_amg:
3292 case seq_amg:
3293 case sne_amg:
2ab54efd
MB		 3294 off = scmp_amg;
3295 break;
a0d0e21e 3296 }
bf5522a1
MB		 3297 if (off != -1) {
3298 if (ocvp && (oamtp->fallback > AMGfallNEVER)) {
3299 cv = ocvp[off];
3300 lr = -1;
3301 }
3302 if (!cv && (cvp && amtp->fallback > AMGfallNEVER)) {
3303 cv = cvp[off];
3304 lr = 1;
3305 }
3306 }
3307 if (cv)
2ab54efd
MB		 3308 postpr = 1;
3309 else
3310 goto not_found;
a0d0e21e 3311 } else {
a6006777 3312 not_found: /* No method found, either report or croak */
b267980d
NIS		 3313 switch (method) {
3314 case to_sv_amg:
3315 case to_av_amg:
3316 case to_hv_amg:
3317 case to_gv_amg:
3318 case to_cv_amg:
3319 /* FAIL safe */
3320 return left; /* Delegate operation to standard mechanisms. */
b267980d 3321 }
a0d0e21e
LW		 3322 if (ocvp && (cv=ocvp[nomethod_amg])) { /* Call report method */
3323 notfound = 1; lr = -1;
3324 } else if (cvp && (cv=cvp[nomethod_amg])) {
3325 notfound = 1; lr = 1;
bf5522a1
MB		 3326 } else if ((use_default_op =
3327 (!ocvp || oamtp->fallback >= AMGfallYES)
3328 && (!cvp || amtp->fallback >= AMGfallYES))
3329 && !DEBUG_o_TEST) {
4cc0ca18
NC		 3330 /* Skip generating the "no method found" message. */
3331 return NULL;
a0d0e21e 3332 } else {
46fc3d4c 3333 SV *msg;
774d564b 3334 if (off==-1) off=method;
b267980d 3335 msg = sv_2mortal(Perl_newSVpvf(aTHX_
147e3846 3336 "Operation \"%s\": no method found,%sargument %s%" SVf "%s%" SVf,
d66cca07
BF		 3337 AMG_id2name(method + assignshift),
3338 (flags & AMGf_unary ? " " : "\n\tleft "),
3339 SvAMAGIC(left)?
3340 "in overloaded package ":
3341 "has no overloaded magic",
3342 SvAMAGIC(left)?
3343 SVfARG(sv_2mortal(newSVhek(HvNAME_HEK(SvSTASH(SvRV(left)))))):
3344 SVfARG(&PL_sv_no),
3345 SvAMAGIC(right)?
3346 ",\n\tright argument in overloaded package ":
3347 (flags & AMGf_unary
3348 ? ""
3349 : ",\n\tright argument has no overloaded magic"),
3350 SvAMAGIC(right)?
3351 SVfARG(sv_2mortal(newSVhek(HvNAME_HEK(SvSTASH(SvRV(right)))))):
3352 SVfARG(&PL_sv_no)));
bf5522a1 3353 if (use_default_op) {
147e3846 3354 DEBUG_o( Perl_deb(aTHX_ "%" SVf, SVfARG(msg)) );
a0d0e21e 3355 } else {
147e3846 3356 Perl_croak(aTHX_ "%" SVf, SVfARG(msg));
a0d0e21e
LW		 3357 }
3358 return NULL;
3359 }
ee239bfe 3360 force_cpy = force_cpy || assign;
a0d0e21e
LW		 3361 }
3362 }
67288365
JL		 3363
3364 switch (method) {
3365 /* in these cases, we're calling '+' or '-' as a fallback for a ++ or --
3366 * operation. we need this to return a value, so that it can be assigned
3367 * later on, in the postpr block (case inc_amg/dec_amg), even if the
3368 * increment or decrement was itself called in void context */
3369 case inc_amg:
3370 if (off == add_amg)
3371 force_scalar = 1;
3372 break;
3373 case dec_amg:
3374 if (off == subtr_amg)
3375 force_scalar = 1;
3376 break;
3377 /* in these cases, we're calling an assignment variant of an operator
3378 * (+= rather than +, for instance). regardless of whether it's a
3379 * fallback or not, it always has to return a value, which will be
3380 * assigned to the proper variable later */
3381 case add_amg:
3382 case subtr_amg:
3383 case mult_amg:
3384 case div_amg:
3385 case modulo_amg:
3386 case pow_amg:
3387 case lshift_amg:
3388 case rshift_amg:
3389 case repeat_amg:
3390 case concat_amg:
3391 case band_amg:
3392 case bor_amg:
3393 case bxor_amg:
6d06ecce
FC		 3394 case sband_amg:
3395 case sbor_amg:
3396 case sbxor_amg:
67288365
JL		 3397 if (assign)
3398 force_scalar = 1;
3399 break;
3400 /* the copy constructor always needs to return a value */
3401 case copy_amg:
3402 force_scalar = 1;
3403 break;
3404 /* because of the way these are implemented (they don't perform the
3405 * dereferencing themselves, they return a reference that perl then
3406 * dereferences later), they always have to be in scalar context */
3407 case to_sv_amg:
3408 case to_av_amg:
3409 case to_hv_amg:
3410 case to_gv_amg:
3411 case to_cv_amg:
3412 force_scalar = 1;
3413 break;
3414 /* these don't have an op of their own; they're triggered by their parent
3415 * op, so the context there isn't meaningful ('$a and foo()' in void
3416 * context still needs to pass scalar context on to $a's bool overload) */
3417 case bool__amg:
3418 case numer_amg:
3419 case string_amg:
3420 force_scalar = 1;
3421 break;
3422 }
3423
497b47a8 3424#ifdef DEBUGGING
a0d0e21e 3425 if (!notfound) {
497b47a8 3426 DEBUG_o(Perl_deb(aTHX_
147e3846 3427 "Overloaded operator \"%s\"%s%s%s:\n\tmethod%s found%s in package %" SVf "%s\n",
497b47a8
JH		 3428 AMG_id2name(off),
3429 method+assignshift==off? "" :
a0288114 3430 " (initially \"",
497b47a8
JH		 3431 method+assignshift==off? "" :
3432 AMG_id2name(method+assignshift),
a0288114 3433 method+assignshift==off? "" : "\")",
497b47a8
JH		 3434 flags & AMGf_unary? "" :
3435 lr==1 ? " for right argument": " for left argument",
3436 flags & AMGf_unary? " for argument" : "",
d66cca07 3437 stash ? SVfARG(sv_2mortal(newSVhek(HvNAME_HEK(stash)))) : SVfARG(newSVpvs_flags("null", SVs_TEMP)),
497b47a8 3438 fl? ",\n\tassignment variant used": "") );
ee239bfe 3439 }
497b47a8 3440#endif
748a9306
LW		 3441 /* Since we use shallow copy during assignment, we need
3442 * to dublicate the contents, probably calling user-supplied
3443 * version of copy operator
3444 */
ee239bfe
IZ		 3445 /* We need to copy in following cases:
3446 * a) Assignment form was called.
3447 * assignshift==1, assign==T, method + 1 == off
3448 * b) Increment or decrement, called directly.
3449 * assignshift==0, assign==0, method + 0 == off
3450 * c) Increment or decrement, translated to assignment add/subtr.
b267980d 3451 * assignshift==0, assign==T,
ee239bfe
IZ		 3452 * force_cpy == T
3453 * d) Increment or decrement, translated to nomethod.
b267980d 3454 * assignshift==0, assign==0,
ee239bfe
IZ		 3455 * force_cpy == T
3456 * e) Assignment form translated to nomethod.
3457 * assignshift==1, assign==T, method + 1 != off
3458 * force_cpy == T
3459 */
3460 /* off is method, method+assignshift, or a result of opcode substitution.
3461 * In the latter case assignshift==0, so only notfound case is important.
3462 */
73512201 3463 if ( (lr == -1) && ( ( (method + assignshift == off)
ee239bfe 3464 && (assign || (method == inc_amg) || (method == dec_amg)))
73512201 3465 || force_cpy) )
6f1401dc 3466 {
1b38c28e
NC		 3467 /* newSVsv does not behave as advertised, so we copy missing
3468 * information by hand */
3469 SV *tmpRef = SvRV(left);
3470 SV *rv_copy;
31d632c3 3471 if (SvREFCNT(tmpRef) > 1 && (rv_copy = AMG_CALLunary(left,copy_amg))) {
1b38c28e
NC		 3472 SvRV_set(left, rv_copy);
3473 SvSETMAGIC(left);
e7881358 3474 SvREFCNT_dec_NN(tmpRef);
1b38c28e 3475 }
6f1401dc
DM		 3476 }
3477
a0d0e21e
LW		 3478 {
3479 dSP;
3480 BINOP myop;
3481 SV* res;
b7787f18 3482 const bool oldcatch = CATCH_GET;
67288365 3483 I32 oldmark, nret;
e839e6ed
DM		 3484 /* for multiconcat, we may call overload several times,
3485 * with the context of individual concats being scalar,
3486 * regardless of the overall context of the multiconcat op
3487 */
3488 U8 gimme = (force_scalar || PL_op->op_type == OP_MULTICONCAT)
3489 ? G_SCALAR : GIMME_V;
a0d0e21e 3490
54310121 3491 CATCH_SET(TRUE);
a0d0e21e
LW		 3492 Zero(&myop, 1, BINOP);
3493 myop.op_last = (OP *) &myop;
b37c2d43 3494 myop.op_next = NULL;
67288365
JL		 3495 myop.op_flags = OPf_STACKED;
3496
3497 switch (gimme) {
3498 case G_VOID:
3499 myop.op_flags |= OPf_WANT_VOID;
3500 break;
3501 case G_ARRAY:
3502 if (flags & AMGf_want_list) {
3503 myop.op_flags |= OPf_WANT_LIST;
3504 break;
3505 }
3506 /* FALLTHROUGH */
3507 default:
3508 myop.op_flags |= OPf_WANT_SCALAR;
3509 break;
3510 }
a0d0e21e 3511
e788e7d3 3512 PUSHSTACKi(PERLSI_OVERLOAD);
a0d0e21e 3513 ENTER;
462e5cf6 3514 SAVEOP();
533c011a 3515 PL_op = (OP *) &myop;
3280af22 3516 if (PERLDB_SUB && PL_curstash != PL_debstash)
533c011a 3517 PL_op->op_private |= OPpENTERSUB_DB;
897d3989 3518 Perl_pp_pushmark(aTHX);
a0d0e21e 3519
924508f0 3520 EXTEND(SP, notfound + 5);
a0d0e21e
LW		 3521 PUSHs(lr>0? right: left);
3522 PUSHs(lr>0? left: right);
3280af22 3523 PUSHs( lr > 0 ? &PL_sv_yes : ( assign ? &PL_sv_undef : &PL_sv_no ));
a0d0e21e 3524 if (notfound) {
59cd0e26
NC		 3525 PUSHs(newSVpvn_flags(AMG_id2name(method + assignshift),
3526 AMG_id2namelen(method + assignshift), SVs_TEMP));
a0d0e21e 3527 }
636ac8fc
FC		 3528 else if (flags & AMGf_numarg)
3529 PUSHs(&PL_sv_undef);
3530 if (flags & AMGf_numarg)
3531 PUSHs(&PL_sv_yes);
ad64d0ec 3532 PUSHs(MUTABLE_SV(cv));
a0d0e21e 3533 PUTBACK;
67288365 3534 oldmark = TOPMARK;
a0d0e21e 3535
139d0ce6 3536 if ((PL_op = PL_ppaddr[OP_ENTERSUB](aTHX)))
cea2e8a9 3537 CALLRUNOPS(aTHX);
a0d0e21e
LW		 3538 LEAVE;
3539 SPAGAIN;
67288365
JL		 3540 nret = SP - (PL_stack_base + oldmark);
3541
3542 switch (gimme) {
3543 case G_VOID:
3544 /* returning NULL has another meaning, and we check the context
3545 * at the call site too, so this can be differentiated from the
3546 * scalar case */
3547 res = &PL_sv_undef;
3548 SP = PL_stack_base + oldmark;
3549 break;
2165bd23 3550 case G_ARRAY:
67288365
JL		 3551 if (flags & AMGf_want_list) {
3552 res = sv_2mortal((SV *)newAV());
3553 av_extend((AV *)res, nret);
3554 while (nret--)
3555 av_store((AV *)res, nret, POPs);
3556 break;
3557 }
3558 /* FALLTHROUGH */
67288365
JL		 3559 default:
3560 res = POPs;
3561 break;
3562 }
a0d0e21e 3563
ebafeae7 3564 PUTBACK;
d3acc0f7 3565 POPSTACK;
54310121 3566 CATCH_SET(oldcatch);
a0d0e21e 3567
a0d0e21e 3568 if (postpr) {
b7787f18 3569 int ans;
a0d0e21e
LW		 3570 switch (method) {
3571 case le_amg:
3572 case sle_amg:
3573 ans=SvIV(res)<=0; break;
3574 case lt_amg:
3575 case slt_amg:
3576 ans=SvIV(res)<0; break;
3577 case ge_amg:
3578 case sge_amg:
3579 ans=SvIV(res)>=0; break;
3580 case gt_amg:
3581 case sgt_amg:
3582 ans=SvIV(res)>0; break;
3583 case eq_amg:
3584 case seq_amg:
3585 ans=SvIV(res)==0; break;
3586 case ne_amg:
3587 case sne_amg:
3588 ans=SvIV(res)!=0; break;
3589 case inc_amg:
3590 case dec_amg:
bbce6d69 3591 SvSetSV(left,res); return left;
dc437b57 3592 case not_amg:
f4c975aa 3593 ans=!SvTRUE_NN(res); break;
b7787f18
AL		 3594 default:
3595 ans=0; break;
a0d0e21e 3596 }
54310121 3597 return boolSV(ans);
748a9306
LW		 3598 } else if (method==copy_amg) {
3599 if (!SvROK(res)) {
cea2e8a9 3600 Perl_croak(aTHX_ "Copy method did not return a reference");
748a9306
LW		 3601 }
3602 return SvREFCNT_inc(SvRV(res));
a0d0e21e
LW		 3603 } else {
3604 return res;
3605 }
3606 }
3607}
c9d5ac95 3608
f5c1e807
NC		 3609void
3610Perl_gv_name_set(pTHX_ GV *gv, const char *name, U32 len, U32 flags)
3611{
3612 dVAR;
acda4c6a 3613 U32 hash;
f5c1e807 3614
7918f24d 3615 PERL_ARGS_ASSERT_GV_NAME_SET;
f5c1e807 3616
acda4c6a 3617 if (len > I32_MAX)
147e3846 3618 Perl_croak(aTHX_ "panic: gv name too long (%" UVuf ")", (UV) len);
acda4c6a 3619
ae8cc45f
NC		 3620 if (!(flags & GV_ADD) && GvNAME_HEK(gv)) {
3621 unshare_hek(GvNAME_HEK(gv));
3622 }
3623
acda4c6a 3624 PERL_HASH(hash, name, len);
c60dbbc3 3625 GvNAME_HEK(gv) = share_hek(name, (flags & SVf_UTF8 ? -(I32)len : (I32)len), hash);
f5c1e807
NC		 3626}
3627
66610fdd 3628/*
f7461760
Z		 3629=for apidoc gv_try_downgrade
3630
2867cdbc
Z		 3631If the typeglob C<gv> can be expressed more succinctly, by having
3632something other than a real GV in its place in the stash, replace it
3633with the optimised form. Basic requirements for this are that C<gv>
3634is a real typeglob, is sufficiently ordinary, and is only referenced
3635from its package. This function is meant to be used when a GV has been
3636looked up in part to see what was there, causing upgrading, but based
3637on what was found it turns out that the real GV isn't required after all.
3638
3639If C<gv> is a completely empty typeglob, it is deleted from the stash.
3640
3641If C<gv> is a typeglob containing only a sufficiently-ordinary constant
3642sub, the typeglob is replaced with a scalar-reference placeholder that
3643more compactly represents the same thing.
f7461760
Z		 3644
3645=cut
3646*/
3647
3648void
3649Perl_gv_try_downgrade(pTHX_ GV *gv)
3650{
3651 HV *stash;
3652 CV *cv;
3653 HEK *namehek;
3654 SV **gvp;
3655 PERL_ARGS_ASSERT_GV_TRY_DOWNGRADE;
95f56751
FC		 3656
3657 /* XXX Why and where does this leave dangling pointers during global
3658 destruction? */
627364f1 3659 if (PL_phase == PERL_PHASE_DESTRUCT) return;
95f56751 3660
2867cdbc 3661 if (!(SvREFCNT(gv) == 1 && SvTYPE(gv) == SVt_PVGV && !SvFAKE(gv) &&
803f2748 3662 !SvOBJECT(gv) && !SvREADONLY(gv) &&
f7461760 3663 isGV_with_GP(gv) && GvGP(gv) &&
2867cdbc 3664 !GvINTRO(gv) && GvREFCNT(gv) == 1 &&
f7461760 3665 !GvSV(gv) && !GvAV(gv) && !GvHV(gv) && !GvIOp(gv) && !GvFORM(gv) &&
099be4f1 3666 GvEGVx(gv) == gv && (stash = GvSTASH(gv))))
2867cdbc 3667 return;
2be08ad1
FC		 3668 if (gv == PL_statgv || gv == PL_last_in_gv || gv == PL_stderrgv)
3669 return;
803f2748
DM		 3670 if (SvMAGICAL(gv)) {
3671 MAGIC *mg;
3672 /* only backref magic is allowed */
3673 if (SvGMAGICAL(gv) || SvSMAGICAL(gv))
3674 return;
3675 for (mg = SvMAGIC(gv); mg; mg = mg->mg_moremagic) {
3676 if (mg->mg_type != PERL_MAGIC_backref)
3677 return;
3678 }
3679 }
2867cdbc
Z		 3680 cv = GvCV(gv);
3681 if (!cv) {
3682 HEK *gvnhek = GvNAME_HEK(gv);
0ca9877d 3683 (void)hv_deletehek(stash, gvnhek, G_DISCARD);
8941bf97 3684 } else if (GvMULTI(gv) && cv && SvREFCNT(cv) == 1 &&
f7461760 3685 !SvOBJECT(cv) && !SvMAGICAL(cv) && !SvREADONLY(cv) &&
34d81fc4 3686 CvSTASH(cv) == stash && !CvNAMED(cv) && CvGV(cv) == gv &&
f7461760
Z		 3687 CvCONST(cv) && !CvMETHOD(cv) && !CvLVALUE(cv) && !CvUNIQUE(cv) &&
3688 !CvNODEBUG(cv) && !CvCLONE(cv) && !CvCLONED(cv) && !CvANON(cv) &&
3689 (namehek = GvNAME_HEK(gv)) &&
48c2c411 3690 (gvp = hv_fetchhek(stash, namehek, 0)) &&
f7461760
Z		 3691 *gvp == (SV*)gv) {
3692 SV *value = SvREFCNT_inc(CvXSUBANY(cv).any_ptr);
70e5f2b5 3693 const bool imported = !!GvIMPORTED_CV(gv);
f7461760
Z		 3694 SvREFCNT(gv) = 0;
3695 sv_clear((SV*)gv);
3696 SvREFCNT(gv) = 1;
70e5f2b5 3697 SvFLAGS(gv) = SVt_IV|SVf_ROK|SVprv_PCS_IMPORTED * imported;
dc6369ef
EH		 3698
3699 /* See also: 'SET_SVANY_FOR_BODYLESS_IV' in sv.c */
f7461760
Z		 3700 SvANY(gv) = (XPVGV*)((char*)&(gv->sv_u.svu_iv) -
3701 STRUCT_OFFSET(XPVIV, xiv_iv));
3702 SvRV_set(gv, value);
3703 }
3704}
3705
9e3fb20c
FC		 3706GV *
3707Perl_gv_override(pTHX_ const char * const name, const STRLEN len)
3708{
3709 GV *gv = gv_fetchpvn(name, len, GV_NOTQUAL, SVt_PVCV);
3710 GV * const *gvp;
3711 PERL_ARGS_ASSERT_GV_OVERRIDE;
3712 if (gv && GvCVu(gv) && GvIMPORTED_CV(gv)) return gv;
3713 gvp = (GV**)hv_fetch(PL_globalstash, name, len, FALSE);
3714 gv = gvp ? *gvp : NULL;
3715 if (gv && !isGV(gv)) {
3716 if (!SvPCS_IMPORTED(gv)) return NULL;
3717 gv_init(gv, PL_globalstash, name, len, 0);
3718 return gv;
3719 }
3720 return gv && GvCVu(gv) && GvIMPORTED_CV(gv) ? gv : NULL;
3721}
3722
4aaa4757
FC		 3723#include "XSUB.h"
3724
3725static void
3726core_xsub(pTHX_ CV* cv)
3727{
3728 Perl_croak(aTHX_
3729 "&CORE::%s cannot be called directly", GvNAME(CvGV(cv))
3730 );
3731}
3732
f7461760 3733/*
14d04a33 3734 * ex: set ts=8 sts=4 sw=4 et:
37442d52 3735 */
Unnamed repository; edit this file 'description' to name the repository.