private void userBreak(SICEvent e)
{
if (breaker)
{
e.Continue = false;
breaker = false;
}
}
public bool Step()
{
this.devicewrite = false;
current = getInstruction();
SICEvent instEvent = new SICEvent(current, ProgramCounter);
PreInstructionHook(instEvent);
if (!instEvent.Continue)
return false;
current.addrof = ProgramCounter;
IncrementPC(current);
if (current.twobyte)
{
DoTwoBye(current);
lastInstruction = current;
instEvent = new SICEvent(lastInstruction, ProgramCounter);
PostInstructionHook(instEvent);
if (!instEvent.Continue)
return false;
return true;
}
int calcaddr, memval;
calcaddr = GetAddress(current);
current.calculatedaddr = calcaddr;
try
{
memval = GetData(current);
}
catch (IndexOutOfRangeException ex)
{
throw new IndexOutOfRangeException(string.Format("Error: Instruction at 0x{0:X3} references memory that's out of range (0x{1:X3}).", current.addrof, calcaddr), ex);
}
try
{
switch ((OpCode)current.opcode)
{
case OpCode.ADD:
RegisterA += memval;
break;
case OpCode.SUB:
RegisterA -= memval;
break;
case OpCode.MUL:
RegisterA *= memval;
break;
case OpCode.DIV:
RegisterA /= memval;
break;
case OpCode.COMP:
Comp(RegisterA, memval);
break;
case OpCode.J:
ProgramCounter = calcaddr;
break;
case OpCode.JLT:
if (StatusWord == -1)
ProgramCounter = calcaddr;
break;
case OpCode.JGT:
if (StatusWord == 1)
ProgramCounter = calcaddr;
break;
case OpCode.JEQ:
if (StatusWord == 0)
ProgramCounter = calcaddr;
break;
case OpCode.STA:
StoreInt(calcaddr, RegisterA);
break;
case OpCode.STB:
StoreInt(calcaddr, RegisterB);
break;
case OpCode.STL:
StoreInt(calcaddr, RegisterL);
break;
case OpCode.STS:
StoreInt(calcaddr, RegisterS);
break;
case OpCode.STT:
StoreInt(calcaddr, RegisterT);
break;
case OpCode.STX:
StoreInt(calcaddr, RegisterX);
break;
case OpCode.LDB:
RegisterB = memval;
break;
case OpCode.LDX:
RegisterX = memval;
break;
case OpCode.LDA:
RegisterA = memval;
break;
case OpCode.LDL:
RegisterL = memval;
break;
case OpCode.LDS:
RegisterS = memval;
break;
case OpCode.LDT:
RegisterT = memval;
break;
case OpCode.TIX:
RegisterX++;
Comp(RegisterX, memval);
break;
case OpCode.JSUB:
RegisterL = ProgramCounter;
ProgramCounter = calcaddr;
break;
case OpCode.RSUB:
ProgramCounter = RegisterL;
break;
case OpCode.LDCH:
byte[] regA = BitConverter.GetBytes(RegisterA);
byte[] memChar = BitConverter.GetBytes(memval);
byte[] newVal = { memChar[2], regA[1], regA[2], regA[3] };
RegisterA = BitConverter.ToInt32(newVal, 0);
break;
case OpCode.STCH:
byte[] regiA = BitConverter.GetBytes(RegisterA);
memory[calcaddr] = regiA[0];
MemoryChangedHook(calcaddr, 1);
break;
case OpCode.RD:
case OpCode.TD:
case OpCode.WD:
devicewrite = true;
if (!DoDevice(current.opcode, memval))
{
ProgramCounter -= 3;
return false;
}
break;
case OpCode.AND:
RegisterA = RegisterA & memval;
break;
case OpCode.OR:
RegisterA = RegisterA | memval;
break;
default:
int location = ProgramCounter;
if (current.extended)
location -= 4;
else
location -= 3;
throw new ArgumentException(string.Format("Error: Instruction at 0x{0} not a recognized opcode.", !current.extended ? location.ToString("X3") : location.ToString("X4")));
}
}
catch (IndexOutOfRangeException ex)
{
throw new IndexOutOfRangeException(string.Format("Error: Instruction at 0x{0:X3} references memory that's out of range (0x{1:X3}).", ProgramCounter - 3, calcaddr), ex);
}
lastInstruction = current;
instEvent = new SICEvent(lastInstruction, ProgramCounter);
PostInstructionHook(instEvent);
if (!instEvent.Continue)
return false;
return true;
}
private void updateDisplay(SICEvent args)
{
if (InvokeRequired)
{
this.Invoke(new Action(() => updateDisplay(args)));
}
else
{
StringBuilder builder = new StringBuilder();
if (args.Message != null)
messages.Enqueue(args.Message);
foreach (string msg in messages)
builder.AppendLine(msg);
messages.Clear();
OutputMemdump(builder.ToString());
lstInstructions.Items.Clear();
foreach (Instruction instruction in trace)
{
lstInstructions.Items.Add(instruction);
}
lstInstructions.SelectedIndex = lstInstructions.Items.Count - 1;
SetRegisters();
hbMemory.Refresh();
}
}
private void traceHandler(SICEvent e)
{
if (InvokeRequired)
{
traceHandlerCallback c = new traceHandlerCallback(traceHandler);
Invoke(c, e);
return;
}
else
{
if (trace.Count > 250)
trace.Dequeue();
trace.Enqueue(e.instruction);
}
}
private void stopOnFF(SICEvent e)
{
if (InvokeRequired)
{
stopOnFFCallback c = new stopOnFFCallback(stopOnFF);
Invoke(c, e);
return;
}
else
{
if (vm.Memory[e.PC] == 0xFF)
{
e.Continue = false;
}
}
}
private void enableButtons(SICEvent args)
{
if (InvokeRequired)
{
this.Invoke(new Action(() => enableButtons(args)));
}
else
{
btnRun.Enabled = true;
btnLoad.Enabled = true;
btnLoadEXT.Enabled = true;
btnStep.Enabled = true;
openFilesToolStripMenuItem.Enabled = true;
btnBreak.Enabled = false;
vmThread = null;
}
}
private void breakptHandler(SICEvent e)
{
if (InvokeRequired)
{
breakptHandlerCallback c = new breakptHandlerCallback(breakptHandler);
Invoke(c, e);
return;
}
if (Breakpoints.Contains(e.PC) && (lastBP != e.PC))
{
e.Continue = false;
messages.Enqueue(string.Format("Breakpoint reached at 0x{0:X4}.", vm.ProgramCounter));
tbRunAddr.Text = string.Format("{0:X}", vm.ProgramCounter);
hbMemory.Refresh();
hbMemory.ScrollByteIntoView(e.PC);
changeColor(e.PC, e.instruction.length, Color.White, Color.DarkRed);
lastBP = e.PC;
}
else if (lastBP != null)
{
resetColor((int)lastBP);
lastBP = null;
}
}
