use std::io;
use bstack::FirstFitBStackAllocator;
use bstack_raii::{
BStack, BStackAllocator, BStackDrop, BStackOwned, TryCloneIn, bstack_block, bstack_enum,
bstack_move,
};
#[bstack_block]
struct BinOp {
op: u8, #[bstack_owned]
lhs: Expr,
#[bstack_owned]
rhs: Expr,
}
#[bstack_enum]
enum Expr {
Lit(i64),
#[bstack_owned]
Op(BinOp),
}
fn eval(expr: &Expr, alloc: &FirstFitBStackAllocator) -> io::Result<i64> {
Ok(match expr.read(alloc)? {
ExprView::Lit(v) => v,
ExprView::Op(node) => {
let lhs = eval(&node.get_lhs(alloc.stack())?, alloc)?;
let rhs = eval(&node.get_rhs(alloc.stack())?, alloc)?;
match node.get_op(alloc.stack())? {
b'+' => lhs + rhs,
b'*' => lhs * rhs,
other => unreachable!("unknown operator {other}"),
}
}
})
}
fn render(expr: &Expr, alloc: &FirstFitBStackAllocator) -> io::Result<String> {
Ok(match expr.read(alloc)? {
ExprView::Lit(v) => v.to_string(),
ExprView::Op(node) => {
let lhs = render(&node.get_lhs(alloc.stack())?, alloc)?;
let rhs = render(&node.get_rhs(alloc.stack())?, alloc)?;
let op = node.get_op(alloc.stack())? as char;
format!("({lhs} {op} {rhs})")
}
})
}
fn lit(alloc: &FirstFitBStackAllocator, v: i64) -> io::Result<BStackOwned<Expr>> {
Expr::new(alloc, ExprData::Lit(v)).map_err(|e| e.into_source())
}
fn op(
alloc: &FirstFitBStackAllocator,
operator: u8,
lhs: BStackOwned<Expr>,
rhs: BStackOwned<Expr>,
) -> io::Result<BStackOwned<Expr>> {
let node = BinOp::new(alloc, operator, lhs, rhs).map_err(|e| e.into_source())?;
Expr::new(alloc, ExprData::Op(node)).map_err(|e| e.into_source())
}
fn main() -> io::Result<()> {
let path = std::env::temp_dir().join("bstack_raii_expr.bstack");
let _ = std::fs::remove_file(&path);
let alloc = FirstFitBStackAllocator::new(BStack::open(&path)?)?;
let sum = op(&alloc, b'+', lit(&alloc, 3)?, lit(&alloc, 4)?)?;
let root = op(&alloc, b'*', sum, lit(&alloc, 2)?)?;
println!("expression: {}", render(&root, &alloc)?);
println!("evaluates to: {}", eval(&root, &alloc)?);
assert_eq!(eval(&root, &alloc)?, 14);
let clone = root.try_clone_in(&alloc)?;
assert_eq!(eval(&clone, &alloc)?, 14);
println!(
"deep clone evaluates to: {} (independent copy)",
eval(&clone, &alloc)?
);
match bstack_move!(clone, &alloc)? {
ExprData::Op(binop) => {
let left = binop.handle().get_lhs(alloc.stack())?;
println!(
"moved out the root `Op`; its left operand is `{}`",
render(&left, &alloc)?
);
binop.bstack_drop(&alloc)?;
}
ExprData::Lit(_) => unreachable!("root was an Op"),
}
assert_eq!(eval(&root, &alloc)?, 14);
println!("original still evaluates to: {}", eval(&root, &alloc)?);
root.bstack_drop(&alloc)?;
let _ = std::fs::remove_file(&path);
Ok(())
}