Added tests and then implementation for the new scoping ops to create a

pointer to local variables on the stack. Possible to create a new block
and end it. Can use get to access local vars from the current scope or
the containing static scope. Can use local to save a little op space and
get vars from the current block. The only thing to note is that these
accessors only take words for the block and scope so one is limited to
255 local vars, including array sizes. It might be better to make them
    use dwords to allow for more, or expect that the programmer can use
    static or free memory for this task. The other possible issue is
    that begin used in a function may cause issues as the previous block
    in nested function calls may not be the static scope of the
    function but instead the scope of the calling function, which is not
    the desired behaviour.

Author: strinsberg

main.c

@@ -144,6 +144,10 @@ enum OP{ HALT=0x00,
   ADD_F, SUB_F, MULT_F, DIV_F,  // 59
   EQ_F, LT_F, GT_F,  // 5C
   PRINT_F, READ_F,  // 5E
+
+  BEGIN, END, SCP, // 61
+  LOCAL, LOCAL_D, LOCAL_Q,  // 64
+  GET, GET_D, GET_Q,  // 67
 };
 
 // Simple Memory /////////////////////////////////////////////////////////////
@@ -185,6 +189,17 @@ static inline void set_qword(WORD* mem, ADDR addr, QWORD data) {
   mem[addr+3] = (WORD)data;
 }
 
+static inline ADDR get_block(WORD* mem, ADDR scp, WORD scopes_above) {
+  ADDR block = get_address(mem, scp);
+  ADDR next = block;
+  for (size_t i = 0; i < scopes_above; i++) {
+    next = get_address(mem, next);
+    if (next == 0xffff) break;
+    block = next;
+  }
+  return block;
+}
+
 // I/O ///////////////////////////////////////////////////////////////////////
 size_t read_program(WORD* mem, const char* filename) {
   FILE* fptr = fopen(filename, "rb");
@@ -232,7 +247,7 @@ void debug_memory(WORD* mem, ADDR start, ADDR end) {
 // Main //////////////////////////////////////////////////////////////////////
 int main( int argc, char *argv[] ) {
   // Some variables we need
-  ADDR sp, bp, pc, ra, fp, prog_len, brk;
+  ADDR sp, bp, pc, ra, fp, prog_len, brk, scp;
   WORD* mem;
 
   // Allocate memory for the VM
@@ -261,11 +276,12 @@ int main( int argc, char *argv[] ) {
   bp = LAST_ADDR - 3;
   fp = bp;
   sp = bp;
+  scp = bp;
 
   // To help keep track if memory in this offset is accidentaly accessed
-  mem[bp] = 0xaa;
-  mem[bp+1] = 0xbb;
-  mem[bp+2] = 0xcc;
+  mem[bp] = 0xff;
+  mem[bp+1] = 0xff;
+  mem[bp+2] = 0x00;
   mem[bp+3] = 0x00;
 
   // Debug info
@@ -791,6 +807,54 @@ int main( int argc, char *argv[] ) {
         break;
         }
 
+      /// Blocks ///
+      case BEGIN:
+        sp-=2;
+        set_address(mem, sp, scp);
+        scp = sp;
+        break;
+      case END:
+        sp = scp + 2;
+        scp = get_address(mem, scp);
+        break;
+      case LOCAL:
+        mem[--sp] = mem[(scp - 1) - mem[++pc]];
+        break;
+      case LOCAL_D:
+        sp-=2;
+        set_dword(mem, sp, get_dword(mem, (scp - 2) - mem[++pc]));
+        break;
+      case LOCAL_Q:
+        sp-=4;
+        set_qword(mem, sp, get_qword(mem, (scp - 4) - mem[++pc]));
+        break;
+      case GET:
+        {
+          WORD scope = mem[++pc];
+          WORD offset = mem[++pc];
+          ADDR block = get_block(mem, scp, scope);
+          mem[--sp] = mem[(block - 1) - offset];
+        }
+        break;
+      case GET_D:
+        {
+          WORD scope = mem[++pc];
+          WORD offset = mem[++pc];
+          ADDR block = get_block(mem, scp, scope);
+          sp-=2;
+          set_dword(mem, sp, get_dword(mem, (block - 2) - offset));
+        }
+        break;
+      case GET_Q:
+        {
+          WORD scope = mem[++pc];
+          WORD offset = mem[++pc];
+          ADDR block = get_block(mem, scp, scope);
+          sp-=4;
+          set_qword(mem, sp, get_qword(mem, (block - 4) - offset));
+        }
+        break;
+
       /// BAD OP CODE ///
       default:
         fprintf(stderr, "Error: Unknown OP code: 0x%02x\n", mem[pc]);

test/test_movement_ops.py

@@ -152,6 +152,44 @@
         "10 00 0a 55 00",
         "ff ff"
     ),
+
+    ### Blocks and scoping ###
+    Test(
+        "Create a new block and GET upper scope local var",
+        "01 aa 5F 01 bb 65 01 00 00",
+        "aa bb ff fc aa"
+    ),
+    Test(
+        "Create a new block and GET_D upper scope local var",
+        "10 aa bb 5F 01 cc 66 01 00 00",
+        "aa bb cc ff fc aa bb"
+    ),
+    Test(
+        "Create a new block and GET_Q upper scope local var",
+        "1F aa bb cc dd 5F 01 ee 67 01 00 00",
+        "aa bb cc dd ee ff fc aa bb cc dd"
+    ),
+    Test(
+        "Create a new block and GET upper scope local var then END",
+        "01 aa 5F 01 bb 65 01 00 60 00",
+        "aa"
+    ),
+    Test(
+        "Create a new block and get LOCAL var",
+        "01 aa 5F 01 bb 01 cc 01 dd 62 01 00",
+        "cc dd cc bb ff fc aa"
+    ),
+    Test(
+        "Create a new block and get LOCAL_D var",
+        "01 aa 5F 01 bb 10 cc ee 01 dd 63 01 00",
+        "cc ee dd cc ee bb ff fc aa"
+    ),
+    Test(
+        "Create a new block and get LOCAL_Q var",
+        "01 aa 5F 01 bb 1F cc ee ff 22 01 dd 64 01 00",
+        "cc ee ff 22 dd cc ee ff 22 bb ff fc aa"
+    ),
+
 ]