Adds a general conditional jump instruction (#44)

* Adds pseudo instructions for all comparisons
* Updates example programs
* Updates bf compiler
* Updates README

README.md

@@ -48,7 +48,7 @@ A couple of examples illustrating the language can be found in the `asm/` folder
 |`ATH`| `D, S, O, M, B` | `BBBMOOOOSSDD0100` | Perform an arithmetic operation on the source and destination registers. O specifies the operation (listed below) and M is the mode, where 0 = place result in destination register and 1 = place result in source register. If the instruction is right or left shift then B specifies the shifting value|
 |`CAL`| `D`             | `XXXXXXXXXXDD0101` | Call a function in memory pointed at by the destination register|
 |`RET`|                 | `XXXXXXXXXXXX0110` | Return from function|
-|`JLT`| `D, S`          | `XXXXXXXXSSDD0111` | Jump to memory address pointed at by the source register, if value in the A register is less than value in destination register|
+|`JCP`| `D, S, A, O`    | `XXXOOOAASSDD0111` | Jump to memory address pointed at by the address register, depending on the comparison specified by the O operation of the destination register and the source register. Operation table specified below.|
 |`PSH`| `S`             | `XXXXXXXXSSXX1000` | Push the value in source register onto the stack|
 |`POP`| `D`             | `XXXXXXXXXXDD1001` | Pop the stack into the destination register|
 |`SYS`|                 | `XXXXXXXXXXXX1010` | Perform a system call. This is described below in more detail.|
@@ -89,9 +89,14 @@ Pseudo instructions are prepocessed by the assembler and expanded into combinati
 |`NOT`      | `D`       |1                | Binary not (invert) the destination|
 |`LDV16`    | `D, V`    |2                | Load a 16 bit value into destination|
 |`SWP`      | `D, S`    |3                | Swap the values in the source and destination registers|
-|`JGE`      | `D, A`    |4                | Jump to address A if value in destination register is greater than or equal to the A register. Can potentially mutate all registers except A and destination|
-|`JEQ`      | `D, A`    |11               | Jump to address A if value in destination register is equal to the A register. Can potentially mutate all registers except A and destination|
-|`JNE`      | `D, A`    |14               | Jump to address A if value in destination register is not equal to the A register. Can potentially mutate all registers except A and destination|
+|`JEQ`      | `D, S, A` |1                | Jump to address A if value in destination register is equal to the source register.|
+|`JNE`      | `D, S, A` |1                | Jump to address A if value in destination register is not equal to the source register.|
+|`JLT`      | `D, S, A` |1                | Jump to address A if value in destination register is less than the source register.|
+|`JGT`      | `D, S, A` |1                | Jump to address A if value in destination register is greater than the source register.|
+|`JLE`      | `D, S, A` |1                | Jump to address A if value in destination register is less than or equal to the source register.|
+|`JGE`      | `D, S, A` |1                | Jump to address A if value in destination register is greater than or equal to the source register.|
+|`JZE`      | `D, S, A` |1                | Jump to address A if value in destination register is zero.|
+|`JNZ`      | `D, S, A` |1                | Jump to address A if value in destination register is not zero.|
 
 
 #### Arithmetic Operation table
@@ -111,6 +116,20 @@ Pseudo instructions are prepocessed by the assembler and expanded into combinati
 |`Xor`        |`1010` |
 |`Not`        |`1011` |
 
+#### Conditional Jump Operation table
+
+|Operation                |Value  |
+|-------------------------|-------|
+|`Equal`                  |`000` |
+|`Not equal`              |`001` |
+|`Less than`              |`010` |
+|`Greater than`           |`011` |
+|`Less than or equal`     |`100` |
+|`Greater than or equal`  |`101` |
+|`Zero`                   |`110` |
+|`Not zero`               |`111` |
+
+
 #### System calls
 
 A system call in the VM allows the program to ask resources outside of it's context, such as communication with stdin and stdout. System calls are passed off to the os module and can return their results directly into the CPUs registers.

asm/factorial.asm

@@ -20,7 +20,7 @@ factorial:
     pop A
     ldv B, 3
     ldv D, done:
-    jlt B, D
+    JLT A, B, D
 
     psh a
     psh b

asm/get-name.asm

@@ -18,7 +18,7 @@ get_name:
   ldv d, get_name:
   mov a, b
   ldv b, 1
-  jlt b, d              ; if a < 1, loop
+  jlt a, b, d              ; if a < 1, loop
 
   ;;;;; Place character into memory ;;;;
   ldv b, .name          ; get the start address of name
@@ -39,7 +39,7 @@ get_name:
 
   ;;;;; Got all the characters? ;;;;;;;;
   ldv c, final_zero:
-  jlt b, c              ; if (a < b) = (name_max < name_pointer), we are done
+  jlt a, b, c              ; if (a < b) = (name_max < name_pointer), we are done
   ldv c, get_name:      ; otherwise jump back to the beginning to get the next character
   jmr c
 

asm/loop-until-a-is-pressed.asm

@@ -27,6 +27,6 @@ main:
 
   loop:
     cal D
-    jne B, C
+    jne A, B, C
 
   hlt

src/assembler/assembler/instruction-encoder.js

@@ -6,7 +6,8 @@ const {
   SOURCE_SHIFT,
   LONG_ADDRESS_SHIFT,
   OFFSET_SHIFT,
-  ADDRESS_SHIFT,
+
+  JUMP,
 
   ARITHMETIC_MODE_SHIFT,
   OPERATION_SHIFT,
@@ -34,7 +35,7 @@ module.exports = {
   STR: (args) => opcodes.STR | (reg[args[0]] << DESTINATION_SHIFT) | (reg[args[1]] << SOURCE_SHIFT) | (args.length > 2 ? (args[2] << OFFSET_SHIFT) : 0),
   ATH: (args) => opcodes.ATH | (reg[args[0]] << DESTINATION_SHIFT) | (reg[args[1]] << SOURCE_SHIFT) | (args[2] << OPERATION_SHIFT) | (args[3] << ARITHMETIC_MODE_SHIFT) | (args[4] << BITWISE_SHIFT_SHIFT),
   CAL: (args) => opcodes.CAL | (reg[args[0]] << DESTINATION_SHIFT),
-  JLT: (args) => opcodes.JLT | (reg[args[0]] << DESTINATION_SHIFT) | (reg[args[1]] << SOURCE_SHIFT),
+  JCP: (args) => opcodes.JCP | (reg[args[0]] << JUMP.R1) | (reg[args[1]] << JUMP.R2) | (reg[args[2]] << JUMP.AR) | (args[3] << JUMP.OP),
   PSH: (args) => opcodes.PSH | (reg[args[0]] << SOURCE_SHIFT),
   POP: (args) => opcodes.POP | (reg[args[0]] << DESTINATION_SHIFT),
   JMP: (args) => opcodes.JMP | (reg[args[0]] << DESTINATION_SHIFT) | (args[1] << LONG_ADDRESS_SHIFT),

src/assembler/preprocessor/stages/pseudo-instructions/expanders/conditional/JEQ.js

@@ -1,43 +1,7 @@
-const {
-  getInstructionArguments,
-  uniqueLabel,
-  getUsableRegister
-} = require('../../../../utils');
+const { getInstructionArguments } = require('../../../../utils');
+const { JUMP } = require('../../../../../../constants');
 
 module.exports = (instruction) => {
-  const [source, addressRegister] = getInstructionArguments(instruction);
-  const mutableRegister = getUsableRegister(source, addressRegister);
-
-  const firstCheck = uniqueLabel();
-  const equal = uniqueLabel();
-  const notEqual = uniqueLabel();
-
-  return [
-    `PSH ${mutableRegister}`,                   // Push mr [mr]
-
-    `PSH ${addressRegister}`,                   // Push ar [ar, mr]
-    `LDV16 ${addressRegister}, ${firstCheck}`,
-    `LDV16 ${mutableRegister}, ${notEqual}`,
-
-    `JGE ${source}, ${addressRegister}`,
-    `JMR ${mutableRegister}`,
-
-    `${firstCheck}`,
-    `LDV16 ${addressRegister}, ${equal}`,
-    `SWP A, ${source}`,
-    `JGE ${source}, ${addressRegister}`,
-
-    `SWP A, ${source}`,
-    `JMR ${mutableRegister}`,
-
-    `${equal}`,
-    `SWP A, ${source}`,
-    `POP ${addressRegister}`,                 // Pop ar [mr]
-    `POP ${mutableRegister}`,                 // Pop mr []
-    `JMR ${addressRegister}`,
-
-    `${notEqual}`,
-    `POP ${addressRegister}`,                 // Pop ar [mr]
-    `POP ${mutableRegister}`                  // Pop mr []
-  ];
-}
+  const [r1, r2, addressRegister] = getInstructionArguments(instruction);
+  return [`JCP ${r1}, ${r2}, ${addressRegister}, ${JUMP.EQ}`];
+};

src/assembler/preprocessor/stages/pseudo-instructions/expanders/conditional/JGE.js

@@ -1,24 +1,7 @@
-const {
-  getInstructionArguments,
-  uniqueLabel,
-  getUsableRegister
-} = require('../../../../utils');
-
+const { getInstructionArguments } = require('../../../../utils');
+const { JUMP } = require('../../../../../../constants');
 
 module.exports = (instruction) => {
-  const [source, addressRegister] = getInstructionArguments(instruction);
-  const lessThan = uniqueLabel();
-  const mutableRegister = getUsableRegister(source, addressRegister);
-
-  return [
-    `PSH ${mutableRegister}`,
-    `LDV16 ${mutableRegister}, ${lessThan}`,
-
-    `JLT ${source}, ${mutableRegister}`,
-    `POP ${mutableRegister}`,
-    `JMR ${addressRegister}`,
-
-    `${lessThan}`,
-    `POP ${mutableRegister}`
-  ];
-}
+  const [r1, r2, addressRegister] = getInstructionArguments(instruction);
+  return [`JCP ${r1}, ${r2}, ${addressRegister}, ${JUMP.GTE}`];
+};

src/assembler/preprocessor/stages/pseudo-instructions/expanders/conditional/JGT.js

@@ -0,0 +1,7 @@
+const { getInstructionArguments } = require('../../../../utils');
+const { JUMP } = require('../../../../../../constants');
+
+module.exports = (instruction) => {
+  const [r1, r2, addressRegister] = getInstructionArguments(instruction);
+  return [`JCP ${r1}, ${r2}, ${addressRegister}, ${JUMP.GT}`];
+};

src/assembler/preprocessor/stages/pseudo-instructions/expanders/conditional/JLE.js

@@ -0,0 +1,7 @@
+const { getInstructionArguments } = require('../../../../utils');
+const { JUMP } = require('../../../../../../constants');
+
+module.exports = (instruction) => {
+  const [r1, r2, addressRegister] = getInstructionArguments(instruction);
+  return [`JCP ${r1}, ${r2}, ${addressRegister}, ${JUMP.JLE}`];
+};

src/assembler/preprocessor/stages/pseudo-instructions/expanders/conditional/JLT.js

@@ -0,0 +1,7 @@
+const { getInstructionArguments } = require('../../../../utils');
+const { JUMP } = require('../../../../../../constants');
+
+module.exports = (instruction) => {
+  const [r1, r2, addressRegister] = getInstructionArguments(instruction);
+  return [`JCP ${r1}, ${r2}, ${addressRegister}, ${JUMP.LT}`];
+};

src/assembler/preprocessor/stages/pseudo-instructions/expanders/conditional/JNE.js

@@ -1,23 +1,7 @@
-const {
-  getInstructionArguments,
-  uniqueLabel,
-  getUsableRegister
-} = require('../../../../utils');
+const { getInstructionArguments } = require('../../../../utils');
+const { JUMP } = require('../../../../../../constants');
 
 module.exports = (instruction) => {
-  const [source, addressRegister] = getInstructionArguments(instruction);
-  const equal = uniqueLabel();
-  const mutableRegister = getUsableRegister(source, addressRegister);
-
-  return [
-    `PSH ${mutableRegister}`,
-    `LDV16 ${mutableRegister}, ${equal}`,
-
-    `JEQ ${source}, ${mutableRegister}`,
-    `POP ${mutableRegister}`,
-    `JMR ${addressRegister}`,
-
-    `${equal}`,
-    `POP ${mutableRegister}`
-  ];
-}
+  const [r1, r2, addressRegister] = getInstructionArguments(instruction);
+  return [`JCP ${r1}, ${r2}, ${addressRegister}, ${JUMP.NEQ}`];
+};

src/assembler/preprocessor/stages/pseudo-instructions/expanders/conditional/JNZ.js

@@ -0,0 +1,7 @@
+const { getInstructionArguments } = require('../../../../utils');
+const { JUMP } = require('../../../../../../constants');
+
+module.exports = (instruction) => {
+  const [r1, r2, addressRegister] = getInstructionArguments(instruction);
+  return [`JCP ${r1}, ${r2}, ${addressRegister}, ${JUMP.NZE}`];
+};

src/assembler/preprocessor/stages/pseudo-instructions/expanders/conditional/JZE.js

@@ -0,0 +1,7 @@
+const { getInstructionArguments } = require('../../../../utils');
+const { JUMP } = require('../../../../../../constants');
+
+module.exports = (instruction) => {
+  const [r1, r2, addressRegister] = getInstructionArguments(instruction);
+  return [`JCP ${r1}, ${r2}, ${addressRegister}, ${JUMP.ZER}`];
+};

src/assembler/preprocessor/stages/pseudo-instructions/expanders/conditional/index.js

@@ -1,9 +1,19 @@
 const JEQ = require('./JEQ');
-const JGE = require('./JGE');
 const JNE = require('./JNE');
+const JLT = require('./JLT');
+const JGT = require('./JGT');
+const JLE = require('./JLE');
+const JGE = require('./JGE');
+const JZE = require('./JZE');
+const JNZ = require('./JNZ');
 
 module.exports = {
   JEQ,
+  JNE,
+  JLT,
+  JGT,
+  JLE,
   JGE,
-  JNE
+  JZE,
+  JNZ
 };

src/compilers/bf/asm/header.js

@@ -46,7 +46,7 @@ input:
   mov A, B            ; swap A and B
   ldv B, 1            ; load 1 into B for comparison
   ldv C, input:       ; load the input address into C
-  jlt B, C            ; if A < 1(B), loop back to input
+  jlt A, B, C            ; if A < 1(B), loop back to input
   psh A               ; push the character into stack
   ldv16 A, .offset    ; Same procedure as inc_mem_ptr, except just set the value directly
   ldr B, A

src/compilers/bf/asm/loop-end.js

@@ -8,6 +8,6 @@ ldr B, A            ; B = value at [memory + offset]
 mov A, B            ; A = value at [memory + offset]
 ldv B, 1            ; Set B to comparison value of 1
 ldv C, ${label}
-jge B, C     ; A(Memory value) >= B(1), then jump
+jge A, B, C     ; A(Memory value) >= B(1), then jump
 
 `;

src/constants.js

@@ -10,7 +10,7 @@ module.exports = {
     'STA',
     'ATH',
     'CAL',
-    'JLT',
+    'JCP',
     'RET',
     'PSH',
     'POP',
@@ -30,6 +30,22 @@ module.exports = {
   ARITHMETIC_MODE_SHIFT: 12,
   BITWISE_SHIFT_SHIFT: 13,
 
+  JUMP: {
+    EQ: 0,
+    NEQ: 1,
+    LT: 2,
+    GT: 3,
+    LTE: 4,
+    GTE: 5,
+    ZER: 6,
+    NZE: 7,
+
+    R1: 4,
+    R2: 6,
+    AR: 8,
+    OP: 10
+  },
+
   ARITHMETIC: {
     ADD: 0,
     SUB: 1,