Update copyright years.
[perl.git] / gv.c
1 /*    gv.c
2  *
3  *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4  *    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
5  *
6  *    You may distribute under the terms of either the GNU General Public
7  *    License or the Artistic License, as specified in the README file.
8  *
9  */
10
11 /*
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,'
17  * laughed Pippin.
18  */
19
20 /*
21 =head1 GV Functions
22
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.
26
27 GVs are usually found as values in stashes (symbol table hashes) where
28 Perl stores its global variables.
29
30 =cut
31 */
32
33 #include "EXTERN.h"
34 #define PERL_IN_GV_C
35 #include "perl.h"
36 #include "overload.c"
37
38 static const char S_autoload[] = "AUTOLOAD";
39 static const STRLEN S_autolen = sizeof(S_autoload)-1;
40
41
42 #ifdef PERL_DONT_CREATE_GVSV
43 GV *
44 Perl_gv_SVadd(pTHX_ GV *gv)
45 {
46     PERL_ARGS_ASSERT_GV_SVADD;
47
48     if (!gv || SvTYPE((SV*)gv) != SVt_PVGV)
49         Perl_croak(aTHX_ "Bad symbol for scalar");
50     if (!GvSV(gv))
51         GvSV(gv) = newSV(0);
52     return gv;
53 }
54 #endif
55
56 GV *
57 Perl_gv_AVadd(pTHX_ register GV *gv)
58 {
59     PERL_ARGS_ASSERT_GV_AVADD;
60
61     if (!gv || SvTYPE((SV*)gv) != SVt_PVGV)
62         Perl_croak(aTHX_ "Bad symbol for array");
63     if (!GvAV(gv))
64         GvAV(gv) = newAV();
65     return gv;
66 }
67
68 GV *
69 Perl_gv_HVadd(pTHX_ register GV *gv)
70 {
71     PERL_ARGS_ASSERT_GV_HVADD;
72
73     if (!gv || SvTYPE((SV*)gv) != SVt_PVGV)
74         Perl_croak(aTHX_ "Bad symbol for hash");
75     if (!GvHV(gv))
76         GvHV(gv) = newHV();
77     return gv;
78 }
79
80 GV *
81 Perl_gv_IOadd(pTHX_ register GV *gv)
82 {
83     dVAR;
84
85     PERL_ARGS_ASSERT_GV_IOADD;
86
87     if (!gv || SvTYPE((SV*)gv) != SVt_PVGV) {
88
89         /*
90          * if it walks like a dirhandle, then let's assume that
91          * this is a dirhandle.
92          */
93         const char * const fh =
94                          PL_op->op_type ==  OP_READDIR ||
95                          PL_op->op_type ==  OP_TELLDIR ||
96                          PL_op->op_type ==  OP_SEEKDIR ||
97                          PL_op->op_type ==  OP_REWINDDIR ||
98                          PL_op->op_type ==  OP_CLOSEDIR ?
99                          "dirhandle" : "filehandle";
100         Perl_croak(aTHX_ "Bad symbol for %s", fh);
101     }
102
103     if (!GvIOp(gv)) {
104 #ifdef GV_UNIQUE_CHECK
105         if (GvUNIQUE(gv)) {
106             Perl_croak(aTHX_ "Bad symbol for filehandle (GV is unique)");
107         }
108 #endif
109         GvIOp(gv) = newIO();
110     }
111     return gv;
112 }
113
114 GV *
115 Perl_gv_fetchfile(pTHX_ const char *name)
116 {
117     PERL_ARGS_ASSERT_GV_FETCHFILE;
118     return gv_fetchfile_flags(name, strlen(name), 0);
119 }
120
121 GV *
122 Perl_gv_fetchfile_flags(pTHX_ const char *const name, const STRLEN namelen,
123                         const U32 flags)
124 {
125     dVAR;
126     char smallbuf[128];
127     char *tmpbuf;
128     const STRLEN tmplen = namelen + 2;
129     GV *gv;
130
131     PERL_ARGS_ASSERT_GV_FETCHFILE_FLAGS;
132     PERL_UNUSED_ARG(flags);
133
134     if (!PL_defstash)
135         return NULL;
136
137     if (tmplen <= sizeof smallbuf)
138         tmpbuf = smallbuf;
139     else
140         Newx(tmpbuf, tmplen, char);
141     /* This is where the debugger's %{"::_<$filename"} hash is created */
142     tmpbuf[0] = '_';
143     tmpbuf[1] = '<';
144     memcpy(tmpbuf + 2, name, namelen);
145     gv = *(GV**)hv_fetch(PL_defstash, tmpbuf, tmplen, TRUE);
146     if (!isGV(gv)) {
147         gv_init(gv, PL_defstash, tmpbuf, tmplen, FALSE);
148 #ifdef PERL_DONT_CREATE_GVSV
149         GvSV(gv) = newSVpvn(name, namelen);
150 #else
151         sv_setpvn(GvSV(gv), name, namelen);
152 #endif
153         if (PERLDB_LINE)
154             hv_magic(GvHVn(gv_AVadd(gv)), NULL, PERL_MAGIC_dbfile);
155     }
156     if (tmpbuf != smallbuf)
157         Safefree(tmpbuf);
158     return gv;
159 }
160
161 /*
162 =for apidoc gv_const_sv
163
164 If C<gv> is a typeglob whose subroutine entry is a constant sub eligible for
165 inlining, or C<gv> is a placeholder reference that would be promoted to such
166 a typeglob, then returns the value returned by the sub.  Otherwise, returns
167 NULL.
168
169 =cut
170 */
171
172 SV *
173 Perl_gv_const_sv(pTHX_ GV *gv)
174 {
175     PERL_ARGS_ASSERT_GV_CONST_SV;
176
177     if (SvTYPE(gv) == SVt_PVGV)
178         return cv_const_sv(GvCVu(gv));
179     return SvROK(gv) ? SvRV(gv) : NULL;
180 }
181
182 GP *
183 Perl_newGP(pTHX_ GV *const gv)
184 {
185     GP *gp;
186     U32 hash;
187 #ifdef USE_ITHREADS
188     const char *const file
189         = (PL_curcop && CopFILE(PL_curcop)) ? CopFILE(PL_curcop) : "";
190     const STRLEN len = strlen(file);
191 #else
192     SV *const temp_sv = CopFILESV(PL_curcop);
193     const char *file;
194     STRLEN len;
195
196     PERL_ARGS_ASSERT_NEWGP;
197
198     if (temp_sv) {
199         file = SvPVX(temp_sv);
200         len = SvCUR(temp_sv);
201     } else {
202         file = "";
203         len = 0;
204     }
205 #endif
206
207     PERL_HASH(hash, file, len);
208
209     Newxz(gp, 1, GP);
210
211 #ifndef PERL_DONT_CREATE_GVSV
212     gp->gp_sv = newSV(0);
213 #endif
214
215     gp->gp_line = PL_curcop ? CopLINE(PL_curcop) : 0;
216     /* XXX Ideally this cast would be replaced with a change to const char*
217        in the struct.  */
218     gp->gp_file_hek = share_hek(file, len, hash);
219     gp->gp_egv = gv;
220     gp->gp_refcnt = 1;
221
222     return gp;
223 }
224
225 void
226 Perl_gv_init(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, int multi)
227 {
228     dVAR;
229     const U32 old_type = SvTYPE(gv);
230     const bool doproto = old_type > SVt_NULL;
231     char * const proto = (doproto && SvPOK(gv)) ? SvPVX(gv) : NULL;
232     const STRLEN protolen = proto ? SvCUR(gv) : 0;
233     SV *const has_constant = doproto && SvROK(gv) ? SvRV(gv) : NULL;
234     const U32 exported_constant = has_constant ? SvPCS_IMPORTED(gv) : 0;
235
236     PERL_ARGS_ASSERT_GV_INIT;
237     assert (!(proto && has_constant));
238
239     if (has_constant) {
240         /* The constant has to be a simple scalar type.  */
241         switch (SvTYPE(has_constant)) {
242         case SVt_PVAV:
243         case SVt_PVHV:
244         case SVt_PVCV:
245         case SVt_PVFM:
246         case SVt_PVIO:
247             Perl_croak(aTHX_ "Cannot convert a reference to %s to typeglob",
248                        sv_reftype(has_constant, 0));
249         default: NOOP;
250         }
251         SvRV_set(gv, NULL);
252         SvROK_off(gv);
253     }
254
255
256     if (old_type < SVt_PVGV) {
257         if (old_type >= SVt_PV)
258             SvCUR_set(gv, 0);
259         sv_upgrade((SV*)gv, SVt_PVGV);
260     }
261     if (SvLEN(gv)) {
262         if (proto) {
263             SvPV_set(gv, NULL);
264             SvLEN_set(gv, 0);
265             SvPOK_off(gv);
266         } else
267             Safefree(SvPVX_mutable(gv));
268     }
269     SvIOK_off(gv);
270     isGV_with_GP_on(gv);
271
272     GvGP(gv) = Perl_newGP(aTHX_ gv);
273     GvSTASH(gv) = stash;
274     if (stash)
275         Perl_sv_add_backref(aTHX_ (SV*)stash, (SV*)gv);
276     gv_name_set(gv, name, len, GV_ADD);
277     if (multi || doproto)              /* doproto means it _was_ mentioned */
278         GvMULTI_on(gv);
279     if (doproto) {                      /* Replicate part of newSUB here. */
280         ENTER;
281         if (has_constant) {
282             /* newCONSTSUB takes ownership of the reference from us.  */
283             GvCV(gv) = newCONSTSUB(stash, name, has_constant);
284             /* If this reference was a copy of another, then the subroutine
285                must have been "imported", by a Perl space assignment to a GV
286                from a reference to CV.  */
287             if (exported_constant)
288                 GvIMPORTED_CV_on(gv);
289         } else {
290             (void) start_subparse(0,0); /* Create empty CV in compcv. */
291             GvCV(gv) = PL_compcv;
292         }
293         LEAVE;
294
295         mro_method_changed_in(GvSTASH(gv)); /* sub Foo::bar($) { (shift) } sub ASDF::baz($); *ASDF::baz = \&Foo::bar */
296         CvGV(GvCV(gv)) = gv;
297         CvFILE_set_from_cop(GvCV(gv), PL_curcop);
298         CvSTASH(GvCV(gv)) = PL_curstash;
299         if (proto) {
300             sv_usepvn_flags((SV*)GvCV(gv), proto, protolen,
301                             SV_HAS_TRAILING_NUL);
302         }
303     }
304 }
305
306 STATIC void
307 S_gv_init_sv(pTHX_ GV *gv, const svtype sv_type)
308 {
309     PERL_ARGS_ASSERT_GV_INIT_SV;
310
311     switch (sv_type) {
312     case SVt_PVIO:
313         (void)GvIOn(gv);
314         break;
315     case SVt_PVAV:
316         (void)GvAVn(gv);
317         break;
318     case SVt_PVHV:
319         (void)GvHVn(gv);
320         break;
321 #ifdef PERL_DONT_CREATE_GVSV
322     case SVt_NULL:
323     case SVt_PVCV:
324     case SVt_PVFM:
325     case SVt_PVGV:
326         break;
327     default:
328         if(GvSVn(gv)) {
329             /* Work round what appears to be a bug in Sun C++ 5.8 2005/10/13
330                If we just cast GvSVn(gv) to void, it ignores evaluating it for
331                its side effect */
332         }
333 #endif
334     }
335 }
336
337 /*
338 =for apidoc gv_fetchmeth
339
340 Returns the glob with the given C<name> and a defined subroutine or
341 C<NULL>.  The glob lives in the given C<stash>, or in the stashes
342 accessible via @ISA and UNIVERSAL::.
343
344 The argument C<level> should be either 0 or -1.  If C<level==0>, as a
345 side-effect creates a glob with the given C<name> in the given C<stash>
346 which in the case of success contains an alias for the subroutine, and sets
347 up caching info for this glob.
348
349 This function grants C<"SUPER"> token as a postfix of the stash name. The
350 GV returned from C<gv_fetchmeth> may be a method cache entry, which is not
351 visible to Perl code.  So when calling C<call_sv>, you should not use
352 the GV directly; instead, you should use the method's CV, which can be
353 obtained from the GV with the C<GvCV> macro.
354
355 =cut
356 */
357
358 /* NOTE: No support for tied ISA */
359
360 GV *
361 Perl_gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level)
362 {
363     dVAR;
364     GV** gvp;
365     AV* linear_av;
366     SV** linear_svp;
367     SV* linear_sv;
368     HV* cstash;
369     GV* candidate = NULL;
370     CV* cand_cv = NULL;
371     CV* old_cv;
372     GV* topgv = NULL;
373     const char *hvname;
374     I32 create = (level >= 0) ? 1 : 0;
375     I32 items;
376     STRLEN packlen;
377     U32 topgen_cmp;
378
379     PERL_ARGS_ASSERT_GV_FETCHMETH;
380
381     /* UNIVERSAL methods should be callable without a stash */
382     if (!stash) {
383         create = 0;  /* probably appropriate */
384         if(!(stash = gv_stashpvs("UNIVERSAL", 0)))
385             return 0;
386     }
387
388     assert(stash);
389
390     hvname = HvNAME_get(stash);
391     if (!hvname)
392       Perl_croak(aTHX_ "Can't use anonymous symbol table for method lookup");
393
394     assert(hvname);
395     assert(name);
396
397     DEBUG_o( Perl_deb(aTHX_ "Looking for method %s in package %s\n",name,hvname) );
398
399     topgen_cmp = HvMROMETA(stash)->cache_gen + PL_sub_generation;
400
401     /* check locally for a real method or a cache entry */
402     gvp = (GV**)hv_fetch(stash, name, len, create);
403     if(gvp) {
404         topgv = *gvp;
405         assert(topgv);
406         if (SvTYPE(topgv) != SVt_PVGV)
407             gv_init(topgv, stash, name, len, TRUE);
408         if ((cand_cv = GvCV(topgv))) {
409             /* If genuine method or valid cache entry, use it */
410             if (!GvCVGEN(topgv) || GvCVGEN(topgv) == topgen_cmp) {
411                 return topgv;
412             }
413             else {
414                 /* stale cache entry, junk it and move on */
415                 SvREFCNT_dec(cand_cv);
416                 GvCV(topgv) = cand_cv = NULL;
417                 GvCVGEN(topgv) = 0;
418             }
419         }
420         else if (GvCVGEN(topgv) == topgen_cmp) {
421             /* cache indicates no such method definitively */
422             return 0;
423         }
424     }
425
426     packlen = HvNAMELEN_get(stash);
427     if (packlen >= 7 && strEQ(hvname + packlen - 7, "::SUPER")) {
428         HV* basestash;
429         packlen -= 7;
430         basestash = gv_stashpvn(hvname, packlen, GV_ADD);
431         linear_av = mro_get_linear_isa(basestash);
432     }
433     else {
434         linear_av = mro_get_linear_isa(stash); /* has ourselves at the top of the list */
435     }
436
437     linear_svp = AvARRAY(linear_av) + 1; /* skip over self */
438     items = AvFILLp(linear_av); /* no +1, to skip over self */
439     while (items--) {
440         linear_sv = *linear_svp++;
441         assert(linear_sv);
442         cstash = gv_stashsv(linear_sv, 0);
443
444         if (!cstash) {
445             if (ckWARN(WARN_SYNTAX))
446                 Perl_warner(aTHX_ packWARN(WARN_SYNTAX), "Can't locate package %"SVf" for @%s::ISA",
447                     SVfARG(linear_sv), hvname);
448             continue;
449         }
450
451         assert(cstash);
452
453         gvp = (GV**)hv_fetch(cstash, name, len, 0);
454         if (!gvp) continue;
455         candidate = *gvp;
456         assert(candidate);
457         if (SvTYPE(candidate) != SVt_PVGV) gv_init(candidate, cstash, name, len, TRUE);
458         if (SvTYPE(candidate) == SVt_PVGV && (cand_cv = GvCV(candidate)) && !GvCVGEN(candidate)) {
459             /*
460              * Found real method, cache method in topgv if:
461              *  1. topgv has no synonyms (else inheritance crosses wires)
462              *  2. method isn't a stub (else AUTOLOAD fails spectacularly)
463              */
464             if (topgv && (GvREFCNT(topgv) == 1) && (CvROOT(cand_cv) || CvXSUB(cand_cv))) {
465                   if ((old_cv = GvCV(topgv))) SvREFCNT_dec(old_cv);
466                   SvREFCNT_inc_simple_void_NN(cand_cv);
467                   GvCV(topgv) = cand_cv;
468                   GvCVGEN(topgv) = topgen_cmp;
469             }
470             return candidate;
471         }
472     }
473
474     /* Check UNIVERSAL without caching */
475     if(level == 0 || level == -1) {
476         candidate = gv_fetchmeth(NULL, name, len, 1);
477         if(candidate) {
478             cand_cv = GvCV(candidate);
479             if (topgv && (GvREFCNT(topgv) == 1) && (CvROOT(cand_cv) || CvXSUB(cand_cv))) {
480                   if ((old_cv = GvCV(topgv))) SvREFCNT_dec(old_cv);
481                   SvREFCNT_inc_simple_void_NN(cand_cv);
482                   GvCV(topgv) = cand_cv;
483                   GvCVGEN(topgv) = topgen_cmp;
484             }
485             return candidate;
486         }
487     }
488
489     if (topgv && GvREFCNT(topgv) == 1) {
490         /* cache the fact that the method is not defined */
491         GvCVGEN(topgv) = topgen_cmp;
492     }
493
494     return 0;
495 }
496
497 /*
498 =for apidoc gv_fetchmeth_autoload
499
500 Same as gv_fetchmeth(), but looks for autoloaded subroutines too.
501 Returns a glob for the subroutine.
502
503 For an autoloaded subroutine without a GV, will create a GV even
504 if C<level < 0>.  For an autoloaded subroutine without a stub, GvCV()
505 of the result may be zero.
506
507 =cut
508 */
509
510 GV *
511 Perl_gv_fetchmeth_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level)
512 {
513     GV *gv = gv_fetchmeth(stash, name, len, level);
514
515     PERL_ARGS_ASSERT_GV_FETCHMETH_AUTOLOAD;
516
517     if (!gv) {
518         CV *cv;
519         GV **gvp;
520
521         if (!stash)
522             return NULL;        /* UNIVERSAL::AUTOLOAD could cause trouble */
523         if (len == S_autolen && memEQ(name, S_autoload, S_autolen))
524             return NULL;
525         if (!(gv = gv_fetchmeth(stash, S_autoload, S_autolen, FALSE)))
526             return NULL;
527         cv = GvCV(gv);
528         if (!(CvROOT(cv) || CvXSUB(cv)))
529             return NULL;
530         /* Have an autoload */
531         if (level < 0)  /* Cannot do without a stub */
532             gv_fetchmeth(stash, name, len, 0);
533         gvp = (GV**)hv_fetch(stash, name, len, (level >= 0));
534         if (!gvp)
535             return NULL;
536         return *gvp;
537     }
538     return gv;
539 }
540
541 /*
542 =for apidoc gv_fetchmethod_autoload
543
544 Returns the glob which contains the subroutine to call to invoke the method
545 on the C<stash>.  In fact in the presence of autoloading this may be the
546 glob for "AUTOLOAD".  In this case the corresponding variable $AUTOLOAD is
547 already setup.
548
549 The third parameter of C<gv_fetchmethod_autoload> determines whether
550 AUTOLOAD lookup is performed if the given method is not present: non-zero
551 means yes, look for AUTOLOAD; zero means no, don't look for AUTOLOAD.
552 Calling C<gv_fetchmethod> is equivalent to calling C<gv_fetchmethod_autoload>
553 with a non-zero C<autoload> parameter.
554
555 These functions grant C<"SUPER"> token as a prefix of the method name. Note
556 that if you want to keep the returned glob for a long time, you need to
557 check for it being "AUTOLOAD", since at the later time the call may load a
558 different subroutine due to $AUTOLOAD changing its value. Use the glob
559 created via a side effect to do this.
560
561 These functions have the same side-effects and as C<gv_fetchmeth> with
562 C<level==0>.  C<name> should be writable if contains C<':'> or C<'
563 ''>. The warning against passing the GV returned by C<gv_fetchmeth> to
564 C<call_sv> apply equally to these functions.
565
566 =cut
567 */
568
569 STATIC HV*
570 S_gv_get_super_pkg(pTHX_ const char* name, I32 namelen)
571 {
572     AV* superisa;
573     GV** gvp;
574     GV* gv;
575     HV* stash;
576
577     PERL_ARGS_ASSERT_GV_GET_SUPER_PKG;
578
579     stash = gv_stashpvn(name, namelen, 0);
580     if(stash) return stash;
581
582     /* If we must create it, give it an @ISA array containing
583        the real package this SUPER is for, so that it's tied
584        into the cache invalidation code correctly */
585     stash = gv_stashpvn(name, namelen, GV_ADD);
586     gvp = (GV**)hv_fetchs(stash, "ISA", TRUE);
587     gv = *gvp;
588     gv_init(gv, stash, "ISA", 3, TRUE);
589     superisa = GvAVn(gv);
590     GvMULTI_on(gv);
591     sv_magic((SV*)superisa, (SV*)gv, PERL_MAGIC_isa, NULL, 0);
592 #ifdef USE_ITHREADS
593     av_push(superisa, newSVpv(CopSTASHPV(PL_curcop), 0));
594 #else
595     av_push(superisa, newSVhek(CopSTASH(PL_curcop)
596                                ? HvNAME_HEK(CopSTASH(PL_curcop)) : NULL));
597 #endif
598
599     return stash;
600 }
601
602 GV *
603 Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload)
604 {
605     PERL_ARGS_ASSERT_GV_FETCHMETHOD_AUTOLOAD;
606
607     return gv_fetchmethod_flags(stash, name, autoload ? GV_AUTOLOAD : 0);
608 }
609
610 /* Don't merge this yet, as it's likely to get a len parameter, and possibly
611    even a U32 hash */
612 GV *
613 Perl_gv_fetchmethod_flags(pTHX_ HV *stash, const char *name, U32 flags)
614 {
615     dVAR;
616     register const char *nend;
617     const char *nsplit = NULL;
618     GV* gv;
619     HV* ostash = stash;
620     const char * const origname = name;
621     SV *const error_report = (SV *)stash;
622     const U32 autoload = flags & GV_AUTOLOAD;
623     const U32 do_croak = flags & GV_CROAK;
624
625     PERL_ARGS_ASSERT_GV_FETCHMETHOD_FLAGS;
626
627     if (SvTYPE(stash) < SVt_PVHV)
628         stash = NULL;
629     else {
630         /* The only way stash can become NULL later on is if nsplit is set,
631            which in turn means that there is no need for a SVt_PVHV case
632            the error reporting code.  */
633     }
634
635     for (nend = name; *nend; nend++) {
636         if (*nend == '\'') {
637             nsplit = nend;
638             name = nend + 1;
639         }
640         else if (*nend == ':' && *(nend + 1) == ':') {
641             nsplit = nend++;
642             name = nend + 1;
643         }
644     }
645     if (nsplit) {
646         if ((nsplit - origname) == 5 && memEQ(origname, "SUPER", 5)) {
647             /* ->SUPER::method should really be looked up in original stash */
648             SV * const tmpstr = sv_2mortal(Perl_newSVpvf(aTHX_ "%s::SUPER",
649                                                   CopSTASHPV(PL_curcop)));
650             /* __PACKAGE__::SUPER stash should be autovivified */
651             stash = gv_get_super_pkg(SvPVX_const(tmpstr), SvCUR(tmpstr));
652             DEBUG_o( Perl_deb(aTHX_ "Treating %s as %s::%s\n",
653                          origname, HvNAME_get(stash), name) );
654         }
655         else {
656             /* don't autovifify if ->NoSuchStash::method */
657             stash = gv_stashpvn(origname, nsplit - origname, 0);
658
659             /* however, explicit calls to Pkg::SUPER::method may
660                happen, and may require autovivification to work */
661             if (!stash && (nsplit - origname) >= 7 &&
662                 strnEQ(nsplit - 7, "::SUPER", 7) &&
663                 gv_stashpvn(origname, nsplit - origname - 7, 0))
664               stash = gv_get_super_pkg(origname, nsplit - origname);
665         }
666         ostash = stash;
667     }
668
669     gv = gv_fetchmeth(stash, name, nend - name, 0);
670     if (!gv) {
671         if (strEQ(name,"import") || strEQ(name,"unimport"))
672             gv = (GV*)&PL_sv_yes;
673         else if (autoload)
674             gv = gv_autoload4(ostash, name, nend - name, TRUE);
675         if (!gv && do_croak) {
676             /* Right now this is exclusively for the benefit of S_method_common
677                in pp_hot.c  */
678             if (stash) {
679                 Perl_croak(aTHX_
680                            "Can't locate object method \"%s\" via package \"%.*s\"",
681                            name, (int)HvNAMELEN_get(stash), HvNAME_get(stash));
682             }
683             else {
684                 STRLEN packlen;
685                 const char *packname;
686
687                 if (nsplit) {
688                     packlen = nsplit - origname;
689                     packname = origname;
690                 } else {
691                     packname = SvPV_const(error_report, packlen);
692                 }
693
694                 Perl_croak(aTHX_
695                            "Can't locate object method \"%s\" via package \"%.*s\""
696                            " (perhaps you forgot to load \"%.*s\"?)",
697                            name, (int)packlen, packname, (int)packlen, packname);
698             }
699         }
700     }
701     else if (autoload) {
702         CV* const cv = GvCV(gv);
703         if (!CvROOT(cv) && !CvXSUB(cv)) {
704             GV* stubgv;
705             GV* autogv;
706
707             if (CvANON(cv))
708                 stubgv = gv;
709             else {
710                 stubgv = CvGV(cv);
711                 if (GvCV(stubgv) != cv)         /* orphaned import */
712                     stubgv = gv;
713             }
714             autogv = gv_autoload4(GvSTASH(stubgv),
715                                   GvNAME(stubgv), GvNAMELEN(stubgv), TRUE);
716             if (autogv)
717                 gv = autogv;
718         }
719     }
720
721     return gv;
722 }
723
724 GV*
725 Perl_gv_autoload4(pTHX_ HV *stash, const char *name, STRLEN len, I32 method)
726 {
727     dVAR;
728     GV* gv;
729     CV* cv;
730     HV* varstash;
731     GV* vargv;
732     SV* varsv;
733     const char *packname = "";
734     STRLEN packname_len = 0;
735
736     PERL_ARGS_ASSERT_GV_AUTOLOAD4;
737
738     if (len == S_autolen && memEQ(name, S_autoload, S_autolen))
739         return NULL;
740     if (stash) {
741         if (SvTYPE(stash) < SVt_PVHV) {
742             packname = SvPV_const((SV*)stash, packname_len);
743             stash = NULL;
744         }
745         else {
746             packname = HvNAME_get(stash);
747             packname_len = HvNAMELEN_get(stash);
748         }
749     }
750     if (!(gv = gv_fetchmeth(stash, S_autoload, S_autolen, FALSE)))
751         return NULL;
752     cv = GvCV(gv);
753
754     if (!(CvROOT(cv) || CvXSUB(cv)))
755         return NULL;
756
757     /*
758      * Inheriting AUTOLOAD for non-methods works ... for now.
759      */
760     if (!method && (GvCVGEN(gv) || GvSTASH(gv) != stash)
761         && ckWARN2(WARN_DEPRECATED, WARN_SYNTAX)
762     )
763         Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
764           "Use of inherited AUTOLOAD for non-method %s::%.*s() is deprecated",
765              packname, (int)len, name);
766
767     if (CvISXSUB(cv)) {
768         /* rather than lookup/init $AUTOLOAD here
769          * only to have the XSUB do another lookup for $AUTOLOAD
770          * and split that value on the last '::',
771          * pass along the same data via some unused fields in the CV
772          */
773         CvSTASH(cv) = stash;
774         SvPV_set(cv, (char *)name); /* cast to lose constness warning */
775         SvCUR_set(cv, len);
776         return gv;
777     }
778
779     /*
780      * Given &FOO::AUTOLOAD, set $FOO::AUTOLOAD to desired function name.
781      * The subroutine's original name may not be "AUTOLOAD", so we don't
782      * use that, but for lack of anything better we will use the sub's
783      * original package to look up $AUTOLOAD.
784      */
785     varstash = GvSTASH(CvGV(cv));
786     vargv = *(GV**)hv_fetch(varstash, S_autoload, S_autolen, TRUE);
787     ENTER;
788
789     if (!isGV(vargv)) {
790         gv_init(vargv, varstash, S_autoload, S_autolen, FALSE);
791 #ifdef PERL_DONT_CREATE_GVSV
792         GvSV(vargv) = newSV(0);
793 #endif
794     }
795     LEAVE;
796     varsv = GvSVn(vargv);
797     sv_setpvn(varsv, packname, packname_len);
798     sv_catpvs(varsv, "::");
799     sv_catpvn(varsv, name, len);
800     return gv;
801 }
802
803
804 /* require_tie_mod() internal routine for requiring a module
805  * that implements the logic of automatical ties like %! and %-
806  *
807  * The "gv" parameter should be the glob.
808  * "varpv" holds the name of the var, used for error messages.
809  * "namesv" holds the module name. Its refcount will be decremented.
810  * "methpv" holds the method name to test for to check that things
811  *   are working reasonably close to as expected.
812  * "flags": if flag & 1 then save the scalar before loading.
813  * For the protection of $! to work (it is set by this routine)
814  * the sv slot must already be magicalized.
815  */
816 STATIC HV*
817 S_require_tie_mod(pTHX_ GV *gv, const char *varpv, SV* namesv, const char *methpv,const U32 flags)
818 {
819     dVAR;
820     HV* stash = gv_stashsv(namesv, 0);
821
822     PERL_ARGS_ASSERT_REQUIRE_TIE_MOD;
823
824     if (!stash || !(gv_fetchmethod(stash, methpv))) {
825         SV *module = newSVsv(namesv);
826         char varname = *varpv; /* varpv might be clobbered by load_module,
827                                   so save it. For the moment it's always
828                                   a single char. */
829         dSP;
830         ENTER;
831         if ( flags & 1 )
832             save_scalar(gv);
833         PUSHSTACKi(PERLSI_MAGIC);
834         Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT, module, NULL);
835         POPSTACK;
836         LEAVE;
837         SPAGAIN;
838         stash = gv_stashsv(namesv, 0);
839         if (!stash)
840             Perl_croak(aTHX_ "panic: Can't use %%%c because %"SVf" is not available",
841                     varname, SVfARG(namesv));
842         else if (!gv_fetchmethod(stash, methpv))
843             Perl_croak(aTHX_ "panic: Can't use %%%c because %"SVf" does not support method %s",
844                     varname, SVfARG(namesv), methpv);
845     }
846     SvREFCNT_dec(namesv);
847     return stash;
848 }
849
850 /*
851 =for apidoc gv_stashpv
852
853 Returns a pointer to the stash for a specified package.  Uses C<strlen> to
854 determine the length of C<name>, then calls C<gv_stashpvn()>.
855
856 =cut
857 */
858
859 HV*
860 Perl_gv_stashpv(pTHX_ const char *name, I32 create)
861 {
862     PERL_ARGS_ASSERT_GV_STASHPV;
863     return gv_stashpvn(name, strlen(name), create);
864 }
865
866 /*
867 =for apidoc gv_stashpvn
868
869 Returns a pointer to the stash for a specified package.  The C<namelen>
870 parameter indicates the length of the C<name>, in bytes.  C<flags> is passed
871 to C<gv_fetchpvn_flags()>, so if set to C<GV_ADD> then the package will be
872 created if it does not already exist.  If the package does not exist and
873 C<flags> is 0 (or any other setting that does not create packages) then NULL
874 is returned.
875
876
877 =cut
878 */
879
880 HV*
881 Perl_gv_stashpvn(pTHX_ const char *name, U32 namelen, I32 flags)
882 {
883     char smallbuf[128];
884     char *tmpbuf;
885     HV *stash;
886     GV *tmpgv;
887
888     PERL_ARGS_ASSERT_GV_STASHPVN;
889
890     if (namelen + 2 <= sizeof smallbuf)
891         tmpbuf = smallbuf;
892     else
893         Newx(tmpbuf, namelen + 2, char);
894     Copy(name,tmpbuf,namelen,char);
895     tmpbuf[namelen++] = ':';
896     tmpbuf[namelen++] = ':';
897     tmpgv = gv_fetchpvn_flags(tmpbuf, namelen, flags, SVt_PVHV);
898     if (tmpbuf != smallbuf)
899         Safefree(tmpbuf);
900     if (!tmpgv)
901         return NULL;
902     if (!GvHV(tmpgv))
903         GvHV(tmpgv) = newHV();
904     stash = GvHV(tmpgv);
905     if (!HvNAME_get(stash))
906         hv_name_set(stash, name, namelen, 0);
907     return stash;
908 }
909
910 /*
911 =for apidoc gv_stashsv
912
913 Returns a pointer to the stash for a specified package.  See C<gv_stashpvn>.
914
915 =cut
916 */
917
918 HV*
919 Perl_gv_stashsv(pTHX_ SV *sv, I32 flags)
920 {
921     STRLEN len;
922     const char * const ptr = SvPV_const(sv,len);
923
924     PERL_ARGS_ASSERT_GV_STASHSV;
925
926     return gv_stashpvn(ptr, len, flags);
927 }
928
929
930 GV *
931 Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 add, const svtype sv_type) {
932     PERL_ARGS_ASSERT_GV_FETCHPV;
933     return gv_fetchpvn_flags(nambeg, strlen(nambeg), add, sv_type);
934 }
935
936 GV *
937 Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type) {
938     STRLEN len;
939     const char * const nambeg = SvPV_const(name, len);
940     PERL_ARGS_ASSERT_GV_FETCHSV;
941     return gv_fetchpvn_flags(nambeg, len, flags | SvUTF8(name), sv_type);
942 }
943
944 GV *
945 Perl_gv_fetchpvn_flags(pTHX_ const char *nambeg, STRLEN full_len, I32 flags,
946                        const svtype sv_type)
947 {
948     dVAR;
949     register const char *name = nambeg;
950     register GV *gv = NULL;
951     GV**gvp;
952     I32 len;
953     register const char *name_cursor;
954     HV *stash = NULL;
955     const I32 no_init = flags & (GV_NOADD_NOINIT | GV_NOINIT);
956     const I32 no_expand = flags & GV_NOEXPAND;
957     const I32 add = flags & ~GV_NOADD_MASK;
958     const char *const name_end = nambeg + full_len;
959     const char *const name_em1 = name_end - 1;
960     U32 faking_it;
961
962     PERL_ARGS_ASSERT_GV_FETCHPVN_FLAGS;
963
964     if (flags & GV_NOTQUAL) {
965         /* Caller promised that there is no stash, so we can skip the check. */
966         len = full_len;
967         goto no_stash;
968     }
969
970     if (full_len > 2 && *name == '*' && isALPHA(name[1])) {
971         /* accidental stringify on a GV? */
972         name++;
973     }
974
975     for (name_cursor = name; name_cursor < name_end; name_cursor++) {
976         if ((*name_cursor == ':' && name_cursor < name_em1
977              && name_cursor[1] == ':')
978             || (*name_cursor == '\'' && name_cursor[1]))
979         {
980             if (!stash)
981                 stash = PL_defstash;
982             if (!stash || !SvREFCNT(stash)) /* symbol table under destruction */
983                 return NULL;
984
985             len = name_cursor - name;
986             if (len > 0) {
987                 char smallbuf[128];
988                 char *tmpbuf;
989
990                 if (len + 2 <= (I32)sizeof (smallbuf))
991                     tmpbuf = smallbuf;
992                 else
993                     Newx(tmpbuf, len+2, char);
994                 Copy(name, tmpbuf, len, char);
995                 tmpbuf[len++] = ':';
996                 tmpbuf[len++] = ':';
997                 gvp = (GV**)hv_fetch(stash,tmpbuf,len,add);
998                 gv = gvp ? *gvp : NULL;
999                 if (gv && gv != (GV*)&PL_sv_undef) {
1000                     if (SvTYPE(gv) != SVt_PVGV)
1001                         gv_init(gv, stash, tmpbuf, len, (add & GV_ADDMULTI));
1002                     else
1003                         GvMULTI_on(gv);
1004                 }
1005                 if (tmpbuf != smallbuf)
1006                     Safefree(tmpbuf);
1007                 if (!gv || gv == (GV*)&PL_sv_undef)
1008                     return NULL;
1009
1010                 if (!(stash = GvHV(gv)))
1011                     stash = GvHV(gv) = newHV();
1012
1013                 if (!HvNAME_get(stash))
1014                     hv_name_set(stash, nambeg, name_cursor - nambeg, 0);
1015             }
1016
1017             if (*name_cursor == ':')
1018                 name_cursor++;
1019             name_cursor++;
1020             name = name_cursor;
1021             if (name == name_end)
1022                 return gv ? gv : (GV*)*hv_fetchs(PL_defstash, "main::", TRUE);
1023         }
1024     }
1025     len = name_cursor - name;
1026
1027     /* No stash in name, so see how we can default */
1028
1029     if (!stash) {
1030     no_stash:
1031         if (len && isIDFIRST_lazy(name)) {
1032             bool global = FALSE;
1033
1034             switch (len) {
1035             case 1:
1036                 if (*name == '_')
1037                     global = TRUE;
1038                 break;
1039             case 3:
1040                 if ((name[0] == 'I' && name[1] == 'N' && name[2] == 'C')
1041                     || (name[0] == 'E' && name[1] == 'N' && name[2] == 'V')
1042                     || (name[0] == 'S' && name[1] == 'I' && name[2] == 'G'))
1043                     global = TRUE;
1044                 break;
1045             case 4:
1046                 if (name[0] == 'A' && name[1] == 'R' && name[2] == 'G'
1047                     && name[3] == 'V')
1048                     global = TRUE;
1049                 break;
1050             case 5:
1051                 if (name[0] == 'S' && name[1] == 'T' && name[2] == 'D'
1052                     && name[3] == 'I' && name[4] == 'N')
1053                     global = TRUE;
1054                 break;
1055             case 6:
1056                 if ((name[0] == 'S' && name[1] == 'T' && name[2] == 'D')
1057                     &&((name[3] == 'O' && name[4] == 'U' && name[5] == 'T')
1058                        ||(name[3] == 'E' && name[4] == 'R' && name[5] == 'R')))
1059                     global = TRUE;
1060                 break;
1061             case 7:
1062                 if (name[0] == 'A' && name[1] == 'R' && name[2] == 'G'
1063                     && name[3] == 'V' && name[4] == 'O' && name[5] == 'U'
1064                     && name[6] == 'T')
1065                     global = TRUE;
1066                 break;
1067             }
1068
1069             if (global)
1070                 stash = PL_defstash;
1071             else if (IN_PERL_COMPILETIME) {
1072                 stash = PL_curstash;
1073                 if (add && (PL_hints & HINT_STRICT_VARS) &&
1074                     sv_type != SVt_PVCV &&
1075                     sv_type != SVt_PVGV &&
1076                     sv_type != SVt_PVFM &&
1077                     sv_type != SVt_PVIO &&
1078                     !(len == 1 && sv_type == SVt_PV &&
1079                       (*name == 'a' || *name == 'b')) )
1080                 {
1081                     gvp = (GV**)hv_fetch(stash,name,len,0);
1082                     if (!gvp ||
1083                         *gvp == (GV*)&PL_sv_undef ||
1084                         SvTYPE(*gvp) != SVt_PVGV)
1085                     {
1086                         stash = NULL;
1087                     }
1088                     else if ((sv_type == SVt_PV   && !GvIMPORTED_SV(*gvp)) ||
1089                              (sv_type == SVt_PVAV && !GvIMPORTED_AV(*gvp)) ||
1090                              (sv_type == SVt_PVHV && !GvIMPORTED_HV(*gvp)) )
1091                     {
1092                         Perl_warn(aTHX_ "Variable \"%c%s\" is not imported",
1093                             sv_type == SVt_PVAV ? '@' :
1094                             sv_type == SVt_PVHV ? '%' : '$',
1095                             name);
1096                         if (GvCVu(*gvp))
1097                             Perl_warn(aTHX_ "\t(Did you mean &%s instead?)\n", name);
1098                         stash = NULL;
1099                     }
1100                 }
1101             }
1102             else
1103                 stash = CopSTASH(PL_curcop);
1104         }
1105         else
1106             stash = PL_defstash;
1107     }
1108
1109     /* By this point we should have a stash and a name */
1110
1111     if (!stash) {
1112         if (add) {
1113             SV * const err = Perl_mess(aTHX_
1114                  "Global symbol \"%s%s\" requires explicit package name",
1115                  (sv_type == SVt_PV ? "$"
1116                   : sv_type == SVt_PVAV ? "@"
1117                   : sv_type == SVt_PVHV ? "%"
1118                   : ""), name);
1119             GV *gv;
1120             if (USE_UTF8_IN_NAMES)
1121                 SvUTF8_on(err);
1122             qerror(err);
1123             gv = gv_fetchpvn_flags("<none>::", 8, GV_ADDMULTI, SVt_PVHV);
1124             if(!gv) {
1125                 /* symbol table under destruction */
1126                 return NULL;
1127             }   
1128             stash = GvHV(gv);
1129         }
1130         else
1131             return NULL;
1132     }
1133
1134     if (!SvREFCNT(stash))       /* symbol table under destruction */
1135         return NULL;
1136
1137     gvp = (GV**)hv_fetch(stash,name,len,add);
1138     if (!gvp || *gvp == (GV*)&PL_sv_undef)
1139         return NULL;
1140     gv = *gvp;
1141     if (SvTYPE(gv) == SVt_PVGV) {
1142         if (add) {
1143             GvMULTI_on(gv);
1144             gv_init_sv(gv, sv_type);
1145             if (len == 1 && (sv_type == SVt_PVHV || sv_type == SVt_PVGV)) {
1146                 if (*name == '!')
1147                     require_tie_mod(gv, "!", newSVpvs("Errno"), "TIEHASH", 1);
1148                 else if (*name == '-' || *name == '+')
1149                     require_tie_mod(gv, name, newSVpvs("Tie::Hash::NamedCapture"), "TIEHASH", 0);
1150             }
1151         }
1152         return gv;
1153     } else if (no_init) {
1154         return gv;
1155     } else if (no_expand && SvROK(gv)) {
1156         return gv;
1157     }
1158
1159     /* Adding a new symbol.
1160        Unless of course there was already something non-GV here, in which case
1161        we want to behave as if there was always a GV here, containing some sort
1162        of subroutine.
1163        Otherwise we run the risk of creating things like GvIO, which can cause
1164        subtle bugs. eg the one that tripped up SQL::Translator  */
1165
1166     faking_it = SvOK(gv);
1167
1168     if (add & GV_ADDWARN && ckWARN_d(WARN_INTERNAL))
1169         Perl_warner(aTHX_ packWARN(WARN_INTERNAL), "Had to create %s unexpectedly", nambeg);
1170     gv_init(gv, stash, name, len, add & GV_ADDMULTI);
1171     gv_init_sv(gv, faking_it ? SVt_PVCV : sv_type);
1172
1173     if (isALPHA(name[0]) && ! (isLEXWARN_on ? ckWARN(WARN_ONCE)
1174                                             : (PL_dowarn & G_WARN_ON ) ) )
1175         GvMULTI_on(gv) ;
1176
1177     /* set up magic where warranted */
1178     if (len > 1) {
1179 #ifndef EBCDIC
1180         if (*name > 'V' ) {
1181             NOOP;
1182             /* Nothing else to do.
1183                The compiler will probably turn the switch statement into a
1184                branch table. Make sure we avoid even that small overhead for
1185                the common case of lower case variable names.  */
1186         } else
1187 #endif
1188         {
1189             const char * const name2 = name + 1;
1190             switch (*name) {
1191             case 'A':
1192                 if (strEQ(name2, "RGV")) {
1193                     IoFLAGS(GvIOn(gv)) |= IOf_ARGV|IOf_START;
1194                 }
1195                 else if (strEQ(name2, "RGVOUT")) {
1196                     GvMULTI_on(gv);
1197                 }
1198                 break;
1199             case 'E':
1200                 if (strnEQ(name2, "XPORT", 5))
1201                     GvMULTI_on(gv);
1202                 break;
1203             case 'I':
1204                 if (strEQ(name2, "SA")) {
1205                     AV* const av = GvAVn(gv);
1206                     GvMULTI_on(gv);
1207                     sv_magic((SV*)av, (SV*)gv, PERL_MAGIC_isa, NULL, 0);
1208                     /* NOTE: No support for tied ISA */
1209                     if ((add & GV_ADDMULTI) && strEQ(nambeg,"AnyDBM_File::ISA")
1210                         && AvFILLp(av) == -1)
1211                         {
1212                             const char *pname;
1213                             av_push(av, newSVpvn(pname = "NDBM_File",9));
1214                             gv_stashpvn(pname, 9, GV_ADD);
1215                             av_push(av, newSVpvn(pname = "DB_File",7));
1216                             gv_stashpvn(pname, 7, GV_ADD);
1217                             av_push(av, newSVpvn(pname = "GDBM_File",9));
1218                             gv_stashpvn(pname, 9, GV_ADD);
1219                             av_push(av, newSVpvn(pname = "SDBM_File",9));
1220                             gv_stashpvn(pname, 9, GV_ADD);
1221                             av_push(av, newSVpvn(pname = "ODBM_File",9));
1222                             gv_stashpvn(pname, 9, GV_ADD);
1223                         }
1224                 }
1225                 break;
1226             case 'O':
1227                 if (strEQ(name2, "VERLOAD")) {
1228                     HV* const hv = GvHVn(gv);
1229                     GvMULTI_on(gv);
1230                     hv_magic(hv, NULL, PERL_MAGIC_overload);
1231                 }
1232                 break;
1233             case 'S':
1234                 if (strEQ(name2, "IG")) {
1235                     HV *hv;
1236                     I32 i;
1237                     if (!PL_psig_ptr) {
1238                         Newxz(PL_psig_ptr,  SIG_SIZE, SV*);
1239                         Newxz(PL_psig_name, SIG_SIZE, SV*);
1240                         Newxz(PL_psig_pend, SIG_SIZE, int);
1241                     }
1242                     GvMULTI_on(gv);
1243                     hv = GvHVn(gv);
1244                     hv_magic(hv, NULL, PERL_MAGIC_sig);
1245                     for (i = 1; i < SIG_SIZE; i++) {
1246                         SV * const * const init = hv_fetch(hv, PL_sig_name[i], strlen(PL_sig_name[i]), 1);
1247                         if (init)
1248                             sv_setsv(*init, &PL_sv_undef);
1249                         PL_psig_ptr[i] = 0;
1250                         PL_psig_name[i] = 0;
1251                         PL_psig_pend[i] = 0;
1252                     }
1253                 }
1254                 break;
1255             case 'V':
1256                 if (strEQ(name2, "ERSION"))
1257                     GvMULTI_on(gv);
1258                 break;
1259             case '\003':        /* $^CHILD_ERROR_NATIVE */
1260                 if (strEQ(name2, "HILD_ERROR_NATIVE"))
1261                     goto magicalize;
1262                 break;
1263             case '\005':        /* $^ENCODING */
1264                 if (strEQ(name2, "NCODING"))
1265                     goto magicalize;
1266                 break;
1267             case '\015':        /* $^MATCH */
1268                 if (strEQ(name2, "ATCH"))
1269                     goto magicalize;
1270             case '\017':        /* $^OPEN */
1271                 if (strEQ(name2, "PEN"))
1272                     goto magicalize;
1273                 break;
1274             case '\020':        /* $^PREMATCH  $^POSTMATCH */
1275                 if (strEQ(name2, "REMATCH") || strEQ(name2, "OSTMATCH"))
1276                     goto magicalize;  
1277             case '\024':        /* ${^TAINT} */
1278                 if (strEQ(name2, "AINT"))
1279                     goto ro_magicalize;
1280                 break;
1281             case '\025':        /* ${^UNICODE}, ${^UTF8LOCALE} */
1282                 if (strEQ(name2, "NICODE"))
1283                     goto ro_magicalize;
1284                 if (strEQ(name2, "TF8LOCALE"))
1285                     goto ro_magicalize;
1286                 if (strEQ(name2, "TF8CACHE"))
1287                     goto magicalize;
1288                 break;
1289             case '\027':        /* $^WARNING_BITS */
1290                 if (strEQ(name2, "ARNING_BITS"))
1291                     goto magicalize;
1292                 break;
1293             case '1':
1294             case '2':
1295             case '3':
1296             case '4':
1297             case '5':
1298             case '6':
1299             case '7':
1300             case '8':
1301             case '9':
1302             {
1303                 /* Ensures that we have an all-digit variable, ${"1foo"} fails
1304                    this test  */
1305                 /* This snippet is taken from is_gv_magical */
1306                 const char *end = name + len;
1307                 while (--end > name) {
1308                     if (!isDIGIT(*end)) return gv;
1309                 }
1310                 goto magicalize;
1311             }
1312             }
1313         }
1314     } else {
1315         /* Names of length 1.  (Or 0. But name is NUL terminated, so that will
1316            be case '\0' in this switch statement (ie a default case)  */
1317         switch (*name) {
1318         case '&':
1319         case '`':
1320         case '\'':
1321             if (
1322                 sv_type == SVt_PVAV ||
1323                 sv_type == SVt_PVHV ||
1324                 sv_type == SVt_PVCV ||
1325                 sv_type == SVt_PVFM ||
1326                 sv_type == SVt_PVIO
1327                 ) { break; }
1328             PL_sawampersand = TRUE;
1329             goto magicalize;
1330
1331         case ':':
1332             sv_setpv(GvSVn(gv),PL_chopset);
1333             goto magicalize;
1334
1335         case '?':
1336 #ifdef COMPLEX_STATUS
1337             SvUPGRADE(GvSVn(gv), SVt_PVLV);
1338 #endif
1339             goto magicalize;
1340
1341         case '!':
1342             GvMULTI_on(gv);
1343             /* If %! has been used, automatically load Errno.pm. */
1344
1345             sv_magic(GvSVn(gv), (SV*)gv, PERL_MAGIC_sv, name, len);
1346
1347             /* magicalization must be done before require_tie_mod is called */
1348             if (sv_type == SVt_PVHV || sv_type == SVt_PVGV)
1349                 require_tie_mod(gv, "!", newSVpvs("Errno"), "TIEHASH", 1);
1350
1351             break;
1352         case '-':
1353         case '+':
1354         GvMULTI_on(gv); /* no used once warnings here */
1355         {
1356             AV* const av = GvAVn(gv);
1357             SV* const avc = (*name == '+') ? (SV*)av : NULL;
1358
1359             sv_magic((SV*)av, avc, PERL_MAGIC_regdata, NULL, 0);
1360             sv_magic(GvSVn(gv), (SV*)gv, PERL_MAGIC_sv, name, len);
1361             if (avc)
1362                 SvREADONLY_on(GvSVn(gv));
1363             SvREADONLY_on(av);
1364
1365             if (sv_type == SVt_PVHV || sv_type == SVt_PVGV)
1366                 require_tie_mod(gv, name, newSVpvs("Tie::Hash::NamedCapture"), "TIEHASH", 0);
1367
1368             break;
1369         }
1370         case '*':
1371         case '#':
1372             if (sv_type == SVt_PV && ckWARN2_d(WARN_DEPRECATED, WARN_SYNTAX))
1373                 Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
1374                             "$%c is no longer supported", *name);
1375             break;
1376         case '|':
1377             sv_setiv(GvSVn(gv), (IV)(IoFLAGS(GvIOp(PL_defoutgv)) & IOf_FLUSH) != 0);
1378             goto magicalize;
1379
1380         case '\010':    /* $^H */
1381             {
1382                 HV *const hv = GvHVn(gv);
1383                 hv_magic(hv, NULL, PERL_MAGIC_hints);
1384             }
1385             goto magicalize;
1386         case '\023':    /* $^S */
1387         ro_magicalize:
1388             SvREADONLY_on(GvSVn(gv));
1389             /* FALL THROUGH */
1390         case '1':
1391         case '2':
1392         case '3':
1393         case '4':
1394         case '5':
1395         case '6':
1396         case '7':
1397         case '8':
1398         case '9':
1399         case '[':
1400         case '^':
1401         case '~':
1402         case '=':
1403         case '%':
1404         case '.':
1405         case '(':
1406         case ')':
1407         case '<':
1408         case '>':
1409         case ',':
1410         case '\\':
1411         case '/':
1412         case '\001':    /* $^A */
1413         case '\003':    /* $^C */
1414         case '\004':    /* $^D */
1415         case '\005':    /* $^E */
1416         case '\006':    /* $^F */
1417         case '\011':    /* $^I, NOT \t in EBCDIC */
1418         case '\016':    /* $^N */
1419         case '\017':    /* $^O */
1420         case '\020':    /* $^P */
1421         case '\024':    /* $^T */
1422         case '\027':    /* $^W */
1423         magicalize:
1424             sv_magic(GvSVn(gv), (SV*)gv, PERL_MAGIC_sv, name, len);
1425             break;
1426
1427         case '\014':    /* $^L */
1428             sv_setpvn(GvSVn(gv),"\f",1);
1429             PL_formfeed = GvSVn(gv);
1430             break;
1431         case ';':
1432             sv_setpvn(GvSVn(gv),"\034",1);
1433             break;
1434         case ']':
1435         {
1436             SV * const sv = GvSVn(gv);
1437             if (!sv_derived_from(PL_patchlevel, "version"))
1438                 upg_version(PL_patchlevel, TRUE);
1439             GvSV(gv) = vnumify(PL_patchlevel);
1440             SvREADONLY_on(GvSV(gv));
1441             SvREFCNT_dec(sv);
1442         }
1443         break;
1444         case '\026':    /* $^V */
1445         {
1446             SV * const sv = GvSVn(gv);
1447             GvSV(gv) = new_version(PL_patchlevel);
1448             SvREADONLY_on(GvSV(gv));
1449             SvREFCNT_dec(sv);
1450         }
1451         break;
1452         }
1453     }
1454     return gv;
1455 }
1456
1457 void
1458 Perl_gv_fullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain)
1459 {
1460     const char *name;
1461     STRLEN namelen;
1462     const HV * const hv = GvSTASH(gv);
1463
1464     PERL_ARGS_ASSERT_GV_FULLNAME4;
1465
1466     if (!hv) {
1467         SvOK_off(sv);
1468         return;
1469     }
1470     sv_setpv(sv, prefix ? prefix : "");
1471
1472     name = HvNAME_get(hv);
1473     if (name) {
1474         namelen = HvNAMELEN_get(hv);
1475     } else {
1476         name = "__ANON__";
1477         namelen = 8;
1478     }
1479
1480     if (keepmain || strNE(name, "main")) {
1481         sv_catpvn(sv,name,namelen);
1482         sv_catpvs(sv,"::");
1483     }
1484     sv_catpvn(sv,GvNAME(gv),GvNAMELEN(gv));
1485 }
1486
1487 void
1488 Perl_gv_efullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain)
1489 {
1490     const GV * const egv = GvEGV(gv);
1491
1492     PERL_ARGS_ASSERT_GV_EFULLNAME4;
1493
1494     gv_fullname4(sv, egv ? egv : gv, prefix, keepmain);
1495 }
1496
1497 IO *
1498 Perl_newIO(pTHX)
1499 {
1500     dVAR;
1501     GV *iogv;
1502     IO * const io = (IO*)newSV_type(SVt_PVIO);
1503     /* This used to read SvREFCNT(io) = 1;
1504        It's not clear why the reference count needed an explicit reset. NWC
1505     */
1506     assert (SvREFCNT(io) == 1);
1507     SvOBJECT_on(io);
1508     /* Clear the stashcache because a new IO could overrule a package name */
1509     hv_clear(PL_stashcache);
1510     iogv = gv_fetchpvs("FileHandle::", 0, SVt_PVHV);
1511     /* unless exists($main::{FileHandle}) and defined(%main::FileHandle::) */
1512     if (!(iogv && GvHV(iogv) && HvARRAY(GvHV(iogv))))
1513       iogv = gv_fetchpvs("IO::Handle::", GV_ADD, SVt_PVHV);
1514     SvSTASH_set(io, (HV*)SvREFCNT_inc(GvHV(iogv)));
1515     return io;
1516 }
1517
1518 void
1519 Perl_gv_check(pTHX_ const HV *stash)
1520 {
1521     dVAR;
1522     register I32 i;
1523
1524     PERL_ARGS_ASSERT_GV_CHECK;
1525
1526     if (!HvARRAY(stash))
1527         return;
1528     for (i = 0; i <= (I32) HvMAX(stash); i++) {
1529         const HE *entry;
1530         for (entry = HvARRAY(stash)[i]; entry; entry = HeNEXT(entry)) {
1531             register GV *gv;
1532             HV *hv;
1533             if (HeKEY(entry)[HeKLEN(entry)-1] == ':' &&
1534                 (gv = (GV*)HeVAL(entry)) && isGV(gv) && (hv = GvHV(gv)))
1535             {
1536                 if (hv != PL_defstash && hv != stash)
1537                      gv_check(hv);              /* nested package */
1538             }
1539             else if (isALPHA(*HeKEY(entry))) {
1540                 const char *file;
1541                 gv = (GV*)HeVAL(entry);
1542                 if (SvTYPE(gv) != SVt_PVGV || GvMULTI(gv))
1543                     continue;
1544                 file = GvFILE(gv);
1545                 CopLINE_set(PL_curcop, GvLINE(gv));
1546 #ifdef USE_ITHREADS
1547                 CopFILE(PL_curcop) = (char *)file;      /* set for warning */
1548 #else
1549                 CopFILEGV(PL_curcop)
1550                     = gv_fetchfile_flags(file, HEK_LEN(GvFILE_HEK(gv)), 0);
1551 #endif
1552                 Perl_warner(aTHX_ packWARN(WARN_ONCE),
1553                         "Name \"%s::%s\" used only once: possible typo",
1554                         HvNAME_get(stash), GvNAME(gv));
1555             }
1556         }
1557     }
1558 }
1559
1560 GV *
1561 Perl_newGVgen(pTHX_ const char *pack)
1562 {
1563     dVAR;
1564
1565     PERL_ARGS_ASSERT_NEWGVGEN;
1566
1567     return gv_fetchpv(Perl_form(aTHX_ "%s::_GEN_%ld", pack, (long)PL_gensym++),
1568                       GV_ADD, SVt_PVGV);
1569 }
1570
1571 /* hopefully this is only called on local symbol table entries */
1572
1573 GP*
1574 Perl_gp_ref(pTHX_ GP *gp)
1575 {
1576     dVAR;
1577     if (!gp)
1578         return NULL;
1579     gp->gp_refcnt++;
1580     if (gp->gp_cv) {
1581         if (gp->gp_cvgen) {
1582             /* If the GP they asked for a reference to contains
1583                a method cache entry, clear it first, so that we
1584                don't infect them with our cached entry */
1585             SvREFCNT_dec(gp->gp_cv);
1586             gp->gp_cv = NULL;
1587             gp->gp_cvgen = 0;
1588         }
1589     }
1590     return gp;
1591 }
1592
1593 void
1594 Perl_gp_free(pTHX_ GV *gv)
1595 {
1596     dVAR;
1597     GP* gp;
1598
1599     if (!gv || !isGV_with_GP(gv) || !(gp = GvGP(gv)))
1600         return;
1601     if (gp->gp_refcnt == 0) {
1602         if (ckWARN_d(WARN_INTERNAL))
1603             Perl_warner(aTHX_ packWARN(WARN_INTERNAL),
1604                         "Attempt to free unreferenced glob pointers"
1605                         pTHX__FORMAT pTHX__VALUE);
1606         return;
1607     }
1608     if (--gp->gp_refcnt > 0) {
1609         if (gp->gp_egv == gv)
1610             gp->gp_egv = 0;
1611         GvGP(gv) = 0;
1612         return;
1613     }
1614
1615     if (gp->gp_file_hek)
1616         unshare_hek(gp->gp_file_hek);
1617     SvREFCNT_dec(gp->gp_sv);
1618     SvREFCNT_dec(gp->gp_av);
1619     /* FIXME - another reference loop GV -> symtab -> GV ?
1620        Somehow gp->gp_hv can end up pointing at freed garbage.  */
1621     if (gp->gp_hv && SvTYPE(gp->gp_hv) == SVt_PVHV) {
1622         const char *hvname = HvNAME_get(gp->gp_hv);
1623         if (PL_stashcache && hvname)
1624             (void)hv_delete(PL_stashcache, hvname, HvNAMELEN_get(gp->gp_hv),
1625                       G_DISCARD);
1626         SvREFCNT_dec(gp->gp_hv);
1627     }
1628     SvREFCNT_dec(gp->gp_io);
1629     SvREFCNT_dec(gp->gp_cv);
1630     SvREFCNT_dec(gp->gp_form);
1631
1632     Safefree(gp);
1633     GvGP(gv) = 0;
1634 }
1635
1636 int
1637 Perl_magic_freeovrld(pTHX_ SV *sv, MAGIC *mg)
1638 {
1639     AMT * const amtp = (AMT*)mg->mg_ptr;
1640     PERL_UNUSED_ARG(sv);
1641
1642     PERL_ARGS_ASSERT_MAGIC_FREEOVRLD;
1643
1644     if (amtp && AMT_AMAGIC(amtp)) {
1645         int i;
1646         for (i = 1; i < NofAMmeth; i++) {
1647             CV * const cv = amtp->table[i];
1648             if (cv) {
1649                 SvREFCNT_dec((SV *) cv);
1650                 amtp->table[i] = NULL;
1651             }
1652         }
1653     }
1654  return 0;
1655 }
1656
1657 /* Updates and caches the CV's */
1658
1659 bool
1660 Perl_Gv_AMupdate(pTHX_ HV *stash)
1661 {
1662   dVAR;
1663   MAGIC* const mg = mg_find((SV*)stash, PERL_MAGIC_overload_table);
1664   AMT amt;
1665   const struct mro_meta* stash_meta = HvMROMETA(stash);
1666   U32 newgen;
1667
1668   PERL_ARGS_ASSERT_GV_AMUPDATE;
1669
1670   newgen = PL_sub_generation + stash_meta->pkg_gen + stash_meta->cache_gen;
1671   if (mg) {
1672       const AMT * const amtp = (AMT*)mg->mg_ptr;
1673       if (amtp->was_ok_am == PL_amagic_generation
1674           && amtp->was_ok_sub == newgen) {
1675           return (bool)AMT_OVERLOADED(amtp);
1676       }
1677       sv_unmagic((SV*)stash, PERL_MAGIC_overload_table);
1678   }
1679
1680   DEBUG_o( Perl_deb(aTHX_ "Recalcing overload magic in package %s\n",HvNAME_get(stash)) );
1681
1682   Zero(&amt,1,AMT);
1683   amt.was_ok_am = PL_amagic_generation;
1684   amt.was_ok_sub = newgen;
1685   amt.fallback = AMGfallNO;
1686   amt.flags = 0;
1687
1688   {
1689     int filled = 0, have_ovl = 0;
1690     int i, lim = 1;
1691
1692     /* Work with "fallback" key, which we assume to be first in PL_AMG_names */
1693
1694     /* Try to find via inheritance. */
1695     GV *gv = gv_fetchmeth(stash, PL_AMG_names[0], 2, -1);
1696     SV * const sv = gv ? GvSV(gv) : NULL;
1697     CV* cv;
1698
1699     if (!gv)
1700         lim = DESTROY_amg;              /* Skip overloading entries. */
1701 #ifdef PERL_DONT_CREATE_GVSV
1702     else if (!sv) {
1703         NOOP;   /* Equivalent to !SvTRUE and !SvOK  */
1704     }
1705 #endif
1706     else if (SvTRUE(sv))
1707         amt.fallback=AMGfallYES;
1708     else if (SvOK(sv))
1709         amt.fallback=AMGfallNEVER;
1710
1711     for (i = 1; i < lim; i++)
1712         amt.table[i] = NULL;
1713     for (; i < NofAMmeth; i++) {
1714         const char * const cooky = PL_AMG_names[i];
1715         /* Human-readable form, for debugging: */
1716         const char * const cp = (i >= DESTROY_amg ? cooky : AMG_id2name(i));
1717         const STRLEN l = PL_AMG_namelens[i];
1718
1719         DEBUG_o( Perl_deb(aTHX_ "Checking overloading of \"%s\" in package \"%.256s\"\n",
1720                      cp, HvNAME_get(stash)) );
1721         /* don't fill the cache while looking up!
1722            Creation of inheritance stubs in intermediate packages may
1723            conflict with the logic of runtime method substitution.
1724            Indeed, for inheritance A -> B -> C, if C overloads "+0",
1725            then we could have created stubs for "(+0" in A and C too.
1726            But if B overloads "bool", we may want to use it for
1727            numifying instead of C's "+0". */
1728         if (i >= DESTROY_amg)
1729             gv = Perl_gv_fetchmeth_autoload(aTHX_ stash, cooky, l, 0);
1730         else                            /* Autoload taken care of below */
1731             gv = Perl_gv_fetchmeth(aTHX_ stash, cooky, l, -1);
1732         cv = 0;
1733         if (gv && (cv = GvCV(gv))) {
1734             const char *hvname;
1735             if (GvNAMELEN(CvGV(cv)) == 3 && strEQ(GvNAME(CvGV(cv)), "nil")
1736                 && strEQ(hvname = HvNAME_get(GvSTASH(CvGV(cv))), "overload")) {
1737                 /* This is a hack to support autoloading..., while
1738                    knowing *which* methods were declared as overloaded. */
1739                 /* GvSV contains the name of the method. */
1740                 GV *ngv = NULL;
1741                 SV *gvsv = GvSV(gv);
1742
1743                 DEBUG_o( Perl_deb(aTHX_ "Resolving method \"%"SVf256\
1744                         "\" for overloaded \"%s\" in package \"%.256s\"\n",
1745                              (void*)GvSV(gv), cp, hvname) );
1746                 if (!gvsv || !SvPOK(gvsv)
1747                     || !(ngv = gv_fetchmethod_autoload(stash, SvPVX_const(gvsv),
1748                                                        FALSE)))
1749                 {
1750                     /* Can be an import stub (created by "can"). */
1751                     const char * const name = (gvsv && SvPOK(gvsv)) ?  SvPVX_const(gvsv) : "???";
1752                     Perl_croak(aTHX_ "%s method \"%.256s\" overloading \"%s\" "\
1753                                 "in package \"%.256s\"",
1754                                (GvCVGEN(gv) ? "Stub found while resolving"
1755                                 : "Can't resolve"),
1756                                name, cp, hvname);
1757                 }
1758                 cv = GvCV(gv = ngv);
1759             }
1760             DEBUG_o( Perl_deb(aTHX_ "Overloading \"%s\" in package \"%.256s\" via \"%.256s::%.256s\"\n",
1761                          cp, HvNAME_get(stash), HvNAME_get(GvSTASH(CvGV(cv))),
1762                          GvNAME(CvGV(cv))) );
1763             filled = 1;
1764             if (i < DESTROY_amg)
1765                 have_ovl = 1;
1766         } else if (gv) {                /* Autoloaded... */
1767             cv = (CV*)gv;
1768             filled = 1;
1769         }
1770         amt.table[i]=(CV*)SvREFCNT_inc_simple(cv);
1771     }
1772     if (filled) {
1773       AMT_AMAGIC_on(&amt);
1774       if (have_ovl)
1775           AMT_OVERLOADED_on(&amt);
1776       sv_magic((SV*)stash, 0, PERL_MAGIC_overload_table,
1777                                                 (char*)&amt, sizeof(AMT));
1778       return have_ovl;
1779     }
1780   }
1781   /* Here we have no table: */
1782   /* no_table: */
1783   AMT_AMAGIC_off(&amt);
1784   sv_magic((SV*)stash, 0, PERL_MAGIC_overload_table,
1785                                                 (char*)&amt, sizeof(AMTS));
1786   return FALSE;
1787 }
1788
1789
1790 CV*
1791 Perl_gv_handler(pTHX_ HV *stash, I32 id)
1792 {
1793     dVAR;
1794     MAGIC *mg;
1795     AMT *amtp;
1796     U32 newgen;
1797     struct mro_meta* stash_meta;
1798
1799     if (!stash || !HvNAME_get(stash))
1800         return NULL;
1801
1802     stash_meta = HvMROMETA(stash);
1803     newgen = PL_sub_generation + stash_meta->pkg_gen + stash_meta->cache_gen;
1804
1805     mg = mg_find((SV*)stash, PERL_MAGIC_overload_table);
1806     if (!mg) {
1807       do_update:
1808         Gv_AMupdate(stash);
1809         mg = mg_find((SV*)stash, PERL_MAGIC_overload_table);
1810     }
1811     assert(mg);
1812     amtp = (AMT*)mg->mg_ptr;
1813     if ( amtp->was_ok_am != PL_amagic_generation
1814          || amtp->was_ok_sub != newgen )
1815         goto do_update;
1816     if (AMT_AMAGIC(amtp)) {
1817         CV * const ret = amtp->table[id];
1818         if (ret && isGV(ret)) {         /* Autoloading stab */
1819             /* Passing it through may have resulted in a warning
1820                "Inherited AUTOLOAD for a non-method deprecated", since
1821                our caller is going through a function call, not a method call.
1822                So return the CV for AUTOLOAD, setting $AUTOLOAD. */
1823             GV * const gv = gv_fetchmethod(stash, PL_AMG_names[id]);
1824
1825             if (gv && GvCV(gv))
1826                 return GvCV(gv);
1827         }
1828         return ret;
1829     }
1830
1831     return NULL;
1832 }
1833
1834
1835 SV*
1836 Perl_amagic_call(pTHX_ SV *left, SV *right, int method, int flags)
1837 {
1838   dVAR;
1839   MAGIC *mg;
1840   CV *cv=NULL;
1841   CV **cvp=NULL, **ocvp=NULL;
1842   AMT *amtp=NULL, *oamtp=NULL;
1843   int off = 0, off1, lr = 0, notfound = 0;
1844   int postpr = 0, force_cpy = 0;
1845   int assign = AMGf_assign & flags;
1846   const int assignshift = assign ? 1 : 0;
1847 #ifdef DEBUGGING
1848   int fl=0;
1849 #endif
1850   HV* stash=NULL;
1851
1852   PERL_ARGS_ASSERT_AMAGIC_CALL;
1853
1854   if (!(AMGf_noleft & flags) && SvAMAGIC(left)
1855       && (stash = SvSTASH(SvRV(left)))
1856       && (mg = mg_find((SV*)stash, PERL_MAGIC_overload_table))
1857       && (ocvp = cvp = (AMT_AMAGIC((AMT*)mg->mg_ptr)
1858                         ? (oamtp = amtp = (AMT*)mg->mg_ptr)->table
1859                         : NULL))
1860       && ((cv = cvp[off=method+assignshift])
1861           || (assign && amtp->fallback > AMGfallNEVER && /* fallback to
1862                                                           * usual method */
1863                   (
1864 #ifdef DEBUGGING
1865                    fl = 1,
1866 #endif
1867                    cv = cvp[off=method])))) {
1868     lr = -1;                    /* Call method for left argument */
1869   } else {
1870     if (cvp && amtp->fallback > AMGfallNEVER && flags & AMGf_unary) {
1871       int logic;
1872
1873       /* look for substituted methods */
1874       /* In all the covered cases we should be called with assign==0. */
1875          switch (method) {
1876          case inc_amg:
1877            force_cpy = 1;
1878            if ((cv = cvp[off=add_ass_amg])
1879                || ((cv = cvp[off = add_amg]) && (force_cpy = 0, postpr = 1))) {
1880              right = &PL_sv_yes; lr = -1; assign = 1;
1881            }
1882            break;
1883          case dec_amg:
1884            force_cpy = 1;
1885            if ((cv = cvp[off = subtr_ass_amg])
1886                || ((cv = cvp[off = subtr_amg]) && (force_cpy = 0, postpr=1))) {
1887              right = &PL_sv_yes; lr = -1; assign = 1;
1888            }
1889            break;
1890          case bool__amg:
1891            (void)((cv = cvp[off=numer_amg]) || (cv = cvp[off=string_amg]));
1892            break;
1893          case numer_amg:
1894            (void)((cv = cvp[off=string_amg]) || (cv = cvp[off=bool__amg]));
1895            break;
1896          case string_amg:
1897            (void)((cv = cvp[off=numer_amg]) || (cv = cvp[off=bool__amg]));
1898            break;
1899          case not_amg:
1900            (void)((cv = cvp[off=bool__amg])
1901                   || (cv = cvp[off=numer_amg])
1902                   || (cv = cvp[off=string_amg]));
1903            postpr = 1;
1904            break;
1905          case copy_amg:
1906            {
1907              /*
1908                   * SV* ref causes confusion with the interpreter variable of
1909                   * the same name
1910                   */
1911              SV* const tmpRef=SvRV(left);
1912              if (!SvROK(tmpRef) && SvTYPE(tmpRef) <= SVt_PVMG) {
1913                 /*
1914                  * Just to be extra cautious.  Maybe in some
1915                  * additional cases sv_setsv is safe, too.
1916                  */
1917                 SV* const newref = newSVsv(tmpRef);
1918                 SvOBJECT_on(newref);
1919                 /* As a bit of a source compatibility hack, SvAMAGIC() and
1920                    friends dereference an RV, to behave the same was as when
1921                    overloading was stored on the reference, not the referant.
1922                    Hence we can't use SvAMAGIC_on()
1923                 */
1924                 SvFLAGS(newref) |= SVf_AMAGIC;
1925                 SvSTASH_set(newref, (HV*)SvREFCNT_inc(SvSTASH(tmpRef)));
1926                 return newref;
1927              }
1928            }
1929            break;
1930          case abs_amg:
1931            if ((cvp[off1=lt_amg] || cvp[off1=ncmp_amg])
1932                && ((cv = cvp[off=neg_amg]) || (cv = cvp[off=subtr_amg]))) {
1933              SV* const nullsv=sv_2mortal(newSViv(0));
1934              if (off1==lt_amg) {
1935                SV* const lessp = amagic_call(left,nullsv,
1936                                        lt_amg,AMGf_noright);
1937                logic = SvTRUE(lessp);
1938              } else {
1939                SV* const lessp = amagic_call(left,nullsv,
1940                                        ncmp_amg,AMGf_noright);
1941                logic = (SvNV(lessp) < 0);
1942              }
1943              if (logic) {
1944                if (off==subtr_amg) {
1945                  right = left;
1946                  left = nullsv;
1947                  lr = 1;
1948                }
1949              } else {
1950                return left;
1951              }
1952            }
1953            break;
1954          case neg_amg:
1955            if ((cv = cvp[off=subtr_amg])) {
1956              right = left;
1957              left = sv_2mortal(newSViv(0));
1958              lr = 1;
1959            }
1960            break;
1961          case int_amg:
1962          case iter_amg:                 /* XXXX Eventually should do to_gv. */
1963              /* FAIL safe */
1964              return NULL;       /* Delegate operation to standard mechanisms. */
1965              break;
1966          case to_sv_amg:
1967          case to_av_amg:
1968          case to_hv_amg:
1969          case to_gv_amg:
1970          case to_cv_amg:
1971              /* FAIL safe */
1972              return left;       /* Delegate operation to standard mechanisms. */
1973              break;
1974          default:
1975            goto not_found;
1976          }
1977          if (!cv) goto not_found;
1978     } else if (!(AMGf_noright & flags) && SvAMAGIC(right)
1979                && (stash = SvSTASH(SvRV(right)))
1980                && (mg = mg_find((SV*)stash, PERL_MAGIC_overload_table))
1981                && (cvp = (AMT_AMAGIC((AMT*)mg->mg_ptr)
1982                           ? (amtp = (AMT*)mg->mg_ptr)->table
1983                           : NULL))
1984                && (cv = cvp[off=method])) { /* Method for right
1985                                              * argument found */
1986       lr=1;
1987     } else if (((ocvp && oamtp->fallback > AMGfallNEVER
1988                  && (cvp=ocvp) && (lr = -1))
1989                 || (cvp && amtp->fallback > AMGfallNEVER && (lr=1)))
1990                && !(flags & AMGf_unary)) {
1991                                 /* We look for substitution for
1992                                  * comparison operations and
1993                                  * concatenation */
1994       if (method==concat_amg || method==concat_ass_amg
1995           || method==repeat_amg || method==repeat_ass_amg) {
1996         return NULL;            /* Delegate operation to string conversion */
1997       }
1998       off = -1;
1999       switch (method) {
2000          case lt_amg:
2001          case le_amg:
2002          case gt_amg:
2003          case ge_amg:
2004          case eq_amg:
2005          case ne_amg:
2006            postpr = 1; off=ncmp_amg; break;
2007          case slt_amg:
2008          case sle_amg:
2009          case sgt_amg:
2010          case sge_amg:
2011          case seq_amg:
2012          case sne_amg:
2013            postpr = 1; off=scmp_amg; break;
2014          }
2015       if (off != -1) cv = cvp[off];
2016       if (!cv) {
2017         goto not_found;
2018       }
2019     } else {
2020     not_found:                  /* No method found, either report or croak */
2021       switch (method) {
2022          case lt_amg:
2023          case le_amg:
2024          case gt_amg:
2025          case ge_amg:
2026          case eq_amg:
2027          case ne_amg:
2028          case slt_amg:
2029          case sle_amg:
2030          case sgt_amg:
2031          case sge_amg:
2032          case seq_amg:
2033          case sne_amg:
2034            postpr = 0; break;
2035          case to_sv_amg:
2036          case to_av_amg:
2037          case to_hv_amg:
2038          case to_gv_amg:
2039          case to_cv_amg:
2040              /* FAIL safe */
2041              return left;       /* Delegate operation to standard mechanisms. */
2042              break;
2043       }
2044       if (ocvp && (cv=ocvp[nomethod_amg])) { /* Call report method */
2045         notfound = 1; lr = -1;
2046       } else if (cvp && (cv=cvp[nomethod_amg])) {
2047         notfound = 1; lr = 1;
2048       } else if ((amtp && amtp->fallback >= AMGfallYES) && !DEBUG_o_TEST) {
2049         /* Skip generating the "no method found" message.  */
2050         return NULL;
2051       } else {
2052         SV *msg;
2053         if (off==-1) off=method;
2054         msg = sv_2mortal(Perl_newSVpvf(aTHX_
2055                       "Operation \"%s\": no method found,%sargument %s%s%s%s",
2056                       AMG_id2name(method + assignshift),
2057                       (flags & AMGf_unary ? " " : "\n\tleft "),
2058                       SvAMAGIC(left)?
2059                         "in overloaded package ":
2060                         "has no overloaded magic",
2061                       SvAMAGIC(left)?
2062                         HvNAME_get(SvSTASH(SvRV(left))):
2063                         "",
2064                       SvAMAGIC(right)?
2065                         ",\n\tright argument in overloaded package ":
2066                         (flags & AMGf_unary
2067                          ? ""
2068                          : ",\n\tright argument has no overloaded magic"),
2069                       SvAMAGIC(right)?
2070                         HvNAME_get(SvSTASH(SvRV(right))):
2071                         ""));
2072         if (amtp && amtp->fallback >= AMGfallYES) {
2073           DEBUG_o( Perl_deb(aTHX_ "%s", SvPVX_const(msg)) );
2074         } else {
2075           Perl_croak(aTHX_ "%"SVf, SVfARG(msg));
2076         }
2077         return NULL;
2078       }
2079       force_cpy = force_cpy || assign;
2080     }
2081   }
2082 #ifdef DEBUGGING
2083   if (!notfound) {
2084     DEBUG_o(Perl_deb(aTHX_
2085                      "Overloaded operator \"%s\"%s%s%s:\n\tmethod%s found%s in package %s%s\n",
2086                      AMG_id2name(off),
2087                      method+assignshift==off? "" :
2088                      " (initially \"",
2089                      method+assignshift==off? "" :
2090                      AMG_id2name(method+assignshift),
2091                      method+assignshift==off? "" : "\")",
2092                      flags & AMGf_unary? "" :
2093                      lr==1 ? " for right argument": " for left argument",
2094                      flags & AMGf_unary? " for argument" : "",
2095                      stash ? HvNAME_get(stash) : "null",
2096                      fl? ",\n\tassignment variant used": "") );
2097   }
2098 #endif
2099     /* Since we use shallow copy during assignment, we need
2100      * to dublicate the contents, probably calling user-supplied
2101      * version of copy operator
2102      */
2103     /* We need to copy in following cases:
2104      * a) Assignment form was called.
2105      *          assignshift==1,  assign==T, method + 1 == off
2106      * b) Increment or decrement, called directly.
2107      *          assignshift==0,  assign==0, method + 0 == off
2108      * c) Increment or decrement, translated to assignment add/subtr.
2109      *          assignshift==0,  assign==T,
2110      *          force_cpy == T
2111      * d) Increment or decrement, translated to nomethod.
2112      *          assignshift==0,  assign==0,
2113      *          force_cpy == T
2114      * e) Assignment form translated to nomethod.
2115      *          assignshift==1,  assign==T, method + 1 != off
2116      *          force_cpy == T
2117      */
2118     /*  off is method, method+assignshift, or a result of opcode substitution.
2119      *  In the latter case assignshift==0, so only notfound case is important.
2120      */
2121   if (( (method + assignshift == off)
2122         && (assign || (method == inc_amg) || (method == dec_amg)))
2123       || force_cpy)
2124     RvDEEPCP(left);
2125   {
2126     dSP;
2127     BINOP myop;
2128     SV* res;
2129     const bool oldcatch = CATCH_GET;
2130
2131     CATCH_SET(TRUE);
2132     Zero(&myop, 1, BINOP);
2133     myop.op_last = (OP *) &myop;
2134     myop.op_next = NULL;
2135     myop.op_flags = OPf_WANT_SCALAR | OPf_STACKED;
2136
2137     PUSHSTACKi(PERLSI_OVERLOAD);
2138     ENTER;
2139     SAVEOP();
2140     PL_op = (OP *) &myop;
2141     if (PERLDB_SUB && PL_curstash != PL_debstash)
2142         PL_op->op_private |= OPpENTERSUB_DB;
2143     PUTBACK;
2144     pp_pushmark();
2145
2146     EXTEND(SP, notfound + 5);
2147     PUSHs(lr>0? right: left);
2148     PUSHs(lr>0? left: right);
2149     PUSHs( lr > 0 ? &PL_sv_yes : ( assign ? &PL_sv_undef : &PL_sv_no ));
2150     if (notfound) {
2151       PUSHs(newSVpvn_flags(AMG_id2name(method + assignshift),
2152                            AMG_id2namelen(method + assignshift), SVs_TEMP));
2153     }
2154     PUSHs((SV*)cv);
2155     PUTBACK;
2156
2157     if ((PL_op = Perl_pp_entersub(aTHX)))
2158       CALLRUNOPS(aTHX);
2159     LEAVE;
2160     SPAGAIN;
2161
2162     res=POPs;
2163     PUTBACK;
2164     POPSTACK;
2165     CATCH_SET(oldcatch);
2166
2167     if (postpr) {
2168       int ans;
2169       switch (method) {
2170       case le_amg:
2171       case sle_amg:
2172         ans=SvIV(res)<=0; break;
2173       case lt_amg:
2174       case slt_amg:
2175         ans=SvIV(res)<0; break;
2176       case ge_amg:
2177       case sge_amg:
2178         ans=SvIV(res)>=0; break;
2179       case gt_amg:
2180       case sgt_amg:
2181         ans=SvIV(res)>0; break;
2182       case eq_amg:
2183       case seq_amg:
2184         ans=SvIV(res)==0; break;
2185       case ne_amg:
2186       case sne_amg:
2187         ans=SvIV(res)!=0; break;
2188       case inc_amg:
2189       case dec_amg:
2190         SvSetSV(left,res); return left;
2191       case not_amg:
2192         ans=!SvTRUE(res); break;
2193       default:
2194         ans=0; break;
2195       }
2196       return boolSV(ans);
2197     } else if (method==copy_amg) {
2198       if (!SvROK(res)) {
2199         Perl_croak(aTHX_ "Copy method did not return a reference");
2200       }
2201       return SvREFCNT_inc(SvRV(res));
2202     } else {
2203       return res;
2204     }
2205   }
2206 }
2207
2208 /*
2209 =for apidoc is_gv_magical_sv
2210
2211 Returns C<TRUE> if given the name of a magical GV. Calls is_gv_magical.
2212
2213 =cut
2214 */
2215
2216 bool
2217 Perl_is_gv_magical_sv(pTHX_ SV *name, U32 flags)
2218 {
2219     STRLEN len;
2220     const char * const temp = SvPV_const(name, len);
2221
2222     PERL_ARGS_ASSERT_IS_GV_MAGICAL_SV;
2223
2224     return is_gv_magical(temp, len, flags);
2225 }
2226
2227 /*
2228 =for apidoc is_gv_magical
2229
2230 Returns C<TRUE> if given the name of a magical GV.
2231
2232 Currently only useful internally when determining if a GV should be
2233 created even in rvalue contexts.
2234
2235 C<flags> is not used at present but available for future extension to
2236 allow selecting particular classes of magical variable.
2237
2238 Currently assumes that C<name> is NUL terminated (as well as len being valid).
2239 This assumption is met by all callers within the perl core, which all pass
2240 pointers returned by SvPV.
2241
2242 =cut
2243 */
2244 bool
2245 Perl_is_gv_magical(pTHX_ const char *name, STRLEN len, U32 flags)
2246 {
2247     PERL_UNUSED_CONTEXT;
2248     PERL_UNUSED_ARG(flags);
2249
2250     PERL_ARGS_ASSERT_IS_GV_MAGICAL;
2251
2252     if (len > 1) {
2253         const char * const name1 = name + 1;
2254         switch (*name) {
2255         case 'I':
2256             if (len == 3 && name[1] == 'S' && name[2] == 'A')
2257                 goto yes;
2258             break;
2259         case 'O':
2260             if (len == 8 && strEQ(name1, "VERLOAD"))
2261                 goto yes;
2262             break;
2263         case 'S':
2264             if (len == 3 && name[1] == 'I' && name[2] == 'G')
2265                 goto yes;
2266             break;
2267             /* Using ${^...} variables is likely to be sufficiently rare that
2268                it seems sensible to avoid the space hit of also checking the
2269                length.  */
2270         case '\017':   /* ${^OPEN} */
2271             if (strEQ(name1, "PEN"))
2272                 goto yes;
2273             break;
2274         case '\024':   /* ${^TAINT} */
2275             if (strEQ(name1, "AINT"))
2276                 goto yes;
2277             break;
2278         case '\025':    /* ${^UNICODE} */
2279             if (strEQ(name1, "NICODE"))
2280                 goto yes;
2281             if (strEQ(name1, "TF8LOCALE"))
2282                 goto yes;
2283             break;
2284         case '\027':   /* ${^WARNING_BITS} */
2285             if (strEQ(name1, "ARNING_BITS"))
2286                 goto yes;
2287             break;
2288         case '1':
2289         case '2':
2290         case '3':
2291         case '4':
2292         case '5':
2293         case '6':
2294         case '7':
2295         case '8':
2296         case '9':
2297         {
2298             const char *end = name + len;
2299             while (--end > name) {
2300                 if (!isDIGIT(*end))
2301                     return FALSE;
2302             }
2303             goto yes;
2304         }
2305         }
2306     } else {
2307         /* Because we're already assuming that name is NUL terminated
2308            below, we can treat an empty name as "\0"  */
2309         switch (*name) {
2310         case '&':
2311         case '`':
2312         case '\'':
2313         case ':':
2314         case '?':
2315         case '!':
2316         case '-':
2317         case '#':
2318         case '[':
2319         case '^':
2320         case '~':
2321         case '=':
2322         case '%':
2323         case '.':
2324         case '(':
2325         case ')':
2326         case '<':
2327         case '>':
2328         case ',':
2329         case '\\':
2330         case '/':
2331         case '|':
2332         case '+':
2333         case ';':
2334         case ']':
2335         case '\001':   /* $^A */
2336         case '\003':   /* $^C */
2337         case '\004':   /* $^D */
2338         case '\005':   /* $^E */
2339         case '\006':   /* $^F */
2340         case '\010':   /* $^H */
2341         case '\011':   /* $^I, NOT \t in EBCDIC */
2342         case '\014':   /* $^L */
2343         case '\016':   /* $^N */
2344         case '\017':   /* $^O */
2345         case '\020':   /* $^P */
2346         case '\023':   /* $^S */
2347         case '\024':   /* $^T */
2348         case '\026':   /* $^V */
2349         case '\027':   /* $^W */
2350         case '1':
2351         case '2':
2352         case '3':
2353         case '4':
2354         case '5':
2355         case '6':
2356         case '7':
2357         case '8':
2358         case '9':
2359         yes:
2360             return TRUE;
2361         default:
2362             break;
2363         }
2364     }
2365     return FALSE;
2366 }
2367
2368 void
2369 Perl_gv_name_set(pTHX_ GV *gv, const char *name, U32 len, U32 flags)
2370 {
2371     dVAR;
2372     U32 hash;
2373
2374     PERL_ARGS_ASSERT_GV_NAME_SET;
2375     PERL_UNUSED_ARG(flags);
2376
2377     if (len > I32_MAX)
2378         Perl_croak(aTHX_ "panic: gv name too long (%"UVuf")", (UV) len);
2379
2380     if (!(flags & GV_ADD) && GvNAME_HEK(gv)) {
2381         unshare_hek(GvNAME_HEK(gv));
2382     }
2383
2384     PERL_HASH(hash, name, len);
2385     GvNAME_HEK(gv) = share_hek(name, len, hash);
2386 }
2387
2388 /*
2389  * Local variables:
2390  * c-indentation-style: bsd
2391  * c-basic-offset: 4
2392  * indent-tabs-mode: t
2393  * End:
2394  *
2395  * ex: set ts=8 sts=4 sw=4 noet:
2396  */