diff options
Diffstat (limited to 'src/pkg/reflect')
-rw-r--r-- | src/pkg/reflect/value.go | 1528 |
1 files changed, 629 insertions, 899 deletions
diff --git a/src/pkg/reflect/value.go b/src/pkg/reflect/value.go index eeae6cce5..ddc31100f 100644 --- a/src/pkg/reflect/value.go +++ b/src/pkg/reflect/value.go @@ -135,7 +135,7 @@ func (v Value) Addr() Value { // It panics if v's kind is not Bool. func (v Value) Bool() bool { u := v.panicIfNot(Bool).(*boolValue) - return u.Get() + return *(*bool)(u.addr) } // CanAddr returns true if the value's address can be obtained with Addr. @@ -161,25 +161,133 @@ func (v Value) CanSet() bool { // It panics if v's Kind is not Func. // It returns the output parameters as Values. func (v Value) Call(in []Value) []Value { - return v.panicIfNot(Func).(*funcValue).Call(in) -} + fv := v.panicIfNot(Func).(*funcValue) + t := fv.Type() + nin := len(in) + if fv.first != nil && !fv.isInterface { + nin++ + } + if nin != t.NumIn() { + panic("funcValue: wrong argument count") + } + nout := t.NumOut() -var capKinds = []Kind{Array, Chan, Slice} + // Compute arg size & allocate. + // This computation is 6g/8g-dependent + // and probably wrong for gccgo, but so + // is most of this function. + size := uintptr(0) + if fv.isInterface { + // extra word for interface value + size += ptrSize + } + for i := 0; i < nin; i++ { + tv := t.In(i) + a := uintptr(tv.Align()) + size = (size + a - 1) &^ (a - 1) + size += tv.Size() + } + size = (size + ptrSize - 1) &^ (ptrSize - 1) + for i := 0; i < nout; i++ { + tv := t.Out(i) + a := uintptr(tv.Align()) + size = (size + a - 1) &^ (a - 1) + size += tv.Size() + } + + // size must be > 0 in order for &args[0] to be valid. + // the argument copying is going to round it up to + // a multiple of ptrSize anyway, so make it ptrSize to begin with. + if size < ptrSize { + size = ptrSize + } + + // round to pointer size + size = (size + ptrSize - 1) &^ (ptrSize - 1) + + // Copy into args. + // + // TODO(rsc): revisit when reference counting happens. + // The values are holding up the in references for us, + // but something must be done for the out references. + // For now make everything look like a pointer by pretending + // to allocate a []*int. + args := make([]*int, size/ptrSize) + ptr := uintptr(unsafe.Pointer(&args[0])) + off := uintptr(0) + delta := 0 + if v := fv.first; v != nil { + // Hard-wired first argument. + if fv.isInterface { + // v is a single uninterpreted word + memmove(addr(ptr), v.getAddr(), ptrSize) + off = ptrSize + } else { + // v is a real value + tv := v.Type() + typesMustMatch(t.In(0), tv) + n := tv.Size() + memmove(addr(ptr), v.getAddr(), n) + off = n + delta = 1 + } + } + for i, v := range in { + tv := v.Type() + typesMustMatch(t.In(i+delta), tv) + a := uintptr(tv.Align()) + off = (off + a - 1) &^ (a - 1) + n := tv.Size() + memmove(addr(ptr+off), v.internal().getAddr(), n) + off += n + } + off = (off + ptrSize - 1) &^ (ptrSize - 1) + + // Call + call(*(**byte)(fv.addr), (*byte)(addr(ptr)), uint32(size)) + + // Copy return values out of args. + // + // TODO(rsc): revisit like above. + ret := make([]Value, nout) + for i := 0; i < nout; i++ { + tv := t.Out(i) + a := uintptr(tv.Align()) + off = (off + a - 1) &^ (a - 1) + v := Zero(tv) + n := tv.Size() + memmove(v.internal().getAddr(), addr(ptr+off), n) + ret[i] = v + off += n + } -type capper interface { - Cap() int + return ret } +var capKinds = []Kind{Array, Chan, Slice} + // Cap returns v's capacity. // It panics if v's Kind is not Array, Chan, or Slice. func (v Value) Cap() int { - return v.panicIfNots(capKinds).(capper).Cap() + switch vv := v.panicIfNots(capKinds).(type) { + case *arrayValue: + return vv.typ.Len() + case *chanValue: + ch := *(**byte)(vv.addr) + return int(chancap(ch)) + case *sliceValue: + return int(vv.slice().Cap) + } + panic("not reached") } // Close closes the channel v. // It panics if v's Kind is not Chan. func (v Value) Close() { - v.panicIfNot(Chan).(*chanValue).Close() + vv := v.panicIfNot(Chan).(*chanValue) + + ch := *(**byte)(vv.addr) + chanclose(ch) } var complexKinds = []Kind{Complex64, Complex128} @@ -187,40 +295,84 @@ var complexKinds = []Kind{Complex64, Complex128} // Complex returns v's underlying value, as a complex128. // It panics if v's Kind is not Complex64 or Complex128 func (v Value) Complex() complex128 { - return v.panicIfNots(complexKinds).(*complexValue).Get() + vv := v.panicIfNots(complexKinds).(*complexValue) + + switch vv.typ.Kind() { + case Complex64: + return complex128(*(*complex64)(vv.addr)) + case Complex128: + return *(*complex128)(vv.addr) + } + panic("reflect: invalid complex kind") } var interfaceOrPtr = []Kind{Interface, Ptr} -type elemer interface { - Elem() Value -} - // Elem returns the value that the interface v contains // or that the pointer v points to. // It panics if v's Kind is not Interface or Ptr. // It returns the zero Value if v is nil. func (v Value) Elem() Value { - return v.panicIfNots(interfaceOrPtr).(elemer).Elem() + switch vv := v.panicIfNots(interfaceOrPtr).(type) { + case *interfaceValue: + return NewValue(vv.Interface()) + case *ptrValue: + if v.IsNil() { + return Value{} + } + flag := canAddr + if vv.flag&canStore != 0 { + flag |= canSet | canStore + } + return newValue(vv.typ.Elem(), *(*addr)(vv.addr), flag) + } + panic("not reached") } // Field returns the i'th field of the struct v. // It panics if v's Kind is not Struct. func (v Value) Field(i int) Value { - return v.panicIfNot(Struct).(*structValue).Field(i) + vv := v.panicIfNot(Struct).(*structValue) + + t := vv.typ + if i < 0 || i >= t.NumField() { + panic("reflect: Field index out of range") + } + f := t.Field(i) + flag := vv.flag + if f.PkgPath != "" { + // unexported field + flag &^= canSet | canStore + } + return newValue(f.Type, addr(uintptr(vv.addr)+f.Offset), flag) } // FieldByIndex returns the nested field corresponding to index. // It panics if v's Kind is not struct. func (v Value) FieldByIndex(index []int) Value { - return v.panicIfNot(Struct).(*structValue).FieldByIndex(index) + v.panicIfNot(Struct) + for i, x := range index { + if i > 0 { + if v.Kind() == Ptr { + v = v.Elem() + } + if v.Kind() != Struct { + return Value{} + } + } + v = v.Field(x) + } + return v } // FieldByName returns the struct field with the given name. // It returns the zero Value if no field was found. // It panics if v's Kind is not struct. func (v Value) FieldByName(name string) Value { - return v.panicIfNot(Struct).(*structValue).FieldByName(name) + if f, ok := v.Type().FieldByName(name); ok { + return v.FieldByIndex(f.Index) + } + return Value{} } // FieldByNameFunc returns the struct field with a name @@ -228,7 +380,10 @@ func (v Value) FieldByName(name string) Value { // It panics if v's Kind is not struct. // It returns the zero Value if no field was found. func (v Value) FieldByNameFunc(match func(string) bool) Value { - return v.panicIfNot(Struct).(*structValue).FieldByNameFunc(match) + if f, ok := v.Type().FieldByNameFunc(match); ok { + return v.FieldByIndex(f.Index) + } + return Value{} } var floatKinds = []Kind{Float32, Float64} @@ -236,7 +391,16 @@ var floatKinds = []Kind{Float32, Float64} // Float returns v's underlying value, as an float64. // It panics if v's Kind is not Float32 or Float64 func (v Value) Float() float64 { - return v.panicIfNots(floatKinds).(*floatValue).Get() + vv := v.panicIfNots(floatKinds).(*floatValue) + + switch vv.typ.Kind() { + case Float32: + return float64(*(*float32)(vv.addr)) + case Float64: + return *(*float64)(vv.addr) + } + panic("reflect: invalid float kind") + } var arrayOrSlice = []Kind{Array, Slice} @@ -244,7 +408,29 @@ var arrayOrSlice = []Kind{Array, Slice} // Index returns v's i'th element. // It panics if v's Kind is not Array or Slice. func (v Value) Index(i int) Value { - return v.panicIfNots(arrayOrSlice).(arrayOrSliceValue).Elem(i) + switch vv := v.panicIfNots(arrayOrSlice).(type) { + case *arrayValue: + typ := vv.typ.Elem() + n := v.Len() + if i < 0 || i >= n { + panic("array index out of bounds") + } + p := addr(uintptr(vv.addr()) + uintptr(i)*typ.Size()) + return newValue(typ, p, vv.flag) + case *sliceValue: + typ := vv.typ.Elem() + n := v.Len() + if i < 0 || i >= n { + panic("reflect: slice index out of range") + } + p := addr(uintptr(vv.addr()) + uintptr(i)*typ.Size()) + flag := canAddr + if vv.flag&canStore != 0 { + flag |= canSet | canStore + } + return newValue(typ, p, flag) + } + panic("not reached") } var intKinds = []Kind{Int, Int8, Int16, Int32, Int64} @@ -252,7 +438,21 @@ var intKinds = []Kind{Int, Int8, Int16, Int32, Int64} // Int returns v's underlying value, as an int64. // It panics if v's Kind is not a sized or unsized Int kind. func (v Value) Int() int64 { - return v.panicIfNots(intKinds).(*intValue).Get() + vv := v.panicIfNots(intKinds).(*intValue) + + switch vv.typ.Kind() { + case Int: + return int64(*(*int)(vv.addr)) + case Int8: + return int64(*(*int8)(vv.addr)) + case Int16: + return int64(*(*int16)(vv.addr)) + case Int32: + return int64(*(*int32)(vv.addr)) + case Int64: + return *(*int64)(vv.addr) + } + panic("reflect: invalid int kind") } // Interface returns v's value as an interface{}. @@ -266,19 +466,31 @@ func (v Value) Interface() interface{} { // InterfaceData returns the interface v's value as a uintptr pair. // It panics if v's Kind is not Interface. func (v Value) InterfaceData() [2]uintptr { - return v.panicIfNot(Interface).(*interfaceValue).Get() + vv := v.panicIfNot(Interface).(*interfaceValue) + + return *(*[2]uintptr)(vv.addr) } var nilKinds = []Kind{Chan, Func, Interface, Map, Ptr, Slice} -type isNiller interface { - IsNil() bool -} - // IsNil returns true if v is a nil value. // It panics if v's Kind is not Chan, Func, Interface, Map, Ptr, or Slice. func (v Value) IsNil() bool { - return v.panicIfNots(nilKinds).(isNiller).IsNil() + switch vv := v.panicIfNots(nilKinds).(type) { + case *chanValue: + return *(*uintptr)(vv.addr) == 0 + case *funcValue: + return *(*uintptr)(vv.addr) == 0 + case *interfaceValue: + return vv.Interface() == nil + case *mapValue: + return *(*uintptr)(vv.addr) == 0 + case *ptrValue: + return *(*uintptr)(vv.addr) == 0 + case *sliceValue: + return vv.slice().Data == 0 + } + panic("not reached") } // IsValid returns true if v represents a value. @@ -301,28 +513,68 @@ func (v Value) Kind() Kind { var lenKinds = []Kind{Array, Chan, Map, Slice} -type lenner interface { - Len() int -} - // Len returns v's length. // It panics if v's Kind is not Array, Chan, Map, or Slice. func (v Value) Len() int { - return v.panicIfNots(lenKinds).(lenner).Len() + switch vv := v.panicIfNots(lenKinds).(type) { + case *arrayValue: + return vv.typ.Len() + case *chanValue: + ch := *(**byte)(vv.addr) + return int(chanlen(ch)) + case *mapValue: + m := *(**byte)(vv.addr) + if m == nil { + return 0 + } + return int(maplen(m)) + case *sliceValue: + return int(vv.slice().Len) + } + panic("not reached") } // MapIndex returns the value associated with key in the map v. // It panics if v's Kind is not Map. // It returns the zero Value if key is not found in the map. func (v Value) MapIndex(key Value) Value { - return v.panicIfNot(Map).(*mapValue).Elem(key) + vv := v.panicIfNot(Map).(*mapValue) + t := vv.Type() + typesMustMatch(t.Key(), key.Type()) + m := *(**byte)(vv.addr) + if m == nil { + return Value{} + } + newval := Zero(t.Elem()) + if !mapaccess(m, (*byte)(key.internal().getAddr()), (*byte)(newval.internal().getAddr())) { + return Value{} + } + return newval } // MapKeys returns a slice containing all the keys present in the map, // in unspecified order. // It panics if v's Kind is not Map. func (v Value) MapKeys() []Value { - return v.panicIfNot(Map).(*mapValue).Keys() + vv := v.panicIfNot(Map).(*mapValue) + tk := vv.Type().Key() + m := *(**byte)(vv.addr) + mlen := int32(0) + if m != nil { + mlen = maplen(m) + } + it := mapiterinit(m) + a := make([]Value, mlen) + var i int + for i = 0; i < len(a); i++ { + k := Zero(tk) + if !mapiterkey(it, (*byte)(k.internal().getAddr())) { + break + } + a[i] = k + mapiternext(it) + } + return a[0:i] } // Method returns a function value corresponding to v's i'th method. @@ -335,124 +587,390 @@ func (v Value) Method(i int) Value { // NumField returns the number of fields in the struct v. // It panics if v's Kind is not Struct. func (v Value) NumField() int { - return v.panicIfNot(Struct).(*structValue).NumField() + return v.panicIfNot(Struct).(*structValue).typ.NumField() } // OverflowComplex returns true if the complex128 x cannot be represented by v's type. // It panics if v's Kind is not Complex64 or Complex128. func (v Value) OverflowComplex(x complex128) bool { - return v.panicIfNots(complexKinds).(*complexValue).Overflow(x) + vv := v.panicIfNots(complexKinds).(*complexValue) + + if vv.typ.Size() == 16 { + return false + } + r := real(x) + i := imag(x) + if r < 0 { + r = -r + } + if i < 0 { + i = -i + } + return math.MaxFloat32 <= r && r <= math.MaxFloat64 || + math.MaxFloat32 <= i && i <= math.MaxFloat64 } // OverflowFloat returns true if the float64 x cannot be represented by v's type. // It panics if v's Kind is not Float32 or Float64. func (v Value) OverflowFloat(x float64) bool { - return v.panicIfNots(floatKinds).(*floatValue).Overflow(x) + vv := v.panicIfNots(floatKinds).(*floatValue) + + if vv.typ.Size() == 8 { + return false + } + if x < 0 { + x = -x + } + return math.MaxFloat32 < x && x <= math.MaxFloat64 } // OverflowInt returns true if the int64 x cannot be represented by v's type. // It panics if v's Kind is not a sized or unsized Int kind. func (v Value) OverflowInt(x int64) bool { - return v.panicIfNots(intKinds).(*intValue).Overflow(x) + vv := v.panicIfNots(intKinds).(*intValue) + + bitSize := uint(vv.typ.Bits()) + trunc := (x << (64 - bitSize)) >> (64 - bitSize) + return x != trunc } // OverflowUint returns true if the uint64 x cannot be represented by v's type. // It panics if v's Kind is not a sized or unsized Uint kind. func (v Value) OverflowUint(x uint64) bool { - return v.panicIfNots(uintKinds).(*uintValue).Overflow(x) + vv := v.panicIfNots(uintKinds).(*uintValue) + + bitSize := uint(vv.typ.Bits()) + trunc := (x << (64 - bitSize)) >> (64 - bitSize) + return x != trunc } var pointerKinds = []Kind{Chan, Func, Map, Ptr, Slice, UnsafePointer} -type uintptrGetter interface { - Get() uintptr -} - // Pointer returns v's value as a uintptr. // It returns uintptr instead of unsafe.Pointer so that // code using reflect cannot obtain unsafe.Pointers // without importing the unsafe package explicitly. // It panics if v's Kind is not Chan, Func, Map, Ptr, Slice, or UnsafePointer. func (v Value) Pointer() uintptr { - return v.panicIfNots(pointerKinds).(uintptrGetter).Get() + switch vv := v.panicIfNots(pointerKinds).(type) { + case *chanValue: + return *(*uintptr)(vv.addr) + case *funcValue: + return *(*uintptr)(vv.addr) + case *mapValue: + return *(*uintptr)(vv.addr) + case *ptrValue: + return *(*uintptr)(vv.addr) + case *sliceValue: + typ := vv.typ + return uintptr(vv.addr()) + uintptr(v.Cap())*typ.Elem().Size() + case *unsafePointerValue: + return uintptr(*(*unsafe.Pointer)(vv.addr)) + } + panic("not reached") } - // Recv receives and returns a value from the channel v. // It panics if v's Kind is not Chan. // The receive blocks until a value is ready. // The boolean value ok is true if the value x corresponds to a send // on the channel, false if it is a zero value received because the channel is closed. func (v Value) Recv() (x Value, ok bool) { - return v.panicIfNot(Chan).(*chanValue).Recv() + return v.panicIfNot(Chan).(*chanValue).recv(nil) +} + +// internal recv; non-blocking if selected != nil +func (v *chanValue) recv(selected *bool) (Value, bool) { + t := v.Type() + if t.ChanDir()&RecvDir == 0 { + panic("recv on send-only channel") + } + ch := *(**byte)(v.addr) + x := Zero(t.Elem()) + var ok bool + chanrecv(ch, (*byte)(x.internal().getAddr()), selected, &ok) + return x, ok } // Send sends x on the channel v. // It panics if v's kind is not Chan or if x's type is not the same type as v's element type. func (v Value) Send(x Value) { - v.panicIfNot(Chan).(*chanValue).Send(x) + v.panicIfNot(Chan).(*chanValue).send(x, nil) +} + +// internal send; non-blocking if selected != nil +func (v *chanValue) send(x Value, selected *bool) { + t := v.Type() + if t.ChanDir()&SendDir == 0 { + panic("send on recv-only channel") + } + typesMustMatch(t.Elem(), x.Type()) + ch := *(**byte)(v.addr) + chansend(ch, (*byte)(x.internal().getAddr()), selected) } // Set assigns x to the value v; x must have the same type as v. // It panics if CanSet() returns false or if x is the zero Value. func (v Value) Set(x Value) { x.internal() - v.internal().SetValue(x) + switch vv := v.internal().(type) { + case *arrayValue: + xx := x.panicIfNot(Array).(*arrayValue) + if !vv.CanSet() { + panic(cannotSet) + } + typesMustMatch(vv.typ, xx.typ) + Copy(v, x) + + case *boolValue: + v.SetBool(x.Bool()) + + case *chanValue: + x := x.panicIfNot(Chan).(*chanValue) + if !vv.CanSet() { + panic(cannotSet) + } + typesMustMatch(vv.typ, x.typ) + *(*uintptr)(vv.addr) = *(*uintptr)(x.addr) + + case *floatValue: + v.SetFloat(x.Float()) + + case *funcValue: + x := x.panicIfNot(Func).(*funcValue) + if !vv.CanSet() { + panic(cannotSet) + } + typesMustMatch(vv.typ, x.typ) + *(*uintptr)(vv.addr) = *(*uintptr)(x.addr) + + case *intValue: + v.SetInt(x.Int()) + + case *interfaceValue: + i := x.Interface() + if !vv.CanSet() { + panic(cannotSet) + } + // Two different representations; see comment in Get. + // Empty interface is easy. + t := (*interfaceType)(unsafe.Pointer(vv.typ.(*commonType))) + if t.NumMethod() == 0 { + *(*interface{})(vv.addr) = i + return + } + + // Non-empty interface requires a runtime check. + setiface(t, &i, vv.addr) + + case *mapValue: + x := x.panicIfNot(Map).(*mapValue) + if !vv.CanSet() { + panic(cannotSet) + } + if x == nil { + *(**uintptr)(vv.addr) = nil + return + } + typesMustMatch(vv.typ, x.typ) + *(*uintptr)(vv.addr) = *(*uintptr)(x.addr) + + case *ptrValue: + x := x.panicIfNot(Ptr).(*ptrValue) + if x == nil { + *(**uintptr)(vv.addr) = nil + return + } + if !vv.CanSet() { + panic(cannotSet) + } + if x.flag&canStore == 0 { + panic("cannot copy pointer obtained from unexported struct field") + } + typesMustMatch(vv.typ, x.typ) + // TODO: This will have to move into the runtime + // once the new gc goes in + *(*uintptr)(vv.addr) = *(*uintptr)(x.addr) + + case *sliceValue: + x := x.panicIfNot(Slice).(*sliceValue) + if !vv.CanSet() { + panic(cannotSet) + } + typesMustMatch(vv.typ, x.typ) + *vv.slice() = *x.slice() + + case *stringValue: + // Do the kind check explicitly, because x.String() does not. + x.panicIfNot(String) + v.SetString(x.String()) + + case *structValue: + x := x.panicIfNot(Struct).(*structValue) + // TODO: This will have to move into the runtime + // once the gc goes in. + if !vv.CanSet() { + panic(cannotSet) + } + typesMustMatch(vv.typ, x.typ) + memmove(vv.addr, x.addr, vv.typ.Size()) + + case *uintValue: + v.SetUint(x.Uint()) + + case *unsafePointerValue: + // Do the kind check explicitly, because x.UnsafePointer + // applies to more than just the UnsafePointer Kind. + x.panicIfNot(UnsafePointer) + v.SetPointer(unsafe.Pointer(x.Pointer())) + } } // SetBool sets v's underlying value. // It panics if v's Kind is not Bool or if CanSet() is false. func (v Value) SetBool(x bool) { - v.panicIfNot(Bool).(*boolValue).Set(x) + vv := v.panicIfNot(Bool).(*boolValue) + + if !vv.CanSet() { + panic(cannotSet) + } + *(*bool)(vv.addr) = x } // SetComplex sets v's underlying value to x. // It panics if v's Kind is not Complex64 or Complex128, or if CanSet() is false. func (v Value) SetComplex(x complex128) { - v.panicIfNots(complexKinds).(*complexValue).Set(x) + vv := v.panicIfNots(complexKinds).(*complexValue) + + if !vv.CanSet() { + panic(cannotSet) + } + switch vv.typ.Kind() { + default: + panic("reflect: invalid complex kind") + case Complex64: + *(*complex64)(vv.addr) = complex64(x) + case Complex128: + *(*complex128)(vv.addr) = x + } } // SetFloat sets v's underlying value to x. // It panics if v's Kind is not Float32 or Float64, or if CanSet() is false. func (v Value) SetFloat(x float64) { - v.panicIfNots(floatKinds).(*floatValue).Set(x) + vv := v.panicIfNots(floatKinds).(*floatValue) + + if !vv.CanSet() { + panic(cannotSet) + } + switch vv.typ.Kind() { + default: + panic("reflect: invalid float kind") + case Float32: + *(*float32)(vv.addr) = float32(x) + case Float64: + *(*float64)(vv.addr) = x + } } // SetInt sets v's underlying value to x. // It panics if v's Kind is not a sized or unsized Int kind, or if CanSet() is false. func (v Value) SetInt(x int64) { - v.panicIfNots(intKinds).(*intValue).Set(x) + vv := v.panicIfNots(intKinds).(*intValue) + + if !vv.CanSet() { + panic(cannotSet) + } + switch vv.typ.Kind() { + default: + panic("reflect: invalid int kind") + case Int: + *(*int)(vv.addr) = int(x) + case Int8: + *(*int8)(vv.addr) = int8(x) + case Int16: + *(*int16)(vv.addr) = int16(x) + case Int32: + *(*int32)(vv.addr) = int32(x) + case Int64: + *(*int64)(vv.addr) = x + } } // SetLen sets v's length to n. // It panics if v's Kind is not Slice. func (v Value) SetLen(n int) { - v.panicIfNot(Slice).(*sliceValue).SetLen(n) + vv := v.panicIfNot(Slice).(*sliceValue) + + s := vv.slice() + if n < 0 || n > int(s.Cap) { + panic("reflect: slice length out of range in SetLen") + } + s.Len = n } // SetMapIndex sets the value associated with key in the map v to val. // It panics if v's Kind is not Map. // If val is the zero Value, SetMapIndex deletes the key from the map. func (v Value) SetMapIndex(key, val Value) { - v.panicIfNot(Map).(*mapValue).SetElem(key, val) + vv := v.panicIfNot(Map).(*mapValue) + t := vv.Type() + typesMustMatch(t.Key(), key.Type()) + var vaddr *byte + if val.IsValid() { + typesMustMatch(t.Elem(), val.Type()) + vaddr = (*byte)(val.internal().getAddr()) + } + m := *(**byte)(vv.addr) + mapassign(m, (*byte)(key.internal().getAddr()), vaddr) } // SetUint sets v's underlying value to x. // It panics if v's Kind is not a sized or unsized Uint kind, or if CanSet() is false. func (v Value) SetUint(x uint64) { - v.panicIfNots(uintKinds).(*uintValue).Set(x) + vv := v.panicIfNots(uintKinds).(*uintValue) + + if !vv.CanSet() { + panic(cannotSet) + } + switch vv.typ.Kind() { + default: + panic("reflect: invalid uint kind") + case Uint: + *(*uint)(vv.addr) = uint(x) + case Uint8: + *(*uint8)(vv.addr) = uint8(x) + case Uint16: + *(*uint16)(vv.addr) = uint16(x) + case Uint32: + *(*uint32)(vv.addr) = uint32(x) + case Uint64: + *(*uint64)(vv.addr) = x + case Uintptr: + *(*uintptr)(vv.addr) = uintptr(x) + } } // SetPointer sets the unsafe.Pointer value v to x. // It panics if v's Kind is not UnsafePointer. func (v Value) SetPointer(x unsafe.Pointer) { - v.panicIfNot(UnsafePointer).(*unsafePointerValue).Set(x) + vv := v.panicIfNot(UnsafePointer).(*unsafePointerValue) + + if !vv.CanSet() { + panic(cannotSet) + } + *(*unsafe.Pointer)(vv.addr) = x } // SetString sets v's underlying value to x. // It panics if v's Kind is not String or if CanSet() is false. func (v Value) SetString(x string) { - v.panicIfNot(String).(*stringValue).Set(x) + vv := v.panicIfNot(String).(*stringValue) + + if !vv.CanSet() { + panic(cannotSet) + } + *(*string)(vv.addr) = x } // BUG(rsc): Value.Slice should allow slicing arrays. @@ -460,7 +978,25 @@ func (v Value) SetString(x string) { // Slice returns a slice of v. // It panics if v's Kind is not Slice. func (v Value) Slice(beg, end int) Value { - return v.panicIfNot(Slice).(*sliceValue).Slice(beg, end) + vv := v.panicIfNot(Slice).(*sliceValue) + + cap := v.Cap() + if beg < 0 || end < beg || end > cap { + panic("slice index out of bounds") + } + typ := vv.typ + s := new(SliceHeader) + s.Data = uintptr(vv.addr()) + uintptr(beg)*typ.Elem().Size() + s.Len = end - beg + s.Cap = cap - beg + + // Like the result of Addr, we treat Slice as an + // unaddressable temporary, so don't set canAddr. + flag := canSet + if vv.flag&canStore != 0 { + flag |= canStore + } + return newValue(typ, addr(s), flag) } // String returns the string v's underlying value, as a string. @@ -473,7 +1009,8 @@ func (v Value) String() string { return "<invalid Value>" } if vi.Kind() == String { - return vi.(*stringValue).Get() + vv := vi.(*stringValue) + return *(*string)(vv.addr) } return "<" + vi.Type().String() + " Value>" } @@ -484,14 +1021,25 @@ func (v Value) String() string { // The boolean ok is true if the value x corresponds to a send // on the channel, false if it is a zero value received because the channel is closed. func (v Value) TryRecv() (x Value, ok bool) { - return v.panicIfNot(Chan).(*chanValue).TryRecv() + vv := v.panicIfNot(Chan).(*chanValue) + + var selected bool + x, ok = vv.recv(&selected) + if !selected { + return Value{}, false + } + return x, ok } // TrySend attempts to send x on the channel v but will not block. // It panics if v's Kind is not Chan. // It returns true if the value was sent, false otherwise. func (v Value) TrySend(x Value) bool { - return v.panicIfNot(Chan).(*chanValue).TrySend(x) + vv := v.panicIfNot(Chan).(*chanValue) + + var selected bool + vv.send(x, &selected) + return selected } // Type returns v's type. @@ -504,7 +1052,23 @@ var uintKinds = []Kind{Uint, Uint8, Uint16, Uint32, Uint64, Uintptr} // Uint returns v's underlying value, as a uint64. // It panics if v's Kind is not a sized or unsized Uint kind. func (v Value) Uint() uint64 { - return v.panicIfNots(uintKinds).(*uintValue).Get() + vv := v.panicIfNots(uintKinds).(*uintValue) + + switch vv.typ.Kind() { + case Uint: + return uint64(*(*uint)(vv.addr)) + case Uint8: + return uint64(*(*uint8)(vv.addr)) + case Uint16: + return uint64(*(*uint16)(vv.addr)) + case Uint32: + return uint64(*(*uint32)(vv.addr)) + case Uint64: + return *(*uint64)(vv.addr) + case Uintptr: + return uint64(*(*uintptr)(vv.addr)) + } + panic("reflect: invalid uint kind") } // UnsafeAddr returns a pointer to v's data. @@ -529,9 +1093,6 @@ type valueInterface interface { // If CanSet returns false, calling the type-specific Set will panic. CanSet() bool - // SetValue assigns v to the value; v must have the same type as the value. - SetValue(v Value) - // CanAddr returns true if the value's address can be obtained with Addr. // Such values are called addressable. A value is addressable if it is // an element of a slice, an element of an addressable array, @@ -635,169 +1196,21 @@ type boolValue struct { value "bool" } -// Get returns the underlying bool value. -func (v *boolValue) Get() bool { return *(*bool)(v.addr) } - -// Set sets v to the value x. -func (v *boolValue) Set(x bool) { - if !v.CanSet() { - panic(cannotSet) - } - *(*bool)(v.addr) = x -} - -// Set sets v to the value x. -func (v *boolValue) SetValue(x Value) { v.Set(x.Bool()) } - // floatValue represents a float value. type floatValue struct { value "float" } -// Get returns the underlying int value. -func (v *floatValue) Get() float64 { - switch v.typ.Kind() { - case Float32: - return float64(*(*float32)(v.addr)) - case Float64: - return *(*float64)(v.addr) - } - panic("reflect: invalid float kind") -} - -// Set sets v to the value x. -func (v *floatValue) Set(x float64) { - if !v.CanSet() { - panic(cannotSet) - } - switch v.typ.Kind() { - default: - panic("reflect: invalid float kind") - case Float32: - *(*float32)(v.addr) = float32(x) - case Float64: - *(*float64)(v.addr) = x - } -} - -// Overflow returns true if x cannot be represented by the type of v. -func (v *floatValue) Overflow(x float64) bool { - if v.typ.Size() == 8 { - return false - } - if x < 0 { - x = -x - } - return math.MaxFloat32 < x && x <= math.MaxFloat64 -} - -// Set sets v to the value x. -func (v *floatValue) SetValue(x Value) { v.Set(x.Float()) } - // complexValue represents a complex value. type complexValue struct { value "complex" } -// Get returns the underlying complex value. -func (v *complexValue) Get() complex128 { - switch v.typ.Kind() { - case Complex64: - return complex128(*(*complex64)(v.addr)) - case Complex128: - return *(*complex128)(v.addr) - } - panic("reflect: invalid complex kind") -} - -// Set sets v to the value x. -func (v *complexValue) Set(x complex128) { - if !v.CanSet() { - panic(cannotSet) - } - switch v.typ.Kind() { - default: - panic("reflect: invalid complex kind") - case Complex64: - *(*complex64)(v.addr) = complex64(x) - case Complex128: - *(*complex128)(v.addr) = x - } -} - -// How did we forget this one? -func (v *complexValue) Overflow(x complex128) bool { - if v.typ.Size() == 16 { - return false - } - r := real(x) - i := imag(x) - if r < 0 { - r = -r - } - if i < 0 { - i = -i - } - return math.MaxFloat32 <= r && r <= math.MaxFloat64 || - math.MaxFloat32 <= i && i <= math.MaxFloat64 -} - -// Set sets v to the value x. -func (v *complexValue) SetValue(x Value) { v.Set(x.Complex()) } - // intValue represents an int value. type intValue struct { value "int" } -// Get returns the underlying int value. -func (v *intValue) Get() int64 { - switch v.typ.Kind() { - case Int: - return int64(*(*int)(v.addr)) - case Int8: - return int64(*(*int8)(v.addr)) - case Int16: - return int64(*(*int16)(v.addr)) - case Int32: - return int64(*(*int32)(v.addr)) - case Int64: - return *(*int64)(v.addr) - } - panic("reflect: invalid int kind") -} - -// Set sets v to the value x. -func (v *intValue) Set(x int64) { - if !v.CanSet() { - panic(cannotSet) - } - switch v.typ.Kind() { - default: - panic("reflect: invalid int kind") - case Int: - *(*int)(v.addr) = int(x) - case Int8: - *(*int8)(v.addr) = int8(x) - case Int16: - *(*int16)(v.addr) = int16(x) - case Int32: - *(*int32)(v.addr) = int32(x) - case Int64: - *(*int64)(v.addr) = x - } -} - -// Set sets v to the value x. -func (v *intValue) SetValue(x Value) { v.Set(x.Int()) } - -// Overflow returns true if x cannot be represented by the type of v. -func (v *intValue) Overflow(x int64) bool { - bitSize := uint(v.typ.Bits()) - trunc := (x << (64 - bitSize)) >> (64 - bitSize) - return x != trunc -} - // StringHeader is the runtime representation of a string. type StringHeader struct { Data uintptr @@ -809,106 +1222,16 @@ type stringValue struct { value "string" } -// Get returns the underlying string value. -func (v *stringValue) Get() string { return *(*string)(v.addr) } - -// Set sets v to the value x. -func (v *stringValue) Set(x string) { - if !v.CanSet() { - panic(cannotSet) - } - *(*string)(v.addr) = x -} - -// Set sets v to the value x. -func (v *stringValue) SetValue(x Value) { - // Do the kind check explicitly, because x.String() does not. - v.Set(x.panicIfNot(String).(*stringValue).Get()) -} - // uintValue represents a uint value. type uintValue struct { value "uint" } -// Get returns the underlying uuint value. -func (v *uintValue) Get() uint64 { - switch v.typ.Kind() { - case Uint: - return uint64(*(*uint)(v.addr)) - case Uint8: - return uint64(*(*uint8)(v.addr)) - case Uint16: - return uint64(*(*uint16)(v.addr)) - case Uint32: - return uint64(*(*uint32)(v.addr)) - case Uint64: - return *(*uint64)(v.addr) - case Uintptr: - return uint64(*(*uintptr)(v.addr)) - } - panic("reflect: invalid uint kind") -} - -// Set sets v to the value x. -func (v *uintValue) Set(x uint64) { - if !v.CanSet() { - panic(cannotSet) - } - switch v.typ.Kind() { - default: - panic("reflect: invalid uint kind") - case Uint: - *(*uint)(v.addr) = uint(x) - case Uint8: - *(*uint8)(v.addr) = uint8(x) - case Uint16: - *(*uint16)(v.addr) = uint16(x) - case Uint32: - *(*uint32)(v.addr) = uint32(x) - case Uint64: - *(*uint64)(v.addr) = x - case Uintptr: - *(*uintptr)(v.addr) = uintptr(x) - } -} - -// Overflow returns true if x cannot be represented by the type of v. -func (v *uintValue) Overflow(x uint64) bool { - bitSize := uint(v.typ.Bits()) - trunc := (x << (64 - bitSize)) >> (64 - bitSize) - return x != trunc -} - -// Set sets v to the value x. -func (v *uintValue) SetValue(x Value) { v.Set(x.Uint()) } - // unsafePointerValue represents an unsafe.Pointer value. type unsafePointerValue struct { value "unsafe.Pointer" } -// Get returns the underlying uintptr value. -// Get returns uintptr, not unsafe.Pointer, so that -// programs that do not import "unsafe" cannot -// obtain a value of unsafe.Pointer type from "reflect". -func (v *unsafePointerValue) Get() uintptr { return uintptr(*(*unsafe.Pointer)(v.addr)) } - -// Set sets v to the value x. -func (v *unsafePointerValue) Set(x unsafe.Pointer) { - if !v.CanSet() { - panic(cannotSet) - } - *(*unsafe.Pointer)(v.addr) = x -} - -// Set sets v to the value x. -func (v *unsafePointerValue) SetValue(x Value) { - // Do the kind check explicitly, because x.UnsafePointer - // applies to more than just the UnsafePointer Kind. - v.Set(unsafe.Pointer(x.panicIfNot(UnsafePointer).(*unsafePointerValue).Get())) -} - func typesMustMatch(t1, t2 Type) { if t1 != t2 { panic("type mismatch: " + t1.String() + " != " + t2.String()) @@ -923,9 +1246,6 @@ func typesMustMatch(t1, t2 Type) { // implemented by both arrayValue and sliceValue. type arrayOrSliceValue interface { valueInterface - Len() int - Cap() int - Elem(i int) Value addr() addr } @@ -961,9 +1281,9 @@ func grow(s Value, extra int) (Value, int, int) { // Each x must have the same type as s' element type. func Append(s Value, x ...Value) Value { s, i0, i1 := grow(s, len(x)) - sa := s.panicIfNot(Slice).(*sliceValue) + s.panicIfNot(Slice) for i, j := i0, 0; i < i1; i, j = i+1, j+1 { - sa.Elem(i).Set(x[j]) + s.Index(i).Set(x[j]) } return s } @@ -1002,41 +1322,9 @@ type arrayValue struct { value "array" } -// Len returns the length of the array. -func (v *arrayValue) Len() int { return v.typ.Len() } - -// Cap returns the capacity of the array (equal to Len()). -func (v *arrayValue) Cap() int { return v.typ.Len() } - // addr returns the base address of the data in the array. func (v *arrayValue) addr() addr { return v.value.addr } -// Set assigns x to v. -// The new value x must have the same type as v. -func (v *arrayValue) Set(x *arrayValue) { - if !v.CanSet() { - panic(cannotSet) - } - typesMustMatch(v.typ, x.typ) - Copy(Value{v}, Value{x}) -} - -// Set sets v to the value x. -func (v *arrayValue) SetValue(x Value) { - v.Set(x.panicIfNot(Array).(*arrayValue)) -} - -// Elem returns the i'th element of v. -func (v *arrayValue) Elem(i int) Value { - typ := v.typ.Elem() - n := v.Len() - if i < 0 || i >= n { - panic("array index out of bounds") - } - p := addr(uintptr(v.addr()) + uintptr(i)*typ.Size()) - return newValue(typ, p, v.flag) -} - /* * slice */ @@ -1055,87 +1343,9 @@ type sliceValue struct { func (v *sliceValue) slice() *SliceHeader { return (*SliceHeader)(v.value.addr) } -// IsNil returns whether v is a nil slice. -func (v *sliceValue) IsNil() bool { return v.slice().Data == 0 } - -// Len returns the length of the slice. -func (v *sliceValue) Len() int { return int(v.slice().Len) } - -// Cap returns the capacity of the slice. -func (v *sliceValue) Cap() int { return int(v.slice().Cap) } - // addr returns the base address of the data in the slice. func (v *sliceValue) addr() addr { return addr(v.slice().Data) } -// SetLen changes the length of v. -// The new length n must be between 0 and the capacity, inclusive. -func (v *sliceValue) SetLen(n int) { - s := v.slice() - if n < 0 || n > int(s.Cap) { - panic("reflect: slice length out of range in SetLen") - } - s.Len = n -} - -// Set assigns x to v. -// The new value x must have the same type as v. -func (v *sliceValue) Set(x *sliceValue) { - if !v.CanSet() { - panic(cannotSet) - } - typesMustMatch(v.typ, x.typ) - *v.slice() = *x.slice() -} - -// Set sets v to the value x. -func (v *sliceValue) SetValue(x Value) { - v.Set(x.panicIfNot(Slice).(*sliceValue)) -} - -// Get returns the uintptr address of the v.Cap()'th element. This gives -// the same result for all slices of the same array. -// It is mainly useful for printing. -func (v *sliceValue) Get() uintptr { - typ := v.typ - return uintptr(v.addr()) + uintptr(v.Cap())*typ.Elem().Size() -} - -// Slice returns a sub-slice of the slice v. -func (v *sliceValue) Slice(beg, end int) Value { - cap := v.Cap() - if beg < 0 || end < beg || end > cap { - panic("slice index out of bounds") - } - typ := v.typ - s := new(SliceHeader) - s.Data = uintptr(v.addr()) + uintptr(beg)*typ.Elem().Size() - s.Len = end - beg - s.Cap = cap - beg - - // Like the result of Addr, we treat Slice as an - // unaddressable temporary, so don't set canAddr. - flag := canSet - if v.flag&canStore != 0 { - flag |= canStore - } - return newValue(typ, addr(s), flag) -} - -// Elem returns the i'th element of v. -func (v *sliceValue) Elem(i int) Value { - typ := v.typ.Elem() - n := v.Len() - if i < 0 || i >= n { - panic("reflect: slice index out of range") - } - p := addr(uintptr(v.addr()) + uintptr(i)*typ.Size()) - flag := canAddr - if v.flag&canStore != 0 { - flag |= canSet | canStore - } - return newValue(typ, p, flag) -} - // MakeSlice creates a new zero-initialized slice value // for the specified slice type, length, and capacity. func MakeSlice(typ Type, len, cap int) Value { @@ -1159,28 +1369,6 @@ type chanValue struct { value "chan" } -// IsNil returns whether v is a nil channel. -func (v *chanValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 } - -// Set assigns x to v. -// The new value x must have the same type as v. -func (v *chanValue) Set(x *chanValue) { - if !v.CanSet() { - panic(cannotSet) - } - typesMustMatch(v.typ, x.typ) - *(*uintptr)(v.addr) = *(*uintptr)(x.addr) -} - -// Set sets v to the value x. -func (v *chanValue) SetValue(x Value) { - v.Set(x.panicIfNot(Chan).(*chanValue)) -} - -// Get returns the uintptr value of v. -// It is mainly useful for printing. -func (v *chanValue) Get() uintptr { return *(*uintptr)(v.addr) } - // implemented in ../pkg/runtime/reflect.cgo func makechan(typ *runtime.ChanType, size uint32) (ch *byte) func chansend(ch, val *byte, selected *bool) @@ -1189,79 +1377,6 @@ func chanclose(ch *byte) func chanlen(ch *byte) int32 func chancap(ch *byte) int32 -// Close closes the channel. -func (v *chanValue) Close() { - ch := *(**byte)(v.addr) - chanclose(ch) -} - -func (v *chanValue) Len() int { - ch := *(**byte)(v.addr) - return int(chanlen(ch)) -} - -func (v *chanValue) Cap() int { - ch := *(**byte)(v.addr) - return int(chancap(ch)) -} - -// internal send; non-blocking if selected != nil -func (v *chanValue) send(x Value, selected *bool) { - t := v.Type() - if t.ChanDir()&SendDir == 0 { - panic("send on recv-only channel") - } - typesMustMatch(t.Elem(), x.Type()) - ch := *(**byte)(v.addr) - chansend(ch, (*byte)(x.internal().getAddr()), selected) -} - -// internal recv; non-blocking if selected != nil -func (v *chanValue) recv(selected *bool) (Value, bool) { - t := v.Type() - if t.ChanDir()&RecvDir == 0 { - panic("recv on send-only channel") - } - ch := *(**byte)(v.addr) - x := Zero(t.Elem()) - var ok bool - chanrecv(ch, (*byte)(x.internal().getAddr()), selected, &ok) - return x, ok -} - -// Send sends x on the channel v. -func (v *chanValue) Send(x Value) { v.send(x, nil) } - -// Recv receives and returns a value from the channel v. -// The receive blocks until a value is ready. -// The boolean value ok is true if the value x corresponds to a send -// on the channel, false if it is a zero value received because the channel is closed. -func (v *chanValue) Recv() (x Value, ok bool) { - return v.recv(nil) -} - -// TrySend attempts to sends x on the channel v but will not block. -// It returns true if the value was sent, false otherwise. -func (v *chanValue) TrySend(x Value) bool { - var selected bool - v.send(x, &selected) - return selected -} - -// TryRecv attempts to receive a value from the channel v but will not block. -// If the receive cannot finish without blocking, TryRecv instead returns x == nil. -// If the receive can finish without blocking, TryRecv returns x != nil. -// The boolean value ok is true if the value x corresponds to a send -// on the channel, false if it is a zero value received because the channel is closed. -func (v *chanValue) TryRecv() (x Value, ok bool) { - var selected bool - x, ok = v.recv(&selected) - if !selected { - return Value{}, false - } - return x, ok -} - // MakeChan creates a new channel with the specified type and buffer size. func MakeChan(typ Type, buffer int) Value { if typ.Kind() != Chan { @@ -1290,28 +1405,6 @@ type funcValue struct { isInterface bool } -// IsNil returns whether v is a nil function. -func (v *funcValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 } - -// Get returns the uintptr value of v. -// It is mainly useful for printing. -func (v *funcValue) Get() uintptr { return *(*uintptr)(v.addr) } - -// Set assigns x to v. -// The new value x must have the same type as v. -func (v *funcValue) Set(x *funcValue) { - if !v.CanSet() { - panic(cannotSet) - } - typesMustMatch(v.typ, x.typ) - *(*uintptr)(v.addr) = *(*uintptr)(x.addr) -} - -// Set sets v to the value x. -func (v *funcValue) SetValue(x Value) { - v.Set(x.panicIfNot(Func).(*funcValue)) -} - // Method returns a funcValue corresponding to v's i'th method. // The arguments to a Call on the returned funcValue // should not include a receiver; the funcValue will use v @@ -1330,10 +1423,6 @@ func (v *value) Method(i int) Value { // implemented in ../pkg/runtime/*/asm.s func call(fn, arg *byte, n uint32) -type tiny struct { - b byte -} - // Interface returns the fv as an interface value. // If fv is a method obtained by invoking Value.Method // (as opposed to Type.Method), Interface cannot return an @@ -1345,111 +1434,6 @@ func (fv *funcValue) Interface() interface{} { return fv.value.Interface() } -// Call calls the function fv with input parameters in. -// It returns the function's output parameters as Values. -func (fv *funcValue) Call(in []Value) []Value { - t := fv.Type() - nin := len(in) - if fv.first != nil && !fv.isInterface { - nin++ - } - if nin != t.NumIn() { - panic("funcValue: wrong argument count") - } - nout := t.NumOut() - - // Compute arg size & allocate. - // This computation is 6g/8g-dependent - // and probably wrong for gccgo, but so - // is most of this function. - size := uintptr(0) - if fv.isInterface { - // extra word for interface value - size += ptrSize - } - for i := 0; i < nin; i++ { - tv := t.In(i) - a := uintptr(tv.Align()) - size = (size + a - 1) &^ (a - 1) - size += tv.Size() - } - size = (size + ptrSize - 1) &^ (ptrSize - 1) - for i := 0; i < nout; i++ { - tv := t.Out(i) - a := uintptr(tv.Align()) - size = (size + a - 1) &^ (a - 1) - size += tv.Size() - } - - // size must be > 0 in order for &args[0] to be valid. - // the argument copying is going to round it up to - // a multiple of ptrSize anyway, so make it ptrSize to begin with. - if size < ptrSize { - size = ptrSize - } - - // round to pointer size - size = (size + ptrSize - 1) &^ (ptrSize - 1) - - // Copy into args. - // - // TODO(rsc): revisit when reference counting happens. - // The values are holding up the in references for us, - // but something must be done for the out references. - // For now make everything look like a pointer by pretending - // to allocate a []*int. - args := make([]*int, size/ptrSize) - ptr := uintptr(unsafe.Pointer(&args[0])) - off := uintptr(0) - delta := 0 - if v := fv.first; v != nil { - // Hard-wired first argument. - if fv.isInterface { - // v is a single uninterpreted word - memmove(addr(ptr), v.getAddr(), ptrSize) - off = ptrSize - } else { - // v is a real value - tv := v.Type() - typesMustMatch(t.In(0), tv) - n := tv.Size() - memmove(addr(ptr), v.getAddr(), n) - off = n - delta = 1 - } - } - for i, v := range in { - tv := v.Type() - typesMustMatch(t.In(i+delta), tv) - a := uintptr(tv.Align()) - off = (off + a - 1) &^ (a - 1) - n := tv.Size() - memmove(addr(ptr+off), v.internal().getAddr(), n) - off += n - } - off = (off + ptrSize - 1) &^ (ptrSize - 1) - - // Call - call(*(**byte)(fv.addr), (*byte)(addr(ptr)), uint32(size)) - - // Copy return values out of args. - // - // TODO(rsc): revisit like above. - ret := make([]Value, nout) - for i := 0; i < nout; i++ { - tv := t.Out(i) - a := uintptr(tv.Align()) - off = (off + a - 1) &^ (a - 1) - v := Zero(tv) - n := tv.Size() - memmove(v.internal().getAddr(), addr(ptr+off), n) - ret[i] = v - off += n - } - - return ret -} - /* * interface */ @@ -1459,44 +1443,9 @@ type interfaceValue struct { value "interface" } -// IsNil returns whether v is a nil interface value. -func (v *interfaceValue) IsNil() bool { return v.Interface() == nil } - -// No single uinptr Get because v.Interface() is available. - -// Get returns the two words that represent an interface in the runtime. -// Those words are useful only when playing unsafe games. -func (v *interfaceValue) Get() [2]uintptr { - return *(*[2]uintptr)(v.addr) -} - -// Elem returns the concrete value stored in the interface value v. -func (v *interfaceValue) Elem() Value { return NewValue(v.Interface()) } - // ../runtime/reflect.cgo func setiface(typ *interfaceType, x *interface{}, addr addr) -// Set assigns x to v. -func (v *interfaceValue) Set(x Value) { - i := x.Interface() - if !v.CanSet() { - panic(cannotSet) - } - // Two different representations; see comment in Get. - // Empty interface is easy. - t := (*interfaceType)(unsafe.Pointer(v.typ.(*commonType))) - if t.NumMethod() == 0 { - *(*interface{})(v.addr) = i - return - } - - // Non-empty interface requires a runtime check. - setiface(t, &i, v.addr) -} - -// Set sets v to the value x. -func (v *interfaceValue) SetValue(x Value) { v.Set(x) } - // Method returns a funcValue corresponding to v's i'th method. // The arguments to a Call on the returned funcValue // should not include a receiver; the funcValue will use v @@ -1527,32 +1476,6 @@ type mapValue struct { value "map" } -// IsNil returns whether v is a nil map value. -func (v *mapValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 } - -// Set assigns x to v. -// The new value x must have the same type as v. -func (v *mapValue) Set(x *mapValue) { - if !v.CanSet() { - panic(cannotSet) - } - if x == nil { - *(**uintptr)(v.addr) = nil - return - } - typesMustMatch(v.typ, x.typ) - *(*uintptr)(v.addr) = *(*uintptr)(x.addr) -} - -// Set sets v to the value x. -func (v *mapValue) SetValue(x Value) { - v.Set(x.panicIfNot(Map).(*mapValue)) -} - -// Get returns the uintptr value of v. -// It is mainly useful for printing. -func (v *mapValue) Get() uintptr { return *(*uintptr)(v.addr) } - // implemented in ../pkg/runtime/reflect.cgo func mapaccess(m, key, val *byte) bool func mapassign(m, key, val *byte) @@ -1562,68 +1485,6 @@ func mapiternext(it *byte) func mapiterkey(it *byte, key *byte) bool func makemap(t *runtime.MapType) *byte -// Elem returns the value associated with key in the map v. -// It returns nil if key is not found in the map. -func (v *mapValue) Elem(key Value) Value { - t := v.Type() - typesMustMatch(t.Key(), key.Type()) - m := *(**byte)(v.addr) - if m == nil { - return Value{} - } - newval := Zero(t.Elem()) - if !mapaccess(m, (*byte)(key.internal().getAddr()), (*byte)(newval.internal().getAddr())) { - return Value{} - } - return newval -} - -// SetElem sets the value associated with key in the map v to val. -// If val is nil, Put deletes the key from map. -func (v *mapValue) SetElem(key, val Value) { - t := v.Type() - typesMustMatch(t.Key(), key.Type()) - var vaddr *byte - if val.IsValid() { - typesMustMatch(t.Elem(), val.Type()) - vaddr = (*byte)(val.internal().getAddr()) - } - m := *(**byte)(v.addr) - mapassign(m, (*byte)(key.internal().getAddr()), vaddr) -} - -// Len returns the number of keys in the map v. -func (v *mapValue) Len() int { - m := *(**byte)(v.addr) - if m == nil { - return 0 - } - return int(maplen(m)) -} - -// Keys returns a slice containing all the keys present in the map, -// in unspecified order. -func (v *mapValue) Keys() []Value { - tk := v.Type().Key() - m := *(**byte)(v.addr) - mlen := int32(0) - if m != nil { - mlen = maplen(m) - } - it := mapiterinit(m) - a := make([]Value, mlen) - var i int - for i = 0; i < len(a); i++ { - k := Zero(tk) - if !mapiterkey(it, (*byte)(k.internal().getAddr())) { - break - } - a[i] = k - mapiternext(it) - } - return a[0:i] -} - // MakeMap creates a new map of the specified type. func MakeMap(typ Type) Value { if typ.Kind() != Map { @@ -1644,66 +1505,6 @@ type ptrValue struct { value "ptr" } -// IsNil returns whether v is a nil pointer. -func (v *ptrValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 } - -// Get returns the uintptr value of v. -// It is mainly useful for printing. -func (v *ptrValue) Get() uintptr { return *(*uintptr)(v.addr) } - -// Set assigns x to v. -// The new value x must have the same type as v, and x.Elem().CanSet() must be true. -func (v *ptrValue) Set(x *ptrValue) { - if x == nil { - *(**uintptr)(v.addr) = nil - return - } - if !v.CanSet() { - panic(cannotSet) - } - if x.flag&canStore == 0 { - panic("cannot copy pointer obtained from unexported struct field") - } - typesMustMatch(v.typ, x.typ) - // TODO: This will have to move into the runtime - // once the new gc goes in - *(*uintptr)(v.addr) = *(*uintptr)(x.addr) -} - -// Set sets v to the value x. -func (v *ptrValue) SetValue(x Value) { - v.Set(x.panicIfNot(Ptr).(*ptrValue)) -} - -// PointTo changes v to point to x. -// If x is a nil Value, PointTo sets v to nil. -func (v *ptrValue) PointTo(x Value) { - if !x.IsValid() { - *(**uintptr)(v.addr) = nil - return - } - if !x.CanSet() { - panic("cannot set x; cannot point to x") - } - typesMustMatch(v.typ.Elem(), x.Type()) - // TODO: This will have to move into the runtime - // once the new gc goes in. - *(*uintptr)(v.addr) = x.UnsafeAddr() -} - -// Elem returns the value that v points to. -// If v is a nil pointer, Elem returns a nil Value. -func (v *ptrValue) Elem() Value { - if v.IsNil() { - return Value{} - } - flag := canAddr - if v.flag&canStore != 0 { - flag |= canSet | canStore - } - return newValue(v.typ.Elem(), *(*addr)(v.addr), flag) -} - // Indirect returns the value that v points to. // If v is a nil pointer, Indirect returns a nil Value. // If v is not a pointer, Indirect returns v. @@ -1711,7 +1512,7 @@ func Indirect(v Value) Value { if v.Kind() != Ptr { return v } - return v.panicIfNot(Ptr).(*ptrValue).Elem() + return v.Elem() } /* @@ -1723,77 +1524,6 @@ type structValue struct { value "struct" } -// Set assigns x to v. -// The new value x must have the same type as v. -func (v *structValue) Set(x *structValue) { - // TODO: This will have to move into the runtime - // once the gc goes in. - if !v.CanSet() { - panic(cannotSet) - } - typesMustMatch(v.typ, x.typ) - memmove(v.addr, x.addr, v.typ.Size()) -} - -// Set sets v to the value x. -func (v *structValue) SetValue(x Value) { - v.Set(x.panicIfNot(Struct).(*structValue)) -} - -// Field returns the i'th field of the struct. -func (v *structValue) Field(i int) Value { - t := v.typ - if i < 0 || i >= t.NumField() { - panic("reflect: Field index out of range") - } - f := t.Field(i) - flag := v.flag - if f.PkgPath != "" { - // unexported field - flag &^= canSet | canStore - } - return newValue(f.Type, addr(uintptr(v.addr)+f.Offset), flag) -} - -// FieldByIndex returns the nested field corresponding to index. -func (t *structValue) FieldByIndex(index []int) (v Value) { - v = Value{t} - for i, x := range index { - if i > 0 { - if v.Kind() == Ptr { - v = v.Elem() - } - if v.Kind() != Struct { - return Value{} - } - } - v = v.Field(x) - } - return -} - -// FieldByName returns the struct field with the given name. -// The result is nil if no field was found. -func (t *structValue) FieldByName(name string) Value { - if f, ok := t.Type().FieldByName(name); ok { - return t.FieldByIndex(f.Index) - } - return Value{} -} - -// FieldByNameFunc returns the struct field with a name that satisfies the -// match function. -// The result is nil if no field was found. -func (t *structValue) FieldByNameFunc(match func(string) bool) Value { - if f, ok := t.Type().FieldByNameFunc(match); ok { - return t.FieldByIndex(f.Index) - } - return Value{} -} - -// NumField returns the number of fields in the struct. -func (v *structValue) NumField() int { return v.typ.NumField() } - /* * constructors */ |