qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-24 22:57:57 -07:00
Code Releases Activity

gob: make (en|dec)code(Ui|I)nt methods rather than functions.

Browse Source 
No functional (ha!) change.

R=rsc
CC=golang-dev
https://golang.org/cl/3959041
This commit is contained in:
Rob Pike 2011-01-11 17:56:45 -08:00
parent 5aeacadc5a
commit a80cdcbe0a
6 changed files with 92 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/pkg/gob/codec_test.go
View File

@ -53,7 +53,7 @@ func TestUintCodec(t *testing.T) {
encState := newEncoderState(nil, b)
for _, tt := range encodeT {
b.Reset()
encodeUint(encState, tt.x)
encState.encodeUint(tt.x)
if !bytes.Equal(tt.b, b.Bytes()) {
t.Errorf("encodeUint: %#x encode: expected % x got % x", tt.x, tt.b, b.Bytes())
}
@ -61,8 +61,8 @@ func TestUintCodec(t *testing.T) {
decState := newDecodeState(nil, &b)
for u := uint64(0); ; u = (u + 1) * 7 {
b.Reset()
encodeUint(encState, u)
v := decodeUint(decState)
encState.encodeUint(u)
v := decState.decodeUint()
if u != v {
t.Errorf("Encode/Decode: sent %#x received %#x", u, v)
}
@ -76,10 +76,10 @@ func verifyInt(i int64, t *testing.T) {
defer testError(t)
var b = new(bytes.Buffer)
encState := newEncoderState(nil, b)
encodeInt(encState, i)
encState.encodeInt(i)
decState := newDecodeState(nil, &b)
decState.buf = make([]byte, 8)
j := decodeInt(decState)
j := decState.decodeInt()
if i != j {
t.Errorf("Encode/Decode: sent %#x received %#x", uint64(i), uint64(j))
}
@ -317,7 +317,7 @@ func TestScalarEncInstructions(t *testing.T) {
func execDec(typ string, instr *decInstr, state *decodeState, t *testing.T, p unsafe.Pointer) {
defer testError(t)
v := int(decodeUint(state))
v := int(state.decodeUint())
if v+state.fieldnum != 6 {
t.Fatalf("decoding field number %d, got %d", 6, v+state.fieldnum)
}

28
src/pkg/gob/debug.go
View File

@ -87,7 +87,7 @@ func (dec *Decoder) debug() {
func (dec *Decoder) debugFromBuffer(indent int, countPresent bool) {
for dec.state.b.Len() > 0 {
// Receive a type id.
id := typeId(decodeInt(dec.state))
id := typeId(dec.state.decodeInt())
// Is it a new type?
if id < 0 { // 0 is the error state, handled above
@ -107,7 +107,7 @@ func (dec *Decoder) debugFromBuffer(indent int, countPresent bool) {
break
}
if countPresent {
decodeUint(dec.state)
dec.state.decodeUint()
}
dec.debugPrint(indent, id)
break
@ -175,7 +175,7 @@ func (dec *Decoder) debugSingle(indent int, id typeId, wire *wireType) {
if !ok && wire == nil {
errorf("type id %d not defined\n", id)
}
decodeUint(dec.state)
dec.state.decodeUint()
dec.printItem(indent, id)
}
@ -206,7 +206,7 @@ func (dec *Decoder) printItem(indent int, id typeId) {
func (dec *Decoder) printArray(indent int, wire *wireType) {
elemId := wire.ArrayT.Elem
n := int(decodeUint(dec.state))
n := int(dec.state.decodeUint())
for i := 0; i < n && dec.err == nil; i++ {
dec.printItem(indent, elemId)
}
@ -219,7 +219,7 @@ func (dec *Decoder) printArray(indent int, wire *wireType) {
func (dec *Decoder) printMap(indent int, wire *wireType) {
keyId := wire.MapT.Key
elemId := wire.MapT.Elem
n := int(decodeUint(dec.state))
n := int(dec.state.decodeUint())
for i := 0; i < n && dec.err == nil; i++ {
dec.printItem(indent, keyId)
dec.printItem(indent+1, elemId)
@ -228,7 +228,7 @@ func (dec *Decoder) printMap(indent int, wire *wireType) {
func (dec *Decoder) printSlice(indent int, wire *wireType) {
elemId := wire.SliceT.Elem
n := int(decodeUint(dec.state))
n := int(dec.state.decodeUint())
for i := 0; i < n && dec.err == nil; i++ {
dec.printItem(indent, elemId)
}
@ -238,27 +238,27 @@ func (dec *Decoder) printBuiltin(indent int, id typeId) {
tab(indent)
switch id {
case tBool:
if decodeInt(dec.state) == 0 {
if dec.state.decodeInt() == 0 {
fmt.Printf("false\n")
} else {
fmt.Printf("true\n")
}
case tInt:
fmt.Printf("%d\n", decodeInt(dec.state))
fmt.Printf("%d\n", dec.state.decodeInt())
case tUint:
fmt.Printf("%d\n", decodeUint(dec.state))
fmt.Printf("%d\n", dec.state.decodeUint())
case tFloat:
fmt.Printf("%g\n", floatFromBits(decodeUint(dec.state)))
fmt.Printf("%g\n", floatFromBits(dec.state.decodeUint()))
case tBytes:
b := make([]byte, decodeUint(dec.state))
b := make([]byte, dec.state.decodeUint())
dec.state.b.Read(b)
fmt.Printf("% x\n", b)
case tString:
b := make([]byte, decodeUint(dec.state))
b := make([]byte, dec.state.decodeUint())
dec.state.b.Read(b)
fmt.Printf("%q\n", b)
case tInterface:
b := make([]byte, decodeUint(dec.state))
b := make([]byte, dec.state.decodeUint())
dec.state.b.Read(b)
if len(b) == 0 {
fmt.Printf("nil interface")
@ -278,7 +278,7 @@ func (dec *Decoder) debugStruct(indent int, id typeId, wire *wireType) {
state := newDecodeState(dec, dec.state.b)
state.fieldnum = -1
for dec.err == nil {
delta := int(decodeUint(state))
delta := int(state.decodeUint())
if delta < 0 {
errorf("gob decode: corrupted data: negative delta")
}

66
src/pkg/gob/decode.go
View File

@ -81,7 +81,7 @@ func decodeUintReader(r io.Reader, buf []byte) (x uint64, err os.Error) {
// decodeUint reads an encoded unsigned integer from state.r.
// Does not check for overflow.
func decodeUint(state *decodeState) (x uint64) {
func (state *decodeState) decodeUint() (x uint64) {
b, err := state.b.ReadByte()
if err != nil {
error(err)
@ -108,8 +108,8 @@ func decodeUint(state *decodeState) (x uint64) {
// decodeInt reads an encoded signed integer from state.r.
// Does not check for overflow.
func decodeInt(state *decodeState) int64 {
x := decodeUint(state)
func (state *decodeState) decodeInt() int64 {
x := state.decodeUint()
if x&1 != 0 {
return ^int64(x >> 1)
}
@ -147,12 +147,12 @@ func decIndirect(p unsafe.Pointer, indir int) unsafe.Pointer {
}
func ignoreUint(i *decInstr, state *decodeState, p unsafe.Pointer) {
decodeUint(state)
state.decodeUint()
}
func ignoreTwoUints(i *decInstr, state *decodeState, p unsafe.Pointer) {
decodeUint(state)
decodeUint(state)
state.decodeUint()
state.decodeUint()
}
func decBool(i *decInstr, state *decodeState, p unsafe.Pointer) {
@ -162,7 +162,7 @@ func decBool(i *decInstr, state *decodeState, p unsafe.Pointer) {
}
p = *(*unsafe.Pointer)(p)
}
*(*bool)(p) = decodeInt(state) != 0
*(*bool)(p) = state.decodeInt() != 0
}
func decInt8(i *decInstr, state *decodeState, p unsafe.Pointer) {
@ -172,7 +172,7 @@ func decInt8(i *decInstr, state *decodeState, p unsafe.Pointer) {
}
p = *(*unsafe.Pointer)(p)
}
v := decodeInt(state)
v := state.decodeInt()
if v < math.MinInt8 || math.MaxInt8 < v {
error(i.ovfl)
} else {
@ -187,7 +187,7 @@ func decUint8(i *decInstr, state *decodeState, p unsafe.Pointer) {
}
p = *(*unsafe.Pointer)(p)
}
v := decodeUint(state)
v := state.decodeUint()
if math.MaxUint8 < v {
error(i.ovfl)
} else {
@ -202,7 +202,7 @@ func decInt16(i *decInstr, state *decodeState, p unsafe.Pointer) {
}
p = *(*unsafe.Pointer)(p)
}
v := decodeInt(state)
v := state.decodeInt()
if v < math.MinInt16 || math.MaxInt16 < v {
error(i.ovfl)
} else {
@ -217,7 +217,7 @@ func decUint16(i *decInstr, state *decodeState, p unsafe.Pointer) {
}
p = *(*unsafe.Pointer)(p)
}
v := decodeUint(state)
v := state.decodeUint()
if math.MaxUint16 < v {
error(i.ovfl)
} else {
@ -232,7 +232,7 @@ func decInt32(i *decInstr, state *decodeState, p unsafe.Pointer) {
}
p = *(*unsafe.Pointer)(p)
}
v := decodeInt(state)
v := state.decodeInt()
if v < math.MinInt32 || math.MaxInt32 < v {
error(i.ovfl)
} else {
@ -247,7 +247,7 @@ func decUint32(i *decInstr, state *decodeState, p unsafe.Pointer) {
}
p = *(*unsafe.Pointer)(p)
}
v := decodeUint(state)
v := state.decodeUint()
if math.MaxUint32 < v {
error(i.ovfl)
} else {
@ -262,7 +262,7 @@ func decInt64(i *decInstr, state *decodeState, p unsafe.Pointer) {
}
p = *(*unsafe.Pointer)(p)
}
*(*int64)(p) = int64(decodeInt(state))
*(*int64)(p) = int64(state.decodeInt())
}
func decUint64(i *decInstr, state *decodeState, p unsafe.Pointer) {
@ -272,7 +272,7 @@ func decUint64(i *decInstr, state *decodeState, p unsafe.Pointer) {
}
p = *(*unsafe.Pointer)(p)
}
*(*uint64)(p) = uint64(decodeUint(state))
*(*uint64)(p) = uint64(state.decodeUint())
}
// Floating-point numbers are transmitted as uint64s holding the bits
@ -291,7 +291,7 @@ func floatFromBits(u uint64) float64 {
}
func storeFloat32(i *decInstr, state *decodeState, p unsafe.Pointer) {
v := floatFromBits(decodeUint(state))
v := floatFromBits(state.decodeUint())
av := v
if av < 0 {
av = -av
@ -321,7 +321,7 @@ func decFloat64(i *decInstr, state *decodeState, p unsafe.Pointer) {
}
p = *(*unsafe.Pointer)(p)
}
*(*float64)(p) = floatFromBits(uint64(decodeUint(state)))
*(*float64)(p) = floatFromBits(uint64(state.decodeUint()))
}
// Complex numbers are just a pair of floating-point numbers, real part first.
@ -343,8 +343,8 @@ func decComplex128(i *decInstr, state *decodeState, p unsafe.Pointer) {
}
p = *(*unsafe.Pointer)(p)
}
real := floatFromBits(uint64(decodeUint(state)))
imag := floatFromBits(uint64(decodeUint(state)))
real := floatFromBits(uint64(state.decodeUint()))
imag := floatFromBits(uint64(state.decodeUint()))
*(*complex128)(p) = cmplx(real, imag)
}
@ -356,7 +356,7 @@ func decUint8Array(i *decInstr, state *decodeState, p unsafe.Pointer) {
}
p = *(*unsafe.Pointer)(p)
}
b := make([]uint8, decodeUint(state))
b := make([]uint8, state.decodeUint())
state.b.Read(b)
*(*[]uint8)(p) = b
}
@ -369,13 +369,13 @@ func decString(i *decInstr, state *decodeState, p unsafe.Pointer) {
}
p = *(*unsafe.Pointer)(p)
}
b := make([]byte, decodeUint(state))
b := make([]byte, state.decodeUint())
state.b.Read(b)
*(*string)(p) = string(b)
}
func ignoreUint8Array(i *decInstr, state *decodeState, p unsafe.Pointer) {
b := make([]byte, decodeUint(state))
b := make([]byte, state.decodeUint())
state.b.Read(b)
}
@ -411,7 +411,7 @@ func (dec *Decoder) decodeSingle(engine *decEngine, rtyp reflect.Type, b **bytes
state := newDecodeState(dec, b)
state.fieldnum = singletonField
basep := p
delta := int(decodeUint(state))
delta := int(state.decodeUint())
if delta != 0 {
errorf("gob decode: corrupted data: non-zero delta for singleton")
}
@ -431,7 +431,7 @@ func (dec *Decoder) decodeStruct(engine *decEngine, rtyp *reflect.StructType, b
state.fieldnum = -1
basep := p
for state.b.Len() > 0 {
delta := int(decodeUint(state))
delta := int(state.decodeUint())
if delta < 0 {
errorf("gob decode: corrupted data: negative delta")
}
@ -459,7 +459,7 @@ func (dec *Decoder) ignoreStruct(engine *decEngine, b **bytes.Buffer) (err os.Er
state := newDecodeState(dec, b)
state.fieldnum = -1
for state.b.Len() > 0 {
delta := int(decodeUint(state))
delta := int(state.decodeUint())
if delta < 0 {
errorf("gob ignore decode: corrupted data: negative delta")
}
@ -493,7 +493,7 @@ func (dec *Decoder) decodeArray(atyp *reflect.ArrayType, state *decodeState, p u
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) {
if n := state.decodeUint(); n != uint64(length) {
errorf("gob: length mismatch in decodeArray")
}
dec.decodeArrayHelper(state, p, elemOp, elemWid, length, elemIndir, ovfl)
@ -522,7 +522,7 @@ func (dec *Decoder) decodeMap(mtyp *reflect.MapType, state *decodeState, p uintp
// that slices etc. can. We must recover a full reflection value for
// the iteration.
v := reflect.NewValue(unsafe.Unreflect(mtyp, unsafe.Pointer((p)))).(*reflect.MapValue)
n := int(decodeUint(state))
n := int(state.decodeUint())
for i := 0; i < n; i++ {
key := decodeIntoValue(state, keyOp, keyIndir, reflect.MakeZero(mtyp.Key()), ovfl)
elem := decodeIntoValue(state, elemOp, elemIndir, reflect.MakeZero(mtyp.Elem()), ovfl)
@ -538,14 +538,14 @@ func (dec *Decoder) ignoreArrayHelper(state *decodeState, elemOp decOp, length i
}
func (dec *Decoder) ignoreArray(state *decodeState, elemOp decOp, length int) {
if n := decodeUint(state); n != uint64(length) {
if n := state.decodeUint(); n != uint64(length) {
errorf("gob: length mismatch in ignoreArray")
}
dec.ignoreArrayHelper(state, elemOp, length)
}
func (dec *Decoder) ignoreMap(state *decodeState, keyOp, elemOp decOp) {
n := int(decodeUint(state))
n := int(state.decodeUint())
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; i++ {
@ -555,7 +555,7 @@ func (dec *Decoder) ignoreMap(state *decodeState, keyOp, elemOp decOp) {
}
func (dec *Decoder) decodeSlice(atyp *reflect.SliceType, state *decodeState, p uintptr, elemOp decOp, elemWid uintptr, indir, elemIndir int, ovfl os.ErrorString) {
n := int(uintptr(decodeUint(state)))
n := int(uintptr(state.decodeUint()))
if indir > 0 {
up := unsafe.Pointer(p)
if *(*unsafe.Pointer)(up) == nil {
@ -574,7 +574,7 @@ func (dec *Decoder) decodeSlice(atyp *reflect.SliceType, state *decodeState, p u
}
func (dec *Decoder) ignoreSlice(state *decodeState, elemOp decOp) {
dec.ignoreArrayHelper(state, elemOp, int(decodeUint(state)))
dec.ignoreArrayHelper(state, elemOp, int(state.decodeUint()))
}
// setInterfaceValue sets an interface value to a concrete value through
@ -598,7 +598,7 @@ func (dec *Decoder) decodeInterface(ityp *reflect.InterfaceType, state *decodeSt
// 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.
b := make([]byte, decodeUint(state))
b := make([]byte, state.decodeUint())
state.b.Read(b)
name := string(b)
if name == "" {
@ -632,7 +632,7 @@ func (dec *Decoder) decodeInterface(ityp *reflect.InterfaceType, state *decodeSt
func (dec *Decoder) ignoreInterface(state *decodeState) {
// Read the name of the concrete type.
b := make([]byte, decodeUint(state))
b := make([]byte, state.decodeUint())
_, err := state.b.Read(b)
if err != nil {
error(err)

4
src/pkg/gob/decoder.go
View File

@ -107,7 +107,7 @@ func (dec *Decoder) recv() {
func (dec *Decoder) decodeValueFromBuffer(value reflect.Value, ignoreInterfaceValue, countPresent bool) {
for dec.state.b.Len() > 0 {
// Receive a type id.
id := typeId(decodeInt(dec.state))
id := typeId(dec.state.decodeInt())
// Is it a new type?
if id < 0 { // 0 is the error state, handled above
@ -127,7 +127,7 @@ func (dec *Decoder) decodeValueFromBuffer(value reflect.Value, ignoreInterfaceVa
}
// An interface value is preceded by a byte count.
if countPresent {
count := int(decodeUint(dec.state))
count := int(dec.state.decodeUint())
if ignoreInterfaceValue {
// An interface value is preceded by a byte count. Just skip that many bytes.
dec.state.b.Next(int(count))

68
src/pkg/gob/encode.go
View File

@ -37,7 +37,7 @@ func newEncoderState(enc *Encoder, b *bytes.Buffer) *encoderState {
// by the byte length, negated.
// encodeUint writes an encoded unsigned integer to state.b.
func encodeUint(state *encoderState, x uint64) {
func (state *encoderState) encodeUint(x uint64) {
if x <= 0x7F {
err := state.b.WriteByte(uint8(x))
if err != nil {
@ -62,14 +62,14 @@ func encodeUint(state *encoderState, x uint64) {
// encodeInt writes an encoded signed integer to state.w.
// The low bit of the encoding says whether to bit complement the (other bits of the)
// uint to recover the int.
func encodeInt(state *encoderState, i int64) {
func (state *encoderState) encodeInt(i int64) {
var x uint64
if i < 0 {
x = uint64(^i<<1) | 1
} else {
x = uint64(i << 1)
}
encodeUint(state, uint64(x))
state.encodeUint(uint64(x))
}
type encOp func(i *encInstr, state *encoderState, p unsafe.Pointer)
@ -86,7 +86,7 @@ type encInstr struct {
// If the instruction pointer is nil, do nothing
func (state *encoderState) update(instr *encInstr) {
if instr != nil {
encodeUint(state, uint64(instr.field-state.fieldnum))
state.encodeUint(uint64(instr.field - state.fieldnum))
state.fieldnum = instr.field
}
}
@ -112,9 +112,9 @@ func encBool(i *encInstr, state *encoderState, p unsafe.Pointer) {
if b || state.sendZero {
state.update(i)
if b {
encodeUint(state, 1)
state.encodeUint(1)
} else {
encodeUint(state, 0)
state.encodeUint(0)
}
}
}
@ -123,7 +123,7 @@ func encInt(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := int64(*(*int)(p))
if v != 0 || state.sendZero {
state.update(i)
encodeInt(state, v)
state.encodeInt(v)
}
}
@ -131,7 +131,7 @@ func encUint(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := uint64(*(*uint)(p))
if v != 0 || state.sendZero {
state.update(i)
encodeUint(state, v)
state.encodeUint(v)
}
}
@ -139,7 +139,7 @@ func encInt8(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := int64(*(*int8)(p))
if v != 0 || state.sendZero {
state.update(i)
encodeInt(state, v)
state.encodeInt(v)
}
}
@ -147,7 +147,7 @@ func encUint8(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := uint64(*(*uint8)(p))
if v != 0 || state.sendZero {
state.update(i)
encodeUint(state, v)
state.encodeUint(v)
}
}
@ -155,7 +155,7 @@ func encInt16(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := int64(*(*int16)(p))
if v != 0 || state.sendZero {
state.update(i)
encodeInt(state, v)
state.encodeInt(v)
}
}
@ -163,7 +163,7 @@ func encUint16(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := uint64(*(*uint16)(p))
if v != 0 || state.sendZero {
state.update(i)
encodeUint(state, v)
state.encodeUint(v)
}
}
@ -171,7 +171,7 @@ func encInt32(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := int64(*(*int32)(p))
if v != 0 || state.sendZero {
state.update(i)
encodeInt(state, v)
state.encodeInt(v)
}
}
@ -179,7 +179,7 @@ func encUint32(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := uint64(*(*uint32)(p))
if v != 0 || state.sendZero {
state.update(i)
encodeUint(state, v)
state.encodeUint(v)
}
}
@ -187,7 +187,7 @@ func encInt64(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := *(*int64)(p)
if v != 0 || state.sendZero {
state.update(i)
encodeInt(state, v)
state.encodeInt(v)
}
}
@ -195,7 +195,7 @@ func encUint64(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := *(*uint64)(p)
if v != 0 || state.sendZero {
state.update(i)
encodeUint(state, v)
state.encodeUint(v)
}
}
@ -203,7 +203,7 @@ func encUintptr(i *encInstr, state *encoderState, p unsafe.Pointer) {
v := uint64(*(*uintptr)(p))
if v != 0 || state.sendZero {
state.update(i)
encodeUint(state, v)
state.encodeUint(v)
}
}
@ -228,7 +228,7 @@ func encFloat(i *encInstr, state *encoderState, p unsafe.Pointer) {
if f != 0 || state.sendZero {
v := floatBits(float64(f))
state.update(i)
encodeUint(state, v)
state.encodeUint(v)
}
}
@ -237,7 +237,7 @@ func encFloat32(i *encInstr, state *encoderState, p unsafe.Pointer) {
if f != 0 || state.sendZero {
v := floatBits(float64(f))
state.update(i)
encodeUint(state, v)
state.encodeUint(v)
}
}
@ -246,7 +246,7 @@ func encFloat64(i *encInstr, state *encoderState, p unsafe.Pointer) {
if f != 0 || state.sendZero {
state.update(i)
v := floatBits(f)
encodeUint(state, v)
state.encodeUint(v)
}
}
@ -257,8 +257,8 @@ func encComplex(i *encInstr, state *encoderState, p unsafe.Pointer) {
rpart := floatBits(float64(real(c)))
ipart := floatBits(float64(imag(c)))
state.update(i)
encodeUint(state, rpart)
encodeUint(state, ipart)
state.encodeUint(rpart)
state.encodeUint(ipart)
}
}
@ -268,8 +268,8 @@ func encComplex64(i *encInstr, state *encoderState, p unsafe.Pointer) {
rpart := floatBits(float64(real(c)))
ipart := floatBits(float64(imag(c)))
state.update(i)
encodeUint(state, rpart)
encodeUint(state, ipart)
state.encodeUint(rpart)
state.encodeUint(ipart)
}
}
@ -279,8 +279,8 @@ func encComplex128(i *encInstr, state *encoderState, p unsafe.Pointer) {
rpart := floatBits(real(c))
ipart := floatBits(imag(c))
state.update(i)
encodeUint(state, rpart)
encodeUint(state, ipart)
state.encodeUint(rpart)
state.encodeUint(ipart)
}
}
@ -292,7 +292,7 @@ func encUint8Array(i *encInstr, state *encoderState, p unsafe.Pointer) {
b := *(*[]byte)(p)
if len(b) > 0 || state.sendZero {
state.update(i)
encodeUint(state, uint64(len(b)))
state.encodeUint(uint64(len(b)))
state.b.Write(b)
}
}
@ -302,14 +302,14 @@ func encString(i *encInstr, state *encoderState, p unsafe.Pointer) {
s := *(*string)(p)
if len(s) > 0 || state.sendZero {
state.update(i)
encodeUint(state, uint64(len(s)))
state.encodeUint(uint64(len(s)))
io.WriteString(state.b, s)
}
}
// The end of a struct is marked by a delta field number of 0.
func encStructTerminator(i *encInstr, state *encoderState, p unsafe.Pointer) {
encodeUint(state, 0)
state.encodeUint(0)
}
// Execution engine
@ -357,7 +357,7 @@ func (enc *Encoder) encodeArray(b *bytes.Buffer, p uintptr, op encOp, elemWid ui
state := newEncoderState(enc, b)
state.fieldnum = -1
state.sendZero = true
encodeUint(state, uint64(length))
state.encodeUint(uint64(length))
for i := 0; i < length; i++ {
elemp := p
up := unsafe.Pointer(elemp)
@ -387,7 +387,7 @@ func (enc *Encoder) encodeMap(b *bytes.Buffer, mv *reflect.MapValue, keyOp, elem
state.fieldnum = -1
state.sendZero = true
keys := mv.Keys()
encodeUint(state, uint64(len(keys)))
state.encodeUint(uint64(len(keys)))
for _, key := range keys {
encodeReflectValue(state, key, keyOp, keyIndir)
encodeReflectValue(state, mv.Elem(key), elemOp, elemIndir)
@ -403,7 +403,7 @@ func (enc *Encoder) encodeInterface(b *bytes.Buffer, iv *reflect.InterfaceValue)
state.fieldnum = -1
state.sendZero = true
if iv.IsNil() {
encodeUint(state, 0)
state.encodeUint(0)
return
}
@ -413,7 +413,7 @@ func (enc *Encoder) encodeInterface(b *bytes.Buffer, iv *reflect.InterfaceValue)
errorf("gob: type not registered for interface: %s", typ)
}
// Send the name.
encodeUint(state, uint64(len(name)))
state.encodeUint(uint64(len(name)))
_, err := io.WriteString(state.b, name)
if err != nil {
error(err)
@ -426,7 +426,7 @@ func (enc *Encoder) encodeInterface(b *bytes.Buffer, iv *reflect.InterfaceValue)
if err != nil {
error(err)
}
encodeUint(state, uint64(data.Len()))
state.encodeUint(uint64(data.Len()))
_, err = state.b.Write(data.Bytes())
if err != nil {
error(err)

6
src/pkg/gob/encoder.go
View File

@ -48,7 +48,7 @@ func (enc *Encoder) setError(err os.Error) {
// Send the data item preceded by a unsigned count of its length.
func (enc *Encoder) send() {
// Encode the length.
encodeUint(enc.countState, uint64(enc.state.b.Len()))
enc.countState.encodeUint(uint64(enc.state.b.Len()))
// Build the buffer.
countLen := enc.countState.b.Len()
total := countLen + enc.state.b.Len()
@ -112,7 +112,7 @@ func (enc *Encoder) sendType(origt reflect.Type) (sent bool) {
}
// Send the pair (-id, type)
// Id:
encodeInt(enc.state, -int64(info.id))
enc.state.encodeInt(-int64(info.id))
// Type:
enc.encode(enc.state.b, reflect.NewValue(info.wire))
enc.send()
@ -170,7 +170,7 @@ func (enc *Encoder) sendTypeDescriptor(rt reflect.Type) {
}
// Identify the type of this top-level value.
encodeInt(enc.state, int64(enc.sent[rt]))
enc.state.encodeInt(int64(enc.sent[rt]))
}
// EncodeValue transmits the data item represented by the reflection value,