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
locale.c: Avoid localeconv()
[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;
cc4c2da6 2070 case '\024': /* ${^TAINT} */
eafd371c 2071 if (memEQs(name, len, "\024AINT"))
cc4c2da6
NC		 2072 goto ro_magicalize;
2073 break;
7cebcbc0 2074 case '\025': /* ${^UNICODE}, ${^UTF8LOCALE} */
eafd371c 2075 if (memEQs(name, len, "\025NICODE"))
cc4c2da6 2076 goto ro_magicalize;
eafd371c 2077 if (memEQs(name, len, "\025TF8LOCALE"))
7cebcbc0 2078 goto ro_magicalize;
eafd371c 2079 if (memEQs(name, len, "\025TF8CACHE"))
e07ea26a 2080 goto magicalize;
cc4c2da6
NC		 2081 break;
2082 case '\027': /* $^WARNING_BITS */
eafd371c 2083 if (memEQs(name, len, "\027ARNING_BITS"))
cc4c2da6 2084 goto magicalize;
8ca2a5d6 2085#ifdef WIN32
eafd371c 2086 else if (memEQs(name, len, "\027IN32_SLOPPY_STAT"))
8ca2a5d6
DD		 2087 goto magicalize;
2088#endif
cc4c2da6
NC		 2089 break;
2090 case '1':
2091 case '2':
2092 case '3':
2093 case '4':
2094 case '5':
2095 case '6':
2096 case '7':
2097 case '8':
2098 case '9':
85e6fe83 2099 {
2fdbfb4d
AB		 2100 /* Ensures that we have an all-digit variable, ${"1foo"} fails
2101 this test */
22ff3130
HS		 2102 UV uv;
2103 if (!grok_atoUV(name, &uv, NULL) || uv > I32_MAX)
1321bbe3 2104 goto ret;
22ff3130
HS		 2105 /* XXX why are we using a SSize_t? */
2106 paren = (SSize_t)(I32)uv;
960b831f 2107 goto storeparen;
1d7c1841 2108 }
dc437b57 2109 }
93a17b20 2110 }
392db708
NC		 2111 } else {
2112 /* Names of length 1. (Or 0. But name is NUL terminated, so that will
2113 be case '\0' in this switch statement (ie a default case) */
cc4c2da6 2114 switch (*name) {
6361f656 2115 case '&': /* $& */
960b831f
NC		 2116 paren = RX_BUFF_IDX_FULLMATCH;
2117 goto sawampersand;
6361f656 2118 case '`': /* $` */
960b831f
NC		 2119 paren = RX_BUFF_IDX_PREMATCH;
2120 goto sawampersand;
6361f656 2121 case '\'': /* $' */
960b831f
NC		 2122 paren = RX_BUFF_IDX_POSTMATCH;
2123 sawampersand:
1a904fc8 2124#ifdef PERL_SAWAMPERSAND
a289ef89 2125 if (!(
cc4c2da6
NC		 2126 sv_type == SVt_PVAV ||
2127 sv_type == SVt_PVHV ||
2128 sv_type == SVt_PVCV ||
2129 sv_type == SVt_PVFM ||
2130 sv_type == SVt_PVIO
d3b97530
DM		 2131 )) { PL_sawampersand |=
2132 (*name == '`')
2133 ? SAWAMPERSAND_LEFT
2134 : (*name == '&')
2135 ? SAWAMPERSAND_MIDDLE
2136 : SAWAMPERSAND_RIGHT;
2137 }
1a904fc8 2138#endif
960b831f 2139 goto storeparen;
e91d8259
NC		 2140 case '1': /* $1 */
2141 case '2': /* $2 */
2142 case '3': /* $3 */
2143 case '4': /* $4 */
2144 case '5': /* $5 */
2145 case '6': /* $6 */
2146 case '7': /* $7 */
2147 case '8': /* $8 */
2148 case '9': /* $9 */
960b831f
NC		 2149 paren = *name - '0';
2150
2151 storeparen:
e91d8259
NC		 2152 /* Flag the capture variables with a NULL mg_ptr
2153 Use mg_len for the array index to lookup. */
960b831f 2154 sv_magic(GvSVn(gv), MUTABLE_SV(gv), PERL_MAGIC_sv, NULL, paren);
e91d8259 2155 break;
cc4c2da6 2156
6361f656 2157 case ':': /* $: */
c69033f2 2158 sv_setpv(GvSVn(gv),PL_chopset);
cc4c2da6
NC		 2159 goto magicalize;
2160
6361f656 2161 case '?': /* $? */
ff0cee69 2162#ifdef COMPLEX_STATUS
c69033f2 2163 SvUPGRADE(GvSVn(gv), SVt_PVLV);
ff0cee69 2164#endif
cc4c2da6 2165 goto magicalize;
ff0cee69 2166
6361f656 2167 case '!': /* $! */
67261566 2168 GvMULTI_on(gv);
44a2ac75 2169 /* If %! has been used, automatically load Errno.pm. */
d2c93421 2170
ad64d0ec 2171 sv_magic(GvSVn(gv), MUTABLE_SV(gv), PERL_MAGIC_sv, name, len);
d2c93421 2172
7c719134 2173 /* magicalization must be done before require_tie_mod_s is called */
67261566 2174 if (sv_type == SVt_PVHV || sv_type == SVt_PVGV)
7c719134 2175 require_tie_mod_s(gv, '!', "Errno", 1);
d2c93421 2176
6cef1e77 2177 break;
754f85ad
YO		 2178 case '-': /* $-, %-, @- */
2179 case '+': /* $+, %+, @+ */
27deb0cf
YO		 2180 GvMULTI_on(gv); /* no used once warnings here */
2181 { /* $- $+ */
2182 sv_magic(GvSVn(gv), MUTABLE_SV(gv), PERL_MAGIC_sv, name, len);
2183 if (*name == '+')
2184 SvREADONLY_on(GvSVn(gv));
2185 }
2186 { /* %- %+ */
2187 if (sv_type == SVt_PVHV || sv_type == SVt_PVGV)
2188 require_tie_mod_s(gv, *name, "Tie::Hash::NamedCapture",0);
2189 }
2190 { /* @- @+ */
2191 AV* const av = GvAVn(gv);
fa531f32 2192 const Size_t n = *name;
67261566 2193
fa531f32 2194 sv_magic(MUTABLE_SV(av), (SV*)n, PERL_MAGIC_regdata, NULL, 0);
27deb0cf
YO		 2195 SvREADONLY_on(av);
2196 }
80305961 2197 break;
a678626e
A		 2198 case '*': /* $* */
2199 case '#': /* $# */
2200 if (sv_type == SVt_PV)
37398dc1 2201 /* diag_listed_as: $* is no longer supported. Its use will be fatal in Perl 5.30 */
a678626e 2202 Perl_ck_warner_d(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
37398dc1
A		 2203 "$%c is no longer supported. Its use "
2204 "will be fatal in Perl 5.30", *name);
a678626e 2205 break;
b3ca2e83
NC		 2206 case '\010': /* $^H */
2207 {
2208 HV *const hv = GvHVn(gv);
2209 hv_magic(hv, NULL, PERL_MAGIC_hints);
2210 }
2211 goto magicalize;
b82b06b8 2212 case '[': /* $[ */
7d69d4a6 2213 if ((sv_type == SVt_PV || sv_type == SVt_PVGV)
2846acbf 2214 && FEATURE_ARYBASE_IS_ENABLED) {
7c719134 2215 require_tie_mod_s(gv,'[',"arybase",0);
b82b06b8 2216 }
7d69d4a6 2217 else goto magicalize;
b82b06b8 2218 break;
cc4c2da6 2219 case '\023': /* $^S */
2fdbfb4d
AB		 2220 ro_magicalize:
2221 SvREADONLY_on(GvSVn(gv));
924ba076 2222 /* FALLTHROUGH */
6361f656 2223 case '0': /* $0 */
6361f656
AB		 2224 case '^': /* $^ */
2225 case '~': /* $~ */
2226 case '=': /* $= */
2227 case '%': /* $% */
2228 case '.': /* $. */
2229 case '(': /* $( */
2230 case ')': /* $) */
2231 case '<': /* $< */
2232 case '>': /* $> */
2233 case '\\': /* $\ */
2234 case '/': /* $/ */
4505a31f 2235 case '|': /* $| */
9cdac2a2 2236 case '$': /* $$ */
cc4c2da6
NC		 2237 case '\001': /* $^A */
2238 case '\003': /* $^C */
2239 case '\004': /* $^D */
2240 case '\005': /* $^E */
2241 case '\006': /* $^F */
cc4c2da6
NC		 2242 case '\011': /* $^I, NOT \t in EBCDIC */
2243 case '\016': /* $^N */
2244 case '\017': /* $^O */
2245 case '\020': /* $^P */
2246 case '\024': /* $^T */
2247 case '\027': /* $^W */
2248 magicalize:
ad64d0ec 2249 sv_magic(GvSVn(gv), MUTABLE_SV(gv), PERL_MAGIC_sv, name, len);
cc4c2da6 2250 break;
e521374c 2251
cc4c2da6 2252 case '\014': /* $^L */
76f68e9b 2253 sv_setpvs(GvSVn(gv),"\f");
463ee0b2 2254 break;
6361f656 2255 case ';': /* $; */
76f68e9b 2256 sv_setpvs(GvSVn(gv),"\034");
463ee0b2 2257 break;
6361f656 2258 case ']': /* $] */
cc4c2da6 2259 {
3638bf15 2260 SV * const sv = GvSV(gv);
d7aa5382 2261 if (!sv_derived_from(PL_patchlevel, "version"))
ac0e6a2f 2262 upg_version(PL_patchlevel, TRUE);
7d54d38e
SH		 2263 GvSV(gv) = vnumify(PL_patchlevel);
2264 SvREADONLY_on(GvSV(gv));
2265 SvREFCNT_dec(sv);
93a17b20
LW		 2266 }
2267 break;
cc4c2da6
NC		 2268 case '\026': /* $^V */
2269 {
3638bf15 2270 SV * const sv = GvSV(gv);
f9be5ac8
DM		 2271 GvSV(gv) = new_version(PL_patchlevel);
2272 SvREADONLY_on(GvSV(gv));
2273 SvREFCNT_dec(sv);
16070b82
GS		 2274 }
2275 break;
ea238638
FC		 2276 case 'a':
2277 case 'b':
dc3e91f6 2278 if (sv_type == SVt_PV)
ea238638 2279 GvMULTI_on(gv);
cc4c2da6 2280 }
79072805 2281 }
930867a8 2282
1321bbe3
FC		 2283 ret:
2284 /* Return true if we actually did something. */
2285 return GvAV(gv) || GvHV(gv) || GvIO(gv) || GvCV(gv)
2286 || ( GvSV(gv) && (
2287 SvOK(GvSV(gv)) || SvMAGICAL(GvSV(gv))
2288 )
2289 );
71c35c05
BF		 2290}
2291
8c995aba
FC		 2292/* If we do ever start using this later on in the file, we need to make
2293 sure we don’t accidentally use the wrong definition. */
2294#undef SvREADONLY_on
2295
070dc475
BF		 2296/* This function is called when the stash already holds the GV of the magic
2297 * variable we're looking for, but we need to check that it has the correct
2298 * kind of magic. For example, if someone first uses $! and then %!, the
2299 * latter would end up here, and we add the Errno tie to the HASH slot of
2300 * the *! glob.
2301 */
2302PERL_STATIC_INLINE void
2303S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type)
2304{
2305 PERL_ARGS_ASSERT_MAYBE_MULTIMAGIC_GV;
2306
2307 if (sv_type == SVt_PVHV || sv_type == SVt_PVGV) {
2308 if (*name == '!')
7c719134 2309 require_tie_mod_s(gv, '!', "Errno", 1);
070dc475 2310 else if (*name == '-' || *name == '+')
7c719134 2311 require_tie_mod_s(gv, *name, "Tie::Hash::NamedCapture", 0);
a678626e
A		 2312 } else if (sv_type == SVt_PV) {
2313 if (*name == '*' || *name == '#') {
37398dc1 2314 /* diag_listed_as: $# is no longer supported. Its use will be fatal in Perl 5.30 */
a678626e
A		 2315 Perl_ck_warner_d(aTHX_ packWARN2(WARN_DEPRECATED,
2316 WARN_SYNTAX),
37398dc1
A		 2317 "$%c is no longer supported. Its use "
2318 "will be fatal in Perl 5.30", *name);
a678626e 2319 }
070dc475
BF		 2320 }
2321 if (sv_type==SVt_PV || sv_type==SVt_PVGV) {
2322 switch (*name) {
2323 case '[':
7c719134 2324 require_tie_mod_s(gv,'[',"arybase",0);
070dc475
BF		 2325 break;
2326#ifdef PERL_SAWAMPERSAND
2327 case '`':
2328 PL_sawampersand |= SAWAMPERSAND_LEFT;
2329 (void)GvSVn(gv);
2330 break;
2331 case '&':
2332 PL_sawampersand |= SAWAMPERSAND_MIDDLE;
2333 (void)GvSVn(gv);
2334 break;
2335 case '\'':
2336 PL_sawampersand |= SAWAMPERSAND_RIGHT;
2337 (void)GvSVn(gv);
2338 break;
2339#endif
2340 }
2341 }
2342}
2343
71c35c05
BF		 2344GV *
2345Perl_gv_fetchpvn_flags(pTHX_ const char *nambeg, STRLEN full_len, I32 flags,
2346 const svtype sv_type)
2347{
71c35c05
BF		 2348 const char *name = nambeg;
2349 GV *gv = NULL;
2350 GV**gvp;
2351 STRLEN len;
2352 HV *stash = NULL;
2353 const I32 no_init = flags & (GV_NOADD_NOINIT | GV_NOINIT);
2354 const I32 no_expand = flags & GV_NOEXPAND;
2355 const I32 add = flags & ~GV_NOADD_MASK;
2356 const U32 is_utf8 = flags & SVf_UTF8;
930867a8 2357 bool addmg = cBOOL(flags & GV_ADDMG);
71c35c05
BF		 2358 const char *const name_end = nambeg + full_len;
2359 U32 faking_it;
2360
2361 PERL_ARGS_ASSERT_GV_FETCHPVN_FLAGS;
2362
2363 /* If we have GV_NOTQUAL, the caller promised that
2364 * there is no stash, so we can skip the check.
2365 * Similarly if full_len is 0, since then we're
2366 * dealing with something like *{""} or ""->foo()
2367 */
2368 if ((flags & GV_NOTQUAL) || !full_len) {
2369 len = full_len;
2370 }
2371 else if (parse_gv_stash_name(&stash, &gv, &name, &len, nambeg, full_len, is_utf8, add)) {
2372 if (name == name_end) return gv;
2373 }
2374 else {
2375 return NULL;
2376 }
2377
2378 if (!stash && !find_default_stash(&stash, name, len, is_utf8, add, sv_type)) {
2379 return NULL;
2380 }
2381
2382 /* By this point we should have a stash and a name */
c161da64 2383 gvp = (GV**)hv_fetch(stash,name,is_utf8 ? -(I32)len : (I32)len,add);
71c35c05
BF		 2384 if (!gvp || *gvp == (const GV *)&PL_sv_undef) {
2385 if (addmg) gv = (GV *)newSV(0);
2386 else return NULL;
2387 }
2388 else gv = *gvp, addmg = 0;
2389 /* From this point on, addmg means gv has not been inserted in the
2390 symtab yet. */
2391
2392 if (SvTYPE(gv) == SVt_PVGV) {
c002ae9a
BF		 2393 /* The GV already exists, so return it, but check if we need to do
2394 * anything else with it before that.
2395 */
71c35c05 2396 if (add) {
c002ae9a
BF		 2397 /* This is the heuristic that handles if a variable triggers the
2398 * 'used only once' warning. If there's already a GV in the stash
2399 * with this name, then we assume that the variable has been used
2400 * before and turn its MULTI flag on.
2401 * It's a heuristic because it can easily be "tricked", like with
2402 * BEGIN { $a = 1; $::{foo} = *a }; () = $foo
2403 * not warning about $main::foo being used just once
2404 */
71c35c05
BF		 2405 GvMULTI_on(gv);
2406 gv_init_svtype(gv, sv_type);
2407 /* You reach this path once the typeglob has already been created,
2408 either by the same or a different sigil. If this path didn't
2409 exist, then (say) referencing $! first, and %! second would
2410 mean that %! was not handled correctly. */
2411 if (len == 1 && stash == PL_defstash) {
070dc475 2412 maybe_multimagic_gv(gv, name, sv_type);
71c35c05 2413 }
b59bf0b2
KW		 2414 else if (sv_type == SVt_PVAV
2415 && memEQs(name, len, "ISA")
71c35c05
BF		 2416 && (!GvAV(gv) || !SvSMAGICAL(GvAV(gv))))
2417 gv_magicalize_isa(gv);
2418 }
2419 return gv;
2420 } else if (no_init) {
2421 assert(!addmg);
2422 return gv;
c002ae9a
BF		 2423 }
2424 /* If GV_NOEXPAND is true and what we got off the stash is a ref,
2425 * don't expand it to a glob. This is an optimization so that things
2426 * copying constants over, like Exporter, don't have to be rewritten
2427 * to take into account that you can store more than just globs in
2428 * stashes.
2429 */
2430 else if (no_expand && SvROK(gv)) {
71c35c05
BF		 2431 assert(!addmg);
2432 return gv;
2433 }
2434
2435 /* Adding a new symbol.
2436 Unless of course there was already something non-GV here, in which case
2437 we want to behave as if there was always a GV here, containing some sort
2438 of subroutine.
2439 Otherwise we run the risk of creating things like GvIO, which can cause
2440 subtle bugs. eg the one that tripped up SQL::Translator */
2441
2442 faking_it = SvOK(gv);
2443
2444 if (add & GV_ADDWARN)
2445 Perl_ck_warner_d(aTHX_ packWARN(WARN_INTERNAL),
147e3846 2446 "Had to create %" UTF8f " unexpectedly",
71c35c05
BF		 2447 UTF8fARG(is_utf8, name_end-nambeg, nambeg));
2448 gv_init_pvn(gv, stash, name, len, (add & GV_ADDMULTI)|is_utf8);
2449
7a207065
KW		 2450 if ( full_len != 0
2451 && isIDFIRST_lazy_if_safe(name, name + full_len, is_utf8)
2452 && !ckWARN(WARN_ONCE) )
2453 {
71c35c05 2454 GvMULTI_on(gv) ;
7a207065 2455 }
71c35c05
BF		 2456
2457 /* set up magic where warranted */
1321bbe3 2458 if ( gv_magicalize(gv, stash, name, len, sv_type) ) {
930867a8 2459 /* See 23496c6 */
1321bbe3
FC		 2460 if (addmg) {
2461 /* gv_magicalize magicalised this gv, so we want it
930867a8 2462 * stored in the symtab.
1321bbe3
FC		 2463 * Effectively the caller is asking, ‘Does this gv exist?’
2464 * And we respond, ‘Er, *now* it does!’
930867a8
BF		 2465 */
2466 (void)hv_store(stash,name,len,(SV *)gv,0);
1321bbe3
FC		 2467 }
2468 }
2469 else if (addmg) {
2470 /* The temporary GV created above */
930867a8
BF		 2471 SvREFCNT_dec_NN(gv);
2472 gv = NULL;
930867a8 2473 }
71c35c05 2474
e6066781 2475 if (gv) gv_init_svtype(gv, faking_it ? SVt_PVCV : sv_type);
93a17b20 2476 return gv;
79072805
LW		 2477}
2478
2479void
35a4481c 2480Perl_gv_fullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain)
43693395 2481{
ed60a868 2482 const char *name;
35a4481c 2483 const HV * const hv = GvSTASH(gv);
7918f24d
NC		 2484
2485 PERL_ARGS_ASSERT_GV_FULLNAME4;
2486
666ea192 2487 sv_setpv(sv, prefix ? prefix : "");
a0288114 2488
52a6327b 2489 if (hv && (name = HvNAME(hv))) {
ed60a868 2490 const STRLEN len = HvNAMELEN(hv);
61e2287f 2491 if (keepmain || ! memBEGINs(name, len, "main")) {
ed60a868 2492 sv_catpvn_flags(sv,name,len,HvNAMEUTF8(hv)?SV_CATUTF8:SV_CATBYTES);
396482e1 2493 sv_catpvs(sv,"::");
ed60a868 2494 }
43693395 2495 }
ed60a868 2496 else sv_catpvs(sv,"__ANON__::");
04f3bf56 2497 sv_catsv(sv,sv_2mortal(newSVhek(GvNAME_HEK(gv))));
43693395
GS		 2498}
2499
2500void
35a4481c 2501Perl_gv_efullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain)
43693395 2502{
099be4f1 2503 const GV * const egv = GvEGVx(gv);
7918f24d
NC		 2504
2505 PERL_ARGS_ASSERT_GV_EFULLNAME4;
2506
46c461b5 2507 gv_fullname4(sv, egv ? egv : gv, prefix, keepmain);
43693395
GS		 2508}
2509
39a65960
DM		 2510
2511/* recursively scan a stash and any nested stashes looking for entries
2512 * that need the "only used once" warning raised
2513 */
2514
79072805 2515void
51da40ed 2516Perl_gv_check(pTHX_ HV *stash)
79072805 2517{
eb578fdb 2518 I32 i;
463ee0b2 2519
7918f24d
NC		 2520 PERL_ARGS_ASSERT_GV_CHECK;
2521
9e5cda6b 2522 if (!SvOOK(stash))
8990e307 2523 return;
90754377 2524
9e5cda6b 2525 assert(HvARRAY(stash));
90754377 2526
a0d0e21e 2527 for (i = 0; i <= (I32) HvMAX(stash); i++) {
e1ec3a88 2528 const HE *entry;
90754377 2529 /* mark stash is being scanned, to avoid recursing */
339441ef 2530 HvAUX(stash)->xhv_aux_flags |= HvAUXf_SCAN_STASH;
dc437b57 2531 for (entry = HvARRAY(stash)[i]; entry; entry = HeNEXT(entry)) {
eb578fdb 2532 GV *gv;
b7787f18 2533 HV *hv;
e7acdfe9
DM		 2534 STRLEN keylen = HeKLEN(entry);
2535 const char * const key = HeKEY(entry);
2536
2537 if (keylen >= 2 && key[keylen-2] == ':' && key[keylen-1] == ':' &&
159b6efe 2538 (gv = MUTABLE_GV(HeVAL(entry))) && isGV(gv) && (hv = GvHV(gv)))
a0d0e21e 2539 {
90754377
DM		 2540 if (hv != PL_defstash && hv != stash
2541 && !(SvOOK(hv)
2542 && (HvAUX(hv)->xhv_aux_flags & HvAUXf_SCAN_STASH))
2543 )
a0d0e21e
LW		 2544 gv_check(hv); /* nested package */
2545 }
7a207065
KW		 2546 else if ( HeKLEN(entry) != 0
2547 && *HeKEY(entry) != '_'
2548 && isIDFIRST_lazy_if_safe(HeKEY(entry),
2549 HeKEY(entry) + HeKLEN(entry),
2550 HeUTF8(entry)) )
2551 {
e1ec3a88 2552 const char *file;
159b6efe 2553 gv = MUTABLE_GV(HeVAL(entry));
55d729e4 2554 if (SvTYPE(gv) != SVt_PVGV || GvMULTI(gv))
463ee0b2 2555 continue;
1d7c1841 2556 file = GvFILE(gv);
1d7c1841 2557 CopLINE_set(PL_curcop, GvLINE(gv));
1dc74fdb
FC		 2558#ifdef USE_ITHREADS
2559 CopFILE(PL_curcop) = (char *)file; /* set for warning */
2560#else
2561 CopFILEGV(PL_curcop)
2562 = gv_fetchfile_flags(file, HEK_LEN(GvFILE_HEK(gv)), 0);
2563#endif
9014280d 2564 Perl_warner(aTHX_ packWARN(WARN_ONCE),
147e3846 2565 "Name \"%" HEKf "::%" HEKf
d0c0e7dd
FC		 2566 "\" used only once: possible typo",
2567 HEKfARG(HvNAME_HEK(stash)),
2568 HEKfARG(GvNAME_HEK(gv)));
463ee0b2 2569 }
79072805 2570 }
339441ef 2571 HvAUX(stash)->xhv_aux_flags &= ~HvAUXf_SCAN_STASH;
79072805
LW		 2572 }
2573}
2574
2575GV *
9cc50d5b 2576Perl_newGVgen_flags(pTHX_ const char *pack, U32 flags)
79072805 2577{
9cc50d5b 2578 PERL_ARGS_ASSERT_NEWGVGEN_FLAGS;
b17a0679 2579 assert(!(flags & ~SVf_UTF8));
7918f24d 2580
147e3846 2581 return gv_fetchpv(Perl_form(aTHX_ "%" UTF8f "::_GEN_%ld",
b17a0679 2582 UTF8fARG(flags, strlen(pack), pack),
9cc50d5b
BF		 2583 (long)PL_gensym++),
2584 GV_ADD, SVt_PVGV);
79072805
LW		 2585}
2586
2587/* hopefully this is only called on local symbol table entries */
2588
2589GP*
864dbfa3 2590Perl_gp_ref(pTHX_ GP *gp)
79072805 2591{
1d7c1841 2592 if (!gp)
d4c19fe8 2593 return NULL;
79072805 2594 gp->gp_refcnt++;
44a8e56a 2595 if (gp->gp_cv) {
2596 if (gp->gp_cvgen) {
e1a479c5
BB		 2597 /* If the GP they asked for a reference to contains
2598 a method cache entry, clear it first, so that we
2599 don't infect them with our cached entry */
e7881358 2600 SvREFCNT_dec_NN(gp->gp_cv);
601f1833 2601 gp->gp_cv = NULL;
44a8e56a 2602 gp->gp_cvgen = 0;
2603 }
44a8e56a 2604 }
79072805 2605 return gp;
79072805
LW		 2606}
2607
2608void
864dbfa3 2609Perl_gp_free(pTHX_ GV *gv)
79072805 2610{
79072805 2611 GP* gp;
b0d55c99 2612 int attempts = 100;
79072805 2613
f7877b28 2614 if (!gv || !isGV_with_GP(gv) || !(gp = GvGP(gv)))
79072805 2615 return;
f248d071 2616 if (gp->gp_refcnt == 0) {
9b387841
NC		 2617 Perl_ck_warner_d(aTHX_ packWARN(WARN_INTERNAL),
2618 "Attempt to free unreferenced glob pointers"
2619 pTHX__FORMAT pTHX__VALUE);
79072805
LW		 2620 return;
2621 }
4571f4a7 2622 if (gp->gp_refcnt > 1) {
bc81b34d 2623 borrowed:
748a9306
LW		 2624 if (gp->gp_egv == gv)
2625 gp->gp_egv = 0;
4571f4a7 2626 gp->gp_refcnt--;
c43ae56f 2627 GvGP_set(gv, NULL);
79072805 2628 return;
748a9306 2629 }
79072805 2630
b0d55c99
FC		 2631 while (1) {
2632 /* Copy and null out all the glob slots, so destructors do not see
2633 freed SVs. */
2634 HEK * const file_hek = gp->gp_file_hek;
2635 SV * const sv = gp->gp_sv;
2636 AV * const av = gp->gp_av;
2637 HV * const hv = gp->gp_hv;
2638 IO * const io = gp->gp_io;
2639 CV * const cv = gp->gp_cv;
2640 CV * const form = gp->gp_form;
2641
2642 gp->gp_file_hek = NULL;
2643 gp->gp_sv = NULL;
2644 gp->gp_av = NULL;
2645 gp->gp_hv = NULL;
2646 gp->gp_io = NULL;
2647 gp->gp_cv = NULL;
2648 gp->gp_form = NULL;
2649
2650 if (file_hek)
2651 unshare_hek(file_hek);
2652
2653 SvREFCNT_dec(sv);
2654 SvREFCNT_dec(av);
2655 /* FIXME - another reference loop GV -> symtab -> GV ?
2656 Somehow gp->gp_hv can end up pointing at freed garbage. */
2657 if (hv && SvTYPE(hv) == SVt_PVHV) {
c2242065 2658 const HEK *hvname_hek = HvNAME_HEK(hv);
923ed580
FC		 2659 if (PL_stashcache && hvname_hek) {
2660 DEBUG_o(Perl_deb(aTHX_
147e3846 2661 "gp_free clearing PL_stashcache for '%" HEKf "'\n",
923ed580 2662 HEKfARG(hvname_hek)));
0ca9877d 2663 (void)hv_deletehek(PL_stashcache, hvname_hek, G_DISCARD);
923ed580 2664 }
b0d55c99
FC		 2665 SvREFCNT_dec(hv);
2666 }
96d7c888
FC		 2667 if (io && SvREFCNT(io) == 1 && IoIFP(io)
2668 && (IoTYPE(io) == IoTYPE_WRONLY ||
2669 IoTYPE(io) == IoTYPE_RDWR ||
2670 IoTYPE(io) == IoTYPE_APPEND)
2671 && ckWARN_d(WARN_IO)
2672 && IoIFP(io) != PerlIO_stdin()
2673 && IoIFP(io) != PerlIO_stdout()
2674 && IoIFP(io) != PerlIO_stderr()
2675 && !(IoFLAGS(io) & IOf_FAKE_DIRP))
2676 io_close(io, gv, FALSE, TRUE);
b0d55c99
FC		 2677 SvREFCNT_dec(io);
2678 SvREFCNT_dec(cv);
2679 SvREFCNT_dec(form);
2680
bc81b34d
FC		 2681 /* Possibly reallocated by a destructor */
2682 gp = GvGP(gv);
2683
b0d55c99
FC		 2684 if (!gp->gp_file_hek
2685 && !gp->gp_sv
2686 && !gp->gp_av
2687 && !gp->gp_hv
2688 && !gp->gp_io
2689 && !gp->gp_cv
2690 && !gp->gp_form) break;
2691
2692 if (--attempts == 0) {
2693 Perl_die(aTHX_
2694 "panic: gp_free failed to free glob pointer - "
2695 "something is repeatedly re-creating entries"
2696 );
2697 }
13207a71 2698 }
748a9306 2699
bc81b34d
FC		 2700 /* Possibly incremented by a destructor doing glob assignment */
2701 if (gp->gp_refcnt > 1) goto borrowed;
79072805 2702 Safefree(gp);
c43ae56f 2703 GvGP_set(gv, NULL);
79072805
LW		 2704}
2705
d460ef45
NIS		 2706int
2707Perl_magic_freeovrld(pTHX_ SV *sv, MAGIC *mg)
2708{
53c1dcc0
AL		 2709 AMT * const amtp = (AMT*)mg->mg_ptr;
2710 PERL_UNUSED_ARG(sv);
dd374669 2711
7918f24d
NC		 2712 PERL_ARGS_ASSERT_MAGIC_FREEOVRLD;
2713
d460ef45
NIS		 2714 if (amtp && AMT_AMAGIC(amtp)) {
2715 int i;
2716 for (i = 1; i < NofAMmeth; i++) {
53c1dcc0 2717 CV * const cv = amtp->table[i];
b37c2d43 2718 if (cv) {
e7881358 2719 SvREFCNT_dec_NN(MUTABLE_SV(cv));
601f1833 2720 amtp->table[i] = NULL;
d460ef45
NIS		 2721 }
2722 }
2723 }
2724 return 0;
2725}
2726
a0d0e21e 2727/* Updates and caches the CV's */
c3a9a790
RGS		 2728/* Returns:
2729 * 1 on success and there is some overload
2730 * 0 if there is no overload
2731 * -1 if some error occurred and it couldn't croak
2732 */
a0d0e21e 2733
c3a9a790 2734int
242f8760 2735Perl_Gv_AMupdate(pTHX_ HV *stash, bool destructing)
a0d0e21e 2736{
ad64d0ec 2737 MAGIC* const mg = mg_find((const SV *)stash, PERL_MAGIC_overload_table);
a6006777 2738 AMT amt;
9b439311 2739 const struct mro_meta* stash_meta = HvMROMETA(stash);
e1a479c5 2740 U32 newgen;
a0d0e21e 2741
7918f24d
NC		 2742 PERL_ARGS_ASSERT_GV_AMUPDATE;
2743
9b439311 2744 newgen = PL_sub_generation + stash_meta->pkg_gen + stash_meta->cache_gen;
14899595
NC		 2745 if (mg) {
2746 const AMT * const amtp = (AMT*)mg->mg_ptr;
66978156 2747 if (amtp->was_ok_sub == newgen) {
8c34e50d 2748 return AMT_AMAGIC(amtp) ? 1 : 0;
14899595 2749 }
ad64d0ec 2750 sv_unmagic(MUTABLE_SV(stash), PERL_MAGIC_overload_table);
14899595 2751 }
a0d0e21e 2752
bfcb3514 2753 DEBUG_o( Perl_deb(aTHX_ "Recalcing overload magic in package %s\n",HvNAME_get(stash)) );
a0d0e21e 2754
d460ef45 2755 Zero(&amt,1,AMT);
e1a479c5 2756 amt.was_ok_sub = newgen;
a6006777 2757 amt.fallback = AMGfallNO;
2758 amt.flags = 0;
2759
a6006777 2760 {
8c34e50d
FC		 2761 int filled = 0;
2762 int i;
3d147ac2
DM		 2763 bool deref_seen = 0;
2764
a6006777 2765
3866ea3b 2766 /* Work with "fallback" key, which we assume to be first in PL_AMG_names */
a6006777 2767
89ffc314 2768 /* Try to find via inheritance. */
e6919483 2769 GV *gv = gv_fetchmeth_pvn(stash, PL_AMG_names[0], 2, -1, 0);
3866ea3b 2770 SV * const sv = gv ? GvSV(gv) : NULL;
53c1dcc0 2771 CV* cv;
89ffc314
IZ		 2772
2773 if (!gv)
3866ea3b
FC		 2774 {
2775 if (!gv_fetchmeth_pvn(stash, "((", 2, -1, 0))
8c34e50d 2776 goto no_table;
3866ea3b
FC		 2777 }
2778#ifdef PERL_DONT_CREATE_GVSV
2779 else if (!sv) {
6f207bd3 2780 NOOP; /* Equivalent to !SvTRUE and !SvOK */
3866ea3b
FC		 2781 }
2782#endif
79c9643d
JL		 2783 else if (SvTRUE(sv))
2784 /* don't need to set overloading here because fallback => 1
2785 * is the default setting for classes without overloading */
89ffc314 2786 amt.fallback=AMGfallYES;
79c9643d
JL		 2787 else if (SvOK(sv)) {
2788 amt.fallback=AMGfallNEVER;
386a5489 2789 filled = 1;
386a5489 2790 }
79c9643d 2791 else {
386a5489 2792 filled = 1;
386a5489 2793 }
a6006777 2794
3d147ac2 2795 assert(SvOOK(stash));
3d147ac2 2796 /* initially assume the worst */
339441ef 2797 HvAUX(stash)->xhv_aux_flags &= ~HvAUXf_NO_DEREF;
3d147ac2 2798
8c34e50d 2799 for (i = 1; i < NofAMmeth; i++) {
6136c704 2800 const char * const cooky = PL_AMG_names[i];
32251b26 2801 /* Human-readable form, for debugging: */
8c34e50d 2802 const char * const cp = AMG_id2name(i);
d279ab82 2803 const STRLEN l = PL_AMG_namelens[i];
89ffc314 2804
a0288114 2805 DEBUG_o( Perl_deb(aTHX_ "Checking overloading of \"%s\" in package \"%.256s\"\n",
bfcb3514 2806 cp, HvNAME_get(stash)) );
611c1e95
IZ		 2807 /* don't fill the cache while looking up!
2808 Creation of inheritance stubs in intermediate packages may
2809 conflict with the logic of runtime method substitution.
2810 Indeed, for inheritance A -> B -> C, if C overloads "+0",
2811 then we could have created stubs for "(+0" in A and C too.
2812 But if B overloads "bool", we may want to use it for
2813 numifying instead of C's "+0". */
8c34e50d 2814 gv = Perl_gv_fetchmeth_pvn(aTHX_ stash, cooky, l, -1, 0);
46fc3d4c 2815 cv = 0;
c3ad4e54 2816 if (gv && (cv = GvCV(gv)) && CvHASGV(cv)) {
79656330 2817 const HEK * const gvhek = CvGvNAME_HEK(cv);
c3ad4e54
FC		 2818 const HEK * const stashek =
2819 HvNAME_HEK(CvNAMED(cv) ? CvSTASH(cv) : GvSTASH(CvGV(cv)));
b59bf0b2
KW		 2820 if (memEQs(HEK_KEY(gvhek), HEK_LEN(gvhek), "nil")
2821 && stashek
2822 && memEQs(HEK_KEY(stashek), HEK_LEN(stashek), "overload")) {
611c1e95
IZ		 2823 /* This is a hack to support autoloading..., while
2824 knowing *which* methods were declared as overloaded. */
44a8e56a 2825 /* GvSV contains the name of the method. */
6136c704 2826 GV *ngv = NULL;
c69033f2 2827 SV *gvsv = GvSV(gv);
a0288114 2828
147e3846 2829 DEBUG_o( Perl_deb(aTHX_ "Resolving method \"%" SVf256\
a0288114 2830 "\" for overloaded \"%s\" in package \"%.256s\"\n",
f0e9f182 2831 (void*)GvSV(gv), cp, HvNAME(stash)) );
c69033f2 2832 if (!gvsv || !SvPOK(gvsv)
7f415459 2833 || !(ngv = gv_fetchmethod_sv_flags(stash, gvsv, 0)))
dc848c6f 2834 {
a0288114 2835 /* Can be an import stub (created by "can"). */
242f8760 2836 if (destructing) {
c3a9a790 2837 return -1;
242f8760
RGS		 2838 }
2839 else {
d66cca07
BF		 2840 const SV * const name = (gvsv && SvPOK(gvsv))
2841 ? gvsv
2842 : newSVpvs_flags("???", SVs_TEMP);
dcbac5bb 2843 /* diag_listed_as: Can't resolve method "%s" overloading "%s" in package "%s" */
147e3846 2844 Perl_croak(aTHX_ "%s method \"%" SVf256
d66cca07 2845 "\" overloading \"%s\" "\
147e3846 2846 "in package \"%" HEKf256 "\"",
242f8760
RGS		 2847 (GvCVGEN(gv) ? "Stub found while resolving"
2848 : "Can't resolve"),
d66cca07 2849 SVfARG(name), cp,
d0c0e7dd 2850 HEKfARG(
d66cca07 2851 HvNAME_HEK(stash)
d0c0e7dd 2852 ));
242f8760 2853 }
44a8e56a 2854 }
dc848c6f 2855 cv = GvCV(gv = ngv);
44a8e56a 2856 }
b464bac0 2857 DEBUG_o( Perl_deb(aTHX_ "Overloading \"%s\" in package \"%.256s\" via \"%.256s::%.256s\"\n",
bfcb3514 2858 cp, HvNAME_get(stash), HvNAME_get(GvSTASH(CvGV(cv))),
44a8e56a 2859 GvNAME(CvGV(cv))) );
2860 filled = 1;
611c1e95 2861 } else if (gv) { /* Autoloaded... */
ea726b52 2862 cv = MUTABLE_CV(gv);
611c1e95 2863 filled = 1;
44a8e56a 2864 }
ea726b52 2865 amt.table[i]=MUTABLE_CV(SvREFCNT_inc_simple(cv));
3d147ac2
DM		 2866
2867 if (gv) {
2868 switch (i) {
2869 case to_sv_amg:
2870 case to_av_amg:
2871 case to_hv_amg:
2872 case to_gv_amg:
2873 case to_cv_amg:
2874 case nomethod_amg:
2875 deref_seen = 1;
2876 break;
2877 }
2878 }
a0d0e21e 2879 }
3d147ac2 2880 if (!deref_seen)
45479970
DM		 2881 /* none of @{} etc overloaded; we can do $obj->[N] quicker.
2882 * NB - aux var invalid here, HvARRAY() could have been
2883 * reallocated since it was assigned to */
2884 HvAUX(stash)->xhv_aux_flags |= HvAUXf_NO_DEREF;
3d147ac2 2885
a0d0e21e 2886 if (filled) {
a6006777 2887 AMT_AMAGIC_on(&amt);
ad64d0ec 2888 sv_magic(MUTABLE_SV(stash), 0, PERL_MAGIC_overload_table,
14befaf4 2889 (char*)&amt, sizeof(AMT));
8c34e50d 2890 return TRUE;
a0d0e21e
LW		 2891 }
2892 }
a6006777 2893 /* Here we have no table: */
8c34e50d 2894 no_table:
a6006777 2895 AMT_AMAGIC_off(&amt);
ad64d0ec 2896 sv_magic(MUTABLE_SV(stash), 0, PERL_MAGIC_overload_table,
14befaf4 2897 (char*)&amt, sizeof(AMTS));
c3a9a790 2898 return 0;
a0d0e21e
LW		 2899}
2900
32251b26
IZ		 2901
2902CV*
2903Perl_gv_handler(pTHX_ HV *stash, I32 id)
2904{
3f8f4626 2905 MAGIC *mg;
32251b26 2906 AMT *amtp;
e1a479c5 2907 U32 newgen;
9b439311 2908 struct mro_meta* stash_meta;
32251b26 2909
bfcb3514 2910 if (!stash || !HvNAME_get(stash))
601f1833 2911 return NULL;
e1a479c5 2912
9b439311
BB		 2913 stash_meta = HvMROMETA(stash);
2914 newgen = PL_sub_generation + stash_meta->pkg_gen + stash_meta->cache_gen;
e1a479c5 2915
ad64d0ec 2916 mg = mg_find((const SV *)stash, PERL_MAGIC_overload_table);
32251b26
IZ		 2917 if (!mg) {
2918 do_update:
8c34e50d 2919 if (Gv_AMupdate(stash, 0) == -1)
242f8760 2920 return NULL;
ad64d0ec 2921 mg = mg_find((const SV *)stash, PERL_MAGIC_overload_table);
32251b26 2922 }
a9fd4e40 2923 assert(mg);
32251b26 2924 amtp = (AMT*)mg->mg_ptr;
66978156 2925 if ( amtp->was_ok_sub != newgen )
32251b26 2926 goto do_update;
3ad83ce7 2927 if (AMT_AMAGIC(amtp)) {
b7787f18 2928 CV * const ret = amtp->table[id];
3ad83ce7
AMS		 2929 if (ret && isGV(ret)) { /* Autoloading stab */
2930 /* Passing it through may have resulted in a warning
2931 "Inherited AUTOLOAD for a non-method deprecated", since
2932 our caller is going through a function call, not a method call.
2933 So return the CV for AUTOLOAD, setting $AUTOLOAD. */
890ce7af 2934 GV * const gv = gv_fetchmethod(stash, PL_AMG_names[id]);
3ad83ce7
AMS		 2935
2936 if (gv && GvCV(gv))
2937 return GvCV(gv);
2938 }
2939 return ret;
2940 }
a0288114 2941
601f1833 2942 return NULL;
32251b26
IZ		 2943}
2944
2945
6f1401dc
DM		 2946/* Implement tryAMAGICun_MG macro.
2947 Do get magic, then see if the stack arg is overloaded and if so call it.
2948 Flags:
2949 AMGf_set return the arg using SETs rather than assigning to
2950 the targ
2951 AMGf_numeric apply sv_2num to the stack arg.
2952*/
2953
2954bool
2955Perl_try_amagic_un(pTHX_ int method, int flags) {
6f1401dc
DM		 2956 dSP;
2957 SV* tmpsv;
2958 SV* const arg = TOPs;
2959
2960 SvGETMAGIC(arg);
2961
9f8bf298 2962 if (SvAMAGIC(arg) && (tmpsv = amagic_call(arg, &PL_sv_undef, method,
636ac8fc
FC		 2963 AMGf_noright | AMGf_unary
2964 | (flags & AMGf_numarg))))
2965 {
6f1401dc
DM		 2966 if (flags & AMGf_set) {
2967 SETs(tmpsv);
2968 }
2969 else {
2970 dTARGET;
2971 if (SvPADMY(TARG)) {
2972 sv_setsv(TARG, tmpsv);
2973 SETTARG;
2974 }
2975 else
2976 SETs(tmpsv);
2977 }
2978 PUTBACK;
2979 return TRUE;
2980 }
2981
2982 if ((flags & AMGf_numeric) && SvROK(arg))
2983 *sp = sv_2num(arg);
2984 return FALSE;
2985}
2986
2987
2988/* Implement tryAMAGICbin_MG macro.
2989 Do get magic, then see if the two stack args are overloaded and if so
2990 call it.
2991 Flags:
2992 AMGf_set return the arg using SETs rather than assigning to
2993 the targ
2994 AMGf_assign op may be called as mutator (eg +=)
2995 AMGf_numeric apply sv_2num to the stack arg.
2996*/
2997
2998bool
2999Perl_try_amagic_bin(pTHX_ int method, int flags) {
6f1401dc
DM		 3000 dSP;
3001 SV* const left = TOPm1s;
3002 SV* const right = TOPs;
3003
3004 SvGETMAGIC(left);
3005 if (left != right)
3006 SvGETMAGIC(right);
3007
3008 if (SvAMAGIC(left) || SvAMAGIC(right)) {
3009 SV * const tmpsv = amagic_call(left, right, method,
636ac8fc
FC		 3010 ((flags & AMGf_assign) && opASSIGN ? AMGf_assign: 0)
3011 | (flags & AMGf_numarg));
6f1401dc
DM		 3012 if (tmpsv) {
3013 if (flags & AMGf_set) {
3014 (void)POPs;
3015 SETs(tmpsv);
3016 }
3017 else {
3018 dATARGET;
3019 (void)POPs;
3020 if (opASSIGN || SvPADMY(TARG)) {
3021 sv_setsv(TARG, tmpsv);
3022 SETTARG;
3023 }
3024 else
3025 SETs(tmpsv);
3026 }
3027 PUTBACK;
3028 return TRUE;
3029 }
3030 }
75ea7a12
FC		 3031 if(left==right && SvGMAGICAL(left)) {
3032 SV * const left = sv_newmortal();
3033 *(sp-1) = left;
3034 /* Print the uninitialized warning now, so it includes the vari-
3035 able name. */
3036 if (!SvOK(right)) {
3037 if (ckWARN(WARN_UNINITIALIZED)) report_uninit(right);
3038 sv_setsv_flags(left, &PL_sv_no, 0);
3039 }
3040 else sv_setsv_flags(left, right, 0);
3041 SvGETMAGIC(right);
3042 }
6f1401dc 3043 if (flags & AMGf_numeric) {
75ea7a12
FC		 3044 if (SvROK(TOPm1s))
3045 *(sp-1) = sv_2num(TOPm1s);
6f1401dc
DM		 3046 if (SvROK(right))
3047 *sp = sv_2num(right);
3048 }
3049 return FALSE;
3050}
3051
25a9ffce
NC		 3052SV *
3053Perl_amagic_deref_call(pTHX_ SV *ref, int method) {
3054 SV *tmpsv = NULL;
3d147ac2 3055 HV *stash;
25a9ffce
NC		 3056
3057 PERL_ARGS_ASSERT_AMAGIC_DEREF_CALL;
3058
3d147ac2
DM		 3059 if (!SvAMAGIC(ref))
3060 return ref;
3061 /* return quickly if none of the deref ops are overloaded */
3062 stash = SvSTASH(SvRV(ref));
3063 assert(SvOOK(stash));
3064 if (HvAUX(stash)->xhv_aux_flags & HvAUXf_NO_DEREF)
3065 return ref;
3066
3067 while ((tmpsv = amagic_call(ref, &PL_sv_undef, method,
25a9ffce
NC		 3068 AMGf_noright | AMGf_unary))) {
3069 if (!SvROK(tmpsv))
3070 Perl_croak(aTHX_ "Overloaded dereference did not return a reference");
3071 if (tmpsv == ref || SvRV(tmpsv) == SvRV(ref)) {
3072 /* Bail out if it returns us the same reference. */
3073 return tmpsv;
3074 }
3075 ref = tmpsv;
3d147ac2
DM		 3076 if (!SvAMAGIC(ref))
3077 break;
25a9ffce
NC		 3078 }
3079 return tmpsv ? tmpsv : ref;
3080}
6f1401dc 3081
8d569291
FC		 3082bool
3083Perl_amagic_is_enabled(pTHX_ int method)
3084{
3085 SV *lex_mask = cop_hints_fetch_pvs(PL_curcop, "overloading", 0);
3086
3087 assert(PL_curcop->cop_hints & HINT_NO_AMAGIC);
3088
3089 if ( !lex_mask || !SvOK(lex_mask) )
3090 /* overloading lexically disabled */
3091 return FALSE;
3092 else if ( lex_mask && SvPOK(lex_mask) ) {
3093 /* we have an entry in the hints hash, check if method has been
3094 * masked by overloading.pm */
3095 STRLEN len;
3096 const int offset = method / 8;
3097 const int bit = method % 8;
3098 char *pv = SvPV(lex_mask, len);
3099
3100 /* Bit set, so this overloading operator is disabled */
3101 if ( (STRLEN)offset < len && pv[offset] & ( 1 << bit ) )
3102 return FALSE;
3103 }
3104 return TRUE;
3105}
3106
a0d0e21e 3107SV*
864dbfa3 3108Perl_amagic_call(pTHX_ SV *left, SV *right, int method, int flags)
a0d0e21e 3109{
27da23d5 3110 dVAR;
b267980d 3111 MAGIC *mg;
9c5ffd7c 3112 CV *cv=NULL;
a0d0e21e 3113 CV **cvp=NULL, **ocvp=NULL;
9c5ffd7c 3114 AMT *amtp=NULL, *oamtp=NULL;
b464bac0
AL		 3115 int off = 0, off1, lr = 0, notfound = 0;
3116 int postpr = 0, force_cpy = 0;
3117 int assign = AMGf_assign & flags;
3118 const int assignshift = assign ? 1 : 0;
bf5522a1 3119 int use_default_op = 0;
67288365 3120 int force_scalar = 0;
497b47a8
JH		 3121#ifdef DEBUGGING
3122 int fl=0;
497b47a8 3123#endif
25716404 3124 HV* stash=NULL;
7918f24d
NC		 3125
3126 PERL_ARGS_ASSERT_AMAGIC_CALL;
3127
e46c382e 3128 if ( PL_curcop->cop_hints & HINT_NO_AMAGIC ) {
8d569291 3129 if (!amagic_is_enabled(method)) return NULL;
e46c382e
YK		 3130 }
3131
a0d0e21e 3132 if (!(AMGf_noleft & flags) && SvAMAGIC(left)
0a2c84ab 3133 && (stash = SvSTASH(SvRV(left))) && Gv_AMG(stash)
ad64d0ec 3134 && (mg = mg_find((const SV *)stash, PERL_MAGIC_overload_table))
b267980d 3135 && (ocvp = cvp = (AMT_AMAGIC((AMT*)mg->mg_ptr)
a6006777 3136 ? (oamtp = amtp = (AMT*)mg->mg_ptr)->table
d4c19fe8 3137 : NULL))
b267980d 3138 && ((cv = cvp[off=method+assignshift])
748a9306
LW		 3139 || (assign && amtp->fallback > AMGfallNEVER && /* fallback to
3140 * usual method */
497b47a8
JH		 3141 (
3142#ifdef DEBUGGING
3143 fl = 1,
a0288114 3144#endif
497b47a8 3145 cv = cvp[off=method])))) {
a0d0e21e
LW		 3146 lr = -1; /* Call method for left argument */
3147 } else {
3148 if (cvp && amtp->fallback > AMGfallNEVER && flags & AMGf_unary) {
3149 int logic;
3150
3151 /* look for substituted methods */
ee239bfe 3152 /* In all the covered cases we should be called with assign==0. */
a0d0e21e
LW		 3153 switch (method) {
3154 case inc_amg:
ee239bfe
IZ		 3155 force_cpy = 1;
3156 if ((cv = cvp[off=add_ass_amg])
3157 || ((cv = cvp[off = add_amg]) && (force_cpy = 0, postpr = 1))) {
3280af22 3158 right = &PL_sv_yes; lr = -1; assign = 1;
a0d0e21e
LW		 3159 }
3160 break;
3161 case dec_amg:
ee239bfe
IZ		 3162 force_cpy = 1;
3163 if ((cv = cvp[off = subtr_ass_amg])
3164 || ((cv = cvp[off = subtr_amg]) && (force_cpy = 0, postpr=1))) {
3280af22 3165 right = &PL_sv_yes; lr = -1; assign = 1;
a0d0e21e
LW		 3166 }
3167 break;
3168 case bool__amg:
3169 (void)((cv = cvp[off=numer_amg]) || (cv = cvp[off=string_amg]));
3170 break;
3171 case numer_amg:
3172 (void)((cv = cvp[off=string_amg]) || (cv = cvp[off=bool__amg]));
3173 break;
3174 case string_amg:
3175 (void)((cv = cvp[off=numer_amg]) || (cv = cvp[off=bool__amg]));
3176 break;
b7787f18
AL		 3177 case not_amg:
3178 (void)((cv = cvp[off=bool__amg])
3179 || (cv = cvp[off=numer_amg])
3180 || (cv = cvp[off=string_amg]));
2ab54efd
MB		 3181 if (cv)
3182 postpr = 1;
b7787f18 3183 break;
748a9306
LW		 3184 case copy_amg:
3185 {
76e3520e
GS		 3186 /*
3187 * SV* ref causes confusion with the interpreter variable of
3188 * the same name
3189 */
890ce7af 3190 SV* const tmpRef=SvRV(left);
76e3520e 3191 if (!SvROK(tmpRef) && SvTYPE(tmpRef) <= SVt_PVMG) {
fc36a67e 3192 /*
3193 * Just to be extra cautious. Maybe in some
3194 * additional cases sv_setsv is safe, too.
3195 */
890ce7af 3196 SV* const newref = newSVsv(tmpRef);
748a9306 3197 SvOBJECT_on(newref);
a1cd65be
FC		 3198 /* No need to do SvAMAGIC_on here, as SvAMAGIC macros
3199 delegate to the stash. */
85fbaab2 3200 SvSTASH_set(newref, MUTABLE_HV(SvREFCNT_inc(SvSTASH(tmpRef))));
748a9306
LW		 3201 return newref;
3202 }
3203 }
3204 break;
a0d0e21e 3205 case abs_amg:
b267980d 3206 if ((cvp[off1=lt_amg] || cvp[off1=ncmp_amg])
a0d0e21e 3207 && ((cv = cvp[off=neg_amg]) || (cv = cvp[off=subtr_amg]))) {
725c44f9 3208 SV* const nullsv=&PL_sv_zero;
a0d0e21e 3209 if (off1==lt_amg) {
890ce7af 3210 SV* const lessp = amagic_call(left,nullsv,
a0d0e21e 3211 lt_amg,AMGf_noright);
f4c975aa 3212 logic = SvTRUE_NN(lessp);
a0d0e21e 3213 } else {
890ce7af 3214 SV* const lessp = amagic_call(left,nullsv,
a0d0e21e
LW		 3215 ncmp_amg,AMGf_noright);
3216 logic = (SvNV(lessp) < 0);
3217 }
3218 if (logic) {
3219 if (off==subtr_amg) {
3220 right = left;
748a9306 3221 left = nullsv;
a0d0e21e
LW		 3222 lr = 1;
3223 }
3224 } else {
3225 return left;
3226 }
3227 }
3228 break;
3229 case neg_amg:
155aba94 3230 if ((cv = cvp[off=subtr_amg])) {
a0d0e21e 3231 right = left;
725c44f9 3232 left = &PL_sv_zero;
a0d0e21e
LW		 3233 lr = 1;
3234 }
3235 break;
f216259d 3236 case int_amg:
f5284f61 3237 case iter_amg: /* XXXX Eventually should do to_gv. */
c4c7412c 3238 case ftest_amg: /* XXXX Eventually should do to_gv. */
d4b87e75 3239 case regexp_amg:
b267980d
NIS		 3240 /* FAIL safe */
3241 return NULL; /* Delegate operation to standard mechanisms. */
81d52ecd 3242
f5284f61
IZ		 3243 case to_sv_amg:
3244 case to_av_amg:
3245 case to_hv_amg:
3246 case to_gv_amg:
3247 case to_cv_amg:
3248 /* FAIL safe */
b267980d 3249 return left; /* Delegate operation to standard mechanisms. */
81d52ecd 3250
a0d0e21e
LW		 3251 default:
3252 goto not_found;
3253 }
3254 if (!cv) goto not_found;
3255 } else if (!(AMGf_noright & flags) && SvAMAGIC(right)
0a2c84ab 3256 && (stash = SvSTASH(SvRV(right))) && Gv_AMG(stash)
ad64d0ec 3257 && (mg = mg_find((const SV *)stash, PERL_MAGIC_overload_table))
b267980d 3258 && (cvp = (AMT_AMAGIC((AMT*)mg->mg_ptr)
a6006777 3259 ? (amtp = (AMT*)mg->mg_ptr)->table
d4c19fe8 3260 : NULL))
69815d08
RS		 3261 && (cv = cvp[off=method])) { /* Method for right
3262 * argument found */
3263 lr=1;
bf5522a1
MB		 3264 } else if (((cvp && amtp->fallback > AMGfallNEVER)
3265 || (ocvp && oamtp->fallback > AMGfallNEVER))
a0d0e21e
LW		 3266 && !(flags & AMGf_unary)) {
3267 /* We look for substitution for
3268 * comparison operations and
fc36a67e 3269 * concatenation */
a0d0e21e
LW		 3270 if (method==concat_amg || method==concat_ass_amg
3271 || method==repeat_amg || method==repeat_ass_amg) {
3272 return NULL; /* Delegate operation to string conversion */
3273 }
3274 off = -1;
3275 switch (method) {
3276 case lt_amg:
3277 case le_amg:
3278 case gt_amg:
3279 case ge_amg:
3280 case eq_amg:
3281 case ne_amg:
2ab54efd
MB		 3282 off = ncmp_amg;
3283 break;
a0d0e21e
LW		 3284 case slt_amg:
3285 case sle_amg:
3286 case sgt_amg:
3287 case sge_amg:
3288 case seq_amg:
3289 case sne_amg:
2ab54efd
MB		 3290 off = scmp_amg;
3291 break;
a0d0e21e 3292 }
bf5522a1
MB		 3293 if (off != -1) {
3294 if (ocvp && (oamtp->fallback > AMGfallNEVER)) {
3295 cv = ocvp[off];
3296 lr = -1;
3297 }
3298 if (!cv && (cvp && amtp->fallback > AMGfallNEVER)) {
3299 cv = cvp[off];
3300 lr = 1;
3301 }
3302 }
3303 if (cv)
2ab54efd
MB		 3304 postpr = 1;
3305 else
3306 goto not_found;
a0d0e21e 3307 } else {
a6006777 3308 not_found: /* No method found, either report or croak */
b267980d
NIS		 3309 switch (method) {
3310 case to_sv_amg:
3311 case to_av_amg:
3312 case to_hv_amg:
3313 case to_gv_amg:
3314 case to_cv_amg:
3315 /* FAIL safe */
3316 return left; /* Delegate operation to standard mechanisms. */
b267980d 3317 }
a0d0e21e
LW		 3318 if (ocvp && (cv=ocvp[nomethod_amg])) { /* Call report method */
3319 notfound = 1; lr = -1;
3320 } else if (cvp && (cv=cvp[nomethod_amg])) {
3321 notfound = 1; lr = 1;
bf5522a1
MB		 3322 } else if ((use_default_op =
3323 (!ocvp || oamtp->fallback >= AMGfallYES)
3324 && (!cvp || amtp->fallback >= AMGfallYES))
3325 && !DEBUG_o_TEST) {
4cc0ca18
NC		 3326 /* Skip generating the "no method found" message. */
3327 return NULL;
a0d0e21e 3328 } else {
46fc3d4c 3329 SV *msg;
774d564b 3330 if (off==-1) off=method;
b267980d 3331 msg = sv_2mortal(Perl_newSVpvf(aTHX_
147e3846 3332 "Operation \"%s\": no method found,%sargument %s%" SVf "%s%" SVf,
d66cca07
BF		 3333 AMG_id2name(method + assignshift),
3334 (flags & AMGf_unary ? " " : "\n\tleft "),
3335 SvAMAGIC(left)?
3336 "in overloaded package ":
3337 "has no overloaded magic",
3338 SvAMAGIC(left)?
3339 SVfARG(sv_2mortal(newSVhek(HvNAME_HEK(SvSTASH(SvRV(left)))))):
3340 SVfARG(&PL_sv_no),
3341 SvAMAGIC(right)?
3342 ",\n\tright argument in overloaded package ":
3343 (flags & AMGf_unary
3344 ? ""
3345 : ",\n\tright argument has no overloaded magic"),
3346 SvAMAGIC(right)?
3347 SVfARG(sv_2mortal(newSVhek(HvNAME_HEK(SvSTASH(SvRV(right)))))):
3348 SVfARG(&PL_sv_no)));
bf5522a1 3349 if (use_default_op) {
147e3846 3350 DEBUG_o( Perl_deb(aTHX_ "%" SVf, SVfARG(msg)) );
a0d0e21e 3351 } else {
147e3846 3352 Perl_croak(aTHX_ "%" SVf, SVfARG(msg));
a0d0e21e
LW		 3353 }
3354 return NULL;
3355 }
ee239bfe 3356 force_cpy = force_cpy || assign;
a0d0e21e
LW		 3357 }
3358 }
67288365
JL		 3359
3360 switch (method) {
3361 /* in these cases, we're calling '+' or '-' as a fallback for a ++ or --
3362 * operation. we need this to return a value, so that it can be assigned
3363 * later on, in the postpr block (case inc_amg/dec_amg), even if the
3364 * increment or decrement was itself called in void context */
3365 case inc_amg:
3366 if (off == add_amg)
3367 force_scalar = 1;
3368 break;
3369 case dec_amg:
3370 if (off == subtr_amg)
3371 force_scalar = 1;
3372 break;
3373 /* in these cases, we're calling an assignment variant of an operator
3374 * (+= rather than +, for instance). regardless of whether it's a
3375 * fallback or not, it always has to return a value, which will be
3376 * assigned to the proper variable later */
3377 case add_amg:
3378 case subtr_amg:
3379 case mult_amg:
3380 case div_amg:
3381 case modulo_amg:
3382 case pow_amg:
3383 case lshift_amg:
3384 case rshift_amg:
3385 case repeat_amg:
3386 case concat_amg:
3387 case band_amg:
3388 case bor_amg:
3389 case bxor_amg:
6d06ecce
FC		 3390 case sband_amg:
3391 case sbor_amg:
3392 case sbxor_amg:
67288365
JL		 3393 if (assign)
3394 force_scalar = 1;
3395 break;
3396 /* the copy constructor always needs to return a value */
3397 case copy_amg:
3398 force_scalar = 1;
3399 break;
3400 /* because of the way these are implemented (they don't perform the
3401 * dereferencing themselves, they return a reference that perl then
3402 * dereferences later), they always have to be in scalar context */
3403 case to_sv_amg:
3404 case to_av_amg:
3405 case to_hv_amg:
3406 case to_gv_amg:
3407 case to_cv_amg:
3408 force_scalar = 1;
3409 break;
3410 /* these don't have an op of their own; they're triggered by their parent
3411 * op, so the context there isn't meaningful ('$a and foo()' in void
3412 * context still needs to pass scalar context on to $a's bool overload) */
3413 case bool__amg:
3414 case numer_amg:
3415 case string_amg:
3416 force_scalar = 1;
3417 break;
3418 }
3419
497b47a8 3420#ifdef DEBUGGING
a0d0e21e 3421 if (!notfound) {
497b47a8 3422 DEBUG_o(Perl_deb(aTHX_
147e3846 3423 "Overloaded operator \"%s\"%s%s%s:\n\tmethod%s found%s in package %" SVf "%s\n",
497b47a8
JH		 3424 AMG_id2name(off),
3425 method+assignshift==off? "" :
a0288114 3426 " (initially \"",
497b47a8
JH		 3427 method+assignshift==off? "" :
3428 AMG_id2name(method+assignshift),
a0288114 3429 method+assignshift==off? "" : "\")",
497b47a8
JH		 3430 flags & AMGf_unary? "" :
3431 lr==1 ? " for right argument": " for left argument",
3432 flags & AMGf_unary? " for argument" : "",
d66cca07 3433 stash ? SVfARG(sv_2mortal(newSVhek(HvNAME_HEK(stash)))) : SVfARG(newSVpvs_flags("null", SVs_TEMP)),
497b47a8 3434 fl? ",\n\tassignment variant used": "") );
ee239bfe 3435 }
497b47a8 3436#endif
748a9306
LW		 3437 /* Since we use shallow copy during assignment, we need
3438 * to dublicate the contents, probably calling user-supplied
3439 * version of copy operator
3440 */
ee239bfe
IZ		 3441 /* We need to copy in following cases:
3442 * a) Assignment form was called.
3443 * assignshift==1, assign==T, method + 1 == off
3444 * b) Increment or decrement, called directly.
3445 * assignshift==0, assign==0, method + 0 == off
3446 * c) Increment or decrement, translated to assignment add/subtr.
b267980d 3447 * assignshift==0, assign==T,
ee239bfe
IZ		 3448 * force_cpy == T
3449 * d) Increment or decrement, translated to nomethod.
b267980d 3450 * assignshift==0, assign==0,
ee239bfe
IZ		 3451 * force_cpy == T
3452 * e) Assignment form translated to nomethod.
3453 * assignshift==1, assign==T, method + 1 != off
3454 * force_cpy == T
3455 */
3456 /* off is method, method+assignshift, or a result of opcode substitution.
3457 * In the latter case assignshift==0, so only notfound case is important.
3458 */
73512201 3459 if ( (lr == -1) && ( ( (method + assignshift == off)
ee239bfe 3460 && (assign || (method == inc_amg) || (method == dec_amg)))
73512201 3461 || force_cpy) )
6f1401dc 3462 {
1b38c28e
NC		 3463 /* newSVsv does not behave as advertised, so we copy missing
3464 * information by hand */
3465 SV *tmpRef = SvRV(left);
3466 SV *rv_copy;
31d632c3 3467 if (SvREFCNT(tmpRef) > 1 && (rv_copy = AMG_CALLunary(left,copy_amg))) {
1b38c28e
NC		 3468 SvRV_set(left, rv_copy);
3469 SvSETMAGIC(left);
e7881358 3470 SvREFCNT_dec_NN(tmpRef);
1b38c28e 3471 }
6f1401dc
DM		 3472 }
3473
a0d0e21e
LW		 3474 {
3475 dSP;
3476 BINOP myop;
3477 SV* res;
b7787f18 3478 const bool oldcatch = CATCH_GET;
67288365 3479 I32 oldmark, nret;
e839e6ed
DM		 3480 /* for multiconcat, we may call overload several times,
3481 * with the context of individual concats being scalar,
3482 * regardless of the overall context of the multiconcat op
3483 */
3484 U8 gimme = (force_scalar || PL_op->op_type == OP_MULTICONCAT)
3485 ? G_SCALAR : GIMME_V;
a0d0e21e 3486
54310121 3487 CATCH_SET(TRUE);
a0d0e21e
LW		 3488 Zero(&myop, 1, BINOP);
3489 myop.op_last = (OP *) &myop;
b37c2d43 3490 myop.op_next = NULL;
67288365
JL		 3491 myop.op_flags = OPf_STACKED;
3492
3493 switch (gimme) {
3494 case G_VOID:
3495 myop.op_flags |= OPf_WANT_VOID;
3496 break;
3497 case G_ARRAY:
3498 if (flags & AMGf_want_list) {
3499 myop.op_flags |= OPf_WANT_LIST;
3500 break;
3501 }
3502 /* FALLTHROUGH */
3503 default:
3504 myop.op_flags |= OPf_WANT_SCALAR;
3505 break;
3506 }
a0d0e21e 3507
e788e7d3 3508 PUSHSTACKi(PERLSI_OVERLOAD);
a0d0e21e 3509 ENTER;
462e5cf6 3510 SAVEOP();
533c011a 3511 PL_op = (OP *) &myop;
3280af22 3512 if (PERLDB_SUB && PL_curstash != PL_debstash)
533c011a 3513 PL_op->op_private |= OPpENTERSUB_DB;
897d3989 3514 Perl_pp_pushmark(aTHX);
a0d0e21e 3515
924508f0 3516 EXTEND(SP, notfound + 5);
a0d0e21e
LW		 3517 PUSHs(lr>0? right: left);
3518 PUSHs(lr>0? left: right);
3280af22 3519 PUSHs( lr > 0 ? &PL_sv_yes : ( assign ? &PL_sv_undef : &PL_sv_no ));
a0d0e21e 3520 if (notfound) {
59cd0e26
NC		 3521 PUSHs(newSVpvn_flags(AMG_id2name(method + assignshift),
3522 AMG_id2namelen(method + assignshift), SVs_TEMP));
a0d0e21e 3523 }
636ac8fc
FC		 3524 else if (flags & AMGf_numarg)
3525 PUSHs(&PL_sv_undef);
3526 if (flags & AMGf_numarg)
3527 PUSHs(&PL_sv_yes);
ad64d0ec 3528 PUSHs(MUTABLE_SV(cv));
a0d0e21e 3529 PUTBACK;
67288365 3530 oldmark = TOPMARK;
a0d0e21e 3531
139d0ce6 3532 if ((PL_op = PL_ppaddr[OP_ENTERSUB](aTHX)))
cea2e8a9 3533 CALLRUNOPS(aTHX);
a0d0e21e
LW		 3534 LEAVE;
3535 SPAGAIN;
67288365
JL		 3536 nret = SP - (PL_stack_base + oldmark);
3537
3538 switch (gimme) {
3539 case G_VOID:
3540 /* returning NULL has another meaning, and we check the context
3541 * at the call site too, so this can be differentiated from the
3542 * scalar case */
3543 res = &PL_sv_undef;
3544 SP = PL_stack_base + oldmark;
3545 break;
2165bd23 3546 case G_ARRAY:
67288365
JL		 3547 if (flags & AMGf_want_list) {
3548 res = sv_2mortal((SV *)newAV());
3549 av_extend((AV *)res, nret);
3550 while (nret--)
3551 av_store((AV *)res, nret, POPs);
3552 break;
3553 }
3554 /* FALLTHROUGH */
67288365
JL		 3555 default:
3556 res = POPs;
3557 break;
3558 }
a0d0e21e 3559
ebafeae7 3560 PUTBACK;
d3acc0f7 3561 POPSTACK;
54310121 3562 CATCH_SET(oldcatch);
a0d0e21e 3563
a0d0e21e 3564 if (postpr) {
b7787f18 3565 int ans;
a0d0e21e
LW		 3566 switch (method) {
3567 case le_amg:
3568 case sle_amg:
3569 ans=SvIV(res)<=0; break;
3570 case lt_amg:
3571 case slt_amg:
3572 ans=SvIV(res)<0; break;
3573 case ge_amg:
3574 case sge_amg:
3575 ans=SvIV(res)>=0; break;
3576 case gt_amg:
3577 case sgt_amg:
3578 ans=SvIV(res)>0; break;
3579 case eq_amg:
3580 case seq_amg:
3581 ans=SvIV(res)==0; break;
3582 case ne_amg:
3583 case sne_amg:
3584 ans=SvIV(res)!=0; break;
3585 case inc_amg:
3586 case dec_amg:
bbce6d69 3587 SvSetSV(left,res); return left;
dc437b57 3588 case not_amg:
f4c975aa 3589 ans=!SvTRUE_NN(res); break;
b7787f18
AL		 3590 default:
3591 ans=0; break;
a0d0e21e 3592 }
54310121 3593 return boolSV(ans);
748a9306
LW		 3594 } else if (method==copy_amg) {
3595 if (!SvROK(res)) {
cea2e8a9 3596 Perl_croak(aTHX_ "Copy method did not return a reference");
748a9306
LW		 3597 }
3598 return SvREFCNT_inc(SvRV(res));
a0d0e21e
LW		 3599 } else {
3600 return res;
3601 }
3602 }
3603}
c9d5ac95 3604
f5c1e807
NC		 3605void
3606Perl_gv_name_set(pTHX_ GV *gv, const char *name, U32 len, U32 flags)
3607{
3608 dVAR;
acda4c6a 3609 U32 hash;
f5c1e807 3610
7918f24d 3611 PERL_ARGS_ASSERT_GV_NAME_SET;
f5c1e807 3612
acda4c6a 3613 if (len > I32_MAX)
147e3846 3614 Perl_croak(aTHX_ "panic: gv name too long (%" UVuf ")", (UV) len);
acda4c6a 3615
ae8cc45f
NC		 3616 if (!(flags & GV_ADD) && GvNAME_HEK(gv)) {
3617 unshare_hek(GvNAME_HEK(gv));
3618 }
3619
acda4c6a 3620 PERL_HASH(hash, name, len);
c60dbbc3 3621 GvNAME_HEK(gv) = share_hek(name, (flags & SVf_UTF8 ? -(I32)len : (I32)len), hash);
f5c1e807
NC		 3622}
3623
66610fdd 3624/*
f7461760
Z		 3625=for apidoc gv_try_downgrade
3626
2867cdbc
Z		 3627If the typeglob C<gv> can be expressed more succinctly, by having
3628something other than a real GV in its place in the stash, replace it
3629with the optimised form. Basic requirements for this are that C<gv>
3630is a real typeglob, is sufficiently ordinary, and is only referenced
3631from its package. This function is meant to be used when a GV has been
3632looked up in part to see what was there, causing upgrading, but based
3633on what was found it turns out that the real GV isn't required after all.
3634
3635If C<gv> is a completely empty typeglob, it is deleted from the stash.
3636
3637If C<gv> is a typeglob containing only a sufficiently-ordinary constant
3638sub, the typeglob is replaced with a scalar-reference placeholder that
3639more compactly represents the same thing.
f7461760
Z		 3640
3641=cut
3642*/
3643
3644void
3645Perl_gv_try_downgrade(pTHX_ GV *gv)
3646{
3647 HV *stash;
3648 CV *cv;
3649 HEK *namehek;
3650 SV **gvp;
3651 PERL_ARGS_ASSERT_GV_TRY_DOWNGRADE;
95f56751
FC		 3652
3653 /* XXX Why and where does this leave dangling pointers during global
3654 destruction? */
627364f1 3655 if (PL_phase == PERL_PHASE_DESTRUCT) return;
95f56751 3656
2867cdbc 3657 if (!(SvREFCNT(gv) == 1 && SvTYPE(gv) == SVt_PVGV && !SvFAKE(gv) &&
803f2748 3658 !SvOBJECT(gv) && !SvREADONLY(gv) &&
f7461760 3659 isGV_with_GP(gv) && GvGP(gv) &&
2867cdbc 3660 !GvINTRO(gv) && GvREFCNT(gv) == 1 &&
f7461760 3661 !GvSV(gv) && !GvAV(gv) && !GvHV(gv) && !GvIOp(gv) && !GvFORM(gv) &&
099be4f1 3662 GvEGVx(gv) == gv && (stash = GvSTASH(gv))))
2867cdbc 3663 return;
2be08ad1
FC		 3664 if (gv == PL_statgv || gv == PL_last_in_gv || gv == PL_stderrgv)
3665 return;
803f2748
DM		 3666 if (SvMAGICAL(gv)) {
3667 MAGIC *mg;
3668 /* only backref magic is allowed */
3669 if (SvGMAGICAL(gv) || SvSMAGICAL(gv))
3670 return;
3671 for (mg = SvMAGIC(gv); mg; mg = mg->mg_moremagic) {
3672 if (mg->mg_type != PERL_MAGIC_backref)
3673 return;
3674 }
3675 }
2867cdbc
Z		 3676 cv = GvCV(gv);
3677 if (!cv) {
3678 HEK *gvnhek = GvNAME_HEK(gv);
0ca9877d 3679 (void)hv_deletehek(stash, gvnhek, G_DISCARD);
8941bf97 3680 } else if (GvMULTI(gv) && cv && SvREFCNT(cv) == 1 &&
f7461760 3681 !SvOBJECT(cv) && !SvMAGICAL(cv) && !SvREADONLY(cv) &&
34d81fc4 3682 CvSTASH(cv) == stash && !CvNAMED(cv) && CvGV(cv) == gv &&
f7461760
Z		 3683 CvCONST(cv) && !CvMETHOD(cv) && !CvLVALUE(cv) && !CvUNIQUE(cv) &&
3684 !CvNODEBUG(cv) && !CvCLONE(cv) && !CvCLONED(cv) && !CvANON(cv) &&
3685 (namehek = GvNAME_HEK(gv)) &&
48c2c411 3686 (gvp = hv_fetchhek(stash, namehek, 0)) &&
f7461760
Z		 3687 *gvp == (SV*)gv) {
3688 SV *value = SvREFCNT_inc(CvXSUBANY(cv).any_ptr);
70e5f2b5 3689 const bool imported = !!GvIMPORTED_CV(gv);
f7461760
Z		 3690 SvREFCNT(gv) = 0;
3691 sv_clear((SV*)gv);
3692 SvREFCNT(gv) = 1;
70e5f2b5 3693 SvFLAGS(gv) = SVt_IV|SVf_ROK|SVprv_PCS_IMPORTED * imported;
dc6369ef
EH		 3694
3695 /* See also: 'SET_SVANY_FOR_BODYLESS_IV' in sv.c */
f7461760
Z		 3696 SvANY(gv) = (XPVGV*)((char*)&(gv->sv_u.svu_iv) -
3697 STRUCT_OFFSET(XPVIV, xiv_iv));
3698 SvRV_set(gv, value);
3699 }
3700}
3701
9e3fb20c
FC		 3702GV *
3703Perl_gv_override(pTHX_ const char * const name, const STRLEN len)
3704{
3705 GV *gv = gv_fetchpvn(name, len, GV_NOTQUAL, SVt_PVCV);
3706 GV * const *gvp;
3707 PERL_ARGS_ASSERT_GV_OVERRIDE;
3708 if (gv && GvCVu(gv) && GvIMPORTED_CV(gv)) return gv;
3709 gvp = (GV**)hv_fetch(PL_globalstash, name, len, FALSE);
3710 gv = gvp ? *gvp : NULL;
3711 if (gv && !isGV(gv)) {
3712 if (!SvPCS_IMPORTED(gv)) return NULL;
3713 gv_init(gv, PL_globalstash, name, len, 0);
3714 return gv;
3715 }
3716 return gv && GvCVu(gv) && GvIMPORTED_CV(gv) ? gv : NULL;
3717}
3718
4aaa4757
FC		 3719#include "XSUB.h"
3720
3721static void
3722core_xsub(pTHX_ CV* cv)
3723{
3724 Perl_croak(aTHX_
3725 "&CORE::%s cannot be called directly", GvNAME(CvGV(cv))
3726 );
3727}
3728
f7461760 3729/*
14d04a33 3730 * ex: set ts=8 sts=4 sw=4 et:
37442d52 3731 */
Unnamed repository; edit this file 'description' to name the repository.