type Indirect struct {
a ***[3]int
s ***[]int
- m ***map[string]int
+ m ****map[string]int
}
type Direct struct {
*i.s = new(*[]int)
**i.s = new([]int)
***i.s = []int{4, 5, 6}
- i.m = new(**map[string]int)
- *i.m = new(*map[string]int)
- **i.m = new(map[string]int)
- ***i.m = map[string]int{"one": 1, "two": 2, "three": 3}
+ i.m = new(***map[string]int)
+ *i.m = new(**map[string]int)
+ **i.m = new(*map[string]int)
+ ***i.m = new(map[string]int)
+ ****i.m = map[string]int{"one": 1, "two": 2, "three": 3}
b := new(bytes.Buffer)
NewEncoder(b).Encode(i)
dec := NewDecoder(b)
t.Error("error: ", err)
}
if len(***i.a) != 3 || (***i.a)[0] != 11 || (***i.a)[1] != 22 || (***i.a)[2] != 33 {
- t.Errorf("indirect to direct: ***i.a is %v not %v", ***i.a, d.a)
+ t.Errorf("direct to indirect: ***i.a is %v not %v", ***i.a, d.a)
}
if len(***i.s) != 3 || (***i.s)[0] != 44 || (***i.s)[1] != 55 || (***i.s)[2] != 66 {
- t.Errorf("indirect to direct: ***i.s is %v not %v", ***i.s, ***i.s)
+ t.Errorf("direct to indirect: ***i.s is %v not %v", ***i.s, ***i.s)
}
- if len(***i.m) != 3 || (***i.m)["four"] != 4 || (***i.m)["five"] != 5 || (***i.m)["six"] != 6 {
- t.Errorf("indirect to direct: ***i.m is %v not %v", ***i.m, d.m)
+ if len(****i.m) != 3 || (****i.m)["four"] != 4 || (****i.m)["five"] != 5 || (****i.m)["six"] != 6 {
+ t.Errorf("direct to indirect: ****i.m is %v not %v", ****i.m, d.m)
}
}
"math"
"os"
"reflect"
- "runtime"
"unsafe"
)
var (
- errBadUint = os.ErrorString("gob: encoded unsigned integer out of range")
- errBadType = os.ErrorString("gob: unknown type id or corrupted data")
- errRange = os.ErrorString("gob: internal error: field numbers out of bounds")
- errNotStruct = os.ErrorString("gob: TODO: can only handle structs")
+ errBadUint = os.ErrorString("gob: encoded unsigned integer out of range")
+ errBadType = os.ErrorString("gob: unknown type id or corrupted data")
+ errRange = os.ErrorString("gob: internal error: field numbers out of bounds")
)
// The global execution state of an instance of the decoder.
numInstr int // the number of active instructions
}
-func decodeStruct(engine *decEngine, rtyp *reflect.StructType, b *bytes.Buffer, p uintptr, indir int) os.Error {
- if indir > 0 {
- up := unsafe.Pointer(p)
- if indir > 1 {
- up = decIndirect(up, indir)
- }
- if *(*unsafe.Pointer)(up) == nil {
- // Allocate object.
- *(*unsafe.Pointer)(up) = unsafe.New((*runtime.StructType)(unsafe.Pointer(rtyp)))
- }
- p = *(*uintptr)(up)
+// allocate makes sure storage is available for an object of underlying type rtyp
+// that is indir levels of indirection through p.
+func allocate(rtyp reflect.Type, p uintptr, indir int) uintptr {
+ if indir == 0 {
+ return p
+ }
+ up := unsafe.Pointer(p)
+ if indir > 1 {
+ up = decIndirect(up, indir)
}
+ if *(*unsafe.Pointer)(up) == nil {
+ // Allocate object.
+ *(*unsafe.Pointer)(up) = unsafe.New(rtyp)
+ }
+ return *(*uintptr)(up)
+}
+
+func decodeSingle(engine *decEngine, rtyp reflect.Type, b *bytes.Buffer, p uintptr, indir int) os.Error {
+ p = allocate(rtyp, p, indir)
+ state := newDecodeState(b)
+ state.fieldnum = singletonField
+ basep := p
+ delta := int(decodeUint(state))
+ if delta != 0 {
+ state.err = os.ErrorString("gob decode: corrupted data: non-zero delta for singleton")
+ return state.err
+ }
+ instr := &engine.instr[singletonField]
+ ptr := unsafe.Pointer(basep) // offset will be zero
+ if instr.indir > 1 {
+ ptr = decIndirect(ptr, instr.indir)
+ }
+ instr.op(instr, state, ptr)
+ return state.err
+}
+
+func decodeStruct(engine *decEngine, rtyp *reflect.StructType, b *bytes.Buffer, p uintptr, indir int) os.Error {
+ p = allocate(rtyp, p, indir)
state := newDecodeState(b)
state.fieldnum = -1
basep := p
func decodeArray(atyp *reflect.ArrayType, state *decodeState, p uintptr, elemOp decOp, elemWid uintptr, length, indir, elemIndir int, ovfl os.ErrorString) os.Error {
if indir > 0 {
- up := unsafe.Pointer(p)
- if *(*unsafe.Pointer)(up) == nil {
- // Allocate object.
- *(*unsafe.Pointer)(up) = unsafe.New(atyp)
- }
- p = *(*uintptr)(up)
+ p = allocate(atyp, p, 1) // All but the last level has been allocated by dec.Indirect
}
if n := decodeUint(state); n != uint64(length) {
return os.ErrorString("gob: length mismatch in decodeArray")
func decodeMap(mtyp *reflect.MapType, state *decodeState, p uintptr, keyOp, elemOp decOp, indir, keyIndir, elemIndir int, ovfl os.ErrorString) os.Error {
if indir > 0 {
- up := unsafe.Pointer(p)
- if *(*unsafe.Pointer)(up) == nil {
- // Allocate object.
- *(*unsafe.Pointer)(up) = unsafe.New(mtyp)
- }
- p = *(*uintptr)(up)
+ p = allocate(mtyp, p, 1) // All but the last level has been allocated by dec.Indirect
}
up := unsafe.Pointer(p)
if *(*unsafe.Pointer)(up) == nil { // maps are represented as a pointer in the runtime
return true
}
+func (dec *Decoder) compileSingle(remoteId typeId, rt reflect.Type) (engine *decEngine, err os.Error) {
+ engine = new(decEngine)
+ engine.instr = make([]decInstr, 1) // one item
+ name := rt.String() // best we can do
+ if !dec.compatibleType(rt, remoteId) {
+ return nil, os.ErrorString("gob: wrong type received for local value " + name)
+ }
+ op, indir, err := dec.decOpFor(remoteId, rt, name)
+ if err != nil {
+ return nil, err
+ }
+ ovfl := os.ErrorString(`value for "` + name + `" out of range`)
+ engine.instr[singletonField] = decInstr{op, singletonField, indir, 0, ovfl}
+ engine.numInstr = 1
+ return
+}
+
func (dec *Decoder) compileDec(remoteId typeId, rt reflect.Type) (engine *decEngine, err os.Error) {
- srt, ok1 := rt.(*reflect.StructType)
+ srt, ok := rt.(*reflect.StructType)
+ if !ok {
+ return dec.compileSingle(remoteId, rt)
+ }
var wireStruct *structType
// Builtin types can come from global pool; the rest must be defined by the decoder
if t, ok := builtinIdToType[remoteId]; ok {
wireStruct = t.(*structType)
} else {
- w, ok2 := dec.wireType[remoteId]
- if !ok1 || !ok2 {
- return nil, errNotStruct
- }
- wireStruct = w.structT
+ wireStruct = dec.wireType[remoteId].structT
}
engine = new(decEngine)
engine.instr = make([]decInstr, len(wireStruct.field))
func (dec *Decoder) decode(wireId typeId, e interface{}) os.Error {
// Dereference down to the underlying struct type.
rt, indir := indirect(reflect.Typeof(e))
- st, ok := rt.(*reflect.StructType)
- if !ok {
- return os.ErrorString("gob: decode can't handle " + rt.String())
- }
enginePtr, err := dec.getDecEnginePtr(wireId, rt)
if err != nil {
return err
}
engine := *enginePtr
- if engine.numInstr == 0 && st.NumField() > 0 && len(dec.wireType[wireId].structT.field) > 0 {
- name := rt.Name()
- return os.ErrorString("gob: type mismatch: no fields matched compiling decoder for " + name)
+ if st, ok := rt.(*reflect.StructType); ok {
+ if engine.numInstr == 0 && st.NumField() > 0 && len(dec.wireType[wireId].structT.field) > 0 {
+ name := rt.Name()
+ return os.ErrorString("gob: type mismatch: no fields matched compiling decoder for " + name)
+ }
+ return decodeStruct(engine, st, dec.state.b, uintptr(reflect.NewValue(e).Addr()), indir)
}
- return decodeStruct(engine, st, dec.state.b, uintptr(reflect.NewValue(e).Addr()), indir)
+ return decodeSingle(engine, rt, dec.state.b, uintptr(reflect.NewValue(e).Addr()), indir)
}
func init() {
}
// No, it's a value.
- // Make sure the type has been defined already.
- if dec.wireType[id] == nil {
+ // Make sure the type has been defined already or is a builtin type (for
+ // top-level singleton values).
+ if dec.wireType[id] == nil && builtinIdToType[id] == nil {
dec.state.err = errBadType
break
}
type encoderState struct {
b *bytes.Buffer
err os.Error // error encountered during encoding.
- inArray bool // encoding an array element or map key/value pair
+ sendZero bool // encoding an array element or map key/value pair; send zero values
fieldnum int // the last field number written.
buf [1 + uint64Size]byte // buffer used by the encoder; here to avoid allocation.
}
func encBool(i *encInstr, state *encoderState, p unsafe.Pointer) {
b := *(*bool)(p)
- if b || state.inArray {
+ if b || state.sendZero {
state.update(i)
if b {
encodeUint(state, 1)
func encInt(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := int64(*(*int)(p))
- if v != 0 || state.inArray {
+ if v != 0 || state.sendZero {
state.update(i)
encodeInt(state, v)
}
func encUint(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := uint64(*(*uint)(p))
- if v != 0 || state.inArray {
+ if v != 0 || state.sendZero {
state.update(i)
encodeUint(state, v)
}
func encInt8(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := int64(*(*int8)(p))
- if v != 0 || state.inArray {
+ if v != 0 || state.sendZero {
state.update(i)
encodeInt(state, v)
}
func encUint8(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := uint64(*(*uint8)(p))
- if v != 0 || state.inArray {
+ if v != 0 || state.sendZero {
state.update(i)
encodeUint(state, v)
}
func encInt16(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := int64(*(*int16)(p))
- if v != 0 || state.inArray {
+ if v != 0 || state.sendZero {
state.update(i)
encodeInt(state, v)
}
func encUint16(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := uint64(*(*uint16)(p))
- if v != 0 || state.inArray {
+ if v != 0 || state.sendZero {
state.update(i)
encodeUint(state, v)
}
func encInt32(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := int64(*(*int32)(p))
- if v != 0 || state.inArray {
+ if v != 0 || state.sendZero {
state.update(i)
encodeInt(state, v)
}
func encUint32(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := uint64(*(*uint32)(p))
- if v != 0 || state.inArray {
+ if v != 0 || state.sendZero {
state.update(i)
encodeUint(state, v)
}
func encInt64(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := *(*int64)(p)
- if v != 0 || state.inArray {
+ if v != 0 || state.sendZero {
state.update(i)
encodeInt(state, v)
}
func encUint64(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := *(*uint64)(p)
- if v != 0 || state.inArray {
+ if v != 0 || state.sendZero {
state.update(i)
encodeUint(state, v)
}
func encUintptr(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := uint64(*(*uintptr)(p))
- if v != 0 || state.inArray {
+ if v != 0 || state.sendZero {
state.update(i)
encodeUint(state, v)
}
func encFloat(i *encInstr, state *encoderState, p unsafe.Pointer) {
f := *(*float)(p)
- if f != 0 || state.inArray {
+ if f != 0 || state.sendZero {
v := floatBits(float64(f))
state.update(i)
encodeUint(state, v)
func encFloat32(i *encInstr, state *encoderState, p unsafe.Pointer) {
f := *(*float32)(p)
- if f != 0 || state.inArray {
+ if f != 0 || state.sendZero {
v := floatBits(float64(f))
state.update(i)
encodeUint(state, v)
func encFloat64(i *encInstr, state *encoderState, p unsafe.Pointer) {
f := *(*float64)(p)
- if f != 0 || state.inArray {
+ if f != 0 || state.sendZero {
state.update(i)
v := floatBits(f)
encodeUint(state, v)
// 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 {
+ if c != 0+0i || state.sendZero {
rpart := floatBits(float64(real(c)))
ipart := floatBits(float64(imag(c)))
state.update(i)
func encComplex64(i *encInstr, state *encoderState, p unsafe.Pointer) {
c := *(*complex64)(p)
- if c != 0+0i || state.inArray {
+ if c != 0+0i || state.sendZero {
rpart := floatBits(float64(real(c)))
ipart := floatBits(float64(imag(c)))
state.update(i)
func encComplex128(i *encInstr, state *encoderState, p unsafe.Pointer) {
c := *(*complex128)(p)
- if c != 0+0i || state.inArray {
+ if c != 0+0i || state.sendZero {
rpart := floatBits(real(c))
ipart := floatBits(imag(c))
state.update(i)
// 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)
- if len(b) > 0 || state.inArray {
+ if len(b) > 0 || state.sendZero {
state.update(i)
encodeUint(state, uint64(len(b)))
state.b.Write(b)
// Strings are encoded as an unsigned count followed by the raw bytes.
func encString(i *encInstr, state *encoderState, p unsafe.Pointer) {
s := *(*string)(p)
- if len(s) > 0 || state.inArray {
+ if len(s) > 0 || state.sendZero {
state.update(i)
encodeUint(state, uint64(len(s)))
io.WriteString(state.b, s)
instr []encInstr
}
+const singletonField = 0
+
+func encodeSingle(engine *encEngine, b *bytes.Buffer, basep uintptr) os.Error {
+ state := new(encoderState)
+ state.b = b
+ state.fieldnum = singletonField
+ // There is no surrounding struct to frame the transmission, so we must
+ // generate data even if the item is zero. To do this, set sendZero.
+ state.sendZero = true
+ instr := &engine.instr[singletonField]
+ p := unsafe.Pointer(basep) // offset will be zero
+ if instr.indir > 0 {
+ if p = encIndirect(p, instr.indir); p == nil {
+ return nil
+ }
+ }
+ instr.op(instr, state, p)
+ return state.err
+}
+
func encodeStruct(engine *encEngine, b *bytes.Buffer, basep uintptr) os.Error {
state := new(encoderState)
state.b = b
state := new(encoderState)
state.b = b
state.fieldnum = -1
- state.inArray = true
+ state.sendZero = true
encodeUint(state, uint64(length))
for i := 0; i < length && state.err == nil; i++ {
elemp := p
v = reflect.Indirect(v)
}
if v == nil {
- state.err = os.ErrorString("gob: encodeMap: nil element")
+ state.err = os.ErrorString("gob: encodeReflectValue: nil element")
return
}
op(nil, state, unsafe.Pointer(v.Addr()))
}
-func encodeMap(b *bytes.Buffer, rt reflect.Type, p uintptr, keyOp, elemOp encOp, keyIndir, elemIndir int) os.Error {
+func encodeMap(b *bytes.Buffer, mv *reflect.MapValue, keyOp, elemOp encOp, keyIndir, elemIndir int) os.Error {
state := new(encoderState)
state.b = b
state.fieldnum = -1
- state.inArray = true
- // Maps cannot be accessed by moving addresses around the way
- // that slices etc. can. We must recover a full reflection value for
- // the iteration.
- v := reflect.NewValue(unsafe.Unreflect(rt, unsafe.Pointer((p))))
- mv := reflect.Indirect(v).(*reflect.MapValue)
+ state.sendZero = true
keys := mv.Keys()
encodeUint(state, uint64(len(keys)))
for _, key := range keys {
return nil, 0, err
}
op = func(i *encInstr, state *encoderState, p unsafe.Pointer) {
+ slice := (*reflect.SliceHeader)(p)
+ if slice.Len == 0 {
+ return
+ }
state.update(i)
state.err = encodeArray(state.b, uintptr(p), elemOp, t.Elem().Size(), indir, t.Len())
}
return nil, 0, err
}
op = func(i *encInstr, state *encoderState, p unsafe.Pointer) {
+ // Maps cannot be accessed by moving addresses around the way
+ // that slices etc. can. We must recover a full reflection value for
+ // the iteration.
+ v := reflect.NewValue(unsafe.Unreflect(t, unsafe.Pointer((p))))
+ mv := reflect.Indirect(v).(*reflect.MapValue)
+ if mv.Len() == 0 {
+ return
+ }
state.update(i)
- state.err = encodeMap(state.b, typ, uintptr(p), keyOp, elemOp, keyIndir, elemIndir)
+ state.err = encodeMap(state.b, mv, keyOp, elemOp, keyIndir, elemIndir)
}
case *reflect.StructType:
// Generate a closure that calls out to the engine for the nested type.
// The local Type was compiled from the actual value, so we know it's compatible.
func compileEnc(rt reflect.Type) (*encEngine, os.Error) {
- srt, ok := rt.(*reflect.StructType)
- if !ok {
- panic("can't happen: non-struct")
- }
+ srt, isStruct := rt.(*reflect.StructType)
engine := new(encEngine)
- engine.instr = make([]encInstr, srt.NumField()+1) // +1 for terminator
- for fieldnum := 0; fieldnum < srt.NumField(); fieldnum++ {
- f := srt.Field(fieldnum)
- op, indir, err := encOpFor(f.Type)
+ if isStruct {
+ engine.instr = make([]encInstr, srt.NumField()+1) // +1 for terminator
+ for fieldnum := 0; fieldnum < srt.NumField(); fieldnum++ {
+ f := srt.Field(fieldnum)
+ op, indir, err := encOpFor(f.Type)
+ if err != nil {
+ return nil, err
+ }
+ engine.instr[fieldnum] = encInstr{op, fieldnum, indir, uintptr(f.Offset)}
+ }
+ engine.instr[srt.NumField()] = encInstr{encStructTerminator, 0, 0, 0}
+ } else {
+ engine.instr = make([]encInstr, 1)
+ op, indir, err := encOpFor(rt)
if err != nil {
return nil, err
}
- engine.instr[fieldnum] = encInstr{op, fieldnum, indir, uintptr(f.Offset)}
+ engine.instr[0] = encInstr{op, singletonField, indir, 0} // offset is zero
}
- engine.instr[srt.NumField()] = encInstr{encStructTerminator, 0, 0, 0}
return engine, nil
}
for i := 0; i < indir; i++ {
v = reflect.Indirect(v)
}
- if _, ok := v.(*reflect.StructValue); !ok {
- return os.ErrorString("gob: encode can't handle " + v.Type().String())
- }
typeLock.Lock()
engine, err := getEncEngine(rt)
typeLock.Unlock()
if err != nil {
return err
}
- return encodeStruct(engine, b, v.Addr())
+ if _, ok := v.(*reflect.StructValue); ok {
+ return encodeStruct(engine, b, v.Addr())
+ }
+ return encodeSingle(engine, b, v.Addr())
}
}
}
-func (enc *Encoder) sendType(origt reflect.Type) {
+func (enc *Encoder) sendType(origt reflect.Type) (sent bool) {
// Drill down to the base type.
rt, _ := indirect(origt)
enc.state.err = nil
rt, _ := indirect(reflect.Typeof(e))
- // Must be a struct
- if _, ok := rt.(*reflect.StructType); !ok {
- enc.badType(rt)
- return enc.state.err
- }
// Sanity check only: encoder should never come in with data present.
if enc.state.b.Len() > 0 || enc.countState.b.Len() > 0 {
// First, have we already sent this type?
if _, alreadySent := enc.sent[rt]; !alreadySent {
// No, so send it.
- enc.sendType(rt)
+ sent := enc.sendType(rt)
if enc.state.err != nil {
return enc.state.err
}
+ // If the type info has still not been transmitted, it means we have
+ // a singleton basic type (int, []byte etc.) at top level. We don't
+ // need to send the type info but we do need to update enc.sent.
+ if !sent {
+ typeLock.Lock()
+ info, err := getTypeInfo(rt)
+ typeLock.Unlock()
+ if err != nil {
+ enc.setError(err)
+ return err
+ }
+ enc.sent[rt] = info.id
+ }
}
// Identify the type of this top-level value.
corruptDataCheck("\x03now is the time for all good men", errBadType, t)
}
-// Types not supported by the Encoder (only structs work at the top level).
-// Basic types work implicitly.
+// Types not supported by the Encoder.
var unsupportedValues = []interface{}{
- 3,
- "hi",
- 7.2,
- []int{1, 2, 3},
- [3]int{1, 2, 3},
make(chan int),
func(a int) bool { return true },
- make(map[string]int),
new(interface{}),
}
t.Error(err)
}
}
+
+var testInt int
+var testFloat32 float32
+var testString string
+var testSlice []string
+var testMap map[string]int
+
+type SingleTest struct {
+ in interface{}
+ out interface{}
+ err string
+}
+
+var singleTests = []SingleTest{
+ SingleTest{17, &testInt, ""},
+ SingleTest{float32(17.5), &testFloat32, ""},
+ SingleTest{"bike shed", &testString, ""},
+ SingleTest{[]string{"bike", "shed", "paint", "color"}, &testSlice, ""},
+ SingleTest{map[string]int{"seven": 7, "twelve": 12}, &testMap, ""},
+
+ // Decode errors
+ SingleTest{172, &testFloat32, "wrong type"},
+}
+
+func TestSingletons(t *testing.T) {
+ b := new(bytes.Buffer)
+ enc := NewEncoder(b)
+ dec := NewDecoder(b)
+ for _, test := range singleTests {
+ b.Reset()
+ err := enc.Encode(test.in)
+ if err != nil {
+ t.Errorf("error encoding %v: %s", test.in, err)
+ continue
+ }
+ err = dec.Decode(test.out)
+ switch {
+ case err != nil && test.err == "":
+ t.Errorf("error decoding %v: %s", test.in, err)
+ continue
+ case err == nil && test.err != "":
+ t.Errorf("expected error decoding %v: %s", test.in, test.err)
+ continue
+ case err != nil && test.err != "":
+ if strings.Index(err.String(), test.err) < 0 {
+ t.Errorf("wrong error decoding %v: wanted %s, got %v", test.in, test.err, err)
+ }
+ continue
+ }
+ // Get rid of the pointer in the rhs
+ val := reflect.NewValue(test.out).(*reflect.PtrValue).Elem().Interface()
+ if !reflect.DeepEqual(test.in, val) {
+ t.Errorf("decoding int: expected %v got %v", test.in, val)
+ }
+ }
+}