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);
}
}
}
