min
/
leaf
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

wip gross...

This commit is contained in:
minish 2025-10-06 23:12:17 -04:00
parent 6bc5646a03
commit a0d30c088b
Signed by: min
SSH Key Fingerprint: SHA256:mf+pUTmK92Y57BuCjlkBdd82LqztTfDCQIUp0fCKABc
2 changed files with 119 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
src/compiler.rs
View File

@ -301,7 +301,6 @@ impl<'a> FuncBuild<'a> {
} }
fn push_any(&mut self) -> Stkval { fn push_any(&mut self) -> Stkval {
// println!("PUSHING ANY TO {:?}", self.local.values());
let i = self.local.height(); let i = self.local.height();
self.local.push(FSValue::Any); self.local.push(FSValue::Any);
Stkval::Local(i as u8) Stkval::Local(i as u8)
@ -319,17 +318,17 @@ impl<'a> FuncBuild<'a> {
(self.is_drop(v1), self.is_drop(v2)) (self.is_drop(v1), self.is_drop(v2))
} }
fn translate(&mut self, e: Expr, unused: bool) -> Val { fn translate(&mut self, e: Expr) -> Val {
// println!("{e:?}\n\n"); // println!("{e:?}");
match e { let outp = match e {
/* organisational */ /* organisational */
Expr::Block(mut b) => { Expr::Block(mut b) => {
let last = b.exprs.pop(); let last = b.exprs.pop();
for e in b.exprs { for e in b.exprs {
self.translate(e, false); self.translate(e);
} }
// yield last expr // yield last expr
last.map_or(Val::Nil, |e| self.translate(e, false)) last.map_or(Val::Nil, |e| self.translate(e))
} }
/* 1 to 1 literals */ /* 1 to 1 literals */
Expr::Literal(Literal::Boolean(b)) => Val::Bool(b), Expr::Literal(Literal::Boolean(b)) => Val::Bool(b),
@ -343,27 +342,130 @@ impl<'a> FuncBuild<'a> {
} }
/* math */ /* math */
Expr::Add(l, r) => { Expr::Add(l, r) => {
let (v1, v2) = (self.translate(*l, false), self.translate(*r, false)); let (v1, v2) = (self.translate(*l), self.translate(*r));
let (a1, a2) = self.is_drop2(&v1, &v2); let (a1, a2) = self.is_drop2(&v1, &v2);
self.insts.push(Inst::Add(a1, a2, v1, v2)); self.insts.push(Inst::Add(a1, a2, v1, v2));
Val::Stack(self.push_any(), true) Val::Stack(self.push_any(), true)
} }
Expr::Multiply(l, r) => {
let (v1, v2) = (self.translate(*l), self.translate(*r));
let (a1, a2) = self.is_drop2(&v1, &v2);
self.insts.push(Inst::Mul(a1, a2, v1, v2));
Val::Stack(self.push_any(), true)
}
Expr::Divide(l, r) => {
let (v1, v2) = (self.translate(*l), self.translate(*r));
let (a1, a2) = self.is_drop2(&v1, &v2);
self.insts.push(Inst::Div(a1, a2, v1, v2));
Val::Stack(self.push_any(), true)
}
Expr::Modulo(l, r) => {
let (v1, v2) = (self.translate(*l), self.translate(*r));
let (a1, a2) = self.is_drop2(&v1, &v2);
self.insts.push(Inst::Mod(a1, a2, v1, v2));
Val::Stack(self.push_any(), true)
}
Expr::Exponent(l, r) => {
let (v1, v2) = (self.translate(*l), self.translate(*r));
let (a1, a2) = self.is_drop2(&v1, &v2);
self.insts.push(Inst::Pow(a1, a2, v1, v2));
Val::Stack(self.push_any(), true)
}
Expr::And(l, r) => {
let (v1, v2) = (self.translate(*l), self.translate(*r));
let (a1, a2) = self.is_drop2(&v1, &v2);
self.insts.push(Inst::And(a1, a2, v1, v2));
Val::Stack(self.push_any(), true)
}
Expr::Or(l, r) => {
let (v1, v2) = (self.translate(*l), self.translate(*r));
let (a1, a2) = self.is_drop2(&v1, &v2);
self.insts.push(Inst::Or(a1, a2, v1, v2));
Val::Stack(self.push_any(), true)
}
Expr::EqualTo(l, r) => {
let (v1, v2) = (self.translate(*l), self.translate(*r));
let (a1, a2) = self.is_drop2(&v1, &v2);
self.insts.push(Inst::Eq(a1, a2, v1, v2));
Val::Stack(self.push_any(), true)
}
Expr::NotEqualTo(l, r) => {
let (v1, v2) = (self.translate(*l), self.translate(Expr::Not(r)));
let (a1, a2) = self.is_drop2(&v1, &v2);
self.insts.push(Inst::Eq(a1, a2, v1, v2));
Val::Stack(self.push_any(), true)
}
Expr::GreaterThan(l, r) => {
let (v1, v2) = (self.translate(*l), self.translate(*r));
let (a1, a2) = self.is_drop2(&v1, &v2);
self.insts.push(Inst::Gt(a1, a2, v1, v2));
Val::Stack(self.push_any(), true)
}
Expr::LessThan(l, r) => {
let (v1, v2) = (self.translate(*l), self.translate(*r));
let (a1, a2) = self.is_drop2(&v1, &v2);
self.insts.push(Inst::Gt(a2, a1, v2, v1));
Val::Stack(self.push_any(), true)
}
Expr::Subtract(l, r) => {
let (v1, v2) = (
self.translate(*l),
self.translate(Expr::Multiply(
r,
Box::new(Expr::Literal(Literal::Integer(-1))),
)),
);
let (a1, a2) = self.is_drop2(&v1, &v2);
self.insts.push(Inst::Add(a1, a2, v1, v2));
Val::Stack(self.push_any(), true)
}
Expr::Not(r) => {
let v1 = self.translate(*r);
let a1 = self.is_drop(&v1);
self.insts.push(Inst::Not(a1, v1));
Val::Stack(self.push_any(), true)
}
Expr::Assign(l, r) => { Expr::Assign(l, r) => {
let Expr::Literal(Literal::Ident(id, Some(ref_stat))) = *l else { let Expr::Literal(Literal::Ident(id, Some(ref_stat))) = *l else {
unreachable!() unreachable!()
}; };
let unused = ref_stat.now == ref_stat.meta.total.get(); let gets_used = ref_stat.now != ref_stat.meta.total.get();
let val = self.translate(*r, unused);
if !unused { match *r {
self.local.push(FSValue::Var(id)); Expr::Literal(lit) if gets_used => {
let v1 = self.translate(Expr::Literal(lit));
self.insts.push(Inst::Copy(v1));
Val::Stack(self.push_any(), false)
} }
Expr::Literal(lit) => self.translate(Expr::Literal(lit)),
e => {
let val = self.translate(e);
// we know the top of the stack is the result
// so lets keep track of that
self.local.swap_top(FSValue::Var(id));
val val
} }
_ => unimplemented!(),
} }
} }
_ => unimplemented!(),
};
// println!("CHECK {:?} {:?}", self.insts.last(), self.local.values());
outp
}
} }
pub fn analysis_demo(e: &mut Expr) { pub fn analysis_demo(e: &mut Expr) {
@ -375,6 +477,6 @@ pub fn analysis_demo(e: &mut Expr) {
pub fn translation_demo(e: Expr) -> Vec<Inst> { pub fn translation_demo(e: Expr) -> Vec<Inst> {
// translation pass // translation pass
let mut fb = FuncBuild::new_root(); let mut fb = FuncBuild::new_root();
fb.translate(e, true); fb.translate(e);
fb.insts fb.insts
} }

3
src/compiler/stack.rs
View File

@ -23,6 +23,9 @@ where
fn height(&self) -> usize { fn height(&self) -> usize {
self.values().len() self.values().len()
} }
fn swap_top(&mut self, new: Self::Value) {
*self.values_mut().last_mut().unwrap() = new;
}
fn find(&self, input: &Self::Input) -> Option<(Self::Output, u16)> { fn find(&self, input: &Self::Input) -> Option<(Self::Output, u16)> {
let mut cur = Some(self); let mut cur = Some(self);