public virtual void Visit(LessNode node)
{
var right = Nodes.Pop();
var left = Nodes.Pop();
Nodes.Push(new LessNode(left, right));
}
public bool Append(LessNode node)
{
int previousLength = outputBuffer.Length;
node.WriteOutput(this);
return(previousLength != outputBuffer.Length);
}
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);
}
public void Visit(LessNode node)
{
node.Left.Accept(this);
node.Right.Accept(this);
node.Accept(_visitor);
}
/// <summary>
/// This method prints the lessNode
/// </summary>
/// <param name="lessNode">The node to print.</param>
/// <returns>Returns null</returns>
public override object Visit(LessNode lessNode)
{
Print("LessNode");
return(null);
}
public void Visit(LessNode node)
{
}
private TypeInfo Visit(LessNode node, MethodBuilder builder, CodegenContext context)
{
return(BinaryOperatorVisit(node, builder, (x) => x.Less(), context));
}
public override void Visit(LessNode node)
{
ReportReturnTypesAreNotSame(node, "Less");
}
/// <summary>
/// This method type checks the LessNode node in the AST.
/// </summary>
/// <param name="lessNode">The node to check.</param>
/// <returns>Less operator type context</returns>
public override object Visit(LessNode lessNode)
{
return(new TypeContext(OP_LESS));
}
private TypeDescriptor Visit(LessNode node, Context context)
{
return(RelationOperator(node, context));
}
private ValInfo Visit(LessNode node)
{
return(BinaryOperator(node, (x, y) => x < y));
}
private Expression GetSingleValuedExpression(LessParser.SingleValuedExpressionContext context)
{
Expression GetMathOperation()
{
var mathOperation = context.op;
if (mathOperation == null)
{
return(null);
}
var lhs = GetSingleValuedExpression(context.singleValuedExpression(0));
var rhs = GetSingleValuedExpression(context.singleValuedExpression(1));
return(new MathOperation(lhs, mathOperation.Text, rhs, keepSpaces: HasLeadingWhitespace(mathOperation) && HasTrailingWhitespace(mathOperation)));
}
Expression GetColor()
{
var color = context.color();
if (color == null)
{
return(null);
}
var hexColor = color.HexColor();
if (hexColor != null)
{
return(Color.FromHexString(hexColor.GetText()));
}
return(Color.FromKeyword(color.KnownColor().GetText()));
}
Expression GetStringLiteral()
{
return((LessString)context.@string()?.Accept(this));
}
Expression GetBoolean()
{
var boolean = context.booleanValue();
if (boolean == null)
{
return(null);
}
return(new BooleanValue(string.Equals("true", boolean.GetText())));
}
if (context == null)
{
return(null);
}
LessNode result = context.variableName()?.Accept(this)
?? GetColor()
?? context.measurement()?.Accept(this)
?? GetStringLiteral()
?? context.escapeSequence()?.Accept(this)
?? context.function()?.Accept(this)
?? context.unicodeRange()?.Accept(this)
?? context.identifier()?.Accept(this)
?? context.parenthesizedExpression()?.Accept(this)
?? GetMathOperation()
?? context.url()?.Accept(this)
?? context.quotedExpression()?.Accept(this)
?? context.selector()?.Accept(this)
?? GetBoolean()
?? throw new ParserException($"Unexpected expression {context.GetText()}");
return((Expression)result);
}
public override void Visit(LessNode node) => ProduceDebuggerInstructions(node, n => base.Visit(n));
/// <summary>
/// This method visits a less node
/// </summary>
/// <param name="lessNode">The name of the node</param>
/// <returns>It returns <</returns>
public override object Visit(LessNode lessNode)
{
return(" < ");
}
/// <summary> /// Visit Less node. /// </summary> /// <param name="node">Less node of AST</param> public abstract void Visit(LessNode node);
/// <summary> /// This visits a less node /// </summary> /// <param name="lessNode">The visited node</param> /// <returns></returns> public abstract object Visit(LessNode lessNode);
/// <summary>
/// Performs "Less" specific operations.
/// </summary>
/// <param name="node">The "Less" node.</param>
public virtual void Visit(LessNode node)
{
ExpressionGenerateInstructions <LessNumeric>();
}
