code review 3959041: gob: make (en|dec)code(Ui|i)nt methods rather than func...

src/pkg/gob/encode.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package gob
 
 import (
         "bytes"
         "io"
         "math"
@@ skipping 19 matching lines @@
 func newEncoderState(enc *Encoder, b *bytes.Buffer) *encoderState {
         return &encoderState{enc: enc, b: b}
 }
 
 // Unsigned integers have a two-state encoding.  If the number is less
 // than 128 (0 through 0x7F), its value is written directly.
 // Otherwise the value is written in big-endian byte order preceded
 // 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 {
                         error(err)
                 }
                 return
         }
         var n, m int
         m = uint64Size
         for n = 1; x > 0; n++ {
                 state.buf[m] = uint8(x & 0xFF)
                 x >>= 8
                 m--
         }
         state.buf[m] = uint8(-(n - 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.
 // 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)
 
 // The 'instructions' of the encoding machine
 type encInstr struct {
         op     encOp
         field  int     // field number
         indir  int     // how many pointer indirections to reach the value in the struct
         offset uintptr // offset in the structure of the field to encode
 }
 
 // Emit a field number and update the state to record its value for delta encoding.
 // 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
         }
 }
 
 // Each encoder is responsible for handling any indirections associated
 // with the data structure.  If any pointer so reached is nil, no bytes are written.
 // If the data item is zero, no bytes are written.
 // Otherwise, the output (for a scalar) is the field number, as an encoded integer,
 // followed by the field data in its appropriate format.
 
 func encIndirect(p unsafe.Pointer, indir int) unsafe.Pointer {
         for ; indir > 0; indir-- {
                 p = *(*unsafe.Pointer)(p)
                 if p == nil {
                         return unsafe.Pointer(nil)
                 }
         }
         return p
 }
 
 func encBool(i *encInstr, state *encoderState, p unsafe.Pointer) {
         b := *(*bool)(p)
         if b || state.sendZero {
                 state.update(i)
                 if b {
-                        encodeUint(state, 1)
+                        state.encodeUint(1)
                 } else {
-                        encodeUint(state, 0)
+                        state.encodeUint(0)
                 }
         }
 }
 
 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)
         }
 }
 
 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)
         }
 }
 
 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)
         }
 }
 
 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)
         }
 }
 
 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)
         }
 }
 
 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)
         }
 }
 
 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)
         }
 }
 
 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)
         }
 }
 
 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)
         }
 }
 
 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)
         }
 }
 
 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)
         }
 }
 
 // Floating-point numbers are transmitted as uint64s holding the bits
 // of the underlying representation.  They are sent byte-reversed, with
 // the exponent end coming out first, so integer floating point numbers
 // (for example) transmit more compactly.  This routine does the
 // swizzling.
 func floatBits(f float64) uint64 {
         u := math.Float64bits(f)
         var v uint64
         for i := 0; i < 8; i++ {
                 v <<= 8
                 v |= u & 0xFF
                 u >>= 8
         }
         return v
 }
 
 func encFloat(i *encInstr, state *encoderState, p unsafe.Pointer) {
         f := *(*float)(p)
         if f != 0 || state.sendZero {
                 v := floatBits(float64(f))
                 state.update(i)
-                encodeUint(state, v)
+                state.encodeUint(v)
         }
 }
 
 func encFloat32(i *encInstr, state *encoderState, p unsafe.Pointer) {
         f := *(*float32)(p)
         if f != 0 || state.sendZero {
                 v := floatBits(float64(f))
                 state.update(i)
-                encodeUint(state, v)
+                state.encodeUint(v)
         }
 }
 
 func encFloat64(i *encInstr, state *encoderState, p unsafe.Pointer) {
         f := *(*float64)(p)
         if f != 0 || state.sendZero {
                 state.update(i)
                 v := floatBits(f)
-                encodeUint(state, v)
+                state.encodeUint(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.sendZero {
                 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)
         }
 }
 
 func encComplex64(i *encInstr, state *encoderState, p unsafe.Pointer) {
         c := *(*complex64)(p)
         if c != 0+0i || state.sendZero {
                 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)
         }
 }
 
 func encComplex128(i *encInstr, state *encoderState, p unsafe.Pointer) {
         c := *(*complex128)(p)
         if c != 0+0i || state.sendZero {
                 rpart := floatBits(real(c))
                 ipart := floatBits(imag(c))
                 state.update(i)
-                encodeUint(state, rpart)
-                encodeUint(state, ipart)
+                state.encodeUint(rpart)
+                state.encodeUint(ipart)
         }
 }
 
 func encNoOp(i *encInstr, state *encoderState, p unsafe.Pointer) {
 }
 
 // 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.sendZero {
                 state.update(i)
-                encodeUint(state, uint64(len(b)))
+                state.encodeUint(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.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
 
 // The encoder engine is an array of instructions indexed by field number of the encoding
 // data, typically a struct.  It is executed top to bottom, walking the struct.
 type encEngine struct {
         instr []encInstr
 }
 
@@ skipping 27 matching lines @@
                         }
                 }
                 instr.op(instr, state, p)
         }
 }
 
 func (enc *Encoder) encodeArray(b *bytes.Buffer, p uintptr, op encOp, elemWid uintptr, elemIndir int, length int) {
         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)
                 if elemIndir > 0 {
                         if up = encIndirect(up, elemIndir); up == nil {
                                 errorf("gob: encodeArray: nil element")
                         }
                         elemp = uintptr(up)
                 }
                 op(nil, state, unsafe.Pointer(elemp))
                 p += uintptr(elemWid)
         }
 }
 
 func encodeReflectValue(state *encoderState, v reflect.Value, op encOp, indir int) {
         for i := 0; i < indir && v != nil; i++ {
                 v = reflect.Indirect(v)
         }
         if v == nil {
                 errorf("gob: encodeReflectValue: nil element")
         }
         op(nil, state, unsafe.Pointer(v.Addr()))
 }
 
 func (enc *Encoder) encodeMap(b *bytes.Buffer, mv *reflect.MapValue, keyOp, elemOp encOp, keyIndir, elemIndir int) {
         state := newEncoderState(enc, b)
         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)
         }
 }
 
 // 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) {
         state := newEncoderState(enc, b)
         state.fieldnum = -1
         state.sendZero = true
         if iv.IsNil() {
-                encodeUint(state, 0)
+                state.encodeUint(0)
                 return
         }
 
         typ, _ := indirect(iv.Elem().Type())
         name, ok := concreteTypeToName[typ]
         if !ok {
                 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)
         }
         // Send (and maybe first define) the type id.
         enc.sendTypeDescriptor(typ)
         // Encode the value into a new buffer.
         data := new(bytes.Buffer)
         err = enc.encode(data, iv.Elem())
         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)
         }
 }
 
 var encOpMap = []encOp{
         reflect.Bool:       encBool,
         reflect.Int:        encInt,
         reflect.Int8:       encInt8,
@@ skipping 146 matching lines @@
                 value = reflect.Indirect(value)
         }
         engine := enc.lockAndGetEncEngine(rt)
         if value.Type().Kind() == reflect.Struct {
                 enc.encodeStruct(b, engine, value.Addr())
         } else {
                 enc.encodeSingle(b, engine, value.Addr())
         }
         return nil
 }