protected internal virtual void executeInterrupts(IList <AbstractInterruptHandler> interruptHandlers, IAction afterInterruptAction, IAction afterHandlerAction) { if (interruptHandlers != null) { for (IEnumerator <AbstractInterruptHandler> it = interruptHandlers.GetEnumerator(); it.MoveNext();) { AbstractInterruptHandler interruptHandler = it.Current; if (interruptHandler != null) { interruptHandler.execute(); } } } if (allegrexInterruptHandlers.Count == 0) { if (afterInterruptAction != null) { afterInterruptAction.execute(); } onEndOfInterrupt(); } else { InterruptState interruptState = new InterruptState(); interruptState.save(insideInterrupt, Emulator.Processor.cpu, afterInterruptAction, afterHandlerAction); InsideInterrupt = true; IEnumerator <AbstractAllegrexInterruptHandler> allegrexInterruptHandlersIterator = allegrexInterruptHandlers.GetEnumerator(); IAction continueAction = new AfterSubIntrAction(this, interruptState, allegrexInterruptHandlersIterator); continueCallAllegrexInterruptHandler(interruptState, allegrexInterruptHandlersIterator, continueAction); } }
/// <summary> /// Set/clear a specific interrupt persistence /// This is used to have more than 1 cycle before generating an /// interruption. /// </summary> /// <param name="interupt">The percistence cycles</param> /// <param name="state">True to set the interrupt, false to clear</param> public void SetInterrupt(InterruptState interupt, bool state) { WriteRegister(Registers.PERS, (byte)interupt); var enable = I2cRead8(Registers.ENABLE); enable = state ? enable |= (byte)Registers.ENABLE_AIEN : enable = (byte)(enable & ~(byte)Registers.ENABLE_AIEN); WriteRegister(Registers.ENABLE, enable); }
public void SetInterruptLine(InterruptType type, InterruptState state) { switch (type) { case InterruptType.Maskable: intState = state; break; case InterruptType.NonMaskable: nmiState = state; break; default: throw new EmulationException("Z80A: Unknown interrupt type"); } }
public virtual void Reset() { af.Word = bc.Word = de.Word = hl.Word = 0; af_.Word = bc_.Word = de_.Word = hl_.Word = 0; ix.Word = iy.Word = 0; i = r = 0; pc = 0; sp = 0; iff1 = iff2 = eiDelay = halt = false; im = 0; intState = nmiState = InterruptState.Clear; currentCycles = 0; }
public virtual void continueCallAllegrexInterruptHandler(InterruptState interruptState, IEnumerator <AbstractAllegrexInterruptHandler> allegrexInterruptHandlersIterator, IAction continueAction) { bool somethingExecuted = false; do { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: if (allegrexInterruptHandlersIterator != null && allegrexInterruptHandlersIterator.hasNext()) { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: AbstractAllegrexInterruptHandler allegrexInterruptHandler = allegrexInterruptHandlersIterator.next(); if (allegrexInterruptHandler != null) { //if (log.DebugEnabled) { Console.WriteLine("Calling InterruptHandler " + allegrexInterruptHandler.ToString()); } allegrexInterruptHandler.copyArgumentsToCpu(Emulator.Processor.cpu); Modules.ThreadManForUserModule.callAddress(allegrexInterruptHandler.Address, continueAction, true); somethingExecuted = true; } } else { break; } } while (!somethingExecuted); if (!somethingExecuted) { // No more handlers, end of interrupt InsideInterrupt = interruptState.restore(Emulator.Processor.cpu); IAction afterInterruptAction = interruptState.AfterInterruptAction; if (afterInterruptAction != null) { afterInterruptAction.execute(); } onEndOfInterrupt(); } }