private static SyntaxNode RightAssignment(RParser.RightAssignmentContext assignment, Func<ParserRuleContext, Scope, SyntaxNode> transform, Scope scope) { var left = transform(assignment.expr()[1], scope) as ExpressionSyntax; var right = transform(assignment.expr()[0], scope) as ExpressionSyntax; Debug.Assert(left != null && right != null); if (topLevel(assignment)) return assigmentStatement(left, right, scope); Debug.Assert(left is IdentifierNameSyntax); var leftValue = left.ToString(); if (!scope.hasVariable(leftValue)) { scope.PreStatements().Add(preVariable.Get<StatementSyntax>(left)); scope.addVariable(leftValue); } return preAssignment.Get(left, right); }
private static SyntaxNode WhileStatement(RParser.WhileStatementContext whileStatement, Func<ParserRuleContext, Scope, SyntaxNode> transform, Scope scope) { if (!topLevel(whileStatement)) throw new NotImplementedException(); var exprs = whileStatement.expr(); var cond = (ExpressionSyntax)transform(exprs[0], scope); var body = parseBlock(exprs[1], transform, scope); return @while.Get<WhileStatementSyntax>(cond) .WithStatement(body); }
private static SyntaxNode Parenthesized(RParser.ParenthesizedContext parenth, Func<ParserRuleContext, Scope, SyntaxNode> transform, Scope scope) { var expr = transform(parenth.expr(), scope) as ExpressionSyntax; Debug.Assert(expr != null); return CSharp.ParenthesizedExpression(expr); }
private static SyntaxNode RepeatStatement(RParser.RepeatStatementContext repeatStatement, Func<ParserRuleContext, Scope, SyntaxNode> transform, Scope scope) { if (!topLevel(repeatStatement)) throw new NotImplementedException(); BlockSyntax body = parseBlock(repeatStatement.expr(), transform, scope); return repeat .WithStatement(body); }
private static SyntaxNode Index(RParser.IndexContext index, Func<ParserRuleContext, Scope, SyntaxNode> transform, Scope scope) { var indexExprs = index.sublist().sub(); if (indexExprs.Length != 1) { //td: error return null; } var expr = transform(index.expr(), scope) as ExpressionSyntax; var args = transform(index.sublist(), scope) as ArgumentListSyntax; Debug.Assert(expr != null && args != null); var indexExpr = args.Arguments[0].Expression; Debug.Assert(indexExpr != null); return indexCall.Get(expr, indexExpr); }
private static SyntaxNode LinearSequence(RParser.SequenceContext sequence, Func<ParserRuleContext, Scope, SyntaxNode> transform, Scope scope) { var exprs = sequence.expr(); Debug.Assert(exprs.Length == 2); var left = transform(exprs[0], scope) as ExpressionSyntax; var right = transform(exprs[1], scope) as ExpressionSyntax; return linearSequenceCall.Get(left, right); }
private static SyntaxNode IfStatement(RParser.IfStatementContext ifStatement, Func<ParserRuleContext, Scope, SyntaxNode> transform, Scope scope) { if (!topLevel(ifStatement)) throw new NotImplementedException(); var exprs = ifStatement.expr(); var cond = (ExpressionSyntax)transform(exprs[0], scope); var code = parseBlock(exprs[1], transform, scope); return @if.Get<IfStatementSyntax>(cond) .WithStatement(code); }
private static SyntaxNode FunctionCall(RParser.FunctionCallContext call, Func<ParserRuleContext, Scope, SyntaxNode> transform, Scope scope) { var expr = transform(call.expr(), scope) as ExpressionSyntax; var args = transform(call.sublist(), scope) as ArgumentListSyntax; Debug.Assert(expr != null && args != null); if (expr is IdentifierNameSyntax) return createInvocation(expr.ToString(), args); throw new NotImplementedException(); }
private static SyntaxNode ForEachStatement(RParser.ForEachStatementContext forStatement, Func<ParserRuleContext, Scope, SyntaxNode> transform, Scope scope) { if (!topLevel(forStatement)) throw new NotImplementedException(); var exprs = forStatement.expr(); var array = (ExpressionSyntax)transform(exprs[0], scope); var body = parseBlock(exprs[1], transform, scope); return @foreach.Get<ForEachStatementSyntax>(forStatement.ID().ToString(), array) .WithStatement(body); }
private static SyntaxNode ExpressionStatement(RParser.ExpressionStatementContext exprStatement, Func<ParserRuleContext, Scope, SyntaxNode> transform, Scope scope) { var expr = transform(exprStatement.expr(), scope); Debug.Assert(expr != null); if (expr is ExpressionSyntax) return CSharp.ExpressionStatement(expr as ExpressionSyntax); return (StatementSyntax)expr; }
private static SyntaxNode AssignmentStatement(RParser.AssignmentContext assignment, Func<ParserRuleContext, Scope, SyntaxNode> transform, Scope scope) { var left = transform(assignment.expr(), scope) as ExpressionSyntax; var right = transform(assignment.expr_or_assign(), scope) as ExpressionStatementSyntax; Debug.Assert(left != null && right != null); return assigmentStatement(left, right.Expression, scope); }