private RdlSyntaxNode ComposeEqualityOperators()
{
var node = ComposeArithmeticOperators(Precendence.Level1);
while (IsEqualityOperator(Current))
{
switch (Current.TokenType)
{
case StatementType.GreaterEqual:
Consume(StatementType.GreaterEqual);
node = new GreaterEqualNode(node, ComposeEqualityOperators());
break;
case StatementType.Greater:
Consume(StatementType.Greater);
node = new GreaterNode(node, ComposeEqualityOperators());
break;
case StatementType.LessEqual:
Consume(StatementType.LessEqual);
node = new LessEqualNode(node, ComposeEqualityOperators());
break;
case StatementType.Less:
Consume(StatementType.Less);
node = new LessNode(node, ComposeEqualityOperators());
break;
case StatementType.Equality:
Consume(StatementType.Equality);
node = new EqualityNode(node, ComposeEqualityOperators());
break;
case StatementType.Diff:
Consume(StatementType.Diff);
node = new DiffNode(node, ComposeEqualityOperators());
break;
case StatementType.Between:
node = new BetweenNode(ConsumeAndGetToken(), node,
ComposeAndSkip(f => f.ComposeArithmeticOperators(Precendence.Level1), StatementType.And),
ComposeArithmeticOperators(Precendence.Level1));
break;
case StatementType.Not:
Consume(StatementType.Not);
node = new NotNode(Current, node);
break;
default:
throw new NotSupportedException();
}
}
return(node);
}
public override ASTNode VisitComparisson([NotNull] CoolParser.ComparissonContext context)
{
BinaryOperatorNode coNode = null;
if (context.op.Text == "<")
{
coNode = new LessNode(context.Start.Line, context.Start.Column);
}
if (context.op.Text == "=")
{
coNode = new EqualNode(context.Start.Line, context.Start.Column);
}
if (context.op.Text == "<=")
{
coNode = new LessEqualNode(context.Start.Line, context.Start.Column);
}
coNode.LeftOperand = Visit(context.expr(0)) as ExpressionNode;
coNode.RightOperand = Visit(context.expr(1)) as ExpressionNode;
return(coNode);
}
/// <summary>
/// Visit LessEqual node in DFS manner.
/// </summary>
/// <param name="node">LessEqual node that will be visited.</param>
public void Visit(LessEqualNode node)
{
node.Left.Accept(this);
node.Right.Accept(this);
node.Accept(_visitor);
}
public override void Visit(LessEqualNode node)
{
ReportReturnTypesAreNotSame(node, "LessEqual");
}
public override void Visit(LessEqualNode node) => ProduceDebuggerInstructions(node, n => base.Visit(n));
/// <summary> /// Visit LessEqual node. /// </summary> /// <param name="node">LessEqual node of AST</param> public abstract void Visit(LessEqualNode node);
public void Visit(LessEqualNode node)
{
}
/// <summary>
/// Performs "LessEqual" specific operations.
/// </summary>
/// <param name="node">The "LessEqual" node.</param>
public virtual void Visit(LessEqualNode node)
{
ExpressionGenerateInstructions <LessEqualNumeric>();
}
