public void ParseBinaryExpressionWithRelOp() { Parser parser; NVBinaryExpression expr = (NVBinaryExpression)GetExpressionFromTemplate( "1 <= 2 && true ne false", out parser); // The AST should look like this: // and // / \ // <= != // / \ / \ // 1 2 T F // Check that there is a BinaryExpression with operator 'and' Assert.AreEqual(Operator.And, expr.Op); // Check that expr.LHS operator is Lte Assert.AreEqual(Operator.Lte, ((NVBinaryExpression)expr.Lhs).Op); Assert.AreEqual(1, ((NVNumExpression)((NVBinaryExpression)expr.Lhs).Lhs).Value); Assert.AreEqual(2, ((NVNumExpression)((NVBinaryExpression)expr.Lhs).Rhs).Value); // Check that expr.RHS operator is Neq Assert.AreEqual(Operator.Neq, ((NVBinaryExpression)expr.Rhs).Op); Assert.AreEqual(true, ((NVBoolExpression)((NVBinaryExpression)expr.Rhs).Lhs).Value); Assert.AreEqual(false, ((NVBoolExpression)((NVBinaryExpression)expr.Rhs).Rhs).Value); AssertNoErrors(parser); }
public void ParseBinaryExpressionWithAddOp() { Parser parser; NVBinaryExpression expr = (NVBinaryExpression)GetExpressionFromTemplate( "1 + 2 - 3", out parser); // The AST should look like this: // - // / \ // + 3 // / \ // 1 2 // Check that there is a BinaryExpression with operator 'Minus' Assert.AreEqual(Operator.Minus, expr.Op); // Check the LHS of the expr Assert.AreEqual(Operator.Plus, ((NVBinaryExpression)expr.Lhs).Op); Assert.AreEqual(1, ((NVNumExpression)((NVBinaryExpression)expr.Lhs).Lhs).Value); Assert.AreEqual(2, ((NVNumExpression)((NVBinaryExpression)expr.Lhs).Rhs).Value); // Check the RHS of the expr Assert.AreEqual(3, ((NVNumExpression)expr.Rhs).Value); AssertNoErrors(parser); }
public void ParseAndExpression() { Parser parser; NVBinaryExpression expr = (NVBinaryExpression)GetExpressionFromTemplate( "true && true and true", out parser); // The AST should look like this: // and // / \ // and true // / \ //true true // Check that there is a BinaryExpression with operator 'And' Assert.AreEqual(Operator.And, expr.Op); // Check the LHS of the expr Assert.AreEqual(Operator.And, ((NVBinaryExpression)expr.Lhs).Op); Assert.AreEqual(true, ((NVBoolExpression)((NVBinaryExpression)expr.Lhs).Lhs).Value); Assert.AreEqual(true, ((NVBoolExpression)((NVBinaryExpression)expr.Lhs).Rhs).Value); // Check the RHS of the expr Assert.AreEqual(true, ((NVBoolExpression)expr.Rhs).Value); AssertNoErrors(parser); }
public void ParseOrExpression() { Parser parser; NVBinaryExpression expr = (NVBinaryExpression)GetExpressionFromTemplate( "true || false", out parser); // Check that LHS and RHS are BooleanExpressions and the operator is Or Assert.AreEqual(Operator.Or, expr.Op); Assert.AreEqual(true, ((NVBoolExpression)expr.Lhs).Value); Assert.AreEqual(false, ((NVBoolExpression)expr.Rhs).Value); AssertNoErrors(parser); }
private NVExpression ParseNVTerm() { // NVTerm -> NVFactor { NVMulOp NVFactor }. NVExpression expr = ParseNVFactor(); while (CurrentTokenIn(TokenType.NVMul, TokenType.NVDiv, TokenType.NVMod)) { expr = new NVBinaryExpression(ParseNVMulOp(), expr, ParseNVFactor()); expr.Position = new Position((NVBinaryExpression)expr); } return(expr); }
private NVExpression ParseNVSimpleExpression() { // NVSimpleExpression -> NVTerm { NVAddOp NVTerm }. NVExpression expr = ParseNVTerm(); while (CurrentTokenIn(TokenType.NVPlus, TokenType.NVMinus)) { expr = new NVBinaryExpression(ParseNVAddOp(), expr, ParseNVTerm()); expr.Position = new Position((NVBinaryExpression)expr); } return(expr); }
public void PositionOfRelExpresion() { Parser parser; NVBinaryExpression expr = (NVBinaryExpression)GetExpressionFromTemplate( "1 == 2", out parser); // Check BinaryExpression AssertPositionForExpression(new Position(1, 1, 1, 7), expr.Position); // Check NumExpressions AssertPositionForExpression(new Position(1, 1, 1, 2), expr.Lhs.Position); AssertPositionForExpression(new Position(1, 6, 1, 7), expr.Rhs.Position); AssertNoErrors(parser); }
private NVExpression ParseNVRelExpression() { // NVRelExpression -> NVSimpleExpression [ NVRelOp NVSimpleExpression ]. NVExpression expr = ParseNVSimpleExpression(); if (CurrentTokenIn(TokenType.NVLte, TokenType.NVLt, TokenType.NVGt, TokenType.NVGte, TokenType.NVEqEq, TokenType.NVNeq)) { expr = new NVBinaryExpression(ParseNVRelOp(), expr, ParseNVSimpleExpression()); expr.Position = new Position((NVBinaryExpression)expr); } return(expr); }
private NVExpression ParseNVAndExpression() { // NVAndExpression -> NVRelExpression { ( "&&" | "and" ) NVRelExpression }. NVExpression expr = ParseNVRelExpression(); while (CurrentTokenType == TokenType.NVAnd) { _scanner.GetToken(); expr = new NVBinaryExpression(Operator.And, expr, ParseNVRelExpression()); expr.Position = new Position((NVBinaryExpression)expr); } return(expr); }
public void ParseBinaryExpressionWithMulOp() { Parser parser; NVBinaryExpression expr = (NVBinaryExpression)GetExpressionFromTemplate( "1 * 2 / 3", out parser); // Check that there is a BinaryExpression with operator 'Div' Assert.AreEqual(Operator.Div, expr.Op); // Check the LHS Assert.AreEqual(Operator.Mul, ((NVBinaryExpression)expr.Lhs).Op); Assert.AreEqual(1, ((NVNumExpression)((NVBinaryExpression)expr.Lhs).Lhs).Value); Assert.AreEqual(2, ((NVNumExpression)((NVBinaryExpression)expr.Lhs).Rhs).Value); // Chec the RHS Assert.AreEqual(3, ((NVNumExpression)expr.Rhs).Value); AssertNoErrors(parser); }
public void ParseExpressionWithParentheses() { Parser parser; NVBinaryExpression expr = (NVBinaryExpression)GetExpressionFromTemplate( "1 * (2 + 3)", out parser); // Check expr Assert.AreEqual(Operator.Mul, expr.Op); // Check LHS Assert.AreEqual(1, ((NVNumExpression)expr.Lhs).Value); // Check RHS NVBinaryExpression rhs = (NVBinaryExpression)expr.Rhs; Assert.AreEqual(Operator.Plus, rhs.Op); Assert.AreEqual(2, ((NVNumExpression)rhs.Lhs).Value); Assert.AreEqual(3, ((NVNumExpression)rhs.Rhs).Value); AssertNoErrors(parser); }
private void AddNodesToTree(AstNode parentAstNode, TreeNode parentTreeNode) { if (parentAstNode is TemplateNode) { // Template Content foreach (AstNode node in ((TemplateNode)parentAstNode).Content) { AddNodesToTree(node, parentTreeNode); } } else if (parentAstNode is NVBinaryExpression) { NVBinaryExpression binExpr = (NVBinaryExpression)parentAstNode; TreeNode binExprTreeNode = new TreeNode(string.Format("NVBinaryExpression={{Op:\"{0}\"}}", binExpr.Op)); binExprTreeNode.Tag = parentAstNode; parentTreeNode.Nodes.Add(binExprTreeNode); AddNodesToTree(binExpr.Lhs, binExprTreeNode); AddNodesToTree(binExpr.Rhs, binExprTreeNode); } else if (parentAstNode is NVBoolExpression) { TreeNode boolTreeNode = new TreeNode(string.Format("NVBoolExpression={{Value:\"{0}\"}}", ((NVBoolExpression)parentAstNode).Value)); boolTreeNode.Tag = parentAstNode; parentTreeNode.Nodes.Add(boolTreeNode); } else if (parentAstNode is NVForeachDirective) { NVForeachDirective foreachDirective = (NVForeachDirective)parentAstNode; TreeNode foreachTreeNode = new TreeNode(string.Format("NVForeachDirective={{Iterator:\"{0}\"}}", foreachDirective.Iterator)); foreachTreeNode.Tag = parentAstNode; parentTreeNode.Nodes.Add(foreachTreeNode); // Content foreach (AstNode astNode in foreachDirective.Content) { AddNodesToTree(astNode, foreachTreeNode); } } else if (parentAstNode is NVDirective) { TreeNode directiveTreeNode = new TreeNode(string.Format("NVDirective={{Name:\"{0}\"}}", ((NVDirective)parentAstNode).Name)); directiveTreeNode.Tag = parentAstNode; parentTreeNode.Nodes.Add(directiveTreeNode); } else if (parentAstNode is NVNumExpression) { TreeNode numTreeNode = new TreeNode(string.Format("NVNumExpression={{Value:\"{0}\"}}", ((NVNumExpression)parentAstNode).Value)); numTreeNode.Tag = parentAstNode; parentTreeNode.Nodes.Add(numTreeNode); } else if (parentAstNode is NVReference) { TreeNode referenceTreeNode = new TreeNode(string.Format("NVReference={{Name:\"{0}\"}}", ((NVReference)parentAstNode).Designator.Name)); referenceTreeNode.Tag = parentAstNode; parentTreeNode.Nodes.Add(referenceTreeNode); foreach (NVSelector selector in ((NVReference)parentAstNode).Designator.Selectors) { AddNodesToTree(selector, referenceTreeNode); } } else if (parentAstNode is NVSelector) { NVSelector selector = (NVSelector)parentAstNode; TreeNode selectorTreeNode = new TreeNode(string.Format("NVSelector={{Name:\"{0}\", Type:\"{1}\"}}", selector.Name, selector.Type != null ? selector.Type.Name : "")); selectorTreeNode.Tag = parentAstNode; parentTreeNode.Nodes.Add(selectorTreeNode); if (selector.Actuals.Count > 0) { TreeNode actualsTreeNode = new TreeNode("Actuals:"); foreach (NVExpression actual in selector.Actuals) { AddNodesToTree(actual, actualsTreeNode); } selectorTreeNode.Nodes.Add(actualsTreeNode); } } else if (parentAstNode is NVStringExpression) { TreeNode stringTreeNode = new TreeNode(string.Format("NVStringExpression={{Value:\"{0}\"}}", ((NVStringExpression)parentAstNode).Value)); stringTreeNode.Tag = parentAstNode; parentTreeNode.Nodes.Add(stringTreeNode); } else if (parentAstNode is XmlAttribute) { TreeNode attributeTreeNode = new TreeNode(string.Format("XmlAttribute={{Name:\"{0}\"}}", ((XmlAttribute)parentAstNode).Name)); attributeTreeNode.Tag = parentAstNode; parentTreeNode.Nodes.Add(attributeTreeNode); // XML Attribute Content foreach (AstNode node in ((XmlAttribute)parentAstNode).Content) { AddNodesToTree(node, attributeTreeNode); } } else if (parentAstNode is XmlElement) { XmlElement xmlElement = (XmlElement)parentAstNode; TreeNode elementTreeNode = new TreeNode(string.Format("XmlElement={{Name:\"{0}\"}}", xmlElement.Name)); elementTreeNode.Tag = parentAstNode; parentTreeNode.Nodes.Add(elementTreeNode); // XML Element Attributes TreeNode attributesTreeNode = new TreeNode("Attributes:"); foreach (AstNode attribute in xmlElement.Attributes) { AddNodesToTree(attribute, attributesTreeNode); } elementTreeNode.Nodes.Add(attributesTreeNode); // XML Element Content TreeNode contentTreeNode = new TreeNode("Content:"); foreach (AstNode node in xmlElement.Content) { AddNodesToTree(node, contentTreeNode); } elementTreeNode.Nodes.Add(contentTreeNode); } else if (parentAstNode is XmlTextNode) { TreeNode textNodeTreeNode = new TreeNode(string.Format("XmlTextNode={{Text:\"{0}\"}}", ((XmlTextNode)parentAstNode).Text.Replace("\n", "\\n"))); textNodeTreeNode.Tag = parentAstNode; parentTreeNode.Nodes.Add(textNodeTreeNode); } else { if (parentAstNode != null) { TreeNode treeNode = new TreeNode("UNKNOWN===" + parentAstNode.GetType().Name); treeNode.Tag = parentAstNode; parentTreeNode.Nodes.Add(treeNode); } } }