qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-21 13:24:40 -07:00
Code Releases Activity

reflect: add Kind, remove Int8Type, Int8Value, etc.

Browse Source 
update other code to match.

R=r
CC=golang-dev
https://golang.org/cl/1680044
This commit is contained in:
Russ Cox 2010-06-20 12:16:25 -07:00
parent 9f002f6892
commit 45bdf0367e
25 changed files with 633 additions and 947 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/cmd/gc/reflect.c
View File

@ -390,6 +390,9 @@ enum {
KindFloat,
KindFloat32,
KindFloat64,
KindComplex,
KindComplex64,
KindComplex128,
KindArray,
KindChan,
KindFunc,
@ -431,6 +434,9 @@ kinds[] =
[TMAP] = KindMap,
[TARRAY] = KindArray,
[TFUNC] = KindFunc,
[TCOMPLEX] = KindComplex,
[TCOMPLEX64] = KindComplex64,
[TCOMPLEX128] = KindComplex128,
};
static char*
@ -438,21 +444,21 @@ structnames[] =
{
[TINT] = "*runtime.IntType",
[TUINT] = "*runtime.UintType",
[TINT8] = "*runtime.Int8Type",
[TUINT8] = "*runtime.Uint8Type",
[TINT16] = "*runtime.Int16Type",
[TUINT16] = "*runtime.Uint16Type",
[TINT32] = "*runtime.Int32Type",
[TUINT32] = "*runtime.Uint32Type",
[TINT64] = "*runtime.Int64Type",
[TUINT64] = "*runtime.Uint64Type",
[TUINTPTR] = "*runtime.UintptrType",
[TINT8] = "*runtime.IntType",
[TUINT8] = "*runtime.UintType",
[TINT16] = "*runtime.IntType",
[TUINT16] = "*runtime.UintType",
[TINT32] = "*runtime.IntType",
[TUINT32] = "*runtime.UintType",
[TINT64] = "*runtime.IntType",
[TUINT64] = "*runtime.UintType",
[TUINTPTR] = "*runtime.UintType",
[TCOMPLEX] = "*runtime.ComplexType",
[TCOMPLEX64] = "*runtime.Complex64Type",
[TCOMPLEX128] = "*runtime.Complex128Type",
[TCOMPLEX64] = "*runtime.ComplexType",
[TCOMPLEX128] = "*runtime.ComplexType",
[TFLOAT] = "*runtime.FloatType",
[TFLOAT32] = "*runtime.Float32Type",
[TFLOAT64] = "*runtime.Float64Type",
[TFLOAT32] = "*runtime.FloatType",
[TFLOAT64] = "*runtime.FloatType",
[TBOOL] = "*runtime.BoolType",
[TSTRING] = "*runtime.StringType",

33
src/pkg/asn1/asn1.go
View File

@ -647,19 +647,22 @@ func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParam
err = err1
return
case *reflect.IntValue:
parsedInt, err1 := parseInt(innerBytes)
if err1 == nil {
val.Set(parsedInt)
switch val.Type().Kind() {
case reflect.Int:
parsedInt, err1 := parseInt(innerBytes)
if err1 == nil {
val.Set(int64(parsedInt))
}
err = err1
return
case reflect.Int64:
parsedInt, err1 := parseInt64(innerBytes)
if err1 == nil {
val.Set(parsedInt)
}
err = err1
return
}
err = err1
return
case *reflect.Int64Value:
parsedInt, err1 := parseInt64(innerBytes)
if err1 == nil {
val.Set(parsedInt)
}
err = err1
return
case *reflect.StructValue:
structType := fieldType.(*reflect.StructType)
@ -686,7 +689,7 @@ func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParam
return
case *reflect.SliceValue:
sliceType := fieldType.(*reflect.SliceType)
if _, ok := sliceType.Elem().(*reflect.Uint8Type); ok {
if sliceType.Elem().Kind() == reflect.Uint8 {
val.Set(reflect.MakeSlice(sliceType, len(innerBytes), len(innerBytes)))
reflect.ArrayCopy(val, reflect.NewValue(innerBytes).(reflect.ArrayOrSliceValue))
return
@ -729,9 +732,7 @@ func setDefaultValue(v reflect.Value, params fieldParameters) (ok bool) {
}
switch val := v.(type) {
case *reflect.IntValue:
val.Set(int(*params.defaultValue))
case *reflect.Int64Value:
val.Set(int64(*params.defaultValue))
val.Set(*params.defaultValue)
}
return
}

6
src/pkg/asn1/common.go
View File

@ -122,17 +122,15 @@ func getUniversalType(t reflect.Type) (tagNumber int, isCompound, ok bool) {
case timeType:
return tagUTCTime, false, true
}
switch i := t.(type) {
switch t := t.(type) {
case *reflect.BoolType:
return tagBoolean, false, true
case *reflect.IntType:
return tagInteger, false, true
case *reflect.Int64Type:
return tagInteger, false, true
case *reflect.StructType:
return tagSequence, true, true
case *reflect.SliceType:
if _, ok := t.(*reflect.SliceType).Elem().(*reflect.Uint8Type); ok {
if t.Elem().Kind() == reflect.Uint8 {
return tagOctetString, false, true
}
if strings.HasSuffix(t.Name(), "SET") {

8
src/pkg/asn1/marshal.go
View File

@ -333,8 +333,6 @@ func marshalBody(out *forkableWriter, value reflect.Value, params fieldParameter
}
case *reflect.IntValue:
return marshalInt64(out, int64(v.Get()))
case *reflect.Int64Value:
return marshalInt64(out, v.Get())
case *reflect.StructValue:
t := v.Type().(*reflect.StructType)
@ -347,7 +345,7 @@ func marshalBody(out *forkableWriter, value reflect.Value, params fieldParameter
if s.Len() > 0 {
bytes := make([]byte, s.Len())
for i := 0; i < s.Len(); i++ {
bytes[i] = s.Elem(i).(*reflect.Uint8Value).Get()
bytes[i] = uint8(s.Elem(i).(*reflect.UintValue).Get())
}
/* The RawContents will contain the tag and
* length fields but we'll also be writing
@ -371,10 +369,10 @@ func marshalBody(out *forkableWriter, value reflect.Value, params fieldParameter
return
case *reflect.SliceValue:
sliceType := v.Type().(*reflect.SliceType)
if _, ok := sliceType.Elem().(*reflect.Uint8Type); ok {
if sliceType.Elem().Kind() == reflect.Uint8 {
bytes := make([]byte, v.Len())
for i := 0; i < v.Len(); i++ {
bytes[i] = v.Elem(i).(*reflect.Uint8Value).Get()
bytes[i] = uint8(v.Elem(i).(*reflect.UintValue).Get())
}
_, err = out.Write(bytes)
return

124
src/pkg/encoding/binary/binary.go
View File

@ -194,26 +194,8 @@ func sizeof(v reflect.Type) int {
}
return sum
case *reflect.Uint8Type:
return 1
case *reflect.Uint16Type:
return 2
case *reflect.Uint32Type:
return 4
case *reflect.Uint64Type:
return 8
case *reflect.Int8Type:
return 1
case *reflect.Int16Type:
return 2
case *reflect.Int32Type:
return 4
case *reflect.Int64Type:
return 8
case *reflect.Float32Type:
return 4
case *reflect.Float64Type:
return 8
case *reflect.UintType, *reflect.IntType, *reflect.FloatType:
return int(v.Size())
}
return -1
}
@ -307,26 +289,37 @@ func (d *decoder) value(v reflect.Value) {
d.value(v.Elem(i))
}
case *reflect.Uint8Value:
v.Set(d.uint8())
case *reflect.Uint16Value:
v.Set(d.uint16())
case *reflect.Uint32Value:
v.Set(d.uint32())
case *reflect.Uint64Value:
v.Set(d.uint64())
case *reflect.Int8Value:
v.Set(d.int8())
case *reflect.Int16Value:
v.Set(d.int16())
case *reflect.Int32Value:
v.Set(d.int32())
case *reflect.Int64Value:
v.Set(d.int64())
case *reflect.Float32Value:
v.Set(math.Float32frombits(d.uint32()))
case *reflect.Float64Value:
v.Set(math.Float64frombits(d.uint64()))
case *reflect.IntValue:
switch v.Type().Kind() {
case reflect.Int8:
v.Set(int64(d.int8()))
case reflect.Int16:
v.Set(int64(d.int16()))
case reflect.Int32:
v.Set(int64(d.int32()))
case reflect.Int64:
v.Set(d.int64())
}
case *reflect.UintValue:
switch v.Type().Kind() {
case reflect.Uint8:
v.Set(uint64(d.uint8()))
case reflect.Uint16:
v.Set(uint64(d.uint16()))
case reflect.Uint32:
v.Set(uint64(d.uint32()))
case reflect.Uint64:
v.Set(d.uint64())
}
case *reflect.FloatValue:
switch v.Type().Kind() {
case reflect.Float32:
v.Set(float64(math.Float32frombits(d.uint32())))
case reflect.Float64:
v.Set(math.Float64frombits(d.uint64()))
}
}
}
@ -348,25 +341,36 @@ func (e *encoder) value(v reflect.Value) {
e.value(v.Elem(i))
}
case *reflect.Uint8Value:
e.uint8(v.Get())
case *reflect.Uint16Value:
e.uint16(v.Get())
case *reflect.Uint32Value:
e.uint32(v.Get())
case *reflect.Uint64Value:
e.uint64(v.Get())
case *reflect.Int8Value:
e.int8(v.Get())
case *reflect.Int16Value:
e.int16(v.Get())
case *reflect.Int32Value:
e.int32(v.Get())
case *reflect.Int64Value:
e.int64(v.Get())
case *reflect.Float32Value:
e.uint32(math.Float32bits(v.Get()))
case *reflect.Float64Value:
e.uint64(math.Float64bits(v.Get()))
case *reflect.IntValue:
switch v.Type().Kind() {
case reflect.Int8:
e.int8(int8(v.Get()))
case reflect.Int16:
e.int16(int16(v.Get()))
case reflect.Int32:
e.int32(int32(v.Get()))
case reflect.Int64:
e.int64(v.Get())
}
case *reflect.UintValue:
switch v.Type().Kind() {
case reflect.Uint8:
e.uint8(uint8(v.Get()))
case reflect.Uint16:
e.uint16(uint16(v.Get()))
case reflect.Uint32:
e.uint32(uint32(v.Get()))
case reflect.Uint64:
e.uint64(v.Get())
}
case *reflect.FloatValue:
switch v.Type().Kind() {
case reflect.Float32:
e.uint32(math.Float32bits(float32(v.Get())))
case reflect.Float64:
e.uint64(math.Float64bits(v.Get()))
}
}
}

62
src/pkg/exp/eval/bridge.go
View File

@ -37,37 +37,45 @@ func TypeFromNative(t reflect.Type) Type {
switch t := t.(type) {
case *reflect.BoolType:
et = BoolType
case *reflect.Float32Type:
et = Float32Type
case *reflect.Float64Type:
et = Float64Type
case *reflect.FloatType:
et = FloatType
case *reflect.Int16Type:
et = Int16Type
case *reflect.Int32Type:
et = Int32Type
case *reflect.Int64Type:
et = Int64Type
case *reflect.Int8Type:
et = Int8Type
switch t.Kind() {
case reflect.Float32:
et = Float32Type
case reflect.Float64:
et = Float64Type
case reflect.Float:
et = FloatType
}
case *reflect.IntType:
et = IntType
switch t.Kind() {
case reflect.Int16:
et = Int16Type
case reflect.Int32:
et = Int32Type
case reflect.Int64:
et = Int64Type
case reflect.Int8:
et = Int8Type
case reflect.Int:
et = IntType
}
case *reflect.UintType:
switch t.Kind() {
case reflect.Uint16:
et = Uint16Type
case reflect.Uint32:
et = Uint32Type
case reflect.Uint64:
et = Uint64Type
case reflect.Uint8:
et = Uint8Type
case reflect.Uint:
et = UintType
case reflect.Uintptr:
et = UintptrType
}
case *reflect.StringType:
et = StringType
case *reflect.Uint16Type:
et = Uint16Type
case *reflect.Uint32Type:
et = Uint32Type
case *reflect.Uint64Type:
et = Uint64Type
case *reflect.Uint8Type:
et = Uint8Type
case *reflect.UintType:
et = UintType
case *reflect.UintptrType:
et = UintptrType
case *reflect.ArrayType:
et = NewArrayType(int64(t.Len()), TypeFromNative(t.Elem()))
case *reflect.ChanType:

2
src/pkg/exp/ogle/process.go
View File

@ -237,7 +237,7 @@ func (p *Process) bootstrap() {
if sym == nil {
continue
}
rtv.Field(i).(*reflect.Uint64Value).Set(sym.Value)
rtv.Field(i).(*reflect.UintValue).Set(sym.Value)
}
// Get runtime field indexes

2
src/pkg/exp/ogle/rruntime.go
View File

@ -265,7 +265,7 @@ func fillRuntimeIndexes(runtime *runtimeValues, out *runtimeIndexes) {
for j := 0; j < outStructt.NumField(); j++ {
f := outStructv.Field(j).(*reflect.IntValue)
name := outStructt.Field(j).Name
f.Set(indexes[name])
f.Set(int64(indexes[name]))
}
}
}

41
src/pkg/fmt/print.go
View File

@ -468,8 +468,6 @@ func (p *pp) fmtUint64(v uint64, verb int, sharp bool, value interface{}) {
}
}
var floatBits = reflect.Typeof(float(0)).Size() * 8
func (p *pp) fmtFloat32(v float32, verb int, value interface{}) {
switch verb {
case 'b':
@ -508,8 +506,6 @@ func (p *pp) fmtFloat64(v float64, verb int, value interface{}) {
}
}
var complexBits = reflect.Typeof(complex(0i)).Size() * 8
func (p *pp) fmtComplex64(v complex64, verb int, value interface{}) {
switch verb {
case 'e', 'E', 'f', 'F', 'g', 'G':
@ -615,6 +611,13 @@ func (p *pp) fmtUintptrGetter(field interface{}, value reflect.Value, verb int,
return true
}
var (
intBits = uintptr(reflect.Typeof(int(0)).Size() * 8)
floatBits = uintptr(reflect.Typeof(float(0)).Size() * 8)
complexBits = uintptr(reflect.Typeof(complex(0+0i)).Size() * 8)
uintptrBits = uintptr(reflect.Typeof(uintptr(0)).Size() * 8)
)
func (p *pp) printField(field interface{}, verb int, plus, sharp bool, depth int) (was_string bool) {
if field != nil {
switch {
@ -724,47 +727,21 @@ BigSwitch:
case *reflect.BoolValue:
p.fmtBool(f.Get(), verb, field)
case *reflect.IntValue:
p.fmtInt64(int64(f.Get()), verb, field)
case *reflect.Int8Value:
p.fmtInt64(int64(f.Get()), verb, field)
case *reflect.Int16Value:
p.fmtInt64(int64(f.Get()), verb, field)
case *reflect.Int32Value:
p.fmtInt64(int64(f.Get()), verb, field)
case *reflect.Int64Value:
p.fmtInt64(f.Get(), verb, field)
case *reflect.UintValue:
p.fmtUint64(uint64(f.Get()), verb, sharp, field)
case *reflect.Uint8Value:
p.fmtUint64(uint64(f.Get()), verb, sharp, field)
case *reflect.Uint16Value:
p.fmtUint64(uint64(f.Get()), verb, sharp, field)
case *reflect.Uint32Value:
p.fmtUint64(uint64(f.Get()), verb, sharp, field)
case *reflect.Uint64Value:
p.fmtUint64(f.Get(), verb, sharp, field)
case *reflect.UintptrValue:
p.fmtUint64(uint64(f.Get()), verb, sharp, field)
case *reflect.FloatValue:
if floatBits == 32 {
if f.Type().Size() == 4 {
p.fmtFloat32(float32(f.Get()), verb, field)
} else {
p.fmtFloat64(float64(f.Get()), verb, field)
}
case *reflect.Float32Value:
p.fmtFloat64(float64(f.Get()), verb, field)
case *reflect.Float64Value:
p.fmtFloat64(f.Get(), verb, field)
case *reflect.ComplexValue:
if complexBits == 64 {
if f.Type().Size() == 8 {
p.fmtComplex64(complex64(f.Get()), verb, field)
} else {
p.fmtComplex128(complex128(f.Get()), verb, field)
}
case *reflect.Complex64Value:
p.fmtComplex64(f.Get(), verb, field)
case *reflect.Complex128Value:
p.fmtComplex128(f.Get(), verb, field)
case *reflect.StringValue:
p.fmtString(f.Get(), verb, sharp, field)
case *reflect.MapValue:

90
src/pkg/fmt/scan.go
View File

@ -353,8 +353,6 @@ func (s *ss) typeError(field interface{}, expected string) {
s.errorString("expected field of type pointer to " + expected + "; found " + reflect.Typeof(field).String())
}
var intBits = uint(reflect.Typeof(int(0)).Size() * 8)
var uintptrBits = uint(reflect.Typeof(int(0)).Size() * 8)
var complexError = os.ErrorString("syntax error scanning complex number")
var boolError = os.ErrorString("syntax error scanning boolean")
@ -458,7 +456,7 @@ func (s *ss) scanNumber(digits string) string {
}
// scanRune returns the next rune value in the input.
func (s *ss) scanRune(bitSize uint) int64 {
func (s *ss) scanRune(bitSize uintptr) int64 {
rune := int64(s.mustGetRune())
x := (rune << (64 - bitSize)) >> (64 - bitSize)
if x != rune {
@ -469,7 +467,7 @@ func (s *ss) scanRune(bitSize uint) int64 {
// scanInt returns the value of the integer represented by the next
// token, checking for overflow. Any error is stored in s.err.
func (s *ss) scanInt(verb int, bitSize uint) int64 {
func (s *ss) scanInt(verb int, bitSize uintptr) int64 {
if verb == 'c' {
return s.scanRune(bitSize)
}
@ -490,7 +488,7 @@ func (s *ss) scanInt(verb int, bitSize uint) int64 {
// scanUint returns the value of the unsigned integer represented
// by the next token, checking for overflow. Any error is stored in s.err.
func (s *ss) scanUint(verb int, bitSize uint) uint64 {
func (s *ss) scanUint(verb int, bitSize uintptr) uint64 {
if verb == 'c' {
return uint64(s.scanRune(bitSize))
}
@ -559,27 +557,9 @@ func (s *ss) complexTokens() (real, imag string) {
return real, imagSign + imag
}
// convertFloat converts the string to a float value.
func (s *ss) convertFloat(str string) float64 {
f, err := strconv.Atof(str)
if err != nil {
s.error(err)
}
return float64(f)
}
// convertFloat32 converts the string to a float32 value.
func (s *ss) convertFloat32(str string) float64 {
f, err := strconv.Atof32(str)
if err != nil {
s.error(err)
}
return float64(f)
}
// convertFloat64 converts the string to a float64 value.
func (s *ss) convertFloat64(str string) float64 {
f, err := strconv.Atof64(str)
// convertFloat converts the string to a float64value.
func (s *ss) convertFloat(str string, n int) float64 {
f, err := strconv.AtofN(str, n)
if err != nil {
s.error(err)
}
@ -590,14 +570,14 @@ func (s *ss) convertFloat64(str string) float64 {
// The atof argument is a type-specific reader for the underlying type.
// If we're reading complex64, atof will parse float32s and convert them
// to float64's to avoid reproducing this code for each complex type.
func (s *ss) scanComplex(verb int, atof func(*ss, string) float64) complex128 {
func (s *ss) scanComplex(verb int, n int) complex128 {
if !s.okVerb(verb, floatVerbs, "complex") {
return 0
}
s.skipSpace()
sreal, simag := s.complexTokens()
real := atof(s, sreal)
imag := atof(s, simag)
real := s.convertFloat(sreal, n/2)
imag := s.convertFloat(simag, n/2)
return cmplx(real, imag)
}
@ -725,11 +705,11 @@ func (s *ss) scanOne(verb int, field interface{}) {
case *bool:
*v = s.scanBool(verb)
case *complex:
*v = complex(s.scanComplex(verb, (*ss).convertFloat))
*v = complex(s.scanComplex(verb, int(complexBits)))
case *complex64:
*v = complex64(s.scanComplex(verb, (*ss).convertFloat32))
*v = complex64(s.scanComplex(verb, 64))
case *complex128:
*v = s.scanComplex(verb, (*ss).convertFloat64)
*v = s.scanComplex(verb, 128)
case *int:
*v = int(s.scanInt(verb, intBits))
case *int8:
@ -757,17 +737,17 @@ func (s *ss) scanOne(verb int, field interface{}) {
case *float:
if s.okVerb(verb, floatVerbs, "float") {
s.skipSpace()
*v = float(s.convertFloat(s.floatToken()))
*v = float(s.convertFloat(s.floatToken(), int(floatBits)))
}
case *float32:
if s.okVerb(verb, floatVerbs, "float32") {
s.skipSpace()
*v = float32(s.convertFloat32(s.floatToken()))
*v = float32(s.convertFloat(s.floatToken(), 32))
}
case *float64:
if s.okVerb(verb, floatVerbs, "float64") {
s.skipSpace()
*v = s.convertFloat64(s.floatToken())
*v = s.convertFloat(s.floatToken(), 64)
}
case *string:
*v = s.convertString(verb)
@ -786,55 +766,27 @@ func (s *ss) scanOne(verb int, field interface{}) {
case *reflect.BoolValue:
v.Set(s.scanBool(verb))
case *reflect.IntValue:
v.Set(int(s.scanInt(verb, intBits)))
case *reflect.Int8Value:
v.Set(int8(s.scanInt(verb, 8)))
case *reflect.Int16Value:
v.Set(int16(s.scanInt(verb, 16)))
case *reflect.Int32Value:
v.Set(int32(s.scanInt(verb, 32)))
case *reflect.Int64Value:
v.Set(s.scanInt(verb, 64))
v.Set(s.scanInt(verb, v.Type().Size()*8))
case *reflect.UintValue:
v.Set(uint(s.scanUint(verb, intBits)))
case *reflect.Uint8Value:
v.Set(uint8(s.scanUint(verb, 8)))
case *reflect.Uint16Value:
v.Set(uint16(s.scanUint(verb, 16)))
case *reflect.Uint32Value:
v.Set(uint32(s.scanUint(verb, 32)))
case *reflect.Uint64Value:
v.Set(s.scanUint(verb, 64))
case *reflect.UintptrValue:
v.Set(uintptr(s.scanUint(verb, uintptrBits)))
v.Set(s.scanUint(verb, v.Type().Size()*8))
case *reflect.StringValue:
v.Set(s.convertString(verb))
case *reflect.SliceValue:
// For now, can only handle (renamed) []byte.
typ := v.Type().(*reflect.SliceType)
if _, ok := typ.Elem().(*reflect.Uint8Type); !ok {
if typ.Elem().Kind() != reflect.Uint8 {
goto CantHandle
}
str := s.convertString(verb)
v.Set(reflect.MakeSlice(typ, len(str), len(str)))
for i := 0; i < len(str); i++ {
v.Elem(i).(*reflect.Uint8Value).Set(str[i])
v.Elem(i).(*reflect.UintValue).Set(uint64(str[i]))
}
case *reflect.FloatValue:
s.skipSpace()
v.Set(float(s.convertFloat(s.floatToken())))
case *reflect.Float32Value:
s.skipSpace()
v.Set(float32(s.convertFloat(s.floatToken())))
case *reflect.Float64Value:
s.skipSpace()
v.Set(s.convertFloat(s.floatToken()))
v.Set(s.convertFloat(s.floatToken(), int(v.Type().Size()*8)))
case *reflect.ComplexValue:
v.Set(complex(s.scanComplex(verb, (*ss).convertFloat)))
case *reflect.Complex64Value:
v.Set(complex64(s.scanComplex(verb, (*ss).convertFloat32)))
case *reflect.Complex128Value:
v.Set(s.scanComplex(verb, (*ss).convertFloat64))
v.Set(s.scanComplex(verb, int(v.Type().Size()*8)))
default:
CantHandle:
s.errorString("Scan: can't handle type: " + val.Type().String())

8
src/pkg/gob/codec_test.go
View File

@ -360,7 +360,7 @@ func TestScalarDecInstructions(t *testing.T) {
var data struct {
a int
}
instr := &decInstr{decOpMap[valueKind(data.a)], 6, 0, 0, ovfl}
instr := &decInstr{decOpMap[reflect.Int], 6, 0, 0, ovfl}
state := newDecodeStateFromData(signedResult)
execDec("int", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {
@ -373,7 +373,7 @@ func TestScalarDecInstructions(t *testing.T) {
var data struct {
a uint
}
instr := &decInstr{decOpMap[valueKind(data.a)], 6, 0, 0, ovfl}
instr := &decInstr{decOpMap[reflect.Uint], 6, 0, 0, ovfl}
state := newDecodeStateFromData(unsignedResult)
execDec("uint", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {
@ -464,7 +464,7 @@ func TestScalarDecInstructions(t *testing.T) {
var data struct {
a uintptr
}
instr := &decInstr{decOpMap[valueKind(data.a)], 6, 0, 0, ovfl}
instr := &decInstr{decOpMap[reflect.Uintptr], 6, 0, 0, ovfl}
state := newDecodeStateFromData(unsignedResult)
execDec("uintptr", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {
@ -503,7 +503,7 @@ func TestScalarDecInstructions(t *testing.T) {
var data struct {
a float
}
instr := &decInstr{decOpMap[valueKind(data.a)], 6, 0, 0, ovfl}
instr := &decInstr{decOpMap[reflect.Float], 6, 0, 0, ovfl}
state := newDecodeStateFromData(floatResult)
execDec("float", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {

47
src/pkg/gob/decode.go
View File

@ -540,19 +540,19 @@ func ignoreSlice(state *decodeState, elemOp decOp) os.Error {
return ignoreArrayHelper(state, elemOp, int(decodeUint(state)))
}
var decOpMap = map[reflect.Type]decOp{
valueKind(false): decBool,
valueKind(int8(0)): decInt8,
valueKind(int16(0)): decInt16,
valueKind(int32(0)): decInt32,
valueKind(int64(0)): decInt64,
valueKind(uint8(0)): decUint8,
valueKind(uint16(0)): decUint16,
valueKind(uint32(0)): decUint32,
valueKind(uint64(0)): decUint64,
valueKind(float32(0)): decFloat32,
valueKind(float64(0)): decFloat64,
valueKind("x"): decString,
var decOpMap = map[reflect.Kind]decOp{
reflect.Bool: decBool,
reflect.Int8: decInt8,
reflect.Int16: decInt16,
reflect.Int32: decInt32,
reflect.Int64: decInt64,
reflect.Uint8: decUint8,
reflect.Uint16: decUint16,
reflect.Uint32: decUint32,
reflect.Uint64: decUint64,
reflect.Float32: decFloat32,
reflect.Float64: decFloat64,
reflect.String: decString,
}
var decIgnoreOpMap = map[typeId]decOp{
@ -568,7 +568,7 @@ var decIgnoreOpMap = map[typeId]decOp{
// the indirection count to reach it.
func (dec *Decoder) decOpFor(wireId typeId, rt reflect.Type, name string) (decOp, int, os.Error) {
typ, indir := indirect(rt)
op, ok := decOpMap[reflect.Typeof(typ)]
op, ok := decOpMap[typ.Kind()]
if !ok {
// Special cases
switch t := typ.(type) {
@ -604,7 +604,7 @@ func (dec *Decoder) decOpFor(wireId typeId, rt reflect.Type, name string) (decOp
case *reflect.SliceType:
name = "element of " + name
if _, ok := t.Elem().(*reflect.Uint8Type); ok {
if t.Elem().Kind() == reflect.Uint8 {
op = decUint8Array
break
}
@ -718,11 +718,11 @@ func (dec *Decoder) compatibleType(fr reflect.Type, fw typeId) bool {
return false
case *reflect.BoolType:
return fw == tBool
case *reflect.IntType, *reflect.Int8Type, *reflect.Int16Type, *reflect.Int32Type, *reflect.Int64Type:
case *reflect.IntType:
return fw == tInt
case *reflect.UintType, *reflect.Uint8Type, *reflect.Uint16Type, *reflect.Uint32Type, *reflect.Uint64Type, *reflect.UintptrType:
case *reflect.UintType:
return fw == tUint
case *reflect.FloatType, *reflect.Float32Type, *reflect.Float64Type:
case *reflect.FloatType:
return fw == tFloat
case *reflect.StringType:
return fw == tString
@ -742,8 +742,7 @@ func (dec *Decoder) compatibleType(fr reflect.Type, fw typeId) bool {
return dec.compatibleType(t.Key(), mapType.Key) && dec.compatibleType(t.Elem(), mapType.Elem)
case *reflect.SliceType:
// Is it an array of bytes?
et := t.Elem()
if _, ok := et.(*reflect.Uint8Type); ok {
if t.Elem().Kind() == reflect.Uint8 {
return fw == tBytes
}
// Extract and compare element types.
@ -874,7 +873,7 @@ func init() {
default:
panic("gob: unknown size of float")
}
decOpMap[valueKind(float(0))] = op
decOpMap[reflect.Float] = op
// A similar assumption about int and uint. Also assume int and uint have the same size.
var uop decOp
@ -888,8 +887,8 @@ func init() {
default:
panic("gob: unknown size of int/uint")
}
decOpMap[valueKind(int(0))] = op
decOpMap[valueKind(uint(0))] = uop
decOpMap[reflect.Int] = op
decOpMap[reflect.Uint] = uop
// Finally uintptr
switch unsafe.Sizeof(uintptr(0)) {
@ -900,5 +899,5 @@ func init() {
default:
panic("gob: unknown size of uintptr")
}
decOpMap[valueKind(uintptr(0))] = uop
decOpMap[reflect.Uintptr] = uop
}

38
src/pkg/gob/encode.go
View File

@ -601,35 +601,35 @@ func encodeMap(b *bytes.Buffer, rt reflect.Type, p uintptr, keyOp, elemOp encOp,
return state.err
}
var encOpMap = map[reflect.Type]encOp{
valueKind(false): encBool,
valueKind(int(0)): encInt,
valueKind(int8(0)): encInt8,
valueKind(int16(0)): encInt16,
valueKind(int32(0)): encInt32,
valueKind(int64(0)): encInt64,
valueKind(uint(0)): encUint,
valueKind(uint8(0)): encUint8,
valueKind(uint16(0)): encUint16,
valueKind(uint32(0)): encUint32,
valueKind(uint64(0)): encUint64,
valueKind(uintptr(0)): encUintptr,
valueKind(float(0)): encFloat,
valueKind(float32(0)): encFloat32,
valueKind(float64(0)): encFloat64,
valueKind("x"): encString,
var encOpMap = map[reflect.Kind]encOp{
reflect.Bool: encBool,
reflect.Int: encInt,
reflect.Int8: encInt8,
reflect.Int16: encInt16,
reflect.Int32: encInt32,
reflect.Int64: encInt64,
reflect.Uint: encUint,
reflect.Uint8: encUint8,
reflect.Uint16: encUint16,
reflect.Uint32: encUint32,
reflect.Uint64: encUint64,
reflect.Uintptr: encUintptr,
reflect.Float: encFloat,
reflect.Float32: encFloat32,
reflect.Float64: encFloat64,
reflect.String: encString,
}
// Return the encoding op for the base type under rt and
// the indirection count to reach it.
func encOpFor(rt reflect.Type) (encOp, int, os.Error) {
typ, indir := indirect(rt)
op, ok := encOpMap[reflect.Typeof(typ)]
op, ok := encOpMap[typ.Kind()]
if !ok {
// Special cases
switch t := typ.(type) {
case *reflect.SliceType:
if _, ok := t.Elem().(*reflect.Uint8Type); ok {
if t.Elem().Kind() == reflect.Uint8 {
op = encUint8Array
break
}

2
src/pkg/gob/encoder.go
View File

@ -78,7 +78,7 @@ func (enc *Encoder) sendType(origt reflect.Type) {
return
case *reflect.SliceType:
// If it's []uint8, don't send; it's considered basic.
if _, ok := rt.Elem().(*reflect.Uint8Type); ok {
if rt.Elem().Kind() == reflect.Uint8 {
return
}
// Otherwise we do send.

23
src/pkg/gob/type.go
View File

@ -11,8 +11,6 @@ import (
"sync"
)
type kind reflect.Type
// Reflection types are themselves interface values holding structs
// describing the type. Each type has a different struct so that struct can
// be the kind. For example, if typ is the reflect type for an int8, typ is
@ -20,17 +18,6 @@ type kind reflect.Type
// function, typ is a pointer to a reflect.FuncType struct; we use the type
// of that pointer as the kind.
// typeKind returns a reflect.Type representing typ's kind. The kind is the
// general kind of type:
// int8, int16, int, uint, float, func, chan, struct, and so on.
// That is, all struct types have the same kind, all func types have the same
// kind, all int8 types have the same kind, and so on.
func typeKind(typ reflect.Type) kind { return kind(reflect.Typeof(typ)) }
// valueKind returns the kind of the value type
// stored inside the interface v.
func valueKind(v interface{}) reflect.Type { return typeKind(reflect.Typeof(v)) }
// A typeId represents a gob Type as an integer that can be passed on the wire.
// Internally, typeIds are used as keys to a map to recover the underlying type info.
type typeId int32
@ -245,13 +232,13 @@ func newTypeObject(name string, rt reflect.Type) (gobType, os.Error) {
case *reflect.BoolType:
return tBool.gobType(), nil
case *reflect.IntType, *reflect.Int8Type, *reflect.Int16Type, *reflect.Int32Type, *reflect.Int64Type:
case *reflect.IntType:
return tInt.gobType(), nil
case *reflect.UintType, *reflect.Uint8Type, *reflect.Uint16Type, *reflect.Uint32Type, *reflect.Uint64Type, *reflect.UintptrType:
case *reflect.UintType:
return tUint.gobType(), nil
case *reflect.FloatType, *reflect.Float32Type, *reflect.Float64Type:
case *reflect.FloatType:
return tFloat.gobType(), nil
case *reflect.StringType:
@ -277,7 +264,7 @@ func newTypeObject(name string, rt reflect.Type) (gobType, os.Error) {
case *reflect.SliceType:
// []byte == []uint8 is a special case
if _, ok := t.Elem().(*reflect.Uint8Type); ok {
if t.Elem().Kind() == reflect.Uint8 {
return tBytes.gobType(), nil
}
gt, err := getType(t.Elem().Name(), t.Elem())
@ -413,7 +400,7 @@ func getTypeInfo(rt reflect.Type) (*typeInfo, os.Error) {
info.wire = &wireType{mapT: t.(*mapType)}
case *reflect.SliceType:
// []byte == []uint8 is a special case handled separately
if _, ok := typ.Elem().(*reflect.Uint8Type); !ok {
if typ.Elem().Kind() != reflect.Uint8 {
info.wire = &wireType{sliceT: t.(*sliceType)}
}
case *reflect.StructType:

87
src/pkg/json/decode.go
View File

@ -572,101 +572,24 @@ func (d *decodeState) literal(v reflect.Value) {
v.Set(reflect.NewValue(n))
case *reflect.IntValue:
n, err := strconv.Atoi(s)
if err != nil {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(n)
case *reflect.Int8Value:
n, err := strconv.Atoi(s)
if err != nil || int(int8(n)) != n {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(int8(n))
case *reflect.Int16Value:
n, err := strconv.Atoi(s)
if err != nil || int(int16(n)) != n {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(int16(n))
case *reflect.Int32Value:
n, err := strconv.Atoi(s)
if err != nil || int(int32(n)) != n {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(int32(n))
case *reflect.Int64Value:
n, err := strconv.Atoi64(s)
if err != nil {
if err != nil || v.Overflow(n) {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(n)
case *reflect.UintValue:
n, err := strconv.Atoui(s)
if err != nil {
n, err := strconv.Atoui64(s)
if err != nil || v.Overflow(n) {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(n)
case *reflect.Uint8Value:
n, err := strconv.Atoui(s)
if err != nil || uint(uint8(n)) != n {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(uint8(n))
case *reflect.Uint16Value:
n, err := strconv.Atoui(s)
if err != nil || uint(uint16(n)) != n {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(uint16(n))
case *reflect.Uint32Value:
n, err := strconv.Atoui(s)
if err != nil || uint(uint32(n)) != n {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(uint32(n))
case *reflect.Uint64Value:
n, err := strconv.Atoui64(s)
if err != nil {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(n)
case *reflect.UintptrValue:
n, err := strconv.Atoui64(s)
if err != nil || uint64(uintptr(n)) != n {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(uintptr(n))
case *reflect.FloatValue:
n, err := strconv.Atof(s)
if err != nil {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(n)
case *reflect.Float32Value:
n, err := strconv.Atof32(s)
if err != nil {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}
v.Set(n)
case *reflect.Float64Value:
n, err := strconv.Atof64(s)
if err != nil {
n, err := strconv.AtofN(s, int(v.Type().Size()*8))
if err != nil || v.Overflow(n) {
d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
break
}

24
src/pkg/json/encode.go
View File

@ -156,35 +156,13 @@ func (e *encodeState) reflectValue(v reflect.Value) {
}
case *reflect.IntValue:
e.WriteString(strconv.Itoa(v.Get()))
case *reflect.Int8Value:
e.WriteString(strconv.Itoa(int(v.Get())))
case *reflect.Int16Value:
e.WriteString(strconv.Itoa(int(v.Get())))
case *reflect.Int32Value:
e.WriteString(strconv.Itoa(int(v.Get())))
case *reflect.Int64Value:
e.WriteString(strconv.Itoa64(v.Get()))
case *reflect.UintValue:
e.WriteString(strconv.Uitoa(v.Get()))
case *reflect.Uint8Value:
e.WriteString(strconv.Uitoa(uint(v.Get())))
case *reflect.Uint16Value:
e.WriteString(strconv.Uitoa(uint(v.Get())))
case *reflect.Uint32Value:
e.WriteString(strconv.Uitoa(uint(v.Get())))
case *reflect.Uint64Value:
e.WriteString(strconv.Uitoa64(v.Get()))
case *reflect.UintptrValue:
e.WriteString(strconv.Uitoa64(uint64(v.Get())))
case *reflect.FloatValue:
e.WriteString(strconv.Ftoa(v.Get(), 'g', -1))
case *reflect.Float32Value:
e.WriteString(strconv.Ftoa32(v.Get(), 'g', -1))
case *reflect.Float64Value:
e.WriteString(strconv.Ftoa64(v.Get(), 'g', -1))
e.WriteString(strconv.FtoaN(v.Get(), 'g', -1, int(v.Type().Size()*8)))
case *reflect.StringValue:
e.string(v.Get())

71
src/pkg/net/dnsmsg.go
View File

@ -369,28 +369,33 @@ func packStructValue(val *reflect.StructValue, msg []byte, off int) (off1 int, o
f := val.Type().(*reflect.StructType).Field(i)
switch fv := val.Field(i).(type) {
default:
BadType:
fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type)
return len(msg), false
case *reflect.StructValue:
off, ok = packStructValue(fv, msg, off)
case *reflect.Uint16Value:
case *reflect.UintValue:
i := fv.Get()
if off+2 > len(msg) {
return len(msg), false
switch fv.Type().Kind() {
default:
goto BadType
case reflect.Uint16:
if off+2 > len(msg) {
return len(msg), false
}
msg[off] = byte(i >> 8)
msg[off+1] = byte(i)
off += 2
case reflect.Uint32:
if off+4 > len(msg) {
return len(msg), false
}
msg[off] = byte(i >> 24)
msg[off+1] = byte(i >> 16)
msg[off+2] = byte(i >> 8)
msg[off+3] = byte(i)
off += 4
}
msg[off] = byte(i >> 8)
msg[off+1] = byte(i)
off += 2
case *reflect.Uint32Value:
i := fv.Get()
if off+4 > len(msg) {
return len(msg), false
}
msg[off] = byte(i >> 24)
msg[off+1] = byte(i >> 16)
msg[off+2] = byte(i >> 8)
msg[off+3] = byte(i)
off += 4
case *reflect.StringValue:
// There are multiple string encodings.
// The tag distinguishes ordinary strings from domain names.
@ -438,24 +443,30 @@ func unpackStructValue(val *reflect.StructValue, msg []byte, off int) (off1 int,
f := val.Type().(*reflect.StructType).Field(i)
switch fv := val.Field(i).(type) {
default:
BadType:
fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type)
return len(msg), false
case *reflect.StructValue:
off, ok = unpackStructValue(fv, msg, off)
case *reflect.Uint16Value:
if off+2 > len(msg) {
return len(msg), false
case *reflect.UintValue:
switch fv.Type().Kind() {
default:
goto BadType
case reflect.Uint16:
if off+2 > len(msg) {
return len(msg), false
}
i := uint16(msg[off])<<8 | uint16(msg[off+1])
fv.Set(uint64(i))
off += 2
case reflect.Uint32:
if off+4 > len(msg) {
return len(msg), false
}
i := uint32(msg[off])<<24 | uint32(msg[off+1])<<16 | uint32(msg[off+2])<<8 | uint32(msg[off+3])
fv.Set(uint64(i))
off += 4
}
i := uint16(msg[off])<<8 | uint16(msg[off+1])
fv.Set(i)
off += 2
case *reflect.Uint32Value:
if off+4 > len(msg) {
return len(msg), false
}
i := uint32(msg[off])<<24 | uint32(msg[off+1])<<16 | uint32(msg[off+2])<<8 | uint32(msg[off+3])
fv.Set(i)
off += 4
case *reflect.StringValue:
var s string
switch f.Tag {
@ -508,7 +519,7 @@ func printStructValue(val *reflect.StructValue) string {
fval := val.Field(i)
if fv, ok := fval.(*reflect.StructValue); ok {
s += printStructValue(fv)
} else if fv, ok := fval.(*reflect.Uint32Value); ok && f.Tag == "ipv4" {
} else if fv, ok := fval.(*reflect.UintValue); ok && f.Tag == "ipv4" {
i := fv.Get()
s += IPv4(byte(i>>24), byte(i>>16), byte(i>>8), byte(i)).String()
} else {

157
src/pkg/reflect/all_test.go
View File

@ -164,8 +164,8 @@ var valueTests = []pair{
pair{(uint16)(0), "16"},
pair{(uint32)(0), "32"},
pair{(uint64)(0), "64"},
pair{(float32)(0), "32.1"},
pair{(float64)(0), "64.2"},
pair{(float32)(0), "256.25"},
pair{(float64)(0), "512.125"},
pair{(string)(""), "stringy cheese"},
pair{(bool)(false), "true"},
pair{(*int8)(nil), "*int8(0)"},
@ -219,31 +219,49 @@ func TestSet(t *testing.T) {
v := NewValue(tt.i)
switch v := v.(type) {
case *IntValue:
v.Set(132)
case *Int8Value:
v.Set(8)
case *Int16Value:
v.Set(16)
case *Int32Value:
v.Set(32)
case *Int64Value:
v.Set(64)
switch v.Type().Kind() {
case Int:
v.Set(132)
case Int8:
v.Set(8)
case Int16:
v.Set(16)
case Int32:
v.Set(32)
case Int64:
v.Set(64)
}
case *UintValue:
v.Set(132)
case *Uint8Value:
v.Set(8)
case *Uint16Value:
v.Set(16)
case *Uint32Value:
v.Set(32)
case *Uint64Value:
v.Set(64)
switch v.Type().Kind() {
case Uint:
v.Set(132)
case Uint8:
v.Set(8)
case Uint16:
v.Set(16)
case Uint32:
v.Set(32)
case Uint64:
v.Set(64)
}
case *FloatValue:
v.Set(3200.0)
case *Float32Value:
v.Set(32.1)
case *Float64Value:
v.Set(64.2)
switch v.Type().Kind() {
case Float:
v.Set(128.5)
case Float32:
v.Set(256.25)
case Float64:
v.Set(512.125)
}
case *ComplexValue:
switch v.Type().Kind() {
case Complex:
v.Set(53200.0 + 100i)
case Complex64:
v.Set(532.125 + 10i)
case Complex128:
v.Set(564.25 + 1i)
}
case *StringValue:
v.Set("stringy cheese")
case *BoolValue:
@ -261,31 +279,50 @@ func TestSetValue(t *testing.T) {
v := NewValue(tt.i)
switch v := v.(type) {
case *IntValue:
v.SetValue(NewValue(int(132)))
case *Int8Value:
v.SetValue(NewValue(int8(8)))
case *Int16Value:
v.SetValue(NewValue(int16(16)))
case *Int32Value:
v.SetValue(NewValue(int32(32)))
case *Int64Value:
v.SetValue(NewValue(int64(64)))
switch v.Type().Kind() {
case Int:
v.SetValue(NewValue(int(132)))
case Int8:
v.SetValue(NewValue(int8(8)))
case Int16:
v.SetValue(NewValue(int16(16)))
case Int32:
v.SetValue(NewValue(int32(32)))
case Int64:
v.SetValue(NewValue(int64(64)))
}
case *UintValue:
v.SetValue(NewValue(uint(132)))
case *Uint8Value:
v.SetValue(NewValue(uint8(8)))
case *Uint16Value:
v.SetValue(NewValue(uint16(16)))
case *Uint32Value:
v.SetValue(NewValue(uint32(32)))
case *Uint64Value:
v.SetValue(NewValue(uint64(64)))
switch v.Type().Kind() {
case Uint:
v.SetValue(NewValue(uint(132)))
case Uint8:
v.SetValue(NewValue(uint8(8)))
case Uint16:
v.SetValue(NewValue(uint16(16)))
case Uint32:
v.SetValue(NewValue(uint32(32)))
case Uint64:
v.SetValue(NewValue(uint64(64)))
}
case *FloatValue:
v.SetValue(NewValue(float(3200.0)))
case *Float32Value:
v.SetValue(NewValue(float32(32.1)))
case *Float64Value:
v.SetValue(NewValue(float64(64.2)))
switch v.Type().Kind() {
case Float:
v.SetValue(NewValue(float(128.5)))
case Float32:
v.SetValue(NewValue(float32(256.25)))
case Float64:
v.SetValue(NewValue(float64(512.125)))
}
case *ComplexValue:
switch v.Type().Kind() {
case Complex:
v.SetValue(NewValue(complex(53200.0 + 100i)))
case Complex64:
v.SetValue(NewValue(complex64(532.125 + 10i)))
case Complex128:
v.SetValue(NewValue(complex128(564.25 + 1i)))
}
case *StringValue:
v.SetValue(NewValue("stringy cheese"))
case *BoolValue:
@ -302,7 +339,7 @@ var _i = 7
var valueToStringTests = []pair{
pair{123, "123"},
pair{123.4, "123.4"},
pair{123.5, "123.5"},
pair{byte(123), "123"},
pair{"abc", "abc"},
pair{T{123, 456.75, "hello", &_i}, "reflect_test.T{123, 456.75, hello, *int(&7)}"},
@ -606,9 +643,9 @@ func TestDeepEqualRecursiveStruct(t *testing.T) {
}
}
type Complex struct {
type _Complex struct {
a int
b [3]*Complex
b [3]*_Complex
c *string
d map[float]float
}
@ -616,9 +653,9 @@ type Complex struct {
func TestDeepEqualComplexStruct(t *testing.T) {
m := make(map[float]float)
stra, strb := "hello", "hello"
a, b := new(Complex), new(Complex)
*a = Complex{5, [3]*Complex{a, b, a}, &stra, m}
*b = Complex{5, [3]*Complex{b, a, a}, &strb, m}
a, b := new(_Complex), new(_Complex)
*a = _Complex{5, [3]*_Complex{a, b, a}, &stra, m}
*b = _Complex{5, [3]*_Complex{b, a, a}, &strb, m}
if !DeepEqual(a, b) {
t.Error("DeepEqual(complex same) = false, want true")
}
@ -627,9 +664,9 @@ func TestDeepEqualComplexStruct(t *testing.T) {
func TestDeepEqualComplexStructInequality(t *testing.T) {
m := make(map[float]float)
stra, strb := "hello", "helloo" // Difference is here
a, b := new(Complex), new(Complex)
*a = Complex{5, [3]*Complex{a, b, a}, &stra, m}
*b = Complex{5, [3]*Complex{b, a, a}, &strb, m}
a, b := new(_Complex), new(_Complex)
*a = _Complex{5, [3]*_Complex{a, b, a}, &stra, m}
*b = _Complex{5, [3]*_Complex{b, a, a}, &strb, m}
if DeepEqual(a, b) {
t.Error("DeepEqual(complex different) = true, want false")
}
@ -830,7 +867,7 @@ func TestMap(t *testing.T) {
// Check that value lookup is correct.
vv := mv.Elem(NewValue(k))
if vi := vv.(*IntValue).Get(); vi != v {
if vi := vv.(*IntValue).Get(); vi != int64(v) {
t.Errorf("Key %q: have value %d, want %d", vi, v)
}
@ -982,9 +1019,9 @@ func TestFunc(t *testing.T) {
t.Fatalf("Call returned %d values, want 3", len(ret))
}
i := ret[0].(*Uint8Value).Get()
i := ret[0].(*UintValue).Get()
j := ret[1].(*IntValue).Get()
k := ret[2].(*Uint8Value).Get()
k := ret[2].(*UintValue).Get()
if i != 10 || j != 20 || k != 30 {
t.Errorf("Call returned %d, %d, %d; want 10, 20, 30", i, j, k)
}

33
src/pkg/reflect/tostring_test.go
View File

@ -23,35 +23,14 @@ func valueToString(val Value) string {
typ := val.Type()
switch val := val.(type) {
case *IntValue:
return strconv.Uitoa64(uint64(val.Get()))
case *Int8Value:
return strconv.Itoa64(int64(val.Get()))
case *Int16Value:
return strconv.Itoa64(int64(val.Get()))
case *Int32Value:
return strconv.Itoa64(int64(val.Get()))
case *Int64Value:
return strconv.Itoa64(int64(val.Get()))
return strconv.Itoa64(val.Get())
case *UintValue:
return strconv.Itoa64(int64(val.Get()))
case *Uint8Value:
return strconv.Itoa64(int64(val.Get()))
case *Uint16Value:
return strconv.Itoa64(int64(val.Get()))
case *Uint32Value:
return strconv.Itoa64(int64(val.Get()))
case *Uint64Value:
return strconv.Uitoa64(uint64(val.Get()))
return strconv.Uitoa64(val.Get())
case *FloatValue:
if strconv.FloatSize == 32 {
return strconv.Ftoa32(float32(val.Get()), 'g', -1)
} else {
return strconv.Ftoa64(float64(val.Get()), 'g', -1)
}
case *Float32Value:
return strconv.Ftoa32(val.Get(), 'g', -1)
case *Float64Value:
return strconv.Ftoa64(val.Get(), 'g', -1)
return strconv.Ftoa64(float64(val.Get()), 'g', -1)
case *ComplexValue:
c := val.Get()
return strconv.Ftoa64(float64(real(c)), 'g', -1) + "+" + strconv.Ftoa64(float64(imag(c)), 'g', -1) + "i"
case *StringValue:
return val.Get()
case *BoolValue:

178
src/pkg/reflect/type.go
View File

@ -40,6 +40,7 @@ type commonType struct {
alg uint8
align uint8
fieldAlign uint8
kind uint8
string *string
*uncommonType
}
@ -64,81 +65,21 @@ type BoolType struct {
commonType
}
// Float32Type represents a float32 type.
type Float32Type struct {
commonType
}
// Float64Type represents a float64 type.
type Float64Type struct {
commonType
}
// FloatType represents a float type.
type FloatType struct {
commonType
}
// Complex64Type represents a complex64 type.
type Complex64Type struct {
commonType
}
// Complex128Type represents a complex128 type.
type Complex128Type struct {
commonType
}
// ComplexType represents a complex type.
type ComplexType struct {
commonType
}
// Int16Type represents an int16 type.
type Int16Type struct {
commonType
}
// Int32Type represents an int32 type.
type Int32Type struct {
commonType
}
// Int64Type represents an int64 type.
type Int64Type struct {
commonType
}
// Int8Type represents an int8 type.
type Int8Type struct {
commonType
}
// IntType represents an int type.
// IntType represents a signed integer type.
type IntType struct {
commonType
}
// Uint16Type represents a uint16 type.
type Uint16Type struct {
commonType
}
// Uint32Type represents a uint32 type.
type Uint32Type struct {
commonType
}
// Uint64Type represents a uint64 type.
type Uint64Type struct {
commonType
}
// Uint8Type represents a uint8 type.
type Uint8Type struct {
commonType
}
// UintType represents a uint type.
type UintType struct {
commonType
@ -149,11 +90,6 @@ type StringType struct {
commonType
}
// UintptrType represents a uintptr type.
type UintptrType struct {
commonType
}
// UnsafePointerType represents an unsafe.Pointer type.
type UnsafePointerType struct {
commonType
@ -286,6 +222,9 @@ type Type interface {
// when used as a field in a struct.
FieldAlign() int
// Kind returns the specific kind of this type.
Kind() Kind
// For non-interface types, Method returns the i'th method with receiver T.
// For interface types, Method returns the i'th method in the interface.
// NumMethod returns the number of such methods.
@ -294,6 +233,84 @@ type Type interface {
uncommon() *uncommonType
}
// A Kind represents the specific kind of type that a Type represents.
// For numeric types, the Kind gives more information than the Type's
// dynamic type. For example, the Type of a float32 is FloatType, but
// the Kind is Float32.
//
// The zero Kind is not a valid kind.
type Kind uint8
const (
Bool Kind = 1 + iota
Int
Int8
Int16
Int32
Int64
Uint
Uint8
Uint16
Uint32
Uint64
Uintptr
Float
Float32
Float64
Complex
Complex64
Complex128
Array
Chan
Func
Interface
Map
Ptr
Slice
String
Struct
UnsafePointer
)
// High bit says whether type has
// embedded pointers,to help garbage collector.
const kindMask = 0x7f
func (k Kind) String() string {
if int(k) < len(kindNames) {
return kindNames[k]
}
return "kind" + strconv.Itoa(int(k))
}
var kindNames = []string{
Bool: "bool",
Int: "int",
Int8: "int8",
Int16: "int16",
Int32: "int32",
Int64: "int64",
Uint: "uint",
Uint8: "uint8",
Uint16: "uint16",
Uint32: "uint32",
Uint64: "uint64",
Uintptr: "uintptr",
Float: "float",
Float32: "float32",
Float64: "float64",
Array: "array",
Chan: "chan",
Func: "func",
Interface: "interface",
Map: "map",
Ptr: "ptr",
Slice: "slice",
String: "string",
Struct: "struct",
UnsafePointer: "unsafe.Pointer",
}
func (t *uncommonType) uncommon() *uncommonType {
return t
}
@ -320,6 +337,8 @@ func (t *commonType) Align() int { return int(t.align) }
func (t *commonType) FieldAlign() int { return int(t.fieldAlign) }
func (t *commonType) Kind() Kind { return Kind(t.kind & kindMask) }
func (t *uncommonType) Method(i int) (m Method) {
if t == nil || i < 0 || i >= len(t.methods) {
return
@ -603,40 +622,14 @@ func toType(i interface{}) Type {
return (*BoolType)(unsafe.Pointer(v))
case *runtime.FloatType:
return (*FloatType)(unsafe.Pointer(v))
case *runtime.Float32Type:
return (*Float32Type)(unsafe.Pointer(v))
case *runtime.Float64Type:
return (*Float64Type)(unsafe.Pointer(v))
case *runtime.ComplexType:
return (*ComplexType)(unsafe.Pointer(v))
case *runtime.Complex64Type:
return (*Complex64Type)(unsafe.Pointer(v))
case *runtime.Complex128Type:
return (*Complex128Type)(unsafe.Pointer(v))
case *runtime.IntType:
return (*IntType)(unsafe.Pointer(v))
case *runtime.Int8Type:
return (*Int8Type)(unsafe.Pointer(v))
case *runtime.Int16Type:
return (*Int16Type)(unsafe.Pointer(v))
case *runtime.Int32Type:
return (*Int32Type)(unsafe.Pointer(v))
case *runtime.Int64Type:
return (*Int64Type)(unsafe.Pointer(v))
case *runtime.StringType:
return (*StringType)(unsafe.Pointer(v))
case *runtime.UintType:
return (*UintType)(unsafe.Pointer(v))
case *runtime.Uint8Type:
return (*Uint8Type)(unsafe.Pointer(v))
case *runtime.Uint16Type:
return (*Uint16Type)(unsafe.Pointer(v))
case *runtime.Uint32Type:
return (*Uint32Type)(unsafe.Pointer(v))
case *runtime.Uint64Type:
return (*Uint64Type)(unsafe.Pointer(v))
case *runtime.UintptrType:
return (*UintptrType)(unsafe.Pointer(v))
case *runtime.UnsafePointerType:
return (*UnsafePointerType)(unsafe.Pointer(v))
case *runtime.ArrayType:
@ -656,6 +649,7 @@ func toType(i interface{}) Type {
case *runtime.StructType:
return (*StructType)(unsafe.Pointer(v))
}
println(i)
panic("toType")
}

381
src/pkg/reflect/value.go
View File

@ -5,6 +5,7 @@
package reflect
import (
"math"
"runtime"
"unsafe"
)
@ -134,72 +135,83 @@ type FloatValue struct {
value
}
// Get returns the underlying float value.
func (v *FloatValue) Get() float { return *(*float)(v.addr) }
// Get returns the underlying int value.
func (v *FloatValue) Get() float64 {
switch v.typ.(*FloatType).Kind() {
case Float:
return float64(*(*float)(v.addr))
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 float) {
func (v *FloatValue) Set(x float64) {
if !v.canSet {
panic(cannotSet)
}
*(*float)(v.addr) = x
switch v.typ.(*FloatType).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()) }
// Float32Value represents a float32 value.
type Float32Value struct {
value
}
// Get returns the underlying float32 value.
func (v *Float32Value) Get() float32 { return *(*float32)(v.addr) }
// Set sets v to the value x.
func (v *Float32Value) Set(x float32) {
if !v.canSet {
panic(cannotSet)
}
*(*float32)(v.addr) = x
}
// Set sets v to the value x.
func (v *Float32Value) SetValue(x Value) { v.Set(x.(*Float32Value).Get()) }
// Float64Value represents a float64 value.
type Float64Value struct {
value
}
// Get returns the underlying float64 value.
func (v *Float64Value) Get() float64 { return *(*float64)(v.addr) }
// Set sets v to the value x.
func (v *Float64Value) Set(x float64) {
if !v.canSet {
panic(cannotSet)
}
*(*float64)(v.addr) = x
}
// Set sets v to the value x.
func (v *Float64Value) SetValue(x Value) { v.Set(x.(*Float64Value).Get()) }
// ComplexValue represents a complex value.
type ComplexValue struct {
value
}
// Get returns the underlying complex value.
func (v *ComplexValue) Get() complex { return *(*complex)(v.addr) }
func (v *ComplexValue) Get() complex128 {
switch v.typ.(*ComplexType).Kind() {
case Complex:
return complex128(*(*complex)(v.addr))
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 complex) {
func (v *ComplexValue) Set(x complex128) {
if !v.canSet {
panic(cannotSet)
}
*(*complex)(v.addr) = x
switch v.typ.(*ComplexType).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.
@ -249,95 +261,53 @@ type IntValue struct {
}
// Get returns the underlying int value.
func (v *IntValue) Get() int { return *(*int)(v.addr) }
func (v *IntValue) Get() int64 {
switch v.typ.(*IntType).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 int) {
func (v *IntValue) Set(x int64) {
if !v.canSet {
panic(cannotSet)
}
*(*int)(v.addr) = x
switch v.typ.(*IntType).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.(*IntValue).Get()) }
// Int8Value represents an int8 value.
type Int8Value struct {
value
// Overflow returns true if x cannot be represented by the type of v.
func (v *IntValue) Overflow(x int64) bool {
bitSize := v.typ.Size() * 8
trunc := (x << (64 - bitSize)) >> (64 - bitSize)
return x != trunc
}
// Get returns the underlying int8 value.
func (v *Int8Value) Get() int8 { return *(*int8)(v.addr) }
// Set sets v to the value x.
func (v *Int8Value) Set(x int8) {
if !v.canSet {
panic(cannotSet)
}
*(*int8)(v.addr) = x
}
// Set sets v to the value x.
func (v *Int8Value) SetValue(x Value) { v.Set(x.(*Int8Value).Get()) }
// Int16Value represents an int16 value.
type Int16Value struct {
value
}
// Get returns the underlying int16 value.
func (v *Int16Value) Get() int16 { return *(*int16)(v.addr) }
// Set sets v to the value x.
func (v *Int16Value) Set(x int16) {
if !v.canSet {
panic(cannotSet)
}
*(*int16)(v.addr) = x
}
// Set sets v to the value x.
func (v *Int16Value) SetValue(x Value) { v.Set(x.(*Int16Value).Get()) }
// Int32Value represents an int32 value.
type Int32Value struct {
value
}
// Get returns the underlying int32 value.
func (v *Int32Value) Get() int32 { return *(*int32)(v.addr) }
// Set sets v to the value x.
func (v *Int32Value) Set(x int32) {
if !v.canSet {
panic(cannotSet)
}
*(*int32)(v.addr) = x
}
// Set sets v to the value x.
func (v *Int32Value) SetValue(x Value) { v.Set(x.(*Int32Value).Get()) }
// Int64Value represents an int64 value.
type Int64Value struct {
value
}
// Get returns the underlying int64 value.
func (v *Int64Value) Get() int64 { return *(*int64)(v.addr) }
// Set sets v to the value x.
func (v *Int64Value) Set(x int64) {
if !v.canSet {
panic(cannotSet)
}
*(*int64)(v.addr) = x
}
// Set sets v to the value x.
func (v *Int64Value) SetValue(x Value) { v.Set(x.(*Int64Value).Get()) }
// StringHeader is the runtime representation of a string.
type StringHeader struct {
Data uintptr
@ -368,115 +338,58 @@ type UintValue struct {
value
}
// Get returns the underlying uint value.
func (v *UintValue) Get() uint { return *(*uint)(v.addr) }
// Get returns the underlying uuint value.
func (v *UintValue) Get() uint64 {
switch v.typ.(*UintType).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 uint) {
func (v *UintValue) Set(x uint64) {
if !v.canSet {
panic(cannotSet)
}
*(*uint)(v.addr) = x
switch v.typ.(*UintType).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 := v.typ.Size() * 8
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.(*UintValue).Get()) }
// Uint8Value represents a uint8 value.
type Uint8Value struct {
value
}
// Get returns the underlying uint8 value.
func (v *Uint8Value) Get() uint8 { return *(*uint8)(v.addr) }
// Set sets v to the value x.
func (v *Uint8Value) Set(x uint8) {
if !v.canSet {
panic(cannotSet)
}
*(*uint8)(v.addr) = x
}
// Set sets v to the value x.
func (v *Uint8Value) SetValue(x Value) { v.Set(x.(*Uint8Value).Get()) }
// Uint16Value represents a uint16 value.
type Uint16Value struct {
value
}
// Get returns the underlying uint16 value.
func (v *Uint16Value) Get() uint16 { return *(*uint16)(v.addr) }
// Set sets v to the value x.
func (v *Uint16Value) Set(x uint16) {
if !v.canSet {
panic(cannotSet)
}
*(*uint16)(v.addr) = x
}
// Set sets v to the value x.
func (v *Uint16Value) SetValue(x Value) { v.Set(x.(*Uint16Value).Get()) }
// Uint32Value represents a uint32 value.
type Uint32Value struct {
value
}
// Get returns the underlying uint32 value.
func (v *Uint32Value) Get() uint32 { return *(*uint32)(v.addr) }
// Set sets v to the value x.
func (v *Uint32Value) Set(x uint32) {
if !v.canSet {
panic(cannotSet)
}
*(*uint32)(v.addr) = x
}
// Set sets v to the value x.
func (v *Uint32Value) SetValue(x Value) { v.Set(x.(*Uint32Value).Get()) }
// Uint64Value represents a uint64 value.
type Uint64Value struct {
value
}
// Get returns the underlying uint64 value.
func (v *Uint64Value) Get() uint64 { return *(*uint64)(v.addr) }
// Set sets v to the value x.
func (v *Uint64Value) Set(x uint64) {
if !v.canSet {
panic(cannotSet)
}
*(*uint64)(v.addr) = x
}
// Set sets v to the value x.
func (v *Uint64Value) SetValue(x Value) { v.Set(x.(*Uint64Value).Get()) }
// UintptrValue represents a uintptr value.
type UintptrValue struct {
value
}
// Get returns the underlying uintptr value.
func (v *UintptrValue) Get() uintptr { return *(*uintptr)(v.addr) }
// Set sets v to the value x.
func (v *UintptrValue) Set(x uintptr) {
if !v.canSet {
panic(cannotSet)
}
*(*uintptr)(v.addr) = x
}
// Set sets v to the value x.
func (v *UintptrValue) SetValue(x Value) { v.Set(x.(*UintptrValue).Get()) }
// UnsafePointerValue represents an unsafe.Pointer value.
type UnsafePointerValue struct {
value
@ -1329,26 +1242,10 @@ func newValue(typ Type, addr addr, canSet bool) Value {
return (*ChanValue)(v)
case *FloatType:
return (*FloatValue)(v)
case *Float32Type:
return (*Float32Value)(v)
case *Float64Type:
return (*Float64Value)(v)
case *ComplexType:
return (*ComplexValue)(v)
case *Complex64Type:
return (*Complex64Value)(v)
case *Complex128Type:
return (*Complex128Value)(v)
case *IntType:
return (*IntValue)(v)
case *Int8Type:
return (*Int8Value)(v)
case *Int16Type:
return (*Int16Value)(v)
case *Int32Type:
return (*Int32Value)(v)
case *Int64Type:
return (*Int64Value)(v)
case *InterfaceType:
return (*InterfaceValue)(v)
case *MapType:
@ -1363,16 +1260,6 @@ func newValue(typ Type, addr addr, canSet bool) Value {
return (*StructValue)(v)
case *UintType:
return (*UintValue)(v)
case *Uint8Type:
return (*Uint8Value)(v)
case *Uint16Type:
return (*Uint16Value)(v)
case *Uint32Type:
return (*Uint32Value)(v)
case *Uint64Type:
return (*Uint64Value)(v)
case *UintptrType:
return (*UintptrValue)(v)
case *UnsafePointerType:
return (*UnsafePointerValue)(v)
}

3
src/pkg/runtime/type.h
View File

@ -44,6 +44,9 @@ enum {
KindFloat,
KindFloat32,
KindFloat64,
KindComplex,
KindComplex64,
KindComplex128,
KindArray,
KindChan,
KindFunc,

65
src/pkg/testing/quick/quick.go
View File

@ -60,26 +60,41 @@ func Value(t reflect.Type, rand *rand.Rand) (value reflect.Value, ok bool) {
switch concrete := t.(type) {
case *reflect.BoolType:
return reflect.NewValue(rand.Int()&1 == 0), true
case *reflect.Float32Type:
return reflect.NewValue(randFloat32(rand)), true
case *reflect.Float64Type:
return reflect.NewValue(randFloat64(rand)), true
case *reflect.FloatType:
if t.Size() == 4 {
return reflect.NewValue(float(randFloat32(rand))), true
} else {
return reflect.NewValue(float(randFloat64(rand))), true
case *reflect.FloatType, *reflect.IntType, *reflect.UintType:
switch t.Kind() {
case reflect.Float32:
return reflect.NewValue(randFloat32(rand)), true
case reflect.Float64:
return reflect.NewValue(randFloat64(rand)), true
case reflect.Float:
if t.Size() == 4 {
return reflect.NewValue(float(randFloat32(rand))), true
} else {
return reflect.NewValue(float(randFloat64(rand))), true
}
case reflect.Int16:
return reflect.NewValue(int16(randInt64(rand))), true
case reflect.Int32:
return reflect.NewValue(int32(randInt64(rand))), true
case reflect.Int64:
return reflect.NewValue(randInt64(rand)), true
case reflect.Int8:
return reflect.NewValue(int8(randInt64(rand))), true
case reflect.Int:
return reflect.NewValue(int(randInt64(rand))), true
case reflect.Uint16:
return reflect.NewValue(uint16(randInt64(rand))), true
case reflect.Uint32:
return reflect.NewValue(uint32(randInt64(rand))), true
case reflect.Uint64:
return reflect.NewValue(uint64(randInt64(rand))), true
case reflect.Uint8:
return reflect.NewValue(uint8(randInt64(rand))), true
case reflect.Uint:
return reflect.NewValue(uint(randInt64(rand))), true
case reflect.Uintptr:
return reflect.NewValue(uintptr(randInt64(rand))), true
}
case *reflect.Int16Type:
return reflect.NewValue(int16(randInt64(rand))), true
case *reflect.Int32Type:
return reflect.NewValue(int32(randInt64(rand))), true
case *reflect.Int64Type:
return reflect.NewValue(randInt64(rand)), true
case *reflect.Int8Type:
return reflect.NewValue(int8(randInt64(rand))), true
case *reflect.IntType:
return reflect.NewValue(int(randInt64(rand))), true
case *reflect.MapType:
numElems := rand.Intn(complexSize)
m := reflect.MakeMap(concrete)
@ -128,18 +143,6 @@ func Value(t reflect.Type, rand *rand.Rand) (value reflect.Value, ok bool) {
s.Field(i).SetValue(v)
}
return s, true
case *reflect.Uint16Type:
return reflect.NewValue(uint16(randInt64(rand))), true
case *reflect.Uint32Type:
return reflect.NewValue(uint32(randInt64(rand))), true
case *reflect.Uint64Type:
return reflect.NewValue(uint64(randInt64(rand))), true
case *reflect.Uint8Type:
return reflect.NewValue(uint8(randInt64(rand))), true
case *reflect.UintType:
return reflect.NewValue(uint(randInt64(rand))), true
case *reflect.UintptrType:
return reflect.NewValue(uintptr(randInt64(rand))), true
default:
return nil, false
}

63
src/pkg/xml/read.go
View File

@ -218,7 +218,7 @@ func (p *Parser) unmarshal(val reflect.Value, start *StartElement) os.Error {
case *reflect.SliceValue:
typ := v.Type().(*reflect.SliceType)
if _, ok := typ.Elem().(*reflect.Uint8Type); ok {
if typ.Elem().Kind() == reflect.Uint8 {
// []byte
saveData = v
break
@ -245,11 +245,7 @@ func (p *Parser) unmarshal(val reflect.Value, start *StartElement) os.Error {
}
return nil
case *reflect.StringValue,
*reflect.IntValue, *reflect.UintValue, *reflect.UintptrValue,
*reflect.Int8Value, *reflect.Int16Value, *reflect.Int32Value, *reflect.Int64Value,
*reflect.Uint8Value, *reflect.Uint16Value, *reflect.Uint32Value, *reflect.Uint64Value,
*reflect.FloatValue, *reflect.Float32Value, *reflect.Float64Value, *reflect.BoolValue:
case *reflect.BoolValue, *reflect.FloatValue, *reflect.IntValue, *reflect.UintValue, *reflect.StringValue:
saveData = v
case *reflect.StructValue:
@ -431,71 +427,16 @@ Loop:
default:
return os.ErrorString("cannot happen: unknown type " + t.Type().String())
case *reflect.IntValue:
if !getInt64() {
return err
}
t.Set(int(itmp))
case *reflect.Int8Value:
if !getInt64() {
return err
}
t.Set(int8(itmp))
case *reflect.Int16Value:
if !getInt64() {
return err
}
t.Set(int16(itmp))
case *reflect.Int32Value:
if !getInt64() {
return err
}
t.Set(int32(itmp))
case *reflect.Int64Value:
if !getInt64() {
return err
}
t.Set(itmp)
case *reflect.UintValue:
if !getUint64() {
return err
}
t.Set(uint(utmp))
case *reflect.Uint8Value:
if !getUint64() {
return err
}
t.Set(uint8(utmp))
case *reflect.Uint16Value:
if !getUint64() {
return err
}
t.Set(uint16(utmp))
case *reflect.Uint32Value:
if !getUint64() {
return err
}
t.Set(uint32(utmp))
case *reflect.Uint64Value:
if !getUint64() {
return err
}
t.Set(utmp)
case *reflect.UintptrValue:
if !getUint64() {
return err
}
t.Set(uintptr(utmp))
case *reflect.FloatValue:
if !getFloat64() {
return err
}
t.Set(float(ftmp))
case *reflect.Float32Value:
if !getFloat64() {
return err
}
t.Set(float32(ftmp))
case *reflect.Float64Value:
if !getFloat64() {
return err
}