Finishing touches

app/src/main/java/Programs/Factorial.java

@@ -0,0 +1,20 @@
+package Programs;
+
+import hatelace.*;
+import hatelace.instructions.*;
+
+public class Factorial extends Program {
+    public Factorial() {
+        Address n = new Address(0),
+                fac = new Address(1);
+
+        add(new Copy(new IntWord(5), n));
+        add(new Copy(new IntWord(1), fac));
+        add(new JumpEq(6, n, new IntWord(1)));
+        add(new Mul(fac, n, fac));
+        add(new Add(n, new IntWord(-1), n));
+        add(new Jump(2));
+        add(new Print(fac));
+        add(new Halt());
+    }
+}

app/src/main/java/hatelace/Computer.java

@@ -15,7 +15,7 @@ public class Computer {
     public void run() {
         // Note that the instructions themselves are responsible for incrementing the PC
         for(ProgramCounter PC = new ProgramCounter(); PC.getPC() < this.program.size() && !PC.halted() && PC.getSysTicks() < 100; ) {
-            program.getInstructions()[PC.getPC()].execute(this.memory, PC);
+            program.get(PC.getPC()).execute(this.memory, PC);
         }
     }
 }

app/src/main/java/hatelace/Main.java

@@ -1,6 +1,6 @@
 package hatelace;
 
-import hatelace.instructions.*;
+import Programs.Factorial;
 
 public class Main {
     public static void main(String[] args) {
@@ -8,26 +8,15 @@ public class Main {
 
         Memory memory = new IntMemory(64); // 64 words of memory
         Computer computer = new Computer(memory);
+        Program program = new Factorial();
 
-        Address n = new Address(0), fac = new Address(1);
-
-        Program program = new Program(new Instruction[] {
-            new Copy(new IntWord(5), n),
-            new Copy(new IntWord(1), fac),
-            new JumpEq(6, n, new IntWord(1)),
-            new Mul(fac, n, fac),
-            new Add(n, new IntWord(-1), n),
-            new Jump(2),
-            new Print(fac),
-            new Halt()
-        });
         computer.load(program);
         computer.run();
         memory.dump();
 
         // Print the program
         System.out.println("Program:");
-        for (Instruction instruction : program.getInstructions()) {
+        for (Instruction instruction : program) {
             System.out.println(instruction);
         }
 

app/src/main/java/hatelace/Program.java

@@ -1,17 +1,6 @@
 package hatelace;
 
-public class Program {
-    private Instruction[] instructions;
+import java.util.ArrayList;
 
-    public Program(Instruction[] instructions) {
-        this.instructions = instructions;
-    }
-
-    public Instruction[] getInstructions() {
-        return this.instructions;
-    }
-
-    public int size() {
-        return this.instructions.length;
-    }
-}
+// This is simply an intermediate class to comply with the specified API requirements.
+public abstract class Program extends ArrayList<Instruction> {}

app/src/main/java/hatelace/instructions/Add.java

@@ -3,18 +3,19 @@ package hatelace.instructions;
 import hatelace.*;
 
 public class Add extends Instruction {
-    private Address op1;
-    private Word op2;
+    private Address src;
+    private Word imm;
     private Address dest;
 
-    public Add(Address op1, Word op2, Address dest) {
-        this.op1 = op1;
-        this.op2 = op2;
+    /** Add immediate value to memory address. */
+    public Add(Address src, Word imm, Address dest) {
+        this.src = src;
+        this.imm = imm;
         this.dest = dest;
     }
 
     public void execute(Memory memory, ProgramCounter PC) {
-        memory.write(this.dest, memory.read(this.op1).add(this.op2));
+        memory.write(this.dest, memory.read(this.src).add(this.imm));
         PC.incPC();
     }
 
@@ -23,6 +24,6 @@ public class Add extends Instruction {
     }
 
     protected Object[] operands() {
-        return new Object[] { this.op1, this.op2, this.dest };
+        return new Object[] { this.src, this.imm, this.dest };
     }
 }

app/src/main/java/hatelace/instructions/Copy.java

@@ -3,16 +3,17 @@ package hatelace.instructions;
 import hatelace.*;
 
 public class Copy extends Instruction {
-    private Word word;
-    private Address address;
+    private Word imm;
+    private Address dest;
 
-    public Copy(Word word, Address address) {
-        this.word = word;
-        this.address = address;
+    /** Copy immediate value to memory address. */
+    public Copy(Word imm, Address dest) {
+        this.imm = imm;
+        this.dest = dest;
     }
 
     public void execute(Memory memory, ProgramCounter PC) {
-        memory.write(this.address, this.word);
+        memory.write(this.dest, this.imm);
         PC.incPC();
     }
 
@@ -21,6 +22,6 @@ public class Copy extends Instruction {
     }
 
     protected Object[] operands() {
-        return new Object[] {this.word, this.address};
+        return new Object[] {this.imm, this.dest};
     }
 }

app/src/main/java/hatelace/instructions/Halt.java

@@ -3,6 +3,7 @@ package hatelace.instructions;
 import hatelace.*;
 
 public class Halt extends Instruction {
+    /** Halts the CPU */
     public Halt(){};
 
     public void execute(Memory memory, ProgramCounter PC) {

app/src/main/java/hatelace/instructions/Jump.java

@@ -5,6 +5,7 @@ import hatelace.*;
 public class Jump extends Instruction {
     private int index;
 
+    /** Unconditional jump, non-relative */
     public Jump(int index) {
         this.index = index;
     }

app/src/main/java/hatelace/instructions/JumpEq.java

@@ -4,17 +4,18 @@ import hatelace.*;
 
 public class JumpEq extends Instruction {
     private int index;
-    private Address address;
-    private Word value;
+    private Address src;
+    private Word imm;
 
-    public JumpEq(int index, Address address, Word value) {
+    /** Conditional jump */
+    public JumpEq(int index, Address src, Word imm) {
         this.index = index;
-        this.address = address;
-        this.value = value;
+        this.src = src;
+        this.imm = imm;
     }
 
     public void execute(Memory memory, ProgramCounter PC) {
-        if (this.value.equals(memory.read(this.address))) {
+        if (this.imm.equals(memory.read(this.src))) {
             PC.setPC(this.index);
         } else {
             PC.incPC();
@@ -26,6 +27,6 @@ public class JumpEq extends Instruction {
     }
 
     protected Object[] operands() {
-        return new Object[] {this.index, this.address, this.value};
+        return new Object[] {this.index, this.src, this.imm};
     }
 }

app/src/main/java/hatelace/instructions/Mul.java

@@ -3,18 +3,19 @@ package hatelace.instructions;
 import hatelace.*;
 
 public class Mul extends Instruction {
-    private Address op1;
-    private Address op2;
+    private Address src1;
+    private Address src2;
     private Address dest;
 
-    public Mul(Address op1, Address op2, Address dest) {
-        this.op1 = op1;
-        this.op2 = op2;
+    /** Multiply contents of two addresses and store the result in a third memory address. */
+    public Mul(Address src1, Address src2, Address dest) {
+        this.src1 = src1;
+        this.src2 = src2;
         this.dest = dest;
     }
 
     public void execute(Memory memory, ProgramCounter PC) {
-        memory.write(this.dest, memory.read(this.op1).multiply(memory.read(this.op2)));
+        memory.write(this.dest, memory.read(this.src1).multiply(memory.read(this.src2)));
         PC.incPC();
     }
 
@@ -23,6 +24,6 @@ public class Mul extends Instruction {
     }
 
     protected Object[] operands() {
-        return new Object[] {this.op1, this.op2, this.dest};
+        return new Object[] { this.src1, this.src2, this.dest };
     }
 }

app/src/main/java/hatelace/instructions/Print.java

@@ -5,6 +5,7 @@ import hatelace.*;
 public class Print extends Instruction {
     private Address address;
 
+    /** Print content of memory address */
     public Print(Address address) {
         this.address = address;
     }