planetscale 0.3.1 → 0.3.3

data/vendor/google.golang.org/protobuf/internal/encoding/text/decode_number.go

@@ -1,190 +0,0 @@
-// 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 text
-
-// parseNumberValue parses a number from the input and returns a Token object.
-func (d *Decoder) parseNumberValue() (Token, bool) {
-	in := d.in
-	num := parseNumber(in)
-	if num.size == 0 {
-		return Token{}, false
-	}
-	numAttrs := num.kind
-	if num.neg {
-		numAttrs |= isNegative
-	}
-	strSize := num.size
-	last := num.size - 1
-	if num.kind == numFloat && (d.in[last] == 'f' || d.in[last] == 'F') {
-		strSize = last
-	}
-	tok := Token{
-		kind:     Scalar,
-		attrs:    numberValue,
-		pos:      len(d.orig) - len(d.in),
-		raw:      d.in[:num.size],
-		str:      string(d.in[:strSize]),
-		numAttrs: numAttrs,
-	}
-	d.consume(num.size)
-	return tok, true
-}
-
-const (
-	numDec uint8 = (1 << iota) / 2
-	numHex
-	numOct
-	numFloat
-)
-
-// number is the result of parsing out a valid number from parseNumber. It
-// contains data for doing float or integer conversion via the strconv package
-// in conjunction with the input bytes.
-type number struct {
-	kind uint8
-	neg  bool
-	size int
-}
-
-// parseNumber constructs a number object from given input. It allows for the
-// following patterns:
-//   integer: ^-?([1-9][0-9]*|0[xX][0-9a-fA-F]+|0[0-7]*)
-//   float: ^-?((0|[1-9][0-9]*)?([.][0-9]*)?([eE][+-]?[0-9]+)?[fF]?)
-// It also returns the number of parsed bytes for the given number, 0 if it is
-// not a number.
-func parseNumber(input []byte) number {
-	kind := numDec
-	var size int
-	var neg bool
-
-	s := input
-	if len(s) == 0 {
-		return number{}
-	}
-
-	// Optional -
-	if s[0] == '-' {
-		neg = true
-		s = s[1:]
-		size++
-		if len(s) == 0 {
-			return number{}
-		}
-	}
-
-	// C++ allows for whitespace and comments in between the negative sign and
-	// the rest of the number. This logic currently does not but is consistent
-	// with v1.
-
-	switch {
-	case s[0] == '0':
-		if len(s) > 1 {
-			switch {
-			case s[1] == 'x' || s[1] == 'X':
-				// Parse as hex number.
-				kind = numHex
-				n := 2
-				s = s[2:]
-				for len(s) > 0 && (('0' <= s[0] && s[0] <= '9') ||
-					('a' <= s[0] && s[0] <= 'f') ||
-					('A' <= s[0] && s[0] <= 'F')) {
-					s = s[1:]
-					n++
-				}
-				if n == 2 {
-					return number{}
-				}
-				size += n
-
-			case '0' <= s[1] && s[1] <= '7':
-				// Parse as octal number.
-				kind = numOct
-				n := 2
-				s = s[2:]
-				for len(s) > 0 && '0' <= s[0] && s[0] <= '7' {
-					s = s[1:]
-					n++
-				}
-				size += n
-			}
-
-			if kind&(numHex|numOct) > 0 {
-				if len(s) > 0 && !isDelim(s[0]) {
-					return number{}
-				}
-				return number{kind: kind, neg: neg, size: size}
-			}
-		}
-		s = s[1:]
-		size++
-
-	case '1' <= s[0] && s[0] <= '9':
-		n := 1
-		s = s[1:]
-		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
-			s = s[1:]
-			n++
-		}
-		size += n
-
-	case s[0] == '.':
-		// Set kind to numFloat to signify the intent to parse as float. And
-		// that it needs to have other digits after '.'.
-		kind = numFloat
-
-	default:
-		return number{}
-	}
-
-	// . followed by 0 or more digits.
-	if len(s) > 0 && s[0] == '.' {
-		n := 1
-		s = s[1:]
-		// If decimal point was before any digits, it should be followed by
-		// other digits.
-		if len(s) == 0 && kind == numFloat {
-			return number{}
-		}
-		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
-			s = s[1:]
-			n++
-		}
-		size += n
-		kind = numFloat
-	}
-
-	// e or E followed by an optional - or + and 1 or more digits.
-	if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
-		kind = numFloat
-		s = s[1:]
-		n := 1
-		if s[0] == '+' || s[0] == '-' {
-			s = s[1:]
-			n++
-			if len(s) == 0 {
-				return number{}
-			}
-		}
-		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
-			s = s[1:]
-			n++
-		}
-		size += n
-	}
-
-	// Optional suffix f or F for floats.
-	if len(s) > 0 && (s[0] == 'f' || s[0] == 'F') {
-		kind = numFloat
-		s = s[1:]
-		size++
-	}
-
-	// Check that next byte is a delimiter or it is at the end.
-	if len(s) > 0 && !isDelim(s[0]) {
-		return number{}
-	}
-
-	return number{kind: kind, neg: neg, size: size}
-}

data/vendor/google.golang.org/protobuf/internal/encoding/text/decode_string.go

@@ -1,161 +0,0 @@
-// 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 text
-
-import (
-	"bytes"
-	"strconv"
-	"strings"
-	"unicode"
-	"unicode/utf16"
-	"unicode/utf8"
-
-	"google.golang.org/protobuf/internal/strs"
-)
-
-// parseStringValue parses string field token.
-// This differs from parseString since the text format allows
-// multiple back-to-back string literals where they are semantically treated
-// as a single large string with all values concatenated.
-//
-// E.g., `"foo" "bar" "baz"` => "foobarbaz"
-func (d *Decoder) parseStringValue() (Token, error) {
-	// Note that the ending quote is sufficient to unambiguously mark the end
-	// of a string. Thus, the text grammar does not require intervening
-	// whitespace or control characters in-between strings.
-	// Thus, the following is valid:
-	//	`"foo"'bar'"baz"` => "foobarbaz"
-	in0 := d.in
-	var ss []string
-	for len(d.in) > 0 && (d.in[0] == '"' || d.in[0] == '\'') {
-		s, err := d.parseString()
-		if err != nil {
-			return Token{}, err
-		}
-		ss = append(ss, s)
-	}
-	// d.in already points to the end of the value at this point.
-	return Token{
-		kind:  Scalar,
-		attrs: stringValue,
-		pos:   len(d.orig) - len(in0),
-		raw:   in0[:len(in0)-len(d.in)],
-		str:   strings.Join(ss, ""),
-	}, nil
-}
-
-// parseString parses a string value enclosed in " or '.
-func (d *Decoder) parseString() (string, error) {
-	in := d.in
-	if len(in) == 0 {
-		return "", ErrUnexpectedEOF
-	}
-	quote := in[0]
-	in = in[1:]
-	i := indexNeedEscapeInBytes(in)
-	in, out := in[i:], in[:i:i] // set cap to prevent mutations
-	for len(in) > 0 {
-		switch r, n := utf8.DecodeRune(in); {
-		case r == utf8.RuneError && n == 1:
-			return "", d.newSyntaxError("invalid UTF-8 detected")
-		case r == 0 || r == '\n':
-			return "", d.newSyntaxError("invalid character %q in string", r)
-		case r == rune(quote):
-			in = in[1:]
-			d.consume(len(d.in) - len(in))
-			return string(out), nil
-		case r == '\\':
-			if len(in) < 2 {
-				return "", ErrUnexpectedEOF
-			}
-			switch r := in[1]; r {
-			case '"', '\'', '\\', '?':
-				in, out = in[2:], append(out, r)
-			case 'a':
-				in, out = in[2:], append(out, '\a')
-			case 'b':
-				in, out = in[2:], append(out, '\b')
-			case 'n':
-				in, out = in[2:], append(out, '\n')
-			case 'r':
-				in, out = in[2:], append(out, '\r')
-			case 't':
-				in, out = in[2:], append(out, '\t')
-			case 'v':
-				in, out = in[2:], append(out, '\v')
-			case 'f':
-				in, out = in[2:], append(out, '\f')
-			case '0', '1', '2', '3', '4', '5', '6', '7':
-				// One, two, or three octal characters.
-				n := len(in[1:]) - len(bytes.TrimLeft(in[1:], "01234567"))
-				if n > 3 {
-					n = 3
-				}
-				v, err := strconv.ParseUint(string(in[1:1+n]), 8, 8)
-				if err != nil {
-					return "", d.newSyntaxError("invalid octal escape code %q in string", in[:1+n])
-				}
-				in, out = in[1+n:], append(out, byte(v))
-			case 'x':
-				// One or two hexadecimal characters.
-				n := len(in[2:]) - len(bytes.TrimLeft(in[2:], "0123456789abcdefABCDEF"))
-				if n > 2 {
-					n = 2
-				}
-				v, err := strconv.ParseUint(string(in[2:2+n]), 16, 8)
-				if err != nil {
-					return "", d.newSyntaxError("invalid hex escape code %q in string", in[:2+n])
-				}
-				in, out = in[2+n:], append(out, byte(v))
-			case 'u', 'U':
-				// Four or eight hexadecimal characters
-				n := 6
-				if r == 'U' {
-					n = 10
-				}
-				if len(in) < n {
-					return "", ErrUnexpectedEOF
-				}
-				v, err := strconv.ParseUint(string(in[2:n]), 16, 32)
-				if utf8.MaxRune < v || err != nil {
-					return "", d.newSyntaxError("invalid Unicode escape code %q in string", in[:n])
-				}
-				in = in[n:]
-
-				r := rune(v)
-				if utf16.IsSurrogate(r) {
-					if len(in) < 6 {
-						return "", ErrUnexpectedEOF
-					}
-					v, err := strconv.ParseUint(string(in[2:6]), 16, 16)
-					r = utf16.DecodeRune(r, rune(v))
-					if in[0] != '\\' || in[1] != 'u' || r == unicode.ReplacementChar || err != nil {
-						return "", d.newSyntaxError("invalid Unicode escape code %q in string", in[:6])
-					}
-					in = in[6:]
-				}
-				out = append(out, string(r)...)
-			default:
-				return "", d.newSyntaxError("invalid escape code %q in string", in[:2])
-			}
-		default:
-			i := indexNeedEscapeInBytes(in[n:])
-			in, out = in[n+i:], append(out, in[:n+i]...)
-		}
-	}
-	return "", ErrUnexpectedEOF
-}
-
-// indexNeedEscapeInString returns the index of the character that needs
-// escaping. If no characters need escaping, this returns the input length.
-func indexNeedEscapeInBytes(b []byte) int { return indexNeedEscapeInString(strs.UnsafeString(b)) }
-
-// UnmarshalString returns an unescaped string given a textproto string value.
-// String value needs to contain single or double quotes. This is only used by
-// internal/encoding/defval package for unmarshaling bytes.
-func UnmarshalString(s string) (string, error) {
-	d := NewDecoder([]byte(s))
-	return d.parseString()
-}

data/vendor/google.golang.org/protobuf/internal/encoding/text/decode_token.go

@@ -1,373 +0,0 @@
-// 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 text
-
-import (
-	"bytes"
-	"fmt"
-	"math"
-	"strconv"
-	"strings"
-
-	"google.golang.org/protobuf/internal/flags"
-)
-
-// Kind represents a token kind expressible in the textproto format.
-type Kind uint8
-
-// Kind values.
-const (
-	Invalid Kind = iota
-	EOF
-	Name   // Name indicates the field name.
-	Scalar // Scalar are scalar values, e.g. "string", 47, ENUM_LITERAL, true.
-	MessageOpen
-	MessageClose
-	ListOpen
-	ListClose
-
-	// comma and semi-colon are only for parsing in between values and should not be exposed.
-	comma
-	semicolon
-
-	// bof indicates beginning of file, which is the default token
-	// kind at the beginning of parsing.
-	bof = Invalid
-)
-
-func (t Kind) String() string {
-	switch t {
-	case Invalid:
-		return "<invalid>"
-	case EOF:
-		return "eof"
-	case Scalar:
-		return "scalar"
-	case Name:
-		return "name"
-	case MessageOpen:
-		return "{"
-	case MessageClose:
-		return "}"
-	case ListOpen:
-		return "["
-	case ListClose:
-		return "]"
-	case comma:
-		return ","
-	case semicolon:
-		return ";"
-	default:
-		return fmt.Sprintf("<invalid:%v>", uint8(t))
-	}
-}
-
-// NameKind represents different types of field names.
-type NameKind uint8
-
-// NameKind values.
-const (
-	IdentName NameKind = iota + 1
-	TypeName
-	FieldNumber
-)
-
-func (t NameKind) String() string {
-	switch t {
-	case IdentName:
-		return "IdentName"
-	case TypeName:
-		return "TypeName"
-	case FieldNumber:
-		return "FieldNumber"
-	default:
-		return fmt.Sprintf("<invalid:%v>", uint8(t))
-	}
-}
-
-// Bit mask in Token.attrs to indicate if a Name token is followed by the
-// separator char ':'. The field name separator char is optional for message
-// field or repeated message field, but required for all other types. Decoder
-// simply indicates whether a Name token is followed by separator or not.  It is
-// up to the prototext package to validate.
-const hasSeparator = 1 << 7
-
-// Scalar value types.
-const (
-	numberValue = iota + 1
-	stringValue
-	literalValue
-)
-
-// Bit mask in Token.numAttrs to indicate that the number is a negative.
-const isNegative = 1 << 7
-
-// Token provides a parsed token kind and value. Values are provided by the
-// different accessor methods.
-type Token struct {
-	// Kind of the Token object.
-	kind Kind
-	// attrs contains metadata for the following Kinds:
-	// Name: hasSeparator bit and one of NameKind.
-	// Scalar: one of numberValue, stringValue, literalValue.
-	attrs uint8
-	// numAttrs contains metadata for numberValue:
-	// - highest bit is whether negative or positive.
-	// - lower bits indicate one of numDec, numHex, numOct, numFloat.
-	numAttrs uint8
-	// pos provides the position of the token in the original input.
-	pos int
-	// raw bytes of the serialized token.
-	// This is a subslice into the original input.
-	raw []byte
-	// str contains parsed string for the following:
-	// - stringValue of Scalar kind
-	// - numberValue of Scalar kind
-	// - TypeName of Name kind
-	str string
-}
-
-// Kind returns the token kind.
-func (t Token) Kind() Kind {
-	return t.kind
-}
-
-// RawString returns the read value in string.
-func (t Token) RawString() string {
-	return string(t.raw)
-}
-
-// Pos returns the token position from the input.
-func (t Token) Pos() int {
-	return t.pos
-}
-
-// NameKind returns IdentName, TypeName or FieldNumber.
-// It panics if type is not Name.
-func (t Token) NameKind() NameKind {
-	if t.kind == Name {
-		return NameKind(t.attrs &^ hasSeparator)
-	}
-	panic(fmt.Sprintf("Token is not a Name type: %s", t.kind))
-}
-
-// HasSeparator returns true if the field name is followed by the separator char
-// ':', else false. It panics if type is not Name.
-func (t Token) HasSeparator() bool {
-	if t.kind == Name {
-		return t.attrs&hasSeparator != 0
-	}
-	panic(fmt.Sprintf("Token is not a Name type: %s", t.kind))
-}
-
-// IdentName returns the value for IdentName type.
-func (t Token) IdentName() string {
-	if t.kind == Name && t.attrs&uint8(IdentName) != 0 {
-		return string(t.raw)
-	}
-	panic(fmt.Sprintf("Token is not an IdentName: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
-}
-
-// TypeName returns the value for TypeName type.
-func (t Token) TypeName() string {
-	if t.kind == Name && t.attrs&uint8(TypeName) != 0 {
-		return t.str
-	}
-	panic(fmt.Sprintf("Token is not a TypeName: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
-}
-
-// FieldNumber returns the value for FieldNumber type. It returns a
-// non-negative int32 value. Caller will still need to validate for the correct
-// field number range.
-func (t Token) FieldNumber() int32 {
-	if t.kind != Name || t.attrs&uint8(FieldNumber) == 0 {
-		panic(fmt.Sprintf("Token is not a FieldNumber: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
-	}
-	// Following should not return an error as it had already been called right
-	// before this Token was constructed.
-	num, _ := strconv.ParseInt(string(t.raw), 10, 32)
-	return int32(num)
-}
-
-// String returns the string value for a Scalar type.
-func (t Token) String() (string, bool) {
-	if t.kind != Scalar || t.attrs != stringValue {
-		return "", false
-	}
-	return t.str, true
-}
-
-// Enum returns the literal value for a Scalar type for use as enum literals.
-func (t Token) Enum() (string, bool) {
-	if t.kind != Scalar || t.attrs != literalValue || (len(t.raw) > 0 && t.raw[0] == '-') {
-		return "", false
-	}
-	return string(t.raw), true
-}
-
-// Bool returns the bool value for a Scalar type.
-func (t Token) Bool() (bool, bool) {
-	if t.kind != Scalar {
-		return false, false
-	}
-	switch t.attrs {
-	case literalValue:
-		if b, ok := boolLits[string(t.raw)]; ok {
-			return b, true
-		}
-	case numberValue:
-		// Unsigned integer representation of 0 or 1 is permitted: 00, 0x0, 01,
-		// 0x1, etc.
-		n, err := strconv.ParseUint(t.str, 0, 64)
-		if err == nil {
-			switch n {
-			case 0:
-				return false, true
-			case 1:
-				return true, true
-			}
-		}
-	}
-	return false, false
-}
-
-// These exact boolean literals are the ones supported in C++.
-var boolLits = map[string]bool{
-	"t":     true,
-	"true":  true,
-	"True":  true,
-	"f":     false,
-	"false": false,
-	"False": false,
-}
-
-// Uint64 returns the uint64 value for a Scalar type.
-func (t Token) Uint64() (uint64, bool) {
-	if t.kind != Scalar || t.attrs != numberValue ||
-		t.numAttrs&isNegative > 0 || t.numAttrs&numFloat > 0 {
-		return 0, false
-	}
-	n, err := strconv.ParseUint(t.str, 0, 64)
-	if err != nil {
-		return 0, false
-	}
-	return n, true
-}
-
-// Uint32 returns the uint32 value for a Scalar type.
-func (t Token) Uint32() (uint32, bool) {
-	if t.kind != Scalar || t.attrs != numberValue ||
-		t.numAttrs&isNegative > 0 || t.numAttrs&numFloat > 0 {
-		return 0, false
-	}
-	n, err := strconv.ParseUint(t.str, 0, 32)
-	if err != nil {
-		return 0, false
-	}
-	return uint32(n), true
-}
-
-// Int64 returns the int64 value for a Scalar type.
-func (t Token) Int64() (int64, bool) {
-	if t.kind != Scalar || t.attrs != numberValue || t.numAttrs&numFloat > 0 {
-		return 0, false
-	}
-	if n, err := strconv.ParseInt(t.str, 0, 64); err == nil {
-		return n, true
-	}
-	// C++ accepts large positive hex numbers as negative values.
-	// This feature is here for proto1 backwards compatibility purposes.
-	if flags.ProtoLegacy && (t.numAttrs == numHex) {
-		if n, err := strconv.ParseUint(t.str, 0, 64); err == nil {
-			return int64(n), true
-		}
-	}
-	return 0, false
-}
-
-// Int32 returns the int32 value for a Scalar type.
-func (t Token) Int32() (int32, bool) {
-	if t.kind != Scalar || t.attrs != numberValue || t.numAttrs&numFloat > 0 {
-		return 0, false
-	}
-	if n, err := strconv.ParseInt(t.str, 0, 32); err == nil {
-		return int32(n), true
-	}
-	// C++ accepts large positive hex numbers as negative values.
-	// This feature is here for proto1 backwards compatibility purposes.
-	if flags.ProtoLegacy && (t.numAttrs == numHex) {
-		if n, err := strconv.ParseUint(t.str, 0, 32); err == nil {
-			return int32(n), true
-		}
-	}
-	return 0, false
-}
-
-// Float64 returns the float64 value for a Scalar type.
-func (t Token) Float64() (float64, bool) {
-	if t.kind != Scalar {
-		return 0, false
-	}
-	switch t.attrs {
-	case literalValue:
-		if f, ok := floatLits[strings.ToLower(string(t.raw))]; ok {
-			return f, true
-		}
-	case numberValue:
-		n, err := strconv.ParseFloat(t.str, 64)
-		if err == nil {
-			return n, true
-		}
-		nerr := err.(*strconv.NumError)
-		if nerr.Err == strconv.ErrRange {
-			return n, true
-		}
-	}
-	return 0, false
-}
-
-// Float32 returns the float32 value for a Scalar type.
-func (t Token) Float32() (float32, bool) {
-	if t.kind != Scalar {
-		return 0, false
-	}
-	switch t.attrs {
-	case literalValue:
-		if f, ok := floatLits[strings.ToLower(string(t.raw))]; ok {
-			return float32(f), true
-		}
-	case numberValue:
-		n, err := strconv.ParseFloat(t.str, 64)
-		if err == nil {
-			// Overflows are treated as (-)infinity.
-			return float32(n), true
-		}
-		nerr := err.(*strconv.NumError)
-		if nerr.Err == strconv.ErrRange {
-			return float32(n), true
-		}
-	}
-	return 0, false
-}
-
-// These are the supported float literals which C++ permits case-insensitive
-// variants of these.
-var floatLits = map[string]float64{
-	"nan":       math.NaN(),
-	"inf":       math.Inf(1),
-	"infinity":  math.Inf(1),
-	"-inf":      math.Inf(-1),
-	"-infinity": math.Inf(-1),
-}
-
-// TokenEquals returns true if given Tokens are equal, else false.
-func TokenEquals(x, y Token) bool {
-	return x.kind == y.kind &&
-		x.attrs == y.attrs &&
-		x.numAttrs == y.numAttrs &&
-		x.pos == y.pos &&
-		bytes.Equal(x.raw, y.raw) &&
-		x.str == y.str
-}