blob: 38e6a7099c493d5c3b0f4ccc91efd26c167755b3 [file] [log] [blame]
// Copyright 2018 The CUE Authors
//
// 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 cue
import (
"bytes"
"encoding/json"
"fmt"
"io"
"math"
"math/big"
"strconv"
"strings"
"unicode"
"cuelang.org/go/cue/ast"
"cuelang.org/go/cue/errors"
"cuelang.org/go/cue/token"
"github.com/cockroachdb/apd/v2"
)
// Kind determines the underlying type of a Value.
type Kind int
const (
// BottomKind is the error value.
BottomKind Kind = 1 << iota
// NullKind indicates a null value.
NullKind
// BoolKind indicates a boolean value.
BoolKind
// IntKind represents an integral number.
IntKind
// FloatKind represents a decimal float point number that cannot be
// converted to an integer. The underlying number may still be integral,
// but resulting from an operation that enforces the float type.
FloatKind
// StringKind indicates any kind of string.
StringKind
// BytesKind is a blob of data.
BytesKind
// StructKind is a kev-value map.
StructKind
// ListKind indicates a list of values.
ListKind
nextKind
// NumberKind represents any kind of number.
NumberKind = IntKind | FloatKind
)
// An structValue represents a JSON object.
//
// TODO: remove
type structValue struct {
ctx *context
path *valueData
n *structLit
}
// Len reports the number of fields in this struct.
func (o *structValue) Len() int {
if o.n == nil {
return 0
}
return len(o.n.arcs)
}
// At reports the key and value of the ith field, i < o.Len().
func (o *structValue) At(i int) (key string, v Value) {
a := o.n.arcs[i]
v = newChildValue(o, i)
return o.ctx.labelStr(a.feature), v
}
// Lookup reports the field for the given key. The returned Value is invalid
// if it does not exist.
func (o *structValue) Lookup(key string) Value {
f := o.ctx.strLabel(key)
i := 0
len := o.Len()
for ; i < len; i++ {
if o.n.arcs[i].feature == f {
break
}
}
if i == len {
// TODO: better message.
return newValueRoot(o.ctx, o.ctx.mkErr(o.n, codeNotExist,
"value %q not found", key))
}
// v, _ := o.n.lookup(o.ctx, f)
// v = o.ctx.manifest(v)
return newChildValue(o, i)
}
// MarshalJSON returns a valid JSON encoding or reports an error if any of the
// fields is invalid.
func (o *structValue) marshalJSON() (b []byte, err errors.Error) {
b = append(b, '{')
n := o.Len()
for i := 0; i < n; i++ {
k, v := o.At(i)
s, err := json.Marshal(k)
if err != nil {
return nil, unwrapJSONError(err)
}
b = append(b, s...)
b = append(b, ':')
bb, err := json.Marshal(v)
if err != nil {
return nil, unwrapJSONError(err)
}
b = append(b, bb...)
if i < n-1 {
b = append(b, ',')
}
}
b = append(b, '}')
return b, nil
}
var _ errors.Error = &marshalError{}
type marshalError struct {
err errors.Error
}
func toMarshalErr(v Value, b *bottom) error {
return &marshalError{v.toErr(b)}
}
func marshalErrf(v Value, src source, msg string, args ...interface{}) error {
arguments := append([]interface{}{msg}, args...)
b := v.idx.mkErr(src, arguments...)
return toMarshalErr(v, b)
}
func (e *marshalError) Error() string {
path := e.Path()
if len(path) == 0 {
return fmt.Sprintf("cue: marshal error: %v", e.err)
}
p := strings.Join(path, ".")
return fmt.Sprintf("cue: marshal error at path %s: %v", p, e.err)
}
func (e *marshalError) Path() []string { return e.err.Path() }
func (e *marshalError) Msg() (string, []interface{}) { return e.err.Msg() }
func (e *marshalError) Position() token.Pos { return e.err.Position() }
func (e *marshalError) InputPositions() []token.Pos {
return e.err.InputPositions()
}
func unwrapJSONError(err error) errors.Error {
switch x := err.(type) {
case *json.MarshalerError:
return unwrapJSONError(x.Err)
case *marshalError:
return x
case errors.Error:
return &marshalError{x}
default:
return &marshalError{errors.Wrapf(err, token.NoPos, "json error")}
}
}
// An Iterator iterates over values.
//
type Iterator struct {
val Value
ctx *context
iter iterAtter
len int
p int
cur Value
f label
}
// Next advances the iterator to the next value and reports whether there was
// any. It must be called before the first call to Value or Key.
func (i *Iterator) Next() bool {
if i.p >= i.len {
i.cur = Value{}
return false
}
arc := i.iter.iterAt(i.ctx, i.p)
i.cur = i.val.makeChild(i.ctx, uint32(i.p), arc)
i.f = arc.feature
i.p++
return true
}
// Value returns the current value in the list. It will panic if Next advanced
// past the last entry.
func (i *Iterator) Value() Value {
return i.cur
}
// Label reports the label of the value if i iterates over struct fields and
// "" otherwise.
func (i *Iterator) Label() string {
if i.f == 0 {
return ""
}
return i.ctx.labelStr(i.f)
}
// IsHidden reports if a field is hidden from the data model.
func (i *Iterator) IsHidden() bool {
return i.f&hidden != 0
}
// IsOptional reports if a field is optional.
func (i *Iterator) IsOptional() bool {
return i.cur.path.arc.optional
}
// marshalJSON iterates over the list and generates JSON output. HasNext
// will return false after this operation.
func marshalList(l *Iterator) (b []byte, err errors.Error) {
b = append(b, '[')
if l.Next() {
for i := 0; ; i++ {
x, err := json.Marshal(l.Value())
if err != nil {
return nil, unwrapJSONError(err)
}
b = append(b, x...)
if !l.Next() {
break
}
b = append(b, ',')
}
}
b = append(b, ']')
return b, nil
}
func (v Value) getNum(k kind) (*numLit, errors.Error) {
v, _ = v.Default()
if err := v.checkKind(v.ctx(), k); err != nil {
return nil, v.toErr(err)
}
n, _ := v.path.cache.(*numLit)
return n, nil
}
// MantExp breaks x into its mantissa and exponent components and returns the
// exponent. If a non-nil mant argument is provided its value is set to the
// mantissa of x. The components satisfy x == mant × 10**exp. It returns an
// error if v is not a number.
//
// The components are not normalized. For instance, 2.00 is represented mant ==
// 200 and exp == -2. Calling MantExp with a nil argument is an efficient way to
// get the exponent of the receiver.
func (v Value) MantExp(mant *big.Int) (exp int, err error) {
n, err := v.getNum(numKind)
if err != nil {
return 0, err
}
if n.v.Form != 0 {
return 0, ErrInfinite
}
if mant != nil {
mant.Set(&n.v.Coeff)
if n.v.Negative {
mant.Neg(mant)
}
}
return int(n.v.Exponent), nil
}
// AppendInt appends the string representation of x in the given base to buf and
// returns the extended buffer, or an error if the underlying number was not
// an integer.
func (v Value) AppendInt(buf []byte, base int) ([]byte, error) {
i, err := v.Int(nil)
if err != nil {
return nil, err
}
return i.Append(buf, base), nil
}
// AppendFloat appends to buf the string form of the floating-point number x.
// It returns an error if v is not a number.
func (v Value) AppendFloat(buf []byte, fmt byte, prec int) ([]byte, error) {
n, err := v.getNum(numKind)
if err != nil {
return nil, err
}
ctx := apd.BaseContext
nd := int(apd.NumDigits(&n.v.Coeff)) + int(n.v.Exponent)
if n.v.Form == apd.Infinite {
if n.v.Negative {
buf = append(buf, '-')
}
return append(buf, string('∞')...), nil
}
if fmt == 'f' && nd > 0 {
ctx.Precision = uint32(nd + prec)
} else {
ctx.Precision = uint32(prec)
}
var d apd.Decimal
ctx.Round(&d, &n.v)
return d.Append(buf, fmt), nil
}
var (
// ErrBelow indicates that a value was rounded down in a conversion.
ErrBelow = errors.New("cue: value was rounded down")
// ErrAbove indicates that a value was rounded up in a conversion.
ErrAbove = errors.New("cue: value was rounded up")
// ErrInfinite indicates that a value is infinite.
ErrInfinite = errors.New("cue: infinite")
)
// Int converts the underlying integral number to an big.Int. It reports an
// error if the underlying value is not an integer type. If a non-nil *Int
// argument z is provided, Int stores the result in z instead of allocating a
// new Int.
func (v Value) Int(z *big.Int) (*big.Int, error) {
n, err := v.getNum(intKind)
if err != nil {
return nil, err
}
if z == nil {
z = &big.Int{}
}
if n.v.Exponent != 0 {
panic("cue: exponent should always be nil for integer types")
}
z.Set(&n.v.Coeff)
if n.v.Negative {
z.Neg(z)
}
return z, nil
}
// Int64 converts the underlying integral number to int64. It reports an
// error if the underlying value is not an integer type or cannot be represented
// as an int64. The result is (math.MinInt64, ErrAbove) for x < math.MinInt64,
// and (math.MaxInt64, ErrBelow) for x > math.MaxInt64.
func (v Value) Int64() (int64, error) {
n, err := v.getNum(intKind)
if err != nil {
return 0, err
}
if !n.v.Coeff.IsInt64() {
if n.v.Negative {
return math.MinInt64, ErrAbove
}
return math.MaxInt64, ErrBelow
}
i := n.v.Coeff.Int64()
if n.v.Negative {
i = -i
}
return i, nil
}
// Uint64 converts the underlying integral number to uint64. It reports an
// error if the underlying value is not an integer type or cannot be represented
// as a uint64. The result is (0, ErrAbove) for x < 0, and
// (math.MaxUint64, ErrBelow) for x > math.MaxUint64.
func (v Value) Uint64() (uint64, error) {
n, err := v.getNum(intKind)
if err != nil {
return 0, err
}
if n.v.Negative {
return 0, ErrAbove
}
if !n.v.Coeff.IsUint64() {
return math.MaxUint64, ErrBelow
}
i := n.v.Coeff.Uint64()
return i, nil
}
// trimZeros trims 0's for better JSON respresentations.
func trimZeros(s string) string {
n1 := len(s)
s2 := strings.TrimRight(s, "0")
n2 := len(s2)
if p := strings.IndexByte(s2, '.'); p != -1 {
if p == n2-1 {
return s[:len(s2)+1]
}
return s2
}
if n1-n2 <= 4 {
return s
}
return fmt.Sprint(s2, "e+", n1-n2)
}
var (
smallestPosFloat64 *apd.Decimal
smallestNegFloat64 *apd.Decimal
maxPosFloat64 *apd.Decimal
maxNegFloat64 *apd.Decimal
)
func init() {
const (
// math.SmallestNonzeroFloat64: 1 / 2**(1023 - 1 + 52)
smallest = "4.940656458412465441765687928682213723651e-324"
// math.MaxFloat64: 2**1023 * (2**53 - 1) / 2**52
max = "1.797693134862315708145274237317043567981e+308"
)
ctx := apd.BaseContext
ctx.Precision = 40
var err error
smallestPosFloat64, _, err = ctx.NewFromString(smallest)
if err != nil {
panic(err)
}
smallestNegFloat64, _, err = ctx.NewFromString("-" + smallest)
if err != nil {
panic(err)
}
maxPosFloat64, _, err = ctx.NewFromString(max)
if err != nil {
panic(err)
}
maxNegFloat64, _, err = ctx.NewFromString("-" + max)
if err != nil {
panic(err)
}
}
// Float64 returns the float64 value nearest to x. It reports an error if v is
// not a number. If x is too small to be represented by a float64 (|x| <
// math.SmallestNonzeroFloat64), the result is (0, ErrBelow) or (-0, ErrAbove),
// respectively, depending on the sign of x. If x is too large to be represented
// by a float64 (|x| > math.MaxFloat64), the result is (+Inf, ErrAbove) or
// (-Inf, ErrBelow), depending on the sign of x.
func (v Value) Float64() (float64, error) {
n, err := v.getNum(numKind)
if err != nil {
return 0, err
}
if n.v.Negative {
if n.v.Cmp(smallestNegFloat64) == 1 {
return -0, ErrAbove
}
if n.v.Cmp(maxNegFloat64) == -1 {
return math.Inf(-1), ErrBelow
}
} else {
if n.v.Cmp(smallestPosFloat64) == -1 {
return 0, ErrBelow
}
if n.v.Cmp(maxPosFloat64) == 1 {
return math.Inf(1), ErrAbove
}
}
f, _ := n.v.Float64()
return f, nil
}
type valueData struct {
parent *valueData
index uint32
arc
}
// path returns the path of the value.
func (v *valueData) appendPath(a []string, idx *index) ([]string, kind) {
var k kind
if v.parent != nil {
a, k = v.parent.appendPath(a, idx)
}
switch k {
case listKind:
a = append(a, strconv.FormatInt(int64(v.index), 10))
case structKind:
f := idx.labelStr(v.arc.feature)
if !isIdent(f) && !isNumber(f) {
f = quote(f, '"')
}
a = append(a, f)
}
return a, v.arc.cache.kind()
}
var validIdent = []*unicode.RangeTable{unicode.L, unicode.N}
func isIdent(s string) bool {
valid := []*unicode.RangeTable{unicode.Letter}
for _, r := range s {
if !unicode.In(r, valid...) && r != '_' {
return false
}
valid = validIdent
}
return true
}
func isNumber(s string) bool {
for _, r := range s {
if r < '0' || '9' < r {
return false
}
}
return true
}
// Value holds any value, which may be a Boolean, Error, List, Null, Number,
// Struct, or String.
type Value struct {
idx *index
path *valueData
}
func newValueRoot(ctx *context, x value) Value {
v := x.evalPartial(ctx)
return Value{ctx.index, &valueData{nil, 0, arc{cache: v, v: x}}}
}
func newChildValue(obj *structValue, i int) Value {
a := obj.n.arcs[i]
a.cache = obj.n.at(obj.ctx, i)
return Value{obj.ctx.index, &valueData{obj.path, uint32(i), a}}
}
func remakeValue(base Value, v value) Value {
path := *base.path
path.v = v
path.cache = v.evalPartial(base.ctx())
return Value{base.idx, &path}
}
func (v Value) ctx() *context {
return v.idx.newContext()
}
func (v Value) makeChild(ctx *context, i uint32, a arc) Value {
return Value{v.idx, &valueData{v.path, i, a}}
}
func (v Value) eval(ctx *context) value {
if v.path == nil || v.path.cache == nil {
panic("undefined value")
}
return ctx.manifest(v.path.cache)
}
// Eval resolves the references of a value and returns the result.
// This method is not necessary to obtain concrete values.
func (v Value) Eval() Value {
if v.path == nil {
return v
}
return remakeValue(v, v.path.v.evalPartial(v.ctx()))
}
// Default reports the default value and whether it existed. It returns the
// normal value if there is no default.
func (v Value) Default() (Value, bool) {
if v.path == nil {
return v, false
}
u := v.path.v.evalPartial(v.ctx())
x := v.ctx().manifest(u)
if x != u {
return remakeValue(v, x), true
}
return v, false
}
// Label reports he label used to obtain this value from the enclosing struct.
//
// TODO: get rid of this somehow. Probably by including a FieldInfo struct
// or the like.
func (v Value) Label() (string, bool) {
if v.path.feature == 0 {
return "", false
}
return v.idx.labelStr(v.path.feature), true
}
// Kind returns the kind of value. It returns BottomKind for atomic values that
// are not concrete. For instance, it will return BottomKind for the bounds
// >=0.
func (v Value) Kind() Kind {
if v.path == nil {
return BottomKind
}
k := v.path.v.evalPartial(v.ctx()).kind()
if k.isGround() {
switch {
case k.isAnyOf(nullKind):
return NullKind
case k.isAnyOf(boolKind):
return BoolKind
case k&numKind == (intKind):
return IntKind
case k&numKind == (floatKind):
return FloatKind
case k.isAnyOf(numKind):
return NumberKind
case k.isAnyOf(bytesKind):
return BytesKind
case k.isAnyOf(stringKind):
return StringKind
case k.isAnyOf(structKind):
return StructKind
case k.isAnyOf(listKind):
return ListKind
}
}
return BottomKind
}
// IncompleteKind returns a mask of all kinds that this value may be.
func (v Value) IncompleteKind() Kind {
if v.path == nil {
return BottomKind
}
k := v.path.v.evalPartial(v.ctx()).kind()
vk := BottomKind // Everything is a bottom kind.
for i := kind(1); i < nonGround; i <<= 1 {
if k&i != 0 {
switch i {
case nullKind:
vk |= NullKind
case boolKind:
vk |= BoolKind
case intKind:
vk |= IntKind
case floatKind:
vk |= FloatKind
case stringKind:
vk |= StringKind
case bytesKind:
vk |= BytesKind
case structKind:
vk |= StructKind
case listKind:
vk |= ListKind
}
}
}
return vk
}
// MarshalJSON marshalls this value into valid JSON.
func (v Value) MarshalJSON() (b []byte, err error) {
b, err = v.marshalJSON()
if err != nil {
return nil, unwrapJSONError(err)
}
return b, nil
}
func (v Value) marshalJSON() (b []byte, err error) {
v, _ = v.Default()
if v.path == nil {
return json.Marshal(nil)
}
ctx := v.idx.newContext()
x := v.eval(ctx)
// TODO: implement marshalles in value.
switch k := x.kind(); k {
case nullKind:
return json.Marshal(nil)
case boolKind:
return json.Marshal(x.(*boolLit).b)
case intKind, floatKind, numKind:
return x.(*numLit).v.MarshalText()
case stringKind:
return json.Marshal(x.(*stringLit).str)
case bytesKind:
return json.Marshal(x.(*bytesLit).b)
case listKind:
l := x.(*list)
i := Iterator{ctx: ctx, val: v, iter: l, len: len(l.elem.arcs)}
return marshalList(&i)
case structKind:
obj, _ := v.structVal(ctx)
return obj.marshalJSON()
case bottomKind:
return nil, toMarshalErr(v, x.(*bottom))
default:
if k.hasReferences() {
return nil, marshalErrf(v, x, "value %q contains unresolved references", debugStr(ctx, x))
}
if !k.isGround() {
return nil, marshalErrf(v, x, "cannot convert incomplete value %q to JSON", debugStr(ctx, x))
}
return nil, marshalErrf(v, x, "cannot convert value %q of type %T to JSON", debugStr(ctx, x), x)
}
}
// Syntax converts the possibly partially evaluated value into syntax. This
// can use used to print the value with package format.
func (v Value) Syntax(opts ...Option) ast.Node {
if v.path == nil || v.path.cache == nil {
return nil
}
ctx := v.ctx()
o := getOptions(opts)
if o.raw {
return export(ctx, v.path.v, o)
}
return export(ctx, v.path.cache, o)
}
// Decode initializes x with Value v. If x is a struct, it will validate the
// constraints specified in the field tags.
func (v Value) Decode(x interface{}) error {
// TODO: optimize
b, err := v.MarshalJSON()
if err != nil {
return err
}
return json.Unmarshal(b, x)
}
// // EncodeJSON generates JSON for the given value.
// func (v Value) EncodeJSON(w io.Writer, v Value) error {
// return nil
// }
// Doc returns all documentation comments associated with the field from which
// the current value originates.
func (v Value) Doc() []*ast.CommentGroup {
if v.path == nil {
return nil
}
return v.path.docs.appendDocs(nil)
}
// Split returns a list of values from which v originated such that
// the unification of all these values equals v and for all returned values
// Source returns a non-nil value.
func (v Value) Split() []Value {
if v.path == nil {
return nil
}
ctx := v.ctx()
a := []Value{}
for _, x := range separate(v.path.v) {
path := *v.path
path.cache = x.evalPartial(ctx)
path.v = x
a = append(a, Value{v.idx, &path})
}
return a
}
func separate(v value) (a []value) {
c := v.computed()
if c == nil || c.op != opUnify {
return []value{v}
}
if c.x != nil {
a = append(a, separate(c.x)...)
}
if c.y != nil {
a = append(a, separate(c.y)...)
}
return a
}
// Source returns the original node for this value. The return value may not
// be a syntax.Expr. For instance, a struct kind may be represented by a
// struct literal, a field comprehension, or a file. It returns nil for
// computed nodes. Use Split to get all source values that apply to a field.
func (v Value) Source() ast.Node {
if v.path == nil {
return nil
}
return v.path.v.syntax()
}
// Err returns the error represented by v or nil v is not an error.
func (v Value) Err() error {
if err := v.checkKind(v.ctx(), bottomKind); err != nil {
return v.toErr(err)
}
return nil
}
// Pos returns position information.
func (v Value) Pos() token.Pos {
if v.path == nil || v.Source() == nil {
return token.NoPos
}
pos := v.Source().Pos()
return pos
}
// IsConcrete reports whether the current value is a concrete scalar value,
// not relying on default values, a terminal error, a list, or a struct.
// It does not verify that values of lists or structs are concrete themselves.
// To check whether there is a concrete default, use v.Default().IsConcrete().
func (v Value) IsConcrete() bool {
if v.path == nil {
return false // any is neither concrete, not a list or struct.
}
x := v.path.v.evalPartial(v.ctx())
// Errors marked as incomplete are treated as not complete.
if isIncomplete(x) {
return false
}
// Other errors are considered ground.
return x.kind().isGround()
}
// IsIncomplete is deprecated.
//
// It indicates that the value cannot be fully evaluated due to
// insufficient information.
func (v Value) IsIncomplete() bool {
// TODO: remove
x := v.eval(v.ctx())
if x.kind().hasReferences() || !x.kind().isGround() {
return true
}
return isIncomplete(x)
}
// IsValid reports whether this value is defined and evaluates to something
// other than an error.
func (v Value) IsValid() bool {
if v.path == nil || v.path.cache == nil {
return false
}
k := v.eval(v.ctx()).kind()
return k != bottomKind && !v.IsIncomplete()
}
// Exists reports whether this value existed in the configuration.
func (v Value) Exists() bool {
if v.path == nil {
return false
}
return exists(v.eval(v.ctx()))
}
func (v Value) checkKind(ctx *context, want kind) *bottom {
if v.path == nil {
return errNotExists
}
// TODO: use checkKind
x := v.eval(ctx)
if b, ok := x.(*bottom); ok {
return b
}
got := x.kind()
if want != bottomKind {
if got&want&concreteKind == bottomKind {
return ctx.mkErr(x, "not of right kind (%v vs %v)", got, want)
}
if !got.isGround() {
return ctx.mkErr(x, codeIncomplete,
"non-concrete value %v", got)
}
}
return nil
}
func makeInt(v Value, x int64) Value {
n := &numLit{numBase: numBase{baseValue: v.path.v.base()}}
n.v.SetInt64(x)
return remakeValue(v, n)
}
// Len returns the number of items of the underlying value.
// For lists it reports the capacity of the list. For structs it indicates the
// number of fields, for bytes the number of bytes.
func (v Value) Len() Value {
if v.path != nil {
switch x := v.path.v.evalPartial(v.ctx()).(type) {
case *list:
return remakeValue(v, x.len.evalPartial(v.ctx()))
case *bytesLit:
return makeInt(v, int64(x.len()))
case *stringLit:
return makeInt(v, int64(x.len()))
}
}
const msg = "len not supported for type %v"
return remakeValue(v, v.ctx().mkErr(v.path.v, msg, v.Kind()))
}
// Elem returns the value of undefined element types of lists and structs.
func (v Value) Elem() (Value, bool) {
ctx := v.ctx()
switch x := v.path.v.(type) {
case *structLit:
if x.template == nil {
break
}
fn, ok := ctx.manifest(x.template).(*lambdaExpr)
if !ok {
// TODO: return an error instead.
break
}
// Note, this template does not maintain the relation between the
// the attribute value and the instance.
y := fn.call(ctx, x, &basicType{x.baseValue, stringKind})
return newValueRoot(ctx, y), true
case *list:
return newValueRoot(ctx, x.typ), true
}
return Value{}, false
}
// List creates an iterator over the values of a list or reports an error if
// v is not a list.
func (v Value) List() (Iterator, error) {
v, _ = v.Default()
ctx := v.ctx()
if err := v.checkKind(ctx, listKind); err != nil {
return Iterator{ctx: ctx}, v.toErr(err)
}
l := v.eval(ctx).(*list)
return Iterator{ctx: ctx, val: v, iter: l, len: len(l.elem.arcs)}, nil
}
// Null reports an error if v is not null.
func (v Value) Null() error {
v, _ = v.Default()
if err := v.checkKind(v.ctx(), nullKind); err != nil {
return v.toErr(err)
}
return nil
}
// // IsNull reports whether v is null.
// func (v Value) IsNull() bool {
// return v.Null() == nil
// }
// Bool returns the bool value of v or false and an error if v is not a boolean.
func (v Value) Bool() (bool, error) {
v, _ = v.Default()
ctx := v.ctx()
if err := v.checkKind(ctx, boolKind); err != nil {
return false, v.toErr(err)
}
return v.eval(ctx).(*boolLit).b, nil
}
// String returns the string value if v is a string or an error otherwise.
func (v Value) String() (string, error) {
v, _ = v.Default()
ctx := v.ctx()
if err := v.checkKind(ctx, stringKind); err != nil {
return "", v.toErr(err)
}
return v.eval(ctx).(*stringLit).str, nil
}
// Bytes returns a byte slice if v represents a list of bytes or an error
// otherwise.
func (v Value) Bytes() ([]byte, error) {
v, _ = v.Default()
ctx := v.ctx()
switch x := v.eval(ctx).(type) {
case *bytesLit:
return append([]byte(nil), x.b...), nil
case *stringLit:
return []byte(x.str), nil
}
return nil, v.toErr(v.checkKind(ctx, bytesKind|stringKind))
}
// Reader returns a new Reader if v is a string or bytes type and an error
// otherwise.
func (v Value) Reader() (io.Reader, error) {
v, _ = v.Default()
ctx := v.ctx()
switch x := v.eval(ctx).(type) {
case *bytesLit:
return bytes.NewReader(x.b), nil
case *stringLit:
return strings.NewReader(x.str), nil
}
return nil, v.toErr(v.checkKind(ctx, stringKind|bytesKind))
}
// TODO: distinguish between optional, hidden, etc. Probably the best approach
// is to mark options in context and have a single function for creating
// a structVal.
// structVal returns an structVal or an error if v is not a struct.
func (v Value) structVal(ctx *context) (structValue, *bottom) {
return v.structValOpts(ctx, options{
omitHidden: true,
omitOptional: true,
})
}
// structVal returns an structVal or an error if v is not a struct.
func (v Value) structValOpts(ctx *context, o options) (structValue, *bottom) {
v, _ = v.Default()
if err := v.checkKind(ctx, structKind); err != nil {
return structValue{}, err
}
obj := v.eval(ctx).(*structLit)
// TODO: This is expansion appropriate?
obj = obj.expandFields(ctx) // expand comprehensions
// check if any fields can be omitted
needFilter := false
if o.omitHidden || o.omitOptional {
f := label(0)
for _, a := range obj.arcs {
f |= a.feature
if o.omitOptional && a.optional {
needFilter = true
}
}
needFilter = needFilter || f&hidden != 0
}
if needFilter {
arcs := make([]arc, len(obj.arcs))
k := 0
for _, a := range obj.arcs {
if a.feature&hidden == 0 && !a.optional {
arcs[k] = a
k++
}
}
arcs = arcs[:k]
obj = &structLit{
obj.baseValue,
obj.emit,
obj.template,
nil,
arcs,
nil,
}
}
return structValue{ctx, v.path, obj}, nil
}
// Fields creates an iterator over v's fields if v is a struct or an error
// otherwise.
func (v Value) Fields(opts ...Option) (Iterator, error) {
o := options{omitHidden: true, omitOptional: true}
o.updateOptions(opts)
ctx := v.ctx()
obj, err := v.structValOpts(ctx, o)
if err != nil {
return Iterator{ctx: ctx}, v.toErr(err)
}
return Iterator{ctx: ctx, val: v, iter: obj.n, len: len(obj.n.arcs)}, nil
}
// Lookup reports the value starting from v, or an error if the path is not
// found. The empty path returns v itself.
//
// Lookup cannot be used to look up hidden fields.
func (v Value) Lookup(path ...string) Value {
ctx := v.ctx()
for _, k := range path {
obj, err := v.structVal(ctx)
if err != nil {
// TODO: return a Value at the same location and a new error?
return newValueRoot(ctx, err)
}
v = obj.Lookup(k)
}
return v
}
// Template returns a function that represents the template definition for a
// struct in a configuration file. It returns nil if v is not a struct kind or
// if there is no template associated with the struct.
//
// The returned function returns the value that would be unified with field
// given its name.
func (v Value) Template() func(label string) Value {
ctx := v.ctx()
x, ok := v.path.cache.(*structLit)
if !ok || x.template == nil {
return nil
}
fn, ok := ctx.manifest(x.template).(*lambdaExpr)
if !ok {
return nil
}
return func(label string) Value {
arg := &stringLit{x.baseValue, label, nil}
y := fn.call(ctx, x, arg)
return newValueRoot(ctx, y)
}
}
// Subsumes reports whether w is an instance of v.
//
// Value v and w must be obtained from the same build.
// TODO: remove this requirement.
func (v Value) Subsumes(w Value) bool {
ctx := v.ctx()
return subsumes(ctx, v.eval(ctx), w.eval(ctx), subChoose)
}
// Unify reports the greatest lower bound of v and w.
//
// Value v and w must be obtained from the same build.
// TODO: remove this requirement.
func (v Value) Unify(w Value) Value {
ctx := v.ctx()
if v.path == nil {
return w
}
if w.path == nil {
return v
}
a := v.path.v
b := w.path.v
src := binSrc(token.NoPos, opUnify, a, b)
val := mkBin(ctx, src.Pos(), opUnify, a, b)
if err := validate(ctx, val.evalPartial(ctx)); err != nil {
val = err
}
return newValueRoot(ctx, val)
}
// Format prints a debug version of a value.
func (v Value) Format(state fmt.State, verb rune) {
ctx := v.ctx()
if v.path == nil {
fmt.Fprint(state, "<nil>")
return
}
io.WriteString(state, debugStr(ctx, v.path.cache))
}
// Reference returns path from the root of the instance referred to by this
// value such that inst.Lookup(path) resolves to the same value, or no path if
// this value is not a reference,
func (v Value) Reference() (inst *Instance, path []string) {
// TODO: don't include references to hidden fields.
if v.path == nil {
return nil, nil
}
sel, ok := v.path.v.(*selectorExpr)
if !ok {
return nil, nil
}
imp, a := mkPath(v.ctx(), v.path, sel, 0)
return imp, a
}
func mkPath(c *context, up *valueData, sel *selectorExpr, d int) (imp *Instance, a []string) {
switch x := sel.x.(type) {
case *selectorExpr:
imp, a = mkPath(c, up.parent, x, d+1)
case *nodeRef:
// the parent must exist.
for ; up != nil && up.cache != x.node.(value); up = up.parent {
}
var v value
v, a = mkFromRoot(c, up, d+2)
if v == nil {
v = x.node
}
imp = c.getImportFromNode(x.node)
default:
panic("should not happend")
}
return imp, append(a, c.labelStr(sel.feature))
}
func mkFromRoot(c *context, up *valueData, d int) (root value, a []string) {
if up == nil {
return nil, make([]string, 0, d)
}
root, a = mkFromRoot(c, up.parent, d+1)
if up.parent != nil {
a = append(a, c.labelStr(up.feature))
} else {
root = up.v
}
return root, a
}
// References reports all references used to evaluate this value. It does not
// report references for sub fields if v is a struct.
//
// Deprecated: can be implemented in terms of Reference and Expr.
func (v Value) References() [][]string {
ctx := v.ctx()
pf := pathFinder{up: v.path}
raw := v.path.v
if raw == nil {
return nil
}
rewrite(ctx, raw, pf.find)
return pf.paths
}
type pathFinder struct {
paths [][]string
stack []string
up *valueData
}
func (p *pathFinder) find(ctx *context, v value) (value, bool) {
switch x := v.(type) {
case *selectorExpr:
i := len(p.stack)
p.stack = append(p.stack, ctx.labelStr(x.feature))
rewrite(ctx, x.x, p.find)
p.stack = p.stack[:i]
return v, false
case *nodeRef:
i := len(p.stack)
up := p.up
for ; up != nil && up.cache != x.node.(value); up = up.parent {
}
for ; up != nil && up.feature > 0; up = up.parent {
p.stack = append(p.stack, ctx.labelStr(up.feature))
}
path := make([]string, len(p.stack))
for i, v := range p.stack {
path[len(path)-1-i] = v
}
p.paths = append(p.paths, path)
p.stack = p.stack[:i]
return v, false
case *structLit: // handled in sub fields
return v, false
}
return v, true
}
type options struct {
concrete bool // enforce that values are concrete
raw bool // show original values
hasHidden bool
omitHidden bool
omitOptional bool
omitAttrs bool
}
// An Option defines modes of evaluation.
type Option option
type option func(p *options)
// Used in Iter, Validate, Subsume?, Fields() Syntax, Export
// TODO: could also be used for subsumption.
// Concrete ensures that all values are concrete.
//
// For Validate this means it returns an error if this is not the case.
// In other cases a non-concrete value will be replaced with an error.
func Concrete(concrete bool) Option {
return func(p *options) {
if concrete {
p.concrete = true
if !p.hasHidden {
p.omitHidden = true
}
} else {
p.raw = true
}
}
}
// All indicates that all fields and values should be included in processing
// even if they can be elided or omitted.
func All() Option {
return func(p *options) {
p.omitAttrs = false
p.omitHidden = false
p.omitOptional = false
}
}
// Hidden indicates that hidden fields should be included.
//
// Hidden fields may still be included if include is false,
// even if a value is not concrete.
func Hidden(include bool) Option {
return func(p *options) {
p.hasHidden = true
p.omitHidden = !include
}
}
// Optional indicates that optional fields should be included.
func Optional(include bool) Option {
return func(p *options) { p.omitOptional = !include }
}
// Attributes indicates that attributes should be included.
func Attributes(include bool) Option {
return func(p *options) { p.omitAttrs = !include }
}
func getOptions(opts []Option) (o options) {
o.updateOptions(opts)
return
}
func (o *options) updateOptions(opts []Option) {
for _, fn := range opts {
fn(o)
}
}
// Validate reports any errors, recursively. The returned error may represent
// more than one error, retrievable with errors.Errors, if more than one
// exists.
func (v Value) Validate(opts ...Option) error {
o := getOptions(opts)
var errs errors.Error
v.Walk(func(v Value) bool {
if err := v.checkKind(v.ctx(), bottomKind); err != nil {
if !o.concrete && isIncomplete(v.eval(v.ctx())) {
return false
}
errs = errors.Append(errs, v.toErr(err))
if len(errors.Errors(errs)) > 50 {
return false // mostly to avoid some hypothetical cycle issue
}
}
if o.concrete {
if err := isGroundRecursive(v.ctx(), v.eval(v.ctx())); err != nil {
errs = errors.Append(errs, v.toErr(err))
}
}
return true
}, nil)
return errors.Sanitize(errs)
}
func isGroundRecursive(ctx *context, v value) *bottom {
switch x := v.(type) {
case *list:
for i := 0; i < len(x.elem.arcs); i++ {
v := ctx.manifest(x.at(ctx, i))
if err := isGroundRecursive(ctx, v); err != nil {
return err
}
}
default:
if !x.kind().isGround() {
return ctx.mkErr(v, "incomplete value (%v)", debugStr(ctx, v))
}
}
return nil
}
// Walk descends into all values of v, calling f. If f returns false, Walk
// will not descent further.
func (v Value) Walk(before func(Value) bool, after func(Value)) {
ctx := v.ctx()
switch v.Kind() {
case StructKind:
if before != nil && !before(v) {
return
}
obj, _ := v.structVal(ctx)
for i := 0; i < obj.Len(); i++ {
_, v := obj.At(i)
v.Walk(before, after)
}
case ListKind:
if before != nil && !before(v) {
return
}
list, _ := v.List()
for list.Next() {
list.Value().Walk(before, after)
}
default:
if before != nil {
before(v)
}
}
if after != nil {
after(v)
}
}
// Attribute returns the attribute data for the given key.
// The returned attribute will return an error for any of its methods if there
// is no attribute for the requested key.
func (v Value) Attribute(key string) Attribute {
// look up the attributes
if v.path == nil || v.path.attrs == nil {
return Attribute{err: v.toErr(errNotExists)}
}
for _, a := range v.path.attrs.attr {
if a.key() != key {
continue
}
at := Attribute{}
if err := parseAttrBody(v.ctx(), nil, a.body(), &at.attr); err != nil {
return Attribute{err: err.(error)}
}
return at
}
return Attribute{err: v.toErr(errNotExists)}
}
// An Attribute contains meta data about a field.
type Attribute struct {
attr parsedAttr
err error
}
// Err returns the error associated with this Attribute or nil if this
// attribute is valid.
func (a *Attribute) Err() error {
return a.err
}
func (a *Attribute) hasPos(p int) error {
if a.err != nil {
return a.err
}
if p >= len(a.attr.fields) {
return fmt.Errorf("field does not exist")
}
return nil
}
// String reports the possibly empty string value at the given position or
// an error the attribute is invalid or if the position does not exist.
func (a *Attribute) String(pos int) (string, error) {
if err := a.hasPos(pos); err != nil {
return "", err
}
return a.attr.fields[pos].text(), nil
}
// Int reports the integer at the given position or an error if the attribute is
// invalid, the position does not exist, or the value at the given position is
// not an integer.
func (a *Attribute) Int(pos int) (int64, error) {
if err := a.hasPos(pos); err != nil {
return 0, err
}
// TODO: use CUE's literal parser once it exists, allowing any of CUE's
// number types.
return strconv.ParseInt(a.attr.fields[pos].text(), 10, 64)
}
// Flag reports whether an entry with the given name exists at position pos or
// onwards or an error if the attribute is invalid or if the first pos-1 entries
// are not defined.
func (a *Attribute) Flag(pos int, key string) (bool, error) {
if err := a.hasPos(pos - 1); err != nil {
return false, err
}
for _, kv := range a.attr.fields[pos:] {
if kv.text() == key {
return true, nil
}
}
return false, nil
}
// Lookup searches for an entry of the form key=value from position pos onwards
// and reports the value if found. It reports an error if the attribute is
// invalid or if the first pos-1 entries are not defined.
func (a *Attribute) Lookup(pos int, key string) (val string, found bool, err error) {
if err := a.hasPos(pos - 1); err != nil {
return "", false, err
}
for _, kv := range a.attr.fields[pos:] {
if kv.key() == key {
return kv.value(), true, nil
}
}
return "", false, nil
}
// Expr reports the operation of the underlying expression and the values it
// operates on. The returned values are appended to the given slice, which may
// be nil.
//
// For unary expressions, it returns the single value of the expression.
//
// For binary expressions it returns first the left and right value, in that
// order. For associative operations however, (for instance '&' and '|'), it may
// return more than two values, where the operation is to be applied in
// sequence.
//
// For selector and index expressions it returns the subject and then the index.
// For selectors, the index is the string value of the identifier. For slice
// expressions, it returns the subject, low value, and high value, in that
// order.
//
// For interpolations it returns a sequence of values to be concatenated, some
// of which will be literal strings and some unevaluated expressions.
//
// A builtin call expression returns the value of the builtin followed by the
// args of the call.
//
// If v is not an expression, Partial append v itself.
// TODO: return v if this is complete? Yes for now
// TODO: add values if a == nil?
func (v Value) Expr() (Op, []Value) {
if v.path == nil {
return NoOp, nil
}
// TODO: replace appends with []Value{}. For not leave.
a := []Value{}
op := NoOp
switch x := v.path.v.(type) {
case *binaryExpr:
a = append(a, remakeValue(v, x.left))
a = append(a, remakeValue(v, x.right))
op = opToOp[x.op]
case *unaryExpr:
a = append(a, remakeValue(v, x.x))
op = opToOp[x.op]
case *bound:
a = append(a, remakeValue(v, x.value))
op = opToOp[x.op]
case *unification:
// pre-expanded unification
for _, conjunct := range x.values {
a = append(a, remakeValue(v, conjunct))
}
op = AndOp
case *disjunction:
// Filter defaults that are subsumed by another value.
count := 0
outer:
for _, disjunct := range x.values {
if disjunct.marked {
for _, n := range x.values {
if !n.marked && subsumes(v.ctx(), n.val, disjunct.val, 0) {
continue outer
}
}
}
count++
a = append(a, remakeValue(v, disjunct.val))
}
if count > 1 {
op = OrOp
}
case *interpolation:
for _, p := range x.parts {
a = append(a, remakeValue(v, p))
}
op = InterpolationOp
case *selectorExpr:
a = append(a, remakeValue(v, x.x))
a = append(a, remakeValue(v, &stringLit{
x.baseValue,
v.ctx().labelStr(x.feature),
nil,
}))
op = SelectorOp
case *indexExpr:
a = append(a, remakeValue(v, x.x))
a = append(a, remakeValue(v, x.index))
op = IndexOp
case *sliceExpr:
a = append(a, remakeValue(v, x.x))
a = append(a, remakeValue(v, x.lo))
a = append(a, remakeValue(v, x.hi))
op = SliceOp
case *callExpr:
a = append(a, remakeValue(v, x.x))
for _, arg := range x.args {
a = append(a, remakeValue(v, arg))
}
op = CallOp
default:
a = append(a, v)
}
return op, a
}