...
Run Format

Source file src/encoding/gob/debug.go

Documentation: encoding/gob

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Delete the next line to include in the gob package.
     6  // +build ignore
     7  
     8  package gob
     9  
    10  // This file is not normally included in the gob package. Used only for debugging the package itself.
    11  // Except for reading uints, it is an implementation of a reader that is independent of
    12  // the one implemented by Decoder.
    13  // To enable the Debug function, delete the +build ignore line above and do
    14  //	go install
    15  
    16  import (
    17  	"bytes"
    18  	"fmt"
    19  	"io"
    20  	"os"
    21  	"strings"
    22  	"sync"
    23  )
    24  
    25  var dumpBytes = false // If true, print the remaining bytes in the input buffer at each item.
    26  
    27  // Init installs the debugging facility. If this file is not compiled in the
    28  // package, the tests in codec_test.go are no-ops.
    29  func init() {
    30  	debugFunc = Debug
    31  }
    32  
    33  var (
    34  	blanks = bytes.Repeat([]byte{' '}, 3*10)
    35  	empty  = []byte(": <empty>\n")
    36  	tabs   = strings.Repeat("\t", 100)
    37  )
    38  
    39  // tab indents itself when printed.
    40  type tab int
    41  
    42  func (t tab) String() string {
    43  	n := int(t)
    44  	if n > len(tabs) {
    45  		n = len(tabs)
    46  	}
    47  	return tabs[0:n]
    48  }
    49  
    50  func (t tab) print() {
    51  	fmt.Fprint(os.Stderr, t)
    52  }
    53  
    54  // A peekReader wraps an io.Reader, allowing one to peek ahead to see
    55  // what's coming without stealing the data from the client of the Reader.
    56  type peekReader struct {
    57  	r    io.Reader
    58  	data []byte // read-ahead data
    59  }
    60  
    61  // newPeekReader returns a peekReader that wraps r.
    62  func newPeekReader(r io.Reader) *peekReader {
    63  	return &peekReader{r: r}
    64  }
    65  
    66  // Read is the usual method. It will first take data that has been read ahead.
    67  func (p *peekReader) Read(b []byte) (n int, err error) {
    68  	if len(p.data) == 0 {
    69  		return p.r.Read(b)
    70  	}
    71  	// Satisfy what's possible from the read-ahead data.
    72  	n = copy(b, p.data)
    73  	// Move data down to beginning of slice, to avoid endless growth
    74  	copy(p.data, p.data[n:])
    75  	p.data = p.data[:len(p.data)-n]
    76  	return
    77  }
    78  
    79  // peek returns as many bytes as possible from the unread
    80  // portion of the stream, up to the length of b.
    81  func (p *peekReader) peek(b []byte) (n int, err error) {
    82  	if len(p.data) > 0 {
    83  		n = copy(b, p.data)
    84  		if n == len(b) {
    85  			return
    86  		}
    87  		b = b[n:]
    88  	}
    89  	if len(b) == 0 {
    90  		return
    91  	}
    92  	m, e := io.ReadFull(p.r, b)
    93  	if m > 0 {
    94  		p.data = append(p.data, b[:m]...)
    95  	}
    96  	n += m
    97  	if e == io.ErrUnexpectedEOF {
    98  		// That means m > 0 but we reached EOF. If we got data
    99  		// we won't complain about not being able to peek enough.
   100  		if n > 0 {
   101  			e = nil
   102  		} else {
   103  			e = io.EOF
   104  		}
   105  	}
   106  	return n, e
   107  }
   108  
   109  type debugger struct {
   110  	mutex          sync.Mutex
   111  	remain         int  // the number of bytes known to remain in the input
   112  	remainingKnown bool // the value of 'remain' is valid
   113  	r              *peekReader
   114  	wireType       map[typeId]*wireType
   115  	tmp            []byte // scratch space for decoding uints.
   116  }
   117  
   118  // dump prints the next nBytes of the input.
   119  // It arranges to print the output aligned from call to
   120  // call, to make it easy to see what has been consumed.
   121  func (deb *debugger) dump(format string, args ...interface{}) {
   122  	if !dumpBytes {
   123  		return
   124  	}
   125  	fmt.Fprintf(os.Stderr, format+" ", args...)
   126  	if !deb.remainingKnown {
   127  		return
   128  	}
   129  	if deb.remain < 0 {
   130  		fmt.Fprintf(os.Stderr, "remaining byte count is negative! %d\n", deb.remain)
   131  		return
   132  	}
   133  	data := make([]byte, deb.remain)
   134  	n, _ := deb.r.peek(data)
   135  	if n == 0 {
   136  		os.Stderr.Write(empty)
   137  		return
   138  	}
   139  	b := new(bytes.Buffer)
   140  	fmt.Fprintf(b, "[%d]{\n", deb.remain)
   141  	// Blanks until first byte
   142  	lineLength := 0
   143  	if n := len(data); n%10 != 0 {
   144  		lineLength = 10 - n%10
   145  		fmt.Fprintf(b, "\t%s", blanks[:lineLength*3])
   146  	}
   147  	// 10 bytes per line
   148  	for len(data) > 0 {
   149  		if lineLength == 0 {
   150  			fmt.Fprint(b, "\t")
   151  		}
   152  		m := 10 - lineLength
   153  		lineLength = 0
   154  		if m > len(data) {
   155  			m = len(data)
   156  		}
   157  		fmt.Fprintf(b, "% x\n", data[:m])
   158  		data = data[m:]
   159  	}
   160  	fmt.Fprint(b, "}\n")
   161  	os.Stderr.Write(b.Bytes())
   162  }
   163  
   164  // Debug prints a human-readable representation of the gob data read from r.
   165  // It is a no-op unless debugging was enabled when the package was built.
   166  func Debug(r io.Reader) {
   167  	err := debug(r)
   168  	if err != nil {
   169  		fmt.Fprintf(os.Stderr, "gob debug: %s\n", err)
   170  	}
   171  }
   172  
   173  // debug implements Debug, but catches panics and returns
   174  // them as errors to be printed by Debug.
   175  func debug(r io.Reader) (err error) {
   176  	defer catchError(&err)
   177  	fmt.Fprintln(os.Stderr, "Start of debugging")
   178  	deb := &debugger{
   179  		r:        newPeekReader(r),
   180  		wireType: make(map[typeId]*wireType),
   181  		tmp:      make([]byte, 16),
   182  	}
   183  	if b, ok := r.(*bytes.Buffer); ok {
   184  		deb.remain = b.Len()
   185  		deb.remainingKnown = true
   186  	}
   187  	deb.gobStream()
   188  	return
   189  }
   190  
   191  // note that we've consumed some bytes
   192  func (deb *debugger) consumed(n int) {
   193  	if deb.remainingKnown {
   194  		deb.remain -= n
   195  	}
   196  }
   197  
   198  // int64 decodes and returns the next integer, which must be present.
   199  // Don't call this if you could be at EOF.
   200  func (deb *debugger) int64() int64 {
   201  	return toInt(deb.uint64())
   202  }
   203  
   204  // uint64 returns and decodes the next unsigned integer, which must be present.
   205  // Don't call this if you could be at EOF.
   206  // TODO: handle errors better.
   207  func (deb *debugger) uint64() uint64 {
   208  	n, w, err := decodeUintReader(deb.r, deb.tmp)
   209  	if err != nil {
   210  		errorf("debug: read error: %s", err)
   211  	}
   212  	deb.consumed(w)
   213  	return n
   214  }
   215  
   216  // GobStream:
   217  //	DelimitedMessage* (until EOF)
   218  func (deb *debugger) gobStream() {
   219  	// Make sure we're single-threaded through here.
   220  	deb.mutex.Lock()
   221  	defer deb.mutex.Unlock()
   222  
   223  	for deb.delimitedMessage(0) {
   224  	}
   225  }
   226  
   227  // DelimitedMessage:
   228  //	uint(lengthOfMessage) Message
   229  func (deb *debugger) delimitedMessage(indent tab) bool {
   230  	for {
   231  		n := deb.loadBlock(true)
   232  		if n < 0 {
   233  			return false
   234  		}
   235  		deb.dump("Delimited message of length %d", n)
   236  		deb.message(indent)
   237  	}
   238  	return true
   239  }
   240  
   241  // loadBlock preps us to read a message
   242  // of the length specified next in the input. It returns
   243  // the length of the block. The argument tells whether
   244  // an EOF is acceptable now. If it is and one is found,
   245  // the return value is negative.
   246  func (deb *debugger) loadBlock(eofOK bool) int {
   247  	n64, w, err := decodeUintReader(deb.r, deb.tmp) // deb.uint64 will error at EOF
   248  	if err != nil {
   249  		if eofOK && err == io.EOF {
   250  			return -1
   251  		}
   252  		errorf("debug: unexpected error: %s", err)
   253  	}
   254  	deb.consumed(w)
   255  	n := int(n64)
   256  	if n < 0 {
   257  		errorf("huge value for message length: %d", n64)
   258  	}
   259  	return int(n)
   260  }
   261  
   262  // Message:
   263  //	TypeSequence TypedValue
   264  // TypeSequence
   265  //	(TypeDefinition DelimitedTypeDefinition*)?
   266  // DelimitedTypeDefinition:
   267  //	uint(lengthOfTypeDefinition) TypeDefinition
   268  // TypedValue:
   269  //	int(typeId) Value
   270  func (deb *debugger) message(indent tab) bool {
   271  	for {
   272  		// Convert the uint64 to a signed integer typeId
   273  		uid := deb.int64()
   274  		id := typeId(uid)
   275  		deb.dump("type id=%d", id)
   276  		if id < 0 {
   277  			deb.typeDefinition(indent, -id)
   278  			n := deb.loadBlock(false)
   279  			deb.dump("Message of length %d", n)
   280  			continue
   281  		} else {
   282  			deb.value(indent, id)
   283  			break
   284  		}
   285  	}
   286  	return true
   287  }
   288  
   289  // Helper methods to make it easy to scan a type descriptor.
   290  
   291  // common returns the CommonType at the input point.
   292  func (deb *debugger) common() CommonType {
   293  	fieldNum := -1
   294  	name := ""
   295  	id := typeId(0)
   296  	for {
   297  		delta := deb.delta(-1)
   298  		if delta == 0 {
   299  			break
   300  		}
   301  		fieldNum += delta
   302  		switch fieldNum {
   303  		case 0:
   304  			name = deb.string()
   305  		case 1:
   306  			// Id typeId
   307  			id = deb.typeId()
   308  		default:
   309  			errorf("corrupted CommonType, delta is %d fieldNum is %d", delta, fieldNum)
   310  		}
   311  	}
   312  	return CommonType{name, id}
   313  }
   314  
   315  // uint returns the unsigned int at the input point, as a uint (not uint64).
   316  func (deb *debugger) uint() uint {
   317  	return uint(deb.uint64())
   318  }
   319  
   320  // int returns the signed int at the input point, as an int (not int64).
   321  func (deb *debugger) int() int {
   322  	return int(deb.int64())
   323  }
   324  
   325  // typeId returns the type id at the input point.
   326  func (deb *debugger) typeId() typeId {
   327  	return typeId(deb.int64())
   328  }
   329  
   330  // string returns the string at the input point.
   331  func (deb *debugger) string() string {
   332  	x := int(deb.uint64())
   333  	b := make([]byte, x)
   334  	nb, _ := deb.r.Read(b)
   335  	if nb != x {
   336  		errorf("corrupted type")
   337  	}
   338  	deb.consumed(nb)
   339  	return string(b)
   340  }
   341  
   342  // delta returns the field delta at the input point. The expect argument,
   343  // if non-negative, identifies what the value should be.
   344  func (deb *debugger) delta(expect int) int {
   345  	delta := int(deb.uint64())
   346  	if delta < 0 || (expect >= 0 && delta != expect) {
   347  		errorf("decode: corrupted type: delta %d expected %d", delta, expect)
   348  	}
   349  	return delta
   350  }
   351  
   352  // TypeDefinition:
   353  //	[int(-typeId) (already read)] encodingOfWireType
   354  func (deb *debugger) typeDefinition(indent tab, id typeId) {
   355  	deb.dump("type definition for id %d", id)
   356  	// Encoding is of a wireType. Decode the structure as usual
   357  	fieldNum := -1
   358  	wire := new(wireType)
   359  	// A wireType defines a single field.
   360  	delta := deb.delta(-1)
   361  	fieldNum += delta
   362  	switch fieldNum {
   363  	case 0: // array type, one field of {{Common}, elem, length}
   364  		// Field number 0 is CommonType
   365  		deb.delta(1)
   366  		com := deb.common()
   367  		// Field number 1 is type Id of elem
   368  		deb.delta(1)
   369  		id := deb.typeId()
   370  		// Field number 3 is length
   371  		deb.delta(1)
   372  		length := deb.int()
   373  		wire.ArrayT = &arrayType{com, id, length}
   374  
   375  	case 1: // slice type, one field of {{Common}, elem}
   376  		// Field number 0 is CommonType
   377  		deb.delta(1)
   378  		com := deb.common()
   379  		// Field number 1 is type Id of elem
   380  		deb.delta(1)
   381  		id := deb.typeId()
   382  		wire.SliceT = &sliceType{com, id}
   383  
   384  	case 2: // struct type, one field of {{Common}, []fieldType}
   385  		// Field number 0 is CommonType
   386  		deb.delta(1)
   387  		com := deb.common()
   388  		// Field number 1 is slice of FieldType
   389  		deb.delta(1)
   390  		numField := int(deb.uint())
   391  		field := make([]*fieldType, numField)
   392  		for i := 0; i < numField; i++ {
   393  			field[i] = new(fieldType)
   394  			deb.delta(1) // field 0 of fieldType: name
   395  			field[i].Name = deb.string()
   396  			deb.delta(1) // field 1 of fieldType: id
   397  			field[i].Id = deb.typeId()
   398  			deb.delta(0) // end of fieldType
   399  		}
   400  		wire.StructT = &structType{com, field}
   401  
   402  	case 3: // map type, one field of {{Common}, key, elem}
   403  		// Field number 0 is CommonType
   404  		deb.delta(1)
   405  		com := deb.common()
   406  		// Field number 1 is type Id of key
   407  		deb.delta(1)
   408  		keyId := deb.typeId()
   409  		// Field number 2 is type Id of elem
   410  		deb.delta(1)
   411  		elemId := deb.typeId()
   412  		wire.MapT = &mapType{com, keyId, elemId}
   413  	case 4: // GobEncoder type, one field of {{Common}}
   414  		// Field number 0 is CommonType
   415  		deb.delta(1)
   416  		com := deb.common()
   417  		wire.GobEncoderT = &gobEncoderType{com}
   418  	case 5: // BinaryMarshaler type, one field of {{Common}}
   419  		// Field number 0 is CommonType
   420  		deb.delta(1)
   421  		com := deb.common()
   422  		wire.BinaryMarshalerT = &gobEncoderType{com}
   423  	case 6: // TextMarshaler type, one field of {{Common}}
   424  		// Field number 0 is CommonType
   425  		deb.delta(1)
   426  		com := deb.common()
   427  		wire.TextMarshalerT = &gobEncoderType{com}
   428  	default:
   429  		errorf("bad field in type %d", fieldNum)
   430  	}
   431  	deb.printWireType(indent, wire)
   432  	deb.delta(0) // end inner type (arrayType, etc.)
   433  	deb.delta(0) // end wireType
   434  	// Remember we've seen this type.
   435  	deb.wireType[id] = wire
   436  }
   437  
   438  // Value:
   439  //	SingletonValue | StructValue
   440  func (deb *debugger) value(indent tab, id typeId) {
   441  	wire, ok := deb.wireType[id]
   442  	if ok && wire.StructT != nil {
   443  		deb.structValue(indent, id)
   444  	} else {
   445  		deb.singletonValue(indent, id)
   446  	}
   447  }
   448  
   449  // SingletonValue:
   450  //	uint(0) FieldValue
   451  func (deb *debugger) singletonValue(indent tab, id typeId) {
   452  	deb.dump("Singleton value")
   453  	// is it a builtin type?
   454  	wire := deb.wireType[id]
   455  	_, ok := builtinIdToType[id]
   456  	if !ok && wire == nil {
   457  		errorf("type id %d not defined", id)
   458  	}
   459  	m := deb.uint64()
   460  	if m != 0 {
   461  		errorf("expected zero; got %d", m)
   462  	}
   463  	deb.fieldValue(indent, id)
   464  }
   465  
   466  // InterfaceValue:
   467  //	NilInterfaceValue | NonNilInterfaceValue
   468  func (deb *debugger) interfaceValue(indent tab) {
   469  	deb.dump("Start of interface value")
   470  	if nameLen := deb.uint64(); nameLen == 0 {
   471  		deb.nilInterfaceValue(indent)
   472  	} else {
   473  		deb.nonNilInterfaceValue(indent, int(nameLen))
   474  	}
   475  }
   476  
   477  // NilInterfaceValue:
   478  //	uint(0) [already read]
   479  func (deb *debugger) nilInterfaceValue(indent tab) int {
   480  	fmt.Fprintf(os.Stderr, "%snil interface\n", indent)
   481  	return 0
   482  }
   483  
   484  // NonNilInterfaceValue:
   485  //	ConcreteTypeName TypeSequence InterfaceContents
   486  // ConcreteTypeName:
   487  //	uint(lengthOfName) [already read=n] name
   488  // InterfaceContents:
   489  //	int(concreteTypeId) DelimitedValue
   490  // DelimitedValue:
   491  //	uint(length) Value
   492  func (deb *debugger) nonNilInterfaceValue(indent tab, nameLen int) {
   493  	// ConcreteTypeName
   494  	b := make([]byte, nameLen)
   495  	deb.r.Read(b) // TODO: CHECK THESE READS!!
   496  	deb.consumed(nameLen)
   497  	name := string(b)
   498  
   499  	for {
   500  		id := deb.typeId()
   501  		if id < 0 {
   502  			deb.typeDefinition(indent, -id)
   503  			n := deb.loadBlock(false)
   504  			deb.dump("Nested message of length %d", n)
   505  		} else {
   506  			// DelimitedValue
   507  			x := deb.uint64() // in case we want to ignore the value; we don't.
   508  			fmt.Fprintf(os.Stderr, "%sinterface value, type %q id=%d; valueLength %d\n", indent, name, id, x)
   509  			deb.value(indent, id)
   510  			break
   511  		}
   512  	}
   513  }
   514  
   515  // printCommonType prints a common type; used by printWireType.
   516  func (deb *debugger) printCommonType(indent tab, kind string, common *CommonType) {
   517  	indent.print()
   518  	fmt.Fprintf(os.Stderr, "%s %q id=%d\n", kind, common.Name, common.Id)
   519  }
   520  
   521  // printWireType prints the contents of a wireType.
   522  func (deb *debugger) printWireType(indent tab, wire *wireType) {
   523  	fmt.Fprintf(os.Stderr, "%stype definition {\n", indent)
   524  	indent++
   525  	switch {
   526  	case wire.ArrayT != nil:
   527  		deb.printCommonType(indent, "array", &wire.ArrayT.CommonType)
   528  		fmt.Fprintf(os.Stderr, "%slen %d\n", indent+1, wire.ArrayT.Len)
   529  		fmt.Fprintf(os.Stderr, "%selemid %d\n", indent+1, wire.ArrayT.Elem)
   530  	case wire.MapT != nil:
   531  		deb.printCommonType(indent, "map", &wire.MapT.CommonType)
   532  		fmt.Fprintf(os.Stderr, "%skey id=%d\n", indent+1, wire.MapT.Key)
   533  		fmt.Fprintf(os.Stderr, "%selem id=%d\n", indent+1, wire.MapT.Elem)
   534  	case wire.SliceT != nil:
   535  		deb.printCommonType(indent, "slice", &wire.SliceT.CommonType)
   536  		fmt.Fprintf(os.Stderr, "%selem id=%d\n", indent+1, wire.SliceT.Elem)
   537  	case wire.StructT != nil:
   538  		deb.printCommonType(indent, "struct", &wire.StructT.CommonType)
   539  		for i, field := range wire.StructT.Field {
   540  			fmt.Fprintf(os.Stderr, "%sfield %d:\t%s\tid=%d\n", indent+1, i, field.Name, field.Id)
   541  		}
   542  	case wire.GobEncoderT != nil:
   543  		deb.printCommonType(indent, "GobEncoder", &wire.GobEncoderT.CommonType)
   544  	}
   545  	indent--
   546  	fmt.Fprintf(os.Stderr, "%s}\n", indent)
   547  }
   548  
   549  // fieldValue prints a value of any type, such as a struct field.
   550  // FieldValue:
   551  //	builtinValue | ArrayValue | MapValue | SliceValue | StructValue | InterfaceValue
   552  func (deb *debugger) fieldValue(indent tab, id typeId) {
   553  	_, ok := builtinIdToType[id]
   554  	if ok {
   555  		if id == tInterface {
   556  			deb.interfaceValue(indent)
   557  		} else {
   558  			deb.printBuiltin(indent, id)
   559  		}
   560  		return
   561  	}
   562  	wire, ok := deb.wireType[id]
   563  	if !ok {
   564  		errorf("type id %d not defined", id)
   565  	}
   566  	switch {
   567  	case wire.ArrayT != nil:
   568  		deb.arrayValue(indent, wire)
   569  	case wire.MapT != nil:
   570  		deb.mapValue(indent, wire)
   571  	case wire.SliceT != nil:
   572  		deb.sliceValue(indent, wire)
   573  	case wire.StructT != nil:
   574  		deb.structValue(indent, id)
   575  	case wire.GobEncoderT != nil:
   576  		deb.gobEncoderValue(indent, id)
   577  	default:
   578  		panic("bad wire type for field")
   579  	}
   580  }
   581  
   582  // printBuiltin prints a value not of a fundamental type, that is,
   583  // one whose type is known to gobs at bootstrap time.
   584  func (deb *debugger) printBuiltin(indent tab, id typeId) {
   585  	switch id {
   586  	case tBool:
   587  		x := deb.int64()
   588  		if x == 0 {
   589  			fmt.Fprintf(os.Stderr, "%sfalse\n", indent)
   590  		} else {
   591  			fmt.Fprintf(os.Stderr, "%strue\n", indent)
   592  		}
   593  	case tInt:
   594  		x := deb.int64()
   595  		fmt.Fprintf(os.Stderr, "%s%d\n", indent, x)
   596  	case tUint:
   597  		x := deb.uint64()
   598  		fmt.Fprintf(os.Stderr, "%s%d\n", indent, x)
   599  	case tFloat:
   600  		x := deb.uint64()
   601  		fmt.Fprintf(os.Stderr, "%s%g\n", indent, float64FromBits(x))
   602  	case tComplex:
   603  		r := deb.uint64()
   604  		i := deb.uint64()
   605  		fmt.Fprintf(os.Stderr, "%s%g+%gi\n", indent, float64FromBits(r), float64FromBits(i))
   606  	case tBytes:
   607  		x := int(deb.uint64())
   608  		b := make([]byte, x)
   609  		deb.r.Read(b)
   610  		deb.consumed(x)
   611  		fmt.Fprintf(os.Stderr, "%s{% x}=%q\n", indent, b, b)
   612  	case tString:
   613  		x := int(deb.uint64())
   614  		b := make([]byte, x)
   615  		deb.r.Read(b)
   616  		deb.consumed(x)
   617  		fmt.Fprintf(os.Stderr, "%s%q\n", indent, b)
   618  	default:
   619  		panic("unknown builtin")
   620  	}
   621  }
   622  
   623  // ArrayValue:
   624  //	uint(n) FieldValue*n
   625  func (deb *debugger) arrayValue(indent tab, wire *wireType) {
   626  	elemId := wire.ArrayT.Elem
   627  	u := deb.uint64()
   628  	length := int(u)
   629  	for i := 0; i < length; i++ {
   630  		deb.fieldValue(indent, elemId)
   631  	}
   632  	if length != wire.ArrayT.Len {
   633  		fmt.Fprintf(os.Stderr, "%s(wrong length for array: %d should be %d)\n", indent, length, wire.ArrayT.Len)
   634  	}
   635  }
   636  
   637  // MapValue:
   638  //	uint(n) (FieldValue FieldValue)*n  [n (key, value) pairs]
   639  func (deb *debugger) mapValue(indent tab, wire *wireType) {
   640  	keyId := wire.MapT.Key
   641  	elemId := wire.MapT.Elem
   642  	u := deb.uint64()
   643  	length := int(u)
   644  	for i := 0; i < length; i++ {
   645  		deb.fieldValue(indent+1, keyId)
   646  		deb.fieldValue(indent+1, elemId)
   647  	}
   648  }
   649  
   650  // SliceValue:
   651  //	uint(n) (n FieldValue)
   652  func (deb *debugger) sliceValue(indent tab, wire *wireType) {
   653  	elemId := wire.SliceT.Elem
   654  	u := deb.uint64()
   655  	length := int(u)
   656  	deb.dump("Start of slice of length %d", length)
   657  
   658  	for i := 0; i < length; i++ {
   659  		deb.fieldValue(indent, elemId)
   660  	}
   661  }
   662  
   663  // StructValue:
   664  //	(uint(fieldDelta) FieldValue)*
   665  func (deb *debugger) structValue(indent tab, id typeId) {
   666  	deb.dump("Start of struct value of %q id=%d\n<<\n", id.name(), id)
   667  	fmt.Fprintf(os.Stderr, "%s%s struct {\n", indent, id.name())
   668  	wire, ok := deb.wireType[id]
   669  	if !ok {
   670  		errorf("type id %d not defined", id)
   671  	}
   672  	strct := wire.StructT
   673  	fieldNum := -1
   674  	indent++
   675  	for {
   676  		delta := deb.uint64()
   677  		if delta == 0 { // struct terminator is zero delta fieldnum
   678  			break
   679  		}
   680  		fieldNum += int(delta)
   681  		if fieldNum < 0 || fieldNum >= len(strct.Field) {
   682  			deb.dump("field number out of range: prevField=%d delta=%d", fieldNum-int(delta), delta)
   683  			break
   684  		}
   685  		fmt.Fprintf(os.Stderr, "%sfield %d:\t%s\n", indent, fieldNum, wire.StructT.Field[fieldNum].Name)
   686  		deb.fieldValue(indent+1, strct.Field[fieldNum].Id)
   687  	}
   688  	indent--
   689  	fmt.Fprintf(os.Stderr, "%s} // end %s struct\n", indent, id.name())
   690  	deb.dump(">> End of struct value of type %d %q", id, id.name())
   691  }
   692  
   693  // GobEncoderValue:
   694  //	uint(n) byte*n
   695  func (deb *debugger) gobEncoderValue(indent tab, id typeId) {
   696  	len := deb.uint64()
   697  	deb.dump("GobEncoder value of %q id=%d, length %d\n", id.name(), id, len)
   698  	fmt.Fprintf(os.Stderr, "%s%s (implements GobEncoder)\n", indent, id.name())
   699  	data := make([]byte, len)
   700  	_, err := deb.r.Read(data)
   701  	if err != nil {
   702  		errorf("gobEncoder data read: %s", err)
   703  	}
   704  	fmt.Fprintf(os.Stderr, "%s[% .2x]\n", indent+1, data)
   705  }
   706  

View as plain text