runtime support for interface ok,

whatever the final syntax ends up being.

R=ken
OCL=18414
CL=18414

diff --git a/src/cmd/gc/sys.go b/src/cmd/gc/sys.go
index 383f2bf7ecbc275e2ca64f2ccfd8636377de9e8f..d68d0283d7541d5d860619c1ab6d6f06a6a5dbbb 100644 (file)
--- a/src/cmd/gc/sys.go
+++ b/src/cmd/gc/sys.go
@@ -30,7 +30,9 @@ export func   arraystring(*[]byte) string;
 
 export func    ifaceT2I(sigi *byte, sigt *byte, elem any) (ret any);
 export func    ifaceI2T(sigt *byte, iface any) (ret any);
+export func    ifaceI2T2(sigt *byte, iface any) (ret any, ok bool);
 export func    ifaceI2I(sigi *byte, iface any) (ret any);
+export func    ifaceI2I2(sigi *byte, iface any) (ret any, ok bool);
 export func    ifaceeq(i1 any, i2 any) (ret bool);
 export func    reflect(i interface { }) (uint64, string);
 export func    unreflect(uint64, string) (ret interface { });

diff --git a/src/cmd/gc/sysimport.c b/src/cmd/gc/sysimport.c
index 195e6b4a151c4c59be67b04f8a8cf6a2a91378f2..750192ef37e73aa95e00375035ac64f2f2e2c68c 100644 (file)
--- a/src/cmd/gc/sysimport.c
+++ b/src/cmd/gc/sysimport.c
@@ -22,7 +22,9 @@ char *sysimport =
        "export func sys.arraystring (? *[]uint8) (? string)\n"
        "export func sys.ifaceT2I (sigi *uint8, sigt *uint8, elem any) (ret any)\n"
        "export func sys.ifaceI2T (sigt *uint8, iface any) (ret any)\n"
+       "export func sys.ifaceI2T2 (sigt *uint8, iface any) (ret any, ok bool)\n"
        "export func sys.ifaceI2I (sigi *uint8, iface any) (ret any)\n"
+       "export func sys.ifaceI2I2 (sigi *uint8, iface any) (ret any, ok bool)\n"
        "export func sys.ifaceeq (i1 any, i2 any) (ret bool)\n"
        "export func sys.reflect (i interface { }) (? uint64, ? string)\n"
        "export func sys.unreflect (? uint64, ? string) (ret interface { })\n"

diff --git a/src/runtime/iface.c b/src/runtime/iface.c
index c8355e8c15caa7b5e4a8d0dd32111186e44d7eed..10a4c53417b6b93f592c6313511e3dcb0336c868 100644 (file)
--- a/src/runtime/iface.c
+++ b/src/runtime/iface.c
@@ -238,8 +238,6 @@ sys·ifaceT2I(Sigi *si, Sigt *st, void *elem, Map *retim, void *retit)
 void
 sys·ifaceI2T(Sigt *st, Map *im, void *it, void *ret)
 {
-//     int32 alg, wid;
-
        if(debug) {
                prints("I2T sigt=");
                printsigt(st);
@@ -250,22 +248,44 @@ sys·ifaceI2T(Sigt *st, Map *im, void *it, void *ret)
 
        if(im == nil)
                throw("ifaceI2T: nil map");
-
        if(im->sigt != st)
                throw("ifaceI2T: wrong type");
-
-//     alg = st->hash;
-//     wid = st->offset;
-//     algarray[alg].copy(wid, &ret, &it);
        ret = it;
-
        if(debug) {
                prints("I2T ret=");
                sys·printpointer(ret);
                prints("\n");
        }
+       FLUSH(&ret);
+}
+
+// ifaceI2T2(sigt *byte, iface any) (ret any, ok bool);
+void
+sys·ifaceI2T2(Sigt *st, Map *im, void *it, void *ret, bool ok)
+{
+       if(debug) {
+               prints("I2T2 sigt=");
+               printsigt(st);
+               prints(" iface=");
+               printiface(im, it);
+               prints("\n");
+       }
 
+       if(im == nil || im->sigt != st) {
+               ret = 0;
+               ok = 0;
+       } else {
+               ret = it;
+               ok = 1;
+       }
+       if(debug) {
+               prints("I2T2 ret=");
+               sys·printpointer(ret);
+               sys·printbool(ok);
+               prints("\n");
+       }
        FLUSH(&ret);
+       FLUSH(&ok);
 }
 
 // ifaceI2I(sigi *byte, iface any) (ret any);
@@ -302,6 +322,49 @@ sys·ifaceI2I(Sigi *si, Map *im, void *it, Map *retim, void *retit)
        FLUSH(&retit);
 }
 
+// ifaceI2I2(sigi *byte, iface any) (ret any, ok bool);
+void
+sys·ifaceI2I2(Sigi *si, Map *im, void *it, Map *retim, void *retit, bool ok)
+{
+       if(debug) {
+               prints("I2I2 sigi=");
+               printsigi(si);
+               prints(" iface=");
+               printiface(im, it);
+               prints("\n");
+       }
+
+       if(im == nil) {
+               // If incoming interface is uninitialized (zeroed)
+               // make the outgoing interface zeroed as well.
+               retim = nil;
+               retit = nil;
+               ok = 1;
+       } else {
+               retit = it;
+               retim = im;
+               ok = 1;
+               if(im->sigi != si) {
+                       retim = hashmap(si, im->sigt, 1);
+                       if(retim == nil) {
+                               retit = nil;
+                               retim = nil;
+                               ok = 0;
+                       }
+               }
+       }
+
+       if(debug) {
+               prints("I2I ret=");
+               printiface(retim, retit);
+               prints("\n");
+       }
+
+       FLUSH(&retim);
+       FLUSH(&retit);
+       FLUSH(&ok);
+}
+
 // ifaceeq(i1 any, i2 any) (ret bool);
 void
 sys·ifaceeq(Map *im1, void *it1, Map *im2, void *it2, byte ret)