2012-03-27 23:13:14 +00:00
|
|
|
// 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.
|
|
|
|
// +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 ...interface{}) {
|
|
|
|
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:
|
2015-08-28 15:33:40 +00:00
|
|
|
errorf("corrupted CommonType, delta is %d fieldNum is %d", delta, fieldNum)
|
2012-03-27 23:13:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
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}
|
2014-09-21 17:33:12 +00:00
|
|
|
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}
|
2012-03-27 23:13:14 +00:00
|
|
|
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.int64()
|
|
|
|
fmt.Fprintf(os.Stderr, "%s%d\n", indent, x)
|
|
|
|
case tFloat:
|
|
|
|
x := deb.uint64()
|
2015-08-28 15:33:40 +00:00
|
|
|
fmt.Fprintf(os.Stderr, "%s%g\n", indent, float64FromBits(x))
|
2012-03-27 23:13:14 +00:00
|
|
|
case tComplex:
|
|
|
|
r := deb.uint64()
|
|
|
|
i := deb.uint64()
|
2015-08-28 15:33:40 +00:00
|
|
|
fmt.Fprintf(os.Stderr, "%s%g+%gi\n", indent, float64FromBits(r), float64FromBits(i))
|
2012-03-27 23:13:14 +00:00
|
|
|
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)
|
|
|
|
}
|