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