public static int AssignTypeRegister(Processor proc, ProgramReader reader) { int id = reader.NextInt(); int flag = reader.NextInt(); proc.Registers.TypeRegisters[id] = (TypeFlag)flag; return(reader.Elapsed()); }
public void Test(ProgramReader reader) { int a = reader.NextInt(); int b = reader.NextInt(); int c = reader.NextInt(); a = a + b + c; LibraryHandler.GetResource <Processor>().Registers.SetReturnCarry(a); }
public void Rand(ProgramReader reader) { int min = reader.NextInt(); int max = reader.NextInt(); min = GetRand().Next(min, max + 1); Processor.Registers.SetReturnCarry(min); }
public static int AssignConstOperationRegister(Processor proc, ProgramReader reader) { int id = reader.NextInt(); int size = reader.NextInt(); byte[] value = reader.NextArray(size); proc.Registers.OperationRegisters[id] = value; return(reader.Elapsed()); }
public static int LibCall(Processor proc, ProgramReader reader) { int size = reader.NextInt(); int libNameSize = reader.NextInt(); int fctNameSize = reader.NextInt(); byte[] lib = reader.NextArray(libNameSize); byte[] fct = reader.NextArray(fctNameSize); string l = Encoding.ASCII.GetString(lib); string f = Encoding.ASCII.GetString(fct); proc.FunctionToCall = new LibStackContainer(l, f, proc.MMU.Alloc(size)); return(reader.Elapsed()); }
public static int AssignOperationRegister(Processor proc, ProgramReader reader) { int id = reader.NextInt(); int size = reader.NextInt(); byte[] ptr = reader.NextArray(Defines.SIZE_PTR); byte[] reg = new byte[size]; MemoryReader r = MemoryReader.GetReader(id, proc, ptr, Defines.SIZE_PTR); Array.Copy(r.Data, 0, reg, 0, size); proc.Registers.OperationRegisters[id] = reg; return(reader.Elapsed()); }
public static int Cast(Processor proc, ProgramReader reader) { TypeFlag returnType = (TypeFlag)reader.NextInt(); uint addr = reader.NextPtr(); object v1 = BytesToNative(proc.Registers.TypeRegisters[0], proc.Registers.OperationRegisters[0]); byte[] b = null; switch (returnType) { case TypeFlag.Char: v1 = Conversions.ToChar(v1); break; case TypeFlag.Int: v1 = Conversions.ToInteger(v1); break; case TypeFlag.Float: v1 = Conversions.ToSingle(v1); break; } b = Convert(v1, returnType); MemoryWriter w = MemoryWriter.GetWriter(2, proc, addr); w.Write(b); return(reader.Elapsed()); }
public static int Jump(Processor proc, ProgramReader reader) { int addr = reader.NextInt(); proc.ActiveStackContainer.ProgramCounter = addr; proc.Registers.JumpCarry = true; return(0); }
public static int AssignTargetRegister(Processor proc, ProgramReader reader) { int id = reader.NextInt(); byte flag = reader.NextByte(); proc.Registers.TargetRegisters[id] = (TargetFlag)flag; return(reader.Elapsed()); }
public static int AssignConditionRegister(Processor proc, ProgramReader reader) { int id = reader.NextInt(); uint ptr = reader.NextPtr(); Array.Copy(proc.ActiveStackContainer.Memory.Memory, ptr, proc.Registers.ConditionRegisters[id], 0, Defines.SIZE_INT); return(reader.Elapsed()); }
public static int AssignReturnCarry(Processor proc, ProgramReader reader) { uint ptr = reader.NextPtr(); int size = reader.NextInt(); Array.Copy(proc.Registers.ReturnCarry, 0, proc.ActiveStackContainer.Memory.Memory, ptr, size); return(reader.Elapsed()); }
public static int SetReturnCarry(Processor proc, ProgramReader reader) { int size = reader.NextInt(); byte[] value = reader.NextArray(size); Array.Copy(value, 0, proc.Registers.ReturnCarry, 0, size); return(reader.Elapsed()); }
public static int AssignStaticConditionRegister(Processor proc, ProgramReader reader) { int id = reader.NextInt(); byte[] value = reader.NextArray(Defines.SIZE_INT); Array.Copy(value, 0, proc.Registers.ConditionRegisters[id], 0, Defines.SIZE_INT); return(reader.Elapsed()); }
public static int FunctionCall(Processor proc, ProgramReader reader) { int fctId = reader.NextInt(); int idx = proc.Functions[fctId]; int size = proc.GetFunctionStackSize(fctId); proc.FunctionToCall = new StackContainer(proc.MMU.Alloc(size), idx + Defines.SIZE_INT); return(reader.Elapsed()); }
public static int VarFctCopy(Processor proc, ProgramReader reader) { int size = reader.NextInt(); uint from = reader.NextPtr(); uint to = reader.NextPtr(); StackContainer c = proc.Stack.Peek(); Array.Copy(c.Memory.Memory, from, proc.FunctionToCall.Memory.Memory, to, size); return(reader.Elapsed()); }
public static int VarConstCopy(Processor proc, ProgramReader reader) { int size = reader.NextInt(); byte[] from = reader.NextArray(size); uint to = reader.NextPtr(); Array.Copy(from, 0, proc.FunctionToCall.Memory.Memory, to, size); return(reader.Elapsed()); }
public void ReadProgram() { int fctId = 0; while (!Reader.IsOver()) { int idx = Reader.GetCounter(); int checkIndex = Reader.GetCounter() - (Defines.SIZE_INT * (FuncsIdx.Count + 1)); if (FuncsIdx.Contains(checkIndex)) { Output.OutputFunctionStart(idx - Defines.SIZE_INT * (FuncsIdx.Count + 1), fctId++, Reader.NextInt()); } else { OPCodes.Codes code = (OPCodes.Codes)Reader.NextInt(); List <string> args = ExtractArgs(code); Output.OutputInstruction(idx - Defines.SIZE_INT * (FuncsIdx.Count + 1), code, args); } } }
public static int Set(Processor proc, ProgramReader reader) { int sourceSize = reader.NextInt(); byte[] source = reader.NextArray(sourceSize); uint dest = reader.NextPtr(); MemoryReader r = MemoryReader.GetReader(0, proc, source, sourceSize); MemoryWriter w = MemoryWriter.GetWriter(1, proc, dest); w.Write(r.Data); return(reader.Elapsed()); }
public static int AssignToPointer(Processor proc, ProgramReader reader) { uint source = reader.NextPtr(); int size = reader.NextInt(); uint dest = reader.NextPtr(); byte[] toCopy = new byte[size]; dest = proc.MMU.ReadPtr(dest); Array.Copy(proc.ActiveStackContainer.Memory.Memory, source, toCopy, 0, size); proc.MMU.WriteBytes(toCopy, dest); return(reader.Elapsed()); }
public static int If(Processor proc, ProgramReader reader) { ConditionFlag flag = (ConditionFlag)reader.NextInt(); uint address = reader.NextPtr(); int a = BitConverter.ToInt32(proc.Registers.ConditionRegisters[0]); int b = BitConverter.ToInt32(proc.Registers.ConditionRegisters[1]); bool result = ConditionChecker(flag, a, b); if (result) { proc.ActiveStackContainer.ProgramCounter = (int)address; proc.Registers.JumpCarry = true; return(0); } return(reader.Elapsed()); }
public static int AssignStatic(Processor proc, ProgramReader reader) { uint ptr = reader.NextPtr(); int size = reader.NextInt(); byte[] toCopy = reader.NextArray(size); if (proc.Registers.PtrCarry) { int a = BitConverter.ToInt32(toCopy) + proc.ActiveStackContainer.Memory.Start; toCopy = BitConverter.GetBytes(a); proc.Registers.PtrCarry = false; } Array.Copy(toCopy, 0, proc.ActiveStackContainer.Memory.Memory, ptr, size); return(reader.Elapsed()); }
public void FormatString(ProgramReader reader) { Pointer ptr = new Pointer(Processor.MMU) { Value = reader.NextPtr() }; string str = ptr.GetString(); Regex r = new Regex(@"\{%[d,s,f]}"); MatchCollection matches = r.Matches(str); foreach (Match match in matches) { object obj = null; if (match.Value == "{%d}") { obj = reader.NextInt(); } if (match.Value == "{%f}") { obj = reader.NextFloat(); } if (match.Value == "{%s}") { obj = new Pointer(Processor.MMU) { Value = reader.NextPtr() }.GetString(); } str = ReplaceFirst(str, match.Value, obj.ToString()); } RangeContainer c = Processor.MMU.Alloc(str.Length + 1); c.Write(str); Processor.Registers.SetReturnCarry(c.Start); }