From 4f6f81714d98bfc2409fda129d419c4d1d75503b Mon Sep 17 00:00:00 2001 From: Akemi Izuko Date: Sat, 18 Nov 2023 13:09:30 -0700 Subject: [PATCH] Params: add verification pass to params --- params.toml | 4 +- src/main.rs | 9 ++- src/params.rs | 193 +++++++++++++++++++++++++++++++++++++++++++++++--- 3 files changed, 194 insertions(+), 12 deletions(-) diff --git a/params.toml b/params.toml index 7253a3a..362451b 100644 --- a/params.toml +++ b/params.toml @@ -1,3 +1,5 @@ +verify_config = true + [global_flow] gen_decl = 0.6 gen_subroutine = 0.0 @@ -18,7 +20,7 @@ gen_integer = 0.5 gen_real = 0.5 gen_tuple = 0.0 - qual_const = 0.0 + qual_const = 1.0 qual_var = 0.0 [statements.gen_global_decl] diff --git a/src/main.rs b/src/main.rs index 692f803..6d18c9e 100644 --- a/src/main.rs +++ b/src/main.rs @@ -17,12 +17,17 @@ struct Args { config: PathBuf, } -fn main() { +fn main() -> Result<(), String> { let args = Args::parse(); let params = Params::parse(&args.config); - let mut builder = AstBuilder::from(params); + if params.verify_config { + params.verify()?; + } + + let mut builder = AstBuilder::from(params); builder.generate(); println!("{}", builder.to_string()); + Ok(()) } diff --git a/src/params.rs b/src/params.rs index 8c8ad7a..174e8e5 100644 --- a/src/params.rs +++ b/src/params.rs @@ -22,6 +22,7 @@ macro_rules! toml_struct { toml_struct!{ struct Params { + verify_config: bool, global_flow: GlobalFlow, statements: Statments, types: Types, @@ -29,6 +30,37 @@ toml_struct!{ } } +impl Params { + pub fn parse(p: &PathBuf) -> Self { + let file_string = fs::read_to_string(p) + .expect("Failed to read parameters file into string"); + + let params: Params = toml::from_str(&file_string) + .expect("Failed to parse TOML from parameters file"); + + params + } + + pub fn verify(&self) -> Result<(), String> { + let global_flow = self.global_flow.verify(); + let statements = self.statements.verify(); + let types = self.types.verify(); + let dev = self.dev.verify(); + + if global_flow.is_err() { + global_flow + } else if statements.is_err() { + statements + } else if types.is_err() { + types + } else if dev.is_err() { + dev + } else { + Ok(()) + } + } +} + toml_struct!{ struct GlobalFlow { gen_decl: f64, @@ -38,6 +70,18 @@ toml_struct!{ } } +impl GlobalFlow { + fn verify(&self) -> Result<(), String> { + let sum = self.gen_decl + self.gen_subroutine + self.gen_typedef + self.end_generation; + + if (sum - 1.0).abs() > f64::EPSILON { + Err(format!("global_flow probability sum is = {}", sum)) + } else { + Ok(()) + } + } +} + toml_struct!{ struct Statments { gen_assign: GenAssign, @@ -48,6 +92,30 @@ toml_struct!{ } } +impl Statments { + fn verify(&self) -> Result<(), String> { + let gen_assign = self.gen_assign.verify(); + let gen_decl = self.gen_decl.verify(); + let gen_global_decl = self.gen_global_decl.verify(); + let gen_if_statement = self.gen_if_statement.verify(); + let gen_loop = self.gen_loop.verify(); + + if gen_assign.is_err() { + gen_assign + } else if gen_decl.is_err() { + gen_decl + } else if gen_global_decl.is_err() { + gen_global_decl + } else if gen_if_statement.is_err() { + gen_if_statement + } else if gen_loop.is_err() { + gen_loop + } else { + Ok(()) + } + } +} + toml_struct!{ struct GenAssign { gen_boolean: f64, @@ -58,6 +126,12 @@ toml_struct!{ } } +impl GenAssign { + fn verify(&self) -> Result<(), String> { + Ok(()) + } +} + toml_struct!{ struct GenDecl { gen_boolean: f64, @@ -70,6 +144,26 @@ toml_struct!{ } } +impl GenDecl { + fn verify(&self) -> Result<(), String> { + let sum_type = self.gen_boolean + + self.gen_character + + self.gen_integer + + self.gen_real + + self.gen_tuple; + + let sum_qual = self.qual_const + self.qual_var; + + if (sum_type - 1.0).abs() > f64::EPSILON { + Err(format!("statements.gen_decl probability sum for types is = {}", sum_type)) + } else if (sum_qual - 1.0).abs() > f64::EPSILON { + Err(format!("statements.gen_decl probability sum for qualifiers is = {}", sum_qual)) + } else { + Ok(()) + } + } +} + toml_struct!{ struct GenGlobalDecl { gen_boolean: f64, @@ -80,6 +174,12 @@ toml_struct!{ } } +impl GenGlobalDecl { + fn verify(&self) -> Result<(), String> { + Ok(()) + } +} + toml_struct!{ struct GenIfStatement { gen_statement: f64, @@ -90,6 +190,12 @@ toml_struct!{ } } +impl GenIfStatement { + fn verify(&self) -> Result<(), String> { + Ok(()) + } +} + toml_struct!{ struct GenLoop { gen_inf_loop: f64, @@ -99,6 +205,12 @@ toml_struct!{ } } +impl GenLoop { + fn verify(&self) -> Result<(), String> { + Ok(()) + } +} + toml_struct!{ struct Types { gen_boolean: GenBoolean, @@ -107,6 +219,24 @@ toml_struct!{ } } +impl Types { + fn verify(&self) -> Result<(), String> { + let gen_boolean = self.gen_boolean.verify(); + let gen_integer = self.gen_integer.verify(); + let gen_real = self.gen_real.verify(); + + if gen_boolean.is_err() { + gen_boolean + } else if gen_integer.is_err() { + gen_integer + } else if gen_real.is_err() { + gen_real + } else { + Ok(()) + } + } +} + toml_struct!{ struct GenBoolean { expr_and: f64, @@ -128,6 +258,12 @@ toml_struct!{ } } +impl GenBoolean { + fn verify(&self) -> Result<(), String> { + Ok(()) + } +} + toml_struct!{ struct GenInteger { expr_add: f64, @@ -143,6 +279,28 @@ toml_struct!{ } } +impl GenInteger { + fn verify(&self) -> Result<(), String> { + let sum = self.expr_add + + self.expr_sub + + self.expr_mul + + self.expr_div + + self.expr_rem + + self.expr_exp + + self.expr_pos + + self.expr_neg + + self.get_instant; + + if self.max_depth <= 0 { + Err("types.gen_integer.max_depth must be at least 1".to_string()) + } else if (sum - 1.0).abs() > f64::EPSILON { + Err(format!("types.gen_integer probability sum is = {}", sum)) + } else { + Ok(()) + } + } +} + toml_struct!{ struct GenReal { expr_add: f64, @@ -159,6 +317,29 @@ toml_struct!{ } } +impl GenReal { + fn verify(&self) -> Result<(), String> { + let sum = self.expr_add + + self.expr_sub + + self.expr_mul + + self.expr_div + + self.expr_rem + + self.expr_exp + + self.expr_pos + + self.expr_neg + + self.gen_integer + + self.get_instant; + + if self.max_depth <= 0 { + Err("types.gen_real.max_depth must be at least 1".to_string()) + } else if (sum - 1.0).abs() > f64::EPSILON { + Err(format!("types.gen_real probability sum is = {}", sum)) + } else { + Ok(()) + } + } +} + toml_struct!{ struct Dev { float_gen_distro_pos_stddiv: f32, @@ -168,14 +349,8 @@ toml_struct!{ } } -impl Params { - pub fn parse(p: &PathBuf) -> Self { - let file_string = fs::read_to_string(p) - .expect("Failed to read parameters file into string"); - - let params: Params = toml::from_str(&file_string) - .expect("Failed to parse TOML from parameters file"); - - params +impl Dev { + fn verify(&self) -> Result<(), String> { + Ok(()) } }