private void Execute(string[] args)
{
var realMode = args.Length == 1 && (args[0].Equals("-realmode") || args[0].Equals("-real"));
if (realMode)
{
memoryCore = realModeMemoryCore = new RealModeMemoryCore(logger: null);
}
else
{
memoryCore = protectedModeMemoryCore = new ProtectedModeMemoryCore(null);
}
mbbsEmuCpuCore = new CpuCore(logger: null);
mbbsEmuCpuRegisters = (ICpuRegisters)mbbsEmuCpuCore;
mbbsEmuCpuCore.Reset(memoryCore, null, null, null);
// Reset
mbbsEmuCpuRegisters.Zero();
mbbsEmuCpuCore.Reset();
memoryCore.Clear();
mbbsEmuCpuCore.Registers.CS = 0x1000;
mbbsEmuCpuCore.Registers.DS = 2;
mbbsEmuCpuCore.Registers.IP = 0;
var instructions = new Assembler(16);
var label_start = instructions.CreateLabel();
var label_loop = instructions.CreateLabel();
instructions.Label(ref label_start);
instructions.mov(__word_ptr[0], 1);
instructions.Label(ref label_loop);
instructions.mov(ax, __word_ptr[0]);
instructions.cmp(ax, 0x7FFF);
instructions.je(label_start);
instructions.inc(__word_ptr[0]);
instructions.jmp(label_loop);
CreateCodeSegment(instructions);
CreateDataSegment(new ReadOnlySpan <byte>());
_isRunning = true;
new Thread(RunThread).Start();
new Thread(MonitorThread).Start();
Console.ReadKey();
_isRunning = false;
}
public void EndOfSegmentString()
{
ushort segment = 1;
var memoryCore = new ProtectedModeMemoryCore(_logger);
memoryCore.AddSegment(segment);
var testString = new string('X', 5) + "\0";
var testStringOffset = (ushort)(ushort.MaxValue - testString.Length + 1);
(memoryCore as IMemoryCore).SetArray(1, testStringOffset, Encoding.ASCII.GetBytes(testString));
var stringFromMemory = Encoding.ASCII.GetString((memoryCore as IMemoryCore).GetString(1, testStringOffset, stripNull: false));
stringFromMemory.Should().Be(testString);
}
protected ExportedModuleTestBase(string modulePath)
{
_serviceResolver = new ServiceResolver(fakeClock, SessionBuilder.ForTest($"MBBSDb_{RANDOM.Next()}"));
var textVariableService = _serviceResolver.GetService <ITextVariableService>();
mbbsEmuMemoryCore = mbbsEmuProtectedModeMemoryCore = new ProtectedModeMemoryCore(_serviceResolver.GetService <ILogger>());
mbbsEmuCpuCore = new CpuCore(_serviceResolver.GetService <ILogger>());
mbbsEmuCpuRegisters = mbbsEmuCpuCore;
var testModuleConfig = new ModuleConfiguration {
ModulePath = modulePath, ModuleEnabled = true
};
mbbsModule = new MbbsModule(FileUtility.CreateForTest(), fakeClock, _serviceResolver.GetService <ILogger>(), testModuleConfig, mbbsEmuProtectedModeMemoryCore);
testSessions = new PointerDictionary <SessionBase>();
testSessions.Allocate(new TestSession(null, textVariableService));
testSessions.Allocate(new TestSession(null, textVariableService));
majorbbs = new HostProcess.ExportedModules.Majorbbs(
_serviceResolver.GetService <IClock>(),
_serviceResolver.GetService <ILogger>(),
_serviceResolver.GetService <AppSettings>(),
_serviceResolver.GetService <IFileUtility>(),
_serviceResolver.GetService <IGlobalCache>(),
mbbsModule,
testSessions,
_serviceResolver.GetService <IAccountKeyRepository>(),
_serviceResolver.GetService <IAccountRepository>(),
textVariableService);
galgsbl = new HostProcess.ExportedModules.Galgsbl(
_serviceResolver.GetService <IClock>(),
_serviceResolver.GetService <ILogger>(),
_serviceResolver.GetService <AppSettings>(),
_serviceResolver.GetService <IFileUtility>(),
_serviceResolver.GetService <IGlobalCache>(),
mbbsModule,
testSessions,
textVariableService);
mbbsEmuCpuCore.Reset(
mbbsEmuMemoryCore,
(ordinal, functionOrdinal) => ExportedFunctionDelegate(ordinal, functionOrdinal, offsetsOnly: false),
null,
null);
}
public void MultiSegmentAllocation()
{
var memoryCore = new ProtectedModeMemoryCore(_logger);
var data1 = memoryCore.Malloc(0xFF00);
data1.Should().NotBeNull();
var data2 = memoryCore.Malloc(0xFF00);
data2.Should().NotBeNull();
data2.Segment.Should().NotBe(data1.Segment);
var data3 = memoryCore.Malloc(0xFF00);
data3.Should().NotBeNull();
data3.Segment.Should().NotBe(data2.Segment);
data3.Segment.Should().NotBe(data1.Segment);
}
protected CpuTestBase()
{
mbbsEmuMemoryCore = mbbsEmuProtectedModeMemoryCore = new ProtectedModeMemoryCore(logger: null);
mbbsEmuCpuCore = new CpuCore(logger: null);
mbbsEmuCpuRegisters = mbbsEmuCpuCore;
pit = new ProgrammableIntervalTimer(logger: null, fakeClock, mbbsEmuCpuCore);
mbbsEmuCpuCore.Reset(
mbbsEmuMemoryCore,
null,
null,
new Dictionary <int, IIOPort>
{
{ 0x40, pit },
{ 0x41, pit },
{ 0x42, pit },
{ 0x43, pit },
});
}
/// <summary>
/// Constructor for MbbsModule
///
/// Pass in an empty/blank moduleIdentifier for a Unit Test/Fake Module
/// </summary>
/// <param name="fileUtility"></param>
/// <param name="clock"></param>
/// <param name="logger"></param>
/// <param name="moduleConfig"></param>
/// <param name="memoryCore"></param>
public MbbsModule(IFileUtility fileUtility, IClock clock, ILogger logger, ModuleConfiguration moduleConfig, ProtectedModeMemoryCore memoryCore = null)
{
_fileUtility = fileUtility;
_logger = logger;
_clock = clock;
ModuleConfig = moduleConfig;
ModuleIdentifier = moduleConfig.ModuleIdentifier;
ModuleDlls = new List <MbbsDll>();
//Sanitize and setup Path
if (string.IsNullOrEmpty(moduleConfig.ModulePath))
{
moduleConfig.ModulePath = Directory.GetCurrentDirectory();
}
if (!Path.EndsInDirectorySeparator(moduleConfig.ModulePath))
{
moduleConfig.ModulePath += Path.DirectorySeparatorChar;
}
ModulePath = moduleConfig.ModulePath;
// will be null in tests
if (string.IsNullOrEmpty(ModuleIdentifier))
{
Mdf = MdfFile.createForTest();
ModuleDlls.Add(new MbbsDll(fileUtility, logger)
{
File = NEFile.createForTest()
});
}
else
{
//Verify Module Path Exists
if (!Directory.Exists(ModulePath))
{
_logger.Error($"Unable to find the specified directory for the module {ModuleIdentifier.ToUpper()}: {ModulePath}");
_logger.Error("Please verify your Command Line Argument or the path specified in your Module JSON File and try again.");
throw new DirectoryNotFoundException($"Unable to locate {ModulePath}");
}
//Verify MDF File Exists
var mdfFile = fileUtility.FindFile(ModulePath, $"{ModuleIdentifier}.MDF");
var fullMdfFilePath = Path.Combine(ModulePath, mdfFile);
if (!File.Exists(fullMdfFilePath))
{
_logger.Error($"Unable to locate {fullMdfFilePath}");
_logger.Error($"Please verify your Command Line Argument or the Module JSON File to ensure {ModuleIdentifier} is the correct Module Identifier and that the Module is installed properly.");
throw new FileNotFoundException($"Unable to locate Module: {fullMdfFilePath}");
}
Mdf = new MdfFile(fullMdfFilePath);
LoadModuleDll(Mdf.DLLFiles[0].Trim());
if (Mdf.MSGFiles.Count > 0)
{
Msgs = new List <MsgFile>(Mdf.MSGFiles.Count);
foreach (var m in Mdf.MSGFiles)
{
Msgs.Add(new MsgFile(_fileUtility, ModulePath, m));
}
}
}
//Set Initial Values
RtkickRoutines = new PointerDictionary <RealTimeRoutine>();
RtihdlrRoutines = new PointerDictionary <RealTimeRoutine>();
TaskRoutines = new PointerDictionary <RealTimeRoutine>();
GlobalCommandHandlers = new List <FarPtr>();
ExportedModuleDictionary = new Dictionary <ushort, IExportedModule>(6);
ExecutionUnits = new Queue <ExecutionUnit>(2);
Memory = memoryCore ?? new ProtectedModeMemoryCore(logger);
ProtectedMemory = (ProtectedModeMemoryCore)Memory;
//Declare PSP Segment
var psp = new PSPStruct {
NextSegOffset = 0x9FFF, EnvSeg = 0xFFFF
};
ProtectedMemory.AddSegment(0x4000);
Memory.SetArray(0x4000, 0, psp.Data);
Memory.AllocateVariable("Int21h-PSP", sizeof(ushort));
Memory.SetWord("Int21h-PSP", 0x4000);
//Find _INIT_ values if any
foreach (var dll in ModuleDlls)
{
//If it's a Test, setup a fake _INIT_
if (string.IsNullOrEmpty(ModuleIdentifier))
{
dll.EntryPoints["_INIT_"] = null;
return;
}
//Setup _INIT_ Entrypoint
FarPtr initEntryPointPointer;
var initResidentName = dll.File.ResidentNameTable.FirstOrDefault(x => x.Name.StartsWith("_INIT__"));
if (initResidentName == null)
{
//This only happens with MajorMUD -- I have no idea why it's a special little snowflake ¯\_(ツ)_/¯
_logger.Warn($"({moduleConfig.ModuleIdentifier}) Unable to locate _INIT_ in Resident Name Table, checking Non-Resident Name Table...");
var initNonResidentName = dll.File.NonResidentNameTable.FirstOrDefault(x => x.Name.StartsWith("_INIT__"));
if (initNonResidentName == null)
{
_logger.Error($"Unable to locate _INIT__ entry in Resident Name Table for {dll.File.FileName}");
continue;
}
var initEntryPoint = dll.File.EntryTable.First(x => x.Ordinal == initNonResidentName.IndexIntoEntryTable);
initEntryPointPointer = new FarPtr((ushort)(initEntryPoint.SegmentNumber + dll.SegmentOffset), initEntryPoint.Offset);
}
else
{
var initEntryPoint = dll.File.EntryTable.First(x => x.Ordinal == initResidentName.IndexIntoEntryTable);
initEntryPointPointer = new FarPtr((ushort)(initEntryPoint.SegmentNumber + dll.SegmentOffset), initEntryPoint.Offset);
}
_logger.Debug($"({ModuleIdentifier}) Located _INIT__: {initEntryPointPointer}");
dll.EntryPoints["_INIT_"] = initEntryPointPointer;
}
}
