From: Rob Pike Date: Wed, 29 Oct 2008 22:31:02 +0000 (-0700) Subject: update reflection library to int/int32 etc. split X-Git-Tag: weekly.2009-11-06~2861 X-Git-Url: http://www.git.cypherpunks.su/?a=commitdiff_plain;h=282493bbf6d6952335d97e1faa4e86585cdf04e6;p=gostls13.git 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 1de31dd041..ae04b8b32e 100644 --- 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 e3871a5316..d33bc11fb1 100755 --- 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 d899929fe9..34acbda6e0 100644 --- 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 4b3ff78ca4..767886a759 100644 --- 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 c70ad7990f..987c17138d 100644 --- 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 890fd9bdb9..c39b1cb3e6 100644 --- 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;