type decodeState struct {
// The buffer is stored with an extra indirection because it may be replaced
// if we load a type during decode (when reading an interface value).
- b **bytes.Buffer
- err os.Error
+ b **bytes.Buffer
+ // err os.Error
fieldnum int // the last field number read.
buf []byte
}
// Sets state.err. If state.err is already non-nil, it does nothing.
// Does not check for overflow.
func decodeUint(state *decodeState) (x uint64) {
- if state.err != nil {
- return
+ b, err := state.b.ReadByte()
+ if err != nil {
+ error(err)
}
- var b uint8
- b, state.err = state.b.ReadByte()
if b <= 0x7f { // includes state.err != nil
return uint64(b)
}
nb := -int(int8(b))
if nb > uint64Size {
- state.err = errBadUint
- return
+ error(errBadUint)
+ }
+ n, err := state.b.Read(state.buf[0:nb])
+ if err != nil {
+ error(err)
}
- var n int
- n, state.err = state.b.Read(state.buf[0:nb])
// Don't need to check error; it's safe to loop regardless.
// Could check that the high byte is zero but it's not worth it.
for i := 0; i < n; i++ {
// Does not check for overflow.
func decodeInt(state *decodeState) int64 {
x := decodeUint(state)
- if state.err != nil {
- return 0
- }
if x&1 != 0 {
return ^int64(x >> 1)
}
}
v := decodeInt(state)
if v < math.MinInt8 || math.MaxInt8 < v {
- state.err = i.ovfl
+ error(i.ovfl)
} else {
*(*int8)(p) = int8(v)
}
}
v := decodeUint(state)
if math.MaxUint8 < v {
- state.err = i.ovfl
+ error(i.ovfl)
} else {
*(*uint8)(p) = uint8(v)
}
}
v := decodeInt(state)
if v < math.MinInt16 || math.MaxInt16 < v {
- state.err = i.ovfl
+ error(i.ovfl)
} else {
*(*int16)(p) = int16(v)
}
}
v := decodeUint(state)
if math.MaxUint16 < v {
- state.err = i.ovfl
+ error(i.ovfl)
} else {
*(*uint16)(p) = uint16(v)
}
}
v := decodeInt(state)
if v < math.MinInt32 || math.MaxInt32 < v {
- state.err = i.ovfl
+ error(i.ovfl)
} else {
*(*int32)(p) = int32(v)
}
}
v := decodeUint(state)
if math.MaxUint32 < v {
- state.err = i.ovfl
+ error(i.ovfl)
} else {
*(*uint32)(p) = uint32(v)
}
}
// +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
+ error(i.ovfl)
} else {
*(*float32)(p) = float32(v)
}
return *(*uintptr)(up)
}
-func decodeSingle(engine *decEngine, rtyp reflect.Type, b **bytes.Buffer, p uintptr, indir int) os.Error {
+func decodeSingle(engine *decEngine, rtyp reflect.Type, b **bytes.Buffer, p uintptr, indir int) (err os.Error) {
+ defer catchError(&err)
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
+ errorf("gob decode: corrupted data: non-zero delta for singleton")
}
instr := &engine.instr[singletonField]
ptr := unsafe.Pointer(basep) // offset will be zero
ptr = decIndirect(ptr, instr.indir)
}
instr.op(instr, state, ptr)
- return state.err
+ return nil
}
-func (dec *Decoder) decodeStruct(engine *decEngine, rtyp *reflect.StructType, b **bytes.Buffer, p uintptr, indir int) os.Error {
+func (dec *Decoder) decodeStruct(engine *decEngine, rtyp *reflect.StructType, b **bytes.Buffer, p uintptr, indir int) (err os.Error) {
+ defer catchError(&err)
p = allocate(rtyp, p, indir)
state := newDecodeState(b)
state.fieldnum = -1
basep := p
- for state.b.Len() > 0 && state.err == nil {
+ for state.b.Len() > 0 {
delta := int(decodeUint(state))
if delta < 0 {
- state.err = os.ErrorString("gob decode: corrupted data: negative delta")
- break
+ errorf("gob decode: corrupted data: negative delta")
}
- if state.err != nil || delta == 0 { // struct terminator is zero delta fieldnum
+ if delta == 0 { // struct terminator is zero delta fieldnum
break
}
fieldnum := state.fieldnum + delta
if fieldnum >= len(engine.instr) {
- state.err = errRange
+ error(errRange)
break
}
instr := &engine.instr[fieldnum]
instr.op(instr, state, p)
state.fieldnum = fieldnum
}
- return state.err
+ return nil
}
-func ignoreStruct(engine *decEngine, b **bytes.Buffer) os.Error {
+func ignoreStruct(engine *decEngine, b **bytes.Buffer) (err os.Error) {
+ defer catchError(&err)
state := newDecodeState(b)
state.fieldnum = -1
- for state.b.Len() > 0 && state.err == nil {
+ for state.b.Len() > 0 {
delta := int(decodeUint(state))
if delta < 0 {
- state.err = os.ErrorString("gob ignore decode: corrupted data: negative delta")
- break
+ errorf("gob ignore decode: corrupted data: negative delta")
}
- if state.err != nil || delta == 0 { // struct terminator is zero delta fieldnum
+ if delta == 0 { // struct terminator is zero delta fieldnum
break
}
fieldnum := state.fieldnum + delta
if fieldnum >= len(engine.instr) {
- state.err = errRange
- break
+ error(errRange)
}
instr := &engine.instr[fieldnum]
instr.op(instr, state, unsafe.Pointer(nil))
state.fieldnum = fieldnum
}
- return state.err
+ return nil
}
-func decodeArrayHelper(state *decodeState, p uintptr, elemOp decOp, elemWid uintptr, length, elemIndir int, ovfl os.ErrorString) os.Error {
+func decodeArrayHelper(state *decodeState, p uintptr, elemOp decOp, elemWid uintptr, length, elemIndir int, ovfl os.ErrorString) {
instr := &decInstr{elemOp, 0, elemIndir, 0, ovfl}
- for i := 0; i < length && state.err == nil; i++ {
+ for i := 0; i < length; i++ {
up := unsafe.Pointer(p)
if elemIndir > 1 {
up = decIndirect(up, elemIndir)
elemOp(instr, state, up)
p += uintptr(elemWid)
}
- return state.err
}
-func decodeArray(atyp *reflect.ArrayType, state *decodeState, p uintptr, elemOp decOp, elemWid uintptr, length, indir, elemIndir int, ovfl os.ErrorString) os.Error {
+func decodeArray(atyp *reflect.ArrayType, state *decodeState, p uintptr, elemOp decOp, elemWid uintptr, length, indir, elemIndir int, ovfl os.ErrorString) {
if indir > 0 {
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")
+ errorf("gob: length mismatch in decodeArray")
}
- return decodeArrayHelper(state, p, elemOp, elemWid, length, elemIndir, ovfl)
+ decodeArrayHelper(state, p, elemOp, elemWid, length, elemIndir, ovfl)
}
func decodeIntoValue(state *decodeState, op decOp, indir int, v reflect.Value, ovfl os.ErrorString) reflect.Value {
return v
}
-func decodeMap(mtyp *reflect.MapType, state *decodeState, p uintptr, keyOp, elemOp decOp, indir, keyIndir, elemIndir int, ovfl os.ErrorString) os.Error {
+func decodeMap(mtyp *reflect.MapType, state *decodeState, p uintptr, keyOp, elemOp decOp, indir, keyIndir, elemIndir int, ovfl os.ErrorString) {
if indir > 0 {
p = allocate(mtyp, p, 1) // All but the last level has been allocated by dec.Indirect
}
// the iteration.
v := reflect.NewValue(unsafe.Unreflect(mtyp, unsafe.Pointer((p)))).(*reflect.MapValue)
n := int(decodeUint(state))
- for i := 0; i < n && state.err == nil; i++ {
+ for i := 0; i < n; i++ {
key := decodeIntoValue(state, keyOp, keyIndir, reflect.MakeZero(mtyp.Key()), ovfl)
- if state.err != nil {
- break
- }
elem := decodeIntoValue(state, elemOp, elemIndir, reflect.MakeZero(mtyp.Elem()), ovfl)
- if state.err != nil {
- break
- }
v.SetElem(key, elem)
}
- return state.err
}
-func ignoreArrayHelper(state *decodeState, elemOp decOp, length int) os.Error {
+func ignoreArrayHelper(state *decodeState, elemOp decOp, length int) {
instr := &decInstr{elemOp, 0, 0, 0, os.ErrorString("no error")}
- for i := 0; i < length && state.err == nil; i++ {
+ for i := 0; i < length; i++ {
elemOp(instr, state, nil)
}
- return state.err
}
-func ignoreArray(state *decodeState, elemOp decOp, length int) os.Error {
+func ignoreArray(state *decodeState, elemOp decOp, length int) {
if n := decodeUint(state); n != uint64(length) {
- return os.ErrorString("gob: length mismatch in ignoreArray")
+ errorf("gob: length mismatch in ignoreArray")
}
- return ignoreArrayHelper(state, elemOp, length)
+ ignoreArrayHelper(state, elemOp, length)
}
-func ignoreMap(state *decodeState, keyOp, elemOp decOp) os.Error {
+func ignoreMap(state *decodeState, keyOp, elemOp decOp) {
n := int(decodeUint(state))
keyInstr := &decInstr{keyOp, 0, 0, 0, os.ErrorString("no error")}
elemInstr := &decInstr{elemOp, 0, 0, 0, os.ErrorString("no error")}
- for i := 0; i < n && state.err == nil; i++ {
+ for i := 0; i < n; i++ {
keyOp(keyInstr, state, nil)
elemOp(elemInstr, state, nil)
}
- return state.err
}
-func decodeSlice(atyp *reflect.SliceType, state *decodeState, p uintptr, elemOp decOp, elemWid uintptr, indir, elemIndir int, ovfl os.ErrorString) os.Error {
+func decodeSlice(atyp *reflect.SliceType, state *decodeState, p uintptr, elemOp decOp, elemWid uintptr, indir, elemIndir int, ovfl os.ErrorString) {
n := int(uintptr(decodeUint(state)))
if indir > 0 {
up := unsafe.Pointer(p)
hdrp.Data = uintptr(unsafe.NewArray(atyp.Elem(), n))
hdrp.Len = n
hdrp.Cap = n
- return decodeArrayHelper(state, hdrp.Data, elemOp, elemWid, n, elemIndir, ovfl)
+ decodeArrayHelper(state, hdrp.Data, elemOp, elemWid, n, elemIndir, ovfl)
}
-func ignoreSlice(state *decodeState, elemOp decOp) os.Error {
- return ignoreArrayHelper(state, elemOp, int(decodeUint(state)))
+func ignoreSlice(state *decodeState, elemOp decOp) {
+ ignoreArrayHelper(state, elemOp, int(decodeUint(state)))
}
// setInterfaceValue sets an interface value to a concrete value through
// This dance avoids manually checking that the value satisfies the
// interface.
// TODO(rsc): avoid panic+recover after fixing issue 327.
-func setInterfaceValue(ivalue *reflect.InterfaceValue, value reflect.Value) (err os.Error) {
+func setInterfaceValue(ivalue *reflect.InterfaceValue, value reflect.Value) {
defer func() {
if e := recover(); e != nil {
- err = e.(os.Error)
+ error(e.(os.Error))
}
}()
ivalue.Set(value)
- return nil
}
// decodeInterface receives the name of a concrete type followed by its value.
// If the name is empty, the value is nil and no value is sent.
-func (dec *Decoder) decodeInterface(ityp *reflect.InterfaceType, state *decodeState, p uintptr, indir int) os.Error {
+func (dec *Decoder) decodeInterface(ityp *reflect.InterfaceType, state *decodeState, p uintptr, indir int) {
// Create an interface reflect.Value. We need one even for the nil case.
ivalue := reflect.MakeZero(ityp).(*reflect.InterfaceValue)
// Read the name of the concrete type.
// Copy the representation of the nil interface value to the target.
// This is horribly unsafe and special.
*(*[2]uintptr)(unsafe.Pointer(p)) = ivalue.Get()
- return state.err
+ return
}
// The concrete type must be registered.
typ, ok := nameToConcreteType[name]
if !ok {
- state.err = os.ErrorString("gob: name not registered for interface: " + name)
- return state.err
+ errorf("gob: name not registered for interface: %q", name)
}
// Read the concrete value.
value := reflect.MakeZero(typ)
dec.decodeValueFromBuffer(value, false)
- if dec.state.err != nil {
- state.err = dec.state.err
- return state.err
+ if dec.err != nil {
+ error(dec.err)
}
// Allocate the destination interface value.
if indir > 0 {
}
// Assign the concrete value to the interface.
// Tread carefully; it might not satisfy the interface.
- dec.state.err = setInterfaceValue(ivalue, value)
- if dec.state.err != nil {
- state.err = dec.state.err
- return state.err
- }
+ setInterfaceValue(ivalue, value)
// Copy the representation of the interface value to the target.
// This is horribly unsafe and special.
*(*[2]uintptr)(unsafe.Pointer(p)) = ivalue.Get()
- return nil
}
-func (dec *Decoder) ignoreInterface(state *decodeState) os.Error {
+func (dec *Decoder) ignoreInterface(state *decodeState) {
// Read the name of the concrete type.
b := make([]byte, decodeUint(state))
_, err := state.b.Read(b)
if err != nil {
dec.decodeValueFromBuffer(nil, true)
- err = dec.state.err
+ if dec.err != nil {
+ error(err)
+ }
}
- return err
}
// Index by Go types.
}
ovfl := overflow(name)
op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
- state.err = decodeArray(t, state, uintptr(p), elemOp, t.Elem().Size(), t.Len(), i.indir, elemIndir, ovfl)
+ decodeArray(t, state, uintptr(p), elemOp, t.Elem().Size(), t.Len(), i.indir, elemIndir, ovfl)
}
case *reflect.MapType:
ovfl := overflow(name)
op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
up := unsafe.Pointer(p)
- state.err = decodeMap(t, state, uintptr(up), keyOp, elemOp, i.indir, keyIndir, elemIndir, ovfl)
+ decodeMap(t, state, uintptr(up), keyOp, elemOp, i.indir, keyIndir, elemIndir, ovfl)
}
case *reflect.SliceType:
}
ovfl := overflow(name)
op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
- state.err = decodeSlice(t, state, uintptr(p), elemOp, t.Elem().Size(), i.indir, elemIndir, ovfl)
+ decodeSlice(t, state, uintptr(p), elemOp, t.Elem().Size(), i.indir, elemIndir, ovfl)
}
case *reflect.StructType:
}
op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
// indirect through enginePtr to delay evaluation for recursive structs
- state.err = dec.decodeStruct(*enginePtr, t, state.b, uintptr(p), i.indir)
+ err = dec.decodeStruct(*enginePtr, t, state.b, uintptr(p), i.indir)
+ if err != nil {
+ error(err)
+ }
}
case *reflect.InterfaceType:
op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
- state.err = dec.decodeInterface(t, state, uintptr(p), i.indir)
+ dec.decodeInterface(t, state, uintptr(p), i.indir)
}
}
}
// Special case because it's a method: the ignored item might
// define types and we need to record their state in the decoder.
op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
- state.err = dec.ignoreInterface(state)
+ dec.ignoreInterface(state)
}
return op, nil
}
return nil, err
}
op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
- state.err = ignoreArray(state, elemOp, wire.arrayT.Len)
+ ignoreArray(state, elemOp, wire.arrayT.Len)
}
case wire.mapT != nil:
return nil, err
}
op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
- state.err = ignoreMap(state, keyOp, elemOp)
+ ignoreMap(state, keyOp, elemOp)
}
case wire.sliceT != nil:
return nil, err
}
op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
- state.err = ignoreSlice(state, elemOp)
+ ignoreSlice(state, elemOp)
}
case wire.structT != nil:
}
op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
// indirect through enginePtr to delay evaluation for recursive structs
- state.err = ignoreStruct(*enginePtr, state.b)
+ ignoreStruct(*enginePtr, state.b)
}
}
}
// 0 terminates the structure.
type encoderState struct {
b *bytes.Buffer
- err os.Error // error encountered during encoding.
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.
// encodeUint writes an encoded unsigned integer to state.b. Sets state.err.
// If state.err is already non-nil, it does nothing.
func encodeUint(state *encoderState, x uint64) {
- if state.err != nil {
- return
- }
if x <= 0x7F {
- state.err = state.b.WriteByte(uint8(x))
+ err := state.b.WriteByte(uint8(x))
+ if err != nil {
+ error(err)
+ }
return
}
var n, m int
m--
}
state.buf[m] = uint8(-(n - 1))
- n, state.err = state.b.Write(state.buf[m : uint64Size+1])
+ n, err := state.b.Write(state.buf[m : uint64Size+1])
+ if err != nil {
+ error(err)
+ }
}
// encodeInt writes an encoded signed integer to state.w.
const singletonField = 0
-func encodeSingle(engine *encEngine, b *bytes.Buffer, basep uintptr) os.Error {
+func encodeSingle(engine *encEngine, b *bytes.Buffer, basep uintptr) (err os.Error) {
+ defer catchError(&err)
state := newEncoderState(b)
state.fieldnum = singletonField
// There is no surrounding struct to frame the transmission, so we must
}
}
instr.op(instr, state, p)
- return state.err
+ return
}
-func encodeStruct(engine *encEngine, b *bytes.Buffer, basep uintptr) os.Error {
+func encodeStruct(engine *encEngine, b *bytes.Buffer, basep uintptr) (err os.Error) {
+ defer catchError(&err)
state := newEncoderState(b)
state.fieldnum = -1
for i := 0; i < len(engine.instr); i++ {
}
}
instr.op(instr, state, p)
- if state.err != nil {
- break
- }
}
- return state.err
+ return nil
}
-func encodeArray(b *bytes.Buffer, p uintptr, op encOp, elemWid uintptr, elemIndir int, length int) os.Error {
+func encodeArray(b *bytes.Buffer, p uintptr, op encOp, elemWid uintptr, elemIndir int, length int) {
state := newEncoderState(b)
state.fieldnum = -1
state.sendZero = true
encodeUint(state, uint64(length))
- for i := 0; i < length && state.err == nil; i++ {
+ for i := 0; i < length; i++ {
elemp := p
up := unsafe.Pointer(elemp)
if elemIndir > 0 {
if up = encIndirect(up, elemIndir); up == nil {
- state.err = os.ErrorString("gob: encodeArray: nil element")
- break
+ errorf("gob: encodeArray: nil element")
}
elemp = uintptr(up)
}
op(nil, state, unsafe.Pointer(elemp))
p += uintptr(elemWid)
}
- return state.err
}
func encodeReflectValue(state *encoderState, v reflect.Value, op encOp, indir int) {
v = reflect.Indirect(v)
}
if v == nil {
- state.err = os.ErrorString("gob: encodeReflectValue: nil element")
- return
+ errorf("gob: encodeReflectValue: nil element")
}
op(nil, state, unsafe.Pointer(v.Addr()))
}
-func encodeMap(b *bytes.Buffer, mv *reflect.MapValue, keyOp, elemOp encOp, keyIndir, elemIndir int) os.Error {
+func encodeMap(b *bytes.Buffer, mv *reflect.MapValue, keyOp, elemOp encOp, keyIndir, elemIndir int) {
state := newEncoderState(b)
state.fieldnum = -1
state.sendZero = true
keys := mv.Keys()
encodeUint(state, uint64(len(keys)))
for _, key := range keys {
- if state.err != nil {
- break
- }
encodeReflectValue(state, key, keyOp, keyIndir)
encodeReflectValue(state, mv.Elem(key), elemOp, elemIndir)
}
- return state.err
}
// To send an interface, we send a string identifying the concrete type, followed
// by the type identifier (which might require defining that type right now), followed
// by the concrete value. A nil value gets sent as the empty string for the name,
// followed by no value.
-func (enc *Encoder) encodeInterface(b *bytes.Buffer, iv *reflect.InterfaceValue) os.Error {
+func (enc *Encoder) encodeInterface(b *bytes.Buffer, iv *reflect.InterfaceValue) {
state := newEncoderState(b)
state.fieldnum = -1
state.sendZero = true
if iv.IsNil() {
encodeUint(state, 0)
- return state.err
+ return
}
typ := iv.Elem().Type()
name, ok := concreteTypeToName[typ]
if !ok {
- state.err = os.ErrorString("gob: type not registered for interface: " + typ.String())
- return state.err
+ errorf("gob: type not registered for interface: %s", typ)
}
// Send the name.
encodeUint(state, uint64(len(name)))
- _, state.err = io.WriteString(state.b, name)
- if state.err != nil {
- return state.err
+ _, err := io.WriteString(state.b, name)
+ if err != nil {
+ error(err)
}
// Send (and maybe first define) the type id.
enc.sendTypeDescriptor(typ)
- if state.err != nil {
- return state.err
- }
// Send the value.
- state.err = enc.encode(state.b, iv.Elem())
- return state.err
+ err = enc.encode(state.b, iv.Elem())
+ if err != nil {
+ error(err)
+ }
}
var encOpMap = []encOp{
return
}
state.update(i)
- state.err = encodeArray(state.b, slice.Data, elemOp, t.Elem().Size(), indir, int(slice.Len))
+ encodeArray(state.b, slice.Data, elemOp, t.Elem().Size(), indir, int(slice.Len))
}
case *reflect.ArrayType:
// True arrays have size in the type.
}
op = func(i *encInstr, state *encoderState, p unsafe.Pointer) {
state.update(i)
- state.err = encodeArray(state.b, uintptr(p), elemOp, t.Elem().Size(), indir, t.Len())
+ encodeArray(state.b, uintptr(p), elemOp, t.Elem().Size(), indir, t.Len())
}
case *reflect.MapType:
keyOp, keyIndir, err := enc.encOpFor(t.Key())
return
}
state.update(i)
- state.err = encodeMap(state.b, mv, keyOp, elemOp, keyIndir, elemIndir)
+ encodeMap(state.b, mv, keyOp, elemOp, keyIndir, elemIndir)
}
case *reflect.StructType:
// Generate a closure that calls out to the engine for the nested type.
op = func(i *encInstr, state *encoderState, p unsafe.Pointer) {
state.update(i)
// indirect through info to delay evaluation for recursive structs
- state.err = encodeStruct(info.encoder, state.b, uintptr(p))
+ encodeStruct(info.encoder, state.b, uintptr(p))
}
case *reflect.InterfaceType:
op = func(i *encInstr, state *encoderState, p unsafe.Pointer) {
return
}
state.update(i)
- state.err = enc.encodeInterface(state.b, iv)
+ enc.encodeInterface(state.b, iv)
}
}
}