public void TestSetAndReadBytes() //MOV AL, BH
{
byte[] test;
RegistersController registry = new SegmentRegisters();
registry.SetBytesToRegistry("CS", 0, 1);
test = registry.GetRegistry("CS");
Assert.AreEqual(BitConverter.ToUInt16(test), 256);
registry.SetBytesToRegistry("SS", 0, 255);
test = registry.GetRegistry("SS");
Assert.AreEqual(BitConverter.ToUInt16(test), 65280);
registry.SetBytesToRegistry("DS", 1, 0, 1, 0, 1, 0);
test = registry.GetRegistry("DS");
Assert.AreEqual(BitConverter.ToUInt16(test), 1);
registry.SetBytesToRegistry("ES", 255);
test = registry.GetRegistry("ES");
Assert.AreEqual(BitConverter.ToUInt16(test), 255);
registry.SetBytesToRegistry("ES");
test = registry.GetRegistry("ES");
Assert.AreEqual(BitConverter.ToUInt16(test), 255);
}
public void TestPOP()
{
MemoryModel.SetAddressBusLength = 20;
MemoryModel memory = MemoryModel.GetInstance();
GeneralPurposeRegisters generalRegistersMock = new GeneralPurposeRegisters();
SegmentRegisters segmentRegistersMock = new SegmentRegisters();
PointerRegisters pointerRegistersMock = new PointerRegisters();
LoggerMock loggerMock = new LoggerMock();
RegistryCommander registryCommand = new RegistryCommander(loggerMock);
POP pop = new POP(generalRegistersMock, pointerRegistersMock, segmentRegistersMock);
PUSH push = new PUSH(generalRegistersMock, pointerRegistersMock, segmentRegistersMock);
XCHG xchg = new XCHG(generalRegistersMock, segmentRegistersMock);
MOV mov = new MOV(generalRegistersMock, segmentRegistersMock);
AssignToRegistry assignTo = new AssignToRegistry(generalRegistersMock, pointerRegistersMock, segmentRegistersMock);
registryCommand.AddHandler(pop);
registryCommand.AddHandler(push);
registryCommand.AddHandler(xchg);
registryCommand.AddHandler(mov);
registryCommand.AddHandler(assignTo);
byte[] word;
registryCommand.InputCommand("ax 1122");
registryCommand.InputCommand("push ax");
registryCommand.InputCommand("pop cx");
word = generalRegistersMock.GetRegistry("CX");
Assert.AreEqual(34, word[0]);
Assert.AreEqual(17, word[1]);
Assert.AreEqual("Value 1122h from physical address 0h popped from stack to registry CX.\r\n", loggerMock.outputResult);
word = pointerRegistersMock.GetRegistry("SP");
Assert.AreEqual(0, word[0]);
registryCommand.InputCommand("ax FFEE");
registryCommand.InputCommand("bx AA99");
registryCommand.InputCommand("SS FF");
registryCommand.InputCommand("push ax");
registryCommand.InputCommand("push bx");
registryCommand.InputCommand("pop dx");
word = generalRegistersMock.GetRegistry("DX");
Assert.AreEqual(153, word[0]);
Assert.AreEqual(170, word[1]);
Assert.AreEqual("Value AA99h from physical address FF2h popped from stack to registry DX.\r\n", loggerMock.outputResult);
word = pointerRegistersMock.GetRegistry("SP");
Assert.AreEqual(2, word[0]);
}
public void TestMOVInvalidCommands()
{
MemoryModel.SetAddressBusLength = 20;
GeneralPurposeRegisters registersMock = new GeneralPurposeRegisters();
SegmentRegisters segmentsMock = new SegmentRegisters();
PointerRegisters pointersMock = new PointerRegisters();
LoggerMock loggerMock = new LoggerMock();
RegistryCommander registryCommand = new RegistryCommander(loggerMock);
MOV mov = new MOV(registersMock, pointersMock, segmentsMock);
AssignToRegistry assign = new AssignToRegistry(registersMock, pointersMock, segmentsMock);
registryCommand.AddHandler(mov);
registryCommand.AddHandler(assign);
registryCommand.InputCommand("mov ak, bh");
Assert.AreEqual(loggerMock.outputResult, "AK is unsupported registry name.");
registryCommand.InputCommand("mov ah, bk");
Assert.AreEqual(loggerMock.outputResult, "BK is unsupported registry name.");
registryCommand.InputCommand("mov ah bk");
Assert.AreEqual(loggerMock.outputResult, "MOV arguments must be separated by comma.");
registryCommand.InputCommand("mov ch,");
Assert.AreEqual(loggerMock.outputResult, "Too few arguments to function MOV.");
registryCommand.InputCommand("mov ax, [0");
Assert.AreEqual(loggerMock.outputResult, "Argument is missing bracket.");
registryCommand.InputCommand("mov [0, ax");
Assert.AreEqual(loggerMock.outputResult, "Argument is missing bracket.");
registryCommand.InputCommand("mov [0, ch");
Assert.AreEqual(loggerMock.outputResult, "Argument is missing bracket.");
registryCommand.InputCommand("BP ffff");
registryCommand.InputCommand("DS ffff");
registryCommand.InputCommand("mov [BP], CX");
Assert.AreEqual("Converting arguments into effective address FFFFh.\r\nPhysical address 10FFEFh is out of range memory.\nAborting operation MOV.\r\n", loggerMock.outputResult);
registryCommand.InputCommand("mov CX, [BP]");
Assert.AreEqual("Converting arguments into effective address FFFFh.\r\nPhysical address 10FFEFh is out of range memory.\nAborting operation MOV.\r\n", loggerMock.outputResult);
MemoryModel.SetAddressBusLength = 0;
}
public void TestPUSH()
{
MemoryModel.SetAddressBusLength = 20;
MemoryModel memory = MemoryModel.GetInstance();
GeneralPurposeRegisters generalRegistersMock = new GeneralPurposeRegisters();
SegmentRegisters segmentRegistersMock = new SegmentRegisters();
PointerRegisters pointerRegistersMock = new PointerRegisters();
LoggerMock loggerMock = new LoggerMock();
RegistryCommander registryCommand = new RegistryCommander(loggerMock);
PUSH push = new PUSH(generalRegistersMock, pointerRegistersMock, segmentRegistersMock);
XCHG xchg = new XCHG(generalRegistersMock, segmentRegistersMock);
MOV mov = new MOV(generalRegistersMock, segmentRegistersMock);
AssignToRegistry assignTo = new AssignToRegistry(generalRegistersMock, pointerRegistersMock, segmentRegistersMock);
registryCommand.AddHandler(push);
registryCommand.AddHandler(xchg);
registryCommand.AddHandler(mov);
registryCommand.AddHandler(assignTo);
byte[] word;
registryCommand.InputCommand("ax 1122");
registryCommand.InputCommand("push ax");
word = memory.GetMemoryWord(0);
Assert.AreEqual(word[0], 34);
Assert.AreEqual(word[1], 17);
Assert.AreEqual("Value 1122h from registry AX pushed on stack with physical address 0h.\r\n", loggerMock.outputResult);
word = pointerRegistersMock.GetRegistry("SP");
Assert.AreEqual(word[0], 2);
registryCommand.InputCommand("ax FFEE");
registryCommand.InputCommand("bx AA99");
registryCommand.InputCommand("SS FF");
registryCommand.InputCommand("push ax");
registryCommand.InputCommand("push bx");
word = memory.GetMemoryWord(4083);
Assert.AreEqual(word[0], 255);
Assert.AreEqual(word[1], 153);
Assert.AreEqual("Value AA99h from registry BX pushed on stack with physical address FF4h.\r\n", loggerMock.outputResult);
word = pointerRegistersMock.GetRegistry("SP");
Assert.AreEqual(word[0], 6);
}
public void TestXCHGMemoryRegistry()
{
MemoryModel.SetAddressBusLength = 20;
MemoryModel memory = MemoryModel.GetInstance();
GeneralPurposeRegisters generalRegistersMock = new GeneralPurposeRegisters();
SegmentRegisters segmentRegistersMock = new SegmentRegisters();
LoggerMock loggerMock = new LoggerMock();
RegistryCommander registryCommand = new RegistryCommander(loggerMock);
XCHG xchg = new XCHG(generalRegistersMock, segmentRegistersMock);
MOV mov = new MOV(generalRegistersMock, segmentRegistersMock);
AssignToRegistry assignTo = new AssignToRegistry(generalRegistersMock, segmentRegistersMock);
registryCommand.AddHandler(xchg);
registryCommand.AddHandler(mov);
registryCommand.AddHandler(assignTo);
registryCommand.InputCommand("MoV AL, FFh");
registryCommand.InputCommand("MoV [SI + 0], AL");
registryCommand.InputCommand("MoV AL, 1");
registryCommand.InputCommand("XCHG [0], AL");
byte bytetmp = memory.GetMemoryCell(0);
Assert.AreEqual(bytetmp, 1);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"0\" as decimal.\r\nConverting arguments into effective address 0h.\r\nValue 1h from registry AL exchanged with FF at physical address 0h.\r\n");
bytetmp = generalRegistersMock.GetRegistry("AL")[0];
Assert.AreEqual(bytetmp, 255);
segmentRegistersMock.SetBytesToRegistry("DS", 255);
registryCommand.InputCommand("MoV CX, FF11h");
registryCommand.InputCommand("MoV [SI + BP + FFh], CX");
registryCommand.InputCommand("MoV CX, 2233h");
registryCommand.InputCommand("XCHG CX, [100h]");
byte[] word = generalRegistersMock.GetRegistry("CX");
Assert.AreEqual(word[0], 255);
Assert.AreEqual(word[1], 0);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"100\" as hexadecimal.\r\nConverting arguments into effective address 100h.\r\nValue 2233h from registry CX exchanged with FF at physical address 10F0h.\r\n");
word = memory.GetMemoryWord(4336);
Assert.AreEqual(word[0], 51);
Assert.AreEqual(word[1], 34);
MemoryModel.SetAddressBusLength = 0;
}
public MainWindow()
{
InitializeComponent();
MemoryModel.SetAddressBusLength = 20;
MemoryModel.GetInstance().AddObserver(this);
memoryView = new MemoryView();
Go_Click(null, null);
generalPurposeRegisters = new GeneralPurposeRegisters();
indexRegisters = new IndexRegisters();
pointerRegisters = new PointerRegisters();
segmentRegisters = new SegmentRegisters();
commandInterpreter = InitDefaultRegistryCommander();
generalPurposeRegistersView = new GeneralPurposeRegistersView(new HexParser());
indexRegistersView = new IndexRegistersView(new HexParser());
pointerRegistersView = new PointerRegistersView(new HexParser());
segmentRegistersView = new SegmentRegistersView(new HexParser());
if (generalPurposeRegisters is Observable observableGeneralPurposeReg)
{
observableGeneralPurposeReg.AddObserver(generalPurposeRegistersView);
}
if (indexRegisters is Observable observableIndexReg)
{
observableIndexReg.AddObserver(indexRegistersView);
}
if (pointerRegisters is Observable observablePointersReg)
{
observablePointersReg.AddObserver(pointerRegistersView);
}
if (segmentRegisters is Observable observableSegmentsReg)
{
observableSegmentsReg.AddObserver(segmentRegistersView);
}
SetBlockDataContext();
}
/// <summary>
/// Gets the linear address of a specified segment.
/// </summary>
/// <param name="segment">The segment to get.</param>
/// <param name="context">The context.</param>
/// <returns>A <see cref="IntPtr" /> pointer corresponding to the linear address of the segment.</returns>
/// <exception cref="InvalidEnumArgumentException">segment</exception>
public IntPtr GetRealSegmentAddress(SegmentRegisters segment, ref ThreadContext32 context)
{
// Get a selector entry for the segment
LdtEntry entry;
switch (segment)
{
case SegmentRegisters.Cs:
entry = ThreadCore.GetThreadSelectorEntry(Handle, context.SegCs);
break;
case SegmentRegisters.Ds:
entry = ThreadCore.GetThreadSelectorEntry(Handle, context.SegDs);
break;
case SegmentRegisters.Es:
entry = ThreadCore.GetThreadSelectorEntry(Handle, context.SegEs);
break;
case SegmentRegisters.Fs:
entry = ThreadCore.GetThreadSelectorEntry(Handle, context.SegFs);
break;
case SegmentRegisters.Gs:
entry = ThreadCore.GetThreadSelectorEntry(Handle, context.SegGs);
break;
case SegmentRegisters.Ss:
entry = ThreadCore.GetThreadSelectorEntry(Handle, context.SegSs);
break;
default:
throw new InvalidEnumArgumentException(nameof(segment), (int)segment, typeof(SegmentRegisters));
}
// Compute the linear address
return(new IntPtr(entry.BaseLow | (entry.BaseMid << 16) | (entry.BaseHi << 24)));
}
public void TestFromToRegistryMemory()
{
MemoryModel.SetAddressBusLength = 20;
MemoryModel memory = MemoryModel.GetInstance();
GeneralPurposeRegisters generalRegistersMock = new GeneralPurposeRegisters();
SegmentRegisters segmentRegistersMock = new SegmentRegisters();
LoggerMock loggerMock = new LoggerMock();
RegistryCommander registryCommand = new RegistryCommander(loggerMock);
XCHG xchg = new XCHG(generalRegistersMock, segmentRegistersMock);
MOV mov = new MOV(generalRegistersMock, segmentRegistersMock);
AssignToRegistry assignTo = new AssignToRegistry(generalRegistersMock, segmentRegistersMock);
registryCommand.AddHandler(xchg);
registryCommand.AddHandler(mov);
registryCommand.AddHandler(assignTo);
registryCommand.InputCommand("MoV AL, 255");
registryCommand.InputCommand("MoV [0], AL");
byte bytetmp = memory.GetMemoryCell(0);
Assert.AreEqual(bytetmp, 255);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"0\" as decimal.\r\nConverting arguments into effective address 0h.\r\nValue FFh from registry AL assigned to physical address 0h.\r\n");
segmentRegistersMock.SetBytesToRegistry("DS", 255);
registryCommand.InputCommand("MoV AH, AAh");
registryCommand.InputCommand("MoV [FFh], AH");
bytetmp = memory.GetMemoryCell(4335);
Assert.AreEqual(bytetmp, 170);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"FF\" as hexadecimal.\r\nConverting arguments into effective address FFh.\r\nValue AAh from registry AH assigned to physical address 10EFh.\r\n");
segmentRegistersMock.SetBytesToRegistry("DS", 15);
registryCommand.InputCommand("MoV [0h], AX");
byte[] word = memory.GetMemoryWord(240);
Assert.AreEqual(word[0], 255);
Assert.AreEqual(word[1], 170);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"0\" as hexadecimal.\r\nConverting arguments into effective address 0h.\r\nValue AAFFh from registry AX assigned to physical address F0h.\r\n");
segmentRegistersMock.SetBytesToRegistry("DS", 0);
registryCommand.InputCommand("MoV AX, [0h]");
word = generalRegistersMock.GetRegistry("AX");
Assert.AreEqual(word[0], 255);
Assert.AreEqual(word[1], 0);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"0\" as hexadecimal.\r\nConverting arguments into effective address 0h.\r\nValue FFh assigned to registry AX from physical address 0h.\r\n");
segmentRegistersMock.SetBytesToRegistry("DS", 255);
registryCommand.InputCommand("MoV AX, [FEh]");
word = generalRegistersMock.GetRegistry("AX");
Assert.AreEqual(word[0], 0);
Assert.AreEqual(word[1], 170);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"FE\" as hexadecimal.\r\nConverting arguments into effective address FEh.\r\nValue AA00h assigned to registry AX from physical address 10EEh.\r\n");
segmentRegistersMock.SetBytesToRegistry("DS", 15);
registryCommand.InputCommand("MoV AX, [0h]");
word = generalRegistersMock.GetRegistry("AX");
Assert.AreEqual(word[0], 255);
Assert.AreEqual(word[1], 170);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"0\" as hexadecimal.\r\nConverting arguments into effective address 0h.\r\nValue AAFFh assigned to registry AX from physical address F0h.\r\n");
MemoryModel.SetAddressBusLength = 0;
}
