143 lines
4.1 KiB
Rust
143 lines
4.1 KiB
Rust
use std::io;
|
|
|
|
use crate::{
|
|
ast::{typed::TypedExpr, UntypedExpr},
|
|
representation::intermediate::IntermediateExpr,
|
|
symbols::SymbolsTable,
|
|
};
|
|
|
|
pub fn print_intermediate_exprs(
|
|
exprs: &[IntermediateExpr],
|
|
writer: &mut impl io::Write,
|
|
) -> io::Result<()> {
|
|
for expr in exprs {
|
|
match expr {
|
|
IntermediateExpr::IntToFloat { result, value } => {
|
|
writeln!(writer, "i2f <id,{}>, {}", result, value)?;
|
|
}
|
|
IntermediateExpr::BinOp {
|
|
result,
|
|
lhs,
|
|
op,
|
|
rhs,
|
|
} => {
|
|
writeln!(writer, "{:#} <id,{}>, {}, {}", op, result, lhs, rhs)?;
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn print_postfix_expr(expr: &TypedExpr, writer: &mut impl io::Write) -> io::Result<()> {
|
|
match expr {
|
|
TypedExpr::Int { value, .. } => write!(writer, "{} ", value)?,
|
|
TypedExpr::Float { value, .. } => write!(writer, "{} ", value)?,
|
|
TypedExpr::Var { name, .. } => write!(writer, "<id,{}> ", name)?,
|
|
TypedExpr::BinOp { lhs, op, rhs, .. } => {
|
|
print_postfix_expr(lhs, writer)?;
|
|
print_postfix_expr(rhs, writer)?;
|
|
write!(writer, "{} ", op)?;
|
|
}
|
|
TypedExpr::IntToFloat { value, .. } => {
|
|
print_postfix_expr(value, writer)?;
|
|
write!(writer, "i2f ")?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn write_typed_expr(
|
|
expr: &TypedExpr,
|
|
symbols: &SymbolsTable,
|
|
writer: &mut impl io::Write,
|
|
prefix: &str,
|
|
is_last: bool,
|
|
) -> io::Result<()> {
|
|
let branch = if is_last { "└──" } else { "├──" };
|
|
|
|
write!(writer, "{}{}", prefix, branch)?;
|
|
|
|
match expr {
|
|
TypedExpr::Int { value, .. } => writeln!(writer, "<{}>", value),
|
|
TypedExpr::Float { value, .. } => writeln!(writer, "<{}>", value),
|
|
TypedExpr::Var { name, .. } => {
|
|
let ty = symbols.resolve(name).unwrap().ty.unwrap();
|
|
writeln!(writer, "<id,{},{}>", name, ty)
|
|
}
|
|
TypedExpr::BinOp { lhs, op, rhs, .. } => {
|
|
writeln!(writer, "<{}>", op)?;
|
|
|
|
let new_prefix = if is_last {
|
|
format!("{} ", prefix)
|
|
} else {
|
|
format!("{}│ ", prefix)
|
|
};
|
|
|
|
write_typed_expr(lhs, symbols, writer, &new_prefix, false)?;
|
|
write_typed_expr(rhs, symbols, writer, &new_prefix, true)
|
|
}
|
|
TypedExpr::IntToFloat { value, .. } => {
|
|
writeln!(writer, "i2f")?;
|
|
|
|
let new_prefix = if is_last {
|
|
format!("{} ", prefix)
|
|
} else {
|
|
format!("{}│ ", prefix)
|
|
};
|
|
|
|
write_typed_expr(value, symbols, writer, &new_prefix, true)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn print_typed_expr(
|
|
expr: &TypedExpr,
|
|
symbols: &SymbolsTable,
|
|
writer: &mut impl io::Write,
|
|
) -> io::Result<()> {
|
|
write_typed_expr(expr, symbols, writer, "", true)
|
|
}
|
|
|
|
fn write_untyped_expr(
|
|
expr: &UntypedExpr,
|
|
writer: &mut impl io::Write,
|
|
prefix: &str,
|
|
is_last: bool,
|
|
) -> io::Result<()> {
|
|
let branch = if is_last { "└──" } else { "├──" };
|
|
|
|
write!(writer, "{}{}", prefix, branch)?;
|
|
|
|
match expr {
|
|
UntypedExpr::Int { value, .. } => writeln!(writer, "<{}>", value),
|
|
UntypedExpr::Float { value, .. } => writeln!(writer, "<{}>", value),
|
|
UntypedExpr::Var {
|
|
name: id, typename, ..
|
|
} => {
|
|
write!(writer, "<id,{}", id)?;
|
|
if let Some(typename) = typename {
|
|
write!(writer, ",{}", typename)?;
|
|
}
|
|
writeln!(writer, ">")
|
|
}
|
|
UntypedExpr::BinOp { lhs, op, rhs, .. } => {
|
|
writeln!(writer, "<{}>", op)?;
|
|
|
|
let new_prefix = if is_last {
|
|
format!("{} ", prefix)
|
|
} else {
|
|
format!("{}│ ", prefix)
|
|
};
|
|
|
|
write_untyped_expr(lhs, writer, &new_prefix, false)?;
|
|
write_untyped_expr(rhs, writer, &new_prefix, true)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn print_untyped_expr(expr: &UntypedExpr, writer: &mut impl io::Write) -> io::Result<()> {
|
|
write_untyped_expr(expr, writer, "", true)
|
|
}
|