public bool EqualBoolean(EqualExpression node, List <object> parameters)
{
ExpressionNode lhs = node.Children[0];
ExpressionNode rhs = node.Children[1];
return(IsEqual(lhs, rhs, node.Type, parameters));
}
public void EqualIntegerReal()
{
EqualExpression expr = new EqualExpression(new ConstantExpression(1), new ConstantExpression(1.0));
Assert.AreEqual(true, expr.Evaluate(null));
Assert.AreSame(TypeInfo.Boolean, expr.TypeInfo);
}
public void EqualBoolean_Element_CheckParametersPassedDown()
{
var lhs = Utilities.GetBoolLitExpression();
var rhs = Utilities.GetBoolLitExpression();
List <object> parameters = Utilities.GetParameterList(4);
List <object> expectedParams = parameters;
var expression = new EqualExpression(lhs, rhs, 0, 0);
expression.Type = TypeEnum.Element;
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
List <object> lhsParams = new List <object>();
List <object> rhsParams = new List <object>();
Element testElement = new Element(17);
parent.DispatchElement(lhs, Arg.Do <List <object> >(x => lhsParams = x)).Returns(testElement);
parent.DispatchElement(rhs, Arg.Do <List <object> >(x => rhsParams = x)).Returns(testElement);
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
booleanHelper.EqualBoolean(expression, parameters);
Assert.AreEqual(expectedParams, lhsParams);
Assert.AreEqual(expectedParams, rhsParams);
}
private IExpression ParseBinaryExpression(int level)
{
if (level >= binaryoperators.Length)
{
return(this.ParseTerm());
}
IExpression expr = this.ParseBinaryExpression(level + 1);
if (expr == null)
{
return(null);
}
Token token;
for (token = this.lexer.NextToken(); token != null && this.IsBinaryOperator(level, token); token = this.lexer.NextToken())
{
if (token.Value == "=:=")
{
expr = new StrictEqualExpression(expr, this.ParseBinaryExpression(level + 1));
}
else if (token.Value == "==")
{
expr = new EqualExpression(expr, this.ParseBinaryExpression(level + 1));
}
else if (token.Value == "+")
{
expr = new AddExpression(expr, this.ParseBinaryExpression(level + 1));
}
else if (token.Value == "-")
{
expr = new SubtractExpression(expr, this.ParseBinaryExpression(level + 1));
}
else if (token.Value == "*")
{
expr = new MultiplyExpression(expr, this.ParseBinaryExpression(level + 1));
}
else if (token.Value == "/")
{
expr = new DivideExpression(expr, this.ParseBinaryExpression(level + 1));
}
else if (token.Value == "div")
{
expr = new DivExpression(expr, this.ParseBinaryExpression(level + 1));
}
else if (token.Value == "rem")
{
expr = new RemExpression(expr, this.ParseBinaryExpression(level + 1));
}
}
if (token != null)
{
this.lexer.PushToken(token);
}
return(expr);
}
public void EqualExpression()
{
var e = new EqualExpression(new Literal("13"), new Literal("37"));
Assert.IsFalse(e.IsTrivial);
Assert.AreEqual("(13==37)", e.ToString());
Assert.AreEqual("Equal", e.Name);
}
public Justification(EqualExpression expression, RuleApplication ra)
{
m_expr = expression;
var list = new List <RuleApplication>(1);
list.Add(ra);
m_ras = new ReadOnlyCollection <RuleApplication>(list);
}
public Justification(EqualExpression expression, IEnumerable <RuleApplication> ras)
{
m_expr = expression;
var list = new List <RuleApplication>(ras);
list.TrimExcess();
m_ras = new ReadOnlyCollection <RuleApplication>(list);
}
/// <summary>
/// 產生EqualExpression
/// </summary>
/// <returns>EqualExpression</returns>
public EqualExpression CreateEqualExpression()
{
decimal.TryParse(NumberStr, out decimal number);
var equalExpression = new EqualExpression(number: number, leftBracket: LeftBracket, rightBracket: RightBracket, unaryList: UnaryList);
InitThis();
return(equalExpression);
}
ISemantic E(EqualExpression x, ISemantic lValue = null, ISemantic rValue = null)
{
var l = TryGetValue(lValue ?? E(x.LeftOperand));
var r = TryGetValue(rValue ?? E(x.RightOperand));
var isEq = SymbolValueComparer.IsEqual(l, r);
return(new PrimitiveValue(x.OperatorToken == DTokens.Equal ? isEq : !isEq, x));
}
public void TestRightNull()
{
var expression = new EqualExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)false),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)null),
ExpressiveOptions.None);
Assert.AreEqual(false, expression.Evaluate(null));
}
public void TestIntFloatEqual()
{
var expression = new EqualExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)1),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)1.00),
ExpressiveOptions.None);
Assert.AreEqual(true, expression.Evaluate(null));
}
public static void TestEvaluate(object lhs, object rhs, object expectedValue)
{
var expression = new EqualExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == lhs),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == rhs),
new Context(ExpressiveOptions.None));
Assert.That(expression.Evaluate(null), Is.EqualTo(expectedValue));
}
public ISymbolValue Visit(EqualExpression x)
{
var lValue = this.lValue ?? (x.LeftOperand != null ? x.LeftOperand.Accept(this) : null);
var rValue = this.rValue ?? (x.RightOperand != null ? x.RightOperand.Accept(this) : null);
this.lValue = null;
this.rValue = null;
var l = TryGetValue(lValue);
var r = TryGetValue(rValue);
var isEq = SymbolValueComparer.IsEqual(l, r);
return(new PrimitiveValue(x.OperatorToken == DTokens.Equal ? isEq : !isEq, x));
}
public void EqualBoolean_Bool_CorrectValuesReturned(bool lhsValue, bool rhsValue, bool expected)
{
var lhs = Utilities.GetRealLitExpression();
var rhs = Utilities.GetRealLitExpression();
EqualExpression expression = new EqualExpression(lhs, rhs, 0, 0);
expression.Type = TypeEnum.Boolean;
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
parent.DispatchBoolean(lhs, Arg.Any <List <object> >()).Returns(lhsValue);
parent.DispatchBoolean(rhs, Arg.Any <List <object> >()).Returns(rhsValue);
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
bool res = booleanHelper.EqualBoolean(expression, new List <object>());
Assert.AreEqual(expected, res);
}
public override AstNode VisitCompare([NotNull] QlParser.CompareContext context)
{
var op = context.op.Text;
BinaryExpression binExp = null;
var lhs = this.Visit(context.lhs) as Expression;
var rhs = this.Visit(context.rhs) as Expression;
switch (op)
{
case "<":
binExp = new LessThanExpression(lhs, rhs);
break;
case "<=":
binExp = new LessThanOrEqualExpression(lhs, rhs);
break;
case ">":
binExp = new GreaterThanExpression(lhs, rhs);
break;
case ">=":
binExp = new GreaterThanOrEqualExpression(lhs, rhs);
break;
case "==":
binExp = new EqualExpression(lhs, rhs);
break;
case "!=":
binExp = new NotEqualExpression(lhs, rhs);
break;
default:
throw new ArgumentOutOfRangeException(nameof(op), "Unsupported operator.");
}
return(binExp);
}
public void EqualBoolean_Set_CorrectValuesReturned(int leftDataRow, int rightDataRow, bool expected)
{
Set lhsValue = GetSet(leftDataRow);
Set rhsValue = GetSet(rightDataRow);
var lhs = Utilities.GetRealLitExpression();
var rhs = Utilities.GetRealLitExpression();
EqualExpression expression = new EqualExpression(lhs, rhs, 0, 0);
expression.Type = TypeEnum.Set;
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
parent.DispatchSet(lhs, Arg.Any <List <object> >()).Returns(lhsValue);
parent.DispatchSet(rhs, Arg.Any <List <object> >()).Returns(rhsValue);
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
bool res = booleanHelper.EqualBoolean(expression, new List <object>());
Assert.AreEqual(expected, res);
}
ISemantic E(EqualExpression x, ISemantic lValue = null, ISemantic rValue = null)
{
var l = TryGetValue(lValue ?? E(x.LeftOperand));
var r = TryGetValue(rValue ?? E(x.RightOperand));
bool isEq = false;
// If they are integral values or pointers, equality is defined as the bit pattern of the type matches exactly
if (l is PrimitiveValue && r is PrimitiveValue)
{
var pv_l = (PrimitiveValue)l;
var pv_r = (PrimitiveValue)r;
isEq = pv_l.Value == pv_r.Value && pv_l.ImaginaryPart == pv_r.ImaginaryPart;
}
/*
* Furthermore TODO: object comparison, pointer content comparison
*/
return(new PrimitiveValue(x.OperatorToken == DTokens.Equal ? isEq : !isEq, x));
}
public void EqualBoolean_Element_CorrectValuesReturned(int[] a, int[] b, bool expected)
{
Element lhsValue = new Element(a.ToList());
Element rhsValue = new Element(b.ToList());
var lhs = Utilities.GetRealLitExpression();
var rhs = Utilities.GetRealLitExpression();
EqualExpression expression = new EqualExpression(lhs, rhs, 0, 0);
expression.Type = TypeEnum.Element;
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
parent.DispatchElement(lhs, Arg.Any <List <object> >()).Returns(lhsValue);
parent.DispatchElement(rhs, Arg.Any <List <object> >()).Returns(rhsValue);
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
bool res = booleanHelper.EqualBoolean(expression, new List <object>());
Assert.AreEqual(expected, res);
}
/// <summary>
/// 取得運算結果。body可能會有數字(int)、右括號(bool)、單元運算列(List(char))
/// </summary>
/// <param name="userIdForAns">用戶ID</param>
/// <returns>運算結果</returns>
public IHttpActionResult PostAnswer(int userIdForAns)
{
//讀取body
EqualExpression equalexpression = Request.Content.ReadAsAsync <EqualExpression>().Result;
ExpressionController expController = Users.GetExpressionController(userIdForAns);
List <UnaryOperator> unaryList = (equalexpression.UnaryList == null) ?
new List <UnaryOperator>()
: equalexpression.UnaryList.Select(x => Operators.GetUnary(x)).ToList();
decimal?number = equalexpression.Number;
decimal ans = 0;
try
{
switch (equalexpression.Type())
{
case EqualType.NUM_EQUAL:
expController.Add(number.Value, unaryList);
ans = expController.GetResult();
break;
case EqualType.NUM_RB_EQUAL:
expController.Add(number.Value, unaryList);
expController.RightBracket();
ans = expController.GetResult();
break;
default:
throw new Exception("EqualType錯誤");
}
}
catch (Exception)
{
expController.Clear();
return(Ok("fail"));
}
return(Ok(ans));
}
public void NotEqualReals()
{
EqualExpression expr = new EqualExpression(new ConstantExpression(1.3), new ConstantExpression(2.4));
Assert.AreEqual(false, expr.Evaluate(null));
}
public void NotEqualIntegers()
{
EqualExpression expr = new EqualExpression(new ConstantExpression(1), new ConstantExpression(2));
Assert.AreEqual(false, expr.Evaluate(null));
}
public ISymbolValue Visit(EqualExpression x)
{
var lValue = this.lValue ?? (x.LeftOperand != null ? x.LeftOperand.Accept(this) : null);
var rValue = this.rValue ?? (x.RightOperand != null ? x.RightOperand.Accept(this) : null);
this.lValue = null;
this.rValue = null;
var l = TryGetValue(lValue);
var r = TryGetValue(rValue);
var isEq = SymbolValueComparer.IsEqual(l, r);
return new PrimitiveValue(x.OperatorToken == DTokens.Equal ? isEq : !isEq);
}
private bool ParseRelationalOperatorIfExists(Lexer lexer, Token token, Attributes attributes)
{
var successfullyParsed = true;
successfullyParsed &= ParseAdditionOrSubstractionIfExists(lexer, token, attributes);
if (lexer.GetCurrentToken().Is(TokenType.EqualOperator) ||
lexer.GetCurrentToken().Is(TokenType.GreaterThanOperator) ||
lexer.GetCurrentToken().Is(TokenType.GreaterThanOrEqualOperator) ||
lexer.GetCurrentToken().Is(TokenType.LessThanOperator) ||
lexer.GetCurrentToken().Is(TokenType.LessThanOrEqualOperator) ||
lexer.GetCurrentToken().Is(TokenType.DistinctOperator))
{
BinaryExpression tree;
if (lexer.GetCurrentToken().Is(TokenType.EqualOperator))
{
tree = new EqualExpression();
}
else if (lexer.GetCurrentToken().Is(TokenType.GreaterThanOperator))
{
tree = new GreaterThanExpression();
}
else if (lexer.GetCurrentToken().Is(TokenType.GreaterThanOrEqualOperator))
{
tree = new GreaterThanOrEqualExpression();
}
else if (lexer.GetCurrentToken().Is(TokenType.LessThanOperator))
{
tree = new LessThanExpression();
}
else if (lexer.GetCurrentToken().Is(TokenType.LessThanOrEqualOperator))
{
tree = new LessThanOrEqualExpression();
}
else
{
tree = new DistinctExpression();
}
tree.LeftOperand = attributes["EXP"] as Expression;
successfullyParsed &= ParseAdditionOrSubstractionIfExists(lexer, lexer.GetNextToken(), attributes);
tree.RightOperand = attributes["EXP"] as Expression;
// SEM: Sólo pueden compararse expresiones del mismo tipo
if (tree.LeftOperand.Type != tree.RightOperand.Type)
{
LogTypeMismatch(lexer.GetCurrentToken(), tree.LeftOperand.Type, tree.RightOperand.Type);
successfullyParsed = false;
}
// SEM: Las comparaciones de tipo >, >=, <, <= sólo pueden realizarse entre enteros
else if (!lexer.GetCurrentToken().Is(TokenType.EqualOperator) &&
!lexer.GetCurrentToken().Is(TokenType.DistinctOperator) && tree.LeftOperand.Type != DataType.Integer)
{
LogTypeExpressionInvalid(lexer.GetCurrentToken(), DataType.Integer, tree.LeftOperand.Type);
successfullyParsed = false;
}
attributes["EXP"] = tree;
}
return(successfullyParsed);
}
public void Visit(EqualExpression x)
{
}
IExpression ParseAsmEqualExpression(IBlockNode Scope, IStatement Parent)
{
var left = ParseAsmRelExpression(Scope, Parent);
while (laKind == Equal || laKind == NotEqual)
{
Step();
var e = new EqualExpression(t.Kind == NotEqual);
e.LeftOperand = left;
e.RightOperand = ParseAsmRelExpression(Scope, Parent);
left = e;
}
return left;
}
IExpression CmpExpression(IBlockNode Scope = null)
{
// TODO: Make this into a switch.
var left = ShiftExpression(Scope);
OperatorBasedExpression ae = null;
// Equality Expressions
if (laKind == Equal || laKind == NotEqual)
ae = new EqualExpression(laKind == NotEqual);
// Relational Expressions
else if (IsRelationalOperator(laKind))
ae = new RelExpression(laKind);
// Identity Expressions
else if (laKind == Is || (laKind == Not && Peek(1).Kind == Is))
ae = new IdentityExpression(laKind == Not);
// In Expressions
else if (laKind == In || (laKind == Not && Peek(1).Kind == In))
ae = new InExpression(laKind == Not);
else return left;
// Skip possible !-Token
if (laKind == Not)
Step();
// Skip operator
Step();
ae.LeftOperand = left;
ae.RightOperand = ShiftExpression(Scope);
return ae;
}
IExpression CmpExpression(IBlockNode Scope = null)
{
// TODO: Make this into a switch.
var left = ShiftExpression(Scope);
OperatorBasedExpression ae;
switch (laKind) {
case DTokens.Equal:
case DTokens.NotEqual:
ae = new EqualExpression (laKind == NotEqual);
break;
case DTokens.LessThan:
case DTokens.LessEqual:
case DTokens.GreaterThan:
case DTokens.GreaterEqual:
case DTokens.Unordered:
case DTokens.LessOrGreater:
case DTokens.LessEqualOrGreater:
case DTokens.UnorderedOrGreater:
case DTokens.UnorderedGreaterOrEqual:
case DTokens.UnorderedOrLess:
case DTokens.UnorderedLessOrEqual:
case DTokens.UnorderedOrEqual:
ae = new RelExpression (laKind);
break;
case DTokens.Is:
ae = new IdentityExpression (false);
break;
case DTokens.In:
ae = new InExpression (false);
break;
case Not:
switch (Peek (1).Kind) {
case DTokens.Is:
ae = new IdentityExpression (false);
Step ();
break;
case DTokens.In:
ae = new InExpression (true);
Step ();
break;
default:
return left;
}
break;
default:
return left;
}
// Skip operator
Step();
ae.LeftOperand = left;
ae.RightOperand = ShiftExpression(Scope);
return ae;
}
ISemantic E(EqualExpression x, ISemantic lValue =null, ISemantic rValue = null)
{
var l = TryGetValue(lValue ?? E(x.LeftOperand));
var r = TryGetValue(rValue ?? E(x.RightOperand));
bool isEq = false;
// If they are integral values or pointers, equality is defined as the bit pattern of the type matches exactly
if (l is PrimitiveValue && r is PrimitiveValue)
{
var pv_l = (PrimitiveValue)l;
var pv_r = (PrimitiveValue)r;
isEq = pv_l.Value == pv_r.Value && pv_l.ImaginaryPart == pv_r.ImaginaryPart;
}
/*
* Furthermore TODO: object comparison, pointer content comparison
*/
return new PrimitiveValue(x.OperatorToken == DTokens.Equal ? isEq : !isEq, x);
}
/// <summary>
/// Converts the parts of an expression into a FastDAO IExpression.
/// Supported operators: gt, lt, ge, le, eq
/// </summary>
/// <param name="expressionParts">IDictionary with the following keys:
/// "a" for the Attribute name
/// "o" for the Operator
/// "v" for the Value</param>
/// <returns>A FastDAO IExpression</returns>
private static IExpression DictionaryToExpression(IDictionary <string, object> expressionParts)
{
if (expressionParts == null)
{
throw new ArgumentNullException("expressionParts", "Cannot convert null to SQL expression");
}
if (!expressionParts.ContainsKey(ATTRIBUTE_KEY))
{
throw new ArgumentException("Missing the [" + ATTRIBUTE_KEY + "] key from the expression parts. Cannot convert to SQL expression", "expressionParts");
}
if (!expressionParts.ContainsKey(OPERATOR_KEY))
{
throw new ArgumentException("Missing the [" + OPERATOR_KEY + "] key from the expression parts. Cannot convert to SQL expression", "expressionParts");
}
if (!expressionParts.ContainsKey(VALUE_KEY))
{
throw new ArgumentException("Missing the [" + VALUE_KEY + "] key from the expression parts. Cannot convert to SQL expression", "expressionParts");
}
IExpression retVal;
string attr = (string)expressionParts[ATTRIBUTE_KEY];
string oper = (string)expressionParts[OPERATOR_KEY];
object val = expressionParts[VALUE_KEY];
// Supported Operator Values: gt, lt, ge, le, eq, lk
switch (oper)
{
case "eq":
if (val is IList)
{
retVal = new PropertyInListExpression(attr, (IEnumerable)val);
}
else
{
retVal = new EqualExpression(attr, val);
}
break;
case "gt":
retVal = new GreaterExpression(attr, val);
break;
case "lt":
retVal = new LesserExpression(attr, val);
break;
case "ge":
retVal = new LesserExpression(attr, val, false);
break;
case "le":
retVal = new GreaterExpression(attr, val, false);
break;
case "lk":
retVal = new LikeExpression(attr, "%" + val + "%");
break;
default:
throw new ArgumentException("Cannot convert unsupported operator to SQL expression: " + oper);
}
return(retVal);
}
public void NotEqualStrings()
{
EqualExpression expr = new EqualExpression(new ConstantExpression("foo"), new ConstantExpression("bar"));
Assert.AreEqual(false, expr.Evaluate(null));
}
public virtual T VisitEqualExpression(EqualExpression equalExpression)
{
throw new NotImplementedException();
}
public Justification(EqualExpression expression)
{
m_expr = expression;
m_ras = s_empty;
}
public AbstractType Visit(EqualExpression x)
{
return(new PrimitiveType(DTokens.Bool));
}
IExpression CmpExpression(IBlockNode Scope = null)
{
var left = ShiftExpression(Scope);
OperatorBasedExpression ae = null;
// Equality Expressions
if (laKind == Equal || laKind == NotEqual)
ae = new EqualExpression(laKind == NotEqual);
// Relational Expressions
else if (RelationalOperators[laKind])
ae = new RelExpression(laKind);
// Identity Expressions
else if (laKind == Is || (laKind == Not && Peek(1).Kind == Is))
ae = new IdendityExpression(laKind == Not);
// In Expressions
else if (laKind == In || (laKind == Not && Peek(1).Kind == In))
ae = new InExpression(laKind == Not);
else return left;
LastParsedObject = ae;
// Skip possible !-Token
if (laKind == Not)
Step();
// Skip operator
Step();
ae.LeftOperand = left;
ae.RightOperand = ShiftExpression(Scope);
return ae;
}
public void Visit(EqualExpression x)
{
}
public void CompareRealOneWithIntegerOne()
{
EqualExpression expr = new EqualExpression(new ConstantExpression(1.0), new ConstantExpression(1));
Assert.AreEqual(true, expr.Evaluate(null));
}
public virtual TResult Visit(EqualExpression expression, TEnvironment environment)
{
return(this.Visit((BinaryExpression)expression, environment));
}
ISemantic E(EqualExpression x, ISemantic lValue =null, ISemantic rValue = null)
{
var l = TryGetValue(lValue ?? E(x.LeftOperand));
var r = TryGetValue(rValue ?? E(x.RightOperand));
var isEq = SymbolValueComparer.IsEqual(l, r);
return new PrimitiveValue(x.OperatorToken == DTokens.Equal ? isEq : !isEq, x);
}
