Add support for inserting into variable map

inp.txt

@@ -1,3 +1,4 @@
+lv9backers 
 pHello pWorld! 
 a15-16 s19-4 m3-3 d9-3
 

src/main.rs

@@ -2,12 +2,14 @@ use std::fs;
 use std::env;
 use std::fmt;
 use std::usize;
+use std::collections::HashMap;
 
 mod eval;
 
 struct Program {
     data: Vec<String>,
-    pc: usize
+    pc: usize,
+    vars: HashMap<char, String>
 }
 
 impl Program {
@@ -22,19 +24,43 @@ impl Program {
                 op_list.push(new_op.to_owned());
             }
         }
-        return Program{ data: op_list, pc: 0 };
+
+        return Program{ data: op_list, pc: 0, vars: HashMap::new() };
     }
 
-    fn eval(&self, instruction: &String) {
+    fn args_or_vars<'a>(&self, arguments: &'a str) -> String {
+        let mut deconstructed: Vec<char> = arguments.chars().collect();
+
+        for (index, char) in arguments.chars().enumerate() {
+            if char == 'e' {
+                deconstructed[index] = 'f';
+            }
+        }
+
+        println!("{:?}", self.vars);
+        deconstructed.into_iter().collect()
+    }
+
+    fn add_var(&mut self, arguments: &str) {
+        let name = arguments.chars().collect::<Vec<char>>()[0];
+        let old_value = &arguments[1..];
+
+        let value = old_value.to_owned();
+
+        self.vars.insert(name, value);
+    }
+
+    fn eval(&mut self, instruction: &String) {
         let opcode = instruction.chars().collect::<Vec<char>>()[0];
         let arguments = &instruction[1..];
 
         match opcode {
-            'p' => println!("{}", arguments),
+            'p' => println!("{}", self.args_or_vars(arguments)),
             'a' => println!("{}", eval::do_math(arguments, '+')),
             's' => println!("{}", eval::do_math(arguments, '-')),
             'm' => println!("{}", eval::do_math(arguments, '*')),
             'd' => println!("{}", eval::do_math(arguments, '/')),
+            'l' => self.add_var(arguments),
             _ => panic!("SyntaxError at opcode {}!", self.pc)
         }
     }
@@ -42,9 +68,9 @@ impl Program {
     fn run(&mut self) {
         println!("{}", self);
         while self.pc < self.data.len() {
-            let instruction = &self.data[self.pc];
+            let instruction = self.data[self.pc].to_owned();
 
-            self.eval(instruction);
+            self.eval(&instruction);
 
             self.pc = self.pc + 1;
         }