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()));
}
