public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
var add_left = vm.Register[(Registers)(int)cmd[0]];
var add_right = vm.Register[(Registers)(int)cmd[1]];
vm.Register[Registers.ACC] = add_left + add_right;
}
public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
var fromReg = (Registers)(int)cmd[0];
var toReg = (Registers)(int)cmd[1];
vm.Register[toReg] = vm.Register[fromReg];
}
public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
var in_addr = (int)cmd[0];
var in_reg = (Registers)(int)cmd[1];
PortMappedDeviceManager.Read(in_addr, in_reg, vm);
}
public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
var out_addr = (int)cmd[0];
var out_value = (int)cmd[1];
PortMappedDeviceManager.Write(out_addr, out_value, vm);
}
public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
var to = cmd[0];
var rval = vm.Stack.Pop();
vm.Register[(Registers)to] = rval;
}
public void ParseInstruction(BinaryReader r)
{
var cmd = new AsmCommand();
cmd.OpCode = (OpCode)r.ReadInt32();
var argCount = r.ReadInt32();
Register[Registers.IPR] += sizeof(int) * 2;
for (int i = 0; i < argCount; i++)
{
var arg = new AsmCommandArg();
arg.Value = r.ReadInt32();
Register[Registers.IPR] += sizeof(int);
cmd.Args.Add(arg);
}
if (!Debugger.HasBreakPoint(Register[Registers.IPR]))
{
if (!RunInstruction(cmd))
{
Register[Registers.ERR] = 1;
}
}
}
public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
var reg = (int)cmd[0];
var val = cmd[1];
vm.Register[(Registers)reg] = (int)val;
}
public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
var cll = (int)cmd[0];
vm.Stack.PushRegisters(vm.Register);
vm.Register[Registers.IPR] = cll;
}
public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
var neq_f = (Registers)(int)cmd[0];
var neq_s = (Registers)(int)cmd[1];
vm.Register[Registers.BRR] = neq_f != neq_s ? 1 : 0;
}
public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
var e_addr = (int)cmd[0];
if (vm.Register[Registers.BRR] != 0)
{
vm.Register[Registers.IPR] = e_addr;
}
}
public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
var startIndex = (int)cmd[0];
var section = vm.Assembly[AssemblySections.ReadOnly];
var value = BitConverter.ToInt32(section.Raw, startIndex);
vm.Stack.Push(value);
}
public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
var startIndex = (int)cmd[0];
var reg = (Registers)(int)cmd[1];
var section = vm.Assembly[AssemblySections.ReadOnly];
var value = BitConverter.ToInt32(section.Raw, startIndex);
vm.Register[reg] = value;
}
private bool RunInstruction(AsmCommand cmd)
{
if (Instructions.ContainsKey(cmd.OpCode))
{
Instructions[cmd.OpCode].Invoke(cmd, this);
}
else
{
throw new Exception($"Instructon '{Enum.GetName(typeof(OpCode), cmd.OpCode)}' not found");
}
return(true);
}
public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
var jmp_index = (int)cmd[0];
if (jmp_index < 0)
{
vm.Register[Registers.IPR] -= jmp_index;
}
else
{
vm.Register[Registers.IPR] += jmp_index;
}
}
public abstract void Invoke(AsmCommand cmd, VirtualMachine vm);
public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
vm.Stack.PopRegisters(vm.Register);
}
public Command(AsmCommand command)
{
this.name = command.Target;
args = new string[command.OpCount][];
for (int i = 0; i < command.OpCount; i++)
{
args[i] = new string[command.GetOp(i).TokenCount];
for (int t = 0; t < command.GetOp(i).TokenCount; t++)
args[i][t] = command.GetOp(i).GetToken(t);
}
}
public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
var addr = (int)cmd[0];
vm.Register[Registers.IPR] = addr;
}
public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
var interrupt = (int)cmd[0];
InterruptTable.Interrupt(interrupt, vm);
}
public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
var push_lit = (int)cmd[0];
vm.Stack.Push(push_lit);
}
public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
var from = (int)cmd[0];
vm.Stack.Push(vm.Register[(Registers)from]);
}
public override void Invoke(AsmCommand cmd, VirtualMachine vm)
{
var reg = (Registers)(int)cmd[0];
vm.Register[reg]--;
}
