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