remove arrmap

src/main.rs

@@ -1,4 +1,3 @@
-use std::collections::HashMap;
 use std::env;
 use std::fmt;
 use std::fs;
@@ -7,7 +6,6 @@ use text_io::read;
 struct UMState {
     pc: usize,                     // program counter
     regs: [u32; 8],                // register contents
-    arrmap: HashMap<u32, usize>,   // active arrays
     mem: Vec<Vec<u32>>             // memory contents (array of arrays)
 }
 
@@ -175,14 +173,26 @@ fn um_step(um: &mut UMState, op: UMOp) {
         },
         UMOp::Allocate(b, c) => {
             let new_arr = vec![0u32; um.regs[c as usize] as usize];
-            let new_arr_add = um.mem.len() as u32;
-            um.mem.push(new_arr);
-            um.arrmap.insert(new_arr_add, new_arr_add as usize);
-            um.regs[b as usize] = new_arr_add;
+            let l = um.mem.len();
+            let mut new_arr_add = 0;
+            for i in 1..l {
+                if um.mem[i].len() == 0 {
+                    new_arr_add = i;
+                    break
+                }
+            }
+
+            if new_arr_add > 0 {
+                um.mem[new_arr_add] = new_arr;
+                um.regs[b as usize] = new_arr_add as u32;
+            } else {
+                um.mem.push(new_arr);
+                um.regs[b as usize] = l as u32;
+            }
+            //println!("num of arrays: {}", um.mem.len());
         },
         UMOp::Abandon(c) => {
-            let i = um.arrmap[&um.regs[c as usize]];
-            um.arrmap.remove(&um.regs[c as usize]);
+            let i = um.regs[c as usize] as usize;
             um.mem[i] = vec![0u32; 0];
         },
         UMOp::Output(c) => {
@@ -211,7 +221,7 @@ fn um_step(um: &mut UMState, op: UMOp) {
 
 fn um_run(um: &mut UMState) {
     loop {
-        let instr = um.mem[um.arrmap[&0]][um.pc];
+        let instr = um.mem[0][um.pc];
         let full_op = parse_instr(instr);
         //println!("{}", full_op);
 
@@ -227,6 +237,9 @@ fn main() {
     let codex8 = &fs::read(&args[1]).unwrap();
 
     let mut codex = vec![0u32; codex8.len() / 4];
+    let zeroarr = vec![0u32; 0];
+
+    let mut mem = vec![vec![0u32; 0]; u16::MAX as usize];
 
     for i in 0..codex.len() {
         codex[i] = u32::from_be_bytes([
@@ -236,14 +249,12 @@ fn main() {
             codex8[i*4+3] ]);
     }
 
-    let mut arrmap: HashMap<u32,usize> = HashMap::new();
-    arrmap.insert(0,0);
+    mem[0] = codex;
 
     let mut um = UMState {
         pc: 0,
-        arrmap,
         regs: [0,0,0,0,0,0,0,0],
-        mem: vec![codex]
+        mem
     };
 
     um_run(&mut um);