code review 4035044: Update to current version of Go library.

libgo/go/reflect/value.go

 // 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.
 
 package reflect
 
 import (
         "math"
         "runtime"
         "unsafe"
@@ skipping 123 matching lines @@
 // Set sets v to the value x.
 func (v *BoolValue) SetValue(x Value) { v.Set(x.(*BoolValue).Get()) }
 
 // FloatValue represents a float value.
 type FloatValue struct {
         value "float"
 }
 
 // Get returns the underlying int value.
 func (v *FloatValue) Get() float64 {
-        switch v.typ.(*FloatType).Kind() {
-        case Float:
-                return float64(*(*float)(v.addr))
+        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.(*FloatType).Kind() {
+        switch v.typ.Kind() {
         default:
                 panic("reflect: invalid float kind")
-        case Float:
-                *(*float)(v.addr) = float(x)
         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.(*FloatValue).Get()) }
 
 // ComplexValue represents a complex value.
 type ComplexValue struct {
         value "complex"
 }
 
 // Get returns the underlying complex value.
 func (v *ComplexValue) Get() complex128 {
-        switch v.typ.(*ComplexType).Kind() {
-        case Complex:
-                return complex128(*(*complex)(v.addr))
+        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.(*ComplexType).Kind() {
+        switch v.typ.Kind() {
         default:
                 panic("reflect: invalid complex kind")
-        case Complex:
-                *(*complex)(v.addr) = complex(x)
         case Complex64:
                 *(*complex64)(v.addr) = complex64(x)
         case Complex128:
                 *(*complex128)(v.addr) = x
         }
 }
 
 // Set sets v to the value x.
 func (v *ComplexValue) SetValue(x Value) { v.Set(x.(*ComplexValue).Get()) }
 
 // IntValue represents an int value.
 type IntValue struct {
         value "int"
 }
 
 // Get returns the underlying int value.
 func (v *IntValue) Get() int64 {
-        switch v.typ.(*IntType).Kind() {
+        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.(*IntType).Kind() {
+        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)
@@ skipping 37 matching lines @@
 // Set sets v to the value x.
 func (v *StringValue) SetValue(x Value) { v.Set(x.(*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.(*UintType).Kind() {
+        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.(*UintType).Kind() {
+        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)
@@ skipping 51 matching lines @@
 // ArrayOrSliceValue is the common interface
 // implemented by both ArrayValue and SliceValue.
 type ArrayOrSliceValue interface {
         Value
         Len() int
         Cap() int
         Elem(i int) Value
         addr() addr
 }
 
-// ArrayCopy copies the contents of src into dst until either
+// grow grows the slice s so that it can hold extra more values, allocating
+// more capacity if needed. It also returns the old and new slice lengths.
+func grow(s *SliceValue, extra int) (*SliceValue, int, int) {
+        i0 := s.Len()
+        i1 := i0 + extra
+        if i1 < i0 {
+                panic("append: slice overflow")
+        }
+        m := s.Cap()
+        if i1 <= m {
+                return s.Slice(0, i1), i0, i1
+        }
+        if m == 0 {
+                m = extra
+        } else {
+                for m < i1 {
+                        if i0 < 1024 {
+                                m += m
+                        } else {
+                                m += m / 4
+                        }
+                }
+        }
+        t := MakeSlice(s.Type().(*SliceType), i1, m)
+        Copy(t, s)
+        return t, i0, i1
+}
+
+// Append appends the values x to a slice s and returns the resulting slice.
+// Each x must have the same type as s' element type.
+func Append(s *SliceValue, x ...Value) *SliceValue {
+        s, i0, i1 := grow(s, len(x))
+        for i, j := i0, 0; i < i1; i, j = i+1, j+1 {
+                s.Elem(i).SetValue(x[j])
+        }
+        return s
+}
+
+// AppendSlice appends a slice t to a slice s and returns the resulting slice.
+// The slices s and t must have the same element type.
+func AppendSlice(s, t *SliceValue) *SliceValue {
+        s, i0, i1 := grow(s, t.Len())
+        Copy(s.Slice(i0, i1), t)
+        return s
+}
+
+// Copy copies the contents of src into dst until either
 // dst has been filled or src has been exhausted.
 // It returns the number of elements copied.
 // The arrays dst and src must have the same element type.
-func ArrayCopy(dst, src ArrayOrSliceValue) int {
+func Copy(dst, src ArrayOrSliceValue) int {
         // TODO: This will have to move into the runtime
         // once the real gc goes in.
         de := dst.Type().(ArrayOrSliceType).Elem()
         se := src.Type().(ArrayOrSliceType).Elem()
         typesMustMatch(de, se)
         n := dst.Len()
         if xn := src.Len(); n > xn {
                 n = xn
         }
         memmove(dst.addr(), src.addr(), uintptr(n)*de.Size())
@@ skipping 14 matching lines @@
 // 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)
-        ArrayCopy(v, x)
+        Copy(v, x)
 }
 
 // Set sets v to the value x.
 func (v *ArrayValue) SetValue(x Value) { v.Set(x.(*ArrayValue)) }
 
 // Elem returns the i'th element of v.
 func (v *ArrayValue) Elem(i int) Value {
         typ := v.typ.(*ArrayType).Elem()
         n := v.Len()
         if i < 0 || i >= n {
@@ skipping 742 matching lines @@
         panic("newValue" + typ.String())
 }
 
 // MakeZero returns a zero Value for the specified Type.
 func MakeZero(typ Type) Value {
         if typ == nil {
                 return nil
         }
         return newValue(typ, addr(unsafe.New(typ)), true)
 }