public override IExpressionNode VisitLogicalExpression([NotNull] QLanguageParser.LogicalExpressionContext context)
{
var logicalEntityContext = context.logicalEntity();
if (logicalEntityContext != null)
{
return(VisitLogicalEntity(logicalEntityContext));
}
var logicalExpressionContext = context.logicalExpression();
if (logicalExpressionContext != null && logicalExpressionContext.Length == 1)
{
return(VisitLogicalExpression(logicalExpressionContext[0]));
}
var comparisonExpressionContext = context.comparisonExpression();
if (comparisonExpressionContext != null)
{
return(new ComparisonExpressionVisitor().VisitComparisonExpression(comparisonExpressionContext));
}
var left = VisitLogicalExpression(context.LEFT);
var opr = LogicalExpressionNode.ParseLogicalOperator(context.OPR.Text);
var right = VisitLogicalExpression(context.RIGHT);
return(new LogicalExpressionNode(Location.FromContext(context), left, opr, right));;
}
private StatementType Analyze(LogicalExpressionNode node)
{
StatementType left = AnalyseExpression(node.Left);
StatementType right = AnalyseExpression(node.Right);
return((left == right && left == StatementType.Boolean) ? StatementType.Boolean : StatementType.Unknown);
}
public override IExpressionNode VisitLogicalExpression(LogicalExpressionContext context)
{
if (context == null)
{
throw new ArgumentNullException("Context can't be null");
}
var logicalEntityContext = context.logicalEntity();
if (logicalEntityContext != null)
{
return(VisitLogicalEntity(logicalEntityContext));
}
var logicalExpressionContext = context.logicalExpression();
if (logicalExpressionContext != null && logicalExpressionContext.Length == 1)
{
return(VisitLogicalExpression(logicalExpressionContext[0]));
}
var comparisonExpressionContext = context.comparisonExpression();
if (comparisonExpressionContext != null)
{
return(new ComparisonExpressionVisitor().VisitComparisonExpression(comparisonExpressionContext));
}
var left = VisitLogicalExpression(context.LEFT);
var opr = LogicalExpressionNode.ParseLogicalOperator(context.OPR.Text);
var right = VisitLogicalExpression(context.RIGHT);
return(new LogicalExpressionNode(Location.FromContext(context), left, opr, right));;
}
private StatementType Analyze(LogicalExpressionNode node)
{
StatementType left = AnalyseExpression(node.Left);
StatementType right = AnalyseExpression(node.Right);
return((left == right && left == StatementType.BOOLEAN) ? StatementType.BOOLEAN : StatementType.UNKNOWN);
}
public void InValidBoolComparisonTest()
{
SymbolTable.Add("TestBool", QValueType.Boolean);
var left = new IdentifierNode(new Location(0, 0), "TestBool");
var right = new LiteralNode(new Location(0, 0), "false", QValueType.Integer);
var comparisonNode = new LogicalExpressionNode(new Location(0, 0), left, LogicalOperator.Or, right);
var analyser = new StatementTypeAnalyser();
var result = analyser.Analyse(comparisonNode);
Assert.IsFalse(result);
}
public override TreeReference Visit(LogicalExpressionNode node, TreeReference state)
{
var loc = node.OperatorToken.Location;
var left = Visit(node.LeftOperand);
var right = Visit(node.RightOperand);
return(node.OperatorToken.Kind switch
{
SyntaxTokenKind.AndKeyword => new TreeLogicalAndNode(_context, loc, left, right),
SyntaxTokenKind.OrKeyword => new TreeLogicalOrNode(_context, loc, left, right),
_ => throw DebugAssert.Unreachable(),
});
private Node and_expr_rest(Node exp)
{
if (Tokenizer.Peek().type == TokenType.KeywordAnd)
{
Tokenizer.Next();
Node right = compare_expr(Tokenizer.Next());
exp = new LogicalExpressionNode(LogicalOperator.And, exp, right);
if (Tokenizer.HasFinished)
{
return(exp);
}
return(and_expr_rest(exp));
}
return(exp);
}
public void InValidComparisonWithArthimetricTest()
{
SymbolTable.Add("TestBool", QValueType.Boolean);
var left = new IdentifierNode(new Location(0, 0), "TestBool");
var five = new LiteralNode(new Location(0, 0), "5", QValueType.Integer);
var ten = new LiteralNode(new Location(0, 0), "blah blah", QValueType.Text);
var right = new ComparisonExpressionNode(new Location(0, 0), five, ComparisonOperator.GreaterEqual, ten);
var comparisonNode = new LogicalExpressionNode(new Location(0, 0), left, LogicalOperator.Or, right);
var analyser = new StatementTypeAnalyser();
var result = analyser.Analyse(comparisonNode);
Assert.IsFalse(result);
}
public void ValidComparisonWithArthimetricTest()
{
SymbolTable.Add("TestBool", QValueType.BOOLEAN);
var left = new IdentifierNode(new Location(0, 0), "TestBool");
var five = new LiteralNode(new Location(0, 0), "5", QValueType.INTEGER);
var ten = new LiteralNode(new Location(0, 0), "10", QValueType.INTEGER);
var right = new ComparisonExpressionNode(new Location(0, 0), five, ComparisonOperator.GE, ten);
var comparisonNode = new LogicalExpressionNode(new Location(0, 0), left, LogicalOperator.OR, right);
var analyser = new StatementTypeAnalyser();
var result = analyser.Analyse(comparisonNode);
Assert.IsTrue(result);
}
private ExpressionValue ParseLogicalNode(LogicalExpressionNode logicalExpressionNode)
{
ExpressionValue leftExpressionValue = ParseExpressionNode(logicalExpressionNode.Left);
ExpressionValue rightExpressionValue = ParseExpressionNode(logicalExpressionNode.Right);
ExpressionOperator expressionOperator = ExpressionOperator.Undefined;
switch (logicalExpressionNode.Operator)
{
case LogicalOperator.And:
expressionOperator = ExpressionOperator.And;
break;
case LogicalOperator.Or:
expressionOperator = ExpressionOperator.Or;
break;
default:
throw new NotImplementedException();
}
return(leftExpressionValue.Combine(rightExpressionValue, expressionOperator));
}
private void processTokenToExpression(LogicalExpressionNode current, Token token)
{
if (LETokenType.Literal == token.Type)
{
current.Children.Add(new LiteralNode {
Literal = token.Value, Negative = token.Negation
});
return;
}
if (LETokenType.Number == token.Type)
{
current.Children.Add(new LiteralNode {
Literal = token.Value, IsNumber = true, Negative = token.Negation
});
return;
}
if (LETokenType.And == token.Type || LETokenType.Block == token.Type)
{
var conj = new ConjunctionNode {
Negative = token.Negation
};
current.Children.Add(conj);
foreach (var child in token.Children)
{
processTokenToExpression(conj, child);
}
return;
}
if (LETokenType.Or == token.Type)
{
var disj = new DisjunctionNode {
Negative = token.Negation
};
current.Children.Add(disj);
foreach (var child in token.Children)
{
processTokenToExpression(disj, child);
}
return;
}
if (0 != (token.Type & LETokenType.Compare))
{
var fst = token.Children[0];
var sec = token.Children[1];
LogicalExpressionNode n;
if (token.Type == LETokenType.Regex)
{
n = new RegexTestNode {
First = fst.Value,
Second = sec.Value,
FirstIsLiteral = fst.Type == LETokenType.Literal,
SecondIsLiteral = sec.Type == LETokenType.Literal
};
}
else if (fst.Type == LETokenType.Number)
{
var eq = new EqualValueNode();
n = eq;
eq.Literal = sec.Value;
eq.Value = fst.Value;
eq.IsNumber = true;
}
else if (sec.Type == LETokenType.Number)
{
var eq = new EqualValueNode();
n = eq;
eq.Literal = fst.Value;
eq.Value = sec.Value;
eq.IsNumber = true;
}
else if (sec.Type == LETokenType.Literal)
{
var eq = new EqualNode();
n = eq;
if (fst.Type == LETokenType.String)
{
var eq2 = new EqualValueNode();
eq2.Literal = sec.Value;
eq2.Value = fst.Value;
n = eq2;
}
else
{
eq.FirstLiteral = fst.Value;
eq.SecondLiteral = sec.Value;
}
}
else
{
var eq = new EqualValueNode();
n = eq;
eq.Literal = fst.Value;
eq.Value = sec.Value;
}
n.Negative = token.Negation;
n.Operation = token.Type;
if (token.Type != LETokenType.Neq && token.Type != LETokenType.Eq)
{
n.IsNumber = true;
}
if (LETokenType.Neq == token.Type)
{
n.Negative = !n.Negative;
}
current.Children.Add(n);
}
}
