public async Task ModifyMemory(Command cmd, string name, Memory data = null) {
var list = CSDK.Game.Converter.ConvertMemory(memory);
await Task.Delay (1);
for (int i = 0; i < list.Count; ++i) {
if (cmd != Command.Retrieve && data == null)
break;
if (list [i].Value.Key != name)
continue;
Guid guid = list [i].Key;
switch (cmd) {
case Command.Add:
memory.Add (Guid.NewGuid(), new KeyValuePair<string, Memory> (name, data));
break;
case Command.Remove:
memory.Remove(guid);
break;
case Command.Replace:
memory[guid] = new KeyValuePair<string, Memory> (name, data);
break;
case Command.Retrieve:
data = memory [guid].Value;
break;
default:
break;
}
}
}
public SuiteRunner(Memory memory, ProgressReporter theReporter, Func<Memory, CellProcessor> newService)
{
TestCounts = new TestCounts();
myReporter = theReporter;
this.memory = memory;
this.newService = newService;
}
public TelegramService(string token, string applicationDirectory)
{
Telegram_token = token;
SetUp("https://api.telegram.org/bot" + Telegram_token);
mem = new Memory(applicationDirectory);
ReadStoredUsernames();
}
public override void DecodeArguments(Memory.MemoryBin bin, ref InstructionDecodeContext context, ref int offset, ref InstructionReference instructionReference)
{
if (decodeArgumentsFunction != null)
{
decodeArgumentsFunction(this, bin, ref context, ref offset, ref instructionReference.param1, ref instructionReference.param2);
}
}
public GPU(string _Name, string _Valmistaja, int _CC, int _MC, int _Memory)
{
Name = _Name;
Valmistaja = _Valmistaja;
CC = _CC;
Mem = new Memory(_MC, _Memory);
}
/// <summary>
/// Initializes a new instance of the <see cref="MemorySecret"/> class with
/// the specified values.
/// </summary>
/// <param name="game">The game.</param>
/// <param name="gameId">The game id.</param>
/// <param name="memory">The memory.</param>
/// <param name="isReturnSecret">if set to <c>true</c> is return secret.</param>
public MemorySecret(Game game, short gameId, Memory memory, bool isReturnSecret)
{
GameID = gameId;
TargetGame = game;
Memory = memory;
IsReturnSecret = isReturnSecret;
}
[SetUp] public void SetUp() {
memory = new TypeDictionary();
memory.GetItem<Settings>().InputFolder = "in";
memory.GetItem<Settings>().OutputFolder = "out";
folders = new FolderTestModel();
}
/// <summary>
/// Parses the script into statements and expressions.
/// </summary>
/// <param name="script">Script text</param>
/// <param name="memory">Memory scope object</param>
public List<Expr> Parse(string script, Memory memory = null)
{
Init(script, memory);
while (true)
{
if (_tokenIt.NextToken.Token == Tokens.EndToken)
break;
if (_tokenIt.NextToken.Token != Tokens.NewLine)
{
// Get next statement.
var stmt = ParseStatement();
if (stmt != null)
{
// Limit case:
_context.Limits.CheckParserStatement(stmt);
// Add to list of statements.
_statements.Add(stmt);
}
}
else
_tokenIt.Advance();
}
return _statements;
}
public override void DecodeArguments(Memory.MemoryBin bin, ref InstructionDecodeContext context, ref int offset, ref InstructionReference instructionReference)
{
switch (AddrMode)
{
case AddressingModes.ImpliedAccumulator:
{
break;
}
case AddressingModes.Absolute:
case AddressingModes.AbsoluteIndexedX:
{
instructionReference.param1 = DecodeInt2Argument(bin, ref offset);
break;
}
case AddressingModes.Direct:
case AddressingModes.DirectIndexedX:
{
instructionReference.param1 = DecodeInt1Argument(bin, ref offset);
break;
}
default:
{
throw new InvalidOperationException("Addressing mode unknown for instruction ASL");
}
}
}
public StoryTestFolder(Memory memory, string theInputPath, string theOutputPath, string theSelection, FolderModel theFolderModel, StoryTestFolder theParentFolder) {
this.memory = memory;
Name = theInputPath;
OutputPath = theOutputPath;
myFolderModel = theFolderModel;
myParent = theParentFolder;
mySelection = theSelection;
}
public QAcidState(QAcidRunner<Unit> runner)
{
Runner = runner;
Runs = new List<int>();
Memory = new Memory(this);
TempMemory = new TempMemory();
Shrunk = new Memory(this);
}
int Run(Memory memory, IList<string> arguments)
{
ParseArguments(memory, arguments);
myRunner = new SuiteRunner(memory, myProgressReporter);
myRunner.Run(
CreateStoryTestFolder(memory),
selectedFile);
return myRunner.TestCounts.FailCount;
}
internal MemoryHandler(GameBoy gameboy)
{
this.gameboy = gameboy;
this.memory = (Memory)gameboy.Memory;
this.cartridge = (Cartridge.Cartridge)gameboy.Cartridge;
this.cpu = (CPU)gameboy.CPU;
this.display = (Display)gameboy.Display;
this.apu = (APU)gameboy.APU;
}
static void Main(string[] args)
{
var procs = Process.GetProcessesByName("SC2");
Memory mem = new Memory(procs[0]);
mem.DesiredAccess = Memory.VmRead;
Playertest.TestIt(mem);
}
StoryTestFolder CreateStoryTestFolder(Memory memory, FolderModel folderModel) {
var storyTestFolder = new StoryTestFolder(memory, folderModel);
string tagList = memory.GetItem<Settings>().TagList;
if (!string.IsNullOrEmpty(tagList))
storyTestFolder.AddPageFilter(new TagFilter(tagList));
return storyTestFolder;
}
public int Run(IList<string> commandLineArguments, Memory memory, ProgressReporter reporter) {
var now = DateTime.Now;
myProgressReporter = reporter;
var result = Run(memory, commandLineArguments);
//todo: to suiterunner?
if (!memory.GetItem<Settings>().DryRun)
reporter.Write(string.Format("\n{0}, time: {1}\n", Results, DateTime.Now - now));
return result;
}
StoryTestFolder CreateStoryTestFolder(Memory memory)
{
var storyTestFolder = new StoryTestFolder(memory, new FileSystemModel(memory.GetItem<Settings>().CodePageNumber));
string tagList = memory.GetItem<Settings>().TagList;
if (!string.IsNullOrEmpty(tagList))
storyTestFolder.AddPageFilter(new TagFilter(tagList));
return storyTestFolder;
}
public void Execute(ExecutionNodes nodes, ref Memory memory)
{
ExecutionNode en;
if (nodes.TryGetValue(Label, out en) == false)
{
throw new ArgumentException("Jump: Label " + Label + " does not exist.");
}
en.Execute(nodes, ref memory);
}
public Device(IModeling modeling)
{
this.memories = new List<Memory>();
this.currentMemory = new Memory();
this.Modeling = modeling;
this.Queue = new Queue(modeling);
this.Reset();
this.OnRelease += Device_OnRelease;
}
public Debugger(AsyncTaskRunner asyncTaskRunner) {
Dispatch.AsyncTaskRunner = asyncTaskRunner;
this.BreakpointList = new BreakpointList(this);
this.Memory = new Memory(this);
this.ModuleList = new ModuleList(this);
this.ThreadList = new ThreadList(this);
this.CurrentContext = new Context(this);
}
/// <summary>
/// Initializes the parser with the script and setups various components.
/// </summary>
/// <param name="script"></param>
/// <param name="memory"></param>
public override void Init(string script, Memory memory)
{
// 1. Initalize data members
base.Init(script, memory);
// 3. Convert script to sequence of tokens.
Tokenize();
// 4. Move to first token
_tokenIt.Advance();
}
public int Run(IList<string> arguments, Memory memory, ProgressReporter reporter)
{
LastArguments = arguments;
ApartmentState = Thread.CurrentThread.GetApartmentState();
try {
return int.Parse(ConfigurationManager.AppSettings.Get("returnCode"));
}
catch (Exception) {
return Result;
}
}
public static VAL functions(string func, VAL parameters, Memory DS)
{
if (func != "devalize" && parameters.Size != 2)
return null;
var L0 = parameters[0];
var L1 = parameters[1];
Valizer.Devalize(L0, L1.Value);
return L1;
}
int Run(Memory memory, IList<string> arguments) {
ParseArguments(memory, arguments);
var fileSystem = new FileSystemModel(memory.GetItem<Settings>().CodePageNumber);
memory.GetItem<Context>().PageSource = fileSystem;
memory.GetItem<Context>().SuitePath = new DirectoryPath(memory.GetItem<Settings>().InputFolder);
myRunner = new SuiteRunner(memory, myProgressReporter);
myRunner.Run(
CreateStoryTestFolder(memory, fileSystem),
selectedFile);
return myRunner.TestCounts.FailCount;
}
public void TestDisassembler()
{
var Memory = new Memory();
Memory.WriteBytes(0, new byte[] { 0xAF, 0x21, 0xFF, 0xDF, 0x0E, 0x10, 0x06, 0x00, 0x32, 0x05, 0x20, 0xFC, 0x0D, 0x20, 0xF9, 0x3E });
var Z80Disassembler = new Z80Disassembler(Memory);
Z80Disassembler.Address = 0;
for (int n = 0; n < 7; n++)
{
Console.WriteLine("{0:X4}: {1}", Z80Disassembler.Address, Z80Disassembler.DecodeNext());
}
}
protected void InsertActionIntoDMAQueueAndStopExecution(Process.IProcess myProcess, Memory.DMARequest.MemoryAction action)
{
var request = new Memory.DMARequest()
{
MyProcess = myProcess,
MemoryWork = action
};
myProcess.ContinueCalculating = false;
myProcess.PCB.ProcessRegisters.ProgramCounter += 1;
Sys.System.DMA.InsertRequestInQueue(request);
}
public OptimalSimulator(string path, int memSize)
{
Memory = new Memory(memSize);
_framesList = new List<int>();
var frames = File.ReadAllLines(path);
foreach (var frame in frames) {
var frameToConvert = frame.Split(null)[0].Substring(0,5);
var frameAsInt = Convert.ToInt32(frameToConvert, 16);
_framesList.Add(frameAsInt);
}
PageFaults = PageHits = 0;
}
public _Blob(Server.Script.Api api, Memory memory)
{
Api = api;
World = api.World;
Memory = memory;
Timer = new System.Timers.Timer()
{
AutoReset = true,
Enabled = false,
Interval = 1000,
//Todo: Timer.SynchronizingObject
};
}
/// <summary>
/// Initialize
/// </summary>
public Interpreter()
{
_settings = new LangSettings();
// Initialzie the context.
_context = new Context();
_context.Settings = _settings;
_context.Limits.Init();
_memory = _context.Memory;
_parser = new Parser(_context);
_parser.Settings = _settings;
InitSystemFunctions();
}
/// <summary>
/// Initializes the parser with the script and setups various components.
/// </summary>
/// <param name="script"></param>
/// <param name="memory"></param>
public override void Init(string script, Memory memory)
{
// 1. Initalize data members
base.Init(script, memory);
// 2. Convert script to sequence of tokens.
Tokenize();
SetupTokenIteratorReferences(this._tokenIt);
// 3. Move to first token
_tokenIt.Advance();
// 4. Setup expr builder
Exprs.Setup(_tokenIt, _context, _scriptPath);
}
