use std::collections::HashSet;
use fusevm::Value;
use crate::host::{ElispHost, Obj};
pub fn free_vars(h: &ElispHost, arglist: &Value, body: &[Value]) -> HashSet<u32> {
walk(h, arglist, body).out
}
pub fn let_bound_vars(h: &ElispHost, arglist: &Value, body: &[Value]) -> Vec<u32> {
let mut out = Vec::new();
for sym in walk(h, arglist, body).let_bound.into_iter().rev() {
if !out.contains(&sym) {
out.push(sym);
}
}
out
}
fn walk<'a>(h: &'a ElispHost, arglist: &Value, body: &[Value]) -> Walk<'a> {
let mut w = Walk {
h,
out: HashSet::new(),
let_bound: Vec::new(),
};
let mut bound = Vec::new();
w.params(arglist, &mut bound);
for form in body {
w.form(form, &bound);
}
w
}
struct Walk<'a> {
h: &'a ElispHost,
out: HashSet<u32>,
let_bound: Vec<u32>,
}
impl Walk<'_> {
fn form(&mut self, form: &Value, bound: &[u32]) {
let Value::Obj(_) = form else { return };
match self.h.obj(form) {
Some(Obj::Symbol(_)) => {
if let Some(sym) = self.sym_handle(form) {
if !bound.contains(&sym) {
self.out.insert(sym);
}
}
}
Some(Obj::Cons(..)) => self.call(form, bound),
_ => {}
}
}
fn call(&mut self, form: &Value, bound: &[u32]) {
let Some(elems) = self.h.list_vec(form) else {
self.capture_all(form);
return;
};
let Some(head) = elems.first() else { return };
let name = self.h.sym_name(head);
match name.as_deref() {
Some("quote") => {}
Some("function") => {
if let Some(inner) = elems.get(1) {
if self.head_is(inner, "lambda") {
self.lambda(inner, bound);
}
}
}
Some("lambda") => self.lambda(form, bound),
Some("let") | Some("let*") => {
let sequential = name.as_deref() == Some("let*");
let binders = elems
.get(1)
.and_then(|b| self.h.list_vec(b))
.unwrap_or_default();
let mut inner = bound.to_vec();
for binder in binders {
let (sym, value) = match self.h.list_vec(&binder) {
Some(pair) if !pair.is_empty() => (pair[0].clone(), pair.get(1).cloned()),
_ => (binder.clone(), None),
};
if let Some(v) = value {
self.form(&v, if sequential { &inner } else { bound });
}
if let Some(s) = self.sym_handle(&sym) {
inner.push(s);
self.let_bound.push(s);
}
}
for f in elems.get(2..).unwrap_or(&[]) {
self.form(f, &inner);
}
}
Some("setq") => {
let mut rest = &elems[1..];
while !rest.is_empty() {
if let Some(s) = self.sym_handle(&rest[0]) {
if !bound.contains(&s) {
self.out.insert(s);
}
}
if let Some(v) = rest.get(1) {
self.form(v, bound);
}
rest = rest.get(2..).unwrap_or(&[]);
}
}
Some("condition-case") => {
if let Some(p) = elems.get(2) {
self.form(p, bound);
}
let mut inner = bound.to_vec();
if let Some(v) = elems.get(1).and_then(|v| self.sym_handle(v)) {
inner.push(v);
}
for handler in elems.get(3..).unwrap_or(&[]) {
for f in self.h.list_vec(handler).unwrap_or_default().iter().skip(1) {
self.form(f, &inner);
}
}
}
Some("defvar") | Some("defconst") => {
if let Some(v) = elems.get(2) {
self.form(v, bound);
}
}
Some("defun") | Some("defmacro") => {
let arglist = elems.get(2).cloned().unwrap_or(Value::Undef);
let mut inner = bound.to_vec();
self.params(&arglist, &mut inner);
for f in elems.get(3..).unwrap_or(&[]) {
self.form(f, &inner);
}
}
Some("interactive") => {}
Some("cond") => {
for clause in elems.get(1..).unwrap_or(&[]) {
for f in self.h.list_vec(clause).unwrap_or_default() {
self.form(&f, bound);
}
}
}
_ => {
if name.is_none() && self.head_is(head, "lambda") {
self.lambda(head, bound);
}
for f in &elems[1..] {
self.form(f, bound);
}
}
}
}
fn lambda(&mut self, form: &Value, bound: &[u32]) {
let elems = self.h.list_vec(form).unwrap_or_default();
let arglist = elems.get(1).cloned().unwrap_or(Value::Undef);
let mut inner = bound.to_vec();
self.params(&arglist, &mut inner);
for f in elems.get(2..).unwrap_or(&[]) {
self.form(f, &inner);
}
}
fn params(&mut self, arglist: &Value, bound: &mut Vec<u32>) {
for p in self.h.list_vec(arglist).unwrap_or_default() {
if let Some(s) = self.sym_handle(&p) {
bound.push(s);
}
}
}
fn capture_all(&mut self, form: &Value) {
match self.h.obj(form) {
Some(Obj::Symbol(_)) => {
if let Some(s) = self.sym_handle(form) {
self.out.insert(s);
}
}
Some(Obj::Cons(car, cdr)) => {
let (car, cdr) = (car.clone(), cdr.clone());
self.capture_all(&car);
self.capture_all(&cdr);
}
_ => {}
}
}
fn sym_handle(&self, v: &Value) -> Option<u32> {
match (v, self.h.obj(v)) {
(Value::Obj(id), Some(Obj::Symbol(_))) => Some(*id),
_ => None,
}
}
fn head_is(&self, form: &Value, name: &str) -> bool {
match self.h.obj(form) {
Some(Obj::Cons(car, _)) => self.h.sym_name(car).as_deref() == Some(name),
_ => false,
}
}
}