MM_Unix patch for use under CVS

[p5sagit/p5-mst-13.2.git] / gv.c

diff --git a/gv.c b/gv.c
index cc520d6..8bb1f10 100644 (file)
--- a/gv.c
+++ b/gv.c
@@ -212,8 +212,16 @@ I32 level;
            if (gv = gv_fetchmeth(lastchance, name, len,
                                  (level >= 0) ? level + 1 : level - 1)) {
          gotcha:
-               /* Use topgv for cache only if it has no synonyms */
-               if (topgv && GvREFCNT(topgv) == 1) {
+               /*
+                * Cache method in topgv if:
+                *  1. topgv has no synonyms (else inheritance crosses wires)
+                *  2. method isn't a stub (else AUTOLOAD fails spectacularly)
+                */
+               if (topgv &&
+                   GvREFCNT(topgv) == 1 &&
+                   (cv = GvCV(gv)) &&
+                   (CvROOT(cv) || CvXSUB(cv)))
+               {
                    if (cv = GvCV(topgv))
                        SvREFCNT_dec(cv);
                    GvCV(topgv) = (CV*)SvREFCNT_inc(GvCV(gv));
@@ -232,6 +240,15 @@ gv_fetchmethod(stash, name)
 HV* stash;
 char* name;
 {
+    return gv_fetchmethod_autoload(stash, name, TRUE);
+}
+
+GV *
+gv_fetchmethod_autoload(stash, name, autoload)
+HV* stash;
+char* name;
+I32 autoload;
+{
     register char *nend;
     char *nsplit = 0;
     GV* gv;
@@ -263,18 +280,38 @@ char* name;
     if (!gv) {
        if (strEQ(name,"import"))
            gv = (GV*)&sv_yes;
-       else
-           gv = gv_autoload(stash, name, nend - name);
+       else if (autoload)
+           gv = gv_autoload4(stash, name, nend - name, TRUE);
+    }
+    else if (autoload) {
+       CV* cv = GvCV(gv);
+       if (!CvROOT(cv) && !CvXSUB(cv)) {
+           GV* stubgv;
+           GV* autogv;
+
+           if (CvANON(cv))
+               stubgv = gv;
+           else {
+               stubgv = CvGV(cv);
+               if (GvCV(stubgv) != cv)         /* orphaned import */
+                   stubgv = gv;
+           }
+           autogv = gv_autoload4(GvSTASH(stubgv),
+                                 GvNAME(stubgv), GvNAMELEN(stubgv), TRUE);
+           if (autogv)
+               gv = autogv;
+       }
     }
 
     return gv;
 }
 
 GV*
-gv_autoload(stash, name, len)
+gv_autoload4(stash, name, len, method)
 HV* stash;
 char* name;
 STRLEN len;
+I32 method;
 {
     static char autoload[] = "AUTOLOAD";
     static STRLEN autolen = 8;
@@ -286,11 +323,19 @@ STRLEN len;
 
     if (len == autolen && strnEQ(name, autoload, autolen))
        return Nullgv;
-    if (!(gv = gv_fetchmeth(stash, autoload, autolen, 0)))
+    if (!(gv = gv_fetchmeth(stash, autoload, autolen, FALSE)))
        return Nullgv;
     cv = GvCV(gv);
 
     /*
+     * Inheriting AUTOLOAD for non-methods works ... for now.
+     */
+    if (dowarn && !method && (GvCVGEN(gv) || GvSTASH(gv) != stash))
+       warn(
+         "Use of inherited AUTOLOAD for non-method %s::%.*s() is deprecated",
+            HvNAME(stash), (int)len, name);
+
+    /*
      * Given &FOO::AUTOLOAD, set $FOO::AUTOLOAD to desired function name.
      * The subroutine's original name may not be "AUTOLOAD", so we don't
      * use that, but for lack of anything better we will use the sub's
@@ -1029,11 +1074,10 @@ HV* stash;
                
                DEBUG_o( deb("Resolving method `%.256s' for overloaded `%s' in package `%.256s'\n", 
                             SvPV(GvSV(gv), na), cp, HvNAME(stash)) );
-               if (SvPOK(GvSV(gv)) 
-                   && (ngv = gv_fetchmethod(stash, SvPVX(GvSV(gv))))) {
-                   name = SvPVX(GvSV(gv));
-                   cv = GvCV(gv = ngv);
-               } else {
+               if (!SvPOK(GvSV(gv)) 
+                   || !(ngv = gv_fetchmethod_autoload(stash, SvPVX(GvSV(gv)),
+                                                      FALSE)))
+               {
                    /* Can be an import stub (created by `can'). */
                    if (GvCVGEN(gv)) {
                        croak("Stub found while resolving method `%.256s' overloading `%s' in package `%.256s'", 
@@ -1044,9 +1088,8 @@ HV* stash;
                              (SvPOK(GvSV(gv)) ?  SvPVX(GvSV(gv)) : "???" ),
                              cp, HvNAME(stash));
                }
-               /* If the sub is only a stub then we may have a gv to AUTOLOAD */
-               gv = (GV*)*hv_fetch(GvSTASH(gv), name, strlen(name), TRUE);
-               cv = GvCV(gv);
+               name = SvPVX(GvSV(gv));
+               cv = GvCV(gv = ngv);
            }
            DEBUG_o( deb("Overloading `%s' in package `%.256s' via `%.256s::%.256s' \n",
                         cp, HvNAME(stash), HvNAME(GvSTASH(CvGV(cv))),
@@ -1282,14 +1325,14 @@ int flags;
     dSP;
     BINOP myop;
     SV* res;
-    bool oldmustcatch = mustcatch;
+    bool oldcatch = CATCH_GET;
 
+    CATCH_SET(TRUE);
     Zero(&myop, 1, BINOP);
     myop.op_last = (OP *) &myop;
     myop.op_next = Nullop;
-    myop.op_flags = OPf_KNOW|OPf_STACKED;
+    myop.op_flags = OPf_WANT_SCALAR | OPf_STACKED;
 
-    mustcatch = TRUE;
     ENTER;
     SAVESPTR(op);
     op = (OP *) &myop;
@@ -1301,7 +1344,7 @@ int flags;
     EXTEND(sp, notfound + 5);
     PUSHs(lr>0? right: left);
     PUSHs(lr>0? left: right);
-    PUSHs( assign ? &sv_undef : (lr>0? &sv_yes: &sv_no));
+    PUSHs( lr > 0 ? &sv_yes : ( assign ? &sv_undef : &sv_no ));
     if (notfound) {
       PUSHs( sv_2mortal(newSVpv((char *)AMG_names[method + assignshift],0)) );
     }
@@ -1315,7 +1358,7 @@ int flags;
 
     res=POPs;
     PUTBACK;
-    mustcatch = oldmustcatch;
+    CATCH_SET(oldcatch);
 
     if (postpr) {
       int ans;
@@ -1344,7 +1387,7 @@ int flags;
       case not_amg:
        ans=!SvOK(res); break;
       }
-      return ans? &sv_yes: &sv_no;
+      return boolSV(ans);
     } else if (method==copy_amg) {
       if (!SvROK(res)) {
        croak("Copy method did not return a reference");