package net.mograsim.plugin.launch;
-import java.util.Arrays;
-
+import static org.eclipse.core.resources.IResourceDelta.CHANGED;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarkerDelta;
+import org.eclipse.core.resources.IResourceChangeEvent;
+import org.eclipse.core.resources.IResourceChangeListener;
+import org.eclipse.core.resources.IResourceDelta;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.PlatformObject;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.model.IProcess;
import org.eclipse.debug.core.model.IStepFilters;
import org.eclipse.debug.core.model.IThread;
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.ui.PlatformUI;
+import net.mograsim.logic.model.LogicExecuter;
+import net.mograsim.machine.BitVectorMemory;
+import net.mograsim.machine.BitVectorMemoryDefinition;
import net.mograsim.machine.Machine;
+import net.mograsim.machine.MachineDefinition;
+import net.mograsim.machine.StandardMainMemory;
+import net.mograsim.machine.mi.MicroInstructionMemoryParser;
+import net.mograsim.machine.mi.StandardMPROM;
+import net.mograsim.machine.standard.memory.AbstractAssignableBitVectorMemory;
+import net.mograsim.machine.standard.memory.BitVectorBasedMemoryParser;
import net.mograsim.plugin.MograsimActivator;
public class MachineDebugTarget extends PlatformObject implements IDebugTarget, IMemoryBlockRetrievalExtension
{
- private final MachineProcess process;
+ private final static boolean USE_PSEUDO_THREAD = true;
+
+ private final ILaunch launch;
+ private final Machine machine;
+ private final LogicExecuter exec;
+ private final MachineThread thread;
+ private final IFile mpmFile;
+ private final Optional<IFile> mpromFile;
+ private final Optional<IFile> memFile;
+
+ private boolean running;
- public MachineDebugTarget(MachineProcess process)
+ private final List<Consumer<Double>> executionSpeedListeners;
+
+ private final IResourceChangeListener resChangedListener;
+
+ public MachineDebugTarget(ILaunch launch, IFile mpmFile, Optional<IFile> mpromFile, Optional<IFile> memFile,
+ MachineDefinition machineDefinition) throws CoreException
{
- this.process = process;
+ this.launch = launch;
+ this.machine = machineDefinition.createNew();
+ this.exec = new LogicExecuter(machine.getTimeline());
- DebugPlugin.getDefault().addDebugEventListener(es -> Arrays.stream(es).filter(e -> e.getSource() == process).forEach(e ->
- {
- switch (e.getKind())
- {
- case DebugEvent.RESUME:
- fireResumeEvent(e.getDetail());
- break;
- case DebugEvent.SUSPEND:
- fireSuspendEvent(e.getDetail());
- break;
- case DebugEvent.TERMINATE:
- fireTerminateEvent();
- break;
- default:
- // ignore
- }
- }));
+ this.executionSpeedListeners = new ArrayList<>();
+ this.mpmFile = mpmFile;
+ this.mpromFile = mpromFile;
+ this.memFile = memFile;
+
+ assignMicroInstructionMemory();
+ assignMPROM();
+ assignMainMemory();
+
+ exec.startLiveExecution();
+ running = true;
getLaunch().addDebugTarget(this);
fireCreationEvent();
+
+ this.resChangedListener = this::resourceChanged;
+ ResourcesPlugin.getWorkspace().addResourceChangeListener(resChangedListener, IResourceChangeEvent.POST_CHANGE);
+
+ // create after creating ourself
+ this.thread = USE_PSEUDO_THREAD ? new MachineThread(this) : null;
}
public Machine getMachine()
{
- return process.getMachine();
+ return machine;
}
@Override
public String getName() throws DebugException
{
- return process.getName();
+ return "Mograsim machine \"" + machine.getDefinition().getId() + '"';
}
@Override
@Override
public ILaunch getLaunch()
{
- return process.getLaunch();
+ return launch;
+ }
+
+ public double getExecutionSpeed()
+ {
+ return exec.getSpeedFactor();
}
public void setExecutionSpeed(double speed)
{
- process.setExecutionSpeed(speed);
+ if (getExecutionSpeed() != speed)
+ {
+ exec.setSpeedFactor(speed);
+ callExecutionSpeedListener(speed);
+ }
}
@Override
public boolean isSuspended()
{
- return process.isSuspended();
+ return exec.isPaused();
}
@Override
public boolean canSuspend()
{
- return process.canSuspend();
+ return !isTerminated() && !isSuspended();
}
@Override
public void suspend() throws DebugException
{
- process.suspend();
+ if (isTerminated())
+ throwDebugException("Can't suspend a terminated MachineProcess");
+ if (isSuspended())
+ throwDebugException("Can't suspend a suspended MachineProcess");
+
+ exec.pauseLiveExecution();
+ fireSuspendEvent(DebugEvent.CLIENT_REQUEST);
}
@Override
public boolean canResume()
{
- return process.canResume();
+ return !isTerminated() && isSuspended();
}
@Override
public void resume() throws DebugException
{
- process.resume();
+ if (isTerminated())
+ throwDebugException("Can't resume a terminated MachineProcess");
+ if (!isSuspended())
+ throwDebugException("Can't resume a non-suspended MachineProcess");
+
+ exec.unpauseLiveExecution();
+ fireResumeEvent(DebugEvent.CLIENT_REQUEST);
}
@Override
public boolean isTerminated()
{
- return process.isTerminated();
+ return !running;
}
@Override
public boolean canTerminate()
{
- return process.canTerminate();
+ return !isTerminated();
}
@Override
public void terminate() throws DebugException
{
- process.terminate();
+ if (isTerminated())
+ return;
+
+ ResourcesPlugin.getWorkspace().removeResourceChangeListener(resChangedListener);
+ exec.stopLiveExecution();
+ running = false;
+ fireTerminateEvent();
}
@Override
}
@Override
- public MachineProcess getProcess()
+ public IProcess getProcess()
{
- return process;
+ return null;
}
@Override
public boolean hasThreads() throws DebugException
{
- return false;
+ return USE_PSEUDO_THREAD;
}
@Override
public IThread[] getThreads() throws DebugException
{
- return new IThread[0];
+ return thread == null ? new IThread[0] : new IThread[] { thread };
+ }
+
+ public void addExecutionSpeedListener(Consumer<Double> executionSpeedListener)
+ {
+ executionSpeedListeners.add(executionSpeedListener);
+ }
+
+ public void removeExecutionSpeedListener(Consumer<Double> executionSpeedListener)
+ {
+ executionSpeedListeners.remove(executionSpeedListener);
+ }
+
+ private void callExecutionSpeedListener(double executionSpeed)
+ {
+ executionSpeedListeners.forEach(l -> l.accept(executionSpeed));
}
@SuppressWarnings("unchecked")
if (adapter == ILaunch.class)
return (T) getLaunch();
- if (adapter == IProcess.class)
- return (T) getProcess();
-
// CONTEXTLAUNCHING
if (adapter == ILaunchConfiguration.class)
return (T) getLaunch().getLaunchConfiguration();
{
DebugPlugin.getDefault().fireDebugEventSet(new DebugEvent[] { event });
}
+
+ private static void throwDebugException(String message) throws DebugException
+ {
+ throw new DebugException(
+ new Status(IStatus.ERROR, MograsimActivator.PLUGIN_ID, DebugException.TARGET_REQUEST_FAILED, message, null));
+ }
+
+ private void resourceChanged(IResourceChangeEvent event)
+ {
+ if (event.getType() == IResourceChangeEvent.POST_CHANGE)
+ {
+ tryHotReplaceIfChanged(event, mpmFile, this::assignMicroInstructionMemory, "MPM");
+
+ if (mpromFile.isPresent())
+ tryHotReplaceIfChanged(event, mpromFile.get(), this::assignMPROM, "MPROM");
+ }
+ }
+
+ private static void tryHotReplaceIfChanged(IResourceChangeEvent event, IFile memFile, RunnableThrowingCoreException assign, String type)
+ {
+ IResourceDelta mpmDelta = event.getDelta().findMember(memFile.getFullPath());
+ if (mpmDelta != null && (mpmDelta.getKind() & CHANGED) == CHANGED && memFile.exists())
+ tryHotReplace(memFile, assign, type);
+ }
+
+ private static void tryHotReplace(IFile memFile, RunnableThrowingCoreException assign, String type)
+ {
+ AtomicBoolean doHotReplace = new AtomicBoolean();
+ PlatformUI.getWorkbench().getDisplay().syncExec(() ->
+ {
+ if (MessageDialog.openConfirm(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), "Hot Replace " + type + "?",
+ String.format("The " + type + " %s has been modified on the file system. Replace simulated " + type
+ + " with modified contents?", memFile.getName())))
+ doHotReplace.set(true);
+ });
+ if (doHotReplace.get())
+ {
+ try
+ {
+ assign.run();
+ }
+ catch (CoreException e)
+ {
+ PlatformUI.getWorkbench().getDisplay()
+ .asyncExec(() -> MessageDialog.openError(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),
+ "Failed Hot Replace!",
+ "An error occurred trying to read the modified " + type + " from the file system: " + e.getMessage()));
+ }
+ }
+ }
+
+ private static interface RunnableThrowingCoreException
+ {
+ public void run() throws CoreException;
+ }
+
+ private void assignMicroInstructionMemory() throws CoreException
+ {
+ try (InputStream mpmStream = mpmFile.getContents())
+ {
+ machine.getMicroInstructionMemory().bind(
+ MicroInstructionMemoryParser.parseMemory(machine.getDefinition().getMicroInstructionMemoryDefinition(), mpmStream));
+ }
+ catch (IOException e)
+ {
+ throw new CoreException(new Status(IStatus.ERROR, MograsimActivator.PLUGIN_ID, "Unexpected IO exception reading MPM file", e));
+ }
+ }
+
+ private void assignMPROM() throws CoreException
+ {
+ assignMemory(mpromFile, machine.getMPROM(), machine.getDefinition().getMPROMDefinition(), StandardMPROM::new, "MPROM");
+ }
+
+ private void assignMainMemory() throws CoreException
+ {
+ assignMemory(memFile, machine.getMainMemory(), machine.getDefinition().getMainMemoryDefinition(), StandardMainMemory::new,
+ "initial RAM");
+ }
+
+ private static <D extends BitVectorMemoryDefinition, M extends BitVectorMemory> void assignMemory(Optional<IFile> memFile,
+ AbstractAssignableBitVectorMemory<M> memoryToAssign, D definition, Function<D, M> newMemory, String type) throws CoreException
+ {
+ if (memFile.isPresent())
+ {
+ try (InputStream initialRAMStream = memFile.get().getContents())
+ {
+ M mem = newMemory.apply(definition);
+ BitVectorBasedMemoryParser.parseMemory(mem, initialRAMStream);
+ memoryToAssign.bind(mem);
+ }
+ catch (IOException e)
+ {
+ throw new CoreException(
+ new Status(IStatus.ERROR, MograsimActivator.PLUGIN_ID, "Unexpected IO exception reading " + type + " file", e));
+ }
+ }
+ }
+
+ public IFile getMPMFile()
+ {
+ return mpmFile;
+ }
+
+ public Optional<IFile> getMPROMFile()
+ {
+ return mpromFile;
+ }
+
+ public Optional<IFile> getMEMFile()
+ {
+ return memFile;
+ }
}
\ No newline at end of file