public void PcShouldNotAdvance()
{
var clock = new Mock <IClock>();
clock.Setup(x => x.AddConnectedComponent(It.IsAny <IClockConnectedComponent>()));
var bus = new Mock <IBus>();
var controlUnit = new Mock <IControlUnit>();
ControlLine countEnableLine = new ControlLine(ControlLineId.PC_ENABLE);
controlUnit.Setup(x => x.GetControlLine(ControlLineId.PC_ENABLE)).Returns(countEnableLine);
ControlLine busOutputLine = new ControlLine(ControlLineId.PC_OUT);
controlUnit.Setup(x => x.GetControlLine(ControlLineId.PC_OUT)).Returns(busOutputLine);
ControlLine busInputLine = new ControlLine(ControlLineId.PC_IN);
controlUnit.Setup(x => x.GetControlLine(ControlLineId.PC_IN)).Returns(busInputLine);
var pc = new ProgramCounter(clock.Object, bus.Object, controlUnit.Object);
byte v1 = pc.Value;
pc.OnRisingEdge();
byte v2 = pc.Value;
Assert.Equal(v1, v2);
}
public void PcReadFromBus()
{
byte expectedValue = 0xF0;
var clock = new Mock <IClock>();
clock.Setup(x => x.AddConnectedComponent(It.IsAny <IClockConnectedComponent>()));
var bus = new Mock <IBus>();
bus.SetupGet(x => x.Value).Returns(expectedValue);
var controlUnit = new Mock <IControlUnit>();
ControlLine countEnableLine = new ControlLine(ControlLineId.PC_ENABLE);
controlUnit.Setup(x => x.GetControlLine(ControlLineId.PC_ENABLE)).Returns(countEnableLine);
ControlLine busOutputLine = new ControlLine(ControlLineId.PC_OUT);
controlUnit.Setup(x => x.GetControlLine(ControlLineId.PC_OUT)).Returns(busOutputLine);
ControlLine busInputLine = new ControlLine(ControlLineId.PC_IN);
controlUnit.Setup(x => x.GetControlLine(ControlLineId.PC_IN)).Returns(busInputLine);
busInputLine.State = true;
var pc = new ProgramCounter(clock.Object, bus.Object, controlUnit.Object);
pc.OnRisingEdge();
Assert.Equal(expectedValue, pc.Value);
}
public void IsSetReturned()
{
var pc = new ProgramCounter();
pc.Set(15);
Assert.AreEqual(15, pc.Next());
}
// On Re-entrant (i.e while awaiting)
public NodeRunResult OnAwaiting(ref ProgramCounter pc)
{
var input = Console.ReadKey().KeyChar;
Console.WriteLine();
// TODO Flesh this out a little more it's a touch error prone
if (input == '1')
{
SelectChild(pc, 0);
return(NodeRunResult.PushChildN);
}
if (input == '2')
{
SelectChild(pc, 1);
return(NodeRunResult.PushChildN);
}
if (input == '3')
{
SelectChild(pc, 2);
return(NodeRunResult.PushChildN);
}
if (input == 'X' || input == 'x')
{
return(NodeRunResult.NextCommand);
}
return(NodeRunResult.Await);
}
public override NodeRunResult Run(ref ProgramCounter pc, ref ProgramData pd)
{
var i = 0;
foreach (var n in Children)
{
if (n is OptionNode)
{
var o = n as OptionNode;
if (o.RemoveOnSelect && pd.HasRemovedOption(o.Id))
{
}
else
{
i++;
Console.WriteLine(o.Text);
}
}
}
// If there are no options return nextnode
if (i == 0)
{
return(NodeRunResult.NextCommand);
}
{
return(OnAwaiting(ref pc));
}
}
// On Re-entrant (i.e while awaiting)
public NodeRunResult OnAwaiting(ref ProgramCounter pc)
{
var input = Console.ReadKey().KeyChar;
Console.WriteLine();
// TODO Flesh this out a little more
// TODO Mark as remove on selected if flag set
if (input == '1')
{
pc.ReturnRegisterInt32 = 0;
return(NodeRunResult.PushChildN);
}
if (input == '2')
{
pc.ReturnRegisterInt32 = 1;
return(NodeRunResult.PushChildN);
}
if (input == '3')
{
pc.ReturnRegisterInt32 = 2;
return(NodeRunResult.PushChildN);
}
if (input == 'X' || input == 'x')
{
return(NodeRunResult.NextCommand);
}
return(NodeRunResult.Await);
}
public void IsSetIncremented()
{
var pc = new ProgramCounter();
pc.Set(15);
pc.Next();
Assert.AreEqual(16, pc.Next());
}
public void IsSecondOne()
{
var pc = new ProgramCounter();
pc.Next();
Assert.AreEqual(1, pc.Next());
}
public Processor(MemoryMap memory)
{
this.Memory = memory;
instructions = new InstructionSet();
extraCodeInstructions = new ExtraCodeInstructionSet();
// configure registers
// main registers?
A = memory.AddRegister <Accumulator>(0x00);
L = memory.AddRegister <ErasableMemory>(0x01);
Q = memory.AddRegister <FullRegister>(0x02);
EB = memory.AddRegister <ErasableBankRegister>(0x03);
FB = memory.AddRegister <FixedBankRegister>(0x4);
Z = memory.AddRegister <ProgramCounter>(0x05);
BB = memory.AddRegister <BothBanksRegister>(0x06);
//memory[0x7] = 0; // this is always set to 0, TODO: need to hard code?
// interrupt helper registers
ARUPT = memory.AddRegister <ErasableMemory>(0x08);
LRUPT = memory.AddRegister <ErasableMemory>(0x09);
QRUPT = memory.AddRegister <ErasableMemory>(0x0A);
// 0XB, 0XC are spares. not used?
ZRUPT = memory.AddRegister <ErasableMemory>(0x0D);
BBRUPT = memory.AddRegister <ErasableMemory>(0x0E);
BRUPT = memory.AddRegister <ErasableMemory>(0x0F);
// editing registers
CYR = memory.AddRegister <CycleRightRegister>(0x10);
SR = memory.AddRegister <ShiftRightRegister>(0x11);
CYL = memory.GetWord(0x12);
EDOP = memory.GetWord(0x13);
// time registers
TIME2 = memory.GetWord(0x14);
TIME1 = memory.GetWord(0x15);
TIME3 = memory.GetWord(0x16);
TIME4 = memory.GetWord(0x17);
TIME5 = memory.GetWord(0x18);
TIME6 = memory.GetWord(0x19);
// orientation registers
CDUX = memory.AddRegister <ErasableMemory>(0x1A);
CDUY = memory.AddRegister <ErasableMemory>(0x1B);
CDUZ = memory.AddRegister <ErasableMemory>(0x1C);
OPTY = memory.AddRegister <ErasableMemory>(0x1D);
OPTX = memory.AddRegister <ErasableMemory>(0x1E);
PIPAX = memory.AddRegister <ErasableMemory>(0x1F);
PIPAY = memory.AddRegister <ErasableMemory>(0x20);
PIPAZ = memory.AddRegister <ErasableMemory>(0x21);
// LM Only Pitch, Yaw, and Roll registers
INLINK = memory.AddRegister <ErasableMemory>(0x25);
// prime Z to start at the boot interrupt
Z.Write(new OnesCompliment(0x800));
}
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 void CallingMoveScriptWhenNoScriptHasBeenSetUpThrowsAnException()
{
var programCounter = new ProgramCounter();
Action act = () => programCounter.MoveScriptPointer(2);
act.Should().Throw <Exception>()
.WithMessage("Program Counter does not have a script.");
}
public override NodeRunResult Run(ref ProgramCounter pc, ref ProgramData pd)
{
if (RemoveOnSelect)
{
pd.RemoveOption(this.Id);
}
pc.ReturnRegisterInt32 = 0;
return(NodeRunResult.PushChildN);
}
public void ProgramCounterIncrements()
{
SignalBus signals = new SignalBus();
ProgramCounter programCounter = new ProgramCounter(null, signals);
signals.CE = true;
programCounter.ReadFromBus();
Assert.AreEqual(1, programCounter.Value);
}
public override NodeRunResult Run(ref ProgramCounter pc, ref ProgramData pd)
{
if (pd.HasRunOnceOnly(this.Id))
{
return(NodeRunResult.PushChildFalse);
}
else
{
pd.MarkOnceOnly(this.Id);
return(NodeRunResult.PushChildTrue);
}
}
public void Reset()
{
InstructionCounter.Reset();
ProgramCounter.Reset();
A.Reset();
B.Reset();
Flags.Reset();
Instruction.Reset();
MemoryAddress.Reset();
Output.Reset();
Sum.Reset();
}
public override NodeRunResult Run(ref ProgramCounter pc, ref ProgramData pd)
{
// Console.WriteLine("Node wait: " + Counter);
if (Counter < WaitTimeMilliseconds)
{
Counter += pd.DeltaTime;
return(NodeRunResult.Await);
}
//Console.WriteLine("Node wait done");
//Thread.Sleep(WaitTimeMilliseconds); // Not good implementation
return(NodeRunResult.NextCommand);
}
public void ProgramCounterWraps()
{
SignalBus signals = new SignalBus();
ProgramCounter programCounter = new ProgramCounter(null, signals);
programCounter.Value = 15;
signals.CE = true;
programCounter.ReadFromBus();
Assert.AreEqual(0, programCounter.Value);
}
public void ProgramCounterOutputs()
{
DataBus bus = new DataBus();
SignalBus signals = new SignalBus();
ProgramCounter programCounter = new ProgramCounter(bus, signals);
programCounter.Value = 15;
signals.CO = true;
programCounter.WriteToBus();
Assert.AreEqual(15, bus.Value);
}
private void SelectChild(ProgramCounter pc, int index)
{
if (index < Children.Count)
{
if (Children[index] is OptionNode)
{
var c = Children[index] as OptionNode;
if (c.ReturnOnSelect)
{
this.ReturnOnSelect = true;
}
}
pc.ReturnRegisterInt32 = index;
}
}
static bool StoreByte(int value)
{
if (value > 0xff)
{
LogError(currentFileName, null, "Value too big, expeced byte!");
return(false);
}
if (ProgramCounter > 0xffff)
{
LogError(currentFileName, null, "Program Counter out of range: " + ProgramCounter.ToString("X4"));
return(false);
}
Memory[ProgramCounter++] = (byte)value;
return(true);
}
static CPU()
{
RegisterFile = new GenericMemory(16);
DataMemory = new GenericMemory(16);
PC = new ProgramCounter();
Instructions = new InstructionMemory();
IsReady = false;
_clockCycle = 0;
_isStalled = false;
InstructionQueue = new Queue <Instruction>();
AwaitingRegisters = new HashSet <int>();
ForwardedRegisters = new Dictionary <int, int>();
}
public void Interrupt(byte interrupt)
{
if (InterruptDescriptorTablePointer == null)
{
#if DEBUG
Console.WriteLine("Aborted, int: " + interrupt.ToString("X"));
#endif
Abort();
}
else
{
ProgramCounter.CallInterrupt(interrupt);
}
throw new InterruptSignal(interrupt);
}
private void RunInterrupt(ushort programCounterLocation, int cycles)
{
PushToStack((ProgramCounter >> 8).ApplyLowMask());
PushToStack(ProgramCounter.ApplyLowMask());
RemoveFlag(CpuFlag.Break);
SetFlag(CpuFlag.Unused);
SetFlag(CpuFlag.DisableInterrupts);
PushToStack((byte)StatusRegister);
AbsoluteAddress = programCounterLocation;
SetProgramCounter();
Cycles = cycles;
}
public Processor(Dictionary <byte, AssemblerInstruction> instructions)
{
this.Context = null;
RegistersContainer = new Dictionary <byte, IRegister>(RegistersCount);
InstructionSet = instructions;
flags = 0;
abort = false;
for (byte r = 0; r < RegistersCount; r++)
{
RegistersContainer.Add(r, new Register <T>());
}
StackPointer = new StackPointer(this, new Register <uint>(), 0, 0);
ProgramCounter = new ProgramCounter <uint>(this, new Register <uint>());
}
/// <summary>
/// Displays the current state of the processor.
/// </summary>
public void DumpState()
{
Console.WriteLine("State:");
Console.WriteLine("\tProgram Counter: " + ProgramCounter.GetString());
Console.WriteLine("\tInstruction: " + Instruction.GetString());
Console.WriteLine("\tOpcode: " + Instruction.GetOpCode().ToString());
Console.WriteLine("\tA: " + a.GetString());
Console.WriteLine("\tB: " + b.GetString());
Console.WriteLine("\tC: " + c.GetString());
Console.WriteLine("\tD: " + D.GetString());
Console.WriteLine("\tE: " + E.GetString());
Console.WriteLine("\tF: " + F.GetString());
Console.WriteLine("\tG: " + G.GetString());
Console.WriteLine("\tH: " + H.GetString());
Console.WriteLine("\tXL: " + XL.GetString());
Console.WriteLine("\tXH: " + XH.GetString());
Console.WriteLine("");
}
public override NodeRunResult Run(ref ProgramCounter pc, ref ProgramData pd)
{
var i = 0;
if (ReturnOnSelect)
{
// We selected an option which results in a return
}
else
{
foreach (var n in Children)
{
if (n is OptionNode)
{
var o = n as OptionNode;
// TODO this could be shifted into the compiler at somestage.
if (this.RemoveOnSelect == true)
{
o.RemoveOnSelect = true;
}
if (o.RemoveOnSelect && pd.HasRemovedOption(o.Id))
{
}
else
{
i++;
Console.WriteLine(o.Text);
}
}
}
}
// If there are no options return nextnode
if (i == 0)
{
return(NodeRunResult.NextCommand);
}
{
return(OnAwaiting(ref pc));
}
}
/**
* @brief Links all the component so they
* can be used in micro instructions.
*/
public void LinkCPUcomponents(
ProgramCounter PC, MemoryAddressRegister MAR,
MemoryDataRegister MDR, InstructionRegister IR,
GeneralPurposeRegisterA GPA, GeneralPurposeRegisterB GPB,
ProcessStatusRegister PSR,
MemoryListControl memory, ArithmeticLogicUnit ALU,
Clock clock, BusControl busSystem)
{
this.PC = PC;
this.MAR = MAR;
this.MDR = MDR;
this.IR = IR;
this.GPA = GPA;
this.GPB = GPB;
this.PSR = PSR;
this.memory = memory;
this.ALU = ALU;
this.clock = clock;
this.busSystem = busSystem;
}
// TODO The variables need to be added to program data
public override NodeRunResult Run(ref ProgramCounter pc, ref ProgramData pd)
{
if (pd.ScriptVariableTable.HasVariable(variableId))
{
Console.WriteLine("TODO Provide variable");
var context = new ExpressionContext(new HostSymbolTable()); // TODO This should be provided from somewhere.
context.scriptVariabeTable = pd.ScriptVariableTable; // TODO Should be provided
var result = pd.expressionRunner.Evaluate(expression, context);
// TODO What if the return value of an expression is expected to be a string?
pd.ScriptVariableTable.SetVariable(variableId, result.ToString());
}
else
{
// Error invalid variable (Should never be unknown because should be checked at compiletime.
}
return(NodeRunResult.NextCommand);
}
public override NodeRunResult Run(ref ProgramCounter pc, ref ProgramData pd)
{
Console.WriteLine("TODO Eval Expression");
var value = true; //pd.ScriptVariableTable.GetValueBool("$bTalked_to_man");
var context = new ExpressionContext(new HostSymbolTable()); // TODO This should be provided from somewhere.
context.scriptVariabeTable = pd.ScriptVariableTable; // TODO Should be provided
var result = pd.expressionRunner.Evaluate(Expression, context);
if (result == 1)
{
return(NodeRunResult.PushChildTrue);
}
else
{
return(NodeRunResult.PushChildFalse);
}
}
public void Clk()
{
if (Clock.IsHalted)
{
return;
}
signals.Reset();
Operation operation = GetOperation(Instruction.Value);
operation.Clk();
InstructionCounter.Clk();
RAM.WriteToBus();
Instruction.WriteToBus();
ProgramCounter.WriteToBus();
MemoryAddress.WriteToBus();
Sum.WriteToBus();
A.WriteToBus();
B.WriteToBus();
Flags.WriteToBus();
Output.WriteToBus();
RAM.ReadFromBus();
Instruction.ReadFromBus();
ProgramCounter.ReadFromBus();
MemoryAddress.ReadFromBus();
Sum.ReadFromBus();
A.ReadFromBus();
B.ReadFromBus();
Flags.ReadFromBus();
Output.ReadFromBus();
if (signals.HLT)
{
Clock.IsHalted = true;
}
}
