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