"encoding"
"errors"
"fmt"
"maps"
"os"
"reflect"
"sync"
"sync/atomic"
"unicode"
"unicode/utf8"
"encoding"
"errors"
"internal/saferio"
"io"
"math"
"math/bits"
"reflect"
"reflect"
"encoding"
"encoding/binary"
"math"
"math/bits"
"reflect"
"sync"
"fmt"
"bytes"
"fmt"
"io"
"os"
"strings"
"sync"
"math"
"reflect"
"bufio"
"errors"
"internal/saferio"
"io"
"reflect"
"sync"
"errors"
"io"
"reflect"
"sync"
var binaryMarshalerInterfaceType = *ast.CallExprvar binaryUnmarshalerInterfaceType = *ast.CallExprvar blanks = *ast.CallExprvar builtinIdToTypeSlice [firstUserId]gobTypevar concreteTypeToName sync.MapIf debug.go is compiled into the program, debugFunc prints a human-readable representation of the gob data read from r by calling that file's Debug function. Otherwise it is nil.
var debugFunc func(io.Reader)var decArrayHelper = map[reflect.Kind]decHelper{...}Indexed by gob types. tComplex will be added during type.init().
var decIgnoreOpMap = map[typeId]decOp{...}Index by Go types.
var decOpTable = [...]decOp{...}var decSliceHelper = map[reflect.Kind]decHelper{...}var dumpBytes = falsevar empty = *ast.CallExprvar emptyStructType = *ast.CallExprvar encArrayHelper = map[reflect.Kind]encHelper{...}var encBufferPool = sync.Pool{...}var encOpTable = [...]encOp{...}var encSliceHelper = map[reflect.Kind]encHelper{...}var errBadCount = *ast.CallExprvar errBadType = *ast.CallExprvar errBadUint = *ast.CallExprvar errRange = *ast.CallExprconst firstUserId = 64var gobDecoderInterfaceType = *ast.CallExprvar gobEncoderInterfaceType = *ast.CallExprvar idToTypeSlice = *ast.CallExprconst intBits = *ast.BinaryExprvar maxIgnoreNestingDepth = 10000Before we encode a message, we reserve space at the head of the buffer in which to encode its length. This means we can use the buffer to assemble the message without another allocation.
const maxLength = 9var nameToConcreteType sync.Mapvar noValue reflect.Valueconst singletonField = 0var spaceForLength = *ast.CallExprPrimordial types, needed during initialization. Always passed as pointers so the interface{} type goes through without losing its interfaceness.
var tBool = *ast.CallExprvar tBytes = *ast.CallExprvar tComplex = *ast.CallExprvar tFloat = *ast.CallExprvar tInt = *ast.CallExprvar tInterface = *ast.CallExprvar tReserved1 = *ast.CallExprvar tReserved2 = *ast.CallExprvar tReserved3 = *ast.CallExprvar tReserved4 = *ast.CallExprvar tReserved5 = *ast.CallExprvar tReserved6 = *ast.CallExprReserve some Ids for compatible expansion
var tReserved7 = *ast.CallExprvar tString = *ast.CallExprvar tUint = *ast.CallExprPredefined because it's needed by the Decoder
var tWireType = *ast.CallExpr.idvar tabs = *ast.CallExprvar textMarshalerInterfaceType = *ast.CallExprvar textUnmarshalerInterfaceType = *ast.CallExprtooBig provides a sanity check for sizes; used in several places. Upper limit of is 1GB on 32-bit systems, 8GB on 64-bit, allowing room to grow a little without overflow.
const tooBig = *ast.BinaryExprtypeInfoMap is an atomic pointer to map[reflect.Type]*typeInfo. It's updated copy-on-write. Readers just do an atomic load to get the current version of the map. Writers make a full copy of the map and atomically update the pointer to point to the new map. Under heavy read contention, this is significantly faster than a map protected by a mutex.
var typeInfoMap atomic.ValuetypeInfoMapInit is used instead of typeInfoMap during init time, as types are registered sequentially during init and we can save the overhead of making map copies. It is saved to typeInfoMap and set to nil before init finishes.
var typeInfoMapInit = *ast.CallExprvar typeLock sync.Mutexvar types = *ast.CallExprconst uint64Size = 8const uintptrBits = *ast.BinaryExprvar userTypeCache sync.Mapvar wireTypeType = *ast.CallExprvar wireTypeUserInfo *userTypeInfoexternalEncoding bits
const xBinaryexternalEncoding bits
const xGob = *ast.BinaryExprexternalEncoding bits
const xTexttype decHelper func(state *decoderState, v reflect.Value, length int, ovfl error) booldecOp is the signature of a decoding operator for a given type.
type decOp func(i *decInstr, state *decoderState, v reflect.Value)type encHelper func(state *encoderState, v reflect.Value) boolencOp is the signature of an encoding operator for a given type.
type encOp func(i *encInstr, state *encoderState, v reflect.Value)tab indents itself when printed.
type tab intA typeId represents a gob Type as an integer that can be passed on the wire. Internally, typeIds are used as keys to a map to recover the underlying type info.
type typeId int32GobDecoder is the interface describing data that provides its own routine for decoding transmitted values sent by a GobEncoder.
type GobDecoder interface {
GobDecode([]byte) error
}GobEncoder is the interface describing data that provides its own representation for encoding values for transmission to a GobDecoder. A type that implements GobEncoder and GobDecoder has complete control over the representation of its data and may therefore contain things such as private fields, channels, and functions, which are not usually transmissible in gob streams. Note: Since gobs can be stored permanently, it is good design to guarantee the encoding used by a GobEncoder is stable as the software evolves. For instance, it might make sense for GobEncode to include a version number in the encoding.
type GobEncoder interface {
GobEncode() ([]byte, error)
}type gobType interface {
id() typeId
setId(id typeId)
name() string
string() string
safeString(seen map[typeId]bool) string
}CommonType holds elements of all types. It is a historical artifact, kept for binary compatibility and exported only for the benefit of the package's encoding of type descriptors. It is not intended for direct use by clients.
type CommonType struct {
Name string
Id typeId
}A Decoder manages the receipt of type and data information read from the remote side of a connection. It is safe for concurrent use by multiple goroutines. The Decoder does only basic sanity checking on decoded input sizes, and its limits are not configurable. Take caution when decoding gob data from untrusted sources.
type Decoder struct {
mutex sync.Mutex
r io.Reader
buf decBuffer
wireType map[typeId]*wireType
decoderCache map[reflect.Type]map[typeId]**decEngine
ignorerCache map[typeId]**decEngine
freeList *decoderState
countBuf []byte
err error
ignoreDepth int
}An Encoder manages the transmission of type and data information to the other side of a connection. It is safe for concurrent use by multiple goroutines.
type Encoder struct {
mutex sync.Mutex
w []io.Writer
sent map[reflect.Type]typeId
countState *encoderState
freeList *encoderState
byteBuf encBuffer
err error
}Array type
type arrayType struct {
CommonType
Elem typeId
Len int
}type debugger struct {
mutex sync.Mutex
remain int
remainingKnown bool
r *peekReader
wireType map[typeId]*wireType
tmp []byte
}decBuffer is an extremely simple, fast implementation of a read-only byte buffer. It is initialized by calling Size and then copying the data into the slice returned by Bytes().
type decBuffer struct {
data []byte
offset int
}The encoder engine is an array of instructions indexed by field number of the incoming decoder. It is executed with random access according to field number.
type decEngine struct {
instr []decInstr
numInstr int
}The 'instructions' of the decoding machine
type decInstr struct {
op decOp
field int
index []int
ovfl error
}decoderState is the execution state of an instance of the decoder. A new state is created for nested objects.
type decoderState struct {
dec *Decoder
b *decBuffer
fieldnum int
next *decoderState
}emptyStruct is the type we compile into when ignoring a struct value.
type emptyStruct struct {
}encBuffer is an extremely simple, fast implementation of a write-only byte buffer. It never returns a non-nil error, but Write returns an error value so it matches io.Writer.
type encBuffer struct {
data []byte
scratch [64]byte
}encEngine 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
}The 'instructions' of the encoding machine
type encInstr struct {
op encOp
field int
index []int
indir int
}encoderState is the global execution state of an instance of the encoder. Field numbers are delta encoded and always increase. The field number is initialized to -1 so 0 comes out as delta(1). A delta of 0 terminates the structure.
type encoderState struct {
enc *Encoder
b *encBuffer
sendZero bool
fieldnum int
buf [*ast.BinaryExpr]byte
next *encoderState
}Struct type
type fieldType struct {
Name string
Id typeId
}GobEncoder type (something that implements the GobEncoder interface)
type gobEncoderType struct {
CommonType
}A gobError is used to distinguish errors (panics) generated in this package.
type gobError struct {
err error
}Map type
type mapType struct {
CommonType
Key typeId
Elem typeId
}A peekReader wraps an io.Reader, allowing one to peek ahead to see what's coming without stealing the data from the client of the Reader.
type peekReader struct {
r io.Reader
data []byte
}Slice type
type sliceType struct {
CommonType
Elem typeId
}type structType struct {
CommonType
Field []fieldType
}type typeInfo struct {
id typeId
encInit sync.Mutex
encoder *ast.IndexExpr
wire wireType
}userTypeInfo stores the information associated with a type the user has handed to the package. It's computed once and stored in a map keyed by reflection type.
type userTypeInfo struct {
user reflect.Type
base reflect.Type
indir int
externalEnc int
externalDec int
encIndir int8
decIndir int8
}Representation of the information we send and receive about this type. Each value we send is preceded by its type definition: an encoded int. However, the very first time we send the value, we first send the pair (-id, wireType). For bootstrapping purposes, we assume that the recipient knows how to decode a wireType; it is exactly the wireType struct here, interpreted using the gob rules for sending a structure, except that we assume the ids for wireType and structType etc. are known. The relevant pieces are built in encode.go's init() function. To maintain binary compatibility, if you extend this type, always put the new fields last.
type wireType struct {
ArrayT *arrayType
SliceT *sliceType
StructT *structType
MapT *mapType
GobEncoderT *gobEncoderType
BinaryMarshalerT *gobEncoderType
TextMarshalerT *gobEncoderType
}func (d *decBuffer) Bytes() []bytefunc (e *encBuffer) Bytes() []byteDebug prints a human-readable representation of the gob data read from r. It is a no-op unless debugging was enabled when the package was built.
func Debug(r io.Reader)Decode reads the next value from the input stream and stores it in the data represented by the empty interface value. If e is nil, the value will be discarded. Otherwise, the value underlying e must be a pointer to the correct type for the next data item received. If the input is at EOF, Decode returns [io.EOF] and does not modify e.
func (dec *Decoder) Decode(e any) errorDecodeValue reads the next value from the input stream. If v is the zero reflect.Value (v.Kind() == Invalid), DecodeValue discards the value. Otherwise, it stores the value into v. In that case, v must represent a non-nil pointer to data or be an assignable reflect.Value (v.CanSet()) If the input is at EOF, DecodeValue returns [io.EOF] and does not modify v.
func (dec *Decoder) DecodeValue(v reflect.Value) errorfunc (d *decBuffer) Drop(n int)Encode transmits the data item represented by the empty interface value, guaranteeing that all necessary type information has been transmitted first. Passing a nil pointer to Encoder will panic, as they cannot be transmitted by gob.
func (enc *Encoder) Encode(e any) errorEncodeValue transmits the data item represented by the reflection value, guaranteeing that all necessary type information has been transmitted first. Passing a nil pointer to EncodeValue will panic, as they cannot be transmitted by gob.
func (enc *Encoder) EncodeValue(value reflect.Value) errorfunc (e *encBuffer) Len() intfunc (d *decBuffer) Len() intNewDecoder returns a new decoder that reads from the [io.Reader]. If r does not also implement [io.ByteReader], it will be wrapped in a [bufio.Reader].
func NewDecoder(r io.Reader) *DecoderNewEncoder returns a new encoder that will transmit on the [io.Writer].
func NewEncoder(w io.Writer) *EncoderRead is the usual method. It will first take data that has been read ahead.
func (p *peekReader) Read(b []byte) (n int, err error)func (d *decBuffer) Read(p []byte) (int, error)func (d *decBuffer) ReadByte() (byte, error)Register records a type, identified by a value for that type, under its internal type name. That name will identify the concrete type of a value sent or received as an interface variable. Only types that will be transferred as implementations of interface values need to be registered. Expecting to be used only during initialization, it panics if the mapping between types and names is not a bijection.
func Register(value any)RegisterName is like [Register] but uses the provided name rather than the type's default.
func RegisterName(name string, value any)func (e *encBuffer) Reset()func (d *decBuffer) Reset()SetBytes sets the buffer to the bytes, discarding any existing data.
func (d *decBuffer) SetBytes(data []byte)func (t tab) String() stringfunc (e *encBuffer) Write(p []byte) (int, error)func (e *encBuffer) WriteString(s string)Gob depends on being able to take the address of zeroed Values it creates, so use this wrapper instead of the standard reflect.Zero. Each call allocates once.
func allocValue(t reflect.Type) reflect.ValueArrayValue: uint(n) FieldValue*n
func (deb *debugger) arrayValue(indent tab, wire *wireType)used for building the basic types; called only from init(). the incoming interface always refers to a pointer.
func bootstrapType(name string, e any) typeIdfunc buildEncEngine(info *typeInfo, ut *userTypeInfo, building map[*typeInfo]bool) *encEnginebuildTypeInfo constructs the type information for the type and stores it in the type info map.
func buildTypeInfo(ut *userTypeInfo, rt reflect.Type) (*typeInfo, error)func builtinIdToType(id typeId) gobTypecatchError is meant to be used as a deferred function to turn a panic(gobError) into a plain error. It overwrites the error return of the function that deferred its call.
func catchError(err *error)func checkId(want typeId, got typeId)common returns the CommonType at the input point.
func (deb *debugger) common() CommonTypecompatibleType asks: Are these two gob Types compatible? Answers the question for basic types, arrays, maps and slices, plus GobEncoder/Decoder pairs. Structs are considered ok; fields will be checked later.
func (dec *Decoder) compatibleType(fr reflect.Type, fw typeId, inProgress map[reflect.Type]typeId) boolcompileDec compiles the decoder engine for a value. If the value is not a struct, it calls out to compileSingle.
func (dec *Decoder) compileDec(remoteId typeId, ut *userTypeInfo) (engine *decEngine, err error)compileEnc returns the engine to compile the type.
func compileEnc(ut *userTypeInfo, building map[*typeInfo]bool) *encEnginecompileIgnoreSingle compiles the decoder engine for a non-struct top-level value that will be discarded.
func (dec *Decoder) compileIgnoreSingle(remoteId typeId) *decEnginecompileSingle compiles the decoder engine for a non-struct top-level value, including GobDecoders.
func (dec *Decoder) compileSingle(remoteId typeId, ut *userTypeInfo) (engine *decEngine, err error)note that we've consumed some bytes
func (deb *debugger) consumed(n int)debug implements Debug, but catches panics and returns them as errors to be printed by Debug.
func debug(r io.Reader) (err error)decAlloc takes a value and returns a settable value that can be assigned to. If the value is a pointer, decAlloc guarantees it points to storage. The callers to the individual decoders are expected to have used decAlloc. The individual decoders don't need it.
func decAlloc(v reflect.Value) reflect.ValuedecBool decodes a uint and stores it as a boolean in value.
func decBool(i *decInstr, state *decoderState, value reflect.Value)func decBoolArray(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decBoolSlice(state *decoderState, v reflect.Value, length int, ovfl error) booldecComplex128 decodes a pair of unsigned integers, treats them as a pair of floating point numbers, and stores them as a complex128 in value. The real part comes first.
func decComplex128(i *decInstr, state *decoderState, value reflect.Value)func decComplex128Array(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decComplex128Slice(state *decoderState, v reflect.Value, length int, ovfl error) booldecComplex64 decodes a pair of unsigned integers, treats them as a pair of floating point numbers, and stores them as a complex64 in value. The real part comes first.
func decComplex64(i *decInstr, state *decoderState, value reflect.Value)func decComplex64Array(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decComplex64Slice(state *decoderState, v reflect.Value, length int, ovfl error) booldecFloat32 decodes an unsigned integer, treats it as a 32-bit floating-point number, and stores it in value.
func decFloat32(i *decInstr, state *decoderState, value reflect.Value)func decFloat32Array(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decFloat32Slice(state *decoderState, v reflect.Value, length int, ovfl error) booldecFloat64 decodes an unsigned integer, treats it as a 64-bit floating-point number, and stores it in value.
func decFloat64(i *decInstr, state *decoderState, value reflect.Value)func decFloat64Array(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decFloat64Slice(state *decoderState, v reflect.Value, length int, ovfl error) booldecIgnoreOpFor returns the decoding op for a field that has no destination.
func (dec *Decoder) decIgnoreOpFor(wireId typeId, inProgress map[typeId]*decOp) *decOpdecInt16 decodes an integer and stores it as an int16 in value.
func decInt16(i *decInstr, state *decoderState, value reflect.Value)func decInt16Array(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decInt16Slice(state *decoderState, v reflect.Value, length int, ovfl error) booldecInt32 decodes an integer and stores it as an int32 in value.
func decInt32(i *decInstr, state *decoderState, value reflect.Value)func decInt32Array(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decInt32Slice(state *decoderState, v reflect.Value, length int, ovfl error) booldecInt64 decodes an integer and stores it as an int64 in value.
func decInt64(i *decInstr, state *decoderState, value reflect.Value)func decInt64Array(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decInt64Slice(state *decoderState, v reflect.Value, length int, ovfl error) booldecInt8 decodes an integer and stores it as an int8 in value.
func decInt8(i *decInstr, state *decoderState, value reflect.Value)func decInt8Array(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decInt8Slice(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decIntArray(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decIntSlice(state *decoderState, v reflect.Value, length int, ovfl error) booldecOpFor returns the decoding op for the base type under rt and the indirection count to reach it.
func (dec *Decoder) decOpFor(wireId typeId, rt reflect.Type, name string, inProgress map[reflect.Type]*decOp) *decOpdecString decodes byte array and stores in value a string header describing the data. Strings are encoded as an unsigned count followed by the raw bytes.
func decString(i *decInstr, state *decoderState, value reflect.Value)func decStringArray(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decStringSlice(state *decoderState, v reflect.Value, length int, ovfl error) booldecUint16 decodes an unsigned integer and stores it as a uint16 in value.
func decUint16(i *decInstr, state *decoderState, value reflect.Value)func decUint16Array(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decUint16Slice(state *decoderState, v reflect.Value, length int, ovfl error) booldecUint32 decodes an unsigned integer and stores it as a uint32 in value.
func decUint32(i *decInstr, state *decoderState, value reflect.Value)func decUint32Array(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decUint32Slice(state *decoderState, v reflect.Value, length int, ovfl error) booldecUint64 decodes an unsigned integer and stores it as a uint64 in value.
func decUint64(i *decInstr, state *decoderState, value reflect.Value)func decUint64Array(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decUint64Slice(state *decoderState, v reflect.Value, length int, ovfl error) booldecUint8 decodes an unsigned integer and stores it as a uint8 in value.
func decUint8(i *decInstr, state *decoderState, value reflect.Value)decUint8Slice decodes a byte slice and stores in value a slice header describing the data. uint8 slices are encoded as an unsigned count followed by the raw bytes.
func decUint8Slice(i *decInstr, state *decoderState, value reflect.Value)func decUintArray(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decUintSlice(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decUintptrArray(state *decoderState, v reflect.Value, length int, ovfl error) boolfunc decUintptrSlice(state *decoderState, v reflect.Value, length int, ovfl error) booldecodeArray decodes an array and stores it in value. The length is an unsigned integer preceding the elements. Even though the length is redundant (it's part of the type), it's a useful check and is included in the encoding.
func (dec *Decoder) decodeArray(state *decoderState, value reflect.Value, elemOp decOp, length int, ovfl error, helper decHelper)decodeArrayHelper does the work for decoding arrays and slices.
func (dec *Decoder) decodeArrayHelper(state *decoderState, value reflect.Value, elemOp decOp, length int, ovfl error, helper decHelper)decodeGobDecoder decodes something implementing the GobDecoder interface. The data is encoded as a byte slice.
func (dec *Decoder) decodeGobDecoder(ut *userTypeInfo, state *decoderState, value reflect.Value)decodeIgnoredValue decodes the data stream representing a value of the specified type and discards it.
func (dec *Decoder) decodeIgnoredValue(wireId typeId)decodeInt reads an encoded signed integer from state.r. Does not check for overflow.
func (state *decoderState) decodeInt() int64decodeInterface decodes an interface value and stores it in value. Interfaces are encoded as the name of a concrete type followed by a value. If the name is empty, the value is nil and no value is sent.
func (dec *Decoder) decodeInterface(ityp reflect.Type, state *decoderState, value reflect.Value)decodeIntoValue is a helper for map decoding.
func decodeIntoValue(state *decoderState, op decOp, isPtr bool, value reflect.Value, instr *decInstr) reflect.ValuedecodeMap decodes a map and stores it in value. Maps are encoded as a length followed by key:value pairs. Because the internals of maps are not visible to us, we must use reflection rather than pointer magic.
func (dec *Decoder) decodeMap(mtyp reflect.Type, state *decoderState, value reflect.Value, keyOp decOp, elemOp decOp, ovfl error)decodeSingle decodes a top-level value that is not a struct and stores it in value. Such values are preceded by a zero, making them have the memory layout of a struct field (although with an illegal field number).
func (dec *Decoder) decodeSingle(engine *decEngine, value reflect.Value)decodeSlice decodes a slice and stores it in value. Slices are encoded as an unsigned length followed by the elements.
func (dec *Decoder) decodeSlice(state *decoderState, value reflect.Value, elemOp decOp, ovfl error, helper decHelper)decodeStruct decodes a top-level struct and stores it in value. Indir is for the value, not the type. At the time of the call it may differ from ut.indir, which was computed when the engine was built. This state cannot arise for decodeSingle, which is called directly from the user's value, not from the innards of an engine.
func (dec *Decoder) decodeStruct(engine *decEngine, value reflect.Value)decodeTypeSequence parses: TypeSequence (TypeDefinition DelimitedTypeDefinition*)? and returns the type id of the next value. It returns -1 at EOF. Upon return, the remainder of dec.buf is the value to be decoded. If this is an interface value, it can be ignored by resetting that buffer.
func (dec *Decoder) decodeTypeSequence(isInterface bool) typeIddecodeUint reads an encoded unsigned integer from state.r. Does not check for overflow.
func (state *decoderState) decodeUint() (x uint64)decodeUintReader reads an encoded unsigned integer from an io.Reader. Used only by the Decoder to read the message length.
func decodeUintReader(r io.Reader, buf []byte) (x uint64, width int, err error)decodeValue decodes the data stream representing a value and stores it in value.
func (dec *Decoder) decodeValue(wireId typeId, value reflect.Value)DelimitedMessage: uint(lengthOfMessage) Message
func (deb *debugger) delimitedMessage(indent tab) booldelta returns the field delta at the input point. The expect argument, if non-negative, identifies what the value should be.
func (deb *debugger) delta(expect int) intdump prints the next nBytes of the input. It arranges to print the output aligned from call to call, to make it easy to see what has been consumed.
func (deb *debugger) dump(format string, args ...any)encBool encodes the bool referenced by v as an unsigned 0 or 1.
func encBool(i *encInstr, state *encoderState, v reflect.Value)func encBoolArray(state *encoderState, v reflect.Value) boolfunc encBoolSlice(state *encoderState, v reflect.Value) boolencComplex encodes the complex value (complex64 complex128) referenced by v. Complex numbers are just a pair of floating-point numbers, real part first.
func encComplex(i *encInstr, state *encoderState, v reflect.Value)func encComplex128Array(state *encoderState, v reflect.Value) boolfunc encComplex128Slice(state *encoderState, v reflect.Value) boolfunc encComplex64Array(state *encoderState, v reflect.Value) boolfunc encComplex64Slice(state *encoderState, v reflect.Value) boolencFloat encodes the floating point value (float32 float64) referenced by v.
func encFloat(i *encInstr, state *encoderState, v reflect.Value)func encFloat32Array(state *encoderState, v reflect.Value) boolfunc encFloat32Slice(state *encoderState, v reflect.Value) boolfunc encFloat64Array(state *encoderState, v reflect.Value) boolfunc encFloat64Slice(state *encoderState, v reflect.Value) boolencIndirect dereferences pv indir times and returns the result.
func encIndirect(pv reflect.Value, indir int) reflect.ValueencInt encodes the signed integer (int int8 int16 int32 int64) referenced by v.
func encInt(i *encInstr, state *encoderState, v reflect.Value)func encInt16Array(state *encoderState, v reflect.Value) boolfunc encInt16Slice(state *encoderState, v reflect.Value) boolfunc encInt32Array(state *encoderState, v reflect.Value) boolfunc encInt32Slice(state *encoderState, v reflect.Value) boolfunc encInt64Array(state *encoderState, v reflect.Value) boolfunc encInt64Slice(state *encoderState, v reflect.Value) boolfunc encInt8Array(state *encoderState, v reflect.Value) boolfunc encInt8Slice(state *encoderState, v reflect.Value) boolfunc encIntArray(state *encoderState, v reflect.Value) boolfunc encIntSlice(state *encoderState, v reflect.Value) boolencOpFor returns (a pointer to) the encoding op for the base type under rt and the indirection count to reach it.
func encOpFor(rt reflect.Type, inProgress map[reflect.Type]*encOp, building map[*typeInfo]bool) (*encOp, int)encString encodes the string referenced by v. Strings are encoded as an unsigned count followed by the raw bytes.
func encString(i *encInstr, state *encoderState, v reflect.Value)func encStringArray(state *encoderState, v reflect.Value) boolfunc encStringSlice(state *encoderState, v reflect.Value) boolencStructTerminator encodes the end of an encoded struct as delta field number of 0.
func encStructTerminator(i *encInstr, state *encoderState, v reflect.Value)encUint encodes the unsigned integer (uint uint8 uint16 uint32 uint64 uintptr) referenced by v.
func encUint(i *encInstr, state *encoderState, v reflect.Value)func encUint16Array(state *encoderState, v reflect.Value) boolfunc encUint16Slice(state *encoderState, v reflect.Value) boolfunc encUint32Array(state *encoderState, v reflect.Value) boolfunc encUint32Slice(state *encoderState, v reflect.Value) boolfunc encUint64Array(state *encoderState, v reflect.Value) boolfunc encUint64Slice(state *encoderState, v reflect.Value) boolencUint8Array encodes the byte array referenced by v. Byte arrays are encoded as an unsigned count followed by the raw bytes.
func encUint8Array(i *encInstr, state *encoderState, v reflect.Value)func encUintArray(state *encoderState, v reflect.Value) boolfunc encUintSlice(state *encoderState, v reflect.Value) boolfunc encUintptrArray(state *encoderState, v reflect.Value) boolfunc encUintptrSlice(state *encoderState, v reflect.Value) boolfunc (enc *Encoder) encode(b *encBuffer, value reflect.Value, ut *userTypeInfo)encodeArray encodes an array.
func (enc *Encoder) encodeArray(b *encBuffer, value reflect.Value, op encOp, elemIndir int, length int, helper encHelper)encodeGobEncoder encodes a value that implements the GobEncoder interface. The data is sent as a byte array.
func (enc *Encoder) encodeGobEncoder(b *encBuffer, ut *userTypeInfo, v reflect.Value)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 (state *encoderState) encodeInt(i int64)encodeInterface encodes the interface value iv. 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 *encBuffer, iv reflect.Value)encodeMap encodes a map as unsigned count followed by key:value pairs.
func (enc *Encoder) encodeMap(b *encBuffer, mv reflect.Value, keyOp encOp, elemOp encOp, keyIndir int, elemIndir int)encodeReflectValue is a helper for maps. It encodes the value v.
func encodeReflectValue(state *encoderState, v reflect.Value, op encOp, indir int)encodeSingle encodes a single top-level non-struct value.
func (enc *Encoder) encodeSingle(b *encBuffer, engine *encEngine, value reflect.Value)encodeStruct encodes a single struct value.
func (enc *Encoder) encodeStruct(b *encBuffer, engine *encEngine, value reflect.Value)encodeUint writes an encoded unsigned integer to state.b.
func (state *encoderState) encodeUint(x uint64)error_ wraps the argument error and uses it as the argument to panic.
func error_(err error)errorf is like error_ but takes Printf-style arguments to construct an error. It always prefixes the message with "gob: ".
func errorf(format string, args ...any)fieldValue prints a value of any type, such as a struct field. FieldValue: builtinValue | ArrayValue | MapValue | SliceValue | StructValue | InterfaceValue
func (deb *debugger) fieldValue(indent tab, id typeId)float32FromBits decodes an unsigned integer, treats it as a 32-bit floating-point number, and returns it. It's a helper function for float32 and complex64. It returns a float64 because that's what reflection needs, but its return value is known to be accurately representable in a float32.
func float32FromBits(u uint64, ovfl error) float64Floating-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 unswizzling.
func float64FromBits(u uint64) float64floatBits returns a uint64 holding the bits of a floating-point number. 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) uint64func (dec *Decoder) freeDecoderState(d *decoderState)func (enc *Encoder) freeEncoderState(e *encoderState)getBaseType returns the Gob type describing the given reflect.Type's base type. typeLock must be held.
func getBaseType(name string, rt reflect.Type) (gobType, error)getDecEnginePtr returns the engine for the specified type.
func (dec *Decoder) getDecEnginePtr(remoteId typeId, ut *userTypeInfo) (enginePtr **decEngine, err error)getEncEngine returns the engine to compile the type.
func getEncEngine(ut *userTypeInfo, building map[*typeInfo]bool) *encEnginegetIgnoreEnginePtr returns the engine for the specified type when the value is to be discarded.
func (dec *Decoder) getIgnoreEnginePtr(wireId typeId) (enginePtr **decEngine, err error)getLength decodes the next uint and makes sure it is a possible size for a data item that follows, which means it must fit in a non-negative int and fit in the buffer.
func (state *decoderState) getLength() (int, bool)getType returns the Gob type describing the given reflect.Type. Should be called only when handling GobEncoders/Decoders, which may be pointers. All other types are handled through the base type, never a pointer. typeLock must be held.
func getType(name string, ut *userTypeInfo, rt reflect.Type) (gobType, error)func getTypeInfo(ut *userTypeInfo) (*typeInfo, error)gobDecodeOpFor returns the op for a type that is known to implement GobDecoder.
func (dec *Decoder) gobDecodeOpFor(ut *userTypeInfo) *decOpgobEncodeOpFor returns the op for a type that is known to implement GobEncoder.
func gobEncodeOpFor(ut *userTypeInfo) (*encOp, int)GobEncoderValue: uint(n) byte*n
func (deb *debugger) gobEncoderValue(indent tab, id typeId)GobStream: DelimitedMessage* (until EOF)
func (deb *debugger) gobStream()func (t typeId) gobType() gobTypegrowSlice is called for a slice that we only partially allocated, to grow it up to length.
func growSlice(v reflect.Value, ps *[]E, length int)func (t *CommonType) id() typeIdfunc idToType(id typeId) gobTypeignoreArray discards the data for an array value with no destination.
func (dec *Decoder) ignoreArray(state *decoderState, elemOp decOp, length int)ignoreArrayHelper does the work for discarding arrays and slices.
func (dec *Decoder) ignoreArrayHelper(state *decoderState, elemOp decOp, length int)ignoreGobDecoder discards the data for a GobDecoder value with no destination.
func (dec *Decoder) ignoreGobDecoder(state *decoderState)ignoreInterface discards the data for an interface value with no destination.
func (dec *Decoder) ignoreInterface(state *decoderState)ignoreMap discards the data for a map value with no destination.
func (dec *Decoder) ignoreMap(state *decoderState, keyOp decOp, elemOp decOp)ignoreSingle discards the data for a top-level non-struct value with no destination. It's used when calling Decode with a nil value.
func (dec *Decoder) ignoreSingle(engine *decEngine)ignoreSlice skips over the data for a slice value with no destination.
func (dec *Decoder) ignoreSlice(state *decoderState, elemOp decOp)ignoreStruct discards the data for a struct with no destination.
func (dec *Decoder) ignoreStruct(engine *decEngine)ignoreTwoUints discards a uint value with no destination. It's used to skip complex values.
func ignoreTwoUints(i *decInstr, state *decoderState, v reflect.Value)ignoreUint discards a uint value with no destination.
func ignoreUint(i *decInstr, state *decoderState, v reflect.Value)ignoreUint8Array skips over the data for a byte slice value with no destination.
func ignoreUint8Array(i *decInstr, state *decoderState, value reflect.Value)implementsInterface reports whether the type implements the gobEncoder/gobDecoder interface. It also returns the number of indirections required to get to the implementation.
func implementsInterface(typ reflect.Type, gobEncDecType reflect.Type) (success bool, indir int8)func (a *arrayType) init(elem gobType, len int)Init installs the debugging facility. If this file is not compiled in the package, the tests in codec_test.go are no-ops.
func init()func init()func (s *sliceType) init(elem gobType)func (m *mapType) init(key gobType, elem gobType)func init()func init()int returns the signed int at the input point, as an int (not int64).
func (deb *debugger) int() intint64 decodes and returns the next integer, which must be present. Don't call this if you could be at EOF.
func (deb *debugger) int64() int64InterfaceValue: NilInterfaceValue | NonNilInterfaceValue
func (deb *debugger) interfaceValue(indent tab)isExported reports whether this is an exported - upper case - name.
func isExported(name string) boolisSent reports whether this struct field is to be transmitted. It will be transmitted only if it is exported and not a chan or func field or pointer to chan or func.
func isSent(field *reflect.StructField) boolloadBlock preps us to read a message of the length specified next in the input. It returns the length of the block. The argument tells whether an EOF is acceptable now. If it is and one is found, the return value is negative.
func (deb *debugger) loadBlock(eofOK bool) intfunc lookupTypeInfo(rt reflect.Type) *typeInfoMapValue: uint(n) (FieldValue FieldValue)*n [n (key, value) pairs]
func (deb *debugger) mapValue(indent tab, wire *wireType)Message: TypeSequence TypedValue TypeSequence (TypeDefinition DelimitedTypeDefinition*)? DelimitedTypeDefinition: uint(lengthOfTypeDefinition) TypeDefinition TypedValue: int(typeId) Value
func (deb *debugger) message(indent tab) boolCalled only when a panic is acceptable and unexpected.
func mustGetTypeInfo(rt reflect.Type) *typeInfofunc (t *CommonType) name() stringName returns the name of the type associated with the typeId.
func (t typeId) name() stringfunc newArrayType(name string) *arrayTypeWe pass the bytes.Buffer separately for easier testing of the infrastructure without requiring a full Decoder.
func (dec *Decoder) newDecoderState(buf *decBuffer) *decoderStatefunc (enc *Encoder) newEncoderState(b *encBuffer) *encoderStatefunc newGobEncoderType(name string) *gobEncoderTypefunc newMapType(name string) *mapTypenewPeekReader returns a peekReader that wraps r.
func newPeekReader(r io.Reader) *peekReaderfunc newSliceType(name string) *sliceTypefunc newStructType(name string) *structTypenewTypeObject allocates a gobType for the reflection type rt. Unless ut represents a GobEncoder, rt should be the base type of ut. This is only called from the encoding side. The decoding side works through typeIds and userTypeInfos alone.
func newTypeObject(name string, ut *userTypeInfo, rt reflect.Type) (gobType, error)func (dec *Decoder) nextInt() int64func (dec *Decoder) nextUint() uint64NilInterfaceValue: uint(0) [already read]
func (deb *debugger) nilInterfaceValue(indent tab) intNonNilInterfaceValue: ConcreteTypeName TypeSequence InterfaceContents ConcreteTypeName: uint(lengthOfName) [already read=n] name InterfaceContents: int(concreteTypeId) DelimitedValue DelimitedValue: uint(length) Value
func (deb *debugger) nonNilInterfaceValue(indent tab, nameLen int)func overflow(name string) errorpeek returns as many bytes as possible from the unread portion of the stream, up to the length of b.
func (p *peekReader) peek(b []byte) (n int, err error)popWriter pops the innermost writer.
func (enc *Encoder) popWriter()func (t tab) print()printBuiltin prints a value not of a fundamental type, that is, one whose type is known to gobs at bootstrap time.
func (deb *debugger) printBuiltin(indent tab, id typeId)printCommonType prints a common type; used by printWireType.
func (deb *debugger) printCommonType(indent tab, kind string, common *CommonType)printWireType prints the contents of a wireType.
func (deb *debugger) printWireType(indent tab, wire *wireType)pushWriter adds a writer to the encoder.
func (enc *Encoder) pushWriter(w io.Writer)readMessage reads the next nbytes bytes from the input.
func (dec *Decoder) readMessage(nbytes int)recvMessage reads the next count-delimited item from the input. It is the converse of Encoder.writeMessage. It returns false on EOF or other error reading the message.
func (dec *Decoder) recvMessage() boolrecvType loads the definition of a type.
func (dec *Decoder) recvType(id typeId)func registerBasics()func (s *structType) safeString(seen map[typeId]bool) stringfunc (a *arrayType) safeString(seen map[typeId]bool) stringfunc (m *mapType) safeString(seen map[typeId]bool) stringfunc (t *CommonType) safeString(seen map[typeId]bool) stringfunc (g *gobEncoderType) safeString(seen map[typeId]bool) stringfunc (s *sliceType) safeString(seen map[typeId]bool) stringsendActualType sends the requested type, without further investigation, unless it's been sent before.
func (enc *Encoder) sendActualType(w io.Writer, state *encoderState, ut *userTypeInfo, actual reflect.Type) (sent bool)sendType sends the type info to the other side, if necessary.
func (enc *Encoder) sendType(w io.Writer, state *encoderState, origt reflect.Type) (sent bool)sendTypeDescriptor makes sure the remote side knows about this type. It will send a descriptor if this is the first time the type has been sent.
func (enc *Encoder) sendTypeDescriptor(w io.Writer, state *encoderState, ut *userTypeInfo)sendTypeId sends the id, which must have already been defined.
func (enc *Encoder) sendTypeId(state *encoderState, ut *userTypeInfo)func (enc *Encoder) setError(err error)func (t *CommonType) setId(id typeId)func setTypeId(typ gobType)SingletonValue: uint(0) FieldValue
func (deb *debugger) singletonValue(indent tab, id typeId)SliceValue: uint(n) (n FieldValue)
func (deb *debugger) sliceValue(indent tab, wire *wireType)func (m *mapType) string() stringfunc (a *arrayType) string() stringfunc (s *structType) string() stringfunc (s *sliceType) string() stringstring returns the string at the input point.
func (deb *debugger) string() stringfunc (t *CommonType) string() stringfunc (w *wireType) string() stringfunc (g *gobEncoderType) string() stringstring returns the string representation of the type associated with the typeId.
func (t typeId) string() stringStructValue: (uint(fieldDelta) FieldValue)*
func (deb *debugger) structValue(indent tab, id typeId)toInt turns an encoded uint64 into an int, according to the marshaling rules.
func toInt(x uint64) int64TypeDefinition: [int(-typeId) (already read)] encodingOfWireType
func (deb *debugger) typeDefinition(indent tab, id typeId)typeId returns the type id at the input point.
func (deb *debugger) typeId() typeIdtypeString returns a human-readable description of the type identified by remoteId.
func (dec *Decoder) typeString(remoteId typeId) stringuint returns the unsigned int at the input point, as a uint (not uint64).
func (deb *debugger) uint() uintuint64 returns and decodes the next unsigned integer, which must be present. Don't call this if you could be at EOF. TODO: handle errors better.
func (deb *debugger) uint64() uint64update emits a field number and updates the state to record its value for delta encoding. If the instruction pointer is nil, it does nothing
func (state *encoderState) update(instr *encInstr)userType returns, and saves, the information associated with user-provided type rt. If the user type is not valid, it calls error.
func userType(rt reflect.Type) *userTypeInfovalid reports whether the value is valid and a non-nil pointer. (Slices, maps, and chans take care of themselves.)
func valid(v reflect.Value) boolvalidUserType returns, and saves, the information associated with user-provided type rt. If the user type is not valid, err will be non-nil. To be used when the error handler is not set up.
func validUserType(rt reflect.Type) (*userTypeInfo, error)Value: SingletonValue | StructValue
func (deb *debugger) value(indent tab, id typeId)func (e *encBuffer) writeByte(c byte)writeMessage sends the data item preceded by an unsigned count of its length.
func (enc *Encoder) writeMessage(w io.Writer, b *encBuffer)writer returns the innermost writer the encoder is using.
func (enc *Encoder) writer() io.WriterGenerated with Arrow