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