Some instruction changes to improve usability. Minor bug fix.

Author: mnordahl

README.md

@@ -74,8 +74,8 @@ our code of conduct and the process for submitting pull requests to us.
 
 ## License
 
-This project is licensed under the [Your Choice of License] - see the LICENSE.md
-file for details.
+This project is licensed under the Apache License 2.0 - see the LICENSE.md file
+for details.
 
 ## Acknowledgments
 

src/main/java/instruction/Inc.java

@@ -0,0 +1,34 @@
+package instruction;
+
+import io.IO;
+import model.Memory;
+import model.ProgramCounter;
+import model.Registry;
+
+public class Inc extends Instruction {
+
+  public Inc(int operand) {
+    super(InstructionFactory.INST_NAME_INC, operand);
+  }
+
+  @Override
+  protected void internalExecute(Memory mem, Registry reg, ProgramCounter pc, IO io) {
+    // Operand is a register index, to be incremented.
+    reg.setValueAt(operand, reg.getValueAt(operand) + 1);
+  }
+
+  @Override
+  protected String printOperand() {
+    return String.format("(%s)", Registry.idxToName(operand));
+  }
+
+  @Override
+  public int[] getAffectedMemoryCells(Memory mem, Registry reg, ProgramCounter pc) {
+    return new int[] {pc.getCurrentIndex()};
+  }
+
+  @Override
+  public int[] getAffectedRegisters(Memory mem, Registry reg, ProgramCounter pc) {
+    return new int[] {operand};
+  }
+}

src/main/java/instruction/InstructionFactory.java

@@ -9,25 +9,27 @@ public class InstructionFactory {
   public static final int INST_NOP = 000; // No-op
   public static final int INST_ADD = 0x10; // Addition
   public static final int INST_SUB = 0x20; // Subtraction
-  public static final int INST_CPY = 0x30; // Copy value from one cell to another
-  public static final int INST_MOV = 0x40; // Move value from one cell to another
-  public static final int INST_LOD = 0x50; // Load the next value from memory into registry
-  public static final int INST_LDA = 0x60; // Load address (resolve first) into registry
-  public static final int INST_STO = 0x70; // Store register value in memory
-  public static final int INST_JMP = 0x80; // Jump to address
-  public static final int INST_JEQ = 0x90; // Jump if equal
-  public static final int INST_JNE = 0xA0; // Jump if not equal
-  public static final int INST_PRT = 0xB0; // Print
-  public static final int INST_PRD = 0xC0; // Print
-  public static final int INST_PRL = 0xD0; // Print Loop
-  public static final int INST_HLT = 0xE0; // Halt
+  public static final int INST_INC = 0x30; // Subtraction
+  public static final int INST_CPY = 0x40; // Copy value from one cell to another
+  public static final int INST_MOV = 0x50; // Move value from one cell to another
+  public static final int INST_LOD = 0x60; // Load the next value from memory into registry
+  public static final int INST_LDA = 0x70; // Load address (resolve first) into registry
+  public static final int INST_STO = 0x80; // Store register value in memory
+  public static final int INST_JMP = 0x90; // Jump to address
+  public static final int INST_JEQ = 0xA0; // Jump if equal
+  public static final int INST_JNE = 0xB0; // Jump if not equal
+  public static final int INST_PRT = 0xC0; // Print
+  public static final int INST_PRD = 0xD0; // Print
+  public static final int INST_PRL = 0xE0; // Print Loop
+  public static final int INST_HLT = 0xF0; // Halt
 
   // PRT
   // Add 2 columns: Instr, Char
 
   public static final String INST_NAME_NOP = "NOP";
   public static final String INST_NAME_ADD = "ADD";
   public static final String INST_NAME_SUB = "SUB";
+  public static final String INST_NAME_INC = "INC";
   public static final String INST_NAME_CPY = "CPY";
   public static final String INST_NAME_MOV = "MOV";
   public static final String INST_NAME_LOD = "LD";
@@ -45,6 +47,7 @@ public boolean isInstruction(int code) {
     return code == INST_NOP
         || code == INST_ADD
         || code == INST_SUB
+        || code == INST_INC
         || code == INST_CPY
         || code == INST_MOV
         || code == INST_LOD
@@ -70,6 +73,8 @@ public Instruction createInstruction(int code) {
         return new Add(operand);
       case INST_SUB:
         return new Sub(operand);
+      case INST_INC:
+        return new Inc(operand);
       case INST_CPY:
         return new Cpy(operand);
       case INST_MOV:
@@ -83,7 +88,7 @@ public Instruction createInstruction(int code) {
       case INST_JMP:
         return new Jmp(operand);
       case INST_JEQ:
-        return new Je(operand);
+        return new Jeq(operand);
       case INST_JNE:
         return new Jne(operand);
       case INST_PRT:

src/main/java/instruction/Je.java

@@ -0,0 +1,67 @@
+package instruction;
+
+import io.IO;
+import model.Memory;
+import model.ProgramCounter;
+import model.Registry;
+
+public class Jeq extends Instruction {
+
+  public Jeq(int operand) {
+    super(InstructionFactory.INST_NAME_JEQ, operand);
+  }
+
+  @Override
+  protected void internalExecute(Memory mem, Registry reg, ProgramCounter pc, IO io) {
+    // Read next value, and split into two 4-bit operands.
+    int value = mem.getValueAt(pc.next());
+    int op1 = value >> 4;
+    int op2 = value & 0xF;
+
+    // Read the next value, use as the destination address.
+    int dst = mem.getValueAt(pc.next());
+
+    int a = reg.getValueAt(op1);
+    int b = reg.getValueAt(op2);
+
+    if (a == b) {
+      pc.jumpTo(dst);
+    }
+  }
+
+  @Override
+  protected String printOperand() {
+    return "";
+  }
+
+  @Override
+  public int[] getAffectedMemoryCells(Memory mem, Registry reg, ProgramCounter pc) {
+    int cur = pc.getCurrentIndex();
+
+    int value = mem.getValueAt(cur + 1);
+    int op1 = value >> 4;
+    int op2 = value & 0xF;
+
+    int dst = mem.getValueAt(cur + 2);
+
+    int a = reg.getValueAt(op1);
+    int b = reg.getValueAt(op2);
+
+    if (a == b) {
+      return new int[] {cur, cur + 1, cur + 2, dst};
+    }
+
+    return new int[] {cur, cur + 1, cur + 2};
+  }
+
+  @Override
+  public int[] getAffectedRegisters(Memory mem, Registry reg, ProgramCounter pc) {
+    int cur = pc.getCurrentIndex();
+
+    int value = mem.getValueAt(cur + 1);
+    int op1 = value >> 4;
+    int op2 = value & 0xF;
+
+    return new int[] {op1, op2};
+  }
+}

src/main/java/instruction/Jeq.java

@@ -13,24 +13,25 @@ public Jmp(int operand) {
 
   @Override
   protected void internalExecute(Memory mem, Registry reg, ProgramCounter pc, IO io) {
-    // Destination address is read from register indexed by operand.
-    int dst = reg.getValueAt(operand);
+    // Read the next value, use as the destination address.
+    int dst = mem.getValueAt(pc.next());
     pc.jumpTo(dst);
   }
 
   @Override
   protected String printOperand() {
-    return String.format("(dst: %s)", Registry.idxToName(operand));
+    return "";
   }
 
   @Override
   public int[] getAffectedMemoryCells(Memory mem, Registry reg, ProgramCounter pc) {
-    int dst = reg.getValueAt(operand);
-    return new int[] {pc.getCurrentIndex(), dst};
+    int cur = pc.getCurrentIndex();
+    int dst = mem.getValueAt(cur + 1);
+    return new int[] {cur, cur + 1, dst};
   }
 
   @Override
   public int[] getAffectedRegisters(Memory mem, Registry reg, ProgramCounter pc) {
-    return new int[] {operand};
+    return new int[0];
   }
 }

src/main/java/instruction/Jmp.java

@@ -13,40 +13,55 @@ public Jne(int operand) {
 
   @Override
   protected void internalExecute(Memory mem, Registry reg, ProgramCounter pc, IO io) {
-    // Destination address is read from register indexed by operand.
-    // Values being compared are read from the registers OP1 and OP2.
+    // Read next value, and split into two 4-bit operands.
+    int value = mem.getValueAt(pc.next());
+    int op1 = value >> 4;
+    int op2 = value & 0xF;
 
-    int a = reg.getRegister(Registry.REG_OP1);
-    int b = reg.getRegister(Registry.REG_OP2);
+    // Read the next value, use as the destination address.
+    int dst = mem.getValueAt(pc.next());
+
+    int a = reg.getValueAt(op1);
+    int b = reg.getValueAt(op2);
 
     if (a != b) {
-      int dst = reg.getValueAt(operand);
       pc.jumpTo(dst);
     }
   }
 
   @Override
   protected String printOperand() {
-    return String.format("(dst: %s)", Registry.idxToName(operand));
+    return "";
   }
 
   @Override
   public int[] getAffectedMemoryCells(Memory mem, Registry reg, ProgramCounter pc) {
-    int a = reg.getRegister(Registry.REG_OP1);
-    int b = reg.getRegister(Registry.REG_OP2);
+    int cur = pc.getCurrentIndex();
 
-    if (a != b) {
-      int dst = reg.getValueAt(operand);
-      return new int[] {pc.getCurrentIndex(), dst};
+    int value = mem.getValueAt(cur + 1);
+    int op1 = value >> 4;
+    int op2 = value & 0xF;
+
+    int dst = mem.getValueAt(cur + 2);
+
+    int a = reg.getValueAt(op1);
+    int b = reg.getValueAt(op2);
+
+    if (a == b) {
+      return new int[] {cur, cur + 1, cur + 2, dst};
     }
 
-    return new int[] {pc.getCurrentIndex()};
+    return new int[] {cur, cur + 1, cur + 2};
   }
 
   @Override
   public int[] getAffectedRegisters(Memory mem, Registry reg, ProgramCounter pc) {
-    return new int[] {
-      Registry.nameToIdx(Registry.REG_OP1), Registry.nameToIdx(Registry.REG_OP2), operand
-    };
+    int cur = pc.getCurrentIndex();
+
+    int value = mem.getValueAt(cur + 1);
+    int op1 = value >> 4;
+    int op2 = value & 0xF;
+
+    return new int[] {op1, op2};
   }
 }

src/main/java/instruction/Jne.java

@@ -264,6 +264,7 @@ public void endSelection() {
       selectStartRange = range.from();
       selectEndRange = range.to();
       mouseSelectingOngoing = false;
+      caretPosRow = selectStartRange;
       paintRange(range);
     }
   }