123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705 |
- // 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.
- // Delete the next line to include in the gob package.
- //go:build ignore
- package gob
- // This file is not normally included in the gob package. Used only for debugging the package itself.
- // Except for reading uints, it is an implementation of a reader that is independent of
- // the one implemented by Decoder.
- // To enable the Debug function, delete the +build ignore line above and do
- // go install
- import (
- "bytes"
- "fmt"
- "io"
- "os"
- "strings"
- "sync"
- )
- var dumpBytes = false // If true, print the remaining bytes in the input buffer at each item.
- // 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() {
- debugFunc = Debug
- }
- var (
- blanks = bytes.Repeat([]byte{' '}, 3*10)
- empty = []byte(": <empty>\n")
- tabs = strings.Repeat("\t", 100)
- )
- // tab indents itself when printed.
- type tab int
- func (t tab) String() string {
- n := int(t)
- if n > len(tabs) {
- n = len(tabs)
- }
- return tabs[0:n]
- }
- func (t tab) print() {
- fmt.Fprint(os.Stderr, t)
- }
- // 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 // read-ahead data
- }
- // newPeekReader returns a peekReader that wraps r.
- func newPeekReader(r io.Reader) *peekReader {
- return &peekReader{r: r}
- }
- // Read is the usual method. It will first take data that has been read ahead.
- func (p *peekReader) Read(b []byte) (n int, err error) {
- if len(p.data) == 0 {
- return p.r.Read(b)
- }
- // Satisfy what's possible from the read-ahead data.
- n = copy(b, p.data)
- // Move data down to beginning of slice, to avoid endless growth
- copy(p.data, p.data[n:])
- p.data = p.data[:len(p.data)-n]
- return
- }
- // peek 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) {
- if len(p.data) > 0 {
- n = copy(b, p.data)
- if n == len(b) {
- return
- }
- b = b[n:]
- }
- if len(b) == 0 {
- return
- }
- m, e := io.ReadFull(p.r, b)
- if m > 0 {
- p.data = append(p.data, b[:m]...)
- }
- n += m
- if e == io.ErrUnexpectedEOF {
- // That means m > 0 but we reached EOF. If we got data
- // we won't complain about not being able to peek enough.
- if n > 0 {
- e = nil
- } else {
- e = io.EOF
- }
- }
- return n, e
- }
- type debugger struct {
- mutex sync.Mutex
- remain int // the number of bytes known to remain in the input
- remainingKnown bool // the value of 'remain' is valid
- r *peekReader
- wireType map[typeId]*wireType
- tmp []byte // scratch space for decoding uints.
- }
- // dump 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) {
- if !dumpBytes {
- return
- }
- fmt.Fprintf(os.Stderr, format+" ", args...)
- if !deb.remainingKnown {
- return
- }
- if deb.remain < 0 {
- fmt.Fprintf(os.Stderr, "remaining byte count is negative! %d\n", deb.remain)
- return
- }
- data := make([]byte, deb.remain)
- n, _ := deb.r.peek(data)
- if n == 0 {
- os.Stderr.Write(empty)
- return
- }
- b := new(bytes.Buffer)
- fmt.Fprintf(b, "[%d]{\n", deb.remain)
- // Blanks until first byte
- lineLength := 0
- if n := len(data); n%10 != 0 {
- lineLength = 10 - n%10
- fmt.Fprintf(b, "\t%s", blanks[:lineLength*3])
- }
- // 10 bytes per line
- for len(data) > 0 {
- if lineLength == 0 {
- fmt.Fprint(b, "\t")
- }
- m := 10 - lineLength
- lineLength = 0
- if m > len(data) {
- m = len(data)
- }
- fmt.Fprintf(b, "% x\n", data[:m])
- data = data[m:]
- }
- fmt.Fprint(b, "}\n")
- os.Stderr.Write(b.Bytes())
- }
- // Debug 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) {
- err := debug(r)
- if err != nil {
- fmt.Fprintf(os.Stderr, "gob debug: %s\n", err)
- }
- }
- // debug implements Debug, but catches panics and returns
- // them as errors to be printed by Debug.
- func debug(r io.Reader) (err error) {
- defer catchError(&err)
- fmt.Fprintln(os.Stderr, "Start of debugging")
- deb := &debugger{
- r: newPeekReader(r),
- wireType: make(map[typeId]*wireType),
- tmp: make([]byte, 16),
- }
- if b, ok := r.(*bytes.Buffer); ok {
- deb.remain = b.Len()
- deb.remainingKnown = true
- }
- deb.gobStream()
- return
- }
- // note that we've consumed some bytes
- func (deb *debugger) consumed(n int) {
- if deb.remainingKnown {
- deb.remain -= n
- }
- }
- // int64 decodes and returns the next integer, which must be present.
- // Don't call this if you could be at EOF.
- func (deb *debugger) int64() int64 {
- return toInt(deb.uint64())
- }
- // uint64 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() uint64 {
- n, w, err := decodeUintReader(deb.r, deb.tmp)
- if err != nil {
- errorf("debug: read error: %s", err)
- }
- deb.consumed(w)
- return n
- }
- // GobStream:
- // DelimitedMessage* (until EOF)
- func (deb *debugger) gobStream() {
- // Make sure we're single-threaded through here.
- deb.mutex.Lock()
- defer deb.mutex.Unlock()
- for deb.delimitedMessage(0) {
- }
- }
- // DelimitedMessage:
- // uint(lengthOfMessage) Message
- func (deb *debugger) delimitedMessage(indent tab) bool {
- for {
- n := deb.loadBlock(true)
- if n < 0 {
- return false
- }
- deb.dump("Delimited message of length %d", n)
- deb.message(indent)
- }
- return true
- }
- // loadBlock 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) int {
- n64, w, err := decodeUintReader(deb.r, deb.tmp) // deb.uint64 will error at EOF
- if err != nil {
- if eofOK && err == io.EOF {
- return -1
- }
- errorf("debug: unexpected error: %s", err)
- }
- deb.consumed(w)
- n := int(n64)
- if n < 0 {
- errorf("huge value for message length: %d", n64)
- }
- return int(n)
- }
- // Message:
- // TypeSequence TypedValue
- // TypeSequence
- // (TypeDefinition DelimitedTypeDefinition*)?
- // DelimitedTypeDefinition:
- // uint(lengthOfTypeDefinition) TypeDefinition
- // TypedValue:
- // int(typeId) Value
- func (deb *debugger) message(indent tab) bool {
- for {
- // Convert the uint64 to a signed integer typeId
- uid := deb.int64()
- id := typeId(uid)
- deb.dump("type id=%d", id)
- if id < 0 {
- deb.typeDefinition(indent, -id)
- n := deb.loadBlock(false)
- deb.dump("Message of length %d", n)
- continue
- } else {
- deb.value(indent, id)
- break
- }
- }
- return true
- }
- // Helper methods to make it easy to scan a type descriptor.
- // common returns the CommonType at the input point.
- func (deb *debugger) common() CommonType {
- fieldNum := -1
- name := ""
- id := typeId(0)
- for {
- delta := deb.delta(-1)
- if delta == 0 {
- break
- }
- fieldNum += delta
- switch fieldNum {
- case 0:
- name = deb.string()
- case 1:
- // Id typeId
- id = deb.typeId()
- default:
- errorf("corrupted CommonType, delta is %d fieldNum is %d", delta, fieldNum)
- }
- }
- return CommonType{name, id}
- }
- // uint returns the unsigned int at the input point, as a uint (not uint64).
- func (deb *debugger) uint() uint {
- return uint(deb.uint64())
- }
- // int returns the signed int at the input point, as an int (not int64).
- func (deb *debugger) int() int {
- return int(deb.int64())
- }
- // typeId returns the type id at the input point.
- func (deb *debugger) typeId() typeId {
- return typeId(deb.int64())
- }
- // string returns the string at the input point.
- func (deb *debugger) string() string {
- x := int(deb.uint64())
- b := make([]byte, x)
- nb, _ := deb.r.Read(b)
- if nb != x {
- errorf("corrupted type")
- }
- deb.consumed(nb)
- return string(b)
- }
- // delta 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) int {
- delta := int(deb.uint64())
- if delta < 0 || (expect >= 0 && delta != expect) {
- errorf("decode: corrupted type: delta %d expected %d", delta, expect)
- }
- return delta
- }
- // TypeDefinition:
- // [int(-typeId) (already read)] encodingOfWireType
- func (deb *debugger) typeDefinition(indent tab, id typeId) {
- deb.dump("type definition for id %d", id)
- // Encoding is of a wireType. Decode the structure as usual
- fieldNum := -1
- wire := new(wireType)
- // A wireType defines a single field.
- delta := deb.delta(-1)
- fieldNum += delta
- switch fieldNum {
- case 0: // array type, one field of {{Common}, elem, length}
- // Field number 0 is CommonType
- deb.delta(1)
- com := deb.common()
- // Field number 1 is type Id of elem
- deb.delta(1)
- id := deb.typeId()
- // Field number 3 is length
- deb.delta(1)
- length := deb.int()
- wire.ArrayT = &arrayType{com, id, length}
- case 1: // slice type, one field of {{Common}, elem}
- // Field number 0 is CommonType
- deb.delta(1)
- com := deb.common()
- // Field number 1 is type Id of elem
- deb.delta(1)
- id := deb.typeId()
- wire.SliceT = &sliceType{com, id}
- case 2: // struct type, one field of {{Common}, []fieldType}
- // Field number 0 is CommonType
- deb.delta(1)
- com := deb.common()
- // Field number 1 is slice of FieldType
- deb.delta(1)
- numField := int(deb.uint())
- field := make([]*fieldType, numField)
- for i := 0; i < numField; i++ {
- field[i] = new(fieldType)
- deb.delta(1) // field 0 of fieldType: name
- field[i].Name = deb.string()
- deb.delta(1) // field 1 of fieldType: id
- field[i].Id = deb.typeId()
- deb.delta(0) // end of fieldType
- }
- wire.StructT = &structType{com, field}
- case 3: // map type, one field of {{Common}, key, elem}
- // Field number 0 is CommonType
- deb.delta(1)
- com := deb.common()
- // Field number 1 is type Id of key
- deb.delta(1)
- keyId := deb.typeId()
- // Field number 2 is type Id of elem
- deb.delta(1)
- elemId := deb.typeId()
- wire.MapT = &mapType{com, keyId, elemId}
- case 4: // GobEncoder type, one field of {{Common}}
- // Field number 0 is CommonType
- deb.delta(1)
- com := deb.common()
- wire.GobEncoderT = &gobEncoderType{com}
- case 5: // BinaryMarshaler type, one field of {{Common}}
- // Field number 0 is CommonType
- deb.delta(1)
- com := deb.common()
- wire.BinaryMarshalerT = &gobEncoderType{com}
- case 6: // TextMarshaler type, one field of {{Common}}
- // Field number 0 is CommonType
- deb.delta(1)
- com := deb.common()
- wire.TextMarshalerT = &gobEncoderType{com}
- default:
- errorf("bad field in type %d", fieldNum)
- }
- deb.printWireType(indent, wire)
- deb.delta(0) // end inner type (arrayType, etc.)
- deb.delta(0) // end wireType
- // Remember we've seen this type.
- deb.wireType[id] = wire
- }
- // Value:
- // SingletonValue | StructValue
- func (deb *debugger) value(indent tab, id typeId) {
- wire, ok := deb.wireType[id]
- if ok && wire.StructT != nil {
- deb.structValue(indent, id)
- } else {
- deb.singletonValue(indent, id)
- }
- }
- // SingletonValue:
- // uint(0) FieldValue
- func (deb *debugger) singletonValue(indent tab, id typeId) {
- deb.dump("Singleton value")
- // is it a builtin type?
- wire := deb.wireType[id]
- _, ok := builtinIdToType[id]
- if !ok && wire == nil {
- errorf("type id %d not defined", id)
- }
- m := deb.uint64()
- if m != 0 {
- errorf("expected zero; got %d", m)
- }
- deb.fieldValue(indent, id)
- }
- // InterfaceValue:
- // NilInterfaceValue | NonNilInterfaceValue
- func (deb *debugger) interfaceValue(indent tab) {
- deb.dump("Start of interface value")
- if nameLen := deb.uint64(); nameLen == 0 {
- deb.nilInterfaceValue(indent)
- } else {
- deb.nonNilInterfaceValue(indent, int(nameLen))
- }
- }
- // NilInterfaceValue:
- // uint(0) [already read]
- func (deb *debugger) nilInterfaceValue(indent tab) int {
- fmt.Fprintf(os.Stderr, "%snil interface\n", indent)
- return 0
- }
- // NonNilInterfaceValue:
- // 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) {
- // ConcreteTypeName
- b := make([]byte, nameLen)
- deb.r.Read(b) // TODO: CHECK THESE READS!!
- deb.consumed(nameLen)
- name := string(b)
- for {
- id := deb.typeId()
- if id < 0 {
- deb.typeDefinition(indent, -id)
- n := deb.loadBlock(false)
- deb.dump("Nested message of length %d", n)
- } else {
- // DelimitedValue
- x := deb.uint64() // in case we want to ignore the value; we don't.
- fmt.Fprintf(os.Stderr, "%sinterface value, type %q id=%d; valueLength %d\n", indent, name, id, x)
- deb.value(indent, id)
- break
- }
- }
- }
- // printCommonType prints a common type; used by printWireType.
- func (deb *debugger) printCommonType(indent tab, kind string, common *CommonType) {
- indent.print()
- fmt.Fprintf(os.Stderr, "%s %q id=%d\n", kind, common.Name, common.Id)
- }
- // printWireType prints the contents of a wireType.
- func (deb *debugger) printWireType(indent tab, wire *wireType) {
- fmt.Fprintf(os.Stderr, "%stype definition {\n", indent)
- indent++
- switch {
- case wire.ArrayT != nil:
- deb.printCommonType(indent, "array", &wire.ArrayT.CommonType)
- fmt.Fprintf(os.Stderr, "%slen %d\n", indent+1, wire.ArrayT.Len)
- fmt.Fprintf(os.Stderr, "%selemid %d\n", indent+1, wire.ArrayT.Elem)
- case wire.MapT != nil:
- deb.printCommonType(indent, "map", &wire.MapT.CommonType)
- fmt.Fprintf(os.Stderr, "%skey id=%d\n", indent+1, wire.MapT.Key)
- fmt.Fprintf(os.Stderr, "%selem id=%d\n", indent+1, wire.MapT.Elem)
- case wire.SliceT != nil:
- deb.printCommonType(indent, "slice", &wire.SliceT.CommonType)
- fmt.Fprintf(os.Stderr, "%selem id=%d\n", indent+1, wire.SliceT.Elem)
- case wire.StructT != nil:
- deb.printCommonType(indent, "struct", &wire.StructT.CommonType)
- for i, field := range wire.StructT.Field {
- fmt.Fprintf(os.Stderr, "%sfield %d:\t%s\tid=%d\n", indent+1, i, field.Name, field.Id)
- }
- case wire.GobEncoderT != nil:
- deb.printCommonType(indent, "GobEncoder", &wire.GobEncoderT.CommonType)
- }
- indent--
- fmt.Fprintf(os.Stderr, "%s}\n", indent)
- }
- // 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) {
- _, ok := builtinIdToType[id]
- if ok {
- if id == tInterface {
- deb.interfaceValue(indent)
- } else {
- deb.printBuiltin(indent, id)
- }
- return
- }
- wire, ok := deb.wireType[id]
- if !ok {
- errorf("type id %d not defined", id)
- }
- switch {
- case wire.ArrayT != nil:
- deb.arrayValue(indent, wire)
- case wire.MapT != nil:
- deb.mapValue(indent, wire)
- case wire.SliceT != nil:
- deb.sliceValue(indent, wire)
- case wire.StructT != nil:
- deb.structValue(indent, id)
- case wire.GobEncoderT != nil:
- deb.gobEncoderValue(indent, id)
- default:
- panic("bad wire type for field")
- }
- }
- // 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) {
- switch id {
- case tBool:
- x := deb.int64()
- if x == 0 {
- fmt.Fprintf(os.Stderr, "%sfalse\n", indent)
- } else {
- fmt.Fprintf(os.Stderr, "%strue\n", indent)
- }
- case tInt:
- x := deb.int64()
- fmt.Fprintf(os.Stderr, "%s%d\n", indent, x)
- case tUint:
- x := deb.uint64()
- fmt.Fprintf(os.Stderr, "%s%d\n", indent, x)
- case tFloat:
- x := deb.uint64()
- fmt.Fprintf(os.Stderr, "%s%g\n", indent, float64FromBits(x))
- case tComplex:
- r := deb.uint64()
- i := deb.uint64()
- fmt.Fprintf(os.Stderr, "%s%g+%gi\n", indent, float64FromBits(r), float64FromBits(i))
- case tBytes:
- x := int(deb.uint64())
- b := make([]byte, x)
- deb.r.Read(b)
- deb.consumed(x)
- fmt.Fprintf(os.Stderr, "%s{% x}=%q\n", indent, b, b)
- case tString:
- x := int(deb.uint64())
- b := make([]byte, x)
- deb.r.Read(b)
- deb.consumed(x)
- fmt.Fprintf(os.Stderr, "%s%q\n", indent, b)
- default:
- panic("unknown builtin")
- }
- }
- // ArrayValue:
- // uint(n) FieldValue*n
- func (deb *debugger) arrayValue(indent tab, wire *wireType) {
- elemId := wire.ArrayT.Elem
- u := deb.uint64()
- length := int(u)
- for i := 0; i < length; i++ {
- deb.fieldValue(indent, elemId)
- }
- if length != wire.ArrayT.Len {
- fmt.Fprintf(os.Stderr, "%s(wrong length for array: %d should be %d)\n", indent, length, wire.ArrayT.Len)
- }
- }
- // MapValue:
- // uint(n) (FieldValue FieldValue)*n [n (key, value) pairs]
- func (deb *debugger) mapValue(indent tab, wire *wireType) {
- keyId := wire.MapT.Key
- elemId := wire.MapT.Elem
- u := deb.uint64()
- length := int(u)
- for i := 0; i < length; i++ {
- deb.fieldValue(indent+1, keyId)
- deb.fieldValue(indent+1, elemId)
- }
- }
- // SliceValue:
- // uint(n) (n FieldValue)
- func (deb *debugger) sliceValue(indent tab, wire *wireType) {
- elemId := wire.SliceT.Elem
- u := deb.uint64()
- length := int(u)
- deb.dump("Start of slice of length %d", length)
- for i := 0; i < length; i++ {
- deb.fieldValue(indent, elemId)
- }
- }
- // StructValue:
- // (uint(fieldDelta) FieldValue)*
- func (deb *debugger) structValue(indent tab, id typeId) {
- deb.dump("Start of struct value of %q id=%d\n<<\n", id.name(), id)
- fmt.Fprintf(os.Stderr, "%s%s struct {\n", indent, id.name())
- wire, ok := deb.wireType[id]
- if !ok {
- errorf("type id %d not defined", id)
- }
- strct := wire.StructT
- fieldNum := -1
- indent++
- for {
- delta := deb.uint64()
- if delta == 0 { // struct terminator is zero delta fieldnum
- break
- }
- fieldNum += int(delta)
- if fieldNum < 0 || fieldNum >= len(strct.Field) {
- deb.dump("field number out of range: prevField=%d delta=%d", fieldNum-int(delta), delta)
- break
- }
- fmt.Fprintf(os.Stderr, "%sfield %d:\t%s\n", indent, fieldNum, wire.StructT.Field[fieldNum].Name)
- deb.fieldValue(indent+1, strct.Field[fieldNum].Id)
- }
- indent--
- fmt.Fprintf(os.Stderr, "%s} // end %s struct\n", indent, id.name())
- deb.dump(">> End of struct value of type %d %q", id, id.name())
- }
- // GobEncoderValue:
- // uint(n) byte*n
- func (deb *debugger) gobEncoderValue(indent tab, id typeId) {
- len := deb.uint64()
- deb.dump("GobEncoder value of %q id=%d, length %d\n", id.name(), id, len)
- fmt.Fprintf(os.Stderr, "%s%s (implements GobEncoder)\n", indent, id.name())
- data := make([]byte, len)
- _, err := deb.r.Read(data)
- if err != nil {
- errorf("gobEncoder data read: %s", err)
- }
- fmt.Fprintf(os.Stderr, "%s[% .2x]\n", indent+1, data)
- }
|