public virtual Expression visit(LogicalOrExpression expression) { return(visitBinaryExpression(expression)); }
public virtual void Visit(LogicalOrExpression node) { Visit((PolyadicOperatorExpression)node); }
public override void Visit(LogicalOrExpression node) { Visit((BinaryExpression)node); }
/// <summary> /// Reads a logical expression. /// </summary> /// <param name="expressionProxy">Proxy object for the expression being created.</param> /// <param name="leftHandSide">The expression on the left hand side of the operator.</param> /// <param name="previousPrecedence">The precedence of the expression just before this one.</param> /// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param> /// <returns>Returns the expression.</returns> private LogicalExpression GetLogicalExpression( CodeUnitProxy expressionProxy, Expression leftHandSide, ExpressionPrecedence previousPrecedence, bool unsafeCode) { Param.AssertNotNull(expressionProxy, "expressionProxy"); Param.AssertNotNull(leftHandSide, "leftHandSide"); Param.Ignore(previousPrecedence); Param.Ignore(unsafeCode); LogicalExpression expression = null; // Read the details of the expression. OperatorSymbolToken operatorToken = this.PeekOperatorSymbolToken(); CsLanguageService.Debug.Assert(operatorToken.Category == OperatorCategory.Logical, "Expected a logical operator"); // Check the precedence of the operators to make sure we can gather this statement now. ExpressionPrecedence precedence = GetOperatorPrecedence(operatorToken.SymbolType); if (CheckPrecedence(previousPrecedence, precedence)) { // Create the operator toke again and save it. operatorToken = this.GetOperatorSymbolToken(expressionProxy); // Get the expression on the right-hand side of the operator. Expression rightHandSide = this.GetOperatorRightHandExpression(expressionProxy, precedence, unsafeCode); // Get the expression operator type. switch (operatorToken.SymbolType) { case OperatorType.LogicalAnd: expression = new LogicalAndExpression(expressionProxy, leftHandSide, rightHandSide); break; case OperatorType.LogicalOr: expression = new LogicalOrExpression(expressionProxy, leftHandSide, rightHandSide); break; case OperatorType.LogicalXor: expression = new LogicalXorExpression(expressionProxy, leftHandSide, rightHandSide); break; default: CsLanguageService.Debug.Fail("Unexpected operator type"); throw new InvalidOperationException(); } } return expression; }
public override void Visit(LogicalOrExpression node) { UpdateType(node, TypeCalculator.GetType(node)); }
public virtual Expression visit(LogicalOrExpression expression) { return(visit((Expression)expression)); }
public override void Visit(LogicalOrExpression node) { VisitNode(node.Implementation); }
public override void Visit(LogicalOrExpression node) { PushLocation(node); VisitNode(node.Implementation); PopLocation(); }