public override void Visit(LogicalAndExpression node)
{
var implementation = GetCloneOf(node.Implementation);
unfinishedClone = new LogicalAndExpression(implementation.Left, implementation.Middle, implementation);
base.Visit(node);
}
// Currently disabled, to avoid problems with expressions
// like hello " + (1 * "World".
//
// public Expression visit(BinaryOperatorExpression boe) {
// Token op = boe.operator;
//
// if (boe.leftExpression instanceof NumberLiteral
// && boe.rightExpression instanceof NumberLiteral) {
// double leftValue = ((NumberLiteral) boe.leftExpression).value;
// double rightValue = ((NumberLiteral) boe.rightExpression).value;
//
// if ((op == Token.OPERATOR_PLUS && leftValue == 0.0)
// || (op == Token.OPERATOR_MULTIPLY && leftValue == 1.0)) {
// return boe.rightExpression;
// }
//
// if((op == Token.OPERATOR_PLUS && rightValue == 0.0)
// || (op == Token.OPERATOR_MULTIPLY && rightValue == 1.0)
// || (op == Token.OPERATOR_DIVIDE && rightValue == 1.0))
// return boe.leftExpression;
// }
//
// return boe;
// }
public override Expression visit(LogicalAndExpression expression)
{
if (expression.leftExpression is BooleanLiteral)
{
if (((BooleanLiteral)expression.leftExpression).value == false)
{
return(expression.leftExpression);
}
else if (((BooleanLiteral)expression.leftExpression).value == true)
{
return(expression.rightExpression);
}
}
if (expression.rightExpression is BooleanLiteral)
{
if (((BooleanLiteral)expression.rightExpression).value == false)
{
return(expression.rightExpression);
}
else if (((BooleanLiteral)expression.rightExpression).value == true)
{
return(expression.leftExpression);
}
}
return(expression);
}
public void Visit(LogicalAndExpression node)
{
for (int i = 0, len = node.Arity; i < len; ++i)
{
var oprand = node.GetOperand(i);
VisitChild(2, _verdictColumn && IsVerdictPassthroughWhere(oprand), false, oprand);
}
}
public void LogicalAndExpression()
{
var e = new LogicalAndExpression(new Literal("13"), new Literal("37"));
Assert.IsFalse(e.IsTrivial);
Assert.AreEqual("(13&&37)", e.ToString());
Assert.AreEqual("LogicalAnd", e.Name);
}
// [22] LogicalANDExpression = InclusiveORExpression {'&&' InclusiveORExpression}.
private bool IsLogicalAndExpression(out LogicalAndExpression logicalAndExpression)
{
logicalAndExpression = new LogicalAndExpression();
if (!IsInclusiveOrExpression(out var inclusiveOrExpression))
{
return(false);
}
while (CheckToken(SyntaxKind.AmpersandAmpersandToken))
{
if (!IsLogicalOrExpression(out var logicalOrExpression))
{
return(false);
}
}
return(true);
}
internal Expression ParseImplicitLogicalAnd(Expression lhs) // E' -> E E'
{
Expression rhs = this.ParseEx();
if (rhs != null)
{
Expression res = new LogicalAndExpression()
{
Lhs = lhs, Rhs = rhs
};
return(this.ParseExPrime(res));
}
else
{
return(null);
}
}
internal Expression ParseLogicalAnd(Expression lhs) // E' -> && E E'
{
if (this.input.Read() is LogicalAndToken)
{
Expression rhs = this.ParseEx();
if (rhs != null)
{
Expression res = new LogicalAndExpression()
{
Lhs = lhs, Rhs = rhs
};
return(this.ParseExPrime(res));
}
else
{
throw new ArgumentException("Failed to parsed LogicalAnd");
}
}
else
{
this.input.Unread();
return(null);
}
}
/// <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(LogicalAndExpression node)
{
PushLocation(node);
VisitNode(node.Implementation);
PopLocation();
}
public virtual Expression visit(LogicalAndExpression expression)
{
return(expression);
}
public override void Visit(LogicalAndExpression node)
{
Visit((BinaryExpression)node);
}
public virtual Expression visit(LogicalAndExpression expression)
{
return(visitBinaryExpression(expression));
}
/// <summary>
/// The following are rules for C expressions.
/// </summary>
public static void SetExpressionRules()
{
// expression
// : assignment-expression [ ',' assignment-expression ]*
Expression.Is(
AssignmentExpression
.OneOrMore(Comma)
.Then(exprs => {
if (exprs.Count == 1)
{
return(exprs[0]);
}
return(AssignmentList.Create(exprs));
})
);
// primary-expression
// : identifier # Cannot be a typedef name.
// | constant
// | string-literal
// | '(' expression ')'
PrimaryExpression.Is(
Either(Variable)
.Or(Constant)
.Or(StringLiteral)
.Or(
(LeftParen).Then(Expression).Then(RightParen)
)
);
// An identifier for a variable must not be defined as a typedef name.
Variable.Is(
Identifier.Check(result => !result.Environment.IsTypedefName(result.Result)).Then(AST.Variable.Create)
);
// constant
// : const-char
// : const-int
// : const-float
Constant.Is(
Either(ConstChar)
.Or(ConstInt)
.Or(ConstFloat)
);
// constant-expression
// : conditional-expression
//
// Note:
// The size of an array should be a constant.
// Note that the check is actually performed in semantic analysis.
ConstantExpression.Is(
ConditionalExpression
);
// conditional-expression
// : logical-or-expression [ '?' expression ':' conditional-expression ]?
ConditionalExpression.Is(
(LogicalOrExpression)
.Then(
Given <Expr>()
.Then(Question)
.Then(Expression)
.Then(Colon)
.Then(ConditionalExpression)
.Then(AST.ConditionalExpression.Create)
.Optional()
)
);
// assignment-expression
// : unary-expression assignment-operator assignment-expression # first-set = first-set(unary-expression)
// | conditional-expression # first-set = first-set(cast-expression) = first-set(unary-expression) ++ { '(' }
//
// Note:
// Assignment operators are:
// '=', '*=', '/=', '%=', '+=', '-=', '<<=', '>>=', '&=', '^=', '|='
AssignmentExpression.Is(
Either(
AssignmentOperator(
UnaryExpression,
AssignmentExpression,
BinaryOperatorBuilder.Create(Assign, Assignment.Create),
BinaryOperatorBuilder.Create(MultAssign, AST.MultAssign.Create),
BinaryOperatorBuilder.Create(DivAssign, AST.DivAssign.Create),
BinaryOperatorBuilder.Create(ModAssign, AST.ModAssign.Create),
BinaryOperatorBuilder.Create(AddAssign, AST.AddAssign.Create),
BinaryOperatorBuilder.Create(SubAssign, AST.SubAssign.Create),
BinaryOperatorBuilder.Create(LeftShiftAssign, LShiftAssign.Create),
BinaryOperatorBuilder.Create(RightShiftAssign, RShiftAssign.Create),
BinaryOperatorBuilder.Create(BitwiseAndAssign, AST.BitwiseAndAssign.Create),
BinaryOperatorBuilder.Create(XorAssign, AST.XorAssign.Create),
BinaryOperatorBuilder.Create(BitwiseOrAssign, AST.BitwiseOrAssign.Create)
)
).Or(
ConditionalExpression
)
);
// postfix-expression
// : primary-expression [
// '[' expression ']' # Get element from array
// | '(' [argument-expression-list]? ')' # Function call
// | '.' identifier # Get member from struct/union
// | '->' identifier # Get member from struct/union
// | '++' # Increment
// | '--' # Decrement
// ]*
PostfixExpression.Is(
PrimaryExpression
.Then(
Either(
Given <Expr>()
.Then(LeftBracket)
.Then(Expression)
.Then(RightBracket)
.Then((array, index) => Dereference.Create(AST.Add.Create(array, index)))
).Or(
Given <Expr>()
.Then(LeftParen)
.Then(ArgumentExpressionList.Optional(ImmutableList <Expr> .Empty))
.Then(RightParen)
.Then(FuncCall.Create)
).Or(
Given <Expr>()
.Then(Period)
.Then(Identifier)
.Then(Attribute.Create)
).Or(
Given <Expr>()
.Then(RightArrow)
.Then(Identifier)
.Then((expr, member) => Attribute.Create(Dereference.Create(expr), member))
).Or(
Given <Expr>()
.Then(Increment)
.Then(PostIncrement.Create)
).Or(
Given <Expr>()
.Then(Decrement)
.Then(PostDecrement.Create)
).ZeroOrMore()
)
);
// argument-expression-list
// : assignment-expression [ ',' assignment-expression ]*
ArgumentExpressionList.Is(
AssignmentExpression.OneOrMore(Comma)
);
// unary-expression
// : postfix-expression # first-set = { id, const, string }
// | '++' unary-expression # first-set = { '++' }
// | '--' unary-expression # first-set = { '--' }
// | unary-operator cast-expression # first-set = { '&', '*', '+', '-', '~', '!' }
// | 'sizeof' unary-expression # first-set = { 'sizeof' }
// | 'sizeof' '(' Type-name ')' # first-set = { 'sizeof' }
//
// Notes:
// 1. unary-operator can be '&', '*', '+', '-', '~', '!'.
// 2. The last two rules are ambiguous: you can't figure out whether the x in sizeof(x) is a typedef of a variable.
// I have a parser hack for this: add a parser environment to track all the typedefs.
// 3. first_set = first_set(postfix-expression) + { '++', '--', '&', '*', '+', '-', '~', '!', 'sizeof' }
// = first_set(primary-expression) + { '++', '--', '&', '*', '+', '-', '~', '!', 'sizeof' }
// = { id, const, string, '++', '--', '&', '*', '+', '-', '~', '!', 'sizeof' }
UnaryExpression.Is(
Either(
PostfixExpression
).Or(
(Increment).Then(UnaryExpression).Then(PreIncrement.Create)
).Or(
(Decrement).Then(UnaryExpression).Then(PreDecrement.Create)
).Or(
(BitwiseAnd).Then(CastExpression).Then(Reference.Create)
).Or(
(Mult).Then(CastExpression).Then(Dereference.Create)
).Or(
(Add).Then(CastExpression).Then(Positive.Create)
).Or(
(Sub).Then(CastExpression).Then(Negative.Create)
).Or(
(BitwiseNot).Then(CastExpression).Then(AST.BitwiseNot.Create)
).Or(
(LogicalNot).Then(CastExpression).Then(AST.LogicalNot.Create)
).Or(
(SizeOf).Then(UnaryExpression).Then(SizeofExpr.Create)
).Or(
(SizeOf).Then(LeftParen).Then(TypeName).Then(RightParen).Then(SizeofType.Create)
)
);
// cast-expression
// : unary-expression # first-set = { id, const, string, '++', '--', '&', '*', '+', '-', '~', '!', 'sizeof' }
// | '(' type_name ')' cast-expression # first-set = '('
CastExpression.Is(
Either(
UnaryExpression
).Or(
(LeftParen).Then(TypeName).Then(RightParen).Then(CastExpression)
.Then(TypeCast.Create)
)
);
// multiplicative-expression
// : cast-expression [ [ '*' | '/' | '%' ] cast-expression ]*
MultiplicativeExpression.Is(
BinaryOperator(
CastExpression,
BinaryOperatorBuilder.Create(Mult, Multiply.Create),
BinaryOperatorBuilder.Create(Div, Divide.Create),
BinaryOperatorBuilder.Create(Mod, Modulo.Create)
)
);
// additive-expression
// : multiplicative-expression [ [ '+' | '-' ] multiplicative-expression ]*
AdditiveExpression.Is(
BinaryOperator(
MultiplicativeExpression,
BinaryOperatorBuilder.Create(Add, AST.Add.Create),
BinaryOperatorBuilder.Create(Sub, AST.Sub.Create)
)
);
// shift-expression
// : additive-expression [ [ '<<' | '>>' ] additive-expression ]*
ShiftExpression.Is(
BinaryOperator(
AdditiveExpression,
BinaryOperatorBuilder.Create(LeftShift, LShift.Create),
BinaryOperatorBuilder.Create(RightShift, RShift.Create)
)
);
// relational-expression
// : shift-expression [ [ '<' | '>' | '<=' | '>=' ] shift-expression ]*
RelationalExpression.Is(
BinaryOperator(
ShiftExpression,
BinaryOperatorBuilder.Create(Less, AST.Less.Create),
BinaryOperatorBuilder.Create(Greater, AST.Greater.Create),
BinaryOperatorBuilder.Create(LessEqual, LEqual.Create),
BinaryOperatorBuilder.Create(GreaterEqual, GEqual.Create)
)
);
// equality-expression
// : relational-expression [ [ '==' | '!=' ] relational-expression ]*
EqualityExpression.Is(
BinaryOperator(
RelationalExpression,
BinaryOperatorBuilder.Create(Equal, AST.Equal.Create),
BinaryOperatorBuilder.Create(NotEqual, AST.NotEqual.Create)
)
);
// and-expression
// : equality-expression [ '&' equality-expression ]*
AndExpression.Is(
BinaryOperator(
EqualityExpression,
BinaryOperatorBuilder.Create(BitwiseAnd, AST.BitwiseAnd.Create)
)
);
// exclusive-or-expression
// : and-expression [ '^' and-expression ]*
ExclusiveOrExpression.Is(
BinaryOperator(
AndExpression,
BinaryOperatorBuilder.Create(Xor, AST.Xor.Create)
)
);
// inclusive-or-expression
// : exclusive-or-expression [ '|' exclusive-or-expression ]*
InclusiveOrExpression.Is(
BinaryOperator(
ExclusiveOrExpression,
BinaryOperatorBuilder.Create(BitwiseOr, AST.BitwiseOr.Create)
)
);
// logical-and-expression
// : inclusive-or-expression [ '&&' inclusive-or-expression ]*
LogicalAndExpression.Is(
BinaryOperator(
InclusiveOrExpression,
BinaryOperatorBuilder.Create(LogicalAnd, AST.LogicalAnd.Create)
)
);
// logical-or-expression
// :logical-and-expression [ '||' logical-and-expression ]*
LogicalOrExpression.Is(
BinaryOperator(
LogicalAndExpression,
BinaryOperatorBuilder.Create(LogicalOr, AST.LogicalOr.Create)
)
);
}
public override void Visit(LogicalAndExpression node)
{
VisitNode(node.Implementation);
}
public virtual void Visit(LogicalAndExpression node)
{
Visit((PolyadicOperatorExpression)node);
}
BinaryExpressionSyntax(LogicalAndExpression) logicalAnd => CombineLogicalAndOperands(logicalAnd, model),
CasePatternSwitchLabelSyntax {
WhenClause : { } whenClause
public override void Visit(LogicalAndExpression node)
{
UpdateType(node, TypeCalculator.GetType(node));
}
