k3s/vendor/github.com/godbus/dbus/variant_parser.go

package dbus

import (
	"bytes"
	"errors"
	"fmt"
	"io"
	"reflect"
	"strconv"
	"strings"
	"unicode/utf8"
)

type varParser struct {
	tokens []varToken
	i      int
}

func (p *varParser) backup() {
	p.i--
}

func (p *varParser) next() varToken {
	if p.i < len(p.tokens) {
		t := p.tokens[p.i]
		p.i++
		return t
	}
	return varToken{typ: tokEOF}
}

type varNode interface {
	Infer() (Signature, error)
	String() string
	Sigs() sigSet
	Value(Signature) (interface{}, error)
}

func varMakeNode(p *varParser) (varNode, error) {
	var sig Signature

	for {
		t := p.next()
		switch t.typ {
		case tokEOF:
			return nil, io.ErrUnexpectedEOF
		case tokError:
			return nil, errors.New(t.val)
		case tokNumber:
			return varMakeNumNode(t, sig)
		case tokString:
			return varMakeStringNode(t, sig)
		case tokBool:
			if sig.str != "" && sig.str != "b" {
				return nil, varTypeError{t.val, sig}
			}
			b, err := strconv.ParseBool(t.val)
			if err != nil {
				return nil, err
			}
			return boolNode(b), nil
		case tokArrayStart:
			return varMakeArrayNode(p, sig)
		case tokVariantStart:
			return varMakeVariantNode(p, sig)
		case tokDictStart:
			return varMakeDictNode(p, sig)
		case tokType:
			if sig.str != "" {
				return nil, errors.New("unexpected type annotation")
			}
			if t.val[0] == '@' {
				sig.str = t.val[1:]
			} else {
				sig.str = varTypeMap[t.val]
			}
		case tokByteString:
			if sig.str != "" && sig.str != "ay" {
				return nil, varTypeError{t.val, sig}
			}
			b, err := varParseByteString(t.val)
			if err != nil {
				return nil, err
			}
			return byteStringNode(b), nil
		default:
			return nil, fmt.Errorf("unexpected %q", t.val)
		}
	}
}

type varTypeError struct {
	val string
	sig Signature
}

func (e varTypeError) Error() string {
	return fmt.Sprintf("dbus: can't parse %q as type %q", e.val, e.sig.str)
}

type sigSet map[Signature]bool

func (s sigSet) Empty() bool {
	return len(s) == 0
}

func (s sigSet) Intersect(s2 sigSet) sigSet {
	r := make(sigSet)
	for k := range s {
		if s2[k] {
			r[k] = true
		}
	}
	return r
}

func (s sigSet) Single() (Signature, bool) {
	if len(s) == 1 {
		for k := range s {
			return k, true
		}
	}
	return Signature{}, false
}

func (s sigSet) ToArray() sigSet {
	r := make(sigSet, len(s))
	for k := range s {
		r[Signature{"a" + k.str}] = true
	}
	return r
}

type numNode struct {
	sig Signature
	str string
	val interface{}
}

var numSigSet = sigSet{
	Signature{"y"}: true,
	Signature{"n"}: true,
	Signature{"q"}: true,
	Signature{"i"}: true,
	Signature{"u"}: true,
	Signature{"x"}: true,
	Signature{"t"}: true,
	Signature{"d"}: true,
}

func (n numNode) Infer() (Signature, error) {
	if strings.ContainsAny(n.str, ".e") {
		return Signature{"d"}, nil
	}
	return Signature{"i"}, nil
}

func (n numNode) String() string {
	return n.str
}

func (n numNode) Sigs() sigSet {
	if n.sig.str != "" {
		return sigSet{n.sig: true}
	}
	if strings.ContainsAny(n.str, ".e") {
		return sigSet{Signature{"d"}: true}
	}
	return numSigSet
}

func (n numNode) Value(sig Signature) (interface{}, error) {
	if n.sig.str != "" && n.sig != sig {
		return nil, varTypeError{n.str, sig}
	}
	if n.val != nil {
		return n.val, nil
	}
	return varNumAs(n.str, sig)
}

func varMakeNumNode(tok varToken, sig Signature) (varNode, error) {
	if sig.str == "" {
		return numNode{str: tok.val}, nil
	}
	num, err := varNumAs(tok.val, sig)
	if err != nil {
		return nil, err
	}
	return numNode{sig: sig, val: num}, nil
}

func varNumAs(s string, sig Signature) (interface{}, error) {
	isUnsigned := false
	size := 32
	switch sig.str {
	case "n":
		size = 16
	case "i":
	case "x":
		size = 64
	case "y":
		size = 8
		isUnsigned = true
	case "q":
		size = 16
		isUnsigned = true
	case "u":
		isUnsigned = true
	case "t":
		size = 64
		isUnsigned = true
	case "d":
		d, err := strconv.ParseFloat(s, 64)
		if err != nil {
			return nil, err
		}
		return d, nil
	default:
		return nil, varTypeError{s, sig}
	}
	base := 10
	if strings.HasPrefix(s, "0x") {
		base = 16
		s = s[2:]
	}
	if strings.HasPrefix(s, "0") && len(s) != 1 {
		base = 8
		s = s[1:]
	}
	if isUnsigned {
		i, err := strconv.ParseUint(s, base, size)
		if err != nil {
			return nil, err
		}
		var v interface{} = i
		switch sig.str {
		case "y":
			v = byte(i)
		case "q":
			v = uint16(i)
		case "u":
			v = uint32(i)
		}
		return v, nil
	}
	i, err := strconv.ParseInt(s, base, size)
	if err != nil {
		return nil, err
	}
	var v interface{} = i
	switch sig.str {
	case "n":
		v = int16(i)
	case "i":
		v = int32(i)
	}
	return v, nil
}

type stringNode struct {
	sig Signature
	str string      // parsed
	val interface{} // has correct type
}

var stringSigSet = sigSet{
	Signature{"s"}: true,
	Signature{"g"}: true,
	Signature{"o"}: true,
}

func (n stringNode) Infer() (Signature, error) {
	return Signature{"s"}, nil
}

func (n stringNode) String() string {
	return n.str
}

func (n stringNode) Sigs() sigSet {
	if n.sig.str != "" {
		return sigSet{n.sig: true}
	}
	return stringSigSet
}

func (n stringNode) Value(sig Signature) (interface{}, error) {
	if n.sig.str != "" && n.sig != sig {
		return nil, varTypeError{n.str, sig}
	}
	if n.val != nil {
		return n.val, nil
	}
	switch {
	case sig.str == "g":
		return Signature{n.str}, nil
	case sig.str == "o":
		return ObjectPath(n.str), nil
	case sig.str == "s":
		return n.str, nil
	default:
		return nil, varTypeError{n.str, sig}
	}
}

func varMakeStringNode(tok varToken, sig Signature) (varNode, error) {
	if sig.str != "" && sig.str != "s" && sig.str != "g" && sig.str != "o" {
		return nil, fmt.Errorf("invalid type %q for string", sig.str)
	}
	s, err := varParseString(tok.val)
	if err != nil {
		return nil, err
	}
	n := stringNode{str: s}
	if sig.str == "" {
		return stringNode{str: s}, nil
	}
	n.sig = sig
	switch sig.str {
	case "o":
		n.val = ObjectPath(s)
	case "g":
		n.val = Signature{s}
	case "s":
		n.val = s
	}
	return n, nil
}

func varParseString(s string) (string, error) {
	// quotes are guaranteed to be there
	s = s[1 : len(s)-1]
	buf := new(bytes.Buffer)
	for len(s) != 0 {
		r, size := utf8.DecodeRuneInString(s)
		if r == utf8.RuneError && size == 1 {
			return "", errors.New("invalid UTF-8")
		}
		s = s[size:]
		if r != '\\' {
			buf.WriteRune(r)
			continue
		}
		r, size = utf8.DecodeRuneInString(s)
		if r == utf8.RuneError && size == 1 {
			return "", errors.New("invalid UTF-8")
		}
		s = s[size:]
		switch r {
		case 'a':
			buf.WriteRune(0x7)
		case 'b':
			buf.WriteRune(0x8)
		case 'f':
			buf.WriteRune(0xc)
		case 'n':
			buf.WriteRune('\n')
		case 'r':
			buf.WriteRune('\r')
		case 't':
			buf.WriteRune('\t')
		case '\n':
		case 'u':
			if len(s) < 4 {
				return "", errors.New("short unicode escape")
			}
			r, err := strconv.ParseUint(s[:4], 16, 32)
			if err != nil {
				return "", err
			}
			buf.WriteRune(rune(r))
			s = s[4:]
		case 'U':
			if len(s) < 8 {
				return "", errors.New("short unicode escape")
			}
			r, err := strconv.ParseUint(s[:8], 16, 32)
			if err != nil {
				return "", err
			}
			buf.WriteRune(rune(r))
			s = s[8:]
		default:
			buf.WriteRune(r)
		}
	}
	return buf.String(), nil
}

var boolSigSet = sigSet{Signature{"b"}: true}

type boolNode bool

func (boolNode) Infer() (Signature, error) {
	return Signature{"b"}, nil
}

func (b boolNode) String() string {
	if b {
		return "true"
	}
	return "false"
}

func (boolNode) Sigs() sigSet {
	return boolSigSet
}

func (b boolNode) Value(sig Signature) (interface{}, error) {
	if sig.str != "b" {
		return nil, varTypeError{b.String(), sig}
	}
	return bool(b), nil
}

type arrayNode struct {
	set      sigSet
	children []varNode
	val      interface{}
}

func (n arrayNode) Infer() (Signature, error) {
	for _, v := range n.children {
		csig, err := varInfer(v)
		if err != nil {
			continue
		}
		return Signature{"a" + csig.str}, nil
	}
	return Signature{}, fmt.Errorf("can't infer type for %q", n.String())
}

func (n arrayNode) String() string {
	s := "["
	for i, v := range n.children {
		s += v.String()
		if i != len(n.children)-1 {
			s += ", "
		}
	}
	return s + "]"
}

func (n arrayNode) Sigs() sigSet {
	return n.set
}

func (n arrayNode) Value(sig Signature) (interface{}, error) {
	if n.set.Empty() {
		// no type information whatsoever, so this must be an empty slice
		return reflect.MakeSlice(typeFor(sig.str), 0, 0).Interface(), nil
	}
	if !n.set[sig] {
		return nil, varTypeError{n.String(), sig}
	}
	s := reflect.MakeSlice(typeFor(sig.str), len(n.children), len(n.children))
	for i, v := range n.children {
		rv, err := v.Value(Signature{sig.str[1:]})
		if err != nil {
			return nil, err
		}
		s.Index(i).Set(reflect.ValueOf(rv))
	}
	return s.Interface(), nil
}

func varMakeArrayNode(p *varParser, sig Signature) (varNode, error) {
	var n arrayNode
	if sig.str != "" {
		n.set = sigSet{sig: true}
	}
	if t := p.next(); t.typ == tokArrayEnd {
		return n, nil
	} else {
		p.backup()
	}
Loop:
	for {
		t := p.next()
		switch t.typ {
		case tokEOF:
			return nil, io.ErrUnexpectedEOF
		case tokError:
			return nil, errors.New(t.val)
		}
		p.backup()
		cn, err := varMakeNode(p)
		if err != nil {
			return nil, err
		}
		if cset := cn.Sigs(); !cset.Empty() {
			if n.set.Empty() {
				n.set = cset.ToArray()
			} else {
				nset := cset.ToArray().Intersect(n.set)
				if nset.Empty() {
					return nil, fmt.Errorf("can't parse %q with given type information", cn.String())
				}
				n.set = nset
			}
		}
		n.children = append(n.children, cn)
		switch t := p.next(); t.typ {
		case tokEOF:
			return nil, io.ErrUnexpectedEOF
		case tokError:
			return nil, errors.New(t.val)
		case tokArrayEnd:
			break Loop
		case tokComma:
			continue
		default:
			return nil, fmt.Errorf("unexpected %q", t.val)
		}
	}
	return n, nil
}

type variantNode struct {
	n varNode
}

var variantSet = sigSet{
	Signature{"v"}: true,
}

func (variantNode) Infer() (Signature, error) {
	return Signature{"v"}, nil
}

func (n variantNode) String() string {
	return "<" + n.n.String() + ">"
}

func (variantNode) Sigs() sigSet {
	return variantSet
}

func (n variantNode) Value(sig Signature) (interface{}, error) {
	if sig.str != "v" {
		return nil, varTypeError{n.String(), sig}
	}
	sig, err := varInfer(n.n)
	if err != nil {
		return nil, err
	}
	v, err := n.n.Value(sig)
	if err != nil {
		return nil, err
	}
	return MakeVariant(v), nil
}

func varMakeVariantNode(p *varParser, sig Signature) (varNode, error) {
	n, err := varMakeNode(p)
	if err != nil {
		return nil, err
	}
	if t := p.next(); t.typ != tokVariantEnd {
		return nil, fmt.Errorf("unexpected %q", t.val)
	}
	vn := variantNode{n}
	if sig.str != "" && sig.str != "v" {
		return nil, varTypeError{vn.String(), sig}
	}
	return variantNode{n}, nil
}

type dictEntry struct {
	key, val varNode
}

type dictNode struct {
	kset, vset sigSet
	children   []dictEntry
	val        interface{}
}

func (n dictNode) Infer() (Signature, error) {
	for _, v := range n.children {
		ksig, err := varInfer(v.key)
		if err != nil {
			continue
		}
		vsig, err := varInfer(v.val)
		if err != nil {
			continue
		}
		return Signature{"a{" + ksig.str + vsig.str + "}"}, nil
	}
	return Signature{}, fmt.Errorf("can't infer type for %q", n.String())
}

func (n dictNode) String() string {
	s := "{"
	for i, v := range n.children {
		s += v.key.String() + ": " + v.val.String()
		if i != len(n.children)-1 {
			s += ", "
		}
	}
	return s + "}"
}

func (n dictNode) Sigs() sigSet {
	r := sigSet{}
	for k := range n.kset {
		for v := range n.vset {
			sig := "a{" + k.str + v.str + "}"
			r[Signature{sig}] = true
		}
	}
	return r
}

func (n dictNode) Value(sig Signature) (interface{}, error) {
	set := n.Sigs()
	if set.Empty() {
		// no type information -> empty dict
		return reflect.MakeMap(typeFor(sig.str)).Interface(), nil
	}
	if !set[sig] {
		return nil, varTypeError{n.String(), sig}
	}
	m := reflect.MakeMap(typeFor(sig.str))
	ksig := Signature{sig.str[2:3]}
	vsig := Signature{sig.str[3 : len(sig.str)-1]}
	for _, v := range n.children {
		kv, err := v.key.Value(ksig)
		if err != nil {
			return nil, err
		}
		vv, err := v.val.Value(vsig)
		if err != nil {
			return nil, err
		}
		m.SetMapIndex(reflect.ValueOf(kv), reflect.ValueOf(vv))
	}
	return m.Interface(), nil
}

func varMakeDictNode(p *varParser, sig Signature) (varNode, error) {
	var n dictNode

	if sig.str != "" {
		if len(sig.str) < 5 {
			return nil, fmt.Errorf("invalid signature %q for dict type", sig)
		}
		ksig := Signature{string(sig.str[2])}
		vsig := Signature{sig.str[3 : len(sig.str)-1]}
		n.kset = sigSet{ksig: true}
		n.vset = sigSet{vsig: true}
	}
	if t := p.next(); t.typ == tokDictEnd {
		return n, nil
	} else {
		p.backup()
	}
Loop:
	for {
		t := p.next()
		switch t.typ {
		case tokEOF:
			return nil, io.ErrUnexpectedEOF
		case tokError:
			return nil, errors.New(t.val)
		}
		p.backup()
		kn, err := varMakeNode(p)
		if err != nil {
			return nil, err
		}
		if kset := kn.Sigs(); !kset.Empty() {
			if n.kset.Empty() {
				n.kset = kset
			} else {
				n.kset = kset.Intersect(n.kset)
				if n.kset.Empty() {
					return nil, fmt.Errorf("can't parse %q with given type information", kn.String())
				}
			}
		}
		t = p.next()
		switch t.typ {
		case tokEOF:
			return nil, io.ErrUnexpectedEOF
		case tokError:
			return nil, errors.New(t.val)
		case tokColon:
		default:
			return nil, fmt.Errorf("unexpected %q", t.val)
		}
		t = p.next()
		switch t.typ {
		case tokEOF:
			return nil, io.ErrUnexpectedEOF
		case tokError:
			return nil, errors.New(t.val)
		}
		p.backup()
		vn, err := varMakeNode(p)
		if err != nil {
			return nil, err
		}
		if vset := vn.Sigs(); !vset.Empty() {
			if n.vset.Empty() {
				n.vset = vset
			} else {
				n.vset = n.vset.Intersect(vset)
				if n.vset.Empty() {
					return nil, fmt.Errorf("can't parse %q with given type information", vn.String())
				}
			}
		}
		n.children = append(n.children, dictEntry{kn, vn})
		t = p.next()
		switch t.typ {
		case tokEOF:
			return nil, io.ErrUnexpectedEOF
		case tokError:
			return nil, errors.New(t.val)
		case tokDictEnd:
			break Loop
		case tokComma:
			continue
		default:
			return nil, fmt.Errorf("unexpected %q", t.val)
		}
	}
	return n, nil
}

type byteStringNode []byte

var byteStringSet = sigSet{
	Signature{"ay"}: true,
}

func (byteStringNode) Infer() (Signature, error) {
	return Signature{"ay"}, nil
}

func (b byteStringNode) String() string {
	return string(b)
}

func (b byteStringNode) Sigs() sigSet {
	return byteStringSet
}

func (b byteStringNode) Value(sig Signature) (interface{}, error) {
	if sig.str != "ay" {
		return nil, varTypeError{b.String(), sig}
	}
	return []byte(b), nil
}

func varParseByteString(s string) ([]byte, error) {
	// quotes and b at start are guaranteed to be there
	b := make([]byte, 0, 1)
	s = s[2 : len(s)-1]
	for len(s) != 0 {
		c := s[0]
		s = s[1:]
		if c != '\\' {
			b = append(b, c)
			continue
		}
		c = s[0]
		s = s[1:]
		switch c {
		case 'a':
			b = append(b, 0x7)
		case 'b':
			b = append(b, 0x8)
		case 'f':
			b = append(b, 0xc)
		case 'n':
			b = append(b, '\n')
		case 'r':
			b = append(b, '\r')
		case 't':
			b = append(b, '\t')
		case 'x':
			if len(s) < 2 {
				return nil, errors.New("short escape")
			}
			n, err := strconv.ParseUint(s[:2], 16, 8)
			if err != nil {
				return nil, err
			}
			b = append(b, byte(n))
			s = s[2:]
		case '0':
			if len(s) < 3 {
				return nil, errors.New("short escape")
			}
			n, err := strconv.ParseUint(s[:3], 8, 8)
			if err != nil {
				return nil, err
			}
			b = append(b, byte(n))
			s = s[3:]
		default:
			b = append(b, c)
		}
	}
	return append(b, 0), nil
}

func varInfer(n varNode) (Signature, error) {
	if sig, ok := n.Sigs().Single(); ok {
		return sig, nil
	}
	return n.Infer()
}