university/developing-compilers
1
0
Fork 0
Code Activity

lab 6

Browse Source
This commit is contained in:
Lionarius
2024-11-10 10:33:24 +03:00
parent b6c6a3b4b7
commit 322a8faec7
6 changed files with 276 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

98
src/ast/mod.rs
View File

@@ -63,13 +63,109 @@ impl fmt::Display for BinOp {
}
}
pub fn to_typed_expr(expr: UntypedExpr, symbols: &mut SymbolsTable) -> error::Result<TypedExpr> {
pub fn to_typed_expr(
expr: UntypedExpr,
optimize: bool,
symbols: &mut SymbolsTable,
) -> error::Result<TypedExpr> {
let expr = convert_to_typed_expr(expr, symbols)?;
let expr = coerce_types(expr, symbols)?;
let expr = if optimize { optimize_expr(expr) } else { expr };
Ok(expr)
}
fn optimize_expr(expr: TypedExpr) -> TypedExpr {
let expr = match expr {
TypedExpr::BinOp { lhs, rhs, op, span } => {
let lhs = optimize_expr(*lhs);
let rhs = optimize_expr(*rhs);
match (lhs, rhs) {
(TypedExpr::Int { value: lhs, .. }, TypedExpr::Int { value: rhs, .. }) => {
TypedExpr::Int {
span,
value: match op {
BinOp::Add => lhs + rhs,
BinOp::Sub => lhs - rhs,
BinOp::Mul => lhs * rhs,
BinOp::Div => lhs / rhs,
},
}
}
(TypedExpr::Float { value: lhs, .. }, TypedExpr::Float { value: rhs, .. }) => {
TypedExpr::Float {
span,
value: match op {
BinOp::Add => lhs + rhs,
BinOp::Sub => lhs - rhs,
BinOp::Mul => lhs * rhs,
BinOp::Div => lhs / rhs,
},
}
}
(lhs, TypedExpr::Int { value: 0, .. })
| (TypedExpr::Float { value: 0.0, .. }, lhs)
if matches!(op, BinOp::Add | BinOp::Sub) =>
{
lhs
}
(lhs, TypedExpr::Int { value: 1, .. })
| (lhs, TypedExpr::Float { value: 1.0, .. })
if matches!(op, BinOp::Mul | BinOp::Div) =>
{
lhs
}
(TypedExpr::Int { value: 0, .. }, rhs)
| (TypedExpr::Float { value: 0.0, .. }, rhs)
if matches!(op, BinOp::Add) =>
{
rhs
}
(TypedExpr::Int { value: 1, .. }, rhs)
| (TypedExpr::Float { value: 1.0, .. }, rhs)
if matches!(op, BinOp::Mul) =>
{
rhs
}
(TypedExpr::Int { value: 0, .. }, _) | (_, TypedExpr::Int { value: 0, .. })
if matches!(op, BinOp::Mul) =>
{
TypedExpr::Int { span, value: 0 }
}
(TypedExpr::Float { value: 0.0, .. }, _)
| (_, TypedExpr::Float { value: 0.0, .. })
if matches!(op, BinOp::Mul) =>
{
TypedExpr::Float { span, value: 0.0 }
}
(lhs, rhs) => TypedExpr::BinOp {
span,
lhs: Box::new(lhs),
op,
rhs: Box::new(rhs),
},
}
}
TypedExpr::IntToFloat { value } => {
let value = optimize_expr(*value);
if let TypedExpr::Int { value, span } = value {
TypedExpr::Float {
span,
value: value as f64,
}
} else {
TypedExpr::IntToFloat {
value: Box::new(value),
}
}
}
expr => expr,
};
expr
}
fn convert_to_typed_expr(
expr: UntypedExpr,
symbols: &mut SymbolsTable,

2
src/cli.rs
View File

@@ -29,6 +29,8 @@ pub enum Command {
},
Gen {
mode: GenMode,
#[clap(short, long, default_value_t = false)]
optimize: bool,
input: PathBuf,
output: PathBuf,
output_symbols: PathBuf,

24
src/main.rs
View File

@@ -6,13 +6,12 @@ mod representation;
mod symbols;
mod util;
use cli::GenMode;
use parse::parser::Parser;
use std::{
io::{self, Write},
path::Path,
};
use cli::GenMode;
use parse::parser::Parser;
use symbols::SymbolsTable;
fn main() -> anyhow::Result<()> {
@@ -34,11 +33,12 @@ fn main() -> anyhow::Result<()> {
}
cli::Command::Gen {
mode,
optimize,
input,
output,
output_symbols,
} => {
gen_command(mode, input, output, output_symbols)?;
gen_command(mode, *optimize, input, output, output_symbols)?;
}
}
@@ -47,6 +47,7 @@ fn main() -> anyhow::Result<()> {
fn gen_command(
mode: &GenMode,
optimize: bool,
input: &Path,
output: &Path,
output_symbols: &Path,
@@ -58,7 +59,7 @@ fn gen_command(
let mut parser = Parser::new(tokens);
parser.parse()
}
.and_then(|expr| ast::to_typed_expr(expr, &mut symbols))
.and_then(|expr| ast::to_typed_expr(expr, optimize, &mut symbols))
{
Ok(expr) => expr,
Err(e) => {
@@ -71,8 +72,15 @@ fn gen_command(
match mode {
GenMode::Intermediate => {
let intermediate_exprs =
representation::intermediate::to_intermediate_expr(typed_expr, &mut symbols);
let intermediate_exprs = representation::intermediate::to_intermediate_expr(
typed_expr,
optimize,
&mut symbols,
);
let used_symbols = util::collect_used_symbols(&intermediate_exprs);
symbols.retain(&used_symbols);
util::print_intermediate_exprs(&intermediate_exprs, &mut writer)?;
}
GenMode::Postfix => {
@@ -97,7 +105,7 @@ fn sem_command(input: &Path, output_tree: &Path) -> Result<(), anyhow::Error> {
let mut parser = Parser::new(tokens);
parser.parse()
}
.and_then(|expr| ast::to_typed_expr(expr, &mut symbols));
.and_then(|expr| ast::to_typed_expr(expr, false, &mut symbols));
match res {
Ok(expr) => {

139
src/representation/intermediate.rs
View File

@@ -1,5 +1,6 @@
use std::fmt;
use crate::ast::typed::Type;
use crate::{
ast::{typed::TypedExpr, BinOp},
symbols::{Symbol, SymbolsTable},
@@ -36,11 +37,26 @@ pub enum IntermediateExpr {
},
}
fn add_temp_var(temp_var_counter: &mut usize, ty: Type, symbols: &mut SymbolsTable) -> Symbol {
let result = symbols.add(format!("#T{}", temp_var_counter));
{
let data = symbols.resolve_mut(&result).unwrap();
data.ty = Some(ty);
data.temporary = true;
}
*temp_var_counter += 1;
result
}
fn to_intermediate_expr_inner(
expr: TypedExpr,
reuse_symbols: bool,
symbols: &mut SymbolsTable,
intermediate_var_counter: &mut usize,
temp_var_counter: &mut usize,
exprs: &mut Vec<IntermediateExpr>,
temp_float_vars: &mut Vec<Symbol>,
temp_int_vars: &mut Vec<Symbol>,
) -> IntermediateValue {
let ty = expr.ty(symbols);
@@ -49,12 +65,41 @@ fn to_intermediate_expr_inner(
TypedExpr::Float { value, .. } => IntermediateValue::Float { value },
TypedExpr::Var { name, .. } => IntermediateValue::Var { name },
TypedExpr::BinOp { lhs, op, rhs, .. } => {
let lhs = to_intermediate_expr_inner(*lhs, symbols, intermediate_var_counter, exprs);
let rhs = to_intermediate_expr_inner(*rhs, symbols, intermediate_var_counter, exprs);
let lhs = to_intermediate_expr_inner(
*lhs,
reuse_symbols,
symbols,
temp_var_counter,
exprs,
temp_float_vars,
temp_int_vars,
);
let rhs = to_intermediate_expr_inner(
*rhs,
reuse_symbols,
symbols,
temp_var_counter,
exprs,
temp_float_vars,
temp_int_vars,
);
let result = symbols.add(format!("#T{}", intermediate_var_counter));
symbols.resolve_mut(&result).unwrap().ty = Some(ty);
*intermediate_var_counter += 1;
if let IntermediateValue::Var { name } = lhs {
free_temp_var(name, ty, temp_int_vars, temp_float_vars, symbols)
}
if let IntermediateValue::Var { name } = rhs {
free_temp_var(name, ty, temp_int_vars, temp_float_vars, symbols)
}
let result = allocate_temp_var(
ty,
reuse_symbols,
temp_var_counter,
temp_float_vars,
temp_int_vars,
symbols,
);
exprs.push(IntermediateExpr::BinOp {
result,
@@ -66,12 +111,28 @@ fn to_intermediate_expr_inner(
IntermediateValue::Var { name: result }
}
TypedExpr::IntToFloat { value, .. } => {
let value =
to_intermediate_expr_inner(*value, symbols, intermediate_var_counter, exprs);
let value = to_intermediate_expr_inner(
*value,
reuse_symbols,
symbols,
temp_var_counter,
exprs,
temp_float_vars,
temp_int_vars,
);
let result = symbols.add(format!("#T{}", intermediate_var_counter));
symbols.resolve_mut(&result).unwrap().ty = Some(ty);
*intermediate_var_counter += 1;
if let IntermediateValue::Var { name: value } = value {
free_temp_var(value, Type::Int, temp_int_vars, temp_float_vars, symbols)
}
let result = allocate_temp_var(
ty,
reuse_symbols,
temp_var_counter,
temp_float_vars,
temp_int_vars,
symbols,
);
exprs.push(IntermediateExpr::IntToFloat { result, value });
@@ -80,11 +141,63 @@ fn to_intermediate_expr_inner(
}
}
pub fn to_intermediate_expr(expr: TypedExpr, symbols: &mut SymbolsTable) -> Vec<IntermediateExpr> {
fn allocate_temp_var(
ty: Type,
reuse_symbols: bool,
temp_var_counter: &mut usize,
temp_float_vars: &mut Vec<Symbol>,
temp_int_vars: &mut Vec<Symbol>,
symbols: &mut SymbolsTable,
) -> Symbol {
if reuse_symbols {
match ty {
Type::Int if !temp_int_vars.is_empty() => temp_int_vars.pop().unwrap(),
Type::Float if !temp_float_vars.is_empty() => temp_float_vars.pop().unwrap(),
_ => add_temp_var(temp_var_counter, ty, symbols),
}
} else {
add_temp_var(temp_var_counter, ty, symbols)
}
}
fn free_temp_var(
name: Symbol,
ty: Type,
temp_int_vars: &mut Vec<Symbol>,
temp_float_vars: &mut Vec<Symbol>,
symbols: &mut SymbolsTable,
) {
let temporary = symbols.temporary(&name).unwrap();
if !temporary {
return;
}
if ty == Type::Int {
temp_int_vars.push(name);
} else {
temp_float_vars.push(name);
}
}
pub fn to_intermediate_expr(
expr: TypedExpr,
reuse_symbols: bool,
symbols: &mut SymbolsTable,
) -> Vec<IntermediateExpr> {
let mut exprs = Vec::new();
let mut intermediate_var_counter = 0;
let mut temp_float_vars = Vec::new();
let mut temp_int_vars = Vec::new();
to_intermediate_expr_inner(expr, symbols, &mut intermediate_var_counter, &mut exprs);
to_intermediate_expr_inner(
expr,
reuse_symbols,
symbols,
&mut intermediate_var_counter,
&mut exprs,
&mut temp_float_vars,
&mut temp_int_vars,
);
exprs
}

4
src/symbols/mod.rs
View File

@@ -55,6 +55,10 @@ impl SymbolsTable {
}
}
pub fn retain(&mut self, symbols: &[Symbol]) {
self.symbols.retain(|_, data| symbols.contains(&data.id));
}
pub fn add(&mut self, symbol: impl Into<String>) -> Symbol {
let symbol = symbol.into();
if let hash_map::Entry::Vacant(e) = self.symbols.entry(symbol.clone()) {

31
src/util.rs
View File

@@ -1,11 +1,42 @@
use std::collections::HashSet;
use std::io;
use crate::representation::intermediate::IntermediateValue;
use crate::symbols::Symbol;
use crate::{
ast::{typed::TypedExpr, UntypedExpr},
representation::intermediate::IntermediateExpr,
symbols::SymbolsTable,
};
pub fn collect_used_symbols(expr: &[IntermediateExpr]) -> Vec<Symbol> {
let mut used_symbols = HashSet::new();
for expr in expr {
match expr {
IntermediateExpr::IntToFloat { result, value } => {
used_symbols.insert(*result);
if let IntermediateValue::Var { name } = value {
used_symbols.insert(*name);
}
}
IntermediateExpr::BinOp {
result, lhs, rhs, ..
} => {
used_symbols.insert(*result);
if let IntermediateValue::Var { name } = lhs {
used_symbols.insert(*name);
}
if let IntermediateValue::Var { name } = rhs {
used_symbols.insert(*name);
}
}
}
}
used_symbols.into_iter().collect()
}
pub fn print_intermediate_exprs(
exprs: &[IntermediateExpr],
writer: &mut impl io::Write,