add uintptr to reflect and print

R=rsc
DELTA=70  (35 added, 4 deleted, 31 changed)
OCL=20993
CL=20998

src/lib/fmt/print.go

@@ -231,6 +231,8 @@ func getInt(v reflect.Value) (val int64, signed, ok bool) {
 		return int64(v.(reflect.Uint32Value).Get()), false, true;
 	case reflect.Uint64Kind:
 		return int64(v.(reflect.Uint64Value).Get()), false, true;
+	case reflect.UintptrKind:
+		return int64(v.(reflect.UintptrValue).Get()), false, true;
 	}
 	return 0, false, false;
 }
@@ -324,6 +326,10 @@ func (p *P) printField(field reflect.Value) (was_string bool) {
 	case reflect.UintKind, reflect.Uint8Kind, reflect.Uint16Kind, reflect.Uint32Kind, reflect.Uint64Kind:
 		v, signed, ok := getInt(field);
 		s = p.fmt.ud64(uint64(v)).str();
+	case reflect.UintptrKind:
+		v, signed, ok := getInt(field);
+		p.fmt.sharp = !p.fmt.sharp;  // turn 0x on by default
+		s = p.fmt.ux64(uint64(v)).str();
 	case reflect.Float32Kind:
 		v, ok := getFloat32(field);
 		s = p.fmt.g32(v).str();
@@ -357,8 +363,7 @@ func (p *P) printField(field reflect.Value) (was_string bool) {
 				}
 				p.addstr("]");
 			} else {
-				p.add('0');
+				p.fmt.sharp = !p.fmt.sharp;  // turn 0x on by default
-				p.add('x');
 				s = p.fmt.uX64(uint64(v)).str();
 			}
 		}

src/lib/reflect/type.go

@@ -41,6 +41,7 @@ export const (
 	Uint32Kind;
 	Uint64Kind;
 	Uint8Kind;
+	UintptrKind;
 )
 
 // Int is guaranteed large enough to store a size.
@@ -106,6 +107,7 @@ export var (
 	Uint16 = NewBasicType("uint16", Uint16Kind, 2);
 	Uint32 = NewBasicType("uint32", Uint32Kind, 4);
 	Uint64 = NewBasicType("uint64", Uint64Kind, 8);
+	Uintptr = NewBasicType("uintptr", UintptrKind, 8);	// TODO: need to know how big a uintptr is
 	Float = NewBasicType("float", FloatKind, 4);	// TODO: need to know how big a float is
 	Float32 = NewBasicType("float32", Float32Kind, 4);
 	Float64 = NewBasicType("float64", Float64Kind, 8);
@@ -422,6 +424,7 @@ func init() {
 	types["uint16"] = Uint16;
 	types["uint32"] = Uint32;
 	types["uint64"] = Uint64;
+	types["uintptr"] = Uintptr;
 	types["float"] = Float;
 	types["float32"] = Float32;
 	types["float64"] = Float64;
@@ -444,6 +447,7 @@ func init() {
 	basicstub["uint16"] = NewStubType("uint16", Uint16);
 	basicstub["uint32"] = NewStubType("uint32", Uint32);
 	basicstub["uint64"] = NewStubType("uint64", Uint64);
+	basicstub["uintptr"] = NewStubType("uintptr", Uintptr);
 	basicstub["float"] = NewStubType("float", Float);
 	basicstub["float32"] = NewStubType("float32", Float32);
 	basicstub["float64"] = NewStubType("float64", Float64);

src/lib/reflect/value.go

@@ -12,7 +12,7 @@ import (
 	"unsafe";
 )
 
-type Addr unsafe.pointer	// TODO: where are ptrint/intptr etc?
+type Addr unsafe.pointer
 
 func EqualType(a, b Type) bool {
 	return a.String() == b.String()
@@ -320,6 +320,31 @@ func (v *Uint64ValueStruct) Set(i uint64) {
 	*v.addr.(*uint64) = i
 }
 
+// -- Uintptr
+
+export type UintptrValue interface {
+	Kind()	int;
+	Get()	uintptr;
+	Set(uintptr);
+	Type()	Type;
+}
+
+type UintptrValueStruct struct {
+	Common
+}
+
+func UintptrCreator(typ Type, addr Addr) Value {
+	return &UintptrValueStruct{ Common{UintptrKind, typ, addr} }
+}
+
+func (v *UintptrValueStruct) Get() uintptr {
+	return *v.addr.(*uintptr)
+}
+
+func (v *UintptrValueStruct) Set(i uintptr) {
+	*v.addr.(*uintptr) = i
+}
+
 // -- Float
 
 export type FloatValue interface {
@@ -727,39 +752,36 @@ func FuncCreator(typ Type, addr Addr) Value {
 	return &FuncValueStruct{ Common{FuncKind, typ, addr} }
 }
 
-var creator *map[int] Creator
+var creator = map[int] Creator {
-var typecache *map[string] *Type
+	MissingKind : &MissingCreator,
-
+	IntKind : &IntCreator,
-func init() {
+	Int8Kind : &Int8Creator,
-	creator = new(map[int] Creator);
+	Int16Kind : &Int16Creator,
-	creator[MissingKind] = &MissingCreator;
+	Int32Kind : &Int32Creator,
-	creator[IntKind] = &IntCreator;
+	Int64Kind : &Int64Creator,
-	creator[Int8Kind] = &Int8Creator;
+	UintKind : &UintCreator,
-	creator[Int16Kind] = &Int16Creator;
+	Uint8Kind : &Uint8Creator,
-	creator[Int32Kind] = &Int32Creator;
+	Uint16Kind : &Uint16Creator,
-	creator[Int64Kind] = &Int64Creator;
+	Uint32Kind : &Uint32Creator,
-	creator[UintKind] = &UintCreator;
+	Uint64Kind : &Uint64Creator,
-	creator[Uint8Kind] = &Uint8Creator;
+	UintptrKind : &UintptrCreator,
-	creator[Uint16Kind] = &Uint16Creator;
+	FloatKind : &FloatCreator,
-	creator[Uint32Kind] = &Uint32Creator;
+	Float32Kind : &Float32Creator,
-	creator[Uint64Kind] = &Uint64Creator;
+	Float64Kind : &Float64Creator,
-	creator[FloatKind] = &FloatCreator;
+	Float80Kind : &Float80Creator,
-	creator[Float32Kind] = &Float32Creator;
+	StringKind : &StringCreator,
-	creator[Float64Kind] = &Float64Creator;
+	BoolKind : &BoolCreator,
-	creator[Float80Kind] = &Float80Creator;
+	PtrKind : &PtrCreator,
-	creator[StringKind] = &StringCreator;
+	ArrayKind : &ArrayCreator,
-	creator[BoolKind] = &BoolCreator;
+	MapKind : &MapCreator,
-	creator[PtrKind] = &PtrCreator;
+	ChanKind : &ChanCreator,
-	creator[ArrayKind] = &ArrayCreator;
+	StructKind : &StructCreator,
-	creator[MapKind] = &MapCreator;
+	InterfaceKind : &InterfaceCreator,
-	creator[ChanKind] = &ChanCreator;
+	FuncKind : &FuncCreator,
-	creator[StructKind] = &StructCreator;
-	creator[InterfaceKind] = &InterfaceCreator;
-	creator[FuncKind] = &FuncCreator;
-
-	typecache = new(map[string] *Type);
 }
 
+var typecache = new(map[string] *Type);
+
 func NewValueAddr(typ Type, addr Addr) Value {
 	c, ok := creator[typ.Kind()];
 	if !ok {