You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
123 lines
2.7 KiB
123 lines
2.7 KiB
// Package vm implements the execution of gg.Graphs as programs.
|
|
package vm
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
|
|
"code.betamike.com/mediocregopher/ginger/gg"
|
|
"code.betamike.com/mediocregopher/ginger/graph"
|
|
)
|
|
|
|
// ZeroValue is a Value with no fields set. It is equivalent to the 0-tuple.
|
|
var ZeroValue Value
|
|
|
|
// Value extends a gg.Value to include Functions and Tuples as a possible
|
|
// types.
|
|
type Value struct {
|
|
gg.Value
|
|
|
|
Function
|
|
Tuple []Value
|
|
}
|
|
|
|
// Tuple returns a tuple Value comprising the given Values. Calling Tuple with
|
|
// no arguments returns ZeroValue.
|
|
func Tuple(vals ...Value) Value {
|
|
return Value{Tuple: vals}
|
|
}
|
|
|
|
// IsZero returns true if the Value is the zero value (aka the 0-tuple).
|
|
// LexerToken (within the gg.Value) is ignored for this check.
|
|
func (v Value) IsZero() bool {
|
|
return v.Equal(ZeroValue)
|
|
}
|
|
|
|
// Equal returns true if the passed in Value is equivalent, ignoring the
|
|
// LexerToken on either Value.
|
|
//
|
|
// Will panic if the passed in v2 is not a Value from this package.
|
|
func (v Value) Equal(v2g graph.Value) bool {
|
|
|
|
v2 := v2g.(Value)
|
|
|
|
switch {
|
|
|
|
case (v.Value != (gg.Value{}) || v2.Value != (gg.Value{})):
|
|
return v.Value.Equal(v2.Value)
|
|
|
|
case v.Function != nil || v2.Function != nil:
|
|
// for now we say that Functions can't be compared. This will probably
|
|
// get revisted later.
|
|
return false
|
|
|
|
case len(v.Tuple) == len(v2.Tuple):
|
|
|
|
for i := range v.Tuple {
|
|
if !v.Tuple[i].Equal(v2.Tuple[i]) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
|
|
default:
|
|
|
|
// if both were the zero value then both tuples would have the same
|
|
// length (0), which is covered by the previous check. So anything left
|
|
// over must be tuples with differing lengths.
|
|
return false
|
|
}
|
|
|
|
}
|
|
|
|
func (v Value) String() string {
|
|
|
|
switch {
|
|
|
|
case v.Function != nil:
|
|
|
|
// We can try to get better strings for ops later
|
|
return "<fn>"
|
|
|
|
case v.Value != (gg.Value{}):
|
|
return v.Value.String()
|
|
|
|
default:
|
|
|
|
// we consider zero value to be the 0-tuple
|
|
|
|
strs := make([]string, len(v.Tuple))
|
|
|
|
for i := range v.Tuple {
|
|
strs[i] = v.Tuple[i].String()
|
|
}
|
|
|
|
return fmt.Sprintf("(%s)", strings.Join(strs, ", "))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// EvaluateSource reads and parses the io.Reader as an operation, input is used
|
|
// as the argument to the operation, and the resultant value is returned.
|
|
//
|
|
// scope contains pre-defined operations and values which are available during
|
|
// the evaluation.
|
|
func EvaluateSource(opSrc io.Reader, input Value, scope Scope) (Value, error) {
|
|
v, err := gg.NewDecoder(opSrc).Next()
|
|
if err != nil {
|
|
return Value{}, err
|
|
} else if v.Value.Graph == nil {
|
|
return Value{}, errors.New("value must be a graph")
|
|
}
|
|
|
|
fn, err := FunctionFromGraph(v.Value.Graph, scope)
|
|
if err != nil {
|
|
return Value{}, err
|
|
}
|
|
|
|
return fn.Perform(input), nil
|
|
}
|
|
|