Subversion Repositories openrisc

// 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 gob-debug

package gob

// This file is not normally included in the gob package.  Used only for debugging the package itself.

// Add debug.go to the files listed in the Makefile to add Debug to the gob package.

// Except for reading uints, it is an implementation of a reader that is independent of

// the one implemented by Decoder.

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(": \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:

                        errorf("corrupted CommonType")

                }

        }

        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}

        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()

                fmt.Fprintf(os.Stderr, "%s%g\n", indent, floatFromBits(x))

        case tComplex:

                r := deb.uint64()

                i := deb.uint64()

                fmt.Fprintf(os.Stderr, "%s%g+%gi\n", indent, floatFromBits(r), floatFromBits(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)

}