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