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

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)

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

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}");
 	}
 }

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:
+	case IntKind, Int8Kind, Int16Kind, Int32Kind, Int64Kind,
-		return "int8";
+	     UintKind, Uint8Kind, Uint16Kind, Uint32Kind, Uint64Kind,
-	case Int16Kind:
+	     FloatKind, Float32Kind, Float64Kind, Float80Kind:
-		return "int16";
+	     StringKind:
-	case Int32Kind:
+		return typ.Name();
-		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 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:

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);

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;