public void TestNegativeNumber() { Assert.AreEqual(9, ModularArith.Mod(-1, 10)); Assert.AreEqual(0, ModularArith.Mod(-100, 20)); Assert.AreEqual(5, ModularArith.Mod(-15, 10)); Assert.AreEqual(8, ModularArith.Mod(-12, 10)); }
public Statement SetB(int newB) { return(new Statement(this) { FieldB = new NumberExpression(ModularArith.Mod(newB)) }); }
public int NextLoadAddress(int baseAddress, int length) { var positions = coresize + 1 - (minDistance * 2) - length; var nextLoadAddress = ModularArith.Mod(baseAddress + minDistance + rnd.Next() % positions); return(nextLoadAddress); }
public override int Calculate(Warrior warrior = null, int address = 0) { int answer; switch (Op) { case BinaryOperation.Sum: answer = Left.Calculate(warrior, address) + Right.Calculate(warrior, address); break; case BinaryOperation.Sub: answer = Left.Calculate(warrior, address) - Right.Calculate(warrior, address); break; case BinaryOperation.Mul: answer = Left.Calculate(warrior, address) * Right.Calculate(warrior, address); break; case BinaryOperation.Div: answer = ModularArith.Div(Left.Calculate(warrior, address), Right.Calculate(warrior, address)); break; default: throw new InvalidOperationException("Invalid operation to calculate: " + Op); } return(answer); }
public void TestLabels() { var warrior = parser.Parse("imp " + imp + "\nJMP imp"); Assert.AreEqual(2, warrior.Statements.Count); Assert.AreEqual(typeof(NumberExpression), warrior.Statements[1].FieldA.GetType()); Assert.AreEqual(ModularArith.Mod(-1), warrior.Statements[1].FieldA.Calculate()); }
public override string ToString() { return(String.Format("{0} {1}{2}, {3}{4}", statementFactory.GetStatementMnemonic(Type), (char)ModeA, ModularArith.Mod(FieldA.Calculate()), (char)ModeB, ModularArith.Mod(FieldB.Calculate()))); }
public void TestConstants() { var warrior = parser.Parse("a EQU b\nb EQU c + 10\nc EQU d + 2 * 4\nd EQU link - 1\nlink " + imp); Assert.AreEqual(4, warrior.Constants.Count); Assert.AreEqual(typeof(NumberExpression), warrior.Constants["a"].GetType()); Assert.AreEqual(typeof(NumberExpression), warrior.Constants["b"].GetType()); Assert.AreEqual(typeof(NumberExpression), warrior.Constants["c"].GetType()); Assert.AreEqual(typeof(NumberExpression), warrior.Constants["d"].GetType()); Assert.AreEqual(17, warrior.Constants["a"].Calculate()); Assert.AreEqual(17, warrior.Constants["b"].Calculate()); Assert.AreEqual(7, warrior.Constants["c"].Calculate()); Assert.AreEqual(ModularArith.Mod(-1), warrior.Constants["d"].Calculate()); }
public void EvaluateAllExpressions() { var address = 0; foreach (var constant in Constants.Keys.ToArray()) { EvaluatingConstants.Clear(); ExpandConstant(constant); } foreach (var statement in Statements) { statement.FieldA = statement.FieldA.ExpandConstants(this); statement.FieldB = statement.FieldB.ExpandConstants(this); } foreach (var statement in Statements) { statement.FieldA = new NumberExpression(ModularArith.Mod(statement.FieldA.Calculate(this, address))); statement.FieldB = new NumberExpression(ModularArith.Mod(statement.FieldB.Calculate(this, address))); address++; } if (StartAddressExpression == null) { StartAddress = 0; } else { StartAddressExpression = StartAddressExpression.ExpandConstants(this); if (StartAddressExpression.GetType() == typeof(VariableExpression)) { StartAddress = ModularArith.Mod(Statements.Count + StartAddressExpression.Calculate(this, Statements.Count)); } else if (StartAddressExpression.GetType() == typeof(NumberExpression)) { StartAddress = StartAddressExpression.Calculate(this, Statements.Count); } else { throw new CompilationException("END argument must be label, constant name or number", StartAddressExpression.ToString(), 0); } } }
public void TestPositiveNumbers() { Assert.AreEqual(5, ModularArith.Mod(5, 100)); Assert.AreEqual(5, ModularArith.Mod(105, 100)); Assert.AreEqual(0, ModularArith.Mod(45, 15)); }
public void TestExpressionWithMultipleLabels() { var warrior = parser.Parse(imp + "\nl1 " + imp + "\nl2 " + imp + "\nl3 MOV l1, l1 + l2"); Assert.AreEqual(ModularArith.Mod(-3), warrior.Statements[3].FieldB.Calculate()); }
public int CalculateByMod() { return(ModularArith.Mod(Calculate())); }
public Expression Decremented() { return(new NumberExpression(ModularArith.Mod(Calculate() - 1))); }
public void Eval(string text, int expectedResult) { var expr = parser.Parse(text); Assert.AreEqual(ModularArith.Mod(expectedResult), ModularArith.Mod(expr.Calculate())); }