forgot to commit these

compiler/src/backend/dsa/variable.rs

@@ -0,0 +1,186 @@
+use std::{collections::HashMap, hash::Hash};
+
+use crate::{
+    backend::dsa::{
+        instruction::{InsBlock, Reg},
+        registers::Register,
+    },
+    model::{CompilerError, TypeId},
+};
+
+pub struct Variable {
+    name: String,
+
+    /// the type of the variable.
+    r#type: TypeId,
+
+    /// size taken up in bytes.
+    /// if size > 4, value must be stored on the stack.
+    size: usize,
+
+    // location
+    /// this must be None if it cannot be stored in a register.
+    allocated_register: Option<Register>,
+
+    /// represents the offset from the base pointer (Bpr) of the stack frame.
+    /// needs to be signed as offset is positive for function args and negative for local
+    /// variables. as we can't access values at negative offsets, we use the following
+    /// formula: addr = Spr + offset - (Spr - Bpr) where we know (Spr-Bpr) at compile
+    /// time.
+    bpr_offset: Option<isize>,
+}
+
+impl Variable {
+    pub fn new_uninit(name: String, r#type: TypeId) -> Self {
+        Self {
+            name,
+            size: r#type.size(),
+            r#type,
+            allocated_register: None,
+            bpr_offset: None,
+        }
+    }
+
+    fn alloc_register(
+        &mut self,
+        scope: &'_ mut Scope,
+    ) -> Result<Register, CompilerError> {
+        if self.size > 4 {
+            return Err(CompilerError::Generic(format!(
+                "Type {} cannot be allocated a register as it has a size of {} bytes",
+                self.r#type, self.size
+            )));
+        }
+
+        todo!("integrate with register alloc logic")
+
+        // self.allocated_register = Some(...)
+    }
+
+    fn alloc_stack(&mut self, scope: &'_ mut Scope) -> Result<usize, CompilerError> {
+        todo!("integrate with stack alloc logic")
+
+        // self.bpr_offset = Some(...)
+    }
+
+    pub fn load(&mut self, scope: &'_ mut Scope) -> Result<Register, CompilerError> {
+        todo!("load var from stack to reg (if possible)")
+    }
+
+    pub fn new_local(
+        name: String,
+        r#type: TypeId,
+        scope: &'_ mut Scope,
+    ) -> Result<Self, CompilerError> {
+        let mut var = Self::new_uninit(name, r#type);
+        var.alloc_register(scope)?;
+        Ok(var)
+    }
+
+    pub fn new_stack(
+        name: String,
+        r#type: TypeId,
+        scope: &'_ mut Scope,
+    ) -> Result<Self, CompilerError> {
+        let mut init = Self::new_uninit(name, r#type);
+        init.alloc_stack(scope)?;
+        Ok(init)
+    }
+
+    pub fn drop(&mut self, scope: &'_ mut Scope) -> Result<(), CompilerError> {
+        if let Some(reg) = self.allocated_register {
+            todo!("dealloc reg in current function")
+        }
+
+        if let Some(offset) = self.bpr_offset {
+            todo!("free stack slot in current function")
+        }
+
+        Ok(())
+    }
+
+    pub fn spill(&mut self, scope: &'_ mut Scope) -> Result<(), CompilerError> {
+        todo!()
+    }
+}
+
+/// scope object
+pub struct Scope<'a> {
+    /// outer scope, for a function this will be the global scope.
+    parent: Option<&'a mut Scope<'a>>,
+
+    /// is the scope a function body or just a loop?
+    /// depending on the type, ending a scope will have different behaviour
+    r#type: ScopeType,
+
+    /// variables
+    variables: HashMap<String, Variable>,
+
+    /// tells us if a given register is being used or not.
+    /// this can be an array as registers have u8 representation.
+    in_use: [(Register, bool); 16],
+
+    stack_offset: i32,
+}
+
+impl<'a> Scope<'a> {
+    pub fn new(parent: &'a mut Scope<'a>, r#type: ScopeType) -> Scope<'a> {
+        Self {
+            stack_offset: parent.stack_offset,
+            parent: Some(parent),
+            r#type,
+            variables: HashMap::new(),
+            in_use: Register::get_gp().map(|reg| (reg, false)),
+        }
+    }
+
+    pub fn stack_offset(&self) -> i32 {
+        self.stack_offset
+    }
+
+    pub fn stack_offset_mut(&mut self) -> &mut i32 {
+        &mut self.stack_offset
+    }
+
+    pub fn close(&mut self) -> Result<(), CompilerError> {
+        // closing a scope means we need to drop all variables in scope and free registers.
+        for (name, var) in self.variables {
+            if let Some(reg) = var.allocated_register {
+
+            }
+
+            if let Some(off)
+        }
+
+        for reg in self.in_use
+
+        Ok(())
+    }
+
+    pub fn alloc_temp_reg(&mut self) -> Result<(Register, InsBlock), CompilerError> {
+        todo!()
+    }
+
+    pub fn alloc_var_reg(&mut self) -> Result<(Register, InsBlock), CompilerError> {
+        todo!()
+    }
+
+    pub fn alloc_var_stack(&mut self) -> Result<(Register, InsBlock), CompilerError> {
+        todo!()
+    }
+
+    pub fn free_var_stack(&mut self) -> Result<(Register, InsBlock), CompilerError> {
+        todo!()
+    }
+
+    pub fn free_temp_reg(&mut self) -> Result<(Register, InsBlock), CompilerError> {
+        todo!()
+    }
+}
+
+#[derive(PartialEq, Copy, Clone, Debug)]
+enum ScopeType {
+    Function,
+    IfBlock,
+    LoopBlock,
+}