public static long IntValue(Mem mem) { Debug.Assert(mem.Ctx == null || MutexEx.Held(mem.Ctx.Mutex)); // assert( EIGHT_BYTE_ALIGNMENT(pMem) ); MEM flags = mem.Flags; if ((flags & MEM.Int) != 0) { return(mem.u.I); } else if ((flags & MEM.Real) != 0) { return(DoubleToInt64(mem.R)); } else if ((flags & (MEM.Str)) != 0) { Debug.Assert(mem.Z != null || mem.N == 0); C.ASSERTCOVERAGE(mem.Z == null); long value; ConvertEx.Atoi64(mem.Z, out value, mem.N, mem.Encode); return(value); } else if ((flags & (MEM.Blob)) != 0) { Debug.Assert(mem.Z_ != null || mem.N == 0); C.ASSERTCOVERAGE(mem.Z_ == null); long value; ConvertEx.Atoi64(Encoding.UTF8.GetString(mem.Z_, 0, mem.N), out value, mem.N, mem.Encode); return(value); } return(0); }
private static void STA_ZP(CPU cpu, MEM memory) { byte data1 = memory.getMem((ushort)(cpu.PC + 0x0001)); byte data2 = memory.getMem((ushort)(cpu.PC + 0x0002)); memory.setMem(data1, data2, cpu.A); cpu.PC += 3; }
private static void JMP_ABS(CPU cpu, MEM memory) { byte data1 = memory.getMem((ushort)(cpu.PC + 0x0001)); byte data2 = memory.getMem((ushort)(cpu.PC + 0x0002)); cpu.PC = (ushort)(data1 << 8); cpu.PC += data2; }
private void updateAll() { //IF.GetComponent<IFBehavior>().UpdateMe(); ID.GetComponent <IDBehavior>().UpdateMe(); EX.GetComponent <EXBehavior>().UpdateMe(); MEM.GetComponent <MEMBehavior>().UpdateMe(); WB.GetComponent <WBBehavior>().UpdateMe(); }
private static void LDA_IM(CPU cpu, MEM memory) { byte data1 = memory.getMem((ushort)(cpu.PC + 0x0001)); cpu.A = data1; cpu.Z = (data1 == 0x00); cpu.N = (data1 & 0x80) == 0x80; cpu.PC += 0x02; }
public static RC MemStringify(Mem mem, TEXTENCODE encode) { MEM f = mem.Flags; Debug.Assert(mem.Ctx == null || MutexEx.Held(mem.Ctx.Mutex)); Debug.Assert((f & MEM.Zero) == 0); Debug.Assert((f & (MEM.Str | MEM.Blob)) == 0); Debug.Assert((f & (MEM.Int | MEM.Real)) != 0); Debug.Assert((mem.Flags & MEM.RowSet) == 0); //: Debug.Assert(C._HASALIGNMENT8(mem)); const int bytes = 32; if (MemGrow(mem, bytes, false) != 0) { return(RC.NOMEM); } // For a Real or Integer, use sqlite3_mprintf() to produce the UTF-8 string representation of the value. Then, if the required encoding // is UTF-16le or UTF-16be do a translation. // FIX ME: It would be better if sqlite3_snprintf() could do UTF-16. if ((f & MEM.Int) != 0) { mem.Z = mem.u.I.ToString(); //: __snprintf(mem->Z, bytes, "%lld", mem->u.I); } else { Debug.Assert((f & MEM.Real) != 0); if (double.IsNegativeInfinity(mem.R)) { mem.Z = "-Inf"; } else if (double.IsInfinity(mem.R)) { mem.Z = "Inf"; } else if (double.IsPositiveInfinity(mem.R)) { mem.Z = "+Inf"; } else if (mem.R.ToString(CultureInfo.InvariantCulture).Contains(".")) { mem.Z = mem.R.ToString(CultureInfo.InvariantCulture).ToLower(); //: __snprintf(mem->Z, bytes, "%!.15g", mem->R); } else { mem.Z = mem.R.ToString(CultureInfo.InvariantCulture) + ".0"; } } mem.N = mem.Z.Length; mem.Encode = TEXTENCODE.UTF8; mem.Flags |= MEM.Str | MEM.Term; ChangeEncoding(mem, encode); return(RC.OK); }
void Update() { if (MEM.GetIsMovieEvent()) { return; } GetInputKey(); // ① 入力を取得 ChangeState(); // ② 状態を変更する ChangeAnimation(); // ③ 状態に応じてアニメーションを変更する Move(); // ④ 入力に応じて移動する }
private static void INC_ZP(CPU cpu, MEM memory) { byte data1 = memory.getMem((ushort)(cpu.PC + 0x0001)); byte data2 = memory.getMem((ushort)(cpu.PC + 0x0002)); byte x = memory.getMem(data1, data2); x++; memory.setMem(data1, data2, x); cpu.Z = (x == 0x00); cpu.N = (x & 0x80) == 0x80; cpu.PC += 3; }
public static RC MemSetStr(Mem mem, byte[] z, int offset, int n, TEXTENCODE encode, Action <object> del) { Debug.Assert(mem.Ctx == null || MutexEx.Held(mem.Ctx.Mutex)); Debug.Assert((mem.Flags & MEM.RowSet) == 0); // If z is a NULL pointer, set pMem to contain an SQL NULL. if (z == null || z.Length < offset) { MemSetNull(mem); return(RC.OK); } int limit = (mem.Ctx != null ? mem.Ctx.Limits[(int)LIMIT.LENGTH] : CORE_MAX_LENGTH); // Maximum allowed string or blob size MEM flags = (encode == 0 ? MEM.Blob : MEM.Str); // New value for pMem->flags int bytes = n; // New value for pMem->n if (bytes < 0) { Debug.Assert(encode != 0); if (encode == TEXTENCODE.UTF8) { for (bytes = 0; bytes <= limit && bytes < z.Length - offset && z[offset + bytes] != 0; bytes++) { } } else { for (bytes = 0; bytes <= limit && z[bytes + offset] != 0 || z[offset + bytes + 1] != 0; bytes += 2) { } } } // The following block sets the new values of Mem.z and Mem.xDel. It also sets a flag in local variable "flags" to indicate the memory // management (one of MEM_Dyn or MEM_Static). Debug.Assert(encode == 0); { mem.Z = null; mem.Z_ = C._alloc(n); Buffer.BlockCopy(z, offset, mem.Z_, 0, n); } mem.N = bytes; mem.Flags = MEM.Blob | MEM.Term; mem.Encode = (encode == 0 ? TEXTENCODE.UTF8 : encode); mem.Type = (encode == 0 ? TYPE.BLOB : TYPE.TEXT); #if !OMIT_UTF16 if (mem.Encode != TEXTENCODE.UTF8 && MemHandleBom(mem) != 0) { return(RC.NOMEM); } #endif return(bytes > limit ? RC.TOOBIG : RC.OK); }
public static void execute(CPU cpu, MEM memory) { switch (memory.getMem(cpu.PC)) { case 0x4C: JMP.JMP_ABS(cpu, memory); return; case 0x6C: JMP.JMP_INDIRECT(cpu, memory); return; } }
//: #define MEMCELLSIZE (size_t)(&(((Mem *)0)->Malloc)) // Size of struct Mem not including the Mem.zMalloc member. public static void MemShallowCopy(Mem to, Mem from, MEM srcType) { Debug.Assert((from.Flags & MEM.RowSet) == 0); MemReleaseExternal(to); from._memcpy(ref to); to.Del = null; if ((from.Flags & MEM.Static) != 0) { to.Flags &= ~(MEM.Dyn | MEM.Static | MEM.Ephem); Debug.Assert(srcType == MEM.Ephem || srcType == MEM.Static); to.Flags |= srcType; } }
private static void JMP_INDIRECT(CPU cpu, MEM memory) { byte data1 = memory.getMem((ushort)(cpu.PC + 0x0001)); byte data2 = memory.getMem((ushort)(cpu.PC + 0x0002)); ushort address = (ushort)(data1 << 8); address += data2; byte jumpToH = memory.getMem(address); byte jumpToL = memory.getMem((ushort)(address + 0x0001)); cpu.PC = (ushort)(jumpToH << 8); cpu.PC += jumpToL; }
public static void execute(CPU cpu, MEM memory) { switch (memory.getMem(cpu.PC)) { case 0xE6: case 0xEE: INC.INC_ZP(cpu, memory); return; case 0xF6: case 0xFE: return; } }
public static void execute(CPU cpu, MEM memory) { switch (memory.getMem(cpu.PC)) { case 0x85: STA.STA_ZP(cpu, memory); return; case 0x95: case 0x8D: case 0x9D: case 0x99: case 0x81: case 0x91: return; } }
public static void execute(CPU cpu, MEM memory) { switch (memory.getMem(cpu.PC)) { case 0xA9: LDA.LDA_IM(cpu, memory); return; case 0xA5: case 0xB5: case 0xAD: case 0xBD: case 0xB9: case 0xA1: case 0xB1: return; } }
public void oneRight() { if (WB.GetComponent <WBBehavior>().oper != null) { doneOp.Push(WB.GetComponent <WBBehavior>().oper); } WB.GetComponent <WBBehavior>().oper = MEM.GetComponent <MEMBehavior>().oper; MEM_WB.GetComponent <MEM_WBBehavior>().oper = MEM.GetComponent <MEMBehavior>().oper; MEM.GetComponent <MEMBehavior>().oper = EX.GetComponent <EXBehavior>().oper; EX_MEM.GetComponent <EX_MEMBehavior>().oper = EX.GetComponent <EXBehavior>().oper; EX.GetComponent <EXBehavior>().oper = ID.GetComponent <IDBehavior>().oper; ID_EX.GetComponent <ID_EXBehavior>().oper = ID.GetComponent <IDBehavior>().oper; ID.GetComponent <IDBehavior>().oper = IF.GetComponent <IFBehavior>().oper; IF_ID.GetComponent <IF_IDBehavior>().oper = IF.GetComponent <IFBehavior>().oper; IF.GetComponent <IFBehavior>().oper = null; updateAll(); }
public Mem(sqlite3 db, string z, double r, int i, int n, MEM flags, byte type, byte enc #if DEBUG , Mem pScopyFrom, object pFiller #endif ) { this.db = db; this.z = z; this.r = r; this.u.i = i; this.n = n; this.flags = flags; #if DEBUG this.pScopyFrom = pScopyFrom; this.pFiller = pFiller; #endif this.type = type; this.enc = enc; }
protected virtual void Dispose(bool disposing) { if (disposed) { return; } if (disposing) { CPU.Dispose(); MEM.Dispose(); NVM.Dispose(); CPU = null; MEM = null; NVM = null; disposed = true; } }
Temp.Temp TranslateExpr(MEM expr) { Temp.Temp result = new Temp.Temp(); Temp.Temp mem; int offset; if (expr.Exp is BINOP && (expr.Exp as BINOP).Right is CONST) { mem = TranslateExpr((expr.Exp as BINOP).Left); offset = ((expr.Exp as BINOP).Right as CONST).Value; } else { mem = TranslateExpr(expr.Exp); offset = 0; } InstrList.Add(new Load(mem, offset, result)); return(result); }
public Mem(Context db, string z, double r, int i, int n, MEM flags, TYPE type, TEXTENCODE encode #if DEBUG , Mem scopyFrom, object filler #endif ) { Ctx = db; Z = z; R = r; u.I = i; N = n; Flags = flags; #if DEBUG ScopyFrom = scopyFrom; Filler = filler; #endif Type = type; Encode = encode; }
public EmuGB(ConfigsGB aConfigs) { m_configs = aConfigs; m_cpu = new CPU(); m_ppu = new PPU(); m_apu = new APU(); m_mem = new MEM(); m_dmaController = new DMAController(); m_timerController = new TimerController(); m_joypad = new Joypad(); m_serialIO = new SerialIO(); // Start paused m_paused = true; // Temp binding DrawDisplay = (aPPU) => { }; DrawDisplayLine = (aPPU, aScanline) => { }; m_mem.AttachCPU(m_cpu); m_mem.AttachPPU(m_ppu); m_mem.AttachAPU(m_apu); m_mem.AttachDMAController(m_dmaController); m_mem.AttachTimerController(m_timerController); m_mem.AttachJoypad(m_joypad); m_mem.AttachSerialIO(m_serialIO); m_cpu.ProcessorState.BindCyclesStep(m_ppu.CyclesStep); m_cpu.ProcessorState.BindCyclesStep(m_apu.CyclesStep); m_cpu.ProcessorState.BindCyclesStep(m_dmaController.CyclesStep); m_cpu.ProcessorState.BindCyclesStep(m_timerController.CyclesStep); m_cpu.ProcessorState.BindCyclesStep(m_serialIO.CyclesStep); m_ppu.BindRequestIRQ(m_cpu.RequestIRQ); m_timerController.BindRequestIRQ(m_cpu.RequestIRQ); m_joypad.BindRequestIRQ(m_cpu.RequestIRQ); m_serialIO.BindRequestIRQ(m_cpu.RequestIRQ); //m_ppu.BindDrawDisplayLine(DrawDisplayLine); }
public GBA(ushort[] display) { this.cpu = new ARM7TDMI(this, this.EventQueue); this.IO = this.cpu.IO; this.mem = this.cpu.mem; this.bus = this.cpu.bus; this.apu = new APU(this.cpu, this.EventQueue); this.ppu = new PPU(this, display, this.IO); this.mem.Init(this.ppu); this.IO.Init(this.ppu, this.bus); this.IO.Layout(this.cpu, this.apu); // this.mem.UseNormattsBIOS(); this.display = display; #if THREADED_RENDERING this.RenderThread = new Thread(() => ppu.Mainloop()); #endif }
private static bool CheckMemType(MEM actualType, MemType flags) { switch (actualType) { case MEM.PRIVATE: return((flags & MemType.Private) != 0); case MEM.IMAGE: return((flags & MemType.Image) != 0); case MEM.MAPPED: return((flags & MemType.Mapped) != 0); default: if (flags == MemType.All) { return(true); } throw new InvalidOperationException("Unknown/Bogus Memory Type!"); } }
public static RC MemMakeWriteable(Mem mem) { Debug.Assert(mem.Ctx == null || MutexEx.Held(mem.Ctx.Mutex)); Debug.Assert((mem.Flags & MEM.RowSet) == 0); E.ExpandBlob(mem); MEM f = mem.Flags; if ((f & (MEM.Str | MEM.Blob)) != 0) //: mem->Z != mem->Malloc) { if (MemGrow(mem, mem.N + 2, true) != 0) { return(RC.NOMEM); } //: mem.Z[mem.N] = 0; //: mem.Z[mem.N + 1] = 0; mem.Flags |= MEM.Term; #if DEBUG mem.ScopyFrom = null; #endif } return(RC.OK); }
public void oneLeft() { IF.GetComponent <IFBehavior>().oper = ID.GetComponent <IDBehavior>().oper; ID.GetComponent <IDBehavior>().oper = EX.GetComponent <EXBehavior>().oper; IF_ID.GetComponent <IF_IDBehavior>().oper = ID.GetComponent <IDBehavior>().oper; EX.GetComponent <EXBehavior>().oper = MEM.GetComponent <MEMBehavior>().oper; ID_EX.GetComponent <ID_EXBehavior>().oper = EX.GetComponent <EXBehavior>().oper; MEM.GetComponent <MEMBehavior>().oper = WB.GetComponent <WBBehavior>().oper; EX_MEM.GetComponent <EX_MEMBehavior>().oper = MEM.GetComponent <MEMBehavior>().oper; if (doneOp.Count > 0) { WB.GetComponent <WBBehavior>().oper = (GameObject)doneOp.Pop(); MEM_WB.GetComponent <MEM_WBBehavior>().oper = WB.GetComponent <WBBehavior>().oper; } else { WB.GetComponent <WBBehavior>().oper = null; MEM_WB.GetComponent <MEM_WBBehavior>().oper = null; } updateAll(); }
public ARM7TDMI(GBA gba, Scheduler.Scheduler scheduler) { this.gba = gba; this.Pipeline = new cPipeline(this); this.InitARM(); this.InitTHUMB(); this.InitTimers(scheduler); // IO requires bus to be initialized this.bus = new BUS(this); this.IO = new IORAMSection(); // DMAChannels require bus AND IO to be initialized this.DMAChannels[0] = new DMAChannel(this, 0); this.DMAChannels[1] = new DMAChannel(this, 1); this.DMAChannels[2] = new DMAChannel(this, 2); this.DMAChannels[3] = new DMAChannel(this, 3); // mem requires IO AND DMAChannels to be initialized this.mem = new MEM(this); this.SystemBank = new uint[16]; this.FIQBank = new uint[16]; this.SupervisorBank = new uint[16]; // this.AbortBank = new uint[16]; this.IRQBank = new uint[16]; // this.UndefinedBank = new uint[16]; this.state = State.ARM; // need banked registers for CPSR initialization this.CPSR = 0x0000005F; this.PipelineFlush(); this.PC += 4; }
void PrintExp(MEM e, int d) { Indent(d); SayLn("MEM("); PrintExp(e.Exp, d + 1); Say(")"); }
public static void MemSetTypeFlag(Mem p, MEM f) { p.Flags = (p.Flags & ~(MEM.TypeMask | MEM.Zero) | f); }
public System.IntPtr GetPtr(MEM mem = MEM.MEM_CPU) { return(dllz_mat_get_ptr(_matInternalPtr, (int)mem)); }
/// <summary> /// Allocates memory for the Mat. /// </summary> /// <param name="resolution">Size of the image/matrix in pixels.</param> /// <param name="matType">Type of matrix (data type and channels; see sl.MAT_TYPE)</param> /// <param name="mem">Where the buffer will be stored - CPU memory or GPU memory.</param> public void Alloc(sl.Resolution resolution, MAT_TYPE matType, MEM mem = MEM.MEM_CPU) { dllz_mat_alloc(_matInternalPtr, (int)resolution.width, (int)resolution.height, (int)matType, (int)mem); }
/// <summary> /// Allocates memory for the Mat. /// </summary> /// <param name="width">Width of the image/matrix in pixels.</param> /// <param name="height">Height of the image/matrix in pixels.</param> /// <param name="matType">Type of matrix (data type and channels; see sl.MAT_TYPE)</param> /// <param name="mem">Where the buffer will be stored - CPU memory or GPU memory.</param> public void Alloc(uint width, uint height, MAT_TYPE matType, MEM mem = MEM.MEM_CPU) { dllz_mat_alloc(_matInternalPtr, (int)width, (int)height, (int)matType, (int)mem); }
Temp.Temp TranslateExpr(MEM expr) { Temp.Temp result = new Temp.Temp(); Temp.Temp mem; int offset; if (expr.Exp is BINOP && (expr.Exp as BINOP).Right is CONST) { mem = TranslateExpr((expr.Exp as BINOP).Left); offset = ((expr.Exp as BINOP).Right as CONST).Value; } else { mem = TranslateExpr(expr.Exp); offset = 0; } InstrList.Add(new Load(mem, offset, result)); return result; }