update reflection library to int/int32 etc. split

fmt still to come

R=rsc
DELTA=168  (141 added, 19 deleted, 8 changed)
OCL=18064
CL=18071

diff --git a/src/lib/reflect/cast_amd64.s b/src/lib/reflect/cast_amd64.s
index 1de31dd041373d40e7e1b4d228b4dc0cd1327f6a..ae04b8b32e8d35c86164c18a3f63cb63272df4b0 100644 (file)
--- a/src/lib/reflect/cast_amd64.s
+++ b/src/lib/reflect/cast_amd64.s
@@ -11,6 +11,16 @@ TEXT reflect·PtrAddrToAddr(SB),7,$-8
        MOVQ    AX, 16(SP)
        RET
 
+TEXT reflect·AddrToPtrInt(SB),7,$-8
+       MOVQ    8(SP), AX
+       MOVQ    AX, 16(SP)
+       RET
+
+TEXT reflect·PtrIntToAddr(SB),7,$-8
+       MOVQ    8(SP), AX
+       MOVQ    AX, 16(SP)
+       RET
+
 TEXT reflect·AddrToPtrInt8(SB),7,$-8
        MOVQ    8(SP), AX
        MOVQ    AX, 16(SP)
@@ -51,6 +61,16 @@ TEXT reflect·PtrInt64ToAddr(SB),7,$-8
        MOVQ    AX, 16(SP)
        RET
 
+TEXT reflect·AddrToPtrUint(SB),7,$-8
+       MOVQ    8(SP), AX
+       MOVQ    AX, 16(SP)
+       RET
+
+TEXT reflect·PtrUintToAddr(SB),7,$-8
+       MOVQ    8(SP), AX
+       MOVQ    AX, 16(SP)
+       RET
+
 TEXT reflect·AddrToPtrUint8(SB),7,$-8
        MOVQ    8(SP), AX
        MOVQ    AX, 16(SP)
@@ -91,6 +111,16 @@ TEXT reflect·PtrUint64ToAddr(SB),7,$-8
        MOVQ    AX, 16(SP)
        RET
 
+TEXT reflect·AddrToPtrFloat(SB),7,$-8
+       MOVQ    8(SP), AX
+       MOVQ    AX, 16(SP)
+       RET
+
+TEXT reflect·PtrFloatToAddr(SB),7,$-8
+       MOVQ    8(SP), AX
+       MOVQ    AX, 16(SP)
+       RET
+
 TEXT reflect·AddrToPtrFloat32(SB),7,$-8
        MOVQ    8(SP), AX
        MOVQ    AX, 16(SP)

diff --git a/src/lib/reflect/gencast.sh b/src/lib/reflect/gencast.sh
index e3871a5316358b27c8820d02b13bf214781787b7..d33bc11fb189666e589ea5ee5f68c17e77840d9d 100755 (executable)
--- a/src/lib/reflect/gencast.sh
+++ b/src/lib/reflect/gencast.sh
@@ -21,14 +21,17 @@ BEGIN {
 }
 ' > cast_$GOARCH.s << '!'
 Addr
+Int
 Int8
 Int16
 Int32
 Int64
+Uint
 Uint8
 Uint16
 Uint32
 Uint64
+Float
 Float32
 Float64
 Float80

diff --git a/src/lib/reflect/test.go b/src/lib/reflect/test.go
index d899929fe9dee07fd6c55619fd6c4d0c0b0c38d9..34acbda6e0cc4bc87890b1b088e64e23b9a13c37 100644 (file)
--- a/src/lib/reflect/test.go
+++ b/src/lib/reflect/test.go
@@ -49,6 +49,8 @@ func valuedump(s, t string) {
        typ := reflect.ParseTypeString("", s);
        v := reflect.NewInitValue(typ);
        switch v.Kind() {
+       case reflect.IntKind:
+               v.(reflect.IntValue).Put(132);
        case reflect.Int8Kind:
                v.(reflect.Int8Value).Put(8);
        case reflect.Int16Kind:
@@ -57,6 +59,8 @@ func valuedump(s, t string) {
                v.(reflect.Int32Value).Put(32);
        case reflect.Int64Kind:
                v.(reflect.Int64Value).Put(64);
+       case reflect.UintKind:
+               v.(reflect.UintValue).Put(132);
        case reflect.Uint8Kind:
                v.(reflect.Uint8Value).Put(8);
        case reflect.Uint16Kind:
@@ -65,6 +69,8 @@ func valuedump(s, t string) {
                v.(reflect.Uint32Value).Put(32);
        case reflect.Uint64Kind:
                v.(reflect.Uint64Value).Put(64);
+       case reflect.FloatKind:
+               v.(reflect.FloatValue).Put(3200.0);
        case reflect.Float32Kind:
                v.(reflect.Float32Value).Put(32.0);
        case reflect.Float64Kind:
@@ -83,14 +89,17 @@ func main() {
        var s string;
        var t reflect.Type;
 
+       typedump("int", "int");
        typedump("int8", "int8");
        typedump("int16", "int16");
        typedump("int32", "int32");
        typedump("int64", "int64");
+       typedump("uint", "uint");
        typedump("uint8", "uint8");
        typedump("uint16", "uint16");
        typedump("uint32", "uint32");
        typedump("uint64", "uint64");
+       typedump("float", "float");
        typedump("float32", "float32");
        typedump("float64", "float64");
        typedump("float80", "float80");
@@ -149,7 +158,7 @@ func main() {
                var i int = 7;
                var tmp = &T{123, 456.0, "hello", &i};
                value := reflect.NewValue(tmp);
-               assert(reflect.ValueToString(value.(reflect.PtrValue).Sub()), "main.T{123, +4.560000e+02, hello, *int32(@)}");
+               assert(reflect.ValueToString(value.(reflect.PtrValue).Sub()), "main.T{123, +4.560000e+02, hello, *int(@)}");
        }
        {
                type C chan *T; // TODO: should not be necessary
@@ -162,7 +171,7 @@ func main() {
                var tmp A = A{1,2,3,4,5,6,7,8,9,10};
                value := reflect.NewValue(&tmp);
                assert(reflect.ValueToString(value.(reflect.PtrValue).Sub()), "main.A_test{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}");
-               value.(reflect.PtrValue).Sub().(reflect.ArrayValue).Elem(4).(reflect.Int32Value).Put(123);
+               value.(reflect.PtrValue).Sub().(reflect.ArrayValue).Elem(4).(reflect.IntValue).Put(123);
                assert(reflect.ValueToString(value.(reflect.PtrValue).Sub()), "main.A_test{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}");
        }
        {
@@ -171,7 +180,7 @@ func main() {
                var tmp *AA = &tmp1;
                value := reflect.NewValue(tmp);
                assert(reflect.ValueToString(value.(reflect.PtrValue).Sub()), "main.AA_test{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}");
-               value.(reflect.PtrValue).Sub().(reflect.ArrayValue).Elem(4).(reflect.Int32Value).Put(123);
+               value.(reflect.PtrValue).Sub().(reflect.ArrayValue).Elem(4).(reflect.IntValue).Put(123);
                assert(reflect.ValueToString(value.(reflect.PtrValue).Sub()), "main.AA_test{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}");
        }
 }

diff --git a/src/lib/reflect/tostring.go b/src/lib/reflect/tostring.go
index 4b3ff78ca463072504d4e36d320a346f328738e2..767886a759dc2283342779d721b975f26b84778d 100644 (file)
--- a/src/lib/reflect/tostring.go
+++ b/src/lib/reflect/tostring.go
@@ -41,30 +41,11 @@ func TypeToString(typ Type, expand bool) string {
        switch(typ.Kind()) {
        case MissingKind:
                return "$missing$";
-       case Int8Kind:
-               return "int8";
-       case Int16Kind:
-               return "int16";
-       case Int32Kind:
-               return "int32";
-       case Int64Kind:
-               return "int64";
-       case Uint8Kind:
-               return "uint8";
-       case Uint16Kind:
-               return "uint16";
-       case Uint32Kind:
-               return "uint32";
-       case Uint64Kind:
-               return "uint64";
-       case Float32Kind:
-               return "float32";
-       case Float64Kind:
-               return "float64";
-       case Float80Kind:
-               return "float80";
-       case StringKind:
-               return "string";
+       case IntKind, Int8Kind, Int16Kind, Int32Kind, Int64Kind,
+            UintKind, Uint8Kind, Uint16Kind, Uint32Kind, Uint64Kind,
+            FloatKind, Float32Kind, Float64Kind, Float80Kind:
+            StringKind:
+               return typ.Name();
        case PtrKind:
                p := typ.(PtrType);
                return "*" + TypeToString(p.Sub(), false);
@@ -125,6 +106,8 @@ func ValueToString(val Value) string {
        switch(val.Kind()) {
        case MissingKind:
                return "missing";
+       case IntKind:
+               return integer(int64(val.(IntValue).Get()));
        case Int8Kind:
                return integer(int64(val.(Int8Value).Get()));
        case Int16Kind:
@@ -133,6 +116,8 @@ func ValueToString(val Value) string {
                return integer(int64(val.(Int32Value).Get()));
        case Int64Kind:
                return integer(int64(val.(Int64Value).Get()));
+       case UintKind:
+               return integer(int64(val.(UintValue).Get()));
        case Uint8Kind:
                return integer(int64(val.(Uint8Value).Get()));
        case Uint16Kind:
@@ -141,6 +126,8 @@ func ValueToString(val Value) string {
                return integer(int64(val.(Uint32Value).Get()));
        case Uint64Kind:
                return integer(int64(val.(Uint64Value).Get()));
+       case FloatKind:
+               return floatingpoint(float64(val.(FloatValue).Get()));
        case Float32Kind:
                return floatingpoint(float64(val.(Float32Value).Get()));
        case Float64Kind:

diff --git a/src/lib/reflect/type.go b/src/lib/reflect/type.go
index c70ad7990f5f5de196e7fa94e6bc68fd96d694fa..987c17138d387b10d52b1e3ee111609ae0b6d8b0 100644 (file)
--- a/src/lib/reflect/type.go
+++ b/src/lib/reflect/type.go
@@ -17,10 +17,12 @@ export const (
        MissingKind = iota;
        ArrayKind;
        ChanKind;
+       FloatKind;
        Float32Kind;
        Float64Kind;
        Float80Kind;
        FuncKind;
+       IntKind;
        Int16Kind;
        Int32Kind;
        Int64Kind;
@@ -30,6 +32,7 @@ export const (
        PtrKind;
        StringKind;
        StructKind;
+       UintKind;
        Uint16Kind;
        Uint32Kind;
        Uint64Kind;
@@ -79,14 +82,17 @@ func NewBasicType(name string, kind int, size uint64) Type {
 // Prebuilt basic types
 export var (
        Missing = NewBasicType(MissingString, MissingKind, 1);
+       Int = NewBasicType("int", IntKind, 4);  // TODO: need to know how big an int is
        Int8 = NewBasicType("int8", Int8Kind, 1);
        Int16 = NewBasicType("int16", Int16Kind, 2);
        Int32 = NewBasicType("int32", Int32Kind, 4);
        Int64 = NewBasicType("int64", Int64Kind, 8);
+       Uint = NewBasicType("uint", UintKind, 4);       // TODO: need to know how big a uint is
        Uint8 = NewBasicType("uint8", Uint8Kind, 1);
        Uint16 = NewBasicType("uint16", Uint16Kind, 2);
        Uint32 = NewBasicType("uint32", Uint32Kind, 4);
        Uint64 = NewBasicType("uint64", Uint64Kind, 8);
+       Float = NewBasicType("float", FloatKind, 4);    // TODO: need to know how big a float is
        Float32 = NewBasicType("float32", Float32Kind, 4);
        Float64 = NewBasicType("float64", Float64Kind, 8);
        Float80 = NewBasicType("float80", Float80Kind, 10);     // TODO: strange size?
@@ -387,14 +393,17 @@ func init() {
 
        // Basics go into types table
        types[MissingString] = &Missing;
+       types["int"] = ∬
        types["int8"] = &Int8;
        types["int16"] = &Int16;
        types["int32"] = &Int32;
        types["int64"] = &Int64;
+       types["uint"] = &Uint;
        types["uint8"] = &Uint8;
        types["uint16"] = &Uint16;
        types["uint32"] = &Uint32;
        types["uint64"] = &Uint64;
+       types["float"] = &Float;
        types["float32"] = &Float32;
        types["float64"] = &Float64;
        types["float80"] = &Float80;
@@ -403,14 +412,17 @@ func init() {
        // Basics get prebuilt stubs
        MissingStub = NewStubType(MissingString, Missing);
        basicstub[MissingString] = MissingStub;
+       basicstub["int"] = NewStubType("int", Int);
        basicstub["int8"] = NewStubType("int8", Int8);
        basicstub["int16"] = NewStubType("int16", Int16);
        basicstub["int32"] = NewStubType("int32", Int32);
        basicstub["int64"] = NewStubType("int64", Int64);
+       basicstub["uint"] = NewStubType("uint", Uint);
        basicstub["uint8"] = NewStubType("uint8", Uint8);
        basicstub["uint16"] = NewStubType("uint16", Uint16);
        basicstub["uint32"] = NewStubType("uint32", Uint32);
        basicstub["uint64"] = NewStubType("uint64", Uint64);
+       basicstub["float"] = NewStubType("float", Float);
        basicstub["float32"] = NewStubType("float32", Float32);
        basicstub["float64"] = NewStubType("float64", Float64);
        basicstub["float80"] = NewStubType("float80", Float80);

diff --git a/src/lib/reflect/value.go b/src/lib/reflect/value.go
index 890fd9bdb9a456d42250b71366430cf360b7a339..c39b1cb3e6a39b1bbe7d33c2d7331bce013d4378 100644 (file)
--- a/src/lib/reflect/value.go
+++ b/src/lib/reflect/value.go
@@ -41,21 +41,49 @@ type Creator *(typ Type, addr Addr) Value
 
 // Conversion functions, implemented in assembler
 func AddrToPtrAddr(Addr) *Addr
+func AddrToPtrInt(Addr) *int
 func AddrToPtrInt8(Addr) *int8
 func AddrToPtrInt16(Addr) *int16
 func AddrToPtrInt32(Addr) *int32
 func AddrToPtrInt64(Addr) *int64
+func AddrToPtrUint(Addr) *uint
 func AddrToPtrUint8(Addr) *uint8
 func PtrUint8ToAddr(*uint8) Addr
 func AddrToPtrUint16(Addr) *uint16
 func AddrToPtrUint32(Addr) *uint32
 func AddrToPtrUint64(Addr) *uint64
 func PtrUint64ToAddr(*uint64) Addr
+func AddrToPtrFloat(Addr) *float
 func AddrToPtrFloat32(Addr) *float32
 func AddrToPtrFloat64(Addr) *float64
 func AddrToPtrFloat80(Addr) *float80
 func AddrToPtrString(Addr) *string
 
+// -- Int
+
+export type IntValue interface {
+       Kind()  int;
+       Get()   int;
+       Put(int);
+       Type()  Type;
+}
+
+type IntValueStruct struct {
+       CommonV
+}
+
+func IntCreator(typ Type, addr Addr) Value {
+       return &IntValueStruct{ CommonV{IntKind, typ, addr} }
+}
+
+func (v *IntValueStruct) Get() int {
+       return *AddrToPtrInt(v.addr)
+}
+
+func (v *IntValueStruct) Put(i int) {
+       *AddrToPtrInt(v.addr) = i
+}
+
 // -- Int8
 
 export type Int8Value interface {
@@ -156,6 +184,31 @@ func (v *Int64ValueStruct) Put(i int64) {
        *AddrToPtrInt64(v.addr) = i
 }
 
+// -- Uint
+
+export type UintValue interface {
+       Kind()  int;
+       Get()   uint;
+       Put(uint);
+       Type()  Type;
+}
+
+type UintValueStruct struct {
+       CommonV
+}
+
+func UintCreator(typ Type, addr Addr) Value {
+       return &UintValueStruct{ CommonV{UintKind, typ, addr} }
+}
+
+func (v *UintValueStruct) Get() uint {
+       return *AddrToPtrUint(v.addr)
+}
+
+func (v *UintValueStruct) Put(i uint) {
+       *AddrToPtrUint(v.addr) = i
+}
+
 // -- Uint8
 
 export type Uint8Value interface {
@@ -256,6 +309,31 @@ func (v *Uint64ValueStruct) Put(i uint64) {
        *AddrToPtrUint64(v.addr) = i
 }
 
+// -- Float
+
+export type FloatValue interface {
+       Kind()  int;
+       Get()   float;
+       Put(float);
+       Type()  Type;
+}
+
+type FloatValueStruct struct {
+       CommonV
+}
+
+func FloatCreator(typ Type, addr Addr) Value {
+       return &FloatValueStruct{ CommonV{FloatKind, typ, addr} }
+}
+
+func (v *FloatValueStruct) Get() float {
+       return *AddrToPtrFloat(v.addr)
+}
+
+func (v *FloatValueStruct) Put(f float) {
+       *AddrToPtrFloat(v.addr) = f
+}
+
 // -- Float32
 
 export type Float32Value interface {
@@ -572,14 +650,17 @@ var creator *map[int] Creator
 
 func init() {
        creator = new(map[int] Creator);
+       creator[IntKind] = &IntCreator;
        creator[Int8Kind] = &Int8Creator;
        creator[Int16Kind] = &Int16Creator;
        creator[Int32Kind] = &Int32Creator;
        creator[Int64Kind] = &Int64Creator;
+       creator[UintKind] = &UintCreator;
        creator[Uint8Kind] = &Uint8Creator;
        creator[Uint16Kind] = &Uint16Creator;
        creator[Uint32Kind] = &Uint32Creator;
        creator[Uint64Kind] = &Uint64Creator;
+       creator[FloatKind] = &FloatCreator;
        creator[Float32Kind] = &Float32Creator;
        creator[Float64Kind] = &Float64Creator;
        creator[Float80Kind] = &Float80Creator;