limited ident resolving, only handles expressions in expression state…

…ments (not expressions in ifelse or loop statements)
Lokathor · Dec 12, 2024 · 8d289dd · 8d289dd
1 parent 5d0f1d0
commit 8d289dd
Show file tree

Hide file tree

Showing 4 changed files with 90 additions and 3 deletions.
diff --git a/src/ast/data/expression.rs b/src/ast/data/expression.rs
@@ -1,6 +1,6 @@
 use super::*;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub enum Expression {
   NumLit(FileSpanned<StrID>),
   Ident(FileSpanned<StrID>),
@@ -9,6 +9,7 @@ pub enum Expression {
   Macro(FileSpanned<StrID>, FileSpanned<Vec<FileSpanned<TokenTree>>>),
 
   I32(FileSpanned<i32>),
+  StaticLabel(FileSpanned<StrID>),
 
   /// `[x]`
   Deref(Box<FileSpanned<Self>>),
@@ -67,6 +68,7 @@ pub enum Expression {
   /// `x = y`
   Assign(Box<FileSpanned<Self>>, Box<FileSpanned<Self>>),
 
+  #[default]
   ExpressionError,
 }
 impl Expression {
@@ -86,7 +88,7 @@ impl Expression {
         *self = op(take_name, take_args)
       }
       NumLit(_) | Ident(_) | Register(_) | Bool(_) | I32(_)
-      | ExpressionError => (),
+      | StaticLabel(_) | ExpressionError => (),
       Deref(file_spanned) | Neg(file_spanned) | Ref(file_spanned)
       | Inc(file_spanned) | Dec(file_spanned) => file_spanned.map_macros(op),
       Dot(file_spanned, file_spanned1)
@@ -125,7 +127,7 @@ impl Expression {
         *self = op(take_num);
       }
       Macro(_, _) => (),
-      NumLit(_) | Ident(_) | Register(_) | Bool(_) | I32(_)
+      Ident(_) | Register(_) | Bool(_) | I32(_) | StaticLabel(_)
       | ExpressionError => (),
       Deref(file_spanned) | Neg(file_spanned) | Ref(file_spanned)
       | Inc(file_spanned) | Dec(file_spanned) => file_spanned.map_num_lit(op),
@@ -152,4 +154,44 @@ impl Expression {
       }
     }
   }
+
+  /// Maps the closure over any `Macro` atoms within the expression.
+  pub fn map_ident<F>(&mut self, op: &mut F)
+  where
+    F: FnMut(FileSpanned<StrID>) -> Expression,
+  {
+    use Expression::*;
+    match self {
+      Ident(i) => {
+        let take_ident = FileSpanned::take(i);
+        *self = op(take_ident);
+      }
+      Macro(_, _) => (),
+      NumLit(_) | Register(_) | Bool(_) | I32(_) | StaticLabel(_)
+      | ExpressionError => (),
+      Deref(file_spanned) | Neg(file_spanned) | Ref(file_spanned)
+      | Inc(file_spanned) | Dec(file_spanned) => file_spanned.map_ident(op),
+      Dot(file_spanned, file_spanned1)
+      | Mul(file_spanned, file_spanned1)
+      | Div(file_spanned, file_spanned1)
+      | Mod(file_spanned, file_spanned1)
+      | Add(file_spanned, file_spanned1)
+      | Sub(file_spanned, file_spanned1)
+      | ShiftLeft(file_spanned, file_spanned1)
+      | ShiftRight(file_spanned, file_spanned1)
+      | BitAnd(file_spanned, file_spanned1)
+      | BitXor(file_spanned, file_spanned1)
+      | BitOr(file_spanned, file_spanned1)
+      | Eq(file_spanned, file_spanned1)
+      | Ne(file_spanned, file_spanned1)
+      | Lt(file_spanned, file_spanned1)
+      | Gt(file_spanned, file_spanned1)
+      | Le(file_spanned, file_spanned1)
+      | Ge(file_spanned, file_spanned1)
+      | Assign(file_spanned, file_spanned1) => {
+        file_spanned.map_ident(op);
+        file_spanned1.map_ident(op);
+      }
+    }
+  }
 }
diff --git a/src/ast/data/statement.rs b/src/ast/data/statement.rs
@@ -11,3 +11,28 @@ pub enum Statement {
   Return,
   StatementError,
 }
+impl Statement {
+  pub fn map_expressions<F>(&mut self, op: &mut F)
+  where
+    F: FnMut(FileSpanned<Expression>) -> Expression,
+  {
+    match self {
+      Statement::Expression(x) => {
+        let exp: FileSpanned<Expression> = FileSpanned::take(x);
+        **x = op(exp);
+      }
+      Statement::IfElse(if_else) => {
+        let exp: FileSpanned<Expression> = FileSpanned::take(&mut if_else.test);
+        if_else.test._payload = op(exp);
+      }
+      Statement::Loop(file_spanned) => todo!(),
+      Statement::Break(_)
+      | Statement::Continue(_)
+      | Statement::Call(_)
+      | Statement::Return
+      | Statement::StatementError => {
+        todo!()
+      }
+    }
+  }
+}
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
@@ -140,6 +140,25 @@ impl Ast {
       }
     }
   }
+
+  pub fn resolve_identifiers(&mut self) {
+    for func in self.functions.values_mut() {
+      for statement in &mut func.statements {
+        if let Statement::Expression(ex) = &mut statement._payload {
+          ex.map_ident(&mut |i| {
+            if let Some(x) = self.evaluated_consts.get(&i) {
+              Expression::I32(FileSpanned::new(*x, i._span))
+            } else if self.evaluated_statics.contains_key(&i) {
+              Expression::StaticLabel(i)
+            } else {
+              self.err_bucket.push(todo!());
+              Expression::ExpressionError
+            }
+          });
+        }
+      }
+    }
+  }
 }
 
 fn num_lit_to_i32(n: FileSpanned<StrID>) -> Option<i32> {

diff --git a/src/bin/yagbas.rs b/src/bin/yagbas.rs
@@ -196,6 +196,7 @@ pub fn do_ast(args: AstArgs) {
   ast.run_static_eval();
   ast.resolve_size_of_static();
   ast.resolve_numeric_literals();
+  ast.resolve_identifiers();
   println!("{ast:?}");
   err_bucket.append(&mut ast.err_bucket);
   report_all_the_errors(src_files, err_bucket, args.message_size);