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 1de31dd..ae04b8b 100644
--- a/src/lib/reflect/cast_amd64.s
+++ b/src/lib/reflect/cast_amd64.s
@@ -11,6 +11,16 @@
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 @@
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 @@
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 e3871a5..d33bc11 100755
--- a/src/lib/reflect/gencast.sh
+++ b/src/lib/reflect/gencast.sh
@@ -21,14 +21,17 @@
}
' > 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 d899929..34acbda 100644
--- a/src/lib/reflect/test.go
+++ b/src/lib/reflect/test.go
@@ -49,6 +49,8 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 4b3ff78..767886a 100644
--- a/src/lib/reflect/tostring.go
+++ b/src/lib/reflect/tostring.go
@@ -41,30 +41,11 @@
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 @@
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 @@
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 @@
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 c70ad79..987c171 100644
--- a/src/lib/reflect/type.go
+++ b/src/lib/reflect/type.go
@@ -17,10 +17,12 @@
MissingKind = iota;
ArrayKind;
ChanKind;
+ FloatKind;
Float32Kind;
Float64Kind;
Float80Kind;
FuncKind;
+ IntKind;
Int16Kind;
Int32Kind;
Int64Kind;
@@ -30,6 +32,7 @@
PtrKind;
StringKind;
StructKind;
+ UintKind;
Uint16Kind;
Uint32Kind;
Uint64Kind;
@@ -79,14 +82,17 @@
// 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 @@
// 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 @@
// 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 890fd9b..c39b1cb3 100644
--- a/src/lib/reflect/value.go
+++ b/src/lib/reflect/value.go
@@ -41,21 +41,49 @@
// 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 @@
*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 @@
*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 @@
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;
