From 9b4bd25773a04e2f63417916b36d7953b4757d85 Mon Sep 17 00:00:00 2001 From: collin Date: Tue, 7 Apr 2020 14:52:34 -0700 Subject: [PATCH] impl variable declaration resolution --- simple.program | 4 +- src/aleo_program/constraints.rs | 73 +++++++++++++++++++++++++++++-- src/aleo_program/types.rs | 2 +- src/aleo_program/types_display.rs | 1 - src/lib.rs | 2 +- src/main.rs | 4 +- 6 files changed, 75 insertions(+), 11 deletions(-) diff --git a/simple.program b/simple.program index a5afe94873..05eecca22e 100644 --- a/simple.program +++ b/simple.program @@ -1,2 +1,2 @@ -x = 5 + a -return x * x * 2 \ No newline at end of file +x = a +return x \ No newline at end of file diff --git a/src/aleo_program/constraints.rs b/src/aleo_program/constraints.rs index 1b3de82d0c..14ceabae73 100644 --- a/src/aleo_program/constraints.rs +++ b/src/aleo_program/constraints.rs @@ -10,6 +10,7 @@ use snarkos_models::gadgets::{ }; use std::collections::HashMap; +#[derive(Clone)] pub enum ResolvedValue { Boolean(Boolean), FieldElement(UInt32), @@ -176,6 +177,7 @@ impl ResolvedProgram { expression: BooleanExpression, ) -> Boolean { match expression { + BooleanExpression::Variable(variable) => self.bool_from_variable(cs, variable), BooleanExpression::Not(expression) => self.enforce_not(cs, *expression), BooleanExpression::Or(left, right) => self.enforce_or(cs, *left, *right), BooleanExpression::And(left, right) => self.enforce_and(cs, *left, *right), @@ -282,6 +284,7 @@ impl ResolvedProgram { expression: FieldExpression, ) -> UInt32 { match expression { + FieldExpression::Variable(variable) => self.u32_from_variable(cs, variable), FieldExpression::Add(left, right) => self.enforce_add(cs, *left, *right), FieldExpression::Sub(left, right) => self.enforce_sub(cs, *left, *right), FieldExpression::Mul(left, right) => self.enforce_mul(cs, *left, *right), @@ -305,7 +308,11 @@ impl ResolvedProgram { Expression::Boolean(boolean_expression) => { let res = resolved_program.enforce_boolean_expression(cs, boolean_expression); - println!("variable boolean result: {}", res.get_value().unwrap()); + println!( + "variable boolean result: {} = {}", + variable.0, + res.get_value().unwrap() + ); resolved_program.insert(variable, ResolvedValue::Boolean(res)); } Expression::FieldElement(field_expression) => { @@ -317,7 +324,50 @@ impl ResolvedProgram { ); resolved_program.insert(variable, ResolvedValue::FieldElement(res)); } - _ => unimplemented!(), + Expression::Variable(unresolved_variable) => { + if resolved_program + .resolved_variables + .contains_key(&unresolved_variable) + { + // Reassigning variable to another variable + let already_assigned = resolved_program + .resolved_variables + .get_mut(&unresolved_variable) + .unwrap() + .clone(); + resolved_program.insert(variable, already_assigned); + } else { + // The type of the unassigned variable depends on what is passed in + if std::env::args() + .nth(1) + .unwrap_or("true".into()) + .parse::() + .is_ok() + { + let resolved_boolean = + resolved_program.bool_from_variable(cs, unresolved_variable); + println!( + "variable boolean result: {} = {}", + variable.0, + resolved_boolean.get_value().unwrap() + ); + resolved_program + .insert(variable, ResolvedValue::Boolean(resolved_boolean)); + } else { + let resolved_field_element = + resolved_program.u32_from_variable(cs, unresolved_variable); + println!( + " variable field result: {} = {}", + variable.0, + resolved_field_element.value.unwrap() + ); + resolved_program.insert( + variable, + ResolvedValue::FieldElement(resolved_field_element), + ); + } + } + } }, Statement::Return(statements) => { statements @@ -333,10 +383,25 @@ impl ResolvedProgram { resolved_program.enforce_field_expression(cs, field_expression); println!("field result: {}\n", res.value.unwrap()); } - _ => unimplemented!(), + Expression::Variable(variable) => { + match resolved_program + .resolved_variables + .get_mut(&variable) + .unwrap() + .clone() + { + ResolvedValue::Boolean(boolean) => println!( + "variable result: {}\n", + boolean.get_value().unwrap() + ), + ResolvedValue::FieldElement(field_element) => println!( + "variable field result: {}\n", + field_element.value.unwrap() + ), + } + } }); } - statement => unimplemented!("statement unimplemented: {}", statement), }); } } diff --git a/src/aleo_program/types.rs b/src/aleo_program/types.rs index 53d71e70fe..60bf0bedc7 100644 --- a/src/aleo_program/types.rs +++ b/src/aleo_program/types.rs @@ -76,7 +76,7 @@ pub enum Expression { pub enum Statement { /// A statement that could be directly translated to a R1CS constraint a * b = c to be enforced // Constraint(QuadraticCombination, LinearCombination), - Declaration(Variable), + // Declaration(Variable), Definition(Variable, Expression), Return(Vec), } diff --git a/src/aleo_program/types_display.rs b/src/aleo_program/types_display.rs index 4af0998c44..398b044b70 100644 --- a/src/aleo_program/types_display.rs +++ b/src/aleo_program/types_display.rs @@ -83,7 +83,6 @@ impl fmt::Debug for Statement { Statement::Definition(ref variable, ref statement) => { write!(f, "{} = {}", variable, statement) } - _ => unimplemented!(), } } } diff --git a/src/lib.rs b/src/lib.rs index a7ab88dfa2..93017c28c2 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -3,7 +3,7 @@ extern crate pest; extern crate pest_derive; extern crate from_pest; -#[macro_use] +// #[macro_use] extern crate pest_ast; #[macro_use] diff --git a/src/main.rs b/src/main.rs index 3a0d38f60e..b22959e23c 100644 --- a/src/main.rs +++ b/src/main.rs @@ -90,8 +90,8 @@ fn main() { verifying += start.elapsed(); - println!("\n Setup time: {:?} seconds", setup.as_secs()); - println!(" Proving time: {:?} seconds", proving.as_secs()); + println!(" Setup time : {:?} seconds", setup.as_secs()); + println!(" Proving time : {:?} seconds", proving.as_secs()); println!(" Verifying time: {:?} seconds", verifying.as_secs()); // let mut cs = TestConstraintSystem::::new();