var signedResult = []byte{0x07, 2 * 17}
var unsignedResult = []byte{0x07, 17}
var floatResult = []byte{0x07, 0xFE, 0x31, 0x40}
-// The result of encoding "hello" with field number 6
+// The result of encoding a number 17+19i with field number 7
+var complexResult = []byte{0x07, 0xFE, 0x31, 0x40, 0xFE, 0x33, 0x40}
+// The result of encoding "hello" with field number 7
var bytesResult = []byte{0x07, 0x05, 'h', 'e', 'l', 'l', 'o'}
func newencoderState(b *bytes.Buffer) *encoderState {
}
}
+ // complex
+ {
+ var data struct {
+ a complex
+ }
+ instr := &decInstr{decOpMap[reflect.Complex], 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(complexResult)
+ execDec("complex", instr, state, t, unsafe.Pointer(&data))
+ if data.a != 17+19i {
+ t.Errorf("complex a = %v not 17+19i", data.a)
+ }
+ }
+
+ // complex64
+ {
+ var data struct {
+ a complex64
+ }
+ instr := &decInstr{decOpMap[reflect.Complex64], 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(complexResult)
+ execDec("complex", instr, state, t, unsafe.Pointer(&data))
+ if data.a != 17+19i {
+ t.Errorf("complex a = %v not 17+19i", data.a)
+ }
+ }
+
+ // complex128
+ {
+ var data struct {
+ a complex128
+ }
+ instr := &decInstr{decOpMap[reflect.Complex128], 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(complexResult)
+ execDec("complex", instr, state, t, unsafe.Pointer(&data))
+ if data.a != 17+19i {
+ t.Errorf("complex a = %v not 17+19i", data.a)
+ }
+ }
+
// bytes == []uint8
{
var data struct {
n *[3]float
strs *[2]string
int64s *[]int64
+ ri complex64
s string
y []byte
t *T2
n: &[3]float{1.5, 2.5, 3.5},
strs: &[2]string{s1, s2},
int64s: &[]int64{77, 89, 123412342134},
+ ri: 17 - 23i,
s: "Now is the time",
y: []byte("hello, sailor"),
t: &T2{"this is T2"},
maxu uint64
maxf float64
minf float64
+ maxc complex128
+ minc complex128
}
var it inputT
var err os.Error
if err == nil || err.String() != `value for "maxf" out of range` {
t.Error("wrong overflow error for float32:", err)
}
+
+ // complex64
+ b.Reset()
+ it = inputT{
+ maxc: cmplx(math.MaxFloat32*2, math.MaxFloat32*2),
+ }
+ type outc64 struct {
+ maxc complex64
+ minc complex64
+ }
+ var o8 outc64
+ enc.Encode(it)
+ err = dec.Decode(&o8)
+ if err == nil || err.String() != `value for "maxc" out of range` {
+ t.Error("wrong overflow error for complex64:", err)
+ }
}
decodeUint(state)
}
+func ignoreTwoUints(i *decInstr, state *decodeState, p unsafe.Pointer) {
+ decodeUint(state)
+ decodeUint(state)
+}
+
func decBool(i *decInstr, state *decodeState, p unsafe.Pointer) {
if i.indir > 0 {
if *(*unsafe.Pointer)(p) == nil {
return math.Float64frombits(v)
}
-func decFloat32(i *decInstr, state *decodeState, p unsafe.Pointer) {
- if i.indir > 0 {
- if *(*unsafe.Pointer)(p) == nil {
- *(*unsafe.Pointer)(p) = unsafe.Pointer(new(float32))
- }
- p = *(*unsafe.Pointer)(p)
- }
+func storeFloat32(i *decInstr, state *decodeState, p unsafe.Pointer) {
v := floatFromBits(decodeUint(state))
av := v
if av < 0 {
av = -av
}
- if math.MaxFloat32 < av { // underflow is OK
+ // +Inf is OK in both 32- and 64-bit floats. Underflow is always OK.
+ if math.MaxFloat32 < av && av <= math.MaxFloat64 {
state.err = i.ovfl
} else {
*(*float32)(p) = float32(v)
}
}
+func decFloat32(i *decInstr, state *decodeState, p unsafe.Pointer) {
+ if i.indir > 0 {
+ if *(*unsafe.Pointer)(p) == nil {
+ *(*unsafe.Pointer)(p) = unsafe.Pointer(new(float32))
+ }
+ p = *(*unsafe.Pointer)(p)
+ }
+ storeFloat32(i, state, p)
+}
+
func decFloat64(i *decInstr, state *decodeState, p unsafe.Pointer) {
if i.indir > 0 {
if *(*unsafe.Pointer)(p) == nil {
*(*float64)(p) = floatFromBits(uint64(decodeUint(state)))
}
+// Complex numbers are just a pair of floating-point numbers, real part first.
+func decComplex64(i *decInstr, state *decodeState, p unsafe.Pointer) {
+ if i.indir > 0 {
+ if *(*unsafe.Pointer)(p) == nil {
+ *(*unsafe.Pointer)(p) = unsafe.Pointer(new(complex64))
+ }
+ p = *(*unsafe.Pointer)(p)
+ }
+ storeFloat32(i, state, p)
+ storeFloat32(i, state, unsafe.Pointer(uintptr(p)+uintptr(unsafe.Sizeof(float(0)))))
+}
+
+func decComplex128(i *decInstr, state *decodeState, p unsafe.Pointer) {
+ if i.indir > 0 {
+ if *(*unsafe.Pointer)(p) == nil {
+ *(*unsafe.Pointer)(p) = unsafe.Pointer(new(complex128))
+ }
+ p = *(*unsafe.Pointer)(p)
+ }
+ real := floatFromBits(uint64(decodeUint(state)))
+ imag := floatFromBits(uint64(decodeUint(state)))
+ *(*complex128)(p) = cmplx(real, imag)
+}
+
// uint8 arrays are encoded as an unsigned count followed by the raw bytes.
func decUint8Array(i *decInstr, state *decodeState, p unsafe.Pointer) {
if i.indir > 0 {
return ignoreArrayHelper(state, elemOp, int(decodeUint(state)))
}
+// Index by Go types.
var decOpMap = []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,
-}
-
+ 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.Complex64: decComplex64,
+ reflect.Complex128: decComplex128,
+ reflect.String: decString,
+}
+
+// Indexed by gob types. tComplex will be added during type.init().
var decIgnoreOpMap = map[typeId]decOp{
tBool: ignoreUint,
tInt: ignoreUint,
// Special cases
wire := dec.wireType[wireId]
switch {
+ case wire == nil:
+ panic("internal error: can't find ignore op for type " + wireId.string())
case wire.arrayT != nil:
elemId := wire.arrayT.Elem
elemOp, err := dec.decIgnoreOpFor(elemId)
return fw == tUint
case *reflect.FloatType:
return fw == tFloat
+ case *reflect.ComplexType:
+ return fw == tComplex
case *reflect.StringType:
return fw == tString
case *reflect.ArrayType:
}
func init() {
- // We assume that the size of float is sufficient to tell us whether it is
- // equivalent to float32 or to float64. This is very unlikely to be wrong.
- var op decOp
- switch unsafe.Sizeof(float(0)) {
- case unsafe.Sizeof(float32(0)):
- op = decFloat32
- case unsafe.Sizeof(float64(0)):
- op = decFloat64
+ var fop, cop decOp
+ switch reflect.Typeof(float(0)).Bits() {
+ case 32:
+ fop = decFloat32
+ cop = decComplex64
+ case 64:
+ fop = decFloat64
+ cop = decComplex128
default:
panic("gob: unknown size of float")
}
- decOpMap[reflect.Float] = op
+ decOpMap[reflect.Float] = fop
+ decOpMap[reflect.Complex] = cop
- // A similar assumption about int and uint. Also assume int and uint have the same size.
- var uop decOp
- switch unsafe.Sizeof(int(0)) {
- case unsafe.Sizeof(int32(0)):
- op = decInt32
+ var iop, uop decOp
+ switch reflect.Typeof(int(0)).Bits() {
+ case 32:
+ iop = decInt32
uop = decUint32
- case unsafe.Sizeof(int64(0)):
- op = decInt64
+ case 64:
+ iop = decInt64
uop = decUint64
default:
panic("gob: unknown size of int/uint")
}
- decOpMap[reflect.Int] = op
+ decOpMap[reflect.Int] = iop
decOpMap[reflect.Uint] = uop
// Finally uintptr
- switch unsafe.Sizeof(uintptr(0)) {
- case unsafe.Sizeof(uint32(0)):
+ switch reflect.Typeof(uintptr(0)).Bits() {
+ case 32:
uop = decUint32
- case unsafe.Sizeof(uint64(0)):
+ case 64:
uop = decUint64
default:
panic("gob: unknown size of uintptr")
}
func encFloat(i *encInstr, state *encoderState, p unsafe.Pointer) {
- f := float(*(*float)(p))
+ f := *(*float)(p)
if f != 0 || state.inArray {
v := floatBits(float64(f))
state.update(i)
}
func encFloat32(i *encInstr, state *encoderState, p unsafe.Pointer) {
- f := float32(*(*float32)(p))
+ f := *(*float32)(p)
if f != 0 || state.inArray {
v := floatBits(float64(f))
state.update(i)
}
}
+// Complex numbers are just a pair of floating-point numbers, real part first.
+func encComplex(i *encInstr, state *encoderState, p unsafe.Pointer) {
+ c := *(*complex)(p)
+ if c != 0+0i || state.inArray {
+ rpart := floatBits(float64(real(c)))
+ ipart := floatBits(float64(imag(c)))
+ state.update(i)
+ encodeUint(state, rpart)
+ encodeUint(state, ipart)
+ }
+}
+
+func encComplex64(i *encInstr, state *encoderState, p unsafe.Pointer) {
+ c := *(*complex64)(p)
+ if c != 0+0i || state.inArray {
+ rpart := floatBits(float64(real(c)))
+ ipart := floatBits(float64(imag(c)))
+ state.update(i)
+ encodeUint(state, rpart)
+ encodeUint(state, ipart)
+ }
+}
+
+func encComplex128(i *encInstr, state *encoderState, p unsafe.Pointer) {
+ c := *(*complex128)(p)
+ if c != 0+0i || state.inArray {
+ rpart := floatBits(real(c))
+ ipart := floatBits(imag(c))
+ state.update(i)
+ encodeUint(state, rpart)
+ encodeUint(state, ipart)
+ }
+}
+
// Byte arrays are encoded as an unsigned count followed by the raw bytes.
func encUint8Array(i *encInstr, state *encoderState, p unsafe.Pointer) {
b := *(*[]byte)(p)
}
var encOpMap = []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,
+ 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.Complex: encComplex,
+ reflect.Complex64: encComplex64,
+ reflect.Complex128: encComplex128,
+ reflect.String: encString,
}
// Return the encoding op for the base type under rt and
}
}
if op == nil {
- return op, indir, os.ErrorString("gob enc: can't happen: encode type" + rt.String())
+ return op, indir, os.ErrorString("gob enc: can't happen: encode type " + rt.String())
}
return op, indir, nil
}
// Create and check predefined types
// The string for tBytes is "bytes" not "[]byte" to signify its specialness.
-var tBool = bootstrapType("bool", false, 1)
-var tInt = bootstrapType("int", int(0), 2)
-var tUint = bootstrapType("uint", uint(0), 3)
-var tFloat = bootstrapType("float", float64(0), 4)
-var tBytes = bootstrapType("bytes", make([]byte, 0), 5)
-var tString = bootstrapType("string", "", 6)
+var (
+ // Primordial types, needed during initialization.
+ tBool = bootstrapType("bool", false, 1)
+ tInt = bootstrapType("int", int(0), 2)
+ tUint = bootstrapType("uint", uint(0), 3)
+ tFloat = bootstrapType("float", float64(0), 4)
+ tBytes = bootstrapType("bytes", make([]byte, 0), 5)
+ tString = bootstrapType("string", "", 6)
+ // Types added to the language later, not needed during initialization.
+ tComplex typeId
+)
// Predefined because it's needed by the Decoder
var tWireType = mustGetTypeInfo(reflect.Typeof(wireType{})).id
checkId(9, mustGetTypeInfo(reflect.Typeof(commonType{})).id)
checkId(11, mustGetTypeInfo(reflect.Typeof(structType{})).id)
checkId(12, mustGetTypeInfo(reflect.Typeof(fieldType{})).id)
+
+ // Complex was added after gob was written, so appears after the
+ // fundamental types are built.
+ tComplex = bootstrapType("complex", 0+0i, 15)
+ decIgnoreOpMap[tComplex] = ignoreTwoUints
+
builtinIdToType = make(map[typeId]gobType)
for k, v := range idToType {
builtinIdToType[k] = v
}
+
// Move the id space upwards to allow for growth in the predefined world
// without breaking existing files.
if nextId > firstUserId {
case *reflect.FloatType:
return tFloat.gobType(), nil
+ case *reflect.ComplexType:
+ return tComplex.gobType(), nil
+
case *reflect.StringType:
return tString.gobType(), nil
rt := reflect.Typeof(e)
_, present := types[rt]
if present {
- panic("bootstrap type already present: " + name)
+ panic("bootstrap type already present: " + name + ", " + rt.String())
}
typ := &commonType{name: name}
types[rt] = typ