encoding/asn1: prepare for 64-bit ints

The code was assuming that int = 32 bits. Don't.

Update #2188.

R=agl
CC=golang-dev
https://golang.org/cl/6543063

diff --git a/src/pkg/encoding/asn1/asn1.go b/src/pkg/encoding/asn1/asn1.go
index ac2b5f8daa6cb63ce1d2b689c85eb8a9c76d22cb..cac9d64b5e95d7a758d20459d99d84ae1e45c997 100644 (file)
--- a/src/pkg/encoding/asn1/asn1.go
+++ b/src/pkg/encoding/asn1/asn1.go
@@ -77,15 +77,15 @@ func parseInt64(bytes []byte) (ret int64, err error) {
 
 // parseInt treats the given bytes as a big-endian, signed integer and returns
 // the result.
-func parseInt(bytes []byte) (int, error) {
+func parseInt32(bytes []byte) (int32, error) {
        ret64, err := parseInt64(bytes)
        if err != nil {
                return 0, err
        }
-       if ret64 != int64(int(ret64)) {
+       if ret64 != int64(int32(ret64)) {
                return 0, StructuralError{"integer too large"}
        }
-       return int(ret64), nil
+       return int32(ret64), nil
 }
 
 var bigOne = big.NewInt(1)
@@ -670,7 +670,7 @@ func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParam
                err = err1
                return
        case enumeratedType:
-               parsedInt, err1 := parseInt(innerBytes)
+               parsedInt, err1 := parseInt32(innerBytes)
                if err1 == nil {
                        v.SetInt(int64(parsedInt))
                }
@@ -692,19 +692,20 @@ func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParam
                }
                err = err1
                return
-       case reflect.Int, reflect.Int32:
-               parsedInt, err1 := parseInt(innerBytes)
-               if err1 == nil {
-                       val.SetInt(int64(parsedInt))
-               }
-               err = err1
-               return
-       case reflect.Int64:
-               parsedInt, err1 := parseInt64(innerBytes)
-               if err1 == nil {
-                       val.SetInt(parsedInt)
+       case reflect.Int, reflect.Int32, reflect.Int64:
+               if val.Type().Size() == 4 {
+                       parsedInt, err1 := parseInt32(innerBytes)
+                       if err1 == nil {
+                               val.SetInt(int64(parsedInt))
+                       }
+                       err = err1
+               } else {
+                       parsedInt, err1 := parseInt64(innerBytes)
+                       if err1 == nil {
+                               val.SetInt(parsedInt)
+                       }
+                       err = err1
                }
-               err = err1
                return
        // TODO(dfc) Add support for the remaining integer types
        case reflect.Struct:

diff --git a/src/pkg/encoding/asn1/asn1_test.go b/src/pkg/encoding/asn1/asn1_test.go
index eb848bdb4afda1ca5cd747451ea8d3db84dad6e9..cabdf03b4824fd52e3623579d667c63baee2825b 100644 (file)
--- a/src/pkg/encoding/asn1/asn1_test.go
+++ b/src/pkg/encoding/asn1/asn1_test.go
@@ -64,7 +64,7 @@ var int32TestData = []int32Test{
 
 func TestParseInt32(t *testing.T) {
        for i, test := range int32TestData {
-               ret, err := parseInt(test.in)
+               ret, err := parseInt32(test.in)
                if (err == nil) != test.ok {
                        t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok)
                }