public void ValueShouldCarry(int aValue, int bValue, bool sub)
{
var bus = new Mock <IBus>();
var controlUnit = new Mock <IControlUnit>();
var aReg = new Mock <IRegister>();
var bReg = new Mock <IRegister>();
aReg.SetupGet(x => x.Value).Returns((byte)aValue);
bReg.SetupGet(x => x.Value).Returns((byte)bValue);
ControlLine subtractLine = new ControlLine(ControlLineId.SUBTRACT);
ControlLine busOutputLine = new ControlLine(ControlLineId.SUM_OUT);
controlUnit.Setup(x => x.GetControlLine(ControlLineId.SUBTRACT)).Returns(subtractLine);
controlUnit.Setup(x => x.GetControlLine(ControlLineId.SUM_OUT)).Returns(busOutputLine);
// Are we adding or subtracting?
subtractLine.State = sub;
var alu = new Alu(bus.Object, controlUnit.Object, aReg.Object, bReg.Object);
// Carry will return the carried value not the intended value
if (sub)
{
Assert.NotEqual(aValue - bValue, alu.Value);
}
else
{
Assert.NotEqual(aValue + bValue, alu.Value);
}
Assert.True(alu.Carry);
}
public override string First(string input)
{
var alu = new Alu(input);
alu.ExecuteProgram(haltOnReceive: true);
return(alu.GetRegValue(_RECEIVE).ToString());
}
public void Execute(Alu alu)
{
this.Switch(copy => copy.ExecuteCopy(alu),
op => op.ExecuteOp(alu),
jgz => jgz.ExecuteJump(alu),
jnz => jnz.ExecuteJump(alu));
}
// Use this for initialization
public void carga(string registro)
{
ram = gameObject.GetComponent <Ram>();
alu = gameObject.GetComponent <Alu>();
rutina = indexa(registro);
StartCoroutine(rutina);
}
protected override void OnLastCycleLastM()
{
base.OnLastCycleLastM();
var value = _inputPart.Data.Value;
Registers.Flags.S = Alu.IsNegative(value);
Registers.Flags.Z = Alu.IsZero(value);
Registers.Flags.H = false;
Registers.Flags.PV = Alu.IsParityEven(value);
Registers.Flags.N = false;
if (IsIndirect)
{
Registers.A = value;
}
else
{
var reg = ExecutionEngine.Opcode.Definition.Register8FromY;
if (reg != Register8Table.HL)
{
Registers[reg] = value;
}
}
}
public override string First(string input)
{
var alu = new Alu(input);
alu.ExecuteProgram();
return(alu.DebugCount["mul"].ToString());
}
public override string First(string input)
{
var alu = new Alu(input);
alu.ExecuteProgram();
return(alu.Registers["a"].ToString());
}
public void Execute(Alu alu)
{
this.Switch(copy => copy.ExecuteCopy(alu),
inc => inc.ExecuteInc(alu),
dec => dec.ExecuteDec(alu),
jump => jump.ExecuteJump(alu));
}
public void Arithmetic(byte aValue, byte bValue, bool sub)
{
var bus = new Mock <IBus>();
var controlUnit = new Mock <IControlUnit>();
var aReg = new Mock <IRegister>();
var bReg = new Mock <IRegister>();
aReg.SetupGet(x => x.Value).Returns(aValue);
bReg.SetupGet(x => x.Value).Returns(bValue);
ControlLine subtractLine = new ControlLine(ControlLineId.SUBTRACT);
ControlLine busOutputLine = new ControlLine(ControlLineId.SUM_OUT);
controlUnit.Setup(x => x.GetControlLine(ControlLineId.SUBTRACT)).Returns(subtractLine);
controlUnit.Setup(x => x.GetControlLine(ControlLineId.SUM_OUT)).Returns(busOutputLine);
// Are we adding or subtracting?
subtractLine.State = sub;
var alu = new Alu(bus.Object, controlUnit.Object, aReg.Object, bReg.Object);
if (sub)
{
Assert.Equal(aValue - bValue, alu.Value);
}
else
{
Assert.Equal(aValue + bValue, alu.Value);
}
Assert.False(alu.Zero);
Assert.False(alu.Carry);
}
public void TestCalcComplexExpression()
{
List <Token> source = new List <Token>()
{
new TokenOperand()
{
Value = "2"
},
new TokenOperation()
{
Value = "+", Priority = 10
},
new TokenOperand()
{
Value = "3"
},
new TokenOperation()
{
Value = "*", Priority = 20
},
new TokenOperand()
{
Value = "8"
},
};
Alu alu = new Alu();
int actual = alu.Calc(source);
int expected = 26;
Assert.AreEqual(expected, actual);
}
private void SetFlags(byte value)
{
Registers.Flags.S = Alu.IsNegative(value);
Registers.Flags.Z = Alu.IsZero(value);
Registers.Flags.H = false;
Registers.Flags.PV = Registers.Interrupt.IFF2;
Registers.Flags.N = false;
}
public void Execute(Alu alu)
{
this.Switch(copy => copy.ExecuteCopy(alu),
op => op.ExecuteOp(alu),
rcov => rcov.ExecuteRecover(alu),
jump => jump.ExecuteJump(alu),
recv => recv.ExecuteReceive(alu));
}
public void ExecuteRecover(Alu alu)
{
var value = Compare.Match(reg => alu.GetRegValue(reg), val => val.Value);
if (value != 0)
{
alu.SetRegValue(_RECEIVE, alu.GetRegValue(_SEND));
}
}
public void decodificar()
{
alu = gameObject.GetComponent <Alu>();
multiplexor = gameObject.GetComponent <Multiplexor>();
sentencia = identificador.text.Split(' ')[0];
registro = identificador.text.Split(' ')[1];
rutina = decodifica();
StartCoroutine(rutina);
}
public void Execute(Alu alu)
{
this.Switch(copy => copy.ExecuteCopy(alu),
inc => inc.ExecuteInc(alu),
dec => dec.ExecuteDec(alu),
jump => jump.ExecuteJump(alu),
toggle => toggle.ExecuteToggle(alu),
output => output.ExecuteOutput(alu));
}
public Controller(ProgramCounter pcin, Ram ramin, register ain, register bin, Alu aluin, OutputRegister orin)
{
pc = pcin;
ram = ramin;
A = ain;
B = bin;
alu = aluin;
or = orin;
}
public override string Second(string input)
{
// 479009360 : took 29 minutes
var alu = new Alu(input);
alu.Registers["a"] = 12;
alu.ExecuteProgram();
return(alu.Registers["a"].ToString());
}
protected override void OnClockHigh()
{
if (ExecutionEngine.Cycles.IsLastCycle)
{
Cpu.Registers.PC = Alu.Add(Cpu.Registers.PC, _deltaPC);
}
base.OnClockHigh();
}
protected override void OnLastCycleLastM()
{
// perform jump
if (IsConditionMet())
{
var d = (sbyte)InstructionM2.Data.Value;
Registers.PC = Alu.Add(Registers.PC, d);
}
}
public override string Second(string input)
{
//return SecondInCSharp();
var alu = new Alu(PatchProgram(input));
alu.Registers["a"] = 1;
alu.ExecuteProgram();
return(alu.Registers["h"].ToString());
}
private void SetFlags()
{
Registers.Flags.N = (_readPart.Data.Value & (1 << 7)) != 0;
// undocumented p16
var temp = _readPart.Data.Value + Registers.L;
Registers.Flags.H = Registers.Flags.C = (temp > 0xFF);
Registers.Flags.PV = Alu.IsParityEven((byte)((temp & 7) ^ Registers.B));
}
private void SetFlags()
{
Registers.Flags.N = (_writePart.Data.Value & (1 << 7)) != 0;
// undocumented p16/p17
byte adjustedC = (byte)(Registers.C + (IsDecrement ? -1 : 1));
var temp = _writePart.Data.Value + adjustedC;
Registers.Flags.H = Registers.Flags.C = (temp > 0xFF);
Registers.Flags.PV = Alu.IsParityEven((byte)((temp & 7) ^ Registers.B));
}
public void ExecuteJump(Alu alu)
{
if (Compare.Match(reg => alu.GetRegValue(reg), val => val.Value) != 0)
{
if (Offset == 0)
{
throw new StackOverflowException("Assembunny");
}
alu.AdjustPtr(Offset - 1);
}
}
public void TestPolishNotation3()
{
List <Token> source = new List <Token>()
{
new TokenOperand()
{
Value = "2"
},
new TokenOperation()
{
Value = "+", Priority = 10
},
new TokenOperand()
{
Value = "3"
},
new TokenOperation()
{
Value = "*", Priority = 20
},
new TokenOperand()
{
Value = "8"
},
};
Alu alu = new Alu();
Stack <Token> temp = new Stack <Token>();
Queue <Token> actual = new Queue <Token>();
alu.GetPolishNotation(source, temp, actual);
Queue <Token> expected = new Queue <Token>();
expected.Enqueue(new TokenOperand()
{
Value = "2"
});
expected.Enqueue(new TokenOperand()
{
Value = "3"
});
expected.Enqueue(new TokenOperand()
{
Value = "8"
});
expected.Enqueue(new TokenOperation()
{
Value = "*"
});
expected.Enqueue(new TokenOperation()
{
Value = "+"
});
Assert.AreEqual(expected, actual);
}
public void ExecuteOp(Alu alu)
{
if (!string.IsNullOrWhiteSpace(DebugKey))
{
alu.IncreaseDebugCount(DebugKey);
}
alu.SetRegValue(Register, Operation(alu.GetRegValue(Register),
Value.Match(reg => alu.GetRegValue(reg),
val => val.Value)));
}
public void ExecuteReceive(Alu alu)
{
if (alu.HasRegValue(_RECEIVE))
{
alu.SetRegValue(Register, alu.GetRegValue(_RECEIVE));
alu.RemoveRegValue(_RECEIVE);
}
else
{
alu.SetRegValue(_WAITING, 1);
}
}
public List <Alumno> RecuperarAlumnos()
{
List <Alumno> colAlumnos = new List <Alumno>();
foreach (Persona Alu in colPersonas)
{
if (Alu.GetType() == typeof(Alumno))
{
colAlumnos.Add((Alumno)Alu);
}
}
return(colAlumnos);
}
private void CheckCompareLogical(
UInt16 ui16Val1, UInt16 ui16Val2, Boolean expectedSign, Boolean expectedZero, String message)
{
Word word1 = new Word(ui16Val1);
Word word2 = new Word(ui16Val2);
Boolean actualSign;
Boolean actualZero;
Alu.CompareLogical(word1, word2, out actualSign, out actualZero);
Assert.AreEqual(expectedSign, actualSign, "Sign: " + message);
Assert.AreEqual(expectedZero, actualZero, "Zero: " + message);
}
protected virtual void MoveNext()
{
if (IsDecrement)
{
Registers.HL--;
}
else
{
Registers.HL++;
}
Registers.B--;
Registers.Flags.Z = Alu.IsZero(Registers.B);
Registers.Flags.N = true;
}
public override string First(string input)
{
var alu = new Alu(input);
for (int a = 0; a < 100000; a++)
{
alu.Reset();
alu.Registers["a"] = a;
alu.ExecuteProgram();
if (alu.Outputs.Count > 0)
{
return(a.ToString());
}
}
return("NOPE");
}
