public void Visit(DivisionOperator op)
{
op.LeftOperand.Accept(this);
_resultBuilder.Append(" ");
op.RightOperand.Accept(this);
_resultBuilder.Append("/");
}
public void TestPrintIncompleteDivide()
{
BinaryOperator multiplyOperation = new DivisionOperator();
multiplyOperation.SetFirstOperand(new Value(1));
Assert.AreEqual("1 ÷ ".Replace(" ", ""), multiplyOperation.ToString().Replace(" ", ""));
}
public void Visit(DivisionOperator op)
{
var leftArgs = VisitChild(op.Left);
var rightArgs = VisitChild(op.Rigth);
_codeStack.Peek().Scope = rightArgs.Scope;
_codeStack.Peek().CodeExpression = new CodeBinaryOperatorExpression(leftArgs.CodeExpression, CodeBinaryOperatorType.Divide, rightArgs.CodeExpression);
}
public void TestDivision()
{
var op = new DivisionOperator();
var result = op.Apply(1, 2);
Assert.AreEqual(0.5, result);
}
public void Visit(DivisionOperator op)
{
op.LeftOperand.Accept(this);
op.RightOperand.Accept(this);
var temp = _stack.Pop();
_stack.Push(_stack.Pop() / temp);
}
public void TestPrintDivisionExpression()
{
BinaryOperator divisionOperation = new DivisionOperator();
divisionOperation.SetFirstOperand(new Value(2.9M));
divisionOperation.SetSecondOperand(new Value(3));
Assert.AreEqual("2.9 ÷ 3".Replace(" ", ""), divisionOperation.ToString().Replace(" ", ""));
}
public void TestDivision()
{
BinaryOperator divisionExpression = new DivisionOperator();
divisionExpression.SetFirstOperand(new Value(2.2M));
divisionExpression.SetSecondOperand(new Value(1.1M));
Assert.AreEqual(2M, divisionExpression.Evaluate());
}
public void Visit(DivisionOperator node)
{
VisitBinary(node);
ITerminalWrapper leftWrapper = ReferenceTables.GetValue(node.Left);
ITerminalWrapper rightWrapper = ReferenceTables.GetValue(node.Right);
ReferenceTables.SetValue(node, ((dynamic)leftWrapper) / ((dynamic)rightWrapper));
}
public void Visit(DivisionOperator op)
{
op.LeftOperand.Accept(this);
op.RightOperand.Accept(this);
var temp = _stack.Pop();
_stack.Push(_stack.Pop() / temp);
}
public void WhenDivisionOperatorSetValues_OutputShouldBeCorrect()
{
DivisionOperator addition = new DivisionOperator();
addition.Push(new Value(10m, "TEST"));
addition.Push(new Value(5.5m, "TEST"));
Assert.AreEqual(10m / 5.5m, addition.GetValue());
}
void ShouldReturnQuotientOfTwoExpressions()
{
var expression1 = Create <NumberLiteral>();
var expression2 = Create <NumberLiteral>();
var expectedResult = expression1.Result / expression2.Result;
var addition = new DivisionOperator(expression1, expression2);
addition.Result.Should().Be(expectedResult);
}
public void DivisionOperatorDivides()
{
//------------Arrange--------------------
var op = new DivisionOperator();
//------------Act------------------------
var result = op.Eval(2.0, 1.5);
//------------Assert---------------------
Assert.AreEqual(4.0 / 3.0, result);
}
private void CreateChild(ref AbstractTreeElement node, string expression, ref int curNumber)
{
if (curNumber >= expression.Length)
return;
while (expression[curNumber] == ' ' || expression[curNumber] == ')')
++curNumber;
if (expression[curNumber] == '(')
{
Operator newOpertator;
switch (expression[curNumber + 1])
{
case '+':
newOpertator = new PlusOperator();
break;
case '-':
newOpertator = new MinusOperator();
break;
case '*':
newOpertator = new MultiplicationOperator();
break;
case '/':
newOpertator = new DivisionOperator();
break;
default:
throw new System.Exception();
}
curNumber += 2;
var newNode = newOpertator.LeftChild;
CreateChild(ref newNode, expression, ref curNumber);
newOpertator.LeftChild = newNode;
if (expression[curNumber] == ')')
{
++curNumber;
}
newNode = newOpertator.RightChild;
CreateChild(ref newNode, expression, ref curNumber);
newOpertator.RightChild = newNode;
node = newOpertator;
}
else
{
Operand newOperand = new Operand();
newOperand.Element = 0;
while (expression[curNumber] != ' ')
{
if (expression[curNumber] == ')')
break;
newOperand.Element = newOperand.Element * 10 + (expression[curNumber] - '0');
++curNumber;
}
node = newOperand;
}
}
public void TestOperatorMismatchInequality()
{
BinaryOperator addOperation = new AddOperator();
addOperation.SetFirstOperand((Value)5);
addOperation.SetSecondOperand((Value)6);
BinaryOperator divideOperation = new DivisionOperator();
divideOperation.SetFirstOperand((Value)5);
divideOperation.SetSecondOperand((Value)6);
Assert.AreNotEqual(addOperation, divideOperation);
}
public void WhenDivisionOperatorSetOneValueOneOperator_OutputShouldBeCorrect()
{
DivisionOperator operatorValue = new DivisionOperator();
//2
operatorValue.Push(new Value(10m, "TEST"));
operatorValue.Push(new Value(5m, "TEST"));
DivisionOperator output = new DivisionOperator();
output.Push(operatorValue);
output.Push(new Value(4m, "TEST"));
Assert.AreEqual(.5m, output.GetValue());
}
public void TestPrecedence()
{
var addition = new AdditionOperator();
var subtraction = new SubtractionOperator();
var multiplication = new MultiplicationOperator();
var division = new DivisionOperator();
var negation = new NegationOperator();
Assert.IsTrue(addition.Precedence < multiplication.Precedence);
Assert.IsTrue(addition.Precedence < division.Precedence);
Assert.IsTrue(subtraction.Precedence < multiplication.Precedence);
Assert.IsTrue(subtraction.Precedence < division.Precedence);
Assert.IsTrue(multiplication.Precedence < negation.Precedence);
Assert.IsTrue(division.Precedence < negation.Precedence);
}
public void WhenDivisionOperatorSetTwoOperators_OutputShouldBeCorrect()
{
DivisionOperator operator1 = new DivisionOperator();
operator1.Push(new Value(500m, "TEST"));
operator1.Push(new Value(5m, "TEST"));
DivisionOperator operator2 = new DivisionOperator();
operator2.Push(new Value(40m, "TEST"));
operator2.Push(new Value(4m, "TEST"));
DivisionOperator output = new DivisionOperator();
output.Push(operator1);
output.Push(operator2);
Assert.AreEqual(10m, output.GetValue());
}
//I dunno how to name this one, deal with it
public void WhenDivisionOperatorSetWithOperatorSourcedOperators_OutputShouldBeCorrect()
{
DivisionOperator level1a_1 = new DivisionOperator();
DivisionOperator level1a_2 = new DivisionOperator();
//-8
level1a_1.Push(new Value(16m, "TEST"));
level1a_1.Push(new Value(-2m, "TEST"));
//2
level1a_2.Push(new Value(22m, "TEST"));
level1a_2.Push(new Value(11m, "TEST"));
DivisionOperator level1b_1 = new DivisionOperator();
DivisionOperator level1b_2 = new DivisionOperator();
//16
level1b_1.Push(new Value(8m, "TEST"));
level1b_1.Push(new Value(-.5m, "TEST"));
//-4
level1b_2.Push(new Value(16m, "TEST"));
level1b_2.Push(new Value(4m, "TEST"));
DivisionOperator level2a = new DivisionOperator();
DivisionOperator level2b = new DivisionOperator();
//-4
level2a.Push(level1a_1);
level2a.Push(level1a_2);
//4
level2b.Push(level1b_1);
level2b.Push(level1b_2);
DivisionOperator level3 = new DivisionOperator();
level3.Push(level2a);
level3.Push(level2b);
Assert.AreEqual(1, level3.GetValue());
}
public void Visit(DivisionOperator node)
{
}
public virtual void Visit(DivisionOperator binaryOperator)
{
Visit(binaryOperator.Left);
Visit(binaryOperator.Right);
}
public void Visit(DivisionOperator op)
{
Visit((BinaryOperator)op);
}
public void Visit(DivisionOperator node)
{
VisitBinary(node);
CheckOperandsAreOfSameType(node);
}
public void Visit(DivisionOperator op)
{
List<Type> parenthesisOperators = new List<Type> { typeof(DivisionOperator) };
FormatBinaryOperator(op, ParenthesisNeeded(parenthesisOperators));
}
public override void Visit(DivisionOperator binaryOperator)
{
WriteBinaryExpression(binaryOperator, "/");
}
private void CreateChild(ref AbstractTreeElement node, string expression, ref int curNumber)
{
if (curNumber >= expression.Length)
{
return;
}
while (expression[curNumber] == ' ' || expression[curNumber] == ')')
{
++curNumber;
}
if (expression[curNumber] == '(')
{
Operator newOpertator;
switch (expression[curNumber + 1])
{
case '+':
newOpertator = new PlusOperator();
break;
case '-':
newOpertator = new MinusOperator();
break;
case '*':
newOpertator = new MultiplicationOperator();
break;
case '/':
newOpertator = new DivisionOperator();
break;
default:
throw new System.Exception();
}
curNumber += 2;
var newNode = newOpertator.LeftChild;
CreateChild(ref newNode, expression, ref curNumber);
newOpertator.LeftChild = newNode;
if (expression[curNumber] == ')')
{
++curNumber;
}
newNode = newOpertator.RightChild;
CreateChild(ref newNode, expression, ref curNumber);
newOpertator.RightChild = newNode;
node = newOpertator;
}
else
{
Operand newOperand = new Operand();
newOperand.Element = 0;
while (expression[curNumber] != ' ')
{
if (expression[curNumber] == ')')
{
break;
}
newOperand.Element = newOperand.Element * 10 + (expression[curNumber] - '0');
++curNumber;
}
node = newOperand;
}
}
public override void Visit(DivisionOperator binaryOperator)
{
Visit(binaryOperator.Left);
Write(" / ");
Visit(binaryOperator.Right);
}
public void Visit(DivisionOperator op, CommonTree tree)
{
Parent(tree).Children.Add(op);
VisitChildren(tree);
}
private static ExpTreeNode GetAsExpressionTree(this ParseTreeNode parsedNode, ExpTreeNode parentExpNode)
{
//The current node is a variable / value token. Create a value node and return it back
if (!parsedNode.ChildNodes.Any())
{
switch (parsedNode.Term.Name)
{
case "variable":
{
var varName = parsedNode.FindTokenAndGetValue <string>();
return(new VariableValue(varName, parentExpNode));
}
case "boolean":
return(new LiteralValue(parsedNode.FindTokenAndGetValue <bool>(), parentExpNode));
case "integer":
case "decimal":
return(new LiteralValue(parsedNode.FindTokenAndGetValue <double>(), parentExpNode));
case "SingleQuoteString":
case "DoubleQuoteString":
return(new LiteralValue(parsedNode.FindTokenAndGetValue <string>(), parentExpNode));
default:
throw parsedNode.GetException($"Invalid token type '{parsedNode.Term.Name}' in expression");
}
}
// Look on the next node down
else if (parsedNode.ChildNodes.Count == 1)
{
return(GetAsExpressionTree(parsedNode.ChildNodes[0], parentExpNode));
}
//Ignore parenthesis, the middle non-terminal is what we want
// Look on the next node down
else if (parsedNode.ChildNodes.Count == 3 && parsedNode.ChildNodes[0]?.Token?.Text == "(")
{
return(GetAsExpressionTree(parsedNode.ChildNodes[1], parentExpNode));
}
//Binary operator
else if (parsedNode.ChildNodes.Count == 3)
{
BinaryOperatorBase binaryOp;
var opStr = parsedNode.ChildNodes[1].FindToken().ValueString;
switch (opStr)
{
// Math
case "+":
binaryOp = new AdditionOperator(parentExpNode);
break;
case "-":
binaryOp = new SubtractionOperator(parentExpNode);
break;
case "*":
binaryOp = new MultiplacationOperator(parentExpNode);
break;
case "/":
binaryOp = new DivisionOperator(parentExpNode);
break;
case "%":
binaryOp = new ModulusOperator(parentExpNode);
break;
case "^":
binaryOp = new PowerOperator(parentExpNode);
break;
// Bool
case "~==":
binaryOp = new LooseEqualsOperator(parentExpNode);
break;
case "~!=":
binaryOp = new LooseNotEqualsOperator(parentExpNode);
break;
case "==":
binaryOp = new EqualsOperator(parentExpNode);
break;
case "!=":
binaryOp = new NotEqualsOperator(parentExpNode);
break;
case "like":
binaryOp = new LikeOperator(parentExpNode);
break;
case "match":
binaryOp = new MatchOperator(parentExpNode);
break;
case ">":
binaryOp = new GreaterThanOperator(parentExpNode);
break;
case ">=":
binaryOp = new GreaterThanOrEqualOperator(parentExpNode);
break;
case "<":
binaryOp = new LessThanOperator(parentExpNode);
break;
case "<=":
binaryOp = new LessThanOrEqualOperator(parentExpNode);
break;
case "&&":
binaryOp = new AndOperator(parentExpNode);
break;
case "||":
binaryOp = new OrOperator(parentExpNode);
break;
default:
throw parsedNode.ChildNodes[1].GetException($"Unrecognized operator '{opStr}'");
}
binaryOp.LeftOperand = GetAsExpressionTree(parsedNode.ChildNodes[0], binaryOp);
binaryOp.RightOperand = GetAsExpressionTree(parsedNode.ChildNodes[2], binaryOp);
//Optimize
if (binaryOp.LeftOperand is LiteralValue && binaryOp.RightOperand is LiteralValue)
{
return(new LiteralValue(binaryOp.Eval(), parentExpNode));
}
return(binaryOp);
}
// Unary operator
else if (parsedNode.ChildNodes.Count == 2)
{
var opVal = parsedNode.ChildNodes[0].FindToken().Value;
UnaryOperatorBase unaryOp;
if (parsedNode.ChildNodes[0].FindToken().Value is TypeCode convertType)
{
unaryOp = new TypeConversionOperator(convertType, parentExpNode);
}
else
{
var opStr = opVal.ToString();
switch (opStr)
{
case "!":
unaryOp = new NotOperator(parentExpNode);
break;
//Property Checking
case "lengthof":
unaryOp = new LengthOperator(parentExpNode);
break;
case "typeof":
unaryOp = new TypeOperator(parentExpNode);
break;
default:
unaryOp = new GenericUnaryMathFunctionOperator(opStr, parentExpNode);
break;
}
}
unaryOp.Operand = GetAsExpressionTree(parsedNode.ChildNodes[1], unaryOp);
//Optimize
if (unaryOp.Operand is LiteralValue)
{
return(new LiteralValue(unaryOp.Eval(), parentExpNode));
}
return(unaryOp);
}
else
{
throw parsedNode.GetException($"Invalid number of tokens ({parsedNode.ChildNodes.Count})");
}
}
public MulDivOp(DivisionOperator divOp)
{
_divOp = divOp;
}
