private static string GetBoundMessage(string id, SetExpression set) { string s = $"{ id } is not defined as an identifier in " + $"{ set.Element.ElementIdentifier }[{ GetIdentifiers(set.Element.IndexIdentifiers) }]"; return(s); }
public Unit VisitSetExpression(SetExpression expression) { Resolve(expression.Value); Resolve(expression.Object); return(Unit.Value); }
public TypeNode Dispatch(ExpressionNode node, List <TypeNode> parameterTypes) { return(node switch { IBinaryNumberOperator n => _numberHelper.VisitBinaryNumOp(n, parameterTypes), IBinaryBooleanOperator n => _booleanHelper.VisitBinaryBoolOp(n, parameterTypes), IBinarySetOperator n => _setHelper.VisitBinarySetOp(n, parameterTypes), SubsetExpression n => _setHelper.VisitSubset(n, parameterTypes), SetExpression n => _setHelper.VisitSet(n, parameterTypes), NotExpression n => _booleanHelper.VisitNot(n, parameterTypes), FunctionCallExpression n => _declarationHelper.VisitFunctionCall(n, parameterTypes), IdentifierExpression n => _declarationHelper.VisitIdentifier(n, parameterTypes), IntegerLiteralExpression _ => _declarationHelper.VisitIntegerLiteral(), RealLiteralExpression _ => _declarationHelper.VisitRealLiteral(), BooleanLiteralExpression _ => _declarationHelper.VisitBooleanLiteral(), StringLiteralExpression _ => _declarationHelper.VisitStringLiteral(), EmptySetLiteralExpression _ => _declarationHelper.VisitEmptySetLiteral(), AdditionExpression n => _commonOperatorHelper.VisitAddition(n, parameterTypes), SubtractionExpression n => _commonOperatorHelper.VisitSubtraction(n, parameterTypes), AbsoluteValueExpression n => _commonOperatorHelper.VisitAbsoluteValue(n, parameterTypes), IRelationOperator n => _commonOperatorHelper.VisitRelationalOperator(n, parameterTypes), IEquivalenceOperator n => _commonOperatorHelper.VisitEquivalenceOperator(n, parameterTypes), NegativeExpression n => _numberHelper.VisitNegative(n, parameterTypes), ElementExpression n => _commonOperatorHelper.VisitElement(n, parameterTypes), ISetGraphField n => _commonOperatorHelper.VisitISetGraphField(n, parameterTypes), IFunctionGraphField n => _commonOperatorHelper.VisitIFunctionGraphField(n, parameterTypes), GraphExpression n => _commonOperatorHelper.VisitGraph(n, parameterTypes), AnonymousFunctionExpression n => _declarationHelper.VisitAnonymousFunction(n, parameterTypes), _ => throw new UnimplementedTypeCheckerException(node, "Dispatch"), });
public object VisitSetExpression(SetExpression expression) { Resolve(expression.Value); Resolve(expression.Obj); return(null); }
private void DispatchPredicate(SetExpression node, List <string> parameters) { var newParameters = parameters.ToList(); newParameters.Add(node.Element.ElementIdentifier); newParameters.AddRange(node.Element.IndexIdentifiers); _dispatch(node.Predicate, newParameters); }
private void DispatchBounds(SetExpression node, List <string> parameters) { foreach (var bound in node.Bounds) { _dispatch(bound.MinValue, parameters); _dispatch(bound.MaxValue, parameters); } }
private void ThrowExceptionIfBoundsAndIndentifiersDoNotMatch(SetExpression node) { if (node.Element.IndexIdentifiers.Count != node.Bounds.Count) { throw new BoundException(node, "The number of bounds is not the same as element identifiers."); } ThrowExceptionIfBoundsAreNotUnique(node.Bounds); }
public void SerializeSetExpression() { var left = new VariableExpression("x"); var right = new LiteralExpression(1); var a = new SetExpression(left, right); var b = Reserialize(a); Assert.AreEqual(a, b); }
private SetExpression GetSet() { ElementNode element = GetElement(); List <BoundNode> bounds = GetBounds(); ExpressionNode predicate = GetPredicate(); var node = new SetExpression(element, bounds, predicate, 0, 0); return(node); }
private List <BoundNode> GetSortedBounds(SetExpression node) { List <BoundNode> bounds = new List <BoundNode>(); foreach (var id in node.Element.IndexIdentifiers) { bounds.Add(GetBound(id, node.Bounds, node)); } return(bounds); }
private Set GetManualSet(SetExpression node, List <object> parameters) { List <Element> elements = new List <Element>(); foreach (ExpressionNode n in node.Children) { elements.Add(_interpreter.DispatchElement(n, parameters)); } return(new Set(elements)); }
public IMember GetValueFromSet(SetExpression expression) { var contents = new List <IMember>(); foreach (var item in expression.Items.Take(MaxCollectionSize)) { var value = GetValueFromExpression(item) ?? UnknownType; contents.Add(value); } return(PythonCollectionType.CreateSet(Module, contents, exact: expression.Items.Count <= MaxCollectionSize)); }
public IMember GetValueFromSet(SetExpression expression) { var contents = new List <IMember>(); foreach (var item in expression.Items) { var value = GetValueFromExpression(item) ?? UnknownType; contents.Add(value); } return(PythonCollectionType.CreateSet(Interpreter, GetLoc(expression), contents)); }
private BoundNode GetBound(string id, List <BoundNode> bounds, SetExpression set) { foreach (var bound in bounds) { if (bound.Identifier.Equals(id)) { return(bound); } } throw new InvalidIdentifierException(id, set); }
public async Task <IMember> GetValueFromSetAsync(SetExpression expression, CancellationToken cancellationToken = default) { var contents = new List <IMember>(); foreach (var item in expression.Items) { var value = await GetValueFromExpressionAsync(item, cancellationToken) ?? UnknownType; contents.Add(value); } return(PythonCollectionType.CreateSet(Interpreter, GetLoc(expression), contents)); }
private TypeNode CheckManualSet(SetExpression node, List <TypeNode> parameterTypes) { foreach (ExpressionNode n in node.Children) { TypeEnum type = _getType(n, parameterTypes).Type; if (type != TypeEnum.Element) { throw new UnmatchableTypesException(n, type, TypeEnum.Element); } } return(new TypeNode(TypeEnum.Set, 0, 0)); }
public void UnionSet_SetsWithVaryingNumberOfElementIndices_(Set left, Set right, Set expected) { IInterpreterSet parent = Substitute.For <IInterpreterSet>(); SetHelper setHelper = SetUpHelper(parent); SetExpression leftExpr = new SetExpression(null, null, null, 0, 0); SetExpression rightExpr = new SetExpression(null, null, null, 0, 0); UnionExpression intersectionExpr = new UnionExpression(leftExpr, rightExpr, 0, 0); parent.DispatchSet(leftExpr, Arg.Any <List <object> >()).Returns(left); parent.DispatchSet(rightExpr, Arg.Any <List <object> >()).Returns(right); Set result = setHelper.UnionSet(intersectionExpr, new List <object>()); result.Should().BeEquivalentTo(expected); }
public Set DispatchSet(ExpressionNode node, List <Object> parameters) { return(node switch { SetExpression e => _setHelper.SetExpression(e, parameters), UnionExpression e => _setHelper.UnionSet(e, parameters), IntersectionExpression e => _setHelper.IntersectionSet(e, parameters), SubtractionExpression e => _setHelper.SubtractionSet(e, parameters), IdentifierExpression e => _genericHelper.Identifier <Set>(e, parameters), FunctionCallExpression e => _genericHelper.FunctionCall <Set>(e, parameters), VerticesGraphField e => _setHelper.VerticesField(e, parameters), EdgesGraphField e => _setHelper.EdgesField(e, parameters), EmptySetLiteralExpression e => _setHelper.EmptySetLiteral(e, parameters), _ => throw new UnimplementedInterpreterException(node, "DispatctSet") });
public void SubtractionSet_f_f(int[,] left, int[,] right, int[,] expected) { IInterpreterSet parent = Substitute.For <IInterpreterSet>(); SetHelper setHelper = SetUpHelper(parent); SetExpression lhsExpr = new SetExpression(null, null, null, 1, 1); SetExpression rhsExpr = new SetExpression(null, null, null, 1, 1); SubtractionExpression expr = new SubtractionExpression(lhsExpr, rhsExpr, 0, 0); parent.DispatchSet(lhsExpr, Arg.Any <List <object> >()).Returns(getSetFrom2dArray(left)); parent.DispatchSet(rhsExpr, Arg.Any <List <object> >()).Returns(getSetFrom2dArray(right)); Set res = setHelper.SubtractionSet(expr, new List <object>()); res.Should().BeEquivalentTo(getSetFrom2dArray(expected)); }
public void IntersectionSet_ValidInput_ReturnsCorrectSet(Set left, Set right, Set exp) { IInterpreterSet parent = Substitute.For <IInterpreterSet>(); SetHelper setHelper = SetUpHelper(parent); SetExpression leftExpr = new SetExpression(null, null, null, 0, 0); SetExpression rightExpr = new SetExpression(null, null, null, 0, 0); IntersectionExpression intersectionExpr = new IntersectionExpression(leftExpr, rightExpr, 0, 0); parent.DispatchSet(leftExpr, Arg.Any <List <object> >()).Returns(left); parent.DispatchSet(rightExpr, Arg.Any <List <object> >()).Returns(right); Set result = setHelper.IntersectionSet(intersectionExpr, new List <object>()); result.Should().BeEquivalentTo(exp); }
public object VisitSetExpression(SetExpression expression) { var obj = Evaluate(expression.Obj); if (obj is LoxInstance loxInstance) { var value = Evaluate(expression.Value); loxInstance[expression.Name] = value; return(value); } else { throw new LoxRunTimeException(expression.Name, "Only instances have fields."); } }
internal static void GetGraphExpression(int vertexCount, int edgeCount, int indexCount, out GraphExpression graphExpr, out FunctionNode src, out FunctionNode dst) { SetExpression vertexSetExpr = GetSet(indexCount, GetBoundList(indexCount, 1, vertexCount)); SetExpression edgeSetExpr = GetSet(indexCount, GetBoundList(indexCount, 1, edgeCount)); IdentifierExpression srcId = GetIdExpression(0, false); IdentifierExpression dstId = GetIdExpression(1, false); graphExpr = new GraphExpression(vertexSetExpr, edgeSetExpr, srcId, dstId, 0, 0); ElementExpression srcElementExpr = GetElementExpression(GetIntList(1, indexCount)); ConditionNode srcCondNode = GetConditionNode(srcElementExpr, indexCount, 0); src = GetElementFunctionNode(srcCondNode); ElementExpression dstElementExpr = GetElementExpression(GetIntList(1, indexCount), GetIntListWithValue(indexCount, 1)); ConditionNode dstCondNode = GetConditionNode(dstElementExpr, indexCount, 0); dst = GetElementFunctionNode(dstCondNode); }
public void SubsetBoolean_GivenSetAndSet_CorrectValueReturned(int[] a, int[] b, bool expected) { Set lhsValue = GetSetWith1DElements(a); Set rhsValue = GetSetWith1DElements(b); SetExpression lhs = GetSetInit(); SetExpression rhs = GetSetInit(); SubsetExpression expression = new SubsetExpression(lhs, rhs, 0, 0); IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>(); DispatchSetForParent(lhsValue, lhs, parent); DispatchSetForParent(rhsValue, rhs, parent); BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent); bool res = booleanHelper.SubsetBoolean(expression, new List <object>()); Assert.AreEqual(expected, res); }
public void SetExpression_f_f(List <int> min, List <int> max, List <List <object> > indexPairs) { IInterpreterSet parent = Substitute.For <IInterpreterSet>(); SetHelper setHelper = SetUpHelper(parent); List <BoundNode> bounds = GetBounds(parent, min, max); LessExpression expr = new LessExpression(null, null, 0, 0); SetExpression setExpr = new SetExpression(new ElementNode(null, null, 0, 0), bounds, expr, 0, 0); List <Element> expectedElements = new List <Element>(); for (int i = 0; i < indexPairs.Count; i++) { expectedElements.Add(new Element(indexPairs[i].ConvertAll(x => (int)x))); } Set expected = new Set(expectedElements); parent.DispatchBoolean(expr, Arg.Any <List <Object> >()).Returns(x => IsContained(indexPairs, (List <Object>)x[1])); Set result = setHelper.SetExpression(setExpr, new List <object>()); result.Should().BeEquivalentTo(expected); }
public void VisitSet(SetExpression node, List <string> parameters) { if (node.IsSetBuilder) { ThrowExceptionIfIdentifiersAreInParameters(node.Element.IndexIdentifiers, parameters); ThrowExceptionIfIdentifiersAreNotUnique(node.Element.IndexIdentifiers); ThrowExceptionIfBoundsAndIndentifiersDoNotMatch(node); ThrowExceptionIfBoundsAreInParameters(node.Bounds, parameters, node); ThrowExceptionIfElementAreInParameters(node.Element, parameters); node.Bounds = GetSortedBounds(node); DispatchBounds(node, parameters); DispatchPredicate(node, parameters); } else { foreach (ExpressionNode n in node.Children) { _dispatch(n, parameters); } } }
public TypeNode VisitSet(SetExpression node, List <TypeNode> parameterTypes) { if (!node.IsSetBuilder) { return(CheckManualSet(node, parameterTypes)); } List <TypeNode> indexTypes = new List <TypeNode>(); foreach (BoundNode n in node.Bounds) { CheckType(n.MaxValue, parameterTypes, TypeEnum.Integer); CheckType(n.MinValue, parameterTypes, TypeEnum.Integer); indexTypes.Add(new TypeNode(TypeEnum.Integer, 0, 0)); } parameterTypes.Add(new TypeNode(TypeEnum.Element, 0, 0)); parameterTypes.AddRange(indexTypes); CheckType(node.Predicate, parameterTypes, TypeEnum.Boolean); parameterTypes.RemoveRange(parameterTypes.Count - node.Bounds.Count - 1, node.Bounds.Count + 1); return(new TypeNode(TypeEnum.Set, 0, 0)); }
public Set SetExpression(SetExpression node, List <Object> parameters) { if (!node.IsSetBuilder) { return(GetManualSet(node, parameters)); } Set set = new Set(); List <int> minValues = new List <int>(); List <int> maxValues = new List <int>(); List <int> indices = new List <int>(); for (int i = 0; i < node.Bounds.Count; i++) { minValues.Add(_interpreter.DispatchInt(node.Bounds[i].MinValue, parameters)); maxValues.Add(_interpreter.DispatchInt(node.Bounds[i].MaxValue, parameters)); indices.Add(0); } EvaluateSet(minValues, maxValues, indices, node.Predicate, 0, set, parameters); return(set); }
internal static void GetGraphExpression(int vertexCount, int edgeCount, out GraphExpression graphExpr, out FunctionNode src, out FunctionNode dst) { SetExpression vertexSetExpr = GetSet(1, new List <Tuple <int, int> >() { new Tuple <int, int>(1, vertexCount) }); SetExpression edgeSetExpr = GetSet(1, new List <Tuple <int, int> >() { new Tuple <int, int>(1, edgeCount) }); IdentifierExpression srcId = GetIdExpression(0, false); IdentifierExpression dstId = GetIdExpression(1, false); graphExpr = new GraphExpression(vertexSetExpr, edgeSetExpr, srcId, dstId, 0, 0); ElementExpression srcElementExpr = GetElementExpression(1); ConditionNode srcCondNode = GetConditionNode(srcElementExpr, 1, 0); src = GetElementFunctionNode(srcCondNode); ElementExpression dstElementExpr = GetElementExpression(1, 1); ConditionNode dstCondNode = GetConditionNode(dstElementExpr, 1, 0); dst = GetElementFunctionNode(dstCondNode); }
public void GraphExpression_ValidExpressions_ReturnsCorrectGraph() { IInterpreterGraph parent = Substitute.For <IInterpreterGraph>(); GraphHelper graphHelper = SetUpHelper(parent); SetExpression verticesExpr = new SetExpression(null, null, null, 1, 1); SetExpression edgesExpr = new SetExpression(null, null, null, 1, 1); IdentifierExpression srcExpr = new IdentifierExpression(null, 1, 1); IdentifierExpression dstExpr = new IdentifierExpression(null, 1, 1); GraphExpression graphExpr = new GraphExpression(verticesExpr, edgesExpr, srcExpr, dstExpr, 1, 1); Set expectedVerticesSet = new Set(); Set expectedEdgesSet = new Set(); Function expectedSrcFunc = new Function(42); Function expectedDstFunc = new Function(43); Graph expected = new Graph(expectedVerticesSet, expectedEdgesSet, expectedSrcFunc, expectedDstFunc); parent.DispatchSet(verticesExpr, Arg.Any <List <Object> >()).Returns(expectedVerticesSet); parent.DispatchSet(edgesExpr, Arg.Any <List <Object> >()).Returns(expectedEdgesSet); parent.DispatchFunction(srcExpr, Arg.Any <List <Object> >()).Returns(expectedSrcFunc); parent.DispatchFunction(dstExpr, Arg.Any <List <Object> >()).Returns(expectedDstFunc); Graph result = graphHelper.GraphExpression(graphExpr, new List <Object>()); result.Should().BeEquivalentTo(expected); }
public override void PostWalk(SetExpression node) { }
public virtual void PostWalk(SetExpression node) { }
// SetExpression public override bool Walk(SetExpression node) { return false; }
// SetExpression public virtual bool Walk(SetExpression node) { return true; }
// SetExpression public override bool Walk(SetExpression node) { return Location >= node.StartIndex && Location <= node.EndIndex; }