cmd/go-cloud-debug-agent/internal/valuecollector/valuecollector.go - gocloud - Git at Google

 // Copyright 2016 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 // Package valuecollector is used to collect the values of variables in a program.
 package valuecollector

 import (
 	"bytes"
 	"fmt"
 	"strconv"
 	"strings"

 	"cloud.google.com/go/cmd/go-cloud-debug-agent/internal/debug"
 	cd "google.golang.org/api/clouddebugger/v2"
 )

 const (
 	maxArrayLength = 50
 	maxMapLength   = 20
 )

 // Collector is given references to variables from a program being debugged
 // using AddVariable. Then when ReadValues is called, the Collector will fetch
 // the values of those variables. Any variables referred to by those values
 // will also be fetched; e.g. the targets of pointers, members of structs,
 // elements of slices, etc. This continues iteratively, building a graph of
 // values, until all the reachable values are fetched, or a size limit is
 // reached.
 //
 // Variables are passed to the Collector as debug.Var, which is used by x/debug
 // to represent references to variables. Values are returned as cd.Variable,
 // which is used by the Debuglet Controller to represent the graph of values.
 //
 // For example, if the program has a struct variable:
 //
 //	foo := SomeStruct{a:42, b:"xyz"}
 //
 // and we call AddVariable with a reference to foo, we will get back a result
 // like:
 //
 //	cd.Variable{Name:"foo", VarTableIndex:10}
 //
 // which denotes a variable named "foo" which will have its value stored in
 // element 10 of the table that will later be returned by ReadValues. That
 // element might be:
 //
 //	out[10] = &cd.Variable{Members:{{Name:"a", VarTableIndex:11},{Name:"b", VarTableIndex:12}}}
 //
 // which denotes a struct with two members a and b, whose values are in elements
 // 11 and 12 of the output table:
 //
 //	out[11] = &cd.Variable{Value:"42"}
 //	out[12] = &cd.Variable{Value:"xyz"}
 type Collector struct {
 	// prog is the program being debugged.
 	prog debug.Program
 	// limit is the maximum size of the output slice of values.
 	limit int
 	// index is a map from references (variables and map elements) to their
 	// locations in the table.
 	index map[reference]int
 	// table contains the references, including those given to the
 	// Collector directly and those the Collector itself found.
 	// If VarTableIndex is set to 0 in a cd.Variable, it is ignored, so the first entry
 	// of table can't be used. On initialization we put a dummy value there.
 	table []reference
 }

 // reference represents a value which is in the queue to be read by the
 // collector.  It is either a debug.Var, or a mapElement.
 type reference interface{}

 // mapElement represents an element of a map in the debugged program's memory.
 type mapElement struct {
 	debug.Map
 	index uint64
 }

 // NewCollector returns a Collector for the given program and size limit.
 // The limit is the maximum size of the slice of values returned by ReadValues.
 func NewCollector(prog debug.Program, limit int) *Collector {
 	return &Collector{
 		prog:  prog,
 		limit: limit,
 		index: make(map[reference]int),
 		table: []reference{debug.Var{}},
 	}
 }

 // AddVariable adds another variable to be collected.
 // The Collector doesn't get the value immediately; it returns a cd.Variable
 // that contains an index into the table which will later be returned by
 // ReadValues.
 func (c *Collector) AddVariable(lv debug.LocalVar) *cd.Variable {
 	ret := &cd.Variable{Name: lv.Name}
 	if index, ok := c.add(lv.Var); !ok {
 		// If the add call failed, it's because we reached the size limit.
 		// The Debuglet Controller's convention is to pass it a "Not Captured" error
 		// in this case.
 		ret.Status = statusMessage(messageNotCaptured, true, refersToVariableName)
 	} else {
 		ret.VarTableIndex = int64(index)
 	}
 	return ret
 }

 // add adds a reference to the set of values to be read from the
 // program. It returns the index in the output table that will contain the
 // corresponding value. It fails if the table has reached the size limit.
 // It deduplicates references, so the index may be the same as one that was
 // returned from an earlier add call.
 func (c *Collector) add(r reference) (outputIndex int, ok bool) {
 	if i, ok := c.index[r]; ok {
 		return i, true
 	}
 	i := len(c.table)
 	if i >= c.limit {
 		return 0, false
 	}
 	c.index[r] = i
 	c.table = append(c.table, r)
 	return i, true
 }

 func addMember(v *cd.Variable, name string) *cd.Variable {
 	v2 := &cd.Variable{Name: name}
 	v.Members = append(v.Members, v2)
 	return v2
 }

 // ReadValues fetches values of the variables that were passed to the Collector
 // with AddVariable. The values of any new variables found are also fetched,
 // e.g. the targets of pointers or the members of structs, until we reach the
 // size limit or we run out of values to fetch.
 // The results are output as a []*cd.Variable, which is the type we need to send
 // to the Debuglet Controller after we trigger a breakpoint.
 func (c *Collector) ReadValues() (out []*cd.Variable) {
 	for i := 0; i < len(c.table); i++ {
 		// Create a new cd.Variable for this value, and append it to the output.
 		dcv := new(cd.Variable)
 		out = append(out, dcv)
 		if i == 0 {
 			// The first element is unused.
 			continue
 		}
 		switch x := c.table[i].(type) {
 		case mapElement:
 			key, value, err := c.prog.MapElement(x.Map, x.index)
 			if err != nil {
 				dcv.Status = statusMessage(err.Error(), true, refersToVariableValue)
 				continue
 			}
 			// Add a member for the key.
 			member := addMember(dcv, "key")
 			if index, ok := c.add(key); !ok {
 				// The table is full.
 				member.Status = statusMessage(messageNotCaptured, true, refersToVariableName)
 				continue
 			} else {
 				member.VarTableIndex = int64(index)
 			}
 			// Add a member for the value.
 			member = addMember(dcv, "value")
 			if index, ok := c.add(value); !ok {
 				// The table is full.
 				member.Status = statusMessage(messageNotCaptured, true, refersToVariableName)
 			} else {
 				member.VarTableIndex = int64(index)
 			}
 		case debug.Var:
 			if v, err := c.prog.Value(x); err != nil {
 				dcv.Status = statusMessage(err.Error(), true, refersToVariableValue)
 			} else {
 				c.FillValue(v, dcv)
 			}
 		}
 	}
 	return out
 }

 // indexable is an interface for arrays, slices and channels.
 type indexable interface {
 	Len() uint64
 	Element(uint64) debug.Var
 }

 // channel implements indexable.
 type channel struct {
 	debug.Channel
 }

 func (c channel) Len() uint64 {
 	return c.Length
 }

 var (
 	_ indexable = debug.Array{}
 	_ indexable = debug.Slice{}
 	_ indexable = channel{}
 )

 // FillValue copies a value into a cd.Variable.  Any variables referred to by
 // that value, e.g. struct members and pointer targets, are added to the
 // collector's queue, to be fetched later by ReadValues.
 func (c *Collector) FillValue(v debug.Value, dcv *cd.Variable) {
 	if c, ok := v.(debug.Channel); ok {
 		// Convert to channel, which implements indexable.
 		v = channel{c}
 	}
 	// Fill in dcv in a manner depending on the type of the value we got.
 	switch val := v.(type) {
 	case int8, int16, int32, int64, bool, uint8, uint16, uint32, uint64, float32, float64, complex64, complex128:
 		// For simple types, we just print the value to dcv.Value.
 		dcv.Value = fmt.Sprint(val)
 	case string:
 		// Put double quotes around strings.
 		dcv.Value = strconv.Quote(val)
 	case debug.String:
 		if uint64(len(val.String)) < val.Length {
 			// This string value was truncated.
 			dcv.Value = strconv.Quote(val.String + "...")
 		} else {
 			dcv.Value = strconv.Quote(val.String)
 		}
 	case debug.Struct:
 		// For structs, we add an entry to dcv.Members for each field in the
 		// struct.
 		// Each member will contain the name of the field, and the index in the
 		// output table which will contain the value of that field.
 		for _, f := range val.Fields {
 			member := addMember(dcv, f.Name)
 			if index, ok := c.add(f.Var); !ok {
 				// The table is full.
 				member.Status = statusMessage(messageNotCaptured, true, refersToVariableName)
 			} else {
 				member.VarTableIndex = int64(index)
 			}
 		}
 	case debug.Map:
 		dcv.Value = fmt.Sprintf("len = %d", val.Length)
 		for i := uint64(0); i < val.Length; i++ {
 			field := addMember(dcv, `⚫`)
 			if i == maxMapLength {
 				field.Name = "..."
 				field.Status = statusMessage(messageTruncated, true, refersToVariableName)
 				break
 			}
 			if index, ok := c.add(mapElement{val, i}); !ok {
 				// The value table is full; add a member to contain the error message.
 				field.Name = "..."
 				field.Status = statusMessage(messageNotCaptured, true, refersToVariableName)
 				break
 			} else {
 				field.VarTableIndex = int64(index)
 			}
 		}
 	case debug.Pointer:
 		if val.Address == 0 {
 			dcv.Value = "<nil>"
 		} else if val.TypeID == 0 {
 			// We don't know the type of the pointer, so just output the address as
 			// the value.
 			dcv.Value = fmt.Sprintf("0x%X", val.Address)
 			dcv.Status = statusMessage(messageUnknownPointerType, false, refersToVariableName)
 		} else {
 			// Adds the pointed-to variable to the table, and links this value to
 			// that table entry through VarTableIndex.
 			dcv.Value = fmt.Sprintf("0x%X", val.Address)
 			target := addMember(dcv, "")
 			if index, ok := c.add(debug.Var(val)); !ok {
 				target.Status = statusMessage(messageNotCaptured, true, refersToVariableName)
 			} else {
 				target.VarTableIndex = int64(index)
 			}
 		}
 	case indexable:
 		// Arrays, slices and channels.
 		dcv.Value = "len = " + fmt.Sprint(val.Len())
 		for j := uint64(0); j < val.Len(); j++ {
 			field := addMember(dcv, fmt.Sprint(`[`, j, `]`))
 			if j == maxArrayLength {
 				field.Name = "..."
 				field.Status = statusMessage(messageTruncated, true, refersToVariableName)
 				break
 			}
 			vr := val.Element(j)
 			if index, ok := c.add(vr); !ok {
 				// The value table is full; add a member to contain the error message.
 				field.Name = "..."
 				field.Status = statusMessage(messageNotCaptured, true, refersToVariableName)
 				break
 			} else {
 				// Add a member with the index as the name.
 				field.VarTableIndex = int64(index)
 			}
 		}
 	default:
 		dcv.Status = statusMessage(messageUnknownType, false, refersToVariableName)
 	}
 }

 // statusMessage returns a *cd.StatusMessage with the given message, IsError
 // field and refersTo field.
 func statusMessage(msg string, isError bool, refersTo int) *cd.StatusMessage {
 	return &cd.StatusMessage{
 		Description: &cd.FormatMessage{Format: "$0", Parameters: []string{msg}},
 		IsError:     isError,
 		RefersTo:    refersToString[refersTo],
 	}
 }

 // LogString produces a string for a logpoint, substituting in variable values
 // using evaluatedExpressions and varTable.
 func LogString(s string, evaluatedExpressions []*cd.Variable, varTable []*cd.Variable) string {
 	var buf bytes.Buffer
 	fmt.Fprintf(&buf, "LOGPOINT: ")
 	seen := make(map[*cd.Variable]bool)
 	for i := 0; i < len(s); {
 		if s[i] == '$' {
 			i++
 			if num, n, ok := parseToken(s[i:], len(evaluatedExpressions)-1); ok {
 				// This token is one of $0, $1, etc.  Write the corresponding expression.
 				writeExpression(&buf, evaluatedExpressions[num], false, varTable, seen)
 				i += n
 			} else {
 				// Something else, like $$.
 				buf.WriteByte(s[i])
 				i++
 			}
 		} else {
 			buf.WriteByte(s[i])
 			i++
 		}
 	}
 	return buf.String()
 }

 func parseToken(s string, max int) (num int, bytesRead int, ok bool) {
 	var i int
 	for i < len(s) && s[i] >= '0' && s[i] <= '9' {
 		i++
 	}
 	num, err := strconv.Atoi(s[:i])
 	return num, i, err == nil && num <= max
 }

 // writeExpression recursively writes variables to buf, in a format suitable
 // for logging.  If printName is true, writes the name of the variable.
 func writeExpression(buf *bytes.Buffer, v *cd.Variable, printName bool, varTable []*cd.Variable, seen map[*cd.Variable]bool) {
 	if v == nil {
 		// Shouldn't happen.
 		return
 	}
 	name, value, status, members := v.Name, v.Value, v.Status, v.Members

 	// If v.VarTableIndex is not zero, it refers to an element of varTable.
 	// We merge its fields with the fields we got from v.
 	var other *cd.Variable
 	if idx := int(v.VarTableIndex); idx > 0 && idx < len(varTable) {
 		other = varTable[idx]
 	}
 	if other != nil {
 		if name == "" {
 			name = other.Name
 		}
 		if value == "" {
 			value = other.Value
 		}
 		if status == nil {
 			status = other.Status
 		}
 		if len(members) == 0 {
 			members = other.Members
 		}
 	}
 	if printName && name != "" {
 		buf.WriteString(name)
 		buf.WriteByte(':')
 	}

 	// If we have seen this value before, write "..." rather than repeating it.
 	if seen[v] {
 		buf.WriteString("...")
 		return
 	}
 	seen[v] = true
 	if other != nil {
 		if seen[other] {
 			buf.WriteString("...")
 			return
 		}
 		seen[other] = true
 	}

 	if value != "" && !strings.HasPrefix(value, "len = ") {
 		// A plain value.
 		buf.WriteString(value)
 	} else if status != nil && status.Description != nil {
 		// An error.
 		for _, p := range status.Description.Parameters {
 			buf.WriteByte('(')
 			buf.WriteString(p)
 			buf.WriteByte(')')
 		}
 	} else if name == `⚫` {
 		// A map element.
 		first := true
 		for _, member := range members {
 			if first {
 				first = false
 			} else {
 				buf.WriteByte(':')
 			}
 			writeExpression(buf, member, false, varTable, seen)
 		}
 	} else {
 		// A map, array, slice, channel, or struct.
 		isStruct := value == ""
 		first := true
 		buf.WriteByte('{')
 		for _, member := range members {
 			if first {
 				first = false
 			} else {
 				buf.WriteString(", ")
 			}
 			writeExpression(buf, member, isStruct, varTable, seen)
 		}
 		buf.WriteByte('}')
 	}
 }

 const (
 	// Error messages for cd.StatusMessage
 	messageNotCaptured        = "Not captured"
 	messageTruncated          = "Truncated"
 	messageUnknownPointerType = "Unknown pointer type"
 	messageUnknownType        = "Unknown type"
 	// RefersTo values for cd.StatusMessage.
 	refersToVariableName = iota
 	refersToVariableValue
 )

 // refersToString contains the strings for each refersTo value.
 // See the definition of StatusMessage in the v2/clouddebugger package.
 var refersToString = map[int]string{
 	refersToVariableName:  "VARIABLE_NAME",
 	refersToVariableValue: "VARIABLE_VALUE",
 }
	// Copyright 2016 Google LLC
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	// Package valuecollector is used to collect the values of variables in a program.
	package valuecollector

	import (
	"bytes"
	"fmt"
	"strconv"
	"strings"

	"cloud.google.com/go/cmd/go-cloud-debug-agent/internal/debug"
	cd "google.golang.org/api/clouddebugger/v2"
	)

	const (
	maxArrayLength = 50
	maxMapLength = 20
	)

	// Collector is given references to variables from a program being debugged
	// using AddVariable. Then when ReadValues is called, the Collector will fetch
	// the values of those variables. Any variables referred to by those values
	// will also be fetched; e.g. the targets of pointers, members of structs,
	// elements of slices, etc. This continues iteratively, building a graph of
	// values, until all the reachable values are fetched, or a size limit is
	// reached.
	//
	// Variables are passed to the Collector as debug.Var, which is used by x/debug
	// to represent references to variables. Values are returned as cd.Variable,
	// which is used by the Debuglet Controller to represent the graph of values.
	//
	// For example, if the program has a struct variable:
	//
	// foo := SomeStruct{a:42, b:"xyz"}
	//
	// and we call AddVariable with a reference to foo, we will get back a result
	// like:
	//
	// cd.Variable{Name:"foo", VarTableIndex:10}
	//
	// which denotes a variable named "foo" which will have its value stored in
	// element 10 of the table that will later be returned by ReadValues. That
	// element might be:
	//
	// out[10] = &cd.Variable{Members:{{Name:"a", VarTableIndex:11},{Name:"b", VarTableIndex:12}}}
	//
	// which denotes a struct with two members a and b, whose values are in elements
	// 11 and 12 of the output table:
	//
	// out[11] = &cd.Variable{Value:"42"}
	// out[12] = &cd.Variable{Value:"xyz"}
	type Collector struct {
	// prog is the program being debugged.
	prog debug.Program
	// limit is the maximum size of the output slice of values.
	limit int
	// index is a map from references (variables and map elements) to their
	// locations in the table.
	index map[reference]int
	// table contains the references, including those given to the
	// Collector directly and those the Collector itself found.
	// If VarTableIndex is set to 0 in a cd.Variable, it is ignored, so the first entry
	// of table can't be used. On initialization we put a dummy value there.
	table []reference
	}

	// reference represents a value which is in the queue to be read by the
	// collector. It is either a debug.Var, or a mapElement.
	type reference interface{}

	// mapElement represents an element of a map in the debugged program's memory.
	type mapElement struct {
	debug.Map
	index uint64
	}

	// NewCollector returns a Collector for the given program and size limit.
	// The limit is the maximum size of the slice of values returned by ReadValues.
	func NewCollector(prog debug.Program, limit int) *Collector {
	return &Collector{
	prog: prog,
	limit: limit,
	index: make(map[reference]int),
	table: []reference{debug.Var{}},
	}
	}

	// AddVariable adds another variable to be collected.
	// The Collector doesn't get the value immediately; it returns a cd.Variable
	// that contains an index into the table which will later be returned by
	// ReadValues.
	func (c Collector) AddVariable(lv debug.LocalVar) cd.Variable {
	ret := &cd.Variable{Name: lv.Name}
	if index, ok := c.add(lv.Var); !ok {
	// If the add call failed, it's because we reached the size limit.
	// The Debuglet Controller's convention is to pass it a "Not Captured" error
	// in this case.
	ret.Status = statusMessage(messageNotCaptured, true, refersToVariableName)
	} else {
	ret.VarTableIndex = int64(index)
	}
	return ret
	}

	// add adds a reference to the set of values to be read from the
	// program. It returns the index in the output table that will contain the
	// corresponding value. It fails if the table has reached the size limit.
	// It deduplicates references, so the index may be the same as one that was
	// returned from an earlier add call.
	func (c *Collector) add(r reference) (outputIndex int, ok bool) {
	if i, ok := c.index[r]; ok {
	return i, true
	}
	i := len(c.table)
	if i >= c.limit {
	return 0, false
	}
	c.index[r] = i
	c.table = append(c.table, r)
	return i, true
	}

	func addMember(v cd.Variable, name string) cd.Variable {
	v2 := &cd.Variable{Name: name}
	v.Members = append(v.Members, v2)
	return v2
	}

	// ReadValues fetches values of the variables that were passed to the Collector
	// with AddVariable. The values of any new variables found are also fetched,
	// e.g. the targets of pointers or the members of structs, until we reach the
	// size limit or we run out of values to fetch.
	// The results are output as a []*cd.Variable, which is the type we need to send
	// to the Debuglet Controller after we trigger a breakpoint.
	func (c Collector) ReadValues() (out []cd.Variable) {
	for i := 0; i < len(c.table); i++ {
	// Create a new cd.Variable for this value, and append it to the output.
	dcv := new(cd.Variable)
	out = append(out, dcv)
	if i == 0 {
	// The first element is unused.
	continue
	}
	switch x := c.table[i].(type) {
	case mapElement:
	key, value, err := c.prog.MapElement(x.Map, x.index)
	if err != nil {
	dcv.Status = statusMessage(err.Error(), true, refersToVariableValue)
	continue
	}
	// Add a member for the key.
	member := addMember(dcv, "key")
	if index, ok := c.add(key); !ok {
	// The table is full.
	member.Status = statusMessage(messageNotCaptured, true, refersToVariableName)
	continue
	} else {
	member.VarTableIndex = int64(index)
	}
	// Add a member for the value.
	member = addMember(dcv, "value")
	if index, ok := c.add(value); !ok {
	// The table is full.
	member.Status = statusMessage(messageNotCaptured, true, refersToVariableName)
	} else {
	member.VarTableIndex = int64(index)
	}
	case debug.Var:
	if v, err := c.prog.Value(x); err != nil {
	dcv.Status = statusMessage(err.Error(), true, refersToVariableValue)
	} else {
	c.FillValue(v, dcv)
	}
	}
	}
	return out
	}

	// indexable is an interface for arrays, slices and channels.
	type indexable interface {
	Len() uint64
	Element(uint64) debug.Var
	}

	// channel implements indexable.
	type channel struct {
	debug.Channel
	}

	func (c channel) Len() uint64 {
	return c.Length
	}

	var (
	_ indexable = debug.Array{}
	_ indexable = debug.Slice{}
	_ indexable = channel{}
	)

	// FillValue copies a value into a cd.Variable. Any variables referred to by
	// that value, e.g. struct members and pointer targets, are added to the
	// collector's queue, to be fetched later by ReadValues.
	func (c Collector) FillValue(v debug.Value, dcv cd.Variable) {
	if c, ok := v.(debug.Channel); ok {
	// Convert to channel, which implements indexable.
	v = channel{c}
	}
	// Fill in dcv in a manner depending on the type of the value we got.
	switch val := v.(type) {
	case int8, int16, int32, int64, bool, uint8, uint16, uint32, uint64, float32, float64, complex64, complex128:
	// For simple types, we just print the value to dcv.Value.
	dcv.Value = fmt.Sprint(val)
	case string:
	// Put double quotes around strings.
	dcv.Value = strconv.Quote(val)
	case debug.String:
	if uint64(len(val.String)) < val.Length {
	// This string value was truncated.
	dcv.Value = strconv.Quote(val.String + "...")
	} else {
	dcv.Value = strconv.Quote(val.String)
	}
	case debug.Struct:
	// For structs, we add an entry to dcv.Members for each field in the
	// struct.
	// Each member will contain the name of the field, and the index in the
	// output table which will contain the value of that field.
	for _, f := range val.Fields {
	member := addMember(dcv, f.Name)
	if index, ok := c.add(f.Var); !ok {
	// The table is full.
	member.Status = statusMessage(messageNotCaptured, true, refersToVariableName)
	} else {
	member.VarTableIndex = int64(index)
	}
	}
	case debug.Map:
	dcv.Value = fmt.Sprintf("len = %d", val.Length)
	for i := uint64(0); i < val.Length; i++ {
	field := addMember(dcv, `⚫`)
	if i == maxMapLength {
	field.Name = "..."
	field.Status = statusMessage(messageTruncated, true, refersToVariableName)
	break
	}
	if index, ok := c.add(mapElement{val, i}); !ok {
	// The value table is full; add a member to contain the error message.
	field.Name = "..."
	field.Status = statusMessage(messageNotCaptured, true, refersToVariableName)
	break
	} else {
	field.VarTableIndex = int64(index)
	}
	}
	case debug.Pointer:
	if val.Address == 0 {
	dcv.Value = "<nil>"
	} else if val.TypeID == 0 {
	// We don't know the type of the pointer, so just output the address as
	// the value.
	dcv.Value = fmt.Sprintf("0x%X", val.Address)
	dcv.Status = statusMessage(messageUnknownPointerType, false, refersToVariableName)
	} else {
	// Adds the pointed-to variable to the table, and links this value to
	// that table entry through VarTableIndex.
	dcv.Value = fmt.Sprintf("0x%X", val.Address)
	target := addMember(dcv, "")
	if index, ok := c.add(debug.Var(val)); !ok {
	target.Status = statusMessage(messageNotCaptured, true, refersToVariableName)
	} else {
	target.VarTableIndex = int64(index)
	}
	}
	case indexable:
	// Arrays, slices and channels.
	dcv.Value = "len = " + fmt.Sprint(val.Len())
	for j := uint64(0); j < val.Len(); j++ {
	field := addMember(dcv, fmt.Sprint(`[`, j, `]`))
	if j == maxArrayLength {
	field.Name = "..."
	field.Status = statusMessage(messageTruncated, true, refersToVariableName)
	break
	}
	vr := val.Element(j)
	if index, ok := c.add(vr); !ok {
	// The value table is full; add a member to contain the error message.
	field.Name = "..."
	field.Status = statusMessage(messageNotCaptured, true, refersToVariableName)
	break
	} else {
	// Add a member with the index as the name.
	field.VarTableIndex = int64(index)
	}
	}
	default:
	dcv.Status = statusMessage(messageUnknownType, false, refersToVariableName)
	}
	}

	// statusMessage returns a *cd.StatusMessage with the given message, IsError
	// field and refersTo field.
	func statusMessage(msg string, isError bool, refersTo int) *cd.StatusMessage {
	return &cd.StatusMessage{
	Description: &cd.FormatMessage{Format: "$0", Parameters: []string{msg}},
	IsError: isError,
	RefersTo: refersToString[refersTo],
	}
	}

	// LogString produces a string for a logpoint, substituting in variable values
	// using evaluatedExpressions and varTable.
	func LogString(s string, evaluatedExpressions []cd.Variable, varTable []cd.Variable) string {
	var buf bytes.Buffer
	fmt.Fprintf(&buf, "LOGPOINT: ")
	seen := make(map[*cd.Variable]bool)
	for i := 0; i < len(s); {
	if s[i] == '$' {
	i++
	if num, n, ok := parseToken(s[i:], len(evaluatedExpressions)-1); ok {
	// This token is one of $0, $1, etc. Write the corresponding expression.
	writeExpression(&buf, evaluatedExpressions[num], false, varTable, seen)
	i += n
	} else {
	// Something else, like $$.
	buf.WriteByte(s[i])
	i++
	}
	} else {
	buf.WriteByte(s[i])
	i++
	}
	}
	return buf.String()
	}

	func parseToken(s string, max int) (num int, bytesRead int, ok bool) {
	var i int
	for i < len(s) && s[i] >= '0' && s[i] <= '9' {
	i++
	}
	num, err := strconv.Atoi(s[:i])
	return num, i, err == nil && num <= max
	}

	// writeExpression recursively writes variables to buf, in a format suitable
	// for logging. If printName is true, writes the name of the variable.
	func writeExpression(buf bytes.Buffer, v cd.Variable, printName bool, varTable []cd.Variable, seen map[cd.Variable]bool) {
	if v == nil {
	// Shouldn't happen.
	return
	}
	name, value, status, members := v.Name, v.Value, v.Status, v.Members

	// If v.VarTableIndex is not zero, it refers to an element of varTable.
	// We merge its fields with the fields we got from v.
	var other *cd.Variable
	if idx := int(v.VarTableIndex); idx > 0 && idx < len(varTable) {
	other = varTable[idx]
	}
	if other != nil {
	if name == "" {
	name = other.Name
	}
	if value == "" {
	value = other.Value
	}
	if status == nil {
	status = other.Status
	}
	if len(members) == 0 {
	members = other.Members
	}
	}
	if printName && name != "" {
	buf.WriteString(name)
	buf.WriteByte(':')
	}

	// If we have seen this value before, write "..." rather than repeating it.
	if seen[v] {
	buf.WriteString("...")
	return
	}
	seen[v] = true
	if other != nil {
	if seen[other] {
	buf.WriteString("...")
	return
	}
	seen[other] = true
	}

	if value != "" && !strings.HasPrefix(value, "len = ") {
	// A plain value.
	buf.WriteString(value)
	} else if status != nil && status.Description != nil {
	// An error.
	for _, p := range status.Description.Parameters {
	buf.WriteByte('(')
	buf.WriteString(p)
	buf.WriteByte(')')
	}
	} else if name == `⚫` {
	// A map element.
	first := true
	for _, member := range members {
	if first {
	first = false
	} else {
	buf.WriteByte(':')
	}
	writeExpression(buf, member, false, varTable, seen)
	}
	} else {
	// A map, array, slice, channel, or struct.
	isStruct := value == ""
	first := true
	buf.WriteByte('{')
	for _, member := range members {
	if first {
	first = false
	} else {
	buf.WriteString(", ")
	}
	writeExpression(buf, member, isStruct, varTable, seen)
	}
	buf.WriteByte('}')
	}
	}

	const (
	// Error messages for cd.StatusMessage
	messageNotCaptured = "Not captured"
	messageTruncated = "Truncated"
	messageUnknownPointerType = "Unknown pointer type"
	messageUnknownType = "Unknown type"
	// RefersTo values for cd.StatusMessage.
	refersToVariableName = iota
	refersToVariableValue
	)

	// refersToString contains the strings for each refersTo value.
	// See the definition of StatusMessage in the v2/clouddebugger package.
	var refersToString = map[int]string{
	refersToVariableName: "VARIABLE_NAME",
	refersToVariableValue: "VARIABLE_VALUE",
	}