3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 * 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, by Larry Wall and others
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.
12 * 'Mercy!' cried Gandalf. 'If the giving of information is to be the cure
13 * of your inquisitiveness, I shall spend all the rest of my days answering
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,'
23 A GV is a structure which corresponds to to a Perl typeglob, ie *foo.
24 It is a structure that holds a pointer to a scalar, an array, a hash etc,
25 corresponding to $foo, @foo, %foo.
27 GVs are usually found as values in stashes (symbol table hashes) where
28 Perl stores its global variables.
38 static const char S_autoload[] = "AUTOLOAD";
39 static const STRLEN S_autolen = sizeof(S_autoload)-1;
42 #ifdef PERL_DONT_CREATE_GVSV
44 Perl_gv_SVadd(pTHX_ GV *gv)
46 if (!gv || SvTYPE((SV*)gv) != SVt_PVGV)
47 Perl_croak(aTHX_ "Bad symbol for scalar");
55 Perl_gv_AVadd(pTHX_ register GV *gv)
57 if (!gv || SvTYPE((SV*)gv) != SVt_PVGV)
58 Perl_croak(aTHX_ "Bad symbol for array");
65 Perl_gv_HVadd(pTHX_ register GV *gv)
67 if (!gv || SvTYPE((SV*)gv) != SVt_PVGV)
68 Perl_croak(aTHX_ "Bad symbol for hash");
75 Perl_gv_IOadd(pTHX_ register GV *gv)
78 if (!gv || SvTYPE((SV*)gv) != SVt_PVGV) {
81 * if it walks like a dirhandle, then let's assume that
82 * this is a dirhandle.
84 const char * const fh =
85 PL_op->op_type == OP_READDIR ||
86 PL_op->op_type == OP_TELLDIR ||
87 PL_op->op_type == OP_SEEKDIR ||
88 PL_op->op_type == OP_REWINDDIR ||
89 PL_op->op_type == OP_CLOSEDIR ?
90 "dirhandle" : "filehandle";
91 Perl_croak(aTHX_ "Bad symbol for %s", fh);
95 #ifdef GV_UNIQUE_CHECK
97 Perl_croak(aTHX_ "Bad symbol for filehandle (GV is unique)");
106 Perl_gv_fetchfile(pTHX_ const char *name)
108 return gv_fetchfile_flags(name, strlen(name), 0);
112 Perl_gv_fetchfile_flags(pTHX_ const char *const name, const STRLEN namelen,
118 const STRLEN tmplen = namelen + 2;
121 PERL_UNUSED_ARG(flags);
126 if (tmplen <= sizeof smallbuf)
129 Newx(tmpbuf, tmplen, char);
130 /* This is where the debugger's %{"::_<$filename"} hash is created */
133 memcpy(tmpbuf + 2, name, namelen);
134 gv = *(GV**)hv_fetch(PL_defstash, tmpbuf, tmplen, TRUE);
136 gv_init(gv, PL_defstash, tmpbuf, tmplen, FALSE);
137 #ifdef PERL_DONT_CREATE_GVSV
138 GvSV(gv) = newSVpvn(name, namelen);
140 sv_setpvn(GvSV(gv), name, namelen);
143 hv_magic(GvHVn(gv_AVadd(gv)), NULL, PERL_MAGIC_dbfile);
145 if (tmpbuf != smallbuf)
151 =for apidoc gv_const_sv
153 If C<gv> is a typeglob whose subroutine entry is a constant sub eligible for
154 inlining, or C<gv> is a placeholder reference that would be promoted to such
155 a typeglob, then returns the value returned by the sub. Otherwise, returns
162 Perl_gv_const_sv(pTHX_ GV *gv)
164 if (SvTYPE(gv) == SVt_PVGV)
165 return cv_const_sv(GvCVu(gv));
166 return SvROK(gv) ? SvRV(gv) : NULL;
170 Perl_newGP(pTHX_ GV *const gv)
175 const char *const file
176 = (PL_curcop && CopFILE(PL_curcop)) ? CopFILE(PL_curcop) : "";
177 const STRLEN len = strlen(file);
179 SV *const temp_sv = CopFILESV(PL_curcop);
184 file = SvPVX(temp_sv);
185 len = SvCUR(temp_sv);
192 PERL_HASH(hash, file, len);
196 #ifndef PERL_DONT_CREATE_GVSV
197 gp->gp_sv = newSV(0);
200 gp->gp_line = PL_curcop ? CopLINE(PL_curcop) : 0;
201 /* XXX Ideally this cast would be replaced with a change to const char*
203 gp->gp_file_hek = share_hek(file, len, hash);
211 Perl_gv_init(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, int multi)
214 const U32 old_type = SvTYPE(gv);
215 const bool doproto = old_type > SVt_NULL;
216 const char * const proto = (doproto && SvPOK(gv)) ? SvPVX_const(gv) : NULL;
217 SV *const has_constant = doproto && SvROK(gv) ? SvRV(gv) : NULL;
218 const U32 exported_constant = has_constant ? SvPCS_IMPORTED(gv) : 0;
220 assert (!(proto && has_constant));
223 /* The constant has to be a simple scalar type. */
224 switch (SvTYPE(has_constant)) {
230 Perl_croak(aTHX_ "Cannot convert a reference to %s to typeglob",
231 sv_reftype(has_constant, 0));
239 if (old_type < SVt_PVGV) {
240 if (old_type >= SVt_PV)
242 sv_upgrade((SV*)gv, SVt_PVGV);
250 Safefree(SvPVX_mutable(gv));
255 GvGP(gv) = Perl_newGP(aTHX_ gv);
258 Perl_sv_add_backref(aTHX_ (SV*)stash, (SV*)gv);
259 gv_name_set(gv, name, len, GV_ADD);
260 if (multi || doproto) /* doproto means it _was_ mentioned */
262 if (doproto) { /* Replicate part of newSUB here. */
265 /* newCONSTSUB takes ownership of the reference from us. */
266 GvCV(gv) = newCONSTSUB(stash, name, has_constant);
267 /* If this reference was a copy of another, then the subroutine
268 must have been "imported", by a Perl space assignment to a GV
269 from a reference to CV. */
270 if (exported_constant)
271 GvIMPORTED_CV_on(gv);
273 (void) start_subparse(0,0); /* Create empty CV in compcv. */
274 GvCV(gv) = PL_compcv;
278 mro_method_changed_in(GvSTASH(gv)); /* sub Foo::bar($) { (shift) } sub ASDF::baz($); *ASDF::baz = \&Foo::bar */
280 CvFILE_set_from_cop(GvCV(gv), PL_curcop);
281 CvSTASH(GvCV(gv)) = PL_curstash;
283 sv_setpv((SV*)GvCV(gv), proto);
290 S_gv_init_sv(pTHX_ GV *gv, I32 sv_type)
302 #ifdef PERL_DONT_CREATE_GVSV
310 /* Work round what appears to be a bug in Sun C++ 5.8 2005/10/13
311 If we just cast GvSVn(gv) to void, it ignores evaluating it for
319 =for apidoc gv_fetchmeth
321 Returns the glob with the given C<name> and a defined subroutine or
322 C<NULL>. The glob lives in the given C<stash>, or in the stashes
323 accessible via @ISA and UNIVERSAL::.
325 The argument C<level> should be either 0 or -1. If C<level==0>, as a
326 side-effect creates a glob with the given C<name> in the given C<stash>
327 which in the case of success contains an alias for the subroutine, and sets
328 up caching info for this glob.
330 This function grants C<"SUPER"> token as a postfix of the stash name. The
331 GV returned from C<gv_fetchmeth> may be a method cache entry, which is not
332 visible to Perl code. So when calling C<call_sv>, you should not use
333 the GV directly; instead, you should use the method's CV, which can be
334 obtained from the GV with the C<GvCV> macro.
339 /* NOTE: No support for tied ISA */
342 Perl_gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level)
350 GV* candidate = NULL;
355 I32 create = (level >= 0) ? 1 : 0;
360 /* UNIVERSAL methods should be callable without a stash */
362 create = 0; /* probably appropriate */
363 if(!(stash = gv_stashpvs("UNIVERSAL", 0)))
369 hvname = HvNAME_get(stash);
371 Perl_croak(aTHX_ "Can't use anonymous symbol table for method lookup");
376 DEBUG_o( Perl_deb(aTHX_ "Looking for method %s in package %s\n",name,hvname) );
378 topgen_cmp = HvMROMETA(stash)->cache_gen + PL_sub_generation;
380 /* check locally for a real method or a cache entry */
381 gvp = (GV**)hv_fetch(stash, name, len, create);
385 if (SvTYPE(topgv) != SVt_PVGV)
386 gv_init(topgv, stash, name, len, TRUE);
387 if ((cand_cv = GvCV(topgv))) {
388 /* If genuine method or valid cache entry, use it */
389 if (!GvCVGEN(topgv) || GvCVGEN(topgv) == topgen_cmp) {
393 /* stale cache entry, junk it and move on */
394 SvREFCNT_dec(cand_cv);
395 GvCV(topgv) = cand_cv = NULL;
399 else if (GvCVGEN(topgv) == topgen_cmp) {
400 /* cache indicates no such method definitively */
405 packlen = HvNAMELEN_get(stash);
406 if (packlen >= 7 && strEQ(hvname + packlen - 7, "::SUPER")) {
409 basestash = gv_stashpvn(hvname, packlen, GV_ADD);
410 linear_av = mro_get_linear_isa(basestash);
413 linear_av = mro_get_linear_isa(stash); /* has ourselves at the top of the list */
416 linear_svp = AvARRAY(linear_av) + 1; /* skip over self */
417 items = AvFILLp(linear_av); /* no +1, to skip over self */
419 linear_sv = *linear_svp++;
421 cstash = gv_stashsv(linear_sv, 0);
424 if (ckWARN(WARN_SYNTAX))
425 Perl_warner(aTHX_ packWARN(WARN_SYNTAX), "Can't locate package %"SVf" for @%s::ISA",
426 SVfARG(linear_sv), hvname);
432 gvp = (GV**)hv_fetch(cstash, name, len, 0);
436 if (SvTYPE(candidate) != SVt_PVGV) gv_init(candidate, cstash, name, len, TRUE);
437 if (SvTYPE(candidate) == SVt_PVGV && (cand_cv = GvCV(candidate)) && !GvCVGEN(candidate)) {
439 * Found real method, cache method in topgv if:
440 * 1. topgv has no synonyms (else inheritance crosses wires)
441 * 2. method isn't a stub (else AUTOLOAD fails spectacularly)
443 if (topgv && (GvREFCNT(topgv) == 1) && (CvROOT(cand_cv) || CvXSUB(cand_cv))) {
444 if ((old_cv = GvCV(topgv))) SvREFCNT_dec(old_cv);
445 SvREFCNT_inc_simple_void_NN(cand_cv);
446 GvCV(topgv) = cand_cv;
447 GvCVGEN(topgv) = topgen_cmp;
453 /* Check UNIVERSAL without caching */
454 if(level == 0 || level == -1) {
455 candidate = gv_fetchmeth(NULL, name, len, 1);
457 cand_cv = GvCV(candidate);
458 if (topgv && (GvREFCNT(topgv) == 1) && (CvROOT(cand_cv) || CvXSUB(cand_cv))) {
459 if ((old_cv = GvCV(topgv))) SvREFCNT_dec(old_cv);
460 SvREFCNT_inc_simple_void_NN(cand_cv);
461 GvCV(topgv) = cand_cv;
462 GvCVGEN(topgv) = topgen_cmp;
468 if (topgv && GvREFCNT(topgv) == 1) {
469 /* cache the fact that the method is not defined */
470 GvCVGEN(topgv) = topgen_cmp;
477 =for apidoc gv_fetchmeth_autoload
479 Same as gv_fetchmeth(), but looks for autoloaded subroutines too.
480 Returns a glob for the subroutine.
482 For an autoloaded subroutine without a GV, will create a GV even
483 if C<level < 0>. For an autoloaded subroutine without a stub, GvCV()
484 of the result may be zero.
490 Perl_gv_fetchmeth_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level)
492 GV *gv = gv_fetchmeth(stash, name, len, level);
499 return NULL; /* UNIVERSAL::AUTOLOAD could cause trouble */
500 if (len == S_autolen && strnEQ(name, S_autoload, S_autolen))
502 if (!(gv = gv_fetchmeth(stash, S_autoload, S_autolen, FALSE)))
505 if (!(CvROOT(cv) || CvXSUB(cv)))
507 /* Have an autoload */
508 if (level < 0) /* Cannot do without a stub */
509 gv_fetchmeth(stash, name, len, 0);
510 gvp = (GV**)hv_fetch(stash, name, len, (level >= 0));
519 =for apidoc gv_fetchmethod_autoload
521 Returns the glob which contains the subroutine to call to invoke the method
522 on the C<stash>. In fact in the presence of autoloading this may be the
523 glob for "AUTOLOAD". In this case the corresponding variable $AUTOLOAD is
526 The third parameter of C<gv_fetchmethod_autoload> determines whether
527 AUTOLOAD lookup is performed if the given method is not present: non-zero
528 means yes, look for AUTOLOAD; zero means no, don't look for AUTOLOAD.
529 Calling C<gv_fetchmethod> is equivalent to calling C<gv_fetchmethod_autoload>
530 with a non-zero C<autoload> parameter.
532 These functions grant C<"SUPER"> token as a prefix of the method name. Note
533 that if you want to keep the returned glob for a long time, you need to
534 check for it being "AUTOLOAD", since at the later time the call may load a
535 different subroutine due to $AUTOLOAD changing its value. Use the glob
536 created via a side effect to do this.
538 These functions have the same side-effects and as C<gv_fetchmeth> with
539 C<level==0>. C<name> should be writable if contains C<':'> or C<'
540 ''>. The warning against passing the GV returned by C<gv_fetchmeth> to
541 C<call_sv> apply equally to these functions.
547 S_gv_get_super_pkg(pTHX_ const char* name, I32 namelen)
554 stash = gv_stashpvn(name, namelen, 0);
555 if(stash) return stash;
557 /* If we must create it, give it an @ISA array containing
558 the real package this SUPER is for, so that it's tied
559 into the cache invalidation code correctly */
560 stash = gv_stashpvn(name, namelen, GV_ADD);
561 gvp = (GV**)hv_fetchs(stash, "ISA", TRUE);
563 gv_init(gv, stash, "ISA", 3, TRUE);
564 superisa = GvAVn(gv);
566 sv_magic((SV*)superisa, (SV*)gv, PERL_MAGIC_isa, NULL, 0);
567 av_push(superisa, newSVpv(CopSTASHPV(PL_curcop), 0));
573 Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload)
576 register const char *nend;
577 const char *nsplit = NULL;
581 if (stash && SvTYPE(stash) < SVt_PVHV)
584 for (nend = name; *nend; nend++) {
587 else if (*nend == ':' && *(nend + 1) == ':')
591 const char * const origname = name;
595 if ((nsplit - origname) == 5 && strnEQ(origname, "SUPER", 5)) {
596 /* ->SUPER::method should really be looked up in original stash */
597 SV * const tmpstr = sv_2mortal(Perl_newSVpvf(aTHX_ "%s::SUPER",
598 CopSTASHPV(PL_curcop)));
599 /* __PACKAGE__::SUPER stash should be autovivified */
600 stash = gv_get_super_pkg(SvPVX_const(tmpstr), SvCUR(tmpstr));
601 DEBUG_o( Perl_deb(aTHX_ "Treating %s as %s::%s\n",
602 origname, HvNAME_get(stash), name) );
605 /* don't autovifify if ->NoSuchStash::method */
606 stash = gv_stashpvn(origname, nsplit - origname, 0);
608 /* however, explicit calls to Pkg::SUPER::method may
609 happen, and may require autovivification to work */
610 if (!stash && (nsplit - origname) >= 7 &&
611 strnEQ(nsplit - 7, "::SUPER", 7) &&
612 gv_stashpvn(origname, nsplit - origname - 7, 0))
613 stash = gv_get_super_pkg(origname, nsplit - origname);
618 gv = gv_fetchmeth(stash, name, nend - name, 0);
620 if (strEQ(name,"import") || strEQ(name,"unimport"))
621 gv = (GV*)&PL_sv_yes;
623 gv = gv_autoload4(ostash, name, nend - name, TRUE);
626 CV* const cv = GvCV(gv);
627 if (!CvROOT(cv) && !CvXSUB(cv)) {
635 if (GvCV(stubgv) != cv) /* orphaned import */
638 autogv = gv_autoload4(GvSTASH(stubgv),
639 GvNAME(stubgv), GvNAMELEN(stubgv), TRUE);
649 Perl_gv_autoload4(pTHX_ HV *stash, const char *name, STRLEN len, I32 method)
657 const char *packname = "";
658 STRLEN packname_len = 0;
660 if (len == S_autolen && strnEQ(name, S_autoload, S_autolen))
663 if (SvTYPE(stash) < SVt_PVHV) {
664 packname = SvPV_const((SV*)stash, packname_len);
668 packname = HvNAME_get(stash);
669 packname_len = HvNAMELEN_get(stash);
672 if (!(gv = gv_fetchmeth(stash, S_autoload, S_autolen, FALSE)))
676 if (!(CvROOT(cv) || CvXSUB(cv)))
680 * Inheriting AUTOLOAD for non-methods works ... for now.
682 if (!method && (GvCVGEN(gv) || GvSTASH(gv) != stash)
683 && ckWARN2(WARN_DEPRECATED, WARN_SYNTAX)
685 Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
686 "Use of inherited AUTOLOAD for non-method %s::%.*s() is deprecated",
687 packname, (int)len, name);
690 /* rather than lookup/init $AUTOLOAD here
691 * only to have the XSUB do another lookup for $AUTOLOAD
692 * and split that value on the last '::',
693 * pass along the same data via some unused fields in the CV
696 SvPV_set(cv, (char *)name); /* cast to lose constness warning */
702 * Given &FOO::AUTOLOAD, set $FOO::AUTOLOAD to desired function name.
703 * The subroutine's original name may not be "AUTOLOAD", so we don't
704 * use that, but for lack of anything better we will use the sub's
705 * original package to look up $AUTOLOAD.
707 varstash = GvSTASH(CvGV(cv));
708 vargv = *(GV**)hv_fetch(varstash, S_autoload, S_autolen, TRUE);
712 gv_init(vargv, varstash, S_autoload, S_autolen, FALSE);
713 #ifdef PERL_DONT_CREATE_GVSV
714 GvSV(vargv) = newSV(0);
718 varsv = GvSVn(vargv);
719 sv_setpvn(varsv, packname, packname_len);
720 sv_catpvs(varsv, "::");
721 sv_catpvn(varsv, name, len);
726 /* require_tie_mod() internal routine for requiring a module
727 * that implements the logic of automatical ties like %! and %-
729 * The "gv" parameter should be the glob.
730 * "varpv" holds the name of the var, used for error messages.
731 * "namesv" holds the module name. Its refcount will be decremented.
732 * "methpv" holds the method name to test for to check that things
733 * are working reasonably close to as expected.
734 * "flags": if flag & 1 then save the scalar before loading.
735 * For the protection of $! to work (it is set by this routine)
736 * the sv slot must already be magicalized.
739 S_require_tie_mod(pTHX_ GV *gv, const char *varpv, SV* namesv, const char *methpv,const U32 flags)
742 HV* stash = gv_stashsv(namesv, 0);
744 if (!stash || !(gv_fetchmethod(stash, methpv))) {
745 SV *module = newSVsv(namesv);
746 char varname = *varpv; /* varpv might be clobbered by load_module,
747 so save it. For the moment it's always
753 PUSHSTACKi(PERLSI_MAGIC);
754 Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT, module, NULL);
758 stash = gv_stashsv(namesv, 0);
760 Perl_croak(aTHX_ "panic: Can't use %%%c because %"SVf" is not available",
761 varname, SVfARG(namesv));
762 else if (!gv_fetchmethod(stash, methpv))
763 Perl_croak(aTHX_ "panic: Can't use %%%c because %"SVf" does not support method %s",
764 varname, SVfARG(namesv), methpv);
766 SvREFCNT_dec(namesv);
771 =for apidoc gv_stashpv
773 Returns a pointer to the stash for a specified package. Uses C<strlen> to
774 determine the length of C<name>, then calls C<gv_stashpvn()>.
780 Perl_gv_stashpv(pTHX_ const char *name, I32 create)
782 return gv_stashpvn(name, strlen(name), create);
786 =for apidoc gv_stashpvn
788 Returns a pointer to the stash for a specified package. The C<namelen>
789 parameter indicates the length of the C<name>, in bytes. C<flags> is passed
790 to C<gv_fetchpvn_flags()>, so if set to C<GV_ADD> then the package will be
791 created if it does not already exist. If the package does not exist and
792 C<flags> is 0 (or any other setting that does not create packages) then NULL
800 Perl_gv_stashpvn(pTHX_ const char *name, U32 namelen, I32 flags)
807 if (namelen + 2 <= sizeof smallbuf)
810 Newx(tmpbuf, namelen + 2, char);
811 Copy(name,tmpbuf,namelen,char);
812 tmpbuf[namelen++] = ':';
813 tmpbuf[namelen++] = ':';
814 tmpgv = gv_fetchpvn_flags(tmpbuf, namelen, flags, SVt_PVHV);
815 if (tmpbuf != smallbuf)
820 GvHV(tmpgv) = newHV();
822 if (!HvNAME_get(stash))
823 hv_name_set(stash, name, namelen, 0);
828 =for apidoc gv_stashsv
830 Returns a pointer to the stash for a specified package. See C<gv_stashpvn>.
836 Perl_gv_stashsv(pTHX_ SV *sv, I32 flags)
839 const char * const ptr = SvPV_const(sv,len);
840 return gv_stashpvn(ptr, len, flags);
845 Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 add, I32 sv_type) {
846 return gv_fetchpvn_flags(nambeg, strlen(nambeg), add, sv_type);
850 Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, I32 sv_type) {
852 const char * const nambeg = SvPV_const(name, len);
853 return gv_fetchpvn_flags(nambeg, len, flags | SvUTF8(name), sv_type);
857 Perl_gv_fetchpvn_flags(pTHX_ const char *nambeg, STRLEN full_len, I32 flags,
861 register const char *name = nambeg;
862 register GV *gv = NULL;
865 register const char *name_cursor;
867 const I32 no_init = flags & (GV_NOADD_NOINIT | GV_NOINIT);
868 const I32 no_expand = flags & GV_NOEXPAND;
869 const I32 add = flags & ~GV_NOADD_MASK;
870 const char *const name_end = nambeg + full_len;
871 const char *const name_em1 = name_end - 1;
873 if (flags & GV_NOTQUAL) {
874 /* Caller promised that there is no stash, so we can skip the check. */
879 if (full_len > 2 && *name == '*' && isALPHA(name[1])) {
880 /* accidental stringify on a GV? */
884 for (name_cursor = name; name_cursor < name_end; name_cursor++) {
885 if ((*name_cursor == ':' && name_cursor < name_em1
886 && name_cursor[1] == ':')
887 || (*name_cursor == '\'' && name_cursor[1]))
891 if (!stash || !SvREFCNT(stash)) /* symbol table under destruction */
894 len = name_cursor - name;
899 if (len + 2 <= (I32)sizeof (smallbuf))
902 Newx(tmpbuf, len+2, char);
903 Copy(name, tmpbuf, len, char);
906 gvp = (GV**)hv_fetch(stash,tmpbuf,len,add);
907 gv = gvp ? *gvp : NULL;
908 if (gv && gv != (GV*)&PL_sv_undef) {
909 if (SvTYPE(gv) != SVt_PVGV)
910 gv_init(gv, stash, tmpbuf, len, (add & GV_ADDMULTI));
914 if (tmpbuf != smallbuf)
916 if (!gv || gv == (GV*)&PL_sv_undef)
919 if (!(stash = GvHV(gv)))
920 stash = GvHV(gv) = newHV();
922 if (!HvNAME_get(stash))
923 hv_name_set(stash, nambeg, name_cursor - nambeg, 0);
926 if (*name_cursor == ':')
930 if (name == name_end)
931 return gv ? gv : (GV*)*hv_fetchs(PL_defstash, "main::", TRUE);
934 len = name_cursor - name;
936 /* No stash in name, so see how we can default */
940 if (len && isIDFIRST_lazy(name)) {
949 if ((name[0] == 'I' && name[1] == 'N' && name[2] == 'C')
950 || (name[0] == 'E' && name[1] == 'N' && name[2] == 'V')
951 || (name[0] == 'S' && name[1] == 'I' && name[2] == 'G'))
955 if (name[0] == 'A' && name[1] == 'R' && name[2] == 'G'
960 if (name[0] == 'S' && name[1] == 'T' && name[2] == 'D'
961 && name[3] == 'I' && name[4] == 'N')
965 if ((name[0] == 'S' && name[1] == 'T' && name[2] == 'D')
966 &&((name[3] == 'O' && name[4] == 'U' && name[5] == 'T')
967 ||(name[3] == 'E' && name[4] == 'R' && name[5] == 'R')))
971 if (name[0] == 'A' && name[1] == 'R' && name[2] == 'G'
972 && name[3] == 'V' && name[4] == 'O' && name[5] == 'U'
980 else if (IN_PERL_COMPILETIME) {
982 if (add && (PL_hints & HINT_STRICT_VARS) &&
983 sv_type != SVt_PVCV &&
984 sv_type != SVt_PVGV &&
985 sv_type != SVt_PVFM &&
986 sv_type != SVt_PVIO &&
987 !(len == 1 && sv_type == SVt_PV &&
988 (*name == 'a' || *name == 'b')) )
990 gvp = (GV**)hv_fetch(stash,name,len,0);
992 *gvp == (GV*)&PL_sv_undef ||
993 SvTYPE(*gvp) != SVt_PVGV)
997 else if ((sv_type == SVt_PV && !GvIMPORTED_SV(*gvp)) ||
998 (sv_type == SVt_PVAV && !GvIMPORTED_AV(*gvp)) ||
999 (sv_type == SVt_PVHV && !GvIMPORTED_HV(*gvp)) )
1001 Perl_warn(aTHX_ "Variable \"%c%s\" is not imported",
1002 sv_type == SVt_PVAV ? '@' :
1003 sv_type == SVt_PVHV ? '%' : '$',
1006 Perl_warn(aTHX_ "\t(Did you mean &%s instead?)\n", name);
1012 stash = CopSTASH(PL_curcop);
1015 stash = PL_defstash;
1018 /* By this point we should have a stash and a name */
1022 SV * const err = Perl_mess(aTHX_
1023 "Global symbol \"%s%s\" requires explicit package name",
1024 (sv_type == SVt_PV ? "$"
1025 : sv_type == SVt_PVAV ? "@"
1026 : sv_type == SVt_PVHV ? "%"
1029 if (USE_UTF8_IN_NAMES)
1032 gv = gv_fetchpvn_flags("<none>::", 8, GV_ADDMULTI, SVt_PVHV);
1034 /* symbol table under destruction */
1043 if (!SvREFCNT(stash)) /* symbol table under destruction */
1046 gvp = (GV**)hv_fetch(stash,name,len,add);
1047 if (!gvp || *gvp == (GV*)&PL_sv_undef)
1050 if (SvTYPE(gv) == SVt_PVGV) {
1053 gv_init_sv(gv, sv_type);
1054 if (len == 1 && (sv_type == SVt_PVHV || sv_type == SVt_PVGV)) {
1056 require_tie_mod(gv, "!", newSVpvs("Errno"), "TIEHASH", 1);
1057 else if (*name == '-' || *name == '+')
1058 require_tie_mod(gv, name, newSVpvs("Tie::Hash::NamedCapture"), "TIEHASH", 0);
1062 } else if (no_init) {
1064 } else if (no_expand && SvROK(gv)) {
1068 /* Adding a new symbol */
1070 if (add & GV_ADDWARN && ckWARN_d(WARN_INTERNAL))
1071 Perl_warner(aTHX_ packWARN(WARN_INTERNAL), "Had to create %s unexpectedly", nambeg);
1072 gv_init(gv, stash, name, len, add & GV_ADDMULTI);
1073 gv_init_sv(gv, sv_type);
1075 if (isALPHA(name[0]) && ! (isLEXWARN_on ? ckWARN(WARN_ONCE)
1076 : (PL_dowarn & G_WARN_ON ) ) )
1079 /* set up magic where warranted */
1084 /* Nothing else to do.
1085 The compiler will probably turn the switch statement into a
1086 branch table. Make sure we avoid even that small overhead for
1087 the common case of lower case variable names. */
1091 const char * const name2 = name + 1;
1094 if (strEQ(name2, "RGV")) {
1095 IoFLAGS(GvIOn(gv)) |= IOf_ARGV|IOf_START;
1097 else if (strEQ(name2, "RGVOUT")) {
1102 if (strnEQ(name2, "XPORT", 5))
1106 if (strEQ(name2, "SA")) {
1107 AV* const av = GvAVn(gv);
1109 sv_magic((SV*)av, (SV*)gv, PERL_MAGIC_isa, NULL, 0);
1110 /* NOTE: No support for tied ISA */
1111 if ((add & GV_ADDMULTI) && strEQ(nambeg,"AnyDBM_File::ISA")
1112 && AvFILLp(av) == -1)
1115 av_push(av, newSVpvn(pname = "NDBM_File",9));
1116 gv_stashpvn(pname, 9, GV_ADD);
1117 av_push(av, newSVpvn(pname = "DB_File",7));
1118 gv_stashpvn(pname, 7, GV_ADD);
1119 av_push(av, newSVpvn(pname = "GDBM_File",9));
1120 gv_stashpvn(pname, 9, GV_ADD);
1121 av_push(av, newSVpvn(pname = "SDBM_File",9));
1122 gv_stashpvn(pname, 9, GV_ADD);
1123 av_push(av, newSVpvn(pname = "ODBM_File",9));
1124 gv_stashpvn(pname, 9, GV_ADD);
1129 if (strEQ(name2, "VERLOAD")) {
1130 HV* const hv = GvHVn(gv);
1132 hv_magic(hv, NULL, PERL_MAGIC_overload);
1136 if (strEQ(name2, "IG")) {
1140 Newxz(PL_psig_ptr, SIG_SIZE, SV*);
1141 Newxz(PL_psig_name, SIG_SIZE, SV*);
1142 Newxz(PL_psig_pend, SIG_SIZE, int);
1146 hv_magic(hv, NULL, PERL_MAGIC_sig);
1147 for (i = 1; i < SIG_SIZE; i++) {
1148 SV * const * const init = hv_fetch(hv, PL_sig_name[i], strlen(PL_sig_name[i]), 1);
1150 sv_setsv(*init, &PL_sv_undef);
1152 PL_psig_name[i] = 0;
1153 PL_psig_pend[i] = 0;
1158 if (strEQ(name2, "ERSION"))
1161 case '\003': /* $^CHILD_ERROR_NATIVE */
1162 if (strEQ(name2, "HILD_ERROR_NATIVE"))
1165 case '\005': /* $^ENCODING */
1166 if (strEQ(name2, "NCODING"))
1169 case '\015': /* $^MATCH */
1170 if (strEQ(name2, "ATCH"))
1172 case '\017': /* $^OPEN */
1173 if (strEQ(name2, "PEN"))
1176 case '\020': /* $^PREMATCH $^POSTMATCH */
1177 if (strEQ(name2, "REMATCH") || strEQ(name2, "OSTMATCH"))
1179 case '\024': /* ${^TAINT} */
1180 if (strEQ(name2, "AINT"))
1183 case '\025': /* ${^UNICODE}, ${^UTF8LOCALE} */
1184 if (strEQ(name2, "NICODE"))
1186 if (strEQ(name2, "TF8LOCALE"))
1188 if (strEQ(name2, "TF8CACHE"))
1191 case '\027': /* $^WARNING_BITS */
1192 if (strEQ(name2, "ARNING_BITS"))
1205 /* Ensures that we have an all-digit variable, ${"1foo"} fails
1207 /* This snippet is taken from is_gv_magical */
1208 const char *end = name + len;
1209 while (--end > name) {
1210 if (!isDIGIT(*end)) return gv;
1217 /* Names of length 1. (Or 0. But name is NUL terminated, so that will
1218 be case '\0' in this switch statement (ie a default case) */
1224 sv_type == SVt_PVAV ||
1225 sv_type == SVt_PVHV ||
1226 sv_type == SVt_PVCV ||
1227 sv_type == SVt_PVFM ||
1230 PL_sawampersand = TRUE;
1234 sv_setpv(GvSVn(gv),PL_chopset);
1238 #ifdef COMPLEX_STATUS
1239 SvUPGRADE(GvSVn(gv), SVt_PVLV);
1245 /* If %! has been used, automatically load Errno.pm. */
1247 sv_magic(GvSVn(gv), (SV*)gv, PERL_MAGIC_sv, name, len);
1249 /* magicalization must be done before require_tie_mod is called */
1250 if (sv_type == SVt_PVHV || sv_type == SVt_PVGV)
1251 require_tie_mod(gv, "!", newSVpvs("Errno"), "TIEHASH", 1);
1256 GvMULTI_on(gv); /* no used once warnings here */
1258 AV* const av = GvAVn(gv);
1259 SV* const avc = (*name == '+') ? (SV*)av : NULL;
1261 sv_magic((SV*)av, avc, PERL_MAGIC_regdata, NULL, 0);
1262 sv_magic(GvSVn(gv), (SV*)gv, PERL_MAGIC_sv, name, len);
1264 SvREADONLY_on(GvSVn(gv));
1267 if (sv_type == SVt_PVHV || sv_type == SVt_PVGV)
1268 require_tie_mod(gv, name, newSVpvs("Tie::Hash::NamedCapture"), "TIEHASH", 0);
1274 if (sv_type == SVt_PV && ckWARN2_d(WARN_DEPRECATED, WARN_SYNTAX))
1275 Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
1276 "$%c is no longer supported", *name);
1279 sv_setiv(GvSVn(gv), (IV)(IoFLAGS(GvIOp(PL_defoutgv)) & IOf_FLUSH) != 0);
1282 case '\010': /* $^H */
1284 HV *const hv = GvHVn(gv);
1285 hv_magic(hv, NULL, PERL_MAGIC_hints);
1288 case '\023': /* $^S */
1290 SvREADONLY_on(GvSVn(gv));
1314 case '\001': /* $^A */
1315 case '\003': /* $^C */
1316 case '\004': /* $^D */
1317 case '\005': /* $^E */
1318 case '\006': /* $^F */
1319 case '\011': /* $^I, NOT \t in EBCDIC */
1320 case '\016': /* $^N */
1321 case '\017': /* $^O */
1322 case '\020': /* $^P */
1323 case '\024': /* $^T */
1324 case '\027': /* $^W */
1326 sv_magic(GvSVn(gv), (SV*)gv, PERL_MAGIC_sv, name, len);
1329 case '\014': /* $^L */
1330 sv_setpvn(GvSVn(gv),"\f",1);
1331 PL_formfeed = GvSVn(gv);
1334 sv_setpvn(GvSVn(gv),"\034",1);
1338 SV * const sv = GvSVn(gv);
1339 if (!sv_derived_from(PL_patchlevel, "version"))
1340 upg_version(PL_patchlevel, TRUE);
1341 GvSV(gv) = vnumify(PL_patchlevel);
1342 SvREADONLY_on(GvSV(gv));
1346 case '\026': /* $^V */
1348 SV * const sv = GvSVn(gv);
1349 GvSV(gv) = new_version(PL_patchlevel);
1350 SvREADONLY_on(GvSV(gv));
1360 Perl_gv_fullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain)
1364 const HV * const hv = GvSTASH(gv);
1369 sv_setpv(sv, prefix ? prefix : "");
1371 name = HvNAME_get(hv);
1373 namelen = HvNAMELEN_get(hv);
1379 if (keepmain || strNE(name, "main")) {
1380 sv_catpvn(sv,name,namelen);
1383 sv_catpvn(sv,GvNAME(gv),GvNAMELEN(gv));
1387 Perl_gv_efullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain)
1389 const GV * const egv = GvEGV(gv);
1390 gv_fullname4(sv, egv ? egv : gv, prefix, keepmain);
1398 IO * const io = (IO*)newSV_type(SVt_PVIO);
1399 /* This used to read SvREFCNT(io) = 1;
1400 It's not clear why the reference count needed an explicit reset. NWC
1402 assert (SvREFCNT(io) == 1);
1404 /* Clear the stashcache because a new IO could overrule a package name */
1405 hv_clear(PL_stashcache);
1406 iogv = gv_fetchpvs("FileHandle::", 0, SVt_PVHV);
1407 /* unless exists($main::{FileHandle}) and defined(%main::FileHandle::) */
1408 if (!(iogv && GvHV(iogv) && HvARRAY(GvHV(iogv))))
1409 iogv = gv_fetchpvs("IO::Handle::", GV_ADD, SVt_PVHV);
1410 SvSTASH_set(io, (HV*)SvREFCNT_inc(GvHV(iogv)));
1415 Perl_gv_check(pTHX_ const HV *stash)
1420 if (!HvARRAY(stash))
1422 for (i = 0; i <= (I32) HvMAX(stash); i++) {
1424 for (entry = HvARRAY(stash)[i]; entry; entry = HeNEXT(entry)) {
1427 if (HeKEY(entry)[HeKLEN(entry)-1] == ':' &&
1428 (gv = (GV*)HeVAL(entry)) && isGV(gv) && (hv = GvHV(gv)))
1430 if (hv != PL_defstash && hv != stash)
1431 gv_check(hv); /* nested package */
1433 else if (isALPHA(*HeKEY(entry))) {
1435 gv = (GV*)HeVAL(entry);
1436 if (SvTYPE(gv) != SVt_PVGV || GvMULTI(gv))
1439 CopLINE_set(PL_curcop, GvLINE(gv));
1441 CopFILE(PL_curcop) = (char *)file; /* set for warning */
1443 CopFILEGV(PL_curcop)
1444 = gv_fetchfile_flags(file, HEK_LEN(GvFILE_HEK(gv)), 0);
1446 Perl_warner(aTHX_ packWARN(WARN_ONCE),
1447 "Name \"%s::%s\" used only once: possible typo",
1448 HvNAME_get(stash), GvNAME(gv));
1455 Perl_newGVgen(pTHX_ const char *pack)
1458 return gv_fetchpv(Perl_form(aTHX_ "%s::_GEN_%ld", pack, (long)PL_gensym++),
1462 /* hopefully this is only called on local symbol table entries */
1465 Perl_gp_ref(pTHX_ GP *gp)
1473 /* If the GP they asked for a reference to contains
1474 a method cache entry, clear it first, so that we
1475 don't infect them with our cached entry */
1476 SvREFCNT_dec(gp->gp_cv);
1485 Perl_gp_free(pTHX_ GV *gv)
1490 if (!gv || !isGV_with_GP(gv) || !(gp = GvGP(gv)))
1492 if (gp->gp_refcnt == 0) {
1493 if (ckWARN_d(WARN_INTERNAL))
1494 Perl_warner(aTHX_ packWARN(WARN_INTERNAL),
1495 "Attempt to free unreferenced glob pointers"
1496 pTHX__FORMAT pTHX__VALUE);
1499 if (--gp->gp_refcnt > 0) {
1500 if (gp->gp_egv == gv)
1506 if (gp->gp_file_hek)
1507 unshare_hek(gp->gp_file_hek);
1508 SvREFCNT_dec(gp->gp_sv);
1509 SvREFCNT_dec(gp->gp_av);
1510 /* FIXME - another reference loop GV -> symtab -> GV ?
1511 Somehow gp->gp_hv can end up pointing at freed garbage. */
1512 if (gp->gp_hv && SvTYPE(gp->gp_hv) == SVt_PVHV) {
1513 const char *hvname = HvNAME_get(gp->gp_hv);
1514 if (PL_stashcache && hvname)
1515 (void)hv_delete(PL_stashcache, hvname, HvNAMELEN_get(gp->gp_hv),
1517 SvREFCNT_dec(gp->gp_hv);
1519 SvREFCNT_dec(gp->gp_io);
1520 SvREFCNT_dec(gp->gp_cv);
1521 SvREFCNT_dec(gp->gp_form);
1528 Perl_magic_freeovrld(pTHX_ SV *sv, MAGIC *mg)
1530 AMT * const amtp = (AMT*)mg->mg_ptr;
1531 PERL_UNUSED_ARG(sv);
1533 if (amtp && AMT_AMAGIC(amtp)) {
1535 for (i = 1; i < NofAMmeth; i++) {
1536 CV * const cv = amtp->table[i];
1538 SvREFCNT_dec((SV *) cv);
1539 amtp->table[i] = NULL;
1546 /* Updates and caches the CV's */
1549 Perl_Gv_AMupdate(pTHX_ HV *stash)
1552 MAGIC* const mg = mg_find((SV*)stash, PERL_MAGIC_overload_table);
1554 const struct mro_meta* stash_meta = HvMROMETA(stash);
1557 newgen = PL_sub_generation + stash_meta->pkg_gen + stash_meta->cache_gen;
1559 const AMT * const amtp = (AMT*)mg->mg_ptr;
1560 if (amtp->was_ok_am == PL_amagic_generation
1561 && amtp->was_ok_sub == newgen) {
1562 return (bool)AMT_OVERLOADED(amtp);
1564 sv_unmagic((SV*)stash, PERL_MAGIC_overload_table);
1567 DEBUG_o( Perl_deb(aTHX_ "Recalcing overload magic in package %s\n",HvNAME_get(stash)) );
1570 amt.was_ok_am = PL_amagic_generation;
1571 amt.was_ok_sub = newgen;
1572 amt.fallback = AMGfallNO;
1576 int filled = 0, have_ovl = 0;
1579 /* Work with "fallback" key, which we assume to be first in PL_AMG_names */
1581 /* Try to find via inheritance. */
1582 GV *gv = gv_fetchmeth(stash, PL_AMG_names[0], 2, -1);
1583 SV * const sv = gv ? GvSV(gv) : NULL;
1587 lim = DESTROY_amg; /* Skip overloading entries. */
1588 #ifdef PERL_DONT_CREATE_GVSV
1590 NOOP; /* Equivalent to !SvTRUE and !SvOK */
1593 else if (SvTRUE(sv))
1594 amt.fallback=AMGfallYES;
1596 amt.fallback=AMGfallNEVER;
1598 for (i = 1; i < lim; i++)
1599 amt.table[i] = NULL;
1600 for (; i < NofAMmeth; i++) {
1601 const char * const cooky = PL_AMG_names[i];
1602 /* Human-readable form, for debugging: */
1603 const char * const cp = (i >= DESTROY_amg ? cooky : AMG_id2name(i));
1604 const STRLEN l = PL_AMG_namelens[i];
1606 DEBUG_o( Perl_deb(aTHX_ "Checking overloading of \"%s\" in package \"%.256s\"\n",
1607 cp, HvNAME_get(stash)) );
1608 /* don't fill the cache while looking up!
1609 Creation of inheritance stubs in intermediate packages may
1610 conflict with the logic of runtime method substitution.
1611 Indeed, for inheritance A -> B -> C, if C overloads "+0",
1612 then we could have created stubs for "(+0" in A and C too.
1613 But if B overloads "bool", we may want to use it for
1614 numifying instead of C's "+0". */
1615 if (i >= DESTROY_amg)
1616 gv = Perl_gv_fetchmeth_autoload(aTHX_ stash, cooky, l, 0);
1617 else /* Autoload taken care of below */
1618 gv = Perl_gv_fetchmeth(aTHX_ stash, cooky, l, -1);
1620 if (gv && (cv = GvCV(gv))) {
1622 if (GvNAMELEN(CvGV(cv)) == 3 && strEQ(GvNAME(CvGV(cv)), "nil")
1623 && strEQ(hvname = HvNAME_get(GvSTASH(CvGV(cv))), "overload")) {
1624 /* This is a hack to support autoloading..., while
1625 knowing *which* methods were declared as overloaded. */
1626 /* GvSV contains the name of the method. */
1628 SV *gvsv = GvSV(gv);
1630 DEBUG_o( Perl_deb(aTHX_ "Resolving method \"%"SVf256\
1631 "\" for overloaded \"%s\" in package \"%.256s\"\n",
1632 (void*)GvSV(gv), cp, hvname) );
1633 if (!gvsv || !SvPOK(gvsv)
1634 || !(ngv = gv_fetchmethod_autoload(stash, SvPVX_const(gvsv),
1637 /* Can be an import stub (created by "can"). */
1638 const char * const name = (gvsv && SvPOK(gvsv)) ? SvPVX_const(gvsv) : "???";
1639 Perl_croak(aTHX_ "%s method \"%.256s\" overloading \"%s\" "\
1640 "in package \"%.256s\"",
1641 (GvCVGEN(gv) ? "Stub found while resolving"
1645 cv = GvCV(gv = ngv);
1647 DEBUG_o( Perl_deb(aTHX_ "Overloading \"%s\" in package \"%.256s\" via \"%.256s::%.256s\"\n",
1648 cp, HvNAME_get(stash), HvNAME_get(GvSTASH(CvGV(cv))),
1649 GvNAME(CvGV(cv))) );
1651 if (i < DESTROY_amg)
1653 } else if (gv) { /* Autoloaded... */
1657 amt.table[i]=(CV*)SvREFCNT_inc_simple(cv);
1660 AMT_AMAGIC_on(&amt);
1662 AMT_OVERLOADED_on(&amt);
1663 sv_magic((SV*)stash, 0, PERL_MAGIC_overload_table,
1664 (char*)&amt, sizeof(AMT));
1668 /* Here we have no table: */
1670 AMT_AMAGIC_off(&amt);
1671 sv_magic((SV*)stash, 0, PERL_MAGIC_overload_table,
1672 (char*)&amt, sizeof(AMTS));
1678 Perl_gv_handler(pTHX_ HV *stash, I32 id)
1684 struct mro_meta* stash_meta;
1686 if (!stash || !HvNAME_get(stash))
1689 stash_meta = HvMROMETA(stash);
1690 newgen = PL_sub_generation + stash_meta->pkg_gen + stash_meta->cache_gen;
1692 mg = mg_find((SV*)stash, PERL_MAGIC_overload_table);
1696 mg = mg_find((SV*)stash, PERL_MAGIC_overload_table);
1699 amtp = (AMT*)mg->mg_ptr;
1700 if ( amtp->was_ok_am != PL_amagic_generation
1701 || amtp->was_ok_sub != newgen )
1703 if (AMT_AMAGIC(amtp)) {
1704 CV * const ret = amtp->table[id];
1705 if (ret && isGV(ret)) { /* Autoloading stab */
1706 /* Passing it through may have resulted in a warning
1707 "Inherited AUTOLOAD for a non-method deprecated", since
1708 our caller is going through a function call, not a method call.
1709 So return the CV for AUTOLOAD, setting $AUTOLOAD. */
1710 GV * const gv = gv_fetchmethod(stash, PL_AMG_names[id]);
1723 Perl_amagic_call(pTHX_ SV *left, SV *right, int method, int flags)
1728 CV **cvp=NULL, **ocvp=NULL;
1729 AMT *amtp=NULL, *oamtp=NULL;
1730 int off = 0, off1, lr = 0, notfound = 0;
1731 int postpr = 0, force_cpy = 0;
1732 int assign = AMGf_assign & flags;
1733 const int assignshift = assign ? 1 : 0;
1738 if (!(AMGf_noleft & flags) && SvAMAGIC(left)
1739 && (stash = SvSTASH(SvRV(left)))
1740 && (mg = mg_find((SV*)stash, PERL_MAGIC_overload_table))
1741 && (ocvp = cvp = (AMT_AMAGIC((AMT*)mg->mg_ptr)
1742 ? (oamtp = amtp = (AMT*)mg->mg_ptr)->table
1744 && ((cv = cvp[off=method+assignshift])
1745 || (assign && amtp->fallback > AMGfallNEVER && /* fallback to
1751 cv = cvp[off=method])))) {
1752 lr = -1; /* Call method for left argument */
1754 if (cvp && amtp->fallback > AMGfallNEVER && flags & AMGf_unary) {
1757 /* look for substituted methods */
1758 /* In all the covered cases we should be called with assign==0. */
1762 if ((cv = cvp[off=add_ass_amg])
1763 || ((cv = cvp[off = add_amg]) && (force_cpy = 0, postpr = 1))) {
1764 right = &PL_sv_yes; lr = -1; assign = 1;
1769 if ((cv = cvp[off = subtr_ass_amg])
1770 || ((cv = cvp[off = subtr_amg]) && (force_cpy = 0, postpr=1))) {
1771 right = &PL_sv_yes; lr = -1; assign = 1;
1775 (void)((cv = cvp[off=numer_amg]) || (cv = cvp[off=string_amg]));
1778 (void)((cv = cvp[off=string_amg]) || (cv = cvp[off=bool__amg]));
1781 (void)((cv = cvp[off=numer_amg]) || (cv = cvp[off=bool__amg]));
1784 (void)((cv = cvp[off=bool__amg])
1785 || (cv = cvp[off=numer_amg])
1786 || (cv = cvp[off=string_amg]));
1792 * SV* ref causes confusion with the interpreter variable of
1795 SV* const tmpRef=SvRV(left);
1796 if (!SvROK(tmpRef) && SvTYPE(tmpRef) <= SVt_PVMG) {
1798 * Just to be extra cautious. Maybe in some
1799 * additional cases sv_setsv is safe, too.
1801 SV* const newref = newSVsv(tmpRef);
1802 SvOBJECT_on(newref);
1803 /* As a bit of a source compatibility hack, SvAMAGIC() and
1804 friends dereference an RV, to behave the same was as when
1805 overloading was stored on the reference, not the referant.
1806 Hence we can't use SvAMAGIC_on()
1808 SvFLAGS(newref) |= SVf_AMAGIC;
1809 SvSTASH_set(newref, (HV*)SvREFCNT_inc(SvSTASH(tmpRef)));
1815 if ((cvp[off1=lt_amg] || cvp[off1=ncmp_amg])
1816 && ((cv = cvp[off=neg_amg]) || (cv = cvp[off=subtr_amg]))) {
1817 SV* const nullsv=sv_2mortal(newSViv(0));
1819 SV* const lessp = amagic_call(left,nullsv,
1820 lt_amg,AMGf_noright);
1821 logic = SvTRUE(lessp);
1823 SV* const lessp = amagic_call(left,nullsv,
1824 ncmp_amg,AMGf_noright);
1825 logic = (SvNV(lessp) < 0);
1828 if (off==subtr_amg) {
1839 if ((cv = cvp[off=subtr_amg])) {
1841 left = sv_2mortal(newSViv(0));
1846 case iter_amg: /* XXXX Eventually should do to_gv. */
1848 return NULL; /* Delegate operation to standard mechanisms. */
1856 return left; /* Delegate operation to standard mechanisms. */
1861 if (!cv) goto not_found;
1862 } else if (!(AMGf_noright & flags) && SvAMAGIC(right)
1863 && (stash = SvSTASH(SvRV(right)))
1864 && (mg = mg_find((SV*)stash, PERL_MAGIC_overload_table))
1865 && (cvp = (AMT_AMAGIC((AMT*)mg->mg_ptr)
1866 ? (amtp = (AMT*)mg->mg_ptr)->table
1868 && (cv = cvp[off=method])) { /* Method for right
1871 } else if (((ocvp && oamtp->fallback > AMGfallNEVER
1872 && (cvp=ocvp) && (lr = -1))
1873 || (cvp && amtp->fallback > AMGfallNEVER && (lr=1)))
1874 && !(flags & AMGf_unary)) {
1875 /* We look for substitution for
1876 * comparison operations and
1878 if (method==concat_amg || method==concat_ass_amg
1879 || method==repeat_amg || method==repeat_ass_amg) {
1880 return NULL; /* Delegate operation to string conversion */
1890 postpr = 1; off=ncmp_amg; break;
1897 postpr = 1; off=scmp_amg; break;
1899 if (off != -1) cv = cvp[off];
1904 not_found: /* No method found, either report or croak */
1925 return left; /* Delegate operation to standard mechanisms. */
1928 if (ocvp && (cv=ocvp[nomethod_amg])) { /* Call report method */
1929 notfound = 1; lr = -1;
1930 } else if (cvp && (cv=cvp[nomethod_amg])) {
1931 notfound = 1; lr = 1;
1932 } else if ((amtp && amtp->fallback >= AMGfallYES) && !DEBUG_o_TEST) {
1933 /* Skip generating the "no method found" message. */
1937 if (off==-1) off=method;
1938 msg = sv_2mortal(Perl_newSVpvf(aTHX_
1939 "Operation \"%s\": no method found,%sargument %s%s%s%s",
1940 AMG_id2name(method + assignshift),
1941 (flags & AMGf_unary ? " " : "\n\tleft "),
1943 "in overloaded package ":
1944 "has no overloaded magic",
1946 HvNAME_get(SvSTASH(SvRV(left))):
1949 ",\n\tright argument in overloaded package ":
1952 : ",\n\tright argument has no overloaded magic"),
1954 HvNAME_get(SvSTASH(SvRV(right))):
1956 if (amtp && amtp->fallback >= AMGfallYES) {
1957 DEBUG_o( Perl_deb(aTHX_ "%s", SvPVX_const(msg)) );
1959 Perl_croak(aTHX_ "%"SVf, SVfARG(msg));
1963 force_cpy = force_cpy || assign;
1968 DEBUG_o(Perl_deb(aTHX_
1969 "Overloaded operator \"%s\"%s%s%s:\n\tmethod%s found%s in package %s%s\n",
1971 method+assignshift==off? "" :
1973 method+assignshift==off? "" :
1974 AMG_id2name(method+assignshift),
1975 method+assignshift==off? "" : "\")",
1976 flags & AMGf_unary? "" :
1977 lr==1 ? " for right argument": " for left argument",
1978 flags & AMGf_unary? " for argument" : "",
1979 stash ? HvNAME_get(stash) : "null",
1980 fl? ",\n\tassignment variant used": "") );
1983 /* Since we use shallow copy during assignment, we need
1984 * to dublicate the contents, probably calling user-supplied
1985 * version of copy operator
1987 /* We need to copy in following cases:
1988 * a) Assignment form was called.
1989 * assignshift==1, assign==T, method + 1 == off
1990 * b) Increment or decrement, called directly.
1991 * assignshift==0, assign==0, method + 0 == off
1992 * c) Increment or decrement, translated to assignment add/subtr.
1993 * assignshift==0, assign==T,
1995 * d) Increment or decrement, translated to nomethod.
1996 * assignshift==0, assign==0,
1998 * e) Assignment form translated to nomethod.
1999 * assignshift==1, assign==T, method + 1 != off
2002 /* off is method, method+assignshift, or a result of opcode substitution.
2003 * In the latter case assignshift==0, so only notfound case is important.
2005 if (( (method + assignshift == off)
2006 && (assign || (method == inc_amg) || (method == dec_amg)))
2013 const bool oldcatch = CATCH_GET;
2016 Zero(&myop, 1, BINOP);
2017 myop.op_last = (OP *) &myop;
2018 myop.op_next = NULL;
2019 myop.op_flags = OPf_WANT_SCALAR | OPf_STACKED;
2021 PUSHSTACKi(PERLSI_OVERLOAD);
2024 PL_op = (OP *) &myop;
2025 if (PERLDB_SUB && PL_curstash != PL_debstash)
2026 PL_op->op_private |= OPpENTERSUB_DB;
2030 EXTEND(SP, notfound + 5);
2031 PUSHs(lr>0? right: left);
2032 PUSHs(lr>0? left: right);
2033 PUSHs( lr > 0 ? &PL_sv_yes : ( assign ? &PL_sv_undef : &PL_sv_no ));
2035 PUSHs( sv_2mortal(newSVpv(AMG_id2name(method + assignshift),0)));
2040 if ((PL_op = Perl_pp_entersub(aTHX)))
2048 CATCH_SET(oldcatch);
2055 ans=SvIV(res)<=0; break;
2058 ans=SvIV(res)<0; break;
2061 ans=SvIV(res)>=0; break;
2064 ans=SvIV(res)>0; break;
2067 ans=SvIV(res)==0; break;
2070 ans=SvIV(res)!=0; break;
2073 SvSetSV(left,res); return left;
2075 ans=!SvTRUE(res); break;
2080 } else if (method==copy_amg) {
2082 Perl_croak(aTHX_ "Copy method did not return a reference");
2084 return SvREFCNT_inc(SvRV(res));
2092 =for apidoc is_gv_magical_sv
2094 Returns C<TRUE> if given the name of a magical GV. Calls is_gv_magical.
2100 Perl_is_gv_magical_sv(pTHX_ SV *name, U32 flags)
2103 const char * const temp = SvPV_const(name, len);
2104 return is_gv_magical(temp, len, flags);
2108 =for apidoc is_gv_magical
2110 Returns C<TRUE> if given the name of a magical GV.
2112 Currently only useful internally when determining if a GV should be
2113 created even in rvalue contexts.
2115 C<flags> is not used at present but available for future extension to
2116 allow selecting particular classes of magical variable.
2118 Currently assumes that C<name> is NUL terminated (as well as len being valid).
2119 This assumption is met by all callers within the perl core, which all pass
2120 pointers returned by SvPV.
2125 Perl_is_gv_magical(pTHX_ const char *name, STRLEN len, U32 flags)
2127 PERL_UNUSED_CONTEXT;
2128 PERL_UNUSED_ARG(flags);
2131 const char * const name1 = name + 1;
2134 if (len == 3 && name1[1] == 'S' && name[2] == 'A')
2138 if (len == 8 && strEQ(name1, "VERLOAD"))
2142 if (len == 3 && name[1] == 'I' && name[2] == 'G')
2145 /* Using ${^...} variables is likely to be sufficiently rare that
2146 it seems sensible to avoid the space hit of also checking the
2148 case '\017': /* ${^OPEN} */
2149 if (strEQ(name1, "PEN"))
2152 case '\024': /* ${^TAINT} */
2153 if (strEQ(name1, "AINT"))
2156 case '\025': /* ${^UNICODE} */
2157 if (strEQ(name1, "NICODE"))
2159 if (strEQ(name1, "TF8LOCALE"))
2162 case '\027': /* ${^WARNING_BITS} */
2163 if (strEQ(name1, "ARNING_BITS"))
2176 const char *end = name + len;
2177 while (--end > name) {
2185 /* Because we're already assuming that name is NUL terminated
2186 below, we can treat an empty name as "\0" */
2213 case '\001': /* $^A */
2214 case '\003': /* $^C */
2215 case '\004': /* $^D */
2216 case '\005': /* $^E */
2217 case '\006': /* $^F */
2218 case '\010': /* $^H */
2219 case '\011': /* $^I, NOT \t in EBCDIC */
2220 case '\014': /* $^L */
2221 case '\016': /* $^N */
2222 case '\017': /* $^O */
2223 case '\020': /* $^P */
2224 case '\023': /* $^S */
2225 case '\024': /* $^T */
2226 case '\026': /* $^V */
2227 case '\027': /* $^W */
2247 Perl_gv_name_set(pTHX_ GV *gv, const char *name, U32 len, U32 flags)
2253 PERL_UNUSED_ARG(flags);
2256 Perl_croak(aTHX_ "panic: gv name too long (%"UVuf")", (UV) len);
2258 if (!(flags & GV_ADD) && GvNAME_HEK(gv)) {
2259 unshare_hek(GvNAME_HEK(gv));
2262 PERL_HASH(hash, name, len);
2263 GvNAME_HEK(gv) = share_hek(name, len, hash);
2268 * c-indentation-style: bsd
2270 * indent-tabs-mode: t
2273 * ex: set ts=8 sts=4 sw=4 noet: