internal/encoding/json/decode.go

// Copyright 2018 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.

package json

import (
	"bytes"
	"fmt"
	"io"
	"regexp"
	"strconv"
	"unicode/utf8"

	"github.com/golang/protobuf/v2/internal/errors"
)

// call specifies which Decoder method was invoked.
type call uint8

const (
	readCall call = iota
	peekCall
)

// Decoder is a token-based JSON decoder.
type Decoder struct {
	// lastCall is last method called, eiterh readCall or peekCall.
	lastCall call

	// value contains the last read value.
	value Value

	// err contains the last read error.
	err error

	// startStack is a stack containing StartObject and StartArray types. The
	// top of stack represents the object or the array the current value is
	// directly located in.
	startStack []Type

	// orig is used in reporting line and column.
	orig []byte
	// in contains the unconsumed input.
	in []byte
}

// NewDecoder returns a Decoder to read the given []byte.
func NewDecoder(b []byte) *Decoder {
	return &Decoder{orig: b, in: b}
}

// Peek looks ahead and returns the next JSON type without advancing a read.
func (d *Decoder) Peek() Type {
	defer func() { d.lastCall = peekCall }()
	if d.lastCall == readCall {
		d.value, d.err = d.Read()
	}
	return d.value.typ
}

// Read returns the next JSON value. It will return an error if there is no
// valid value.  For String types containing invalid UTF8 characters, a
// non-fatal error is returned and caller can call Read for the next value.
func (d *Decoder) Read() (Value, error) {
	defer func() { d.lastCall = readCall }()
	if d.lastCall == peekCall {
		return d.value, d.err
	}

	var nerr errors.NonFatal
	value, n, err := d.parseNext()
	if !nerr.Merge(err) {
		return Value{}, err
	}

	switch value.typ {
	case EOF:
		if len(d.startStack) != 0 ||
			d.value.typ&Null|Bool|Number|String|EndObject|EndArray == 0 {
			return Value{}, io.ErrUnexpectedEOF
		}

	case Null:
		if !d.isValueNext() {
			return Value{}, d.newSyntaxError("unexpected value null")
		}

	case Bool, Number:
		if !d.isValueNext() {
			return Value{}, d.newSyntaxError("unexpected value %v", value)
		}

	case String:
		if d.isValueNext() {
			break
		}
		// Check if this is for an object name.
		if d.value.typ&(StartObject|comma) == 0 {
			return Value{}, d.newSyntaxError("unexpected value %q", value)
		}
		d.in = d.in[n:]
		d.consume(0)
		if c := d.in[0]; c != ':' {
			return Value{}, d.newSyntaxError(`unexpected character %v, missing ":" after object name`, string(c))
		}
		n = 1
		value.typ = Name

	case StartObject, StartArray:
		if !d.isValueNext() {
			return Value{}, d.newSyntaxError("unexpected character %v", value)
		}
		d.startStack = append(d.startStack, value.typ)

	case EndObject:
		if len(d.startStack) == 0 ||
			d.value.typ == comma ||
			d.startStack[len(d.startStack)-1] != StartObject {
			return Value{}, d.newSyntaxError("unexpected character }")
		}
		d.startStack = d.startStack[:len(d.startStack)-1]

	case EndArray:
		if len(d.startStack) == 0 ||
			d.value.typ == comma ||
			d.startStack[len(d.startStack)-1] != StartArray {
			return Value{}, d.newSyntaxError("unexpected character ]")
		}
		d.startStack = d.startStack[:len(d.startStack)-1]

	case comma:
		if len(d.startStack) == 0 ||
			d.value.typ&(Null|Bool|Number|String|EndObject|EndArray) == 0 {
			return Value{}, d.newSyntaxError("unexpected character ,")
		}
	}

	// Update lastType only after validating value to be in the right
	// sequence.
	d.value.typ = value.typ
	d.in = d.in[n:]

	if d.value.typ == comma {
		return d.Read()
	}
	return value, nerr.E
}

var (
	literalRegexp = regexp.MustCompile(`^(null|true|false)`)
	// Any sequence that looks like a non-delimiter (for error reporting).
	errRegexp = regexp.MustCompile(`^([-+._a-zA-Z0-9]{1,32}|.)`)
)

// parseNext parses for the next JSON value. It returns a Value object for
// different types, except for Name. It also returns the size that was parsed.
// It does not handle whether the next value is in a valid sequence or not, it
// only ensures that the value is a valid one.
func (d *Decoder) parseNext() (value Value, n int, err error) {
	// Trim leading spaces.
	d.consume(0)

	in := d.in
	if len(in) == 0 {
		return d.newValue(EOF, nil, nil), 0, nil
	}

	switch in[0] {
	case 'n', 't', 'f':
		n := matchWithDelim(literalRegexp, in)
		if n == 0 {
			return Value{}, 0, d.newSyntaxError("invalid value %s", errRegexp.Find(in))
		}
		switch in[0] {
		case 'n':
			return d.newValue(Null, in[:n], nil), n, nil
		case 't':
			return d.newValue(Bool, in[:n], true), n, nil
		case 'f':
			return d.newValue(Bool, in[:n], false), n, nil
		}

	case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
		num, n := parseNumber(in)
		if num == nil {
			return Value{}, 0, d.newSyntaxError("invalid number %s", errRegexp.Find(in))
		}
		return d.newValue(Number, in[:n], num), n, nil

	case '"':
		var nerr errors.NonFatal
		s, n, err := d.parseString(in)
		if !nerr.Merge(err) {
			return Value{}, 0, err
		}
		return d.newValue(String, in[:n], s), n, nerr.E

	case '{':
		return d.newValue(StartObject, in[:1], nil), 1, nil

	case '}':
		return d.newValue(EndObject, in[:1], nil), 1, nil

	case '[':
		return d.newValue(StartArray, in[:1], nil), 1, nil

	case ']':
		return d.newValue(EndArray, in[:1], nil), 1, nil

	case ',':
		return d.newValue(comma, in[:1], nil), 1, nil
	}
	return Value{}, 0, d.newSyntaxError("invalid value %s", errRegexp.Find(in))
}

// position returns line and column number of parsed bytes.
func (d *Decoder) position() (int, int) {
	// Calculate line and column of consumed input.
	b := d.orig[:len(d.orig)-len(d.in)]
	line := bytes.Count(b, []byte("\n")) + 1
	if i := bytes.LastIndexByte(b, '\n'); i >= 0 {
		b = b[i+1:]
	}
	column := utf8.RuneCount(b) + 1 // ignore multi-rune characters
	return line, column
}

// newSyntaxError returns an error with line and column information useful for
// syntax errors.
func (d *Decoder) newSyntaxError(f string, x ...interface{}) error {
	e := errors.New(f, x...)
	line, column := d.position()
	return errors.New("syntax error (line %d:%d): %v", line, column, e)
}

// matchWithDelim matches r with the input b and verifies that the match
// terminates with a delimiter of some form (e.g., r"[^-+_.a-zA-Z0-9]").
// As a special case, EOF is considered a delimiter.
func matchWithDelim(r *regexp.Regexp, b []byte) int {
	n := len(r.Find(b))
	if n < len(b) {
		// Check that the next character is a delimiter.
		if isNotDelim(b[n]) {
			return 0
		}
	}
	return n
}

// isNotDelim returns true if given byte is a not delimiter character.
func isNotDelim(c byte) bool {
	return (c == '-' || c == '+' || c == '.' || c == '_' ||
		('a' <= c && c <= 'z') ||
		('A' <= c && c <= 'Z') ||
		('0' <= c && c <= '9'))
}

// consume consumes n bytes of input and any subsequent whitespace.
func (d *Decoder) consume(n int) {
	d.in = d.in[n:]
	for len(d.in) > 0 {
		switch d.in[0] {
		case ' ', '\n', '\r', '\t':
			d.in = d.in[1:]
		default:
			return
		}
	}
}

// isValueNext returns true if next type should be a JSON value: Null,
// Number, String or Bool.
func (d *Decoder) isValueNext() bool {
	if len(d.startStack) == 0 {
		return d.value.typ == 0
	}

	start := d.startStack[len(d.startStack)-1]
	switch start {
	case StartObject:
		return d.value.typ&Name != 0
	case StartArray:
		return d.value.typ&(StartArray|comma) != 0
	}
	panic(fmt.Sprintf(
		"unreachable logic in Decoder.isValueNext, lastType: %v, startStack: %v",
		d.value.typ, start))
}

// newValue constructs a Value.
func (d *Decoder) newValue(typ Type, input []byte, value interface{}) Value {
	line, column := d.position()
	return Value{
		input:  input,
		line:   line,
		column: column,
		typ:    typ,
		value:  value,
	}
}

// Value contains a JSON type and value parsed from calling Decoder.Read.
type Value struct {
	input  []byte
	line   int
	column int
	typ    Type
	// value will be set to the following Go type based on the type field:
	//    Bool   => bool
	//    Number => *numberParts
	//    String => string
	//    Name   => string
	// It will be nil if none of the above.
	value interface{}
}

func (v Value) newError(f string, x ...interface{}) error {
	e := errors.New(f, x...)
	return errors.New("error (line %d:%d): %v", v.line, v.column, e)
}

// Type returns the JSON type.
func (v Value) Type() Type {
	return v.typ
}

// Position returns the line and column of the value.
func (v Value) Position() (int, int) {
	return v.line, v.column
}

// Bool returns the bool value if token is Bool, else it will return an error.
func (v Value) Bool() (bool, error) {
	if v.typ != Bool {
		return false, v.newError("%s is not a bool", v.input)
	}
	return v.value.(bool), nil
}

// String returns the string value for a JSON string token or the read value in
// string if token is not a string.
func (v Value) String() string {
	if v.typ != String {
		return string(v.input)
	}
	return v.value.(string)
}

// Name returns the object name if token is Name, else it will return an error.
func (v Value) Name() (string, error) {
	if v.typ != Name {
		return "", v.newError("%s is not an object name", v.input)
	}
	return v.value.(string), nil
}

// Float returns the floating-point number if token is Number, else it will
// return an error.
//
// The floating-point precision is specified by the bitSize parameter: 32 for
// float32 or 64 for float64. If bitSize=32, the result still has type float64,
// but it will be convertible to float32 without changing its value. It will
// return an error if the number exceeds the floating point limits for given
// bitSize.
func (v Value) Float(bitSize int) (float64, error) {
	if v.typ != Number {
		return 0, v.newError("%s is not a number", v.input)
	}
	f, err := strconv.ParseFloat(string(v.input), bitSize)
	if err != nil {
		return 0, v.newError("%v", err)
	}
	return f, nil
}

// Int returns the signed integer number if token is Number, else it will
// return an error.
//
// The given bitSize specifies the integer type that the result must fit into.
// It returns an error if the number is not an integer value or if the result
// exceeds the limits for given bitSize.
func (v Value) Int(bitSize int) (int64, error) {
	s, err := v.getIntStr()
	if err != nil {
		return 0, err
	}
	n, err := strconv.ParseInt(s, 10, bitSize)
	if err != nil {
		return 0, v.newError("%v", err)
	}
	return n, nil
}

// Uint returns the signed integer number if token is Number, else it will
// return an error.
//
// The given bitSize specifies the unsigned integer type that the result must
// fit into.  It returns an error if the number is not an unsigned integer value
// or if the result exceeds the limits for given bitSize.
func (v Value) Uint(bitSize int) (uint64, error) {
	s, err := v.getIntStr()
	if err != nil {
		return 0, err
	}
	n, err := strconv.ParseUint(s, 10, bitSize)
	if err != nil {
		return 0, v.newError("%v", err)
	}
	return n, nil
}

func (v Value) getIntStr() (string, error) {
	if v.typ != Number {
		return "", v.newError("%s is not a number", v.input)
	}
	pnum := v.value.(*numberParts)
	num, ok := normalizeToIntString(pnum)
	if !ok {
		return "", v.newError("cannot convert %s to integer", v.input)
	}
	return num, nil
}