move reflection code into final place.

this is just a branch.
next cl will update and add to build

R=rsc
DELTA=4528  (2264 added, 2264 deleted, 0 changed)
OCL=17670
CL=17672

src/lib/reflect/value.go

@@ -0,0 +1,822 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Reflection library.
+// Handling values.
+
+package reflect
+
+import (
+	"reflect";
+)
+
+
+type Addr uint64	// TODO: where are ptrint/intptr etc?
+
+export type Value interface {
+	Kind()	int;
+	Type()	Type;
+}
+
+func NewValueAddr(typ Type, addr Addr) Value
+
+type Creator *(typ Type, addr Addr) Value
+
+// Conversion functions, implemented in assembler
+func AddrToPtrAddr(Addr) *Addr
+func AddrToPtrInt8(Addr) *int8
+func AddrToPtrInt16(Addr) *int16
+func AddrToPtrInt32(Addr) *int32
+func AddrToPtrInt64(Addr) *int64
+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 AddrToPtrFloat32(Addr) *float32
+func AddrToPtrFloat64(Addr) *float64
+func AddrToPtrFloat80(Addr) *float80
+func AddrToPtrString(Addr) *string
+
+// -- Int8
+
+export type Int8Value interface {
+	Kind()	int;
+	Get()	int8;
+	Put(int8);
+	Type()	Type;
+}
+
+type Int8ValueStruct struct {
+	addr	Addr
+}
+
+func (v *Int8ValueStruct) Kind() int {
+	return Int8Kind
+}
+
+func (v *Int8ValueStruct) Type() Type {
+	return Int8
+}
+
+func (v *Int8ValueStruct) Get() int8 {
+	return *AddrToPtrInt8(v.addr)
+}
+
+func (v *Int8ValueStruct) Put(i int8) {
+	*AddrToPtrInt8(v.addr) = i
+}
+
+func Int8Creator(typ Type, addr Addr) Value {
+	v := new(Int8ValueStruct);
+	v.addr = addr;
+	return v;
+}
+
+// -- Int16
+
+export type Int16Value interface {
+	Kind()	int;
+	Get()	int16;
+	Put(int16);
+	Type()	Type;
+}
+
+type Int16ValueStruct struct {
+	addr	Addr
+}
+
+func (v *Int16ValueStruct) Kind() int {
+	return Int16Kind
+}
+
+func (v *Int16ValueStruct) Type() Type {
+	return Int16
+}
+
+func (v *Int16ValueStruct) Get() int16 {
+	return *AddrToPtrInt16(v.addr)
+}
+
+func (v *Int16ValueStruct) Put(i int16) {
+	*AddrToPtrInt16(v.addr) = i
+}
+
+func Int16Creator(typ Type, addr Addr) Value {
+	v := new(Int16ValueStruct);
+	v.addr = addr;
+	return v;
+}
+
+// -- Int32
+
+export type Int32Value interface {
+	Kind()	int;
+	Get()	int32;
+	Put(int32);
+	Type()	Type;
+}
+
+type Int32ValueStruct struct {
+	addr	Addr
+}
+
+func (v *Int32ValueStruct) Type() Type {
+	return Int32
+}
+
+func (v *Int32ValueStruct) Kind() int {
+	return Int32Kind
+}
+
+func (v *Int32ValueStruct) Get() int32 {
+	return *AddrToPtrInt32(v.addr)
+}
+
+func (v *Int32ValueStruct) Put(i int32) {
+	*AddrToPtrInt32(v.addr) = i
+}
+
+func Int32Creator(typ Type, addr Addr) Value {
+	v := new(Int32ValueStruct);
+	v.addr = addr;
+	return v;
+}
+
+// -- Int64
+
+export type Int64Value interface {
+	Kind()	int;
+	Get()	int64;
+	Put(int64);
+	Type()	Type;
+}
+
+type Int64ValueStruct struct {
+	addr	Addr
+}
+
+func (v *Int64ValueStruct) Kind() int {
+	return Int64Kind
+}
+
+func (v *Int64ValueStruct) Type() Type {
+	return Int64
+}
+
+func (v *Int64ValueStruct) Get() int64 {
+	return *AddrToPtrInt64(v.addr)
+}
+
+func (v *Int64ValueStruct) Put(i int64) {
+	*AddrToPtrInt64(v.addr) = i
+}
+
+func Int64Creator(typ Type, addr Addr) Value {
+	v := new(Int64ValueStruct);
+	v.addr = addr;
+	return v;
+}
+
+// -- Uint8
+
+export type Uint8Value interface {
+	Kind()	int;
+	Get()	uint8;
+	Put(uint8);
+	Type()	Type;
+}
+
+type Uint8ValueStruct struct {
+	addr	Addr
+}
+
+func (v *Uint8ValueStruct) Kind() int {
+	return Uint8Kind
+}
+
+func (v *Uint8ValueStruct) Type() Type {
+	return Uint8
+}
+
+func (v *Uint8ValueStruct) Get() uint8 {
+	return *AddrToPtrUint8(v.addr)
+}
+
+func (v *Uint8ValueStruct) Put(i uint8) {
+	*AddrToPtrUint8(v.addr) = i
+}
+
+func Uint8Creator(typ Type, addr Addr) Value {
+	v := new(Uint8ValueStruct);
+	v.addr = addr;
+	return v;
+}
+
+// -- Uint16
+
+export type Uint16Value interface {
+	Kind()	int;
+	Get()	uint16;
+	Put(uint16);
+	Type()	Type;
+}
+
+type Uint16ValueStruct struct {
+	addr	Addr
+}
+
+func (v *Uint16ValueStruct) Kind() int {
+	return Uint16Kind
+}
+
+func (v *Uint16ValueStruct) Type() Type {
+	return Uint16
+}
+
+func (v *Uint16ValueStruct) Get() uint16 {
+	return *AddrToPtrUint16(v.addr)
+}
+
+func (v *Uint16ValueStruct) Put(i uint16) {
+	*AddrToPtrUint16(v.addr) = i
+}
+
+func Uint16Creator(typ Type, addr Addr) Value {
+	v := new(Uint16ValueStruct);
+	v.addr = addr;
+	return v;
+}
+
+// -- Uint32
+
+export type Uint32Value interface {
+	Kind()	int;
+	Get()	uint32;
+	Put(uint32);
+	Type()	Type;
+}
+
+type Uint32ValueStruct struct {
+	addr	Addr
+}
+
+func (v *Uint32ValueStruct) Kind() int {
+	return Uint32Kind
+}
+
+func (v *Uint32ValueStruct) Type() Type {
+	return Uint32
+}
+
+func (v *Uint32ValueStruct) Get() uint32 {
+	return *AddrToPtrUint32(v.addr)
+}
+
+func (v *Uint32ValueStruct) Put(i uint32) {
+	*AddrToPtrUint32(v.addr) = i
+}
+
+func Uint32Creator(typ Type, addr Addr) Value {
+	v := new(Uint32ValueStruct);
+	v.addr = addr;
+	return v;
+}
+
+// -- Uint64
+
+export type Uint64Value interface {
+	Kind()	int;
+	Get()	uint64;
+	Put(uint64);
+	Type()	Type;
+}
+
+type Uint64ValueStruct struct {
+	addr	Addr
+}
+
+func (v *Uint64ValueStruct) Kind() int {
+	return Uint64Kind
+}
+
+func (v *Uint64ValueStruct) Type() Type {
+	return Uint64
+}
+
+func (v *Uint64ValueStruct) Get() uint64 {
+	return *AddrToPtrUint64(v.addr)
+}
+
+func (v *Uint64ValueStruct) Put(i uint64) {
+	*AddrToPtrUint64(v.addr) = i
+}
+
+func Uint64Creator(typ Type, addr Addr) Value {
+	v := new(Uint64ValueStruct);
+	v.addr = addr;
+	return v;
+}
+
+// -- Float32
+
+export type Float32Value interface {
+	Kind()	int;
+	Get()	float32;
+	Put(float32);
+	Type()	Type;
+}
+
+type Float32ValueStruct struct {
+	addr	Addr
+}
+
+func (v *Float32ValueStruct) Kind() int {
+	return Float32Kind
+}
+
+func (v *Float32ValueStruct) Type() Type {
+	return Float32
+}
+
+func (v *Float32ValueStruct) Get() float32 {
+	return *AddrToPtrFloat32(v.addr)
+}
+
+func (v *Float32ValueStruct) Put(f float32) {
+	*AddrToPtrFloat32(v.addr) = f
+}
+
+func Float32Creator(typ Type, addr Addr) Value {
+	v := new(Float32ValueStruct);
+	v.addr = addr;
+	return v;
+}
+
+// -- Float64
+
+export type Float64Value interface {
+	Kind()	int;
+	Get()	float64;
+	Put(float64);
+	Type()	Type;
+}
+
+type Float64ValueStruct struct {
+	addr	Addr
+}
+
+func (v *Float64ValueStruct) Kind() int {
+	return Float64Kind
+}
+
+func (v *Float64ValueStruct) Type() Type {
+	return Float64
+}
+
+func (v *Float64ValueStruct) Get() float64 {
+	return *AddrToPtrFloat64(v.addr)
+}
+
+func (v *Float64ValueStruct) Put(f float64) {
+	*AddrToPtrFloat64(v.addr) = f
+}
+
+func Float64Creator(typ Type, addr Addr) Value {
+	v := new(Float64ValueStruct);
+	v.addr = addr;
+	return v;
+}
+
+// -- Float80
+
+export type Float80Value interface {
+	Kind()	int;
+	Get()	float80;
+	Put(float80);
+	Type()	Type;
+}
+
+type Float80ValueStruct struct {
+	addr	Addr
+}
+
+func (v *Float80ValueStruct) Kind() int {
+	return Float80Kind
+}
+
+func (v *Float80ValueStruct) Type() Type {
+	return Float80
+}
+
+/*
+BUG: can't gen code for float80s
+func (v *Float80ValueStruct) Get() float80 {
+	return *AddrToPtrFloat80(v.addr)
+	return 0;
+}
+
+func (v *Float80ValueStruct) Put(f float80) {
+	*AddrToPtrFloat80(v.addr) = f
+}
+*/
+
+func Float80Creator(typ Type, addr Addr) Value {
+	v := new(Float80ValueStruct);
+	v.addr = addr;
+	return v;
+}
+
+// -- String
+
+export type StringValue interface {
+	Kind()	int;
+	Get()	string;
+	Put(string);
+	Type()	Type;
+}
+
+type StringValueStruct struct {
+	addr	Addr
+}
+
+func (v *StringValueStruct) Kind() int {
+	return StringKind
+}
+
+func (v *StringValueStruct) Type() Type {
+	return String
+}
+
+func (v *StringValueStruct) Get() string {
+	return *AddrToPtrString(v.addr)
+}
+
+func (v *StringValueStruct) Put(s string) {
+	*AddrToPtrString(v.addr) = s
+}
+
+func StringCreator(typ Type, addr Addr) Value {
+	v := new(StringValueStruct);
+	v.addr = addr;
+	return v;
+}
+
+// -- Pointer
+
+export type PtrValue interface {
+	Kind()	int;
+	Sub()	Value;
+	Type()	Type;
+	Indirect()	Addr;
+}
+
+type PtrValueStruct struct {
+	addr	Addr;
+	typ	Type;
+}
+
+func (v *PtrValueStruct) Kind() int {
+	return PtrKind
+}
+
+func (v *PtrValueStruct) Type() Type {
+	return v.typ
+}
+
+func (v *PtrValueStruct) Indirect() Addr {
+	return *AddrToPtrAddr(v.addr)
+}
+
+func (v *PtrValueStruct) Sub() Value {
+	return NewValueAddr(v.typ.(PtrType).Sub(), v.Indirect());
+}
+
+func PtrCreator(typ Type, addr Addr) Value {
+	return &PtrValueStruct{addr, typ};
+}
+
+// -- Array	TODO: finish and test
+
+export type ArrayValue interface {
+	Kind()	int;
+	Type()	Type;
+	Open()	bool;
+	Len()	uint64;
+	Elem(i uint64)	Value;
+}
+
+type OpenArrayValueStruct struct {
+	addr	Addr;
+	typ	Type;
+	elemtype	Type;
+	elemsize	uint64;
+}
+/*
+	Run-time representation of open arrays looks like this:
+		struct	Array {
+			byte*	array;		// actual data
+			uint32	nel;		// number of elements
+		};
+*/
+
+func (v *OpenArrayValueStruct) Kind() int {
+	return ArrayKind
+}
+
+func (v *OpenArrayValueStruct) Type() Type {
+	return v.typ
+}
+
+func (v *OpenArrayValueStruct) Open() bool {
+	return true
+}
+
+func (v *OpenArrayValueStruct) Len() uint64 {
+	return uint64(*AddrToPtrInt32(v.addr+8));
+}
+
+func (v *OpenArrayValueStruct) Elem(i uint64) Value {
+	base := *AddrToPtrAddr(v.addr);
+	return NewValueAddr(v.elemtype, base + i * v.elemsize);
+}
+
+type FixedArrayValueStruct struct {
+	addr	Addr;
+	typ	Type;
+	elemtype	Type;
+	elemsize	uint64;
+	len	uint64;
+}
+
+func (v *FixedArrayValueStruct) Kind() int {
+	return ArrayKind
+}
+
+func (v *FixedArrayValueStruct) Type() Type {
+	return v.typ
+}
+
+func (v *FixedArrayValueStruct) Open() bool {
+	return false
+}
+
+func (v *FixedArrayValueStruct) Len() uint64 {
+	return v.len
+}
+
+func (v *FixedArrayValueStruct) Elem(i uint64) Value {
+	return NewValueAddr(v.elemtype, v.addr + i * v.elemsize);
+	return nil
+}
+
+func ArrayCreator(typ Type, addr Addr) Value {
+	arraytype := typ.(ArrayType);
+	if arraytype.Open() {
+		v := new(OpenArrayValueStruct);
+		v.addr = addr;
+		v.typ = typ;
+		v.elemtype = arraytype.Elem();
+		v.elemsize = v.elemtype.Size();
+		return v;
+	}
+	v := new(FixedArrayValueStruct);
+	v.addr = addr;
+	v.typ = typ;
+	v.elemtype = arraytype.Elem();
+	v.elemsize = v.elemtype.Size();
+	v.len = arraytype.Len();
+	return v;
+}
+
+// -- Map	TODO: finish and test
+
+export type MapValue interface {
+	Kind()	int;
+	Type()	Type;
+	Len()	int;
+	Elem(key Value)	Value;
+}
+
+type MapValueStruct struct {
+	addr	Addr;
+	typ	Type;
+	len	int;
+}
+
+func (v *MapValueStruct) Kind() int {
+	return MapKind
+}
+
+func (v *MapValueStruct) Type() Type {
+	return v.typ
+}
+
+func (v *MapValueStruct) Len() int {
+	return v.len	// TODO: probably want this to be dynamic
+}
+
+func (v *MapValueStruct) Elem(key Value) Value {
+	panic("map value element");
+	return nil
+}
+
+func MapCreator(typ Type, addr Addr) Value {
+	arraytype := typ.(MapType);
+	v := new(MapValueStruct);
+	v.addr = addr;
+	v.typ = typ;
+	return v;
+}
+
+// -- Chan
+
+export type ChanValue interface {
+	Kind()	int;
+	Type()	Type;
+}
+
+type ChanValueStruct struct {
+	addr	Addr;
+	typ	Type;
+	len	int;
+}
+
+func (v *ChanValueStruct) Kind() int {
+	return ChanKind
+}
+
+func (v *ChanValueStruct) Type() Type {
+	return v.typ
+}
+
+func ChanCreator(typ Type, addr Addr) Value {
+	v := new(ChanValueStruct);
+	v.addr = addr;
+	v.typ = typ;
+	return v;
+}
+
+// -- Struct
+
+export type StructValue interface {
+	Kind()	int;
+	Type()	Type;
+	Len()	int;
+	Field(i int)	Value;
+}
+
+type StructValueStruct struct {
+	addr	Addr;
+	typ	Type;
+	field	*[]Value;
+}
+
+func (v *StructValueStruct) Kind() int {
+	return StructKind
+}
+
+func (v *StructValueStruct) Type() Type {
+	return v.typ
+}
+
+func (v *StructValueStruct) Len() int {
+	return len(v.field)
+}
+
+func (v *StructValueStruct) Field(i int) Value {
+	return v.field[i]
+}
+
+func StructCreator(typ Type, addr Addr) Value {
+	t := typ.(StructType);
+	v := new(StructValueStruct);
+	v.addr = addr;
+	nfield := t.Len();
+	v.field = new([]Value, nfield);
+	for i := 0; i < nfield; i++ {
+		name, ftype, offset := t.Field(i);
+		v.field[i] = NewValueAddr(ftype, addr + offset);
+	}
+	v.typ = typ;
+	return v;
+}
+
+// -- Interface
+
+export type InterfaceValue interface {
+	Kind()	int;
+	Type()	Type;
+}
+
+type InterfaceValueInterface struct {
+	addr	Addr;
+	typ	Type;
+}
+
+func (v *InterfaceValueInterface) Kind() int {
+	return InterfaceKind
+}
+
+func (v *InterfaceValueInterface) Type() Type {
+	return v.typ
+}
+
+func InterfaceCreator(typ Type, addr Addr) Value {
+	v := new(InterfaceValueInterface);
+	v.addr = addr;
+	v.typ = typ;
+	return v;
+}
+
+// -- Func
+
+export type FuncValue interface {
+	Kind()	int;
+	Type()	Type;
+}
+
+type FuncValueFunc struct {
+	addr	Addr;
+	typ	Type;
+}
+
+func (v *FuncValueFunc) Kind() int {
+	return FuncKind
+}
+
+func (v *FuncValueFunc) Type() Type {
+	return v.typ
+}
+
+func FuncCreator(typ Type, addr Addr) Value {
+	v := new(FuncValueFunc);
+	v.addr = addr;
+	v.typ = typ;
+	return v;
+}
+
+var creator *map[int] Creator
+
+func init() {
+	creator = new(map[int] Creator);
+	creator[Int8Kind] = &Int8Creator;
+	creator[Int16Kind] = &Int16Creator;
+	creator[Int32Kind] = &Int32Creator;
+	creator[Int64Kind] = &Int64Creator;
+	creator[Uint8Kind] = &Uint8Creator;
+	creator[Uint16Kind] = &Uint16Creator;
+	creator[Uint32Kind] = &Uint32Creator;
+	creator[Uint64Kind] = &Uint64Creator;
+	creator[Float32Kind] = &Float32Creator;
+	creator[Float64Kind] = &Float64Creator;
+	creator[Float80Kind] = &Float80Creator;
+	creator[StringKind] = &StringCreator;
+	creator[PtrKind] = &PtrCreator;
+	creator[ArrayKind] = &ArrayCreator;
+	creator[MapKind] = &MapCreator;
+	creator[ChanKind] = &ChanCreator;
+	creator[StructKind] = &StructCreator;
+	creator[InterfaceKind] = &InterfaceCreator;
+	creator[FuncKind] = &FuncCreator;
+}
+
+func NewValueAddr(typ Type, addr Addr) Value {
+	c, ok := creator[typ.Kind()];
+	if !ok {
+		panicln("no creator for type" , typ.Kind());
+	}
+	return c(typ, addr);
+}
+
+export func NewInitValue(typ Type) Value {
+	// Some values cannot be made this way.
+	switch typ.Kind() {
+	case FuncKind, ChanKind, MapKind:	// must be pointers, at least for now (TODO?)
+		return nil;
+	case ArrayKind:
+		if typ.(ArrayType).Open() {
+			return nil
+		}
+	}
+	size := typ.Size();
+	if size == 0 {
+		size = 1;
+	}
+	data := new([]uint8, size);
+	return NewValueAddr(typ, PtrUint8ToAddr(&data[0]));
+}
+
+export type Empty interface {}
+
+export func NewValue(e Empty) Value {
+	value, typestring  := sys.reflect(e);
+	typ := ParseTypeString("", typestring);
+	// Content of interface is a value; need a permanent copy to take its address
+	// so we can modify the contents. Values contain pointers to 'values'.
+	ap := new(uint64);
+	*ap = value;
+	return NewValueAddr(typ, PtrUint64ToAddr(ap));
+}