public void VisitExpressionStatement(ExpressionStatementNode node) { node.Expression.AcceptExpressionVisitor(this); // Remove Result From Stack int resultSize = GetExpressionResultSize(node.Expression); _functionBuilder.AddInstruction(OpCode.POP, 0, resultSize); }
private IStatementNode ParseSimpleStatementNode(bool canHaveLabel = false) { var token = this.NextToken(); while (token != null && token.Type == TokenType.NewLine) { token = this.NextToken(); } if (token == null) { return(null); } if (token.Type == TokenType.Name) { IStatementNode stmt = this.TryParseNameStatement(token.Value); if (stmt != null) { return(stmt); } } this.PushToken(token); if (token.Type == TokenType.Delimiter && token.Value == "{") { return(this.ParseStatementBlock()); } IExpressionNode node = this.ParseExpressionNode(); if (node == null) { return(null); } AssignmentNode anode = this.TryParseAssignmentNode(node); if (anode != null) { return(anode); } if (this.TryParseToken(TokenType.Operator, "<-")) { var cmdnode = new SendNode(node, this.ParseExpressionNode()); return(cmdnode); } var cmd = new ExpressionStatementNode(node); return(cmd); }
private void Write(ExpressionStatementNode stmt, bool notlambda = true) { if (string.IsNullOrEmpty(stmt.Documentation)) { if (notlambda) { Fill(); } Write(stmt.Children[0]); } }
public virtual Value evaluate(Context cx, ExpressionStatementNode node) { output("<ExpressionStatementNode position=\"" + node.pos() + "\">"); indent_Renamed_Field++; if (node.expr != null) { node.expr.evaluate(cx, this); } indent_Renamed_Field--; output("</ExpressionStatementNode>"); return(null); }
private Statement ProcessExpressionStatement(ExpressionStatementNode node) { Expression expression = _expressionBuilder.BuildExpression(node.Expression); if (expression == null) { // This happens when the expression is a method call, and the method // is debug conditional return(null); } return(new ExpressionStatement(expression)); }
private static PythonNode Wrap(ExpressionStatement stmt, PythonNode parent) { var result = new ExpressionStatementNode(stmt) { Parent = parent }; if (!stmt.Documentation.IsNullOrEmpty()) { result.Documentation = stmt.Documentation; } result.AddChild(Wrap(stmt.Expression, result)); return(result); }
public void Accept(ExpressionStatementNode node) { node.Expression.Visit(this); // Peephole optimization: Remove push/pop redundancies var instructions = methodStack.Peek().Instructions; var type = instructions[instructions.Count - 1].InstructionType; if (type == InstructionType.LoadAttribute || type == InstructionType.LoadGlobal || type == InstructionType.LoadLocal || type == InstructionType.Push || type == InstructionType.PushConstant || type == InstructionType.PushHandler || type == InstructionType.PushObject) { instructions.Remove(instructions[instructions.Count - 1]); } else { emit(node.SourceLocation, InstructionType.Pop); } }
private IEnumerable <Statement> ExpandInitializerStatements(StatementBuilder statementBuilder, VariableDeclarationNode variableDeclarationNode) { var variableInitializer = variableDeclarationNode.Initializers.First() .As <VariableInitializerNode>(); var objectInitializer = variableInitializer.Value .As <ObjectInitializerNode>(); List <Statement> statements = new List <Statement>(); foreach (var initializerStatement in objectInitializer.ObjectAssignmentExpressions) { var originalStatement = initializerStatement; if (originalStatement is BinaryExpressionNode binaryExpressionNode && binaryExpressionNode.LeftChild is NameNode) { var objectInitializerAccess = new BinaryExpressionNode(variableInitializer.Name, TokenType.Dot, binaryExpressionNode.LeftChild); var assignmentExpression = new BinaryExpressionNode(objectInitializerAccess, binaryExpressionNode.Operator, binaryExpressionNode.RightChild); var fullObjectInitializerExpression = new ExpressionStatementNode(assignmentExpression); statements.Add(statementBuilder.BuildStatement(fullObjectInitializerExpression)); } } return(statements); }
public void AmbiguityGrammarAggregationTest() { CompilationErrorManager em = new CompilationErrorManager(); AmbiguityParser parser = new AmbiguityParser(em); const string input = "a<b>c;a<b>c;a<b>c;a<b>c;a<b>c;"; var result = parser.Parse(input); var resarr = result.ToArray(); Assert.AreEqual(5, resarr.Length); foreach (var r in resarr) { var ambStat = r as AmbiguityStatementNode; Assert.IsNotNull(ambStat); VarDeclStatementNode vardecl = ambStat.s1 as VarDeclStatementNode; if (vardecl == null) { vardecl = ambStat.s2 as VarDeclStatementNode; } Assert.IsNotNull(vardecl); ExpressionStatementNode expstat = ambStat.s1 as ExpressionStatementNode; if (expstat == null) { expstat = ambStat.s2 as ExpressionStatementNode; } Assert.IsNotNull(expstat); } }
public void VisitExpressionStatement(ExpressionStatementNode node) { node.Expression.AcceptSyntaxTreeVisitor(_childrenVisitor); }
private Statement BindExpressionStatement(ExpressionStatementNode node) { var expression = BindExpression(node.Expression, allowVoid: true); return(new ExpressionStatement(Scope, expression)); }
public void VisitExpressionStatement(ExpressionStatementNode node) { _visitor.VisitStatement(node); //node.Expression.AcceptSyntaxTreeVisitor(_visitor); node.Expression.AcceptSyntaxTreeVisitor(_childrenVisitor); }
public void VisitExpressionStatement(ExpressionStatementNode node) { UpdateLine(node); node.Value.Accept(this); asm.Pop(); }
protected override Boolean handleExpression(ExpressionStatementNode expression, HashSet <StatementNode> visited) { var state = expressionChecker.handleExpression(expression.Expression, visited, false); return((state == AssignmentState.Assigned) ? Boolean.FALSE : Boolean.TRUE); }
public void VisitExpressionStatement(ExpressionStatementNode node) { node.Expression = _processor.ProcessReplacement(node.Expression); }
public void VisitExpressionStatement(ExpressionStatementNode node) { Print("Expression Statement"); VisitSubnode(node.Expression); }
public ExpressionStatementNodeTests() { value = new IdentNode(SourcePosition.NIL, "foo"); subject = new ExpressionStatementNode(SourcePosition.NIL, value); }
public void VisitExpressionStatement(ExpressionStatementNode node) { VisitExpressionStatementNodeHandler(node); }
public virtual Value evaluate(Context cx, ExpressionStatementNode node) { output("<ExpressionStatementNode position=\"" + node.pos() + "\">"); indent_Renamed_Field++; if (node.expr != null) { node.expr.evaluate(cx, this); } indent_Renamed_Field--; output("</ExpressionStatementNode>"); return null; }
public void Accept(ExpressionStatementNode node) { node.Expression.Visit(this); append("popv"); }
public void VisitExpressionStatement(ExpressionStatementNode node) { ExpressionStatementVisitor?.Visit(node); }
private StatementNode ParseStatement() { Expect(TokenType.EXPORTED, TokenType.PROC, TokenType.FINAL, TokenType.VAR, TokenType.IF, TokenType.BREAK, TokenType.CONTINUE, TokenType.FOR, TokenType.WHILE, TokenType.DO, TokenType.DEFER, TokenType.RETURN, TokenType.IDENT, TokenType.LPAREN, TokenType.LBRACE, TokenType.TRY, TokenType.THROW, TokenType.ENUM, TokenType.INC, TokenType.DEC); if (Accept(TokenType.PROC)) { return(ParseProc(false)); } else if (Accept(TokenType.FINAL, TokenType.VAR)) { return(ParseVar(false)); } else if (Accept(TokenType.IF)) { return(ParseIf()); } else if (Accept(TokenType.BREAK)) { var pos = Position(); Next(); Expect(TokenType.SEMICOLON); Next(); return(new BreakNode(pos)); } else if (Accept(TokenType.CONTINUE)) { var pos = Position(); Next(); Expect(TokenType.SEMICOLON); Next(); return(new ContinueNode(pos)); } else if (Accept(TokenType.FOR)) { return(ParseFor()); } else if (Accept(TokenType.WHILE)) { return(ParseWhile()); } else if (Accept(TokenType.DO)) { return(ParseDo()); } else if (Accept(TokenType.DEFER)) { var pos = Position(); Next(); return(new DeferNode(pos, ParseStatement())); } else if (Accept(TokenType.RETURN)) { return(ParseReturn()); } else if (Accept(TokenType.IDENT, TokenType.LPAREN, TokenType.INC, TokenType.DEC)) { var pos = Position(); var left = ParseExpression(); if (left is CallNode || (left is UnaryNode u && (u.OP == UnaryOP.PREFIX_INCREMENT || u.OP == UnaryOP.PREFIX_DECREMENT || u.OP == UnaryOP.POSTFIX_INCREMENT || u.OP == UnaryOP.POSTFIX_DECREMENT))) { var stmt = new ExpressionStatementNode(pos, left); Expect(TokenType.SEMICOLON); Next(); return(stmt); } else { if (Accept(TokenType.ASSIGN, TokenType.ADD_ASSIGN, TokenType.SUB_ASSIGN, TokenType.MUL_ASSIGN, TokenType.DIV_ASSIGN, TokenType.POW_ASSIGN, TokenType.MOD_ASSIGN, TokenType.LSH_ASSIGN, TokenType.RSH_ASSIGN, TokenType.BIT_NOT_ASSIGN, TokenType.BIT_AND_ASSIGN, TokenType.BIT_OR_ASSIGN, TokenType.BIT_XOR_ASSIGN, TokenType.AND_ASSIGN, TokenType.OR_ASSIGN, TokenType.CONCAT_ASSIGN)) { if (!(left is IdentNode || left is IndexNode)) { Unexpected(); } var pos2 = Position(); var op = ParseAssignOP(); Next(); var right = ParseExpression(); Expect(TokenType.SEMICOLON); Next(); return(new AssignNode(pos, op, left, right)); } else { Unexpected(); } } }
public void VisitExpressionStatement(ExpressionStatementNode node) { _scopeManager.SetScope(node, _currentScope); RecurseExpression(node.Expression); }
private void WriteExpressionStatement(ExpressionStatementNode expressionStatement) { WriteExpression(expressionStatement.Expression); _builder.Append(expressionStatement.PeriodToken); }
public void VisitExpressionStatement(ExpressionStatementNode node) { VisitDefaultStatement(node); }
public void VisitExpressionStatement(ExpressionStatementNode node) { }
protected override Void handleExpression(ExpressionStatementNode expression, Set <TypeInfo> dependencies) { expressionHandler.handleExpression(expression.Expression, dependencies, false); return(null); }
public void VisitExpressionStatement(ExpressionStatementNode node) { node.Expression.AcceptExpressionVisitor(this); }
public ExpressionStatementNode makeExpressionStatementNode(ExprNode expr) { ExpressionStatementNode node = new ExpressionStatementNode(expr); return(node); }
// case NodeType.BlockStmt: // codeGen.evalBlockStatement(node); // break; // case NodeType.AssignStmt: // codeGen.evalAssignStatement(node); // break; // case NodeType.IfStmt: // codeGen.evalIfStatement(node); // break; // case NodeType.SwitchStmt: // codeGen.evalSwitchStatement(node); // break; // case NodeType.CaseStmt: // codeGen.evalCaseStatement(node); // break; // case NodeType.WhileStmt: // codeGen.evalwhileStatement(node); // break; // case NodeType.DoWhileStmt: // codeGen.evalDoWhileStatement(node); // break; // case NodeType.ForStmt: // codeGen.evalForStatement(node); // break; // case NodeType.BreakStmt: // codeGen.evalBreakStatement(node); // break; // case NodeType.ContinueStmt: // codeGen.evalContinueStatement(node); // break; // case NodeType.ReturnStmt: // codeGen.evalReturnStatement(node); // break; public void genExpressionStatement(ExpressionStatementNode stmt) { genExpression(stmt.expr); }
protected override Void handleExpression(ExpressionStatementNode expression, Void source) { this.ExpressionValidator.handleExpression(expression.Expression, null, false); return(null); }