update protocol library to new reflection API.
update golden files.
R=rsc
CC=dsymonds
http://codereview.appspot.com/1698044
diff --git a/proto/properties.go b/proto/properties.go
index 960329a..3258217 100644
--- a/proto/properties.go
+++ b/proto/properties.go
@@ -229,6 +229,7 @@
case *reflect.PtrType:
switch t2 := t1.Elem().(type) {
default:
+ BadType:
fmt.Fprintf(os.Stderr, "proto: no encoder function for %T -> %T\n", t1, t2)
break
case *reflect.BoolType:
@@ -236,26 +237,36 @@
p.dec = (*Buffer).dec_bool
p.alignof = unsafe.Alignof(vbool)
p.sizeof = unsafe.Sizeof(vbool)
- case *reflect.Int32Type, *reflect.Uint32Type:
- p.enc = (*Buffer).enc_int32
- p.dec = (*Buffer).dec_int32
- p.alignof = unsafe.Alignof(vint32)
- p.sizeof = unsafe.Sizeof(vint32)
- case *reflect.Int64Type, *reflect.Uint64Type:
- p.enc = (*Buffer).enc_int64
- p.dec = (*Buffer).dec_int64
- p.alignof = unsafe.Alignof(vint64)
- p.sizeof = unsafe.Sizeof(vint64)
- case *reflect.Float32Type:
- p.enc = (*Buffer).enc_int32 // can just treat them as bits
- p.dec = (*Buffer).dec_int32
- p.alignof = unsafe.Alignof(vfloat32)
- p.sizeof = unsafe.Sizeof(vfloat32)
- case *reflect.Float64Type:
- p.enc = (*Buffer).enc_int64 // can just treat them as bits
- p.dec = (*Buffer).dec_int64
- p.alignof = unsafe.Alignof(vfloat64)
- p.sizeof = unsafe.Sizeof(vfloat64)
+ case *reflect.IntType, *reflect.UintType:
+ switch t2.Bits() {
+ case 32:
+ p.enc = (*Buffer).enc_int32
+ p.dec = (*Buffer).dec_int32
+ p.alignof = unsafe.Alignof(vint32)
+ p.sizeof = unsafe.Sizeof(vint32)
+ case 64:
+ p.enc = (*Buffer).enc_int64
+ p.dec = (*Buffer).dec_int64
+ p.alignof = unsafe.Alignof(vint64)
+ p.sizeof = unsafe.Sizeof(vint64)
+ default:
+ goto BadType
+ }
+ case *reflect.FloatType:
+ switch t2.Bits() {
+ case 32:
+ p.enc = (*Buffer).enc_int32 // can just treat them as bits
+ p.dec = (*Buffer).dec_int32
+ p.alignof = unsafe.Alignof(vfloat32)
+ p.sizeof = unsafe.Sizeof(vfloat32)
+ case 64:
+ p.enc = (*Buffer).enc_int64 // can just treat them as bits
+ p.dec = (*Buffer).dec_int64
+ p.alignof = unsafe.Alignof(vfloat64)
+ p.sizeof = unsafe.Sizeof(vfloat64)
+ default:
+ goto BadType
+ }
case *reflect.StringType:
p.enc = (*Buffer).enc_string
p.dec = (*Buffer).dec_string
@@ -275,38 +286,51 @@
case *reflect.SliceType:
switch t2 := t1.Elem().(type) {
default:
- fmt.Fprintf(os.Stderr, "proto: no oenc for %T -> %T\n", t1, t2)
+ BadSliceType:
+ fmt.Fprintf(os.Stderr, "proto: no slice oenc for %T = []%T\n", t1, t2)
break
- case *reflect.Uint8Type:
- p.enc = (*Buffer).enc_slice_byte
- p.dec = (*Buffer).dec_slice_byte
- p.alignof = unsafe.Alignof(vbyte)
- p.sizeof = startSize * unsafe.Sizeof(vbyte)
case *reflect.BoolType:
p.enc = (*Buffer).enc_slice_bool
p.dec = (*Buffer).dec_slice_bool
p.alignof = unsafe.Alignof(vbool)
p.sizeof = startSize * unsafe.Sizeof(vbool)
- case *reflect.Int32Type, *reflect.Uint32Type:
- p.enc = (*Buffer).enc_slice_int32
- p.dec = (*Buffer).dec_slice_int32
- p.alignof = unsafe.Alignof(vint32)
- p.sizeof = startSize * unsafe.Sizeof(vint32)
- case *reflect.Int64Type, *reflect.Uint64Type:
- p.enc = (*Buffer).enc_slice_int64
- p.dec = (*Buffer).dec_slice_int64
- p.alignof = unsafe.Alignof(vint64)
- p.sizeof = startSize * unsafe.Sizeof(vint64)
- case *reflect.Float32Type:
- p.enc = (*Buffer).enc_slice_int32 // can just treat them as bits
- p.dec = (*Buffer).dec_slice_int32
- p.alignof = unsafe.Alignof(vfloat32)
- p.sizeof = startSize * unsafe.Sizeof(vfloat32)
- case *reflect.Float64Type:
- p.enc = (*Buffer).enc_slice_int64 // can just treat them as bits
- p.dec = (*Buffer).dec_slice_int64
- p.alignof = unsafe.Alignof(vfloat64)
- p.sizeof = startSize * unsafe.Sizeof(vfloat64)
+ case *reflect.IntType, *reflect.UintType:
+ switch t2.Bits() {
+ case 32:
+ p.enc = (*Buffer).enc_slice_int32
+ p.dec = (*Buffer).dec_slice_int32
+ p.alignof = unsafe.Alignof(vint32)
+ p.sizeof = startSize * unsafe.Sizeof(vint32)
+ case 64:
+ p.enc = (*Buffer).enc_slice_int64
+ p.dec = (*Buffer).dec_slice_int64
+ p.alignof = unsafe.Alignof(vint64)
+ p.sizeof = startSize * unsafe.Sizeof(vint64)
+ case 8:
+ if t2.Kind() == reflect.Uint8 {
+ p.enc = (*Buffer).enc_slice_byte
+ p.dec = (*Buffer).dec_slice_byte
+ p.alignof = unsafe.Alignof(vbyte)
+ p.sizeof = startSize * unsafe.Sizeof(vbyte)
+ }
+ default:
+ goto BadSliceType
+ }
+ case *reflect.FloatType:
+ switch t2.Bits() {
+ case 32:
+ p.enc = (*Buffer).enc_slice_int32 // can just treat them as bits
+ p.dec = (*Buffer).dec_slice_int32
+ p.alignof = unsafe.Alignof(vfloat32)
+ p.sizeof = startSize * unsafe.Sizeof(vfloat32)
+ case 64:
+ p.enc = (*Buffer).enc_slice_int64 // can just treat them as bits
+ p.dec = (*Buffer).dec_slice_int64
+ p.alignof = unsafe.Alignof(vfloat64)
+ p.sizeof = startSize * unsafe.Sizeof(vfloat64)
+ default:
+ goto BadSliceType
+ }
case *reflect.StringType:
p.enc = (*Buffer).enc_slice_string
p.dec = (*Buffer).dec_slice_string
@@ -315,7 +339,7 @@
case *reflect.PtrType:
switch t3 := t2.Elem().(type) {
default:
- fmt.Fprintf(os.Stderr, "proto: no oenc for %T -> %T -> %T\n", t1, t2, t3)
+ fmt.Fprintf(os.Stderr, "proto: no ptr oenc for %T -> %T -> %T\n", t1, t2, t3)
break
case *reflect.StructType:
p.stype = t2
@@ -329,11 +353,11 @@
p.sizeof = startSize * unsafe.Sizeof(vslice)
}
case *reflect.SliceType:
- switch t3 := t2.Elem().(type) {
+ switch t2.Elem().Kind() {
default:
- fmt.Fprintf(os.Stderr, "proto: no oenc for %T -> %T -> %T\n", t1, t2, t3)
+ fmt.Fprintf(os.Stderr, "proto: no slice elem oenc for %T -> %T -> %T\n", t1, t2, t2.Elem())
break
- case *reflect.Uint8Type:
+ case reflect.Uint8:
p.enc = (*Buffer).enc_slice_slice_byte
p.dec = (*Buffer).dec_slice_slice_byte
p.alignof = unsafe.Alignof(vslice)
diff --git a/proto/testdata/test.pb.go b/proto/testdata/test.pb.go
index b237996..23c1f0e 100644
--- a/proto/testdata/test.pb.go
+++ b/proto/testdata/test.pb.go
@@ -3,7 +3,10 @@
package test_proto
-import "goprotobuf.googlecode.com/hg/proto"
+import proto "goprotobuf.googlecode.com/hg/proto"
+
+// Reference proto import to suppress error if it's not otherwise used.
+var _ = proto.GetString
type FOO int32
const (
diff --git a/proto/testdata/test.pb.go.golden b/proto/testdata/test.pb.go.golden
index b237996..23c1f0e 100644
--- a/proto/testdata/test.pb.go.golden
+++ b/proto/testdata/test.pb.go.golden
@@ -3,7 +3,10 @@
package test_proto
-import "goprotobuf.googlecode.com/hg/proto"
+import proto "goprotobuf.googlecode.com/hg/proto"
+
+// Reference proto import to suppress error if it's not otherwise used.
+var _ = proto.GetString
type FOO int32
const (
diff --git a/proto/text.go b/proto/text.go
index ccb8ae5..f715589 100644
--- a/proto/text.go
+++ b/proto/text.go
@@ -137,15 +137,15 @@
}
func tryWriteEnum(w *textWriter, enum string, v reflect.Value) bool {
- val, ok := reflect.Indirect(v).(*reflect.Int32Value)
- if !ok {
+ v = reflect.Indirect(v)
+ if v.Type().Kind() != reflect.Int32 {
return false
}
m, ok := enumNameMaps[enum]
if !ok {
return false
}
- str, ok := m[val.Get()]
+ str, ok := m[int32(v.(*reflect.IntValue).Get())]
if !ok {
return false
}
@@ -161,10 +161,10 @@
switch val := v.(type) {
case *reflect.SliceValue:
// Should only be a []byte; repeated fields are handled in writeStruct.
- // TODO: Handle other cases cleaner.
+ // TODO: Handle other cases more cleanly.
bytes := make([]byte, val.Len())
for i := 0; i < val.Len(); i++ {
- bytes[i] = val.Elem(i).(*reflect.Uint8Value).Get()
+ bytes[i] = byte(val.Elem(i).(*reflect.UintValue).Get())
}
// TODO: Should be strconv.QuoteC, which doesn't exist yet
fmt.Fprint(w, strconv.Quote(string(bytes)))
diff --git a/proto/text_parser.go b/proto/text_parser.go
index e1c0832..f888f9b 100644
--- a/proto/text_parser.go
+++ b/proto/text_parser.go
@@ -354,7 +354,7 @@
switch fv := v.(type) {
case *reflect.SliceValue:
at := v.Type().(*reflect.SliceType)
- if _, ok := at.Elem().(*reflect.Uint8Type); ok {
+ if at.Elem().Kind() == reflect.Uint8 {
// Special case for []byte
if tok.value[0] != '"' {
// Deliberately written out here, as the error after
@@ -386,38 +386,36 @@
fv.Set(false)
return nil
}
- case *reflect.Float32Value:
- if f, err := strconv.Atof32(tok.value); err == nil {
+ case *reflect.FloatValue:
+ if f, err := strconv.AtofN(tok.value, fv.Type().Bits()); err == nil {
fv.Set(f)
return nil
}
- case *reflect.Float64Value:
- if f, err := strconv.Atof64(tok.value); err == nil {
- fv.Set(f)
+ case *reflect.IntValue:
+ switch fv.Type().Bits() {
+ case 32:
+ if x, err := strconv.Atoi64(tok.value); err == nil && minInt32 <= x && x <= maxInt32 {
+ fv.Set(x)
+ return nil
+ }
+ if len(props.Enum) == 0 {
+ break
+ }
+ m, ok := enumValueMaps[props.Enum]
+ if !ok {
+ break
+ }
+ x, ok := m[tok.value]
+ if !ok {
+ break
+ }
+ fv.Set(int64(x))
return nil
- }
- case *reflect.Int32Value:
- if x, err := strconv.Atoi64(tok.value); err == nil && minInt32 <= x && x <= maxInt32 {
- fv.Set(int32(x))
- return nil
- }
- if len(props.Enum) == 0 {
- break
- }
- m, ok := enumValueMaps[props.Enum]
- if !ok {
- break
- }
- x, ok := m[tok.value]
- if !ok {
- break
- }
- fv.Set(x)
- return nil
- case *reflect.Int64Value:
- if x, err := strconv.Atoi64(tok.value); err == nil {
- fv.Set(x)
- return nil
+ case 64:
+ if x, err := strconv.Atoi64(tok.value); err == nil {
+ fv.Set(x)
+ return nil
+ }
}
case *reflect.PtrValue:
// A basic field (indirected through pointer), or a repeated message/group
@@ -440,15 +438,18 @@
return p.error("expected '{' or '<', found %q", tok.value)
}
return p.readStruct(fv, terminator)
- case *reflect.Uint32Value:
- if x, err := strconv.Atoui64(tok.value); err == nil && x <= maxUint32 {
- fv.Set(uint32(x))
- return nil
- }
- case *reflect.Uint64Value:
- if x, err := strconv.Atoui64(tok.value); err == nil {
- fv.Set(x)
- return nil
+ case *reflect.UintValue:
+ switch fv.Type().Bits() {
+ case 32:
+ if x, err := strconv.Atoui64(tok.value); err == nil && x <= maxUint32 {
+ fv.Set(uint64(x))
+ return nil
+ }
+ case 64:
+ if x, err := strconv.Atoui64(tok.value); err == nil {
+ fv.Set(x)
+ return nil
+ }
}
}
return p.error("invalid %v: %v", v.Type(), tok.value)