public override bool Visit(NotEqualNode node) { int nodeLeft = 0; int nodeRight = 0; if (node.Left is NumberNode) { nodeLeft = Visit(node.Left as NumberNode); } else if (node.Left is IdentifierNode) { nodeLeft = Visit(node.Left as IdentifierNode); } else { nodeLeft = Visit(node.Left as InfixExpressionNode); } if (node.Right is NumberNode) { nodeRight = Visit(node.Right as NumberNode); } else if (node.Right is IdentifierNode) { nodeRight = Visit(node.Right as IdentifierNode); } else { nodeRight = Visit(node.Right as InfixExpressionNode); } return(nodeLeft != nodeRight); }
public void Init() { _testExpression = Expression.NotEqual(TestLeftExpression, TestRightExpression); TestObject = new NotEqualNode( MockNodeFactory.Object, TestExpression); }
public void NotEqualExpressionHasExpectedLeft() { IExpressionNode actual = TestObject.Build(TestNotEqualExpression); NotEqualNode actualNode = actual.VerifyIsActually <NotEqualNode>(); ConstantNode leftNode = actualNode.Left.VerifyIsActually <ConstantNode>(); Assert.AreSame(TestConstantZero, leftNode.SourceExpression); }
public void NotEqualExpressionHasExpectedRight() { IExpressionNode actual = TestObject.Build(TestNotEqualExpression); NotEqualNode actualNode = actual.VerifyIsActually <NotEqualNode>(); ConstantNode rightNode = actualNode.Right.VerifyIsActually <ConstantNode>(); Assert.AreSame(TestConstantOne, rightNode.SourceExpression); }
public void NotEqualExpressionIsExpected() { Expression testExpression = TestNotEqualExpression; IExpressionNode actual = TestObject.Build(testExpression); NotEqualNode actualNode = actual.VerifyIsActually <NotEqualNode>(); Assert.AreSame(testExpression, actualNode.SourceExpression); }
public void InvalidOperandstoOrOperation() { NotEqualNode node = new NotEqualNode("!="); node.Left = new BoolNode(true); node.Right = new IntNode(2); SymbolTable symbolTable = new SymbolTable(); TypeCheckSymbolTableVisitor visitor = new TypeCheckSymbolTableVisitor(symbolTable); Assert.ThrowsException <InvalidOperandsException>(() => { visitor.Visit(node); }); }
public override Node VisitInfixRelationalExpr(ML4DParser.InfixRelationalExprContext context) { InfixExpressionNode node; switch (context.op.Type) { case ML4DLexer.LTHAN: node = new LessThanNode(context.op.Text); break; case ML4DLexer.GTHAN: node = new GreaterThanNode(context.op.Text); break; case ML4DLexer.LETHAN: node = new LessEqualThanNode(context.op.Text); break; case ML4DLexer.GETHAN: node = new GreaterEqualThanNode(context.op.Text); break; case ML4DLexer.EQUALS: node = new EqualNode(context.op.Text); break; case ML4DLexer.NOTEQUALS: node = new NotEqualNode(context.op.Text); break; default: throw new NotSupportedException( $"The operator {context.op.Text}, is not a valid relational operator."); } node.Left = (ExpressionNode)Visit(context.left); node.Right = (ExpressionNode)Visit(context.right); return(node); }
private ExpressionNode ParseEquality() { var lhs = ParseRel(); while (true) { if (_reader.Peek() is Equal) { Match <Equal>(); lhs = new EqualNode(lhs, ParseRel()); } else if (_reader.Peek() is NotEqual) { Match <NotEqual>(); lhs = new NotEqualNode(lhs, ParseRel()); } else { break; } } return(lhs); }
protected virtual QueryNode VisitNotEqual(NotEqualNode node, AzureQueryOptimizerState state) { return(this.Visit((QueryNode) new NotNode((QueryNode) new EqualNode(node.LeftNode, node.RightNode, node.Boost)), state)); }
private bool TryExpression(ParserContext context, out IAstNode instr) { IAstNode value2; if (context.Stream.Consume <IAstNode>(TryTerm, context, out var currInstr)) { instr = currInstr; while (!context.Stream.Eof) { if (context.Stream.Consume(TokenTypes.Plus)) { if (!context.Stream.Consume <IAstNode>(TryTerm, context, out value2)) { return(false); } currInstr = new AddNode(currInstr, value2); instr = currInstr; } else if (context.Stream.Consume(TokenTypes.Minus)) { if (!context.Stream.Consume <IAstNode>(TryTerm, context, out value2)) { return(false); } currInstr = new SubNode(currInstr, value2); instr = currInstr; } else if (context.Stream.Consume(TokenTypes.GreaterThan)) { if (!context.Stream.Consume <IAstNode>(TryTerm, context, out value2)) { return(false); } currInstr = new GreaterThanNode(currInstr, value2); instr = currInstr; } else if (context.Stream.Consume(TokenTypes.LessThan)) { if (!context.Stream.Consume <IAstNode>(TryTerm, context, out value2)) { return(false); } currInstr = new LessThanNode(currInstr, value2); instr = currInstr; } else if (context.Stream.Consume(TokenTypes.Equal)) { if (!context.Stream.Consume <IAstNode>(TryTerm, context, out value2)) { return(false); } currInstr = new EqualNode(currInstr, value2); instr = currInstr; } else if (context.Stream.Consume(TokenTypes.NotEqual)) { if (!context.Stream.Consume <IAstNode>(TryTerm, context, out value2)) { return(false); } currInstr = new NotEqualNode(currInstr, value2); instr = currInstr; } else { return(true); } } return(true); } instr = null; return(false); }
private TypeInfo Visit(NotEqualNode node, MethodBuilder builder, CodegenContext context) { return(BinaryOperatorVisit(node, builder, (x) => x.NEqual(), context)); }
public object Visit(NotEqualNode node) { return(!IsEqual(node.Value1, node.Value2)); }
private ValInfo Visit(NotEqualNode node) { return(BinaryOperator(node, (x, y) => x != y)); }
private TypeDescriptor Visit(NotEqualNode node, Context context) { return(RelationOperator(node, context)); }
protected virtual QueryNode VisitNotEqual(NotEqualNode node, ElasticSearchQueryOptimizerState state) { var node2 = new NotNode(new EqualNode(node.LeftNode, node.RightNode, node.Boost)); return(Visit(node2, state)); }
public virtual void VisitNotEqual(NotEqualNode notEqualNode) => throw new NotImplementedException();
public abstract U Visit(NotEqualNode node);