feat: variable definition

blspc/src/compiler/compile.rs

@@ -60,7 +60,17 @@ impl Compiler {
                                     result.append(&mut then);
                                     result.push(Instr::Jump { to: len(&else_) });
                                     result.append(&mut else_);
-                                }
+                                },
+                                "def" => {
+                                    let var_name = match &cdr[0] {
+                                        Symbol(ref name) => name.clone(),
+                                        _ => return Err(format!("Expected variable name, got {}", cdr[0])),
+                                    };
+                                    let body = &cdr[1];
+
+                                    result.append(&mut self.compile(body.clone())?);
+                                    result.push(Instr::Store { name: var_name });
+                                },
                                 _ => {
                                     result.append(&mut self.compile_intrinsic(call, &cdr)?);
                                 }

blspc/src/vm/instr.rs

@@ -181,7 +181,7 @@ impl FromStr for Register {
 pub enum Instr {
     Label { name: String }, Comment { text: String },
     // Store a literal value into a register.
-    Store { address: Register, value: Type },
+    Store { name: String },
     // Call intrinsic function.
     Call,
     // Stack operations.
@@ -204,7 +204,7 @@ impl Display for Instr {
             //                                        ----------20--------- Parameter start
             Instr::Label { name }        => write!(f, ".{}:", name),
             Instr::Comment { text }      => write!(f, ";{}", text),
-            Instr::Store { address, value } => write!(f, "    STORE           {} {}", address, value),
+            Instr::Store { name }        => write!(f, "    STORE           {}", name),
             Instr::Call                  => write!(f, "    CALL"),
             Instr::Push { value }        => write!(f, "    PUSH            {}", value),
             Instr::Pop { address }       => write!(f, "    POP             {}", address),

blspc/src/vm/parser.rs

@@ -16,10 +16,7 @@ pub fn parse_instr(src: &str) -> Vec<Instr> {
         if tokens[0].starts_with(";") { continue; }
 
         match tokens[0] {
-            "STORE" => { result.push(Instr::Store {
-                address: register!(tokens[1]),
-                value: value!(tokens[2]),
-            }); },
+            "STORE" => { result.push(Instr::Store { name: tokens[1].to_string() }); },
             "CALL"  => { result.push(Instr::Call); },
             "PUSH"  => { result.push(Instr::Push { value: value!(tokens[1]) }); },
             "POP"   => { result.push(Instr::Pop { address: register!(tokens[1]) }); },

blspc/src/vm/vm.rs

@@ -28,6 +28,7 @@ pub struct VM {
     jumped_from: isize,
     registers: Vec<Type>,
     stack: Vec<Type>,
+    variables: Vec<(String, Type)>,
     function_pointer: Vec<(String, isize)>, // (name, index)
 }
 
@@ -40,6 +41,7 @@ impl VM {
             jumped_from: 0,
             registers: vec![Type::Null; 1024],
             stack: Vec::new(),
+            variables: Vec::new(),
             function_pointer: Vec::new(),
         }
     }
@@ -69,8 +71,9 @@ impl VM {
             let instr = &instrs[(self.instr_pointer - 1) as usize];
             if debug { print_debug(self, &instr); }
             match instr {
-                Store { address, value, .. } => {
-                    self.store(&address, &value)?;
+                Store { name } => {
+                    let value = &self.stack.pop().unwrap();
+                    self.store(name, value)?;
                     continue 'tco;
                 },
                 Call => {
@@ -85,7 +88,7 @@ impl VM {
                 },
                 Pop { address } => {
                     let value = self.stack.pop();
-                    self.store(&address, &value.unwrap())?;
+                    self.pop(&address, &value.unwrap())?;
                     continue 'tco;
                 },
                 Swap => {
@@ -150,11 +153,15 @@ impl VM {
         Ok(self.stack.push(value))
     }
     
-    fn store(&mut self, address: &Register, value: &Type) -> Result<(), Error> {
+    fn pop(&mut self, address: &Register, value: &Type) -> Result<(), Error> {
         // TODO: Remove .clone()
         Ok(self.registers[address.value()] = value.clone())
     }
 
+    fn store(&mut self, name: &String, value: &Type) -> Result<(), Error> {
+        Ok(self.variables.push((name.clone(), value.clone())))
+    }
+
     fn get_function_pointer(&mut self, name: String) -> Result<isize, Error> {
         for (idx, (n, _)) in self.function_pointer.iter().enumerate() {
             if n == &name {

example/var.blsp

@@ -0,0 +1,2 @@
+(fun main
+    (def name "bobby"))