Function parseArgs

stack/context.go:840–895

parseArgs parses a collection of comma-separated arguments into an Args struct.

(line []byte)

// parseArgs parses a collection of comma-separated arguments into an Args
// struct.
func parseArgs(line []byte) (Args, error) {
	const maxDepth = 6 // 5 from traceback.go, +1 for top level
	var stack [maxDepth]*Args
	var args Args
	depth := 0
	stack[depth] = &args
	for _, s := range bytes.Split(line, commaSpace) {
		opened, a, closed := trimCurlyBrackets(s)
		for i := 0; i < opened; i++ {
			cur := stack[depth]
			cur.Values = append(cur.Values, Arg{})
			next := &cur.Values[len(cur.Values)-1]
			next.IsAggregate = true
			depth++
			if depth >= maxDepth {
				return Args{}, fmt.Errorf("nested aggregate-typed arguments exceeded depth limit")
			}
			stack[depth] = &next.Fields
		}
		if len(a) > 0 {
			cur := stack[depth]
			switch {
			case bytes.Equal(a, threeDots):
				cur.Elided = true
			case bytes.Equal(a, underscore):
				arg := Arg{IsOffsetTooLarge: true}
				cur.Values = append(cur.Values, arg)
			default:
				inaccurate := bytes.HasSuffix(a, inaccurateQuestionMark)
				if inaccurate {
					a = a[:len(a)-len(inaccurateQuestionMark)]
				}

				v, err := strconv.ParseUint(unsafeString(a), 0, 64)
				if err != nil {
					return Args{}, errors.New("failed to parse int")
				}
				// Assume the stack was generated with the same bitness (32 vs 64) as
				// the code processing it.
				arg := Arg{Value: v, IsPtr: v > pointerFloor && v < pointerCeiling, IsInaccurate: inaccurate}
				cur.Values = append(cur.Values, arg)
			}
		}
		for i := 0; i < closed; i++ {
			stack[depth] = nil
			depth--
			if depth < 0 {
				return Args{}, errors.New("unmatched closing curly bracket")
			}
		}
	}
	if depth != 0 {
		return Args{}, errors.New("unmatched opening curly bracket")
	}
	return args, nil
}

// parseFile only return an error if also processing a Call.