private bool ParseParenExpression(ref ASTNode retn)
{
if (tokenStream.Current != ExpressionTokenType.ParenOpen)
{
return(false);
}
int advance = tokenStream.FindMatchingIndex(ExpressionTokenType.ParenOpen, ExpressionTokenType.ParenClose);
if (advance == -1)
{
throw new Exception("Unmatched paren"); // todo just abort
}
ExpressionParser subParser = CreateSubParser(advance);
retn = subParser.ParseLoop();
if (retn.IsCompound)
{
retn = ASTNode.ParenNode(retn);
}
ASTNode access = null;
if (ParseParenAccessExpression(ref access))
{
ParenNode parenNode = (ParenNode)retn;
parenNode.accessExpression = (MemberAccessExpressionNode)access;
}
subParser.Release();
return(true);
}
public void Parse_Ternary_Partial_Nested_WithFullParens()
{
ASTNode root = ExpressionParser.Parse(("thing != null ? (thing.floatValue > 5 ? 1) : 12"));
OperatorNode outerTernary = AssertOpNode(root, OperatorType.TernaryCondition);
OperatorNode outerCondition = AssertOpNode(outerTernary.left, OperatorType.NotEquals);
OperatorNode outerSelection = AssertOpNode(outerTernary.right, OperatorType.TernarySelection);
Assert.AreEqual("thing", AssertInstanceOfAndReturn <IdentifierNode>(outerCondition.left).name);
Assert.AreEqual("null", AssertInstanceOfAndReturn <LiteralNode>(outerCondition.right).rawValue);
ParenNode parenNode = AssertInstanceOfAndReturn <ParenNode>(outerSelection.left);
OperatorNode innerTernary = AssertOpNode(parenNode.expression, OperatorType.TernaryCondition);
OperatorNode innerCondition = AssertInstanceOfAndReturn <OperatorNode>(innerTernary.left);
Assert.IsInstanceOf <MemberAccessExpressionNode>(innerCondition.left);
Assert.AreEqual("5", AssertInstanceOfAndReturn <LiteralNode>(innerCondition.right).rawValue);
OperatorNode innerSelection = AssertOpNode(innerTernary.right, OperatorType.TernarySelection);
Assert.AreEqual("1", AssertInstanceOfAndReturn <LiteralNode>(innerSelection.left).rawValue);
Assert.AreEqual("default", AssertInstanceOfAndReturn <LiteralNode>(innerSelection.right).rawValue);
Assert.AreEqual("12", AssertInstanceOfAndReturn <LiteralNode>(outerSelection.right).rawValue);
}
public IAstNode BuildTree()
{
var parenNode = new ParenNode(new Token(), _tracer);
var exprNode = _expr.BuildTree();
parenNode.Expression = exprNode;
return(parenNode);
}
public void Parse_ExpressionWithOuterParens_NotStripped()
{
ASTNode root = ExpressionParser.Parse("{ (someIdentifier + 735.2) }");
Assert.IsInstanceOf <ParenNode>(root);
ParenNode parenNode = (ParenNode)root;
Assert.IsInstanceOf <OperatorNode>(parenNode.expression);
OperatorNode opNode = (OperatorNode)parenNode.expression;
Assert.IsInstanceOf <IdentifierNode>(opNode.left);
Assert.IsInstanceOf <LiteralNode>(opNode.right);
}
public void Parse_NestedParenAddition()
{
ASTNode root = ExpressionParser.Parse("(12 + (4 * 3)) * 2");
Assert.IsInstanceOf <OperatorNode>(root);
OperatorNode opEx = (OperatorNode)root;
Assert.IsInstanceOf <ParenNode>(opEx.left);
Assert.IsInstanceOf <LiteralNode>(opEx.right);
ParenNode parenNode = (ParenNode)opEx.left;
Assert.IsInstanceOf <OperatorNode>(parenNode.expression);
opEx = (OperatorNode)parenNode.expression;
Assert.IsInstanceOf <LiteralNode>(opEx.left);
Assert.IsInstanceOf <ParenNode>(opEx.right);
}
private ExpressionNode parseAtom()
{
expect(TokenType.TRUE, TokenType.FALSE, TokenType.NIL, TokenType.INTEGER, TokenType.IDENT, TokenType.STRING, TokenType.LPAREN);
if (accept(TokenType.TRUE, TokenType.FALSE))
{
return(parseBool());
}
else if (accept(TokenType.NIL))
{
next();
return(NilNode.NIL);
}
else if (accept(TokenType.INTEGER))
{
return(parseInteger());
}
else if (accept(TokenType.IDENT))
{
next();
var isCall = accept(TokenType.LPAREN);
prev();
if (isCall)
{
return(parseCall());
}
else
{
return(parseIdent());
}
}
else if (accept(TokenType.LPAREN))
{
next();
var p = new ParenNode(parseExpression());
expect(TokenType.RPAREN);
next();
return(p);
}
else if (accept(TokenType.STRING))
{
return(parseString());
}
throw new Exception("Unreachable");
}
public void ParenNode_WithExpression_ReturnsCorrectString()
{
// Arranged:
var exprNodeMock = new Mock <IExpressionNode>();
exprNodeMock.Setup(exprNode => exprNode.AstNodeType).Returns(AstNodeType.Expression);
exprNodeMock.Setup(exprNode => exprNode.ToString()).Returns(() => "<T>");
var node = new ParenNode(new Token(TokenKind.LeftParen, "("), _tracer)
{
Expression = exprNodeMock.Object
};
// Act:
var actual = node.ToString();
// Assert:
Assert.That(actual, Is.EqualTo("( <T> )"));
}
public void Parse_ArrayAccess_ParenExpression()
{
ASTNode root = ExpressionParser.Parse("{rootContext[ (1 + 1) ]}");
Assert.IsInstanceOf <MemberAccessExpressionNode>(root);
MemberAccessExpressionNode node = (MemberAccessExpressionNode)root;
Assert.AreEqual("rootContext", node.identifier);
Assert.AreEqual(1, node.parts.Count);
Assert.IsInstanceOf <IndexNode>(node.parts[0]);
Assert.IsInstanceOf <ParenNode>(((IndexNode)node.parts[0]).arguments[0]);
Assert.IsInstanceOf <ParenNode>(((IndexNode)node.parts[0]).arguments[0]);
ParenNode parenNodeOld = (ParenNode)((IndexNode)node.parts[0]).arguments[0];
OperatorNode opNode = (OperatorNode)parenNodeOld.expression;
Assert.AreEqual(OperatorType.Plus, opNode.operatorType);
Assert.IsInstanceOf <LiteralNode>(opNode.left);
Assert.IsInstanceOf <LiteralNode>(opNode.right);
}
private ExpressionNode ParseAtom()
{
Expect(TokenType.TRUE, TokenType.FALSE, TokenType.NIL, TokenType.INTEGER, TokenType.FLOAT, TokenType.STRING, TokenType.HERE_STRING, TokenType.INTERPOLATED_STRING,
TokenType.LPAREN, TokenType.IDENT, TokenType.LBRACK, TokenType.LBRACE, TokenType.PROC, TokenType.VARARGS, TokenType.ENUM);
if (Accept(TokenType.TRUE, TokenType.FALSE))
{
return(ParseBool());
}
else if (Accept(TokenType.NIL))
{
Next();
return(new NilNode(Position(-1)));
}
else if (Accept(TokenType.INTEGER, TokenType.FLOAT))
{
return(ParseNumber());
}
else if (Accept(TokenType.STRING, TokenType.HERE_STRING))
{
return(ParseString());
}
else if (Accept(TokenType.INTERPOLATED_STRING))
{
return(ParseInterpolatedString());
}
else if (Accept(TokenType.LPAREN))
{
Next();
var value = new ParenNode(Position(-1), ParseExpression());
Expect(TokenType.RPAREN);
Next();
return(value);
}
else if (Accept(TokenType.IDENT))
{
return(ParseIdent());
}
else if (Accept(TokenType.LBRACK))
{
return(ParseArray());
}
else if (Accept(TokenType.LBRACE))
{
return(ParseObject());
}
else if (Accept(TokenType.PROC))
{
return(ParseLambda());
}
else if (Accept(TokenType.VARARGS))
{
Next();
return(new VarargsNode(Position(-1)));
}
else if (Accept(TokenType.ENUM))
{
return(ParseEnum());
}
throw new Exception();
}
public void VisitParen(ParenNode node)
{
node.Value.Accept(this);
}
private Mock <IAstNodeFactory> BuildNodeFactory()
{
var mock = new Mock <IAstNodeFactory>();
// Syntax
mock.Setup(factory =>
factory.Create(It.Is <AstNodeType>(nodeType => nodeType == AstNodeType.Syntax),
It.IsAny <IToken>()))
.Returns((AstNodeType nodeType, IToken token) =>
{
var node = new SyntaxNode(token, _tracerMock.Object);
_allNodes.Add(node);
return(node);
});
// Statement
mock.Setup(factory =>
factory.Create(It.Is <AstNodeType>(nodeType => nodeType == AstNodeType.Statement),
It.IsAny <IToken>()))
.Returns((AstNodeType nodeType, IToken token) =>
{
var node = new StatementNode(token, _tracerMock.Object);
_allNodes.Add(node);
return(node);
});
// Expression
mock.Setup(factory =>
factory.Create(It.Is <AstNodeType>(nodeType => nodeType == AstNodeType.Expression),
It.IsAny <IToken>()))
.Returns((AstNodeType nodeType, IToken token) =>
{
var node = new ExpressionNode(token, _tracerMock.Object);
_allNodes.Add(node);
return(node);
});
// Term
mock.Setup(factory =>
factory.Create(It.Is <AstNodeType>(nodeType => nodeType == AstNodeType.Term),
It.IsAny <IToken>()))
.Returns((AstNodeType nodeType, IToken token) =>
{
var node = new TermNode(token, _tracerMock.Object);
_allNodes.Add(node);
return(node);
});
// Factor
mock.Setup(factory =>
factory.Create(It.Is <AstNodeType>(nodeType => nodeType == AstNodeType.Factor),
It.IsAny <IToken>()))
.Returns((AstNodeType nodeType, IToken token) =>
{
var node = new FactorNode(token, _tracerMock.Object);
_allNodes.Add(node);
return(node);
});
// Paren
mock.Setup(factory =>
factory.Create(It.Is <AstNodeType>(nodeType => nodeType == AstNodeType.Paren),
It.IsAny <IToken>()))
.Returns((AstNodeType nodeType, IToken token) =>
{
var node = new ParenNode(token, _tracerMock.Object);
_allNodes.Add(node);
return(node);
});
// Option
mock.Setup(factory =>
factory.Create(It.Is <AstNodeType>(nodeType => nodeType == AstNodeType.Option),
It.IsAny <IToken>()))
.Returns((AstNodeType nodeType, IToken token) =>
{
var node = new OptionNode(token, _tracerMock.Object);
_allNodes.Add(node);
return(node);
});
// Kleene
mock.Setup(factory =>
factory.Create(It.Is <AstNodeType>(nodeType => nodeType == AstNodeType.KleeneStar),
It.IsAny <IToken>()))
.Returns((AstNodeType nodeType, IToken token) =>
{
var node = new KleeneNode(token, _tracerMock.Object);
_allNodes.Add(node);
return(node);
});
// ProdRef
mock.Setup(factory =>
factory.Create(It.Is <AstNodeType>(nodeType => nodeType == AstNodeType.ProdRef),
It.IsAny <IToken>()))
.Returns((AstNodeType nodeType, IToken token) =>
{
var node = new ProdRefNode(token, _tracerMock.Object);
_allNodes.Add(node);
return(node);
});
// Terminal
mock.Setup(factory =>
factory.Create(It.Is <AstNodeType>(nodeType => nodeType == AstNodeType.Terminal),
It.IsAny <IToken>()))
.Returns((AstNodeType nodeType, IToken token) =>
{
var node = new TerminalNode(token, _tracerMock.Object);
_allNodes.Add(node);
return(node);
});
// Action
mock.Setup(factory =>
factory.Create(It.Is <AstNodeType>(nodeType => nodeType == AstNodeType.Action),
It.IsAny <IToken>()))
.Returns((AstNodeType nodeType, IToken token) =>
{
var node = new ActionNode(token, _tracerMock.Object);
_allNodes.Add(node);
return(node);
}); mock.Setup(factory => factory.AllNodes).Returns(_allNodes);
return(mock);
}
public void ParenNodesAreConstantIfTheValueIsConstant()
{
subject = new ParenNode(new SourcePosition(2, 4), new StringNode(new SourcePosition(2, 5), "foo"));
Assert.AreEqual(subject.IsConstant(), true);
}
public ParenNodeTests()
{
subject = new ParenNode(new SourcePosition(2, 4), new IdentNode(new SourcePosition(2, 5), "foo"));
}
public void VisitParen(ParenNode node)
{
VisitParenHandler(node);
}
