day07 task 2

src/tasks/day05.rs

@@ -212,6 +212,87 @@ impl IntCodeComputer {
         }
     }
 
+    /**
+     * True means the program terminated, false means it is just waiting for more input
+     */
+    pub fn run_until_input_empty(&mut self) -> bool {
+        let mut op = Op::from(self.pc, &self.ram);
+        let mut inputs = self.input_storage.iter();
+        while op.opcode != OpCode::Terminate {
+            match op.opcode {
+                OpCode::Add => {
+                    let r = op.params[0].retrieve(&self.ram) + op.params[1].retrieve(&self.ram);
+                    op.params[2].store(&mut self.ram, r);
+                    self.pc += 4;
+                }
+                OpCode::Multiply => {
+                    let r = op.params[0].retrieve(&self.ram) * op.params[1].retrieve(&self.ram);
+                    op.params[2].store(&mut self.ram, r);
+                    self.pc += 4;
+                }
+                OpCode::Input => {
+                    if let Some(v) = inputs.next() {
+                        op.params[0].store(&mut self.ram, *v);
+                        self.pc += 2;
+                    } else {
+                        return false;
+                    }
+                }
+                OpCode::Output => {
+                    self.output_storage.push(op.params[0].retrieve(&self.ram));
+                    self.pc += 2;
+                }
+                OpCode::JumpIfTrue => {
+                    if op.params[0].retrieve(&self.ram) > 0 {
+                        self.pc = op.params[1].retrieve(&self.ram) as usize;
+                    } else {
+                        self.pc += 3;
+                    }
+                }
+                OpCode::JumpIfFalse => {
+                    if op.params[0].retrieve(&self.ram) == 0 {
+                        self.pc = op.params[1].retrieve(&self.ram) as usize;
+                    } else {
+                        self.pc += 3;
+                    }
+                }
+                OpCode::LessThan => {
+                    let r = if op.params[0].retrieve(&self.ram) < op.params[1].retrieve(&self.ram) {
+                        1
+                    } else {
+                        0
+                    };
+                    op.params[2].store(&mut self.ram, r);
+                    self.pc += 4;
+                }
+                OpCode::Equals => {
+                    let r = if op.params[0].retrieve(&self.ram) == op.params[1].retrieve(&self.ram)
+                    {
+                        1
+                    } else {
+                        0
+                    };
+                    op.params[2].store(&mut self.ram, r);
+                    self.pc += 4;
+                }
+                OpCode::Terminate => {}
+            }
+            op = Op::from(self.pc, &self.ram);
+        }
+        return true;
+    }
+
+    pub fn set_input(&mut self, input: &[i32]) {
+        self.input_storage.clear();
+        for x in input {
+            self.input_storage.push(*x);
+        }
+    }
+
+    pub fn clear_output(&mut self) {
+        self.output_storage.clear();
+    }
+
     pub fn get_output(&self) -> &[i32] {
         self.output_storage.as_slice()
     }