Merge pull request #6 from binary-banter/while

While & mutation

Cargo.toml

@@ -10,3 +10,7 @@ members = [
 default-members = [
     "compiler"
 ]
+
+[profile.release]
+opt-level = 3
+lto = true

bencher/src/main.rs

@@ -2,7 +2,7 @@ use clap::Parser;
 use compiler::elf::ElfFile;
 use compiler::interpreter::x86var::IStats;
 use compiler::interpreter::{TestIO, IO};
-use compiler::passes::parse::parse_program;
+use compiler::passes::parse::parse::parse_program;
 use compiler::utils::split_test::split_test_raw;
 use git2::{Commit, Repository};
 use mongodb::bson;

compiler/Cargo.toml

@@ -12,8 +12,10 @@ itertools = "0.11.0"
 serde = { version = "1.0.189", features = ["derive"] }
 clap = { version = "4.4.6", features = ["derive"] }
 miette = { version = "5.10.0", features = ["fancy"] }
-zerocopy = {version = "0.7.11", features = ["derive"] }
-lalrpop-util = { version = "0.20.1", features = ["lexer", "unicode"] }
+zerocopy = { version = "0.7.11", features = ["derive"] }
+lalrpop-util = { version = "0.20", features = ["lexer", "unicode"] }
+derive_more = "0.99.17"
+functor_derive = "0.2.2"
 
 [dev-dependencies]
 test_each_file = "0.1.0"

compiler/src/elf/mod.rs

@@ -7,7 +7,6 @@ use std::io::Write;
 use std::mem::size_of;
 use zerocopy::AsBytes;
 
-#[allow(clippy::module_inception)]
 mod header;
 mod program;
 mod section;

compiler/src/interpreter/mod.rs

@@ -1,9 +1,7 @@
-pub mod cvar;
-pub mod lvar;
 pub mod value;
 pub mod x86var;
 
-use crate::language::lvar::Lit;
+use crate::passes::parse::Lit;
 use std::io::stdin;
 use std::vec::IntoIter;
 

compiler/src/interpreter/value.rs

@@ -1,21 +1,38 @@
-use crate::language::lvar::Lit;
-use std::fmt::{Display, Formatter};
+use crate::passes::parse::Lit;
+use derive_more::Display;
+use std::fmt::Display;
 use std::hash::Hash;
 use std::str::FromStr;
 
-#[derive(Eq, PartialEq, Copy, Clone, Debug)]
-pub enum Val<A: Copy + Hash + Eq> {
+#[derive(Eq, PartialEq, Copy, Clone, Debug, Display)]
+pub enum Val<A: Copy + Hash + Eq + Display> {
+    #[display(fmt = "{val}")]
     Int { val: i64 },
+    #[display(fmt = "{}", r#"if *val { "true" } else { "false" }"#)]
     Bool { val: bool },
+    #[display(fmt = "unit")]
+    Unit,
+    #[display(fmt = "fn pointer `{sym}`")]
     Function { sym: A },
 }
 
-impl<A: Copy + Hash + Eq> Val<A> {
+impl<A: Copy + Hash + Eq + Display> From<Lit> for Val<A> {
+    fn from(value: Lit) -> Self {
+        match value {
+            Lit::Int { val } => Val::Int { val },
+            Lit::Bool { val } => Val::Bool { val },
+            Lit::Unit => Val::Unit,
+        }
+    }
+}
+
+impl<A: Copy + Hash + Eq + Display> Val<A> {
     pub fn int(self) -> i64 {
         match self {
             Val::Int { val } => val,
             Val::Bool { .. } => panic!(),
             Val::Function { .. } => panic!(),
+            Val::Unit => panic!(),
         }
     }
 
@@ -24,6 +41,7 @@ impl<A: Copy + Hash + Eq> Val<A> {
             Val::Int { .. } => panic!(),
             Val::Bool { val } => val,
             Val::Function { .. } => panic!(),
+            Val::Unit => panic!(),
         }
     }
 
@@ -32,6 +50,7 @@ impl<A: Copy + Hash + Eq> Val<A> {
             Val::Int { .. } => panic!(),
             Val::Bool { .. } => panic!(),
             Val::Function { sym } => sym,
+            Val::Unit => panic!(),
         }
     }
 }
@@ -41,6 +60,7 @@ impl From<Lit> for i64 {
         match value {
             Lit::Int { val } => val,
             Lit::Bool { val } => val as i64,
+            Lit::Unit => 0,
         }
     }
 }
@@ -52,25 +72,10 @@ impl FromStr for Lit {
         Ok(match s {
             "false" => Lit::Bool { val: false },
             "true" => Lit::Bool { val: true },
+            "unit" => Lit::Unit,
             s => Lit::Int {
                 val: s.parse().map_err(|_| ())?,
             },
         })
     }
 }
-
-impl<A: Copy + Hash + Eq + Display> Display for Val<A> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Val::Int { val } => write!(f, "{val}"),
-            Val::Bool { val } => {
-                if *val {
-                    write!(f, "t")
-                } else {
-                    write!(f, "f")
-                }
-            }
-            Val::Function { sym, .. } => write!(f, "pointer to `{sym}``"),
-        }
-    }
-}

compiler/src/interpreter/x86var.rs

@@ -1,11 +1,12 @@
 use crate::interpreter::IO;
-use crate::language::lvar::Lit;
 use crate::language::x86var::{
     Block, Cnd, Instr, Reg, VarArg, X86Concluded, X86Selected, CALLEE_SAVED, CALLER_SAVED,
 };
-use crate::passes::uniquify::UniqueSym;
+use crate::passes::parse::Lit;
+use crate::utils::gen_sym::UniqueSym;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
+use std::fmt::Debug;
 use std::mem;
 use zerocopy::AsBytes;
 
@@ -61,7 +62,7 @@ impl<'p> X86Concluded<'p> {
                 .blocks
                 .clone()
                 .into_iter()
-                .map(|(sym, block)| (sym, block.into()))
+                .map(|(sym, block)| (sym, block.fmap(Into::into)))
                 .collect(),
             io,
             regs,