package vm import ( "fmt" "github.com/mediocregopher/ginger/gg" "github.com/mediocregopher/ginger/graph" ) // Scope encapsulates a set of names and the values they indicate, or the means // by which to obtain those values, and allows for the evaluation of a name to // its value. type Scope interface { // Evaluate accepts a name Value and returns the real Value which that name // points to. Evaluate(Value) (Value, error) // NewScope returns a new Scope which sub-operations within this Scope // should use for themselves. NewScope() Scope } // edgeToValue ignores the edgeValue, it only evaluates the edge's vertex as a // Value. func edgeToValue(edge graph.OpenEdge[gg.Value], scope Scope) (Value, error) { if ggVal, ok := edge.FromValue(); ok { val := Value{Value: ggVal} if val.Name != nil { return scope.Evaluate(val) } return val, nil } var tupVal Value tup, _ := edge.FromTuple() for _, tupEdge := range tup { val, err := EvaluateEdge(tupEdge, scope) if err != nil { return Value{}, err } tupVal.Tuple = append(tupVal.Tuple, val) } if len(tupVal.Tuple) == 1 { return tupVal.Tuple[0], nil } return tupVal, nil } // EvaluateEdge will use the given Scope to evaluate the edge's ultimate Value, // after passing all leaf vertices up the tree through all Operations found on // edge values. func EvaluateEdge(edge graph.OpenEdge[gg.Value], scope Scope) (Value, error) { edgeVal := Value{Value: edge.EdgeValue()} if edgeVal.IsZero() { return edgeToValue(edge, scope) } edge = edge.WithEdgeValue(gg.ZeroValue) if edgeVal.Name != nil { var err error if edgeVal, err = scope.Evaluate(edgeVal); err != nil { return Value{}, err } } if edgeVal.Graph != nil { edgeVal = Value{ Operation: OperationFromGraph(edgeVal.Graph, scope.NewScope()), } } if edgeVal.Operation == nil { return Value{}, fmt.Errorf("edge value must be an operation") } return edgeVal.Operation.Perform(edge, scope) } // ScopeMap implements the Scope interface. type ScopeMap map[string]Value var _ Scope = ScopeMap{} // Evaluate uses the given name Value as a key into the ScopeMap map, and // returns the Value held there for the key, if any. func (m ScopeMap) Evaluate(nameVal Value) (Value, error) { if nameVal.Name == nil { return Value{}, fmt.Errorf("value %v is not a name value", nameVal) } val, ok := m[*nameVal.Name] if !ok { return Value{}, fmt.Errorf("%q not defined", *nameVal.Name) } return val, nil } // NewScope returns the ScopeMap as-is. func (m ScopeMap) NewScope() Scope { return m } type graphScope struct { *graph.Graph[gg.Value] parent Scope } // ScopeFromGraph returns a Scope which will use the given Graph for evaluation. // // When a name is evaluated, that name will be looked up in the Graph. The // name's vertex must have only a single OpenEdge leading to it. That edge will // be followed, with edge values being evaluated to Operations, until a Value // can be obtained. // // If a name does not appear in the Graph, then the given parent Scope will be // used to evaluate that name. If the parent Scope is nil then an error is // returned. // // NewScope will return the parent scope, if one is given, or an empty ScopeMap // if not. func ScopeFromGraph(g *graph.Graph[gg.Value], parent Scope) Scope { return &graphScope{ Graph: g, parent: parent, } } func (g *graphScope) Evaluate(nameVal Value) (Value, error) { if nameVal.Name == nil { return Value{}, fmt.Errorf("value %v is not a name value", nameVal) } edgesIn := g.ValueIns(nameVal.Value) if l := len(edgesIn); l == 0 && g.parent != nil { return g.parent.Evaluate(nameVal) } else if l != 1 { return Value{}, fmt.Errorf( "%q must have exactly one input edge, found %d input edges", *nameVal.Name, l, ) } return EvaluateEdge(edgesIn[0], g) } func (g *graphScope) NewScope() Scope { if g.parent == nil { return ScopeMap{} } return g.parent }