Separated some code into their own files and removed unused UI elements.

Author: Charanor

gradle.properties

@@ -1,2 +1,2 @@
 junitVersion=4.12
-loggerVersion=1.0.13
+loggerVersion=1.0.13

src/main/java/se/student/liu/jessp088/vm/DebugListener.java

@@ -0,0 +1,44 @@
+package se.student.liu.jessp088.vm;
+
+public interface DebugListener {
+	/** Called before {@link VirtualMachine#execute(Bytecode)} or
+	 * {@link VirtualMachine#debug(Bytecode)} is called but after state has been set to
+	 * {@link VMState#EXECUTING} or {@link VMState#DEBUGGING}.
+	 *
+	 * @param vm
+	 *            the virtual machine */
+	void beforeExecution(VirtualMachine vm);
+
+	/** Called after {@link VirtualMachine#execute(Bytecode)} or
+	 * {@link VirtualMachine#debug(Bytecode)} is called and after state has been set to
+	 * {@link VMState#END_SUCCESS}, {@link VMState#END_ERROR}, or {@link VMState#END_USER}.
+	 *
+	 * @param vm
+	 *            the virtual machine */
+	void afterExecution(VirtualMachine vm);
+
+	/** Called before the virtual machine handles an instruction. Calling
+	 * {@link VirtualMachine#stopExecution()} in this method is guaranteed to stop the execution of
+	 * the virtual machine before the instruction is handled.
+	 *
+	 * @param vm
+	 *            the virtual machine */
+	void beforeInstruction(VirtualMachine vm);
+
+	/** Called after the virtual machine handles an instruction. If execution of the virtual machine
+	 * is paused or stopped this method is <b>not</b> guaranteed to be called before the next
+	 * {@link DebugListener#beforeExecution(VirtualMachine)} is called. This method is guaranteed to
+	 * be called even if the virtual machine gets a <b>non-critical</b> error during execution.
+	 *
+	 * @param vm
+	 *            the virtual machine */
+	void afterInstruction(VirtualMachine vm);
+
+	/** Called after the state of the virtual machine changes.
+	 *
+	 * @param vm
+	 *            the virtual machine
+	 * @see VirtualMachine#getCurrentState()
+	 * @see VirtualMachine#getPreviousState() */
+	void onStateChanged(VirtualMachine vm);
+}

src/main/java/se/student/liu/jessp088/vm/DefaultVirtualMachine.java

@@ -1,6 +1,6 @@
 package se.student.liu.jessp088.vm;
 
-import static se.student.liu.jessp088.vm.VirtualMachine.VMState.*;
+import static se.student.liu.jessp088.vm.VMState.*;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -11,9 +11,7 @@
 import se.student.liu.jessp088.vm.instructions.Instruction;
 import se.student.liu.jessp088.vm.instructions.InstructionException;
 
-
-public class DefaultVirtualMachine implements VirtualMachine
-{
+public class DefaultVirtualMachine implements VirtualMachine {
 	private static final Logger LOGGER = LoggerFactory.getLogger(DefaultVirtualMachine.class);
 
 	private final Stack stack;
@@ -39,14 +37,13 @@ public DefaultVirtualMachine(final int maxStackSize, final int maxVariableSize)
 		previousState = state = END_SUCCESS;
 	}
 
-	/**
-	 * {@inheritDoc}
+	/** {@inheritDoc}
 	 * <p>
 	 * The {@link DefaultVirtualMachine} implementation is an <b>infinite loop</b> that can only be
 	 * broken by calling {@link DefaultVirtualMachine#stopExecution()} or if the code execution is
 	 * stopped either by error or by finishing successfully.
 	 * </p>
-	 */
+	*/
 	@Override
 	public void execute(final Bytecode code) throws IllegalStateException {
 		if (!isStopped()) {
@@ -80,15 +77,17 @@ private void runInternal(final Bytecode code, final boolean debug) {
 		}
 		// catch listener pause or stop
 		if (!isRunning()) {
-			LOGGER.debug("Virtual machine was stopped by a listener before processing could begin.");
+			LOGGER.debug(
+					"Virtual machine was stopped by a listener before processing could begin.");
 			return;
 		}
 
 		while (currentCode.hasNext()) {
 			if (wasAtBreakpoint) {
 				// We don't want to break on the same line twice
 				wasAtBreakpoint = false;
-				LOGGER.trace("Skipping breakpoint on pointer {} (already executed).", currentCode.getPtr());
+				LOGGER.trace("Skipping breakpoint on pointer {} (already executed).",
+						currentCode.getPtr());
 			} else if (debug && isBreakpointAt(currentCode.getPtr())) {
 				wasAtBreakpoint = true;
 				LOGGER.debug("Hit breakpoint at pointer {}.", currentCode.getPtr());
@@ -100,20 +99,22 @@ private void runInternal(final Bytecode code, final boolean debug) {
 
 			beforeInstruction();
 			if (!isRunning()) {
-				LOGGER.debug("Virtual machine stopped by listener before instruction could be processed.");
+				LOGGER.debug(
+						"Virtual machine stopped by listener before instruction could be processed.");
 				// Revert to previous instruction or we will skip an instruction
 				code.setPtr(code.getPtr() - 1);
 				LOGGER.trace("Reverting instruction pointer.");
 				return;
 			}
 
 			try {
-				LOGGER.debug("Processing instruction {}: {}.", currentCode.getPtr() - 1, currentInstruction);
+				LOGGER.trace("Processing instruction {}: {}.", currentCode.getPtr() - 1,
+						currentInstruction);
 				currentInstruction.process(stack, code, variables);
 				afterInstruction();
 			} catch (final InstructionException e) {
-				this.error = String
-					.format("Error executing instruction %s on line %s: %s", currentInstruction, getCurrentLineNumber(), e);
+				this.error = String.format("Error executing instruction %s on line %s: %s",
+						currentInstruction, getCurrentLineNumber(), e);
 				LOGGER.error(error);
 
 				currentCode.setPtr(0);
@@ -155,7 +156,8 @@ public void resumeExecution() {
 		}
 
 		if (!wasRunning()) {
-			LOGGER.error("Cannot resume from state {} when previous state was {}!", state, previousState);
+			LOGGER.error("Cannot resume from state {} when previous state was {}!", state,
+					previousState);
 			final String format = "Cannot resume from state %s when previous state was %s!";
 			throw new IllegalStateException(String.format(format, state, previousState));
 		}
@@ -208,7 +210,8 @@ public void addBreakpoint(final int instructionPtr) {
 		if (!isBreakpointAt(instructionPtr)) {
 			LOGGER.trace("Adding breakpoint at {}", instructionPtr);
 			breakpoints.add(instructionPtr);
-		} else LOGGER.trace("Already a breakpoint at {}.", instructionPtr);
+		} else
+			LOGGER.trace("Already a breakpoint at {}.", instructionPtr);
 	}
 
 	@Override
@@ -217,7 +220,13 @@ public void removeBreakpoint(final int instructionPtr) {
 			LOGGER.trace("Removing breakpoint at {}", instructionPtr);
 			// Must cast otherwise it uses the wrong remove() method
 			breakpoints.remove((Integer) instructionPtr);
-		} else LOGGER.trace("No breakpoint at {} to remove.", instructionPtr);
+		} else
+			LOGGER.trace("No breakpoint at {} to remove.", instructionPtr);
+	}
+
+	@Override
+	public void removeAllBreakpoints() {
+		breakpoints.clear();
 	}
 
 	@Override
@@ -311,7 +320,9 @@ private void onStateChanged() {
 
 	private void setState(final VMState state) {
 		if (this.state == state) {
-			LOGGER.trace("Attempt to set state to {} when virtual machine was already in that state!", state);
+			LOGGER.trace(
+					"Attempt to set state to {} when virtual machine was already in that state!",
+					state);
 			return;
 		}
 

src/main/java/se/student/liu/jessp088/vm/Stack.java

@@ -3,109 +3,100 @@
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
-/**
- * A stack of integers.
+/** A stack of integers.
  *
- * @author Charanor
- */
-public class Stack
-{
+ * @author Charanor */
+public class Stack {
 	private int[] stack;
 	private int stackPtr;
 
-	/**
-	 * Creates a new Stack object with the specified max stack size.
+	/** Creates a new Stack object with the specified max stack size.
 	 *
-	 * @param maxStackSize
-	 */
+	 * @param maxStackSize */
 	public Stack(final int maxStackSize) {
 		stack = new int[maxStackSize];
 	}
 
-	/**
-	 * Creates a new Stack object that is an exact copy (all elements and pointer are the same) of
+	/** Creates a new Stack object that is an exact copy (all elements and pointer are the same) of
 	 * the supplied Stack parameter.
 	 *
-	 * @param stack the stack to copy.
-	 */
+	 * @param stack
+	 *            the stack to copy. */
 	public Stack(final Stack stack) {
 		this.stack = new int[stack.getMaxSize()];
 		System.arraycopy(stack.stack, 0, this.stack, 0, stack.getMaxSize());
 		this.stackPtr = stack.stackPtr;
 	}
 
-	/**
-	 * Push a value to the top of the stack.
+	/** Push a value to the top of the stack.
 	 *
-	 * @param value the value
+	 * @param value
+	 *            the value
 	 *
-	 * @throws IndexOutOfBoundsException if the stack is full
-	 */
+	 * @throws IndexOutOfBoundsException
+	 *             if the stack is full */
 	public void push(final int value) throws IndexOutOfBoundsException {
-		if (stackPtr >= stack.length) throw new IndexOutOfBoundsException("Trying to push past max stack size!");
+		if (stackPtr >= stack.length)
+			throw new IndexOutOfBoundsException("Trying to push past max stack size!");
 		stack[stackPtr++] = value;
 	}
 
-	/**
-	 * Remove and return the top value of the stack.
+	/** Remove and return the top value of the stack.
 	 *
 	 * @return the value
-	 * @throws IndexOutOfBoundsException if the stack is empty.
-	 */
+	 * @throws IndexOutOfBoundsException
+	 *             if the stack is empty. */
 	public int pop() throws IndexOutOfBoundsException {
-		if (stackPtr <= 0) throw new IndexOutOfBoundsException("Trying to pop from an empty stack!");
+		if (stackPtr <= 0)
+			throw new IndexOutOfBoundsException("Trying to pop from an empty stack!");
 		return stack[--stackPtr];
 	}
 
-	/**
-	 * Returns the top value of the stack without removing it.
+	/** Returns the top value of the stack without removing it.
 	 *
-	 * @return the value
-	 */
+	 * @return the value */
 	public int peek() throws IndexOutOfBoundsException {
-		if (stackPtr < 1) throw new IndexOutOfBoundsException("Trying to peek from an empty stack!");
+		if (stackPtr < 1)
+			throw new IndexOutOfBoundsException("Trying to peek from an empty stack!");
 		return stack[stackPtr - 1];
 	}
 
-	/**
-	 * Returns the first value beneath the top of the stack.
+	/** Returns the first value beneath the top of the stack.
 	 *
 	 * @return the value
-	 * @throws IndexOutOfBoundsException if the stack has fewer than 2 elements.
-	 */
+	 * @throws IndexOutOfBoundsException
+	 *             if the stack has fewer than 2 elements. */
 	public int deepPeek() throws IndexOutOfBoundsException {
-		if (stackPtr < 1) throw new IndexOutOfBoundsException("Cannot deep peek a stack with fewer than 2 elements!");
-		return stack[stackPtr - 1];
+		if (stackPtr < 2) throw new IndexOutOfBoundsException(
+				"Cannot deep peek a stack with fewer than 2 elements!");
+		return stack[stackPtr - 2];
 	}
 
 	/** Clears the stack setting the stack pointer to 0. */
 	public void clear() {
 		stackPtr = 0;
 	}
 
-	/**
-	 * Increases the max size of the stack by <code>size</code>.
+	/** Increases the max size of the stack by <code>size</code>.
 	 *
-	 * @param size the size
-	 */
+	 * @param size
+	 *            the size */
 	public void expand(final int size) {
 		sizeTo(getMaxSize() + size);
 	}
 
-	/**
-	 * Reduces the max size of the stack by <code>size</code>.
+	/** Reduces the max size of the stack by <code>size</code>.
 	 *
-	 * @param size the size
-	 */
+	 * @param size
+	 *            the size */
 	public void shrink(final int size) {
 		sizeTo(getMaxSize() - size);
 	}
 
-	/**
-	 * Sets the max size of the stack to <code>size</code>
+	/** Sets the max size of the stack to <code>size</code>.
 	 *
-	 * @param size the size
-	 */
+	 * @param size
+	 *            the size */
 	public void sizeTo(final int size) {
 		final int[] tmp = new int[size];
 		System.arraycopy(stack, 0, tmp, 0, Math.min(size, stack.length));
@@ -127,34 +118,28 @@ public boolean isEmpty() {
 		return stackPtr <= 0;
 	}
 
-	/**
-	 * Returns the contents of the stack. Identical to {@link Stack#toDecimalString()}.
+	/** Returns the contents of the stack. Identical to {@link Stack#toDecimalString()}.
 	 *
-	 * @return the string representation.
-	 */
+	 * @return the string representation. */
 	@Override
 	public String toString() {
 		return toDecimalString();
 	}
 
-	/**
-	 * Returns the contents of the stack represented as decimal numbers. Example:
+	/** Returns the contents of the stack represented as decimal numbers. Example:
 	 * <code>[5, 10, 252]</code>.
 	 *
-	 * @return the string representation.
-	 */
+	 * @return the string representation. */
 	public String toDecimalString() {
 		return IntStream.of(stack).limit(stackPtr).boxed().collect(Collectors.toList()).toString();
 	}
 
-	/**
-	 * Returns the contents of the stack represented as hexadecimal numbers. Example:
+	/** Returns the contents of the stack represented as hexadecimal numbers. Example:
 	 * <code>[0x05, 0x0A, 0xFC]</code>.
 	 *
-	 * @return the string representation.
-	 */
+	 * @return the string representation. */
 	public String toHexString() {
-		return IntStream.of(stack).limit(stackPtr).mapToObj(v -> String.format("0x%02X", v)).collect(Collectors.toList())
-			.toString();
+		return IntStream.of(stack).limit(stackPtr).mapToObj(v -> String.format("0x%02X", v))
+				.collect(Collectors.toList()).toString();
 	}
 }

src/main/java/se/student/liu/jessp088/vm/VMInstruction.java

@@ -1,45 +1,75 @@
 package se.student.liu.jessp088.vm;
 
+import se.student.liu.jessp088.vm.instructions.Instruction;
+import se.student.liu.jessp088.vm.instructions.Literal;
+import se.student.liu.jessp088.vm.instructions.arithmetic.Add;
+import se.student.liu.jessp088.vm.instructions.arithmetic.Div;
+import se.student.liu.jessp088.vm.instructions.arithmetic.Mod;
+import se.student.liu.jessp088.vm.instructions.arithmetic.Mul;
+import se.student.liu.jessp088.vm.instructions.arithmetic.Sub;
+import se.student.liu.jessp088.vm.instructions.control.Cmp;
+import se.student.liu.jessp088.vm.instructions.control.Jmp;
+import se.student.liu.jessp088.vm.instructions.control.JmpEQ;
+import se.student.liu.jessp088.vm.instructions.control.JmpGE;
+import se.student.liu.jessp088.vm.instructions.control.JmpGT;
+import se.student.liu.jessp088.vm.instructions.control.JmpLE;
+import se.student.liu.jessp088.vm.instructions.control.JmpLT;
+import se.student.liu.jessp088.vm.instructions.control.JmpNE;
+import se.student.liu.jessp088.vm.instructions.control.subroutine.Break;
+import se.student.liu.jessp088.vm.instructions.control.subroutine.Call;
+import se.student.liu.jessp088.vm.instructions.control.subroutine.Return;
+import se.student.liu.jessp088.vm.instructions.data.Discard;
+import se.student.liu.jessp088.vm.instructions.data.Dup;
+import se.student.liu.jessp088.vm.instructions.data.Load;
+import se.student.liu.jessp088.vm.instructions.data.Store;
+import se.student.liu.jessp088.vm.instructions.data.Swap;
+import se.student.liu.jessp088.vm.instructions.meta.Free;
+import se.student.liu.jessp088.vm.instructions.meta.Malloc;
+import se.student.liu.jessp088.vm.instructions.meta.SizeTo;
+
 /** All instructions that the VM can process.
  *
  * @author Charanor */
 public enum VMInstruction {
 	// Arithmetic instructions
-	LITERAL(1),
-	ADD(0),
-	SUB(0),
-	DIV(0),
-	MUL(0),
-	MOD(0),
+	LITERAL(1, Literal.class),
+	ADD(0, Add.class),
+	SUB(0, Sub.class),
+	DIV(0, Div.class),
+	MUL(0, Mul.class),
+	MOD(0, Mod.class),
 
 	// Control Flow Instructions
-	CMP(0),
-	JMP(1),
-	JMPGT(1),
-	JMPLT(1),
-	JMPEQ(1),
-	JMPNE(1),
-	JMPGE(1),
-	JMPLE(1),
-	CALL(1),
-	BREAK(0),
-	RETURN(0),
+	CMP(0, Cmp.class),
+	JMP(1, Jmp.class),
+	JMPGT(1, JmpGT.class),
+	JMPLT(1, JmpLT.class),
+	JMPEQ(1, JmpEQ.class),
+	JMPNE(1, JmpNE.class),
+	JMPGE(1, JmpGE.class),
+	JMPLE(1, JmpLE.class),
+	CALL(1, Call.class),
+	BREAK(0, Break.class),
+	RETURN(0, Return.class),
 
 	// Data Transfer Instructions
-	DUP(0),
-	SWAP(0),
-	LOAD(1),
-	STORE(1),
-	DISCARD(0),
+	DUP(0, Dup.class),
+	SWAP(0, Swap.class),
+	LOAD(1, Load.class),
+	STORE(1, Store.class),
+	DISCARD(0, Discard.class),
 
 	// Meta Control Instructions
-	MALLOC(1),
-	FREE(1),
-	SIZETO(1),;
+	MALLOC(1, Malloc.class),
+	FREE(1, Free.class),
+	SIZETO(1, SizeTo.class),;
 
 	public final int numArguments;
+	public final Class<? extends Instruction> instructionClass;
 
-	private VMInstruction(final int numArguments) {
+	private VMInstruction(final int numArguments,
+			final Class<? extends Instruction> instructionClass) {
 		this.numArguments = numArguments;
+		this.instructionClass = instructionClass;
 	}
 }

src/main/java/se/student/liu/jessp088/vm/VMState.java

@@ -0,0 +1,29 @@
+package se.student.liu.jessp088.vm;
+
+/** The types of state a {@link VirtualMachine} can be in at one specific time.
+ *
+ * @author Charanor */
+public enum VMState {
+	/** The virtual machine is currently executing code normally. */
+	EXECUTING(true, false, false),
+	/** The virtual machine is currently debugging code. */
+	DEBUGGING(true, false, false),
+	/** The code executed and ended successfully. */
+	END_SUCCESS(false, false, true),
+	/** The code executed and ended in an error. */
+	END_ERROR(false, false, true),
+	/** The execution was stopped by a user. */
+	END_USER(false, false, true),
+	/** The virtual machine hit a breakpoint and paused execution. */
+	PAUSE_BREAKPOINT(false, true, false),
+	/** The execution was paused by a user. */
+	PAUSE_USER(false, true, false);
+
+	public final boolean running, paused, stopped;
+
+	private VMState(final boolean running, final boolean paused, final boolean stopped) {
+		this.running = running;
+		this.paused = paused;
+		this.stopped = stopped;
+	}
+}

src/main/java/se/student/liu/jessp088/vm/Variables.java

@@ -1,8 +1,9 @@
 package se.student.liu.jessp088.vm;
 
 import java.util.Arrays;
+import java.util.Iterator;
 
-public class Variables {
+public class Variables implements Iterable<Integer> {
 	private final int[] variables;
 	private int numVariables;
 
@@ -42,4 +43,21 @@ public void clear() {
 	public String toString() {
 		return Arrays.toString(Arrays.copyOf(variables, numVariables));
 	}
+
+	@Override
+	public Iterator<Integer> iterator() {
+		return new Iterator<Integer>() {
+			int idx = 0;
+
+			@Override
+			public boolean hasNext() {
+				return idx < variables.length;
+			}
+
+			@Override
+			public Integer next() {
+				return variables[idx++];
+			}
+		};
+	}
 }

src/main/java/se/student/liu/jessp088/vm/VirtualMachine.java

@@ -2,73 +2,68 @@
 
 import se.student.liu.jessp088.vm.instructions.Instruction;
 
-/**
- * An object representing a virtual machine that can run and debug bytecode given to it. It is also
- * responsible for containing the stack and any variables used by the code.
+/** An object representing a virtual machine that can run and debug {@link Bytecode} given to it. It
+ * is also responsible for containing the {@link Stack} and {@link Variables} used by the code.
  *
  * @author Charanor
- */
-public interface VirtualMachine
-{
-	/**
-	 * Executes the code in the {@link Bytecode} object. Calling this method when the virtual
-	 * machine is running or paused will cause an {@link IllegalStateException} to be thrown.
+ *
+ * @see Bytecode
+ * @see Stack
+ * @see Variables */
+public interface VirtualMachine {
+	/** Executes the code in the {@link Bytecode} object. Calling this method when the virtual
+	 * machine is not stopped will cause an {@link IllegalStateException} to be thrown.
+	 *
+	 * @param code
+	 *            the code to execute.
 	 *
-	 * @param code the code to execute.
+	 * @throws IllegalStateException
+	 *             if called when {@link VirtualMachine} is not stopped.
 	 *
-	 * @throws IllegalStateException if called when {@link VirtualMachine} is running or paused.
-	 */
+	 * @see VirtualMachine#isStopped() */
 	void execute(Bytecode code) throws IllegalStateException;
 
-	/**
-	 * Debugs the code in the {@link Bytecode} object. Calling this method when the virtual machine
-	 * is running or paused will cause an {@link IllegalStateException} to be thrown.
+	/** Debugs the code in the {@link Bytecode} object. Calling this method when the virtual machine
+	 * is not stopped will cause an {@link IllegalStateException} to be thrown.
 	 *
-	 * @param code the code to debug.
+	 * @param code
+	 *            the code to debug.
 	 *
-	 * @throws IllegalStateException if called when {@link VirtualMachine} is running or paused.
-	 */
+	 * @throws IllegalStateException
+	 *             if called when {@link VirtualMachine} is not stopped.
+	 *
+	 * @see VirtualMachine#isStopped() */
 	void debug(Bytecode code) throws IllegalStateException;
 
-	/**
-	 * Pauses the execution of the virtual machine. The exact effects of pausing is
+	/** Pauses the execution of the virtual machine. The exact effects of pausing is
 	 * <b>implementation specific</b> and is allowed to depend on the current and previous
 	 * {@link VMState}. The only guarantee made is that pausing prohibits any more
 	 * {@link Instruction}s from being processed until {@link VirtualMachine#resumeExecution()} is
-	 * called. If the virtual machine is not running this method does nothing.
-	 */
+	 * called. If the virtual machine is not running this method does nothing. */
 	void pauseExecution();
 
-	/**
-	 * Resumes the execution of the virtual machine. If the virtual machine is not paused this
-	 * method does nothing.
-	 */
+	/** Resumes the execution of the virtual machine. If the virtual machine is not paused this
+	 * method does nothing. */
 	void resumeExecution();
 
-	/**
-	 * Stops the execution of the virtual machine. The exact effects of stopping is
+	/** Stops the execution of the virtual machine. The exact effects of stopping is
 	 * <b>implementation specific</b> and is allowed to depend on the current and previous
 	 * {@link VMState}. The only guarantee made is that stopping prohibits any more
 	 * {@link Instruction}s from being processed until {@link VirtualMachine#execute(Bytecode)} or
 	 * {@link VirtualMachine#debug(Bytecode)} is called again and that the program counter is reset.
-	 * If the virtual machine is not running this method does nothing.
-	 */
+	 * If the virtual machine is not running this method does nothing. */
 	void stopExecution();
 
-	/**
-	 * Gets the current {@link VMState} of the virtual machine. The default state is
+	/** Gets the current {@link VMState} of the virtual machine. The default state is
 	 * {@link VMState#END_SUCCESS}.
 	 *
-	 * @return the current state.
-	 */
+	 * @return the current state. */
 	VMState getCurrentState();
 
-	/**
-	 * Gets the previous {@link VMState} of the virtual machine. The default state is
+	/** Gets the previous {@link VMState} of the virtual machine. The default state is
 	 * {@link VMState#END_SUCCESS}.
 	 *
-	 * @return the previous state.
-	 */
+	 * @return the previous state. */
 	VMState getPreviousState();
 
 	/** @return true if the virtual machine is currently running; false otherwise. */
@@ -101,23 +96,20 @@ default boolean wasStopped() {
 		return getPreviousState().stopped;
 	}
 
-	/**
-	 * Adds a {@link DebugListener} to listen for debug events from this virtual machine.
+	/** Adds a {@link DebugListener} to listen for debug events from this virtual machine.
 	 *
-	 * @param listener the listener
-	 */
+	 * @param listener
+	 *            the listener */
 	void addDebugListener(DebugListener listener);
 
-	/**
-	 * Removes a previously registered {@link DebugListener} from this virtual machine. If the
+	/** Removes a previously registered {@link DebugListener} from this virtual machine. If the
 	 * listener is not registered this method does nothing.
 	 *
-	 * @param listener the listener
-	 */
+	 * @param listener
+	 *            the listener */
 	void removeDebugListener(DebugListener listener);
 
-	/**
-	 * Adds a breakpoint at the specified instruction pointer. A breakpoint is automatically
+	/** Adds a breakpoint at the specified instruction pointer. A breakpoint is automatically
 	 * triggered and does not require external interference. The exact effects of a breakpoint is
 	 * <b>implementation specific</b>. The only guarantees made are:
 	 * <ul>
@@ -136,179 +128,90 @@ default boolean wasStopped() {
 	 * the instruction that the breakpoint stopped on and is thus <b>undefined behavior</b>.
 	 * </p>
 	 *
-	 * @param instructionPtr the pointer to break at
-	 */
+	 * @param instructionPtr
+	 *            the pointer to break at */
 	void addBreakpoint(int instructionPtr);
 
-	/**
-	 * Removes a breakpoint at the specified instruction pointer. If there is no breakpoint at the
+	/** Removes a breakpoint at the specified instruction pointer. If there is no breakpoint at the
 	 * specified instruction pointer this method does nothing.
 	 *
-	 * @param instructionPtr the pointer to remove the break from
-	 */
+	 * @param instructionPtr
+	 *            the pointer to remove the break from */
 	void removeBreakpoint(int instructionPtr);
 
-	/**
-	 * Returns if there is a breakpoint at the specified instruction pointer.
+	/** Removes all breakpoints. */
+	void removeAllBreakpoints();
+
+	/** Returns if there is a breakpoint at the specified instruction pointer.
 	 *
-	 * @param instructionPtr the pointer
+	 * @param instructionPtr
+	 *            the pointer
 	 *
-	 * @return true if there is a breakpoint; false otherwise or if instructionPtr is invalid.
-	 */
+	 * @return true if there is a breakpoint; false otherwise or if instructionPtr is invalid. */
 	boolean isBreakpointAt(int instructionPtr);
 
-	/**
-	 * Gets the current {@link Instruction}. Whether or not the instruction has already been
+	/** Gets the current {@link Instruction}. Whether or not the instruction has already been
 	 * executed when this call is made is <b>implementation specific</b>.
 	 *
-	 * @return the current {@link Instruction}
-	 */
+	 * @return the current {@link Instruction} */
 	Instruction getCurrentInstruction();
 
-	/**
-	 * Gets the instruction pointer pointing to the index of the {@link Instruction} from
+	/** Gets the instruction pointer pointing to the index of the {@link Instruction} from
 	 * {@link VirtualMachine#getCurrentInstruction()} in a {@link Bytecode} object.
 	 *
-	 * @return the pointer
-	 */
+	 * @return the pointer */
 	int getCurrentInstructionPtr();
 
-	/**
-	 * Gets the line number of the {@link Instruction} from
+	/** Gets the line number of the {@link Instruction} from
 	 * {@link VirtualMachine#getCurrentInstruction()}.
 	 *
-	 * @return the line number
-	 */
+	 * @return the line number */
 	int getCurrentLineNumber();
 
-	/**
-	 * Converts an instruction pointer to the line number where the instruction can be found.
+	/** Converts an instruction pointer to the line number where the instruction can be found.
 	 *
-	 * @param ptr the pointer
+	 * @param ptr
+	 *            the pointer
 	 *
 	 * @return the line number
-	 * @throws IllegalArgumentException if there is no line corresponding to the pointer <b>or</b> if the pointer is
-	 *                                  invalid.
-	 */
+	 * @throws IllegalArgumentException
+	 *             if there is no line corresponding to the pointer <b>or</b> if the pointer is
+	 *             invalid. */
 	int convertPtrToLine(int ptr) throws IllegalArgumentException;
 
-	/**
-	 * Converts a line number to the instruction pointer found on the line number.
+	/** Converts a line number to the instruction pointer found on the line number.
 	 *
-	 * @param line the line
+	 * @param line
+	 *            the line
 	 *
 	 * @return the instruction pointer
-	 * @throws IllegalArgumentException if there is no pointer corresponding to the line given.
-	 */
+	 * @throws IllegalArgumentException
+	 *             if there is no pointer corresponding to the line given. */
 	int convertLineToPtr(int line) throws IllegalArgumentException;
 
-	/**
-	 * Gets the errors the virtual machine has experienced. This method is <b>only</b> guaranteed
+	/** Gets the errors the virtual machine has experienced. This method is <b>only</b> guaranteed
 	 * to return an accurate error message when the virtual machine is stopped. Otherwise the return
 	 * value is <b>implementation specific</b> and is allowed to be <code>null</code>.
 	 *
-	 * @return the current error message(s). May be null.
-	 */
+	 * @return the current error message(s). May be null. */
 	String getError();
 
-	/**
-	 * Checks if the virtual machine currently has any errors. This method is <b>only</b>
+	/** Checks if the virtual machine currently has any errors. This method is <b>only</b>
 	 * guaranteed to return an accurate value when the virtual machine is stopped. Otherwise the
 	 * return value is <b>implementation specific</b>.
 	 *
-	 * @return if the {@link VirtualMachine} currently has any errors.
-	 */
+	 * @return if the {@link VirtualMachine} currently has any errors. */
 	boolean hasErrors();
 
-	/**
-	 * Returns a copy of the current {@link Stack} instance contained in this
+	/** Returns a copy of the current {@link Stack} instance contained in this
 	 * {@link VirtualMachine}.
 	 *
-	 * @return the stack.
-	 */
+	 * @return the stack. */
 	Stack getStack();
 
-	/**
-	 * Returns a copy of the current {@link Variables} instance contained in this
+	/** Returns a copy of the current {@link Variables} instance contained in this
 	 * {@link VirtualMachine}.
 	 *
-	 * @return the variables.
-	 */
+	 * @return the variables. */
 	Variables getVariables();
-
-	/**
-	 * The types of state the {@link VirtualMachine} can be in at one specific time.
-	 *
-	 * @author Charanor
-	 */
-	public static enum VMState
-	{
-		/** The {@link VirtualMachine} is currently executing code normally. */
-		EXECUTING(true, false, false), /** The {@link VirtualMachine} is currently debugging code. */
-	DEBUGGING(true, false, false), /** The code executed and ended successfully. */
-	END_SUCCESS(false, false, true), /**
-	 * The code executed and ended in an error accessible by {@link VirtualMachine#getError()}
-	 * .
-	 */
-	END_ERROR(false, false, true), /** The execution was stopped by a user. */
-	END_USER(false, false, true), /** The execution hit a breakpoint and paused execution. */
-	PAUSE_BREAKPOINT(false, true, false), /** The execution was paused by a user. */
-	PAUSE_USER(false, true, false);
-
-		public final boolean running, paused, stopped;
-
-		private VMState(final boolean running, final boolean paused, final boolean stopped) {
-			this.running = running;
-			this.paused = paused;
-			this.stopped = stopped;
-		}
-	}
-
-	public static interface DebugListener
-	{
-		/**
-		 * Called before {@link VirtualMachine#execute(Bytecode)} or
-		 * {@link VirtualMachine#debug(Bytecode)} is called but after state has been set to
-		 * {@link VMState#EXECUTING} or {@link VMState#DEBUGGING}.
-		 *
-		 * @param vm the virtual machine
-		 */
-		void beforeExecution(VirtualMachine vm);
-
-		/**
-		 * Called after {@link VirtualMachine#execute(Bytecode)} or
-		 * {@link VirtualMachine#debug(Bytecode)} is called and after state has been set to
-		 * {@link VMState#END_SUCCESS}, {@link VMState#END_ERROR}, or {@link VMState#END_USER}.
-		 *
-		 * @param vm the virtual machine
-		 */
-		void afterExecution(VirtualMachine vm);
-
-		/**
-		 * Called before the {@link VirtualMachine} handles an {@link Instruction}. Calling
-		 * {@link VirtualMachine#stopExecution()} is guaranteed to stop the execution of the
-		 * {@link VirtualMachine} before the Instruction is handled.
-		 *
-		 * @param vm the virtual machine
-		 */
-		void beforeInstruction(VirtualMachine vm);
-
-		/**
-		 * Called after the {@link VirtualMachine} handles an {@link Instruction}. If execution of
-		 * the {@link VirtualMachine} is paused or stopped this method is <b>not</b> guaranteed to
-		 * be called before the next {@link DebugListener#beforeExecution(VirtualMachine)} is
-		 * called. This method is guaranteed to be called even if the {@link VirtualMachine} gets a
-		 * <b>non-critical</b> error during execution.
-		 *
-		 * @param vm the virtual machine
-		 */
-		void afterInstruction(VirtualMachine vm);
-
-		/**
-		 * Called after the state of the {@link VirtualMachine} changes.
-		 *
-		 * @param vm the virtual machine
-		 */
-		void onStateChanged(VirtualMachine vm);
-	}
 }

src/main/java/se/student/liu/jessp088/vm/instructions/Literal.java

@@ -1,7 +1,6 @@
 package se.student.liu.jessp088.vm.instructions;
 
 public class Literal extends OneArgInstruction {
-
 	public Literal(final int arg) {
 		super(arg);
 	}

src/main/java/se/student/liu/jessp088/vm/instructions/OneArgInstruction.java

@@ -7,6 +7,10 @@ protected OneArgInstruction(final int arg) {
 		this.arg = arg;
 	}
 
+	public int getArg() {
+		return arg;
+	}
+
 	@Override
 	public String toString() {
 		return super.toString() + " " + arg;

src/main/java/se/student/liu/jessp088/vm/instructions/TwoArgInstruction.java

@@ -9,6 +9,14 @@ protected TwoArgInstruction(final int left, final int right) {
 		this.right = right;
 	}
 
+	public int getArg1() {
+		return left;
+	}
+
+	public int getArg2() {
+		return right;
+	}
+
 	@Override
 	public String toString() {
 		return super.toString() + " " + left + " " + right;

src/main/java/se/student/liu/jessp088/vm/parsing/suppliers/ReflectionSupplier.java

@@ -0,0 +1,28 @@
+package se.student.liu.jessp088.vm.parsing.suppliers;
+
+import java.lang.reflect.InvocationTargetException;
+
+import se.student.liu.jessp088.vm.VMInstruction;
+import se.student.liu.jessp088.vm.instructions.Instruction;
+
+public class ReflectionSupplier implements InstructionSupplier {
+	@Override
+	public Instruction getInstruction(final VMInstruction instruction, final int... inputArgs)
+			throws IllegalArgumentException {
+		final Class<?>[] paramTypes = new Class<?>[instruction.numArguments];
+		for (int i = 0; i < paramTypes.length; i++)
+			paramTypes[i] = int.class;
+
+		// Must be of type Object[] because int[] will cause an argument mismatch.
+		final Object[] args = new Object[instruction.numArguments];
+		for (int i = 0; i < args.length; i++)
+			args[i] = inputArgs[i];
+
+		try {
+			return instruction.instructionClass.getConstructor(paramTypes).newInstance(args);
+		} catch (InstantiationException | IllegalAccessException | InvocationTargetException
+				| NoSuchMethodException | SecurityException e) {
+			throw new IllegalArgumentException("Could not create instruction " + instruction, e);
+		}
+	}
+}

src/main/java/se/student/liu/jessp088/vm/ui/GUI.java

@@ -13,16 +13,40 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.util.List;
-
-import javax.swing.*;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import javax.swing.BorderFactory;
+import javax.swing.Icon;
+import javax.swing.ImageIcon;
+import javax.swing.JComponent;
+import javax.swing.JFileChooser;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JSeparator;
+import javax.swing.JSplitPane;
+import javax.swing.JTabbedPane;
+import javax.swing.JTable;
+import javax.swing.JTextArea;
+import javax.swing.KeyStroke;
+import javax.swing.SwingConstants;
 import javax.swing.border.LineBorder;
 import javax.swing.filechooser.FileNameExtensionFilter;
 import javax.swing.table.DefaultTableModel;
 import javax.swing.text.BadLocationException;
 
 import se.student.liu.jessp088.vm.Bytecode;
+import se.student.liu.jessp088.vm.DebugListener;
 import se.student.liu.jessp088.vm.DefaultVirtualMachine;
+import se.student.liu.jessp088.vm.Variables;
 import se.student.liu.jessp088.vm.VirtualMachine;
+import se.student.liu.jessp088.vm.instructions.Instruction;
+import se.student.liu.jessp088.vm.instructions.data.Store;
 import se.student.liu.jessp088.vm.parsing.Lexer;
 import se.student.liu.jessp088.vm.parsing.Parser;
 import se.student.liu.jessp088.vm.parsing.Token;
@@ -38,6 +62,7 @@ public class GUI {
 	private static final Icon DEBUG_ICON = new ImageIcon(GUI.class.getResource("/debug_16.png"));
 	private static final Icon CONSOLE_ICON = new ImageIcon(GUI.class.getResource("/pc_16.png"));
 	private static final Icon VARIABLES_ICON = new ImageIcon(GUI.class.getResource("/var_16.png"));
+	private static final Icon STACK_ICON = new ImageIcon(GUI.class.getResource("/stack_16.png"));
 	private static final Icon PROGRAM_ICON = new ImageIcon(GUI.class.getResource("/vm_16.png"));
 	private static final Icon RESUME_ICON = new ImageIcon(GUI.class.getResource("/resume_16.png"));
 	private static final Icon PAUSE_ICON = new ImageIcon(GUI.class.getResource("/pause_16.png"));
@@ -46,14 +71,12 @@ public class GUI {
 
 	private static final Font CODE_FONT = new Font("Consolas", Font.PLAIN, 12);
 
+	private final ExecutorService executor = Executors.newSingleThreadExecutor();
+
 	private Lexer lexer;
 	private Parser parser;
 	private VirtualMachine vm;
 
-	// Debugging state
-	private Bytecode parseResult;
-	private boolean isDebugging;
-
 	private JFrame frame;
 	private JFileChooser fc;
 	private JTabbedPane programTabs;
@@ -63,6 +86,11 @@ public class GUI {
 
 	private final int maxStackSize = DEFAULT_MAX_STACK_SIZE;
 	private final int maxVariableSize = DEFAULT_MAX_VARIABLE_SIZE;
+	private JMenuItem resumeOption;
+	private JMenuItem pauseOption;
+	private JMenuItem stopOption;
+	private JTextArea stackTextArea;
+	private JLabel lineInfoLabel;
 
 	/** Launch the application. */
 	public static void main(final String[] args) {
@@ -145,20 +173,26 @@ private void initialize() {
 		final JSeparator separator = new JSeparator();
 		runMenu.add(separator);
 
-		final JMenuItem resumeOption = new JMenuItem("Resume Execution");
+		resumeOption = new JMenuItem("Resume Execution");
+		resumeOption.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_P, InputEvent.CTRL_MASK));
 		resumeOption.setEnabled(false);
 		resumeOption.setIcon(RESUME_ICON);
-		resumeOption.addActionListener(this::resumeDebug);
+		resumeOption.addActionListener(this::resumeExecution);
 		runMenu.add(resumeOption);
 
-		final JMenuItem pauseOption = new JMenuItem("Pause Execution");
+		pauseOption = new JMenuItem("Pause Execution");
+		pauseOption.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_P, InputEvent.CTRL_MASK));
 		pauseOption.setEnabled(false);
 		pauseOption.setIcon(PAUSE_ICON);
+		pauseOption.addActionListener(this::pauseExecution);
 		runMenu.add(pauseOption);
 
-		final JMenuItem stopOption = new JMenuItem("Stop Execution");
+		stopOption = new JMenuItem("Stop Execution");
+		stopOption.setAccelerator(
+				KeyStroke.getKeyStroke(KeyEvent.VK_P, InputEvent.CTRL_MASK | InputEvent.ALT_MASK));
 		stopOption.setEnabled(false);
 		stopOption.setIcon(STOP_ICON);
+		stopOption.addActionListener(this::stopExecution);
 		runMenu.add(stopOption);
 
 		final JSeparator separator_1 = new JSeparator();
@@ -173,6 +207,19 @@ private void initialize() {
 		final JMenuItem addBreakpointOption = new JMenuItem("Add Breakpoint at Cursor");
 		addBreakpointOption.addActionListener(this::addBreakpointAtCursor);
 		debugMenu.add(addBreakpointOption);
+
+		final JMenuItem clearConsoleOption = new JMenuItem("Clear console");
+		clearConsoleOption.addActionListener(e -> consoleTextArea.setText(""));
+
+		final JMenuItem removeBreakpointOption = new JMenuItem("Remove Breakpoint at Cursor");
+		removeBreakpointOption.addActionListener(this::removeBreakpointAtCursor);
+		debugMenu.add(removeBreakpointOption);
+
+		final JMenuItem removeAllOption = new JMenuItem("Remove all Breakpoints");
+		removeAllOption.addActionListener(e -> vm.removeAllBreakpoints());
+		debugMenu.add(removeAllOption);
+		debugMenu.add(clearConsoleOption);
+
 		configurationOption.addActionListener(e -> {
 			final RunConfigDialog dialog = new RunConfigDialog(frame);
 
@@ -187,7 +234,6 @@ private void initialize() {
 		programExtrasSplitter.setOrientation(JSplitPane.VERTICAL_SPLIT);
 
 		programTabs = new JTabbedPane(SwingConstants.TOP);
-		programExtrasSplitter.setLeftComponent(programTabs);
 
 		// final JTextArea codeTextArea = new JTextArea();
 		// codeTextArea.setBorder(new LineBorder(Color.GRAY));
@@ -204,6 +250,7 @@ private void initialize() {
 		programExtrasSplitter.setRightComponent(extrasTabs);
 
 		consoleTextArea = new JTextArea();
+		consoleTextArea.setEditable(false);
 		consoleTextArea.setBorder(new LineBorder(Color.GRAY));
 		consoleTextArea.setFont(CODE_FONT);
 		final JScrollPane consoleScrollPane = new JScrollPane(consoleTextArea);
@@ -219,16 +266,87 @@ private void initialize() {
 
 		final JScrollPane variableScrollPane = new JScrollPane(variableTable);
 		extrasTabs.addTab("Variables", VARIABLES_ICON, variableScrollPane, null);
+
+		stackTextArea = new JTextArea();
+		stackTextArea.setEditable(false);
+		final JScrollPane stackScrollPane = new JScrollPane(stackTextArea);
+		extrasTabs.addTab("Stack", STACK_ICON, stackScrollPane, null);
+
+		// Redirect logging to GUI console
+		new MessageConsole(consoleTextArea).redirectOut();
+
+		final JPanel codePanel = new JPanel();
+		programExtrasSplitter.setLeftComponent(codePanel);
+		codePanel.setLayout(new BorderLayout(0, 0));
+		codePanel.add(programTabs);
+
+		lineInfoLabel = new JLabel("Line: 0, Column: 0");
+		codePanel.add(lineInfoLabel, BorderLayout.SOUTH);
+
+		// Listener to add variables to table
+		vm.addDebugListener(new DebugListener() {
+			@Override
+			public void beforeExecution(final VirtualMachine vm) {
+				final int numRows = variableTable.getModel().getRowCount();
+				for (int i = 0; i < numRows; i++) {
+					variableTable.getModel().setValueAt(null, i, 0);
+					variableTable.getModel().setValueAt(null, i, 1);
+				}
+
+				stackTextArea.setText("");
+			}
+
+			@Override
+			public void afterExecution(final VirtualMachine vm) {
+				resumeOption.setEnabled(false);
+				pauseOption.setEnabled(false);
+				stopOption.setEnabled(false);
+			}
+
+			@Override
+			public void beforeInstruction(final VirtualMachine vm) {
+			}
+
+			@Override
+			public void afterInstruction(final VirtualMachine vm) {
+				stackTextArea.setText(vm.getStack().toString());
+
+				final Instruction ins = vm.getCurrentInstruction();
+				if (!(ins instanceof Store)) return;
+				final Store store = (Store) ins;
+				final int varIdx = store.getArg();
+
+				final Variables variables = vm.getVariables();
+				variableTable.getModel().setValueAt(varIdx, varIdx, 0);
+				variableTable.getModel().setValueAt(variables.load(varIdx), varIdx, 1);
+			}
+
+			@Override
+			public void onStateChanged(final VirtualMachine vm) {
+				resumeOption.setEnabled(vm.isPaused());
+				pauseOption.setEnabled(vm.isRunning());
+				stopOption.setEnabled(vm.isPaused() || vm.isRunning());
+			}
+		});
 	}
 
 	private void openNewProgramTab(final String tabName, final String tabContents) {
-		final JTextArea codeTextArea = new JTextArea(tabContents);
-		codeTextArea.setBorder(BorderFactory.createLineBorder(Color.GRAY));
-		codeTextArea.setFont(CODE_FONT);
+		final JTextArea text = new JTextArea(tabContents);
+		text.setBorder(BorderFactory.createLineBorder(Color.GRAY));
+		text.setFont(CODE_FONT);
+		text.addCaretListener(e -> {
+			try {
+				final int lineNumber = lineNumberAtCursor();
+				final int column = text.getCaretPosition()
+						- text.getLineStartOffset(lineNumber - 1);
+				lineInfoLabel.setText("Line: " + lineNumber + ", Column: " + column);
+			} catch (final Exception ignored) {
+			}
+		});
 
-		final TextLineNumber lineNumbers = new TextLineNumber(codeTextArea);
-		final JScrollPane codeScrollPane = new JScrollPane(codeTextArea);
-		codeScrollPane.setRowHeaderView(lineNumbers);
+		final TextLineNumber lineNumbers = new TextLineNumber(text);
+		final JScrollPane codeScrollPane = new JScrollPane(text);
+		// codeScrollPane.setRowHeaderView(lineNumbers);
 
 		programTabs.addTab(tabName, PROGRAM_ICON, codeScrollPane, null);
 	}
@@ -288,36 +406,33 @@ private void openFile(final ActionEvent e) {
 	private void runCodeInOpenTab(final ActionEvent e) {
 		final Bytecode result = parseCodeInOpenTab();
 		if (result == null) return;
-		// if (!vm.execute(result)) {
-		// addConsoleMessage("Execution of bytecode failed with error
-		// %s.", vm.getError());
-		// } else {
-		// addConsoleMessage("Execution of bytecode successful. End
-		// state: %s.", vm);
-		// }
+
+		executor.execute(() -> {
+			vm.stopExecution();
+			vm.execute(result);
+		});
 	}
 
 	private void debugCodeInOpenTab(final ActionEvent e) {
-		parseResult = parseCodeInOpenTab();
-		if (parseResult == null) return;
+		final Bytecode result = parseCodeInOpenTab();
+		if (result == null) return;
 
-		isDebugging = true;
+		executor.execute(() -> {
+			vm.stopExecution();
+			vm.debug(result);
+		});
+	}
+
+	private void resumeExecution(final ActionEvent e) {
+		vm.resumeExecution();
+	}
 
-		resumeDebug(e);
+	private void pauseExecution(final ActionEvent e) {
+		vm.pauseExecution();
 	}
 
-	private void resumeDebug(final ActionEvent e) {
-		// if (vm.isDebugFinished()) {
-		// addConsoleMessage("Execution of bytecode successful. End
-		// state: %s.", vm);
-		// isDebugging = false;
-		// return;
-		// } else if (!vm.execute(parseResult.code,
-		// parseResult.instructionToLineNumber)) {
-		// addConsoleMessage("Execution of bytecode failed with error
-		// %s.", vm.getError());
-		// isDebugging = false;
-		// }
+	private void stopExecution(final ActionEvent e) {
+		vm.stopExecution();
 	}
 
 	private void closeCurrentProgramTab(final ActionEvent e) {
@@ -331,15 +446,36 @@ private void closeCurrentProgramTab(final ActionEvent e) {
 	}
 
 	private void addBreakpointAtCursor(final ActionEvent e) {
+		final int lineNumber = lineNumberAtCursor();
+		if (lineNumber == -1) {
+			addConsoleMessage("Could not add breakpoint at cursor, invalid line.");
+			return;
+		}
+
+		vm.addBreakpoint(vm.convertLineToPtr(lineNumber));
+		addConsoleMessage("Setting breakpoint at line %s.", lineNumber);
+	}
+
+	private void removeBreakpointAtCursor(final ActionEvent e) {
+		final int lineNumber = lineNumberAtCursor();
+		if (lineNumber == -1) {
+			addConsoleMessage("Could not remove breakpoint at cursor, invalid line.");
+			return;
+		}
+
+		vm.removeBreakpoint(vm.convertLineToPtr(lineNumber));
+		addConsoleMessage("Removing breakpoint at line %s.", lineNumber);
+	}
+
+	private int lineNumberAtCursor() {
 		try {
 			final JTextArea text = getCurrentProgramTextArea();
-			if (text == null) return;
+			if (text == null) return -1;
 			final int carretOffset = text.getCaretPosition();
-			final int lineNumber = text.getLineOfOffset(carretOffset);
-			// vm.setBreakpoint(lineNumber);
-			addConsoleMessage("Setting breakpoint at line %s.", lineNumber);
+			return text.getLineOfOffset(carretOffset) + 1;
 		} catch (final BadLocationException e1) {
-			addConsoleMessage("Could not add breakpoint at cursor. Error: %s.", e1);
+			addConsoleMessage("Could not fetch line number at cursor. Error: %s.", e1);
+			return -1;
 		}
 	}
 

src/main/java/se/student/liu/jessp088/vm/ui/LabeledTextArea.java

@@ -0,0 +1,94 @@
+package se.student.liu.jessp088.vm.ui;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+
+import javax.swing.text.BadLocationException;
+import javax.swing.text.Document;
+import javax.swing.text.JTextComponent;
+
+/*
+ *  Create a simple console to display text messages.
+ *
+ *  Messages can be directed here from different sources. Each source can
+ *  have its messages displayed in a different color.
+ *
+ *  Messages can either be appended to the console or inserted as the first
+ *  line of the console
+ *
+ *  You can limit the number of lines to hold in the Document.
+ */
+public class MessageConsole {
+	private final JTextComponent textComponent;
+	private final Document document;
+
+	public MessageConsole(final JTextComponent textComponent) {
+		this.textComponent = textComponent;
+		this.document = textComponent.getDocument();
+		textComponent.setEditable(false);
+	}
+
+	/* Redirect the output from the standard output to the console using the default text color and
+	 * null PrintStream */
+	public void redirectOut() {
+		final ConsoleOutputStream cos = new ConsoleOutputStream();
+		System.setOut(new PrintStream(cos, true));
+	}
+
+	/* Class to intercept output from a PrintStream and add it to a Document. The output can
+	 * optionally be redirected to a different PrintStream. The text displayed in the Document can
+	 * be color coded to indicate the output source. */
+	class ConsoleOutputStream extends ByteArrayOutputStream {
+		private final String EOL = System.getProperty("line.separator");
+		private final StringBuffer buffer = new StringBuffer(80);
+		private boolean isFirstLine;
+
+		/* Override this method to intercept the output text. Each line of text output will actually
+		 * involve invoking this method twice: a) for the actual text message b) for the newLine
+		 * string The message will be treated differently depending on whether the line will be
+		 * appended or inserted into the Document */
+		@Override
+		public void flush() {
+			final String message = toString();
+			if (message.length() == 0) return;
+			handleAppend(message);
+			reset();
+		}
+
+		/* We don't want to have blank lines in the Document. The first line added will simply be
+		 * the message. For additional lines it will be: newLine + message */
+		private void handleAppend(final String message) {
+			// This check is needed in case the text in the Document has been
+			// cleared. The buffer may contain the EOL string from the previous
+			// message.
+
+			if (document.getLength() == 0) buffer.setLength(0);
+
+			buffer.append(message);
+			if (!EOL.equals(message)) clearBuffer();
+		}
+
+		/* The message and the newLine have been added to the buffer in the appropriate order so we
+		 * can now update the Document and send the text to the optional PrintStream. */
+		private void clearBuffer() {
+			// In case both the standard out and standard err are being redirected
+			// we need to insert a newline character for the first line only
+
+			if (isFirstLine && document.getLength() != 0) {
+				buffer.insert(0, "\n");
+			}
+
+			isFirstLine = false;
+			final String line = buffer.toString();
+
+			try {
+				final int offset = document.getLength();
+				document.insertString(offset, line, null);
+				textComponent.setCaretPosition(document.getLength());
+			} catch (final BadLocationException ignored) {
+			}
+
+			buffer.setLength(0);
+		}
+	}
+}

src/main/java/se/student/liu/jessp088/vm/ui/MessageConsole.java

@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<configuration>
+<configuration scan="true">
 	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
 		<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-			<level>INFO</level>
+			<level>DEBUG</level>
 		</filter>
 
 		<encoder>

src/main/java/se/student/liu/jessp088/vm/ui/TextLineNumber.java

@@ -1,2 +1,2 @@
-#Sun Apr 01 23:06:39 CEST 2018
+#Mon Apr 09 15:30:50 CEST 2018
 version=0.0.1-SNAPSHOT

src/main/resources/logback.xml

@@ -2,15 +2,7 @@
 
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
-import static se.student.liu.jessp088.vm.parsing.TokenType.DEFINE;
-import static se.student.liu.jessp088.vm.parsing.TokenType.DEFTAG;
-import static se.student.liu.jessp088.vm.parsing.TokenType.EOF;
-import static se.student.liu.jessp088.vm.parsing.TokenType.EQUALS;
-import static se.student.liu.jessp088.vm.parsing.TokenType.IDENTIFIER;
-import static se.student.liu.jessp088.vm.parsing.TokenType.LEFTBRACKET;
-import static se.student.liu.jessp088.vm.parsing.TokenType.NEXTOP;
-import static se.student.liu.jessp088.vm.parsing.TokenType.NUMBER;
-import static se.student.liu.jessp088.vm.parsing.TokenType.RIGHTBRACKET;
+import static se.student.liu.jessp088.vm.parsing.TokenType.*;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -25,14 +17,14 @@
 import se.student.liu.jessp088.vm.parsing.Token;
 import se.student.liu.jessp088.vm.parsing.TokenType;
 import se.student.liu.jessp088.vm.parsing.exceptions.ParserException;
+import se.student.liu.jessp088.vm.parsing.suppliers.ReflectionSupplier;
 
-public class ParserTest
-{
+public class ParserTest {
 	private Parser parser;
 
 	@Before
-	public void setUp() throws Exception {
-		parser = new Parser();
+	public void setUp() {
+		parser = new Parser(new ReflectionSupplier());
 	}
 
 	@Test
@@ -71,7 +63,8 @@ public void test() {
 		try {
 			code = parser.parse(tokens);
 		} catch (final ParserException e) {
-			fail("Parsing of tokens " + tokens + " failed! Reason: " + e.getMessage());
+			fail("Parsing of tokens " + tokens + " failed! Reason: " + e);
+			e.printStackTrace();
 			return;
 		}
 

src/main/resources/stack_16.png

@@ -11,7 +11,6 @@
 
 import org.junit.Test;
 
-import se.student.liu.jessp088.vm.VirtualMachine.VMState;
 import se.student.liu.jessp088.vm.parsing.Lexer;
 import se.student.liu.jessp088.vm.parsing.Parser;
 import se.student.liu.jessp088.vm.parsing.Token;

src/main/resources/stack_32.png

@@ -10,17 +10,14 @@
 import org.junit.Before;
 import org.junit.Test;
 
-import se.student.liu.jessp088.vm.VirtualMachine.DebugListener;
-import se.student.liu.jessp088.vm.VirtualMachine.VMState;
 import se.student.liu.jessp088.vm.instructions.Instruction;
 import se.student.liu.jessp088.vm.instructions.Literal;
 import se.student.liu.jessp088.vm.instructions.arithmetic.Sub;
 import se.student.liu.jessp088.vm.instructions.control.Jmp;
 import se.student.liu.jessp088.vm.instructions.data.Load;
 import se.student.liu.jessp088.vm.instructions.data.Store;
 
-public class VirtualMachineTest
-{
+public class VirtualMachineTest {
 	private Bytecode code;
 	private VirtualMachine vm;
 

src/main/resources/version.properties

@@ -55,7 +55,7 @@ literal 0
 		mul
 		load #n
 		cmp 
-		jmpGT check_mod_i_exit
+		jmp_GT check_mod_i_exit
 		dup
 		load #n
 		swap