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