private static ArgumentListSyntax Arguments(ParserRuleContext node)
{
var expr = null as ExpressionSyntax;
var args = null as ArgumentListSyntax;
if (node.ChildCount == 1)
{
expr = visitNode(node.GetRuleContext <ParserRuleContext>(0));
}
else
{
Debug.Assert(node.ChildCount == 2);
expr = visitNode(node.GetRuleContext <ParserRuleContext>(1));
args = Arguments(node.GetRuleContext <ParserRuleContext>(0));
}
var arg = CSharp.Argument(expr);
if (args != null)
{
return(args.AddArguments(arg));
}
return(CSharp
.ArgumentList(CSharp
.SeparatedList(new[] { arg })));
}
private static ExpressionSyntax Parenthesized(ParserRuleContext node)
{
if (node.ChildCount == 1)
{
return(Expression(node.GetRuleContext <ParserRuleContext>(0)));
}
Debug.Assert(node.ChildCount == 3);
var expr = visitNode(node.GetRuleContext <ParserRuleContext>(0));
return(CSharp.ParenthesizedExpression(expr));
}
private static ExpressionSyntax Cast(ParserRuleContext node)
{
if (node.ChildCount == 1)
{
return(Expression(node.GetRuleContext <ParserRuleContext>(0)));
}
Debug.Assert(node.ChildCount == 2);
var type = CSharp.ParseTypeName(node.children[0].GetText());
var expr = visitNode(node.GetRuleContext <ParserRuleContext>(1));
return(CSharp.CastExpression(type, expr));
}
private static ExpressionSyntax Index(ParserRuleContext node)
{
if (node.ChildCount == 1)
{
return(Expression(node.GetRuleContext <ParserRuleContext>(0)));
}
Debug.Assert(node.ChildCount == 4);
var expr = visitNode(node.GetRuleContext <ParserRuleContext>(0));
var index = (ArgumentListSyntax)Arguments(node.GetRuleContext <ParserRuleContext>(2));
return(CSharp.ElementAccessExpression(
expr, CSharp
.BracketedArgumentList(index.Arguments)));
}
private static ExpressionSyntax PostFix(ParserRuleContext node)
{
if (node.ChildCount == 1)
{
return(Expression(node.GetRuleContext <ParserRuleContext>(0)));
}
Debug.Assert(node.ChildCount == 2);
var expr = visitNode(node.GetRuleContext <ParserRuleContext>(0));
SyntaxKind kind;
var op = GetBinaryOperator(node.children[1].GetText(), out kind);
return(CSharp.PostfixUnaryExpression(kind, expr, op));
}
private static ExpressionSyntax Assignment(ParserRuleContext node)
{
if (node.ChildCount == 1)
{
return(Expression(node.GetRuleContext <ParserRuleContext>(0)));
}
Debug.Assert(node.ChildCount == 3);
var left = visitNode(node.GetRuleContext <ParserRuleContext>(0));
var right = visitNode(node.GetRuleContext <ParserRuleContext>(2));
SyntaxKind kind;
var op = GetBinaryOperator(node.children[1].GetText(), out kind);
return(CSharp.AssignmentExpression(kind, left, op, right));
}
private static Selection GetProcedureContextSelection(ParserRuleContext context)
{
var endContext = context.GetRuleContext <VBAParser.EndOfStatementContext>(0);
return(new Selection(context.Start.Line == 0 ? 1 : context.Start.Line,
context.Start.Column + 1,
endContext.Start.Line == 0 ? 1 : endContext.Start.Line,
endContext.Start.Column + 1));
}
private static ArgumentListSyntax Arguments(ParserRuleContext node)
{
var expr = null as ExpressionSyntax;
var args = null as ArgumentListSyntax;
if (node.ChildCount == 1)
expr = visitNode(node.GetRuleContext<ParserRuleContext>(0));
else
{
Debug.Assert(node.ChildCount == 2);
expr = visitNode(node.GetRuleContext<ParserRuleContext>(1));
args = Arguments(node.GetRuleContext<ParserRuleContext>(0));
}
var arg = CSharp.Argument(expr);
if (args != null)
return args.AddArguments(arg);
return CSharp
.ArgumentList(CSharp
.SeparatedList(new[] { arg }));
}
private static ExpressionSyntax Call(ParserRuleContext node)
{
if (node.ChildCount == 1)
{
return(Expression(node.GetRuleContext <ParserRuleContext>(0)));
}
var expr = visitNode(node.GetRuleContext <ParserRuleContext>(0));
var args = null as ArgumentListSyntax;
if (node.ChildCount == 4)
{
args = Arguments(node.GetRuleContext <ParserRuleContext>(2));
}
else
{
args = CSharp.ArgumentList();
}
return(CSharp.InvocationExpression(expr, args));
}
private LogicalOperation Goto(ParserRuleContext context, int i) => Visit(context.GetRuleContext <LogicalGrammarParser.ExpressionContext>(i));
private static ExpressionSyntax Expression(ParserRuleContext node)
{
Debug.Assert(node.ChildCount == 1);
return(visitNode(node.GetRuleContext <ParserRuleContext>(0)));
}
private static ExpressionSyntax Cast(ParserRuleContext node)
{
if (node.ChildCount == 1)
return Expression(node.GetRuleContext<ParserRuleContext>(0));
Debug.Assert(node.ChildCount == 2);
var type = CSharp.ParseTypeName(node.children[0].GetText());
var expr = visitNode(node.GetRuleContext<ParserRuleContext>(1));
return CSharp.CastExpression(type, expr);
}
private static ExpressionSyntax Expression(ParserRuleContext node)
{
Debug.Assert(node.ChildCount == 1);
return visitNode(node.GetRuleContext<ParserRuleContext>(0));
}
private static ExpressionSyntax Index(ParserRuleContext node)
{
if (node.ChildCount == 1)
return Expression(node.GetRuleContext<ParserRuleContext>(0));
Debug.Assert(node.ChildCount == 4);
var expr = visitNode(node.GetRuleContext<ParserRuleContext>(0));
var index = (ArgumentListSyntax)Arguments(node.GetRuleContext<ParserRuleContext>(2));
return CSharp.ElementAccessExpression(
expr, CSharp
.BracketedArgumentList(index.Arguments));
}
private static ExpressionSyntax Parenthesized(ParserRuleContext node)
{
if (node.ChildCount == 1)
return Expression(node.GetRuleContext<ParserRuleContext>(0));
Debug.Assert(node.ChildCount == 3);
var expr = visitNode(node.GetRuleContext<ParserRuleContext>(0));
return CSharp.ParenthesizedExpression(expr);
}
private static ExpressionSyntax UnaryExpression(ParserRuleContext node)
{
if (node.ChildCount == 1)
return Expression(node.GetRuleContext<ParserRuleContext>(0));
Debug.Assert(node.ChildCount == 2);
var expr = visitNode(node.GetRuleContext<ParserRuleContext>(2));
SyntaxKind kind;
var op = GetUnaryOperator(node.children[0].GetText(), out kind);
return CSharp.PrefixUnaryExpression(kind, op, expr);
}
private static ExpressionSyntax Call(ParserRuleContext node)
{
if (node.ChildCount == 1)
return Expression(node.GetRuleContext<ParserRuleContext>(0));
var expr = visitNode(node.GetRuleContext<ParserRuleContext>(0));
var args = null as ArgumentListSyntax;
if (node.ChildCount == 4)
args = Arguments(node.GetRuleContext<ParserRuleContext>(2));
else
args = CSharp.ArgumentList();
return CSharp.InvocationExpression(expr, args);
}
static public ParserRuleContext GetRule(this ParserRuleContext context, int i)
{
return(context.GetRuleContext <ParserRuleContext>(i));
}
private static ExpressionSyntax Assignment(ParserRuleContext node)
{
if (node.ChildCount == 1)
return Expression(node.GetRuleContext<ParserRuleContext>(0));
Debug.Assert(node.ChildCount == 3);
var left = visitNode(node.GetRuleContext<ParserRuleContext>(0));
var right = visitNode(node.GetRuleContext<ParserRuleContext>(2));
SyntaxKind kind;
var op = GetBinaryOperator(node.children[1].GetText(), out kind);
return CSharp.AssignmentExpression(kind, left, op, right);
}
private string GetNodeName(ParserRuleContext node)
{
QualifiedNameContext qualifiedName = node.GetRuleContext <QualifiedNameContext>(0);
return(qualifiedName?.GetText());
}
private Expression GetLeft(ParserRuleContext context)
{
return(Visit(context.GetRuleContext <QlParser.ExprContext>(0)));
}
