Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Remove benign shadowing #104

Merged
merged 15 commits into from
Jun 29, 2024
Merged

Remove benign shadowing #104

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
15 commits
Select commit Hold shift + click to select a range
4d51d19
Remove benign shadowing
Ketasaja Jun 26, 2024
ff3b3fa
Use hashmap for variable suffixes
Ketasaja Jun 27, 2024
f71bc96
Make string arguments more idiomatic
Ketasaja Jun 27, 2024
06bf122
Move functions into Gen, change add_occurrence
Ketasaja Jun 27, 2024
d0aa345
`add_occurrence` returns `(String, Expr)`
Ketasaja Jun 27, 2024
b3ff89f
Use expression returns
Ketasaja Jun 27, 2024
ea794e0
Formatting
Ketasaja Jun 27, 2024
121c512
Stop enum shadowing
Ketasaja Jun 28, 2024
c14c379
Stop CFrame shadowing
Ketasaja Jun 28, 2024
cadce4b
Stop aligned CFrame shadowing
Ketasaja Jun 28, 2024
acc5ede
Formatting
Ketasaja Jun 28, 2024
98c5194
Fix buffer
Ketasaja Jun 28, 2024
7f93749
Fix buffers
Ketasaja Jun 28, 2024
4d1c3cb
Rename `j` to `val`
Ketasaja Jun 28, 2024
a315dbb
Apply Linter
sasial-dev Jun 29, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
118 changes: 77 additions & 41 deletions zap/src/irgen/des.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,10 +1,12 @@
use crate::config::{Enum, NumTy, Struct, Ty};
use std::collections::HashMap;

use super::{Expr, Gen, Stmt, Var};

struct Des {
checks: bool,
buf: Vec<Stmt>,
var_occurrences: HashMap<String, usize>,
}

impl Gen for Des {
Expand All @@ -16,6 +18,10 @@ impl Gen for Des {
self.push_ty(ty, var);
self.buf
}

fn get_var_occurrences(&mut self) -> &mut HashMap<String, usize> {
&mut self.var_occurrences
}
}

impl Des {
Expand All @@ -30,13 +36,14 @@ impl Des {
Enum::Unit(enumerators) => {
let numty = NumTy::from_f64(0.0, enumerators.len() as f64 - 1.0);

self.push_local("enum_value", Some(self.readnumty(numty)));
let (enum_value_name, enum_value_expr) = self.add_occurrence("enum_value");
self.push_local(enum_value_name, Some(self.readnumty(numty)));

for (i, enumerator) in enumerators.iter().enumerate() {
if i == 0 {
self.push_stmt(Stmt::If(Expr::from("enum_value").eq((i as f64).into())));
self.push_stmt(Stmt::If(enum_value_expr.clone().eq((i as f64).into())));
} else {
self.push_stmt(Stmt::ElseIf(Expr::from("enum_value").eq((i as f64).into())));
self.push_stmt(Stmt::ElseIf(enum_value_expr.clone().eq((i as f64).into())));
}

self.push_assign(into.clone(), Expr::Str(enumerator.to_string()));
Expand All @@ -50,13 +57,14 @@ impl Des {
Enum::Tagged { tag, variants } => {
let numty = NumTy::from_f64(0.0, variants.len() as f64 - 1.0);

self.push_local("enum_value", Some(self.readnumty(numty)));
let (enum_value_name, enum_value_expr) = self.add_occurrence("enum_value");
self.push_local(enum_value_name, Some(self.readnumty(numty)));

for (i, (name, struct_ty)) in variants.iter().enumerate() {
if i == 0 {
self.push_stmt(Stmt::If(Expr::from("enum_value").eq((i as f64).into())));
self.push_stmt(Stmt::If(enum_value_expr.clone().eq((i as f64).into())));
} else {
self.push_stmt(Stmt::ElseIf(Expr::from("enum_value").eq((i as f64).into())));
self.push_stmt(Stmt::ElseIf(enum_value_expr.clone().eq((i as f64).into())));
}

self.push_assign(into.clone().nindex(*tag), Expr::Str(name.to_string()));
Expand Down Expand Up @@ -86,66 +94,71 @@ impl Des {
if let Some(len) = range.exact() {
self.push_assign(into, self.readstring(len.into()));
} else {
self.push_local("len", Some(self.readnumty(NumTy::U16)));
let (len_name, len_expr) = self.add_occurrence("len");

self.push_local(len_name.clone(), Some(self.readnumty(NumTy::U16)));

if self.checks {
self.push_range_check(Expr::from("len"), *range);
self.push_range_check(len_expr.clone(), *range);
}

self.push_assign(into, self.readstring(Expr::from("len")));
self.push_assign(into, self.readstring(len_expr.clone()));
}
}

Ty::Buf(range) => {
if let Some(len) = range.exact() {
self.push_read_copy(into, len.into());
} else {
self.push_local("len", Some(self.readnumty(NumTy::U16)));
let (len_name, len_expr) = self.add_occurrence("len");
self.push_local(len_name.clone(), Some(self.readnumty(NumTy::U16)));

if self.checks {
self.push_range_check(Expr::from("len"), *range);
self.push_range_check(len_expr.clone(), *range);
}

self.push_read_copy(into, Expr::from("len"))
self.push_read_copy(into, len_expr.clone())
}
}

Ty::Arr(ty, range) => {
self.push_assign(into.clone(), Expr::EmptyTable);

let var_name: String = format!("i_{}", into.display_escaped_suffix() + 1);
let (var_name, var_expr) = self.add_occurrence("i");

if let Some(len) = range.exact() {
self.push_stmt(Stmt::NumFor {
var: var_name.clone().leak(),
var: var_name.clone(),
from: 1.0.into(),
to: len.into(),
});

self.push_ty(ty, into.clone().eindex(var_name.as_str().into()));
self.push_ty(ty, into.clone().eindex(var_expr.clone()));
self.push_stmt(Stmt::End);
} else {
self.push_local("len", Some(self.readnumty(NumTy::U16)));
let (len_name, len_expr) = self.add_occurrence("len");

self.push_local(len_name.clone(), Some(self.readnumty(NumTy::U16)));

if self.checks {
self.push_range_check(Expr::from("len"), *range);
self.push_range_check(len_expr.clone(), *range);
}

self.push_stmt(Stmt::NumFor {
var: var_name.clone().leak(),
var: var_name.clone(),
from: 1.0.into(),
to: "len".into(),
to: len_expr.clone(),
});

let inner_var_name = format!("j_{}", into.display_escaped_suffix() + 1);
let (inner_var_name, _) = self.add_occurrence("val");

self.push_local(inner_var_name.clone().leak(), None);
self.push_local(inner_var_name.clone(), None);

self.push_ty(ty, Var::Name(inner_var_name.clone()));

self.push_stmt(Stmt::Assign(
into.clone().eindex(var_name.clone().as_str().into()),
Var::Name(inner_var_name).into(),
into.clone().eindex(var_expr.clone()),
Var::Name(inner_var_name.clone()).into(),
));

self.push_stmt(Stmt::End);
Expand All @@ -156,20 +169,20 @@ impl Des {
self.push_assign(into.clone(), Expr::EmptyTable);

self.push_stmt(Stmt::NumFor {
var: "_",
var: "_".into(),
from: 1.0.into(),
to: self.readu16(),
});

let key_name = format!("key_{}", into.display_escaped_suffix() + 1);
self.push_local(key_name.clone().leak(), None);
let val_name = format!("val_{}", into.display_escaped_suffix() + 1);
self.push_local(val_name.clone().leak(), None);
let (key_name, key_expr) = self.add_occurrence("key");
self.push_local(key_name.clone(), None);
let (val_name, val_expr) = self.add_occurrence("val");
self.push_local(val_name.clone(), None);

self.push_ty(key, Var::Name(key_name.clone()));
self.push_ty(val, Var::Name(val_name.clone()));

self.push_assign(into.clone().eindex(key_name.as_str().into()), val_name.as_str().into());
self.push_assign(into.clone().eindex(key_expr.clone()), val_expr.clone());

self.push_stmt(Stmt::End);
}
Expand Down Expand Up @@ -315,26 +328,40 @@ impl Des {
Ty::Vector3 => self.push_assign(into, self.readvector3()),

Ty::AlignedCFrame => {
self.push_local("axis_alignment", Some(self.readu8()));
let (axis_alignment_name, axis_alignment_expr) = self.add_occurrence("axis_alignment");

self.push_local("pos", Some(self.readvector3()));
self.push_local(axis_alignment_name, Some(self.readu8()));

let (pos_name, pos_expr) = self.add_occurrence("pos");

self.push_local(pos_name.clone(), Some(self.readvector3()));

self.push_assign(
into,
Expr::Mul(
Box::new(Expr::Call(
Box::new(Var::from("CFrame").nindex("new")),
None,
vec!["pos".into()],
vec![pos_expr.clone()],
)),
Box::new(Var::from("CFrameSpecialCases").eindex("axis_alignment".into()).into()),
Box::new(
Var::from("CFrameSpecialCases")
.eindex(axis_alignment_expr.clone())
.into(),
),
),
);
}
Ty::CFrame => {
self.push_local("pos", Some(self.readvector3()));
self.push_local("axisangle", Some(self.readvector3()));
self.push_local("angle", Some(Var::from("axisangle").nindex("Magnitude").into()));
let (pos_name, pos_expr) = self.add_occurrence("pos");
self.push_local(pos_name.clone(), Some(self.readvector3()));
let (axisangle_name, axisangle_expr) = self.add_occurrence("axisangle");
self.push_local(axisangle_name.clone(), Some(self.readvector3()));
let (angle_name, angle_expr) = self.add_occurrence("angle");
self.push_local(
angle_name,
Some(Var::from(axisangle_name.as_str()).nindex("Magnitude").into()),
);

// We don't need to convert the axis back to a unit vector as the constructor does that for us
// The angle is the magnitude of the axis vector
Expand All @@ -347,22 +374,26 @@ impl Des {
// value = CFrame.new(pos)
// end

self.push_stmt(Stmt::If(Expr::Neq(Box::new("angle".into()), Box::new("0".into()))));
self.push_stmt(Stmt::If(Expr::Neq(Box::new(angle_expr.clone()), Box::new("0".into()))));
self.push_assign(
into.clone(),
Expr::Add(
Box::new(Expr::Call(
Box::new(Var::from("CFrame").nindex("fromAxisAngle")),
None,
vec!["axisangle".into(), "angle".into()],
vec![axisangle_expr.clone(), angle_expr.clone()],
)),
Box::new("pos".into()),
Box::new(pos_expr.clone()),
),
);
self.push_stmt(Stmt::Else);
self.push_assign(
into,
Expr::Call(Box::new(Var::from("CFrame").nindex("new")), None, vec!["pos".into()]),
Expr::Call(
Box::new(Var::from("CFrame").nindex("new")),
None,
vec![pos_expr.clone()],
),
);
self.push_stmt(Stmt::End);
}
Expand All @@ -371,5 +402,10 @@ impl Des {
}

pub fn gen(ty: &Ty, var: &str, checks: bool) -> Vec<Stmt> {
Des { checks, buf: vec![] }.gen(var.into(), ty)
Des {
checks,
buf: vec![],
var_occurrences: HashMap::new(),
}
.gen(var.into(), ty)
}
50 changes: 23 additions & 27 deletions zap/src/irgen/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,4 +1,5 @@
#![allow(dead_code)]
use std::collections::HashMap;
use std::{fmt::Display, vec};

use crate::config::{NumTy, Range, Ty};
Expand All @@ -10,7 +11,7 @@ pub trait Gen {
fn push_stmt(&mut self, stmt: Stmt);
fn gen(self, var: Var, ty: &Ty<'_>) -> Vec<Stmt>;

fn push_local(&mut self, name: &'static str, expr: Option<Expr>) {
fn push_local(&mut self, name: String, expr: Option<Expr>) {
self.push_stmt(Stmt::Local(name, expr))
}

Expand Down Expand Up @@ -244,28 +245,37 @@ pub trait Gen {
self.push_assert(expr.clone().lte(max.into()), None)
}
}

fn get_var_occurrences(&mut self) -> &mut HashMap<String, usize>;
fn add_occurrence(&mut self, name: &str) -> (String, Expr) {
match self.get_var_occurrences().get(name) {
Some(occurrences) => {
let occurrences_inc = occurrences + 1;
self.get_var_occurrences().insert(name.into(), occurrences_inc);
let suffixed_name = format!("{name}_{occurrences_inc}");
(suffixed_name.clone(), Expr::from(suffixed_name.as_str()))
}
None => {
self.get_var_occurrences().insert(name.into(), 1);
let suffixed_name = format!("{name}_1");
(suffixed_name.clone(), Expr::from(suffixed_name.as_str()))
}
}
}
}

#[derive(Debug, Clone)]
pub enum Stmt {
Local(&'static str, Option<Expr>),
LocalTuple(Vec<&'static str>, Option<Expr>),
Local(String, Option<Expr>),
LocalTuple(Vec<String>, Option<Expr>),
Assign(Var, Expr),
Error(String),
Assert(Expr, Option<String>),

Call(Var, Option<String>, Vec<Expr>),

NumFor {
var: &'static str,
from: Expr,
to: Expr,
},
GenFor {
key: &'static str,
val: &'static str,
obj: Expr,
},
NumFor { var: String, from: Expr, to: Expr },
GenFor { key: String, val: String, obj: Expr },
If(Expr),
ElseIf(Expr),
Else,
Expand Down Expand Up @@ -293,20 +303,6 @@ impl Var {
pub fn call(self, args: Vec<Expr>) -> Expr {
Expr::Call(Box::new(self), None, args)
}

pub fn display_escaped_suffix(&self) -> i32 {
match self {
Self::Name(name) => match name.find('_') {
Some(underscore_index) => match name[underscore_index + 1..].parse::<i32>() {
Ok(number) => number + 1,
Err(_) => 0,
},
None => 0,
},
Self::NameIndex(var, _) => var.display_escaped_suffix() + 1,
Self::ExprIndex(var, _) => var.display_escaped_suffix() + 1,
}
}
}

impl From<&str> for Var {
Expand Down
Loading