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