casify reflect.
R=rsc
DELTA=513 (0 added, 2 deleted, 511 changed)
OCL=22954
CL=22956
diff --git a/src/lib/reflect/value.go b/src/lib/reflect/value.go
index 2adf430..63752d8 100644
--- a/src/lib/reflect/value.go
+++ b/src/lib/reflect/value.go
@@ -12,9 +12,9 @@
"unsafe";
)
-type Addr unsafe.pointer
+export type Addr unsafe.pointer
-func EqualType(a, b Type) bool {
+func equalType(a, b Type) bool {
return a.String() == b.String()
}
@@ -58,9 +58,9 @@
return i;
}
-func NewValueAddr(typ Type, addr Addr) Value
+func newValueAddr(typ Type, addr Addr) Value
-type Creator *(typ Type, addr Addr) Value
+type creatorFn *(typ Type, addr Addr) Value
// -- Missing
@@ -71,12 +71,12 @@
Addr() Addr;
}
-type MissingValueStruct struct {
+type missingValueStruct struct {
commonValue
}
-func MissingCreator(typ Type, addr Addr) Value {
- return &MissingValueStruct{ commonValue{MissingKind, typ, addr} }
+func missingCreator(typ Type, addr Addr) Value {
+ return &missingValueStruct{ commonValue{MissingKind, typ, addr} }
}
// -- Int
@@ -88,19 +88,19 @@
Type() Type;
}
-type IntValueStruct struct {
+type intValueStruct struct {
commonValue
}
-func IntCreator(typ Type, addr Addr) Value {
- return &IntValueStruct{ commonValue{IntKind, typ, addr} }
+func intCreator(typ Type, addr Addr) Value {
+ return &intValueStruct{ commonValue{IntKind, typ, addr} }
}
-func (v *IntValueStruct) Get() int {
+func (v *intValueStruct) Get() int {
return *v.addr.(*int)
}
-func (v *IntValueStruct) Set(i int) {
+func (v *intValueStruct) Set(i int) {
*v.addr.(*int) = i
}
@@ -113,19 +113,19 @@
Type() Type;
}
-type Int8ValueStruct struct {
+type int8ValueStruct struct {
commonValue
}
-func Int8Creator(typ Type, addr Addr) Value {
- return &Int8ValueStruct{ commonValue{Int8Kind, typ, addr} }
+func int8Creator(typ Type, addr Addr) Value {
+ return &int8ValueStruct{ commonValue{Int8Kind, typ, addr} }
}
-func (v *Int8ValueStruct) Get() int8 {
+func (v *int8ValueStruct) Get() int8 {
return *v.addr.(*int8)
}
-func (v *Int8ValueStruct) Set(i int8) {
+func (v *int8ValueStruct) Set(i int8) {
*v.addr.(*int8) = i
}
@@ -138,19 +138,19 @@
Type() Type;
}
-type Int16ValueStruct struct {
+type int16ValueStruct struct {
commonValue
}
-func Int16Creator(typ Type, addr Addr) Value {
- return &Int16ValueStruct{ commonValue{Int16Kind, typ, addr} }
+func int16Creator(typ Type, addr Addr) Value {
+ return &int16ValueStruct{ commonValue{Int16Kind, typ, addr} }
}
-func (v *Int16ValueStruct) Get() int16 {
+func (v *int16ValueStruct) Get() int16 {
return *v.addr.(*int16)
}
-func (v *Int16ValueStruct) Set(i int16) {
+func (v *int16ValueStruct) Set(i int16) {
*v.addr.(*int16) = i
}
@@ -163,19 +163,19 @@
Type() Type;
}
-type Int32ValueStruct struct {
+type int32ValueStruct struct {
commonValue
}
-func Int32Creator(typ Type, addr Addr) Value {
- return &Int32ValueStruct{ commonValue{Int32Kind, typ, addr} }
+func int32Creator(typ Type, addr Addr) Value {
+ return &int32ValueStruct{ commonValue{Int32Kind, typ, addr} }
}
-func (v *Int32ValueStruct) Get() int32 {
+func (v *int32ValueStruct) Get() int32 {
return *v.addr.(*int32)
}
-func (v *Int32ValueStruct) Set(i int32) {
+func (v *int32ValueStruct) Set(i int32) {
*v.addr.(*int32) = i
}
@@ -188,19 +188,19 @@
Type() Type;
}
-type Int64ValueStruct struct {
+type int64ValueStruct struct {
commonValue
}
-func Int64Creator(typ Type, addr Addr) Value {
- return &Int64ValueStruct{ commonValue{Int64Kind, typ, addr} }
+func int64Creator(typ Type, addr Addr) Value {
+ return &int64ValueStruct{ commonValue{Int64Kind, typ, addr} }
}
-func (v *Int64ValueStruct) Get() int64 {
+func (v *int64ValueStruct) Get() int64 {
return *v.addr.(*int64)
}
-func (v *Int64ValueStruct) Set(i int64) {
+func (v *int64ValueStruct) Set(i int64) {
*v.addr.(*int64) = i
}
@@ -213,19 +213,19 @@
Type() Type;
}
-type UintValueStruct struct {
+type uintValueStruct struct {
commonValue
}
-func UintCreator(typ Type, addr Addr) Value {
- return &UintValueStruct{ commonValue{UintKind, typ, addr} }
+func uintCreator(typ Type, addr Addr) Value {
+ return &uintValueStruct{ commonValue{UintKind, typ, addr} }
}
-func (v *UintValueStruct) Get() uint {
+func (v *uintValueStruct) Get() uint {
return *v.addr.(*uint)
}
-func (v *UintValueStruct) Set(i uint) {
+func (v *uintValueStruct) Set(i uint) {
*v.addr.(*uint) = i
}
@@ -238,19 +238,19 @@
Type() Type;
}
-type Uint8ValueStruct struct {
+type uint8ValueStruct struct {
commonValue
}
-func Uint8Creator(typ Type, addr Addr) Value {
- return &Uint8ValueStruct{ commonValue{Uint8Kind, typ, addr} }
+func uint8Creator(typ Type, addr Addr) Value {
+ return &uint8ValueStruct{ commonValue{Uint8Kind, typ, addr} }
}
-func (v *Uint8ValueStruct) Get() uint8 {
+func (v *uint8ValueStruct) Get() uint8 {
return *v.addr.(*uint8)
}
-func (v *Uint8ValueStruct) Set(i uint8) {
+func (v *uint8ValueStruct) Set(i uint8) {
*v.addr.(*uint8) = i
}
@@ -263,19 +263,19 @@
Type() Type;
}
-type Uint16ValueStruct struct {
+type uint16ValueStruct struct {
commonValue
}
-func Uint16Creator(typ Type, addr Addr) Value {
- return &Uint16ValueStruct{ commonValue{Uint16Kind, typ, addr} }
+func uint16Creator(typ Type, addr Addr) Value {
+ return &uint16ValueStruct{ commonValue{Uint16Kind, typ, addr} }
}
-func (v *Uint16ValueStruct) Get() uint16 {
+func (v *uint16ValueStruct) Get() uint16 {
return *v.addr.(*uint16)
}
-func (v *Uint16ValueStruct) Set(i uint16) {
+func (v *uint16ValueStruct) Set(i uint16) {
*v.addr.(*uint16) = i
}
@@ -288,19 +288,19 @@
Type() Type;
}
-type Uint32ValueStruct struct {
+type uint32ValueStruct struct {
commonValue
}
-func Uint32Creator(typ Type, addr Addr) Value {
- return &Uint32ValueStruct{ commonValue{Uint32Kind, typ, addr} }
+func uint32Creator(typ Type, addr Addr) Value {
+ return &uint32ValueStruct{ commonValue{Uint32Kind, typ, addr} }
}
-func (v *Uint32ValueStruct) Get() uint32 {
+func (v *uint32ValueStruct) Get() uint32 {
return *v.addr.(*uint32)
}
-func (v *Uint32ValueStruct) Set(i uint32) {
+func (v *uint32ValueStruct) Set(i uint32) {
*v.addr.(*uint32) = i
}
@@ -313,19 +313,19 @@
Type() Type;
}
-type Uint64ValueStruct struct {
+type uint64ValueStruct struct {
commonValue
}
-func Uint64Creator(typ Type, addr Addr) Value {
- return &Uint64ValueStruct{ commonValue{Uint64Kind, typ, addr} }
+func uint64Creator(typ Type, addr Addr) Value {
+ return &uint64ValueStruct{ commonValue{Uint64Kind, typ, addr} }
}
-func (v *Uint64ValueStruct) Get() uint64 {
+func (v *uint64ValueStruct) Get() uint64 {
return *v.addr.(*uint64)
}
-func (v *Uint64ValueStruct) Set(i uint64) {
+func (v *uint64ValueStruct) Set(i uint64) {
*v.addr.(*uint64) = i
}
@@ -338,19 +338,19 @@
Type() Type;
}
-type UintptrValueStruct struct {
+type uintptrValueStruct struct {
commonValue
}
-func UintptrCreator(typ Type, addr Addr) Value {
- return &UintptrValueStruct{ commonValue{UintptrKind, typ, addr} }
+func uintptrCreator(typ Type, addr Addr) Value {
+ return &uintptrValueStruct{ commonValue{UintptrKind, typ, addr} }
}
-func (v *UintptrValueStruct) Get() uintptr {
+func (v *uintptrValueStruct) Get() uintptr {
return *v.addr.(*uintptr)
}
-func (v *UintptrValueStruct) Set(i uintptr) {
+func (v *uintptrValueStruct) Set(i uintptr) {
*v.addr.(*uintptr) = i
}
@@ -363,19 +363,19 @@
Type() Type;
}
-type FloatValueStruct struct {
+type floatValueStruct struct {
commonValue
}
-func FloatCreator(typ Type, addr Addr) Value {
- return &FloatValueStruct{ commonValue{FloatKind, typ, addr} }
+func floatCreator(typ Type, addr Addr) Value {
+ return &floatValueStruct{ commonValue{FloatKind, typ, addr} }
}
-func (v *FloatValueStruct) Get() float {
+func (v *floatValueStruct) Get() float {
return *v.addr.(*float)
}
-func (v *FloatValueStruct) Set(f float) {
+func (v *floatValueStruct) Set(f float) {
*v.addr.(*float) = f
}
@@ -388,19 +388,19 @@
Type() Type;
}
-type Float32ValueStruct struct {
+type float32ValueStruct struct {
commonValue
}
-func Float32Creator(typ Type, addr Addr) Value {
- return &Float32ValueStruct{ commonValue{Float32Kind, typ, addr} }
+func float32Creator(typ Type, addr Addr) Value {
+ return &float32ValueStruct{ commonValue{Float32Kind, typ, addr} }
}
-func (v *Float32ValueStruct) Get() float32 {
+func (v *float32ValueStruct) Get() float32 {
return *v.addr.(*float32)
}
-func (v *Float32ValueStruct) Set(f float32) {
+func (v *float32ValueStruct) Set(f float32) {
*v.addr.(*float32) = f
}
@@ -413,19 +413,19 @@
Type() Type;
}
-type Float64ValueStruct struct {
+type float64ValueStruct struct {
commonValue
}
-func Float64Creator(typ Type, addr Addr) Value {
- return &Float64ValueStruct{ commonValue{Float64Kind, typ, addr} }
+func float64Creator(typ Type, addr Addr) Value {
+ return &float64ValueStruct{ commonValue{Float64Kind, typ, addr} }
}
-func (v *Float64ValueStruct) Get() float64 {
+func (v *float64ValueStruct) Get() float64 {
return *v.addr.(*float64)
}
-func (v *Float64ValueStruct) Set(f float64) {
+func (v *float64ValueStruct) Set(f float64) {
*v.addr.(*float64) = f
}
@@ -438,12 +438,12 @@
Type() Type;
}
-type Float80ValueStruct struct {
+type float80ValueStruct struct {
commonValue
}
-func Float80Creator(typ Type, addr Addr) Value {
- return &Float80ValueStruct{ commonValue{Float80Kind, typ, addr} }
+func float80Creator(typ Type, addr Addr) Value {
+ return &float80ValueStruct{ commonValue{Float80Kind, typ, addr} }
}
/*
@@ -466,19 +466,19 @@
Type() Type;
}
-type StringValueStruct struct {
+type stringValueStruct struct {
commonValue
}
-func StringCreator(typ Type, addr Addr) Value {
- return &StringValueStruct{ commonValue{StringKind, typ, addr} }
+func stringCreator(typ Type, addr Addr) Value {
+ return &stringValueStruct{ commonValue{StringKind, typ, addr} }
}
-func (v *StringValueStruct) Get() string {
+func (v *stringValueStruct) Get() string {
return *v.addr.(*string)
}
-func (v *StringValueStruct) Set(s string) {
+func (v *stringValueStruct) Set(s string) {
*v.addr.(*string) = s
}
@@ -491,19 +491,19 @@
Type() Type;
}
-type BoolValueStruct struct {
+type boolValueStruct struct {
commonValue
}
-func BoolCreator(typ Type, addr Addr) Value {
- return &BoolValueStruct{ commonValue{BoolKind, typ, addr} }
+func boolCreator(typ Type, addr Addr) Value {
+ return &boolValueStruct{ commonValue{BoolKind, typ, addr} }
}
-func (v *BoolValueStruct) Get() bool {
+func (v *boolValueStruct) Get() bool {
return *v.addr.(*bool)
}
-func (v *BoolValueStruct) Set(b bool) {
+func (v *boolValueStruct) Set(b bool) {
*v.addr.(*bool) = b
}
@@ -517,30 +517,30 @@
SetSub(Value);
}
-type PtrValueStruct struct {
+type ptrValueStruct struct {
commonValue
}
-func (v *PtrValueStruct) Get() Addr {
+func (v *ptrValueStruct) Get() Addr {
return *v.addr.(*Addr)
}
-func (v *PtrValueStruct) Sub() Value {
- return NewValueAddr(v.typ.(PtrType).Sub(), v.Get());
+func (v *ptrValueStruct) Sub() Value {
+ return newValueAddr(v.typ.(PtrType).Sub(), v.Get());
}
-func (v *PtrValueStruct) SetSub(subv Value) {
+func (v *ptrValueStruct) SetSub(subv Value) {
a := v.typ.(PtrType).Sub();
b := subv.Type();
- if !EqualType(a, b) {
+ if !equalType(a, b) {
panicln("reflect: incompatible types in PtrValue.SetSub:",
a.String(), b.String());
}
*v.addr.(*Addr) = subv.Addr();
}
-func PtrCreator(typ Type, addr Addr) Value {
- return &PtrValueStruct{ commonValue{PtrKind, typ, addr} };
+func ptrCreator(typ Type, addr Addr) Value {
+ return &ptrValueStruct{ commonValue{PtrKind, typ, addr} };
}
// -- Array
@@ -563,84 +563,84 @@
uint32 cap;
};
*/
-type RuntimeArray struct {
+type runtimeArray struct {
data Addr;
len uint32;
cap uint32;
}
-type OpenArrayValueStruct struct {
+type openArrayValueStruct struct {
commonValue;
elemtype Type;
elemsize int;
- array *RuntimeArray;
+ array *runtimeArray;
}
-func (v *OpenArrayValueStruct) Open() bool {
+func (v *openArrayValueStruct) Open() bool {
return true
}
-func (v *OpenArrayValueStruct) Len() int {
+func (v *openArrayValueStruct) Len() int {
return int(v.array.len);
}
-func (v *OpenArrayValueStruct) Cap() int {
+func (v *openArrayValueStruct) Cap() int {
return int(v.array.cap);
}
-func (v *OpenArrayValueStruct) SetLen(len int) {
+func (v *openArrayValueStruct) SetLen(len int) {
if len > v.Cap() {
panicln("reflect: OpenArrayValueStruct.SetLen", len, v.Cap());
}
v.array.len = uint32(len);
}
-func (v *OpenArrayValueStruct) Elem(i int) Value {
+func (v *openArrayValueStruct) Elem(i int) Value {
data_uint := uintptr(v.array.data) + uintptr(i * v.elemsize);
- return NewValueAddr(v.elemtype, Addr(data_uint));
+ return newValueAddr(v.elemtype, Addr(data_uint));
}
-type FixedArrayValueStruct struct {
+type fixedArrayValueStruct struct {
commonValue;
elemtype Type;
elemsize int;
len int;
}
-func (v *FixedArrayValueStruct) Open() bool {
+func (v *fixedArrayValueStruct) Open() bool {
return false
}
-func (v *FixedArrayValueStruct) Len() int {
+func (v *fixedArrayValueStruct) Len() int {
return v.len
}
-func (v *FixedArrayValueStruct) Cap() int {
+func (v *fixedArrayValueStruct) Cap() int {
return v.len
}
-func (v *FixedArrayValueStruct) SetLen(len int) {
+func (v *fixedArrayValueStruct) SetLen(len int) {
}
-func (v *FixedArrayValueStruct) Elem(i int) Value {
+func (v *fixedArrayValueStruct) Elem(i int) Value {
data_uint := uintptr(v.addr) + uintptr(i * v.elemsize);
- return NewValueAddr(v.elemtype, Addr(data_uint));
+ return newValueAddr(v.elemtype, Addr(data_uint));
return nil
}
-func ArrayCreator(typ Type, addr Addr) Value {
+func arrayCreator(typ Type, addr Addr) Value {
arraytype := typ.(ArrayType);
if arraytype.Open() {
- v := new(OpenArrayValueStruct);
+ v := new(openArrayValueStruct);
v.kind = ArrayKind;
v.addr = addr;
v.typ = typ;
v.elemtype = arraytype.Elem();
v.elemsize = v.elemtype.Size();
- v.array = addr.(*RuntimeArray);
+ v.array = addr.(*runtimeArray);
return v;
}
- v := new(FixedArrayValueStruct);
+ v := new(fixedArrayValueStruct);
v.kind = ArrayKind;
v.addr = addr;
v.typ = typ;
@@ -659,19 +659,19 @@
Elem(key Value) Value;
}
-type MapValueStruct struct {
+type mapValueStruct struct {
commonValue
}
-func MapCreator(typ Type, addr Addr) Value {
- return &MapValueStruct{ commonValue{MapKind, typ, addr} }
+func mapCreator(typ Type, addr Addr) Value {
+ return &mapValueStruct{ commonValue{MapKind, typ, addr} }
}
-func (v *MapValueStruct) Len() int {
+func (v *mapValueStruct) Len() int {
return 0 // TODO: probably want this to be dynamic
}
-func (v *MapValueStruct) Elem(key Value) Value {
+func (v *mapValueStruct) Elem(key Value) Value {
panic("map value element");
return nil
}
@@ -683,12 +683,12 @@
Type() Type;
}
-type ChanValueStruct struct {
+type chanValueStruct struct {
commonValue
}
-func ChanCreator(typ Type, addr Addr) Value {
- return &ChanValueStruct{ commonValue{ChanKind, typ, addr} }
+func chanCreator(typ Type, addr Addr) Value {
+ return &chanValueStruct{ commonValue{ChanKind, typ, addr} }
}
// -- Struct
@@ -700,27 +700,27 @@
Field(i int) Value;
}
-type StructValueStruct struct {
+type structValueStruct struct {
commonValue;
field []Value;
}
-func (v *StructValueStruct) Len() int {
+func (v *structValueStruct) Len() int {
return len(v.field)
}
-func (v *StructValueStruct) Field(i int) Value {
+func (v *structValueStruct) Field(i int) Value {
return v.field[i]
}
-func StructCreator(typ Type, addr Addr) Value {
+func structCreator(typ Type, addr Addr) Value {
t := typ.(StructType);
nfield := t.Len();
- v := &StructValueStruct{ commonValue{StructKind, typ, addr}, make([]Value, nfield) };
+ v := &structValueStruct{ commonValue{StructKind, typ, addr}, make([]Value, nfield) };
for i := 0; i < nfield; i++ {
name, ftype, str, offset := t.Field(i);
addr_uint := uintptr(addr) + uintptr(offset);
- v.field[i] = NewValueAddr(ftype, Addr(addr_uint));
+ v.field[i] = newValueAddr(ftype, Addr(addr_uint));
}
v.typ = typ;
return v;
@@ -734,16 +734,16 @@
Get() interface {};
}
-type InterfaceValueStruct struct {
+type interfaceValueStruct struct {
commonValue
}
-func (v *InterfaceValueStruct) Get() interface{} {
+func (v *interfaceValueStruct) Get() interface{} {
return *v.addr.(*interface{})
}
-func InterfaceCreator(typ Type, addr Addr) Value {
- return &InterfaceValueStruct{ commonValue{InterfaceKind, typ, addr} }
+func interfaceCreator(typ Type, addr Addr) Value {
+ return &interfaceValueStruct{ commonValue{InterfaceKind, typ, addr} }
}
// -- Func
@@ -753,45 +753,45 @@
Type() Type;
}
-type FuncValueStruct struct {
+type funcValueStruct struct {
commonValue
}
-func FuncCreator(typ Type, addr Addr) Value {
- return &FuncValueStruct{ commonValue{FuncKind, typ, addr} }
+func funcCreator(typ Type, addr Addr) Value {
+ return &funcValueStruct{ commonValue{FuncKind, typ, addr} }
}
-var creator = map[int] Creator {
- MissingKind : &MissingCreator,
- IntKind : &IntCreator,
- Int8Kind : &Int8Creator,
- Int16Kind : &Int16Creator,
- Int32Kind : &Int32Creator,
- Int64Kind : &Int64Creator,
- UintKind : &UintCreator,
- Uint8Kind : &Uint8Creator,
- Uint16Kind : &Uint16Creator,
- Uint32Kind : &Uint32Creator,
- Uint64Kind : &Uint64Creator,
- UintptrKind : &UintptrCreator,
- FloatKind : &FloatCreator,
- Float32Kind : &Float32Creator,
- Float64Kind : &Float64Creator,
- Float80Kind : &Float80Creator,
- StringKind : &StringCreator,
- BoolKind : &BoolCreator,
- PtrKind : &PtrCreator,
- ArrayKind : &ArrayCreator,
- MapKind : &MapCreator,
- ChanKind : &ChanCreator,
- StructKind : &StructCreator,
- InterfaceKind : &InterfaceCreator,
- FuncKind : &FuncCreator,
+var creator = map[int] creatorFn {
+ MissingKind : &missingCreator,
+ IntKind : &intCreator,
+ Int8Kind : &int8Creator,
+ Int16Kind : &int16Creator,
+ Int32Kind : &int32Creator,
+ Int64Kind : &int64Creator,
+ UintKind : &uintCreator,
+ Uint8Kind : &uint8Creator,
+ Uint16Kind : &uint16Creator,
+ Uint32Kind : &uint32Creator,
+ Uint64Kind : &uint64Creator,
+ UintptrKind : &uintptrCreator,
+ FloatKind : &floatCreator,
+ Float32Kind : &float32Creator,
+ Float64Kind : &float64Creator,
+ Float80Kind : &float80Creator,
+ StringKind : &stringCreator,
+ BoolKind : &boolCreator,
+ PtrKind : &ptrCreator,
+ ArrayKind : &arrayCreator,
+ MapKind : &mapCreator,
+ ChanKind : &chanCreator,
+ StructKind : &structCreator,
+ InterfaceKind : &interfaceCreator,
+ FuncKind : &funcCreator,
}
var typecache = make(map[string] Type);
-func NewValueAddr(typ Type, addr Addr) Value {
+func newValueAddr(typ Type, addr Addr) Value {
c, ok := creator[typ.Kind()];
if !ok {
panicln("no creator for type" , typ.Kind());
@@ -814,7 +814,7 @@
size = 1;
}
data := make([]uint8, size);
- return NewValueAddr(typ, Addr(&data[0]));
+ return newValueAddr(typ, Addr(&data[0]));
}
/*
@@ -830,7 +830,7 @@
return nil
}
- array := new(RuntimeArray);
+ array := new(runtimeArray);
size := typ.Elem().Size() * cap;
if size == 0 {
size = 1;
@@ -840,7 +840,7 @@
array.len = uint32(len);
array.cap = uint32(cap);
- return NewValueAddr(typ, Addr(array));
+ return newValueAddr(typ, Addr(array));
}
export func CopyArray(dst ArrayValue, src ArrayValue, n int) {
@@ -849,7 +849,7 @@
}
dt := dst.Type().(ArrayType).Elem();
st := src.Type().(ArrayType).Elem();
- if !EqualType(dt, st) {
+ if !equalType(dt, st) {
panicln("reflect: incompatible types in CopyArray:",
dt.String(), st.String());
}
@@ -885,12 +885,12 @@
if indir {
// Content of interface is a pointer.
- return NewValueAddr(typ, value.(uintptr).(Addr));
+ return newValueAddr(typ, value.(uintptr).(Addr));
}
// Content of interface is a value;
// need a permanent copy to take its address.
ap := new(uint64);
*ap = value;
- return NewValueAddr(typ, ap.(Addr));
+ return newValueAddr(typ, ap.(Addr));
}
