Merge pull request #113 from CSML-by-Clevy/fix/uninitialized_variable…

…_checker Fix/uninitialized variable checker
CSML-by-Clevy · Sep 22, 2020 · 0ce5a1e · 0ce5a1e
2 parents 73df79d + 7e73cd1
commit 0ce5a1e
Show file tree

Hide file tree

Showing 7 changed files with 42 additions and 32 deletions.
diff --git a/csml_interpreter/CSML/examples/hello_world.csml b/csml_interpreter/CSML/examples/hello_world.csml
@@ -1,9 +1,5 @@
 start:
-    say "Hello World 😆"
-    goto step toto
-
-toto:
 
-    say "hola from toto"
+    say "Hello World 😆"
 
-    goto end
+    goto end
diff --git a/csml_interpreter/src/interpreter/ast_interpreter/actions.rs b/csml_interpreter/src/interpreter/ast_interpreter/actions.rs
@@ -52,16 +52,16 @@ pub fn match_actions(
 ) -> Result<MessageData, ErrorInfo> {
     match function {
         ObjectType::Say(arg) => {
-            let msg = Message::new(expr_to_literal(arg, None, data, &mut root, sender)?)?;
+            let msg = Message::new(expr_to_literal(arg, false, None, data, &mut root, sender)?)?;
             MSG::send(&sender, MSG::Message(msg.clone()));
             Ok(Message::add_to_message(root, MessageType::Msg(msg)))
         }
         ObjectType::Use(arg) => {
-            expr_to_literal(arg, None, data, &mut root, sender)?;
+            expr_to_literal(arg, false, None, data, &mut root, sender)?;
             Ok(root)
         }
         ObjectType::Do(DoType::Update(old, new)) => {
-            let new_value = expr_to_literal(new, None, data, &mut root, sender)?;
+            let new_value = expr_to_literal(new, false, None, data, &mut root, sender)?;
             let (lit, name, mem_type, path) = get_var_info(old, None, data, &mut root, sender)?;
             exec_path_actions(
                 lit,
@@ -84,7 +84,7 @@ pub fn match_actions(
             Ok(root)
         }
         ObjectType::Do(DoType::Exec(expr)) => {
-            expr_to_literal(expr, None, data, &mut root, sender)?;
+            expr_to_literal(expr, false, None, data, &mut root, sender)?;
             Ok(root)
         }
         ObjectType::Goto(GotoType::Step(step), ..) => {
@@ -123,7 +123,6 @@ pub fn match_actions(
             Ok(root)
         }
         ObjectType::Goto(GotoType::StepFlow { step, flow }, ..) => {
-
             let mut flow_opt = Some(flow.to_owned());
             root.exit_condition = Some(ExitCondition::Goto);
 
@@ -146,7 +145,7 @@ pub fn match_actions(
             Ok(root)
         }
         ObjectType::Remember(name, variable) => {
-            let lit = expr_to_literal(variable, None, data, &mut root, sender)?;
+            let lit = expr_to_literal(variable, false, None, data, &mut root, sender)?;
             root.add_to_memory(&name.ident, lit.clone());
 
             MSG::send(

diff --git a/csml_interpreter/src/interpreter/ast_interpreter/for_loop.rs b/csml_interpreter/src/interpreter/ast_interpreter/for_loop.rs
@@ -21,7 +21,7 @@ pub fn for_loop(
     instruction_index: Option<usize>,
     sender: &Option<mpsc::Sender<MSG>>,
 ) -> Result<MessageData, ErrorInfo> {
-    let literal = expr_to_literal(expr, None, data, &mut root, sender)?;
+    let literal = expr_to_literal(expr, false, None, data, &mut root, sender)?;
     let array = Literal::get_value::<Vec<Literal>>(
         &literal.primitive,
         range.start.to_owned(),

diff --git a/csml_interpreter/src/interpreter/ast_interpreter/if_statement.rs b/csml_interpreter/src/interpreter/ast_interpreter/if_statement.rs
@@ -33,12 +33,12 @@ fn valid_condition(
     match expr {
         Expr::LitExpr(literal) => valid_literal(Ok(literal.to_owned())),
         Expr::IdentExpr(ident) => {
-            valid_literal(get_var(ident.to_owned(), None, data, root, sender))
+            valid_literal(get_var(ident.to_owned(), true, None, data, root, sender))
         }
         Expr::InfixExpr(inf, exp_1, exp_2) => {
             valid_literal(evaluate_condition(inf, exp_1, exp_2, data, root, sender))
         }
-        value => valid_literal(expr_to_literal(value, None, data, root, sender)),
+        value => valid_literal(expr_to_literal(value, true, None, data, root, sender)),
     }
 }
 
@@ -84,7 +84,7 @@ pub fn evaluate_condition(
 ) -> Result<Literal, ErrorInfo> {
     match (expr1, expr2) {
         (exp_1, ..) if Infix::Not == *infix => {
-            let value = !valid_literal(expr_to_literal(exp_1, None, data, root, sender));
+            let value = !valid_literal(expr_to_literal(exp_1, true, None, data, root, sender));
             let interval = interval_from_expr(exp_1);
             Ok(PrimitiveBoolean::get_literal(value, interval))
         }
@@ -96,17 +96,17 @@ pub fn evaluate_condition(
         (Expr::InfixExpr(i1, ex1, ex2), exp) => evaluate(
             infix,
             evaluate_condition(i1, ex1, ex2, data, root, sender),
-            expr_to_literal(exp, None, data, root, sender),
+            expr_to_literal(exp, true, None, data, root, sender),
         ),
         (exp, Expr::InfixExpr(i1, ex1, ex2)) => evaluate(
             infix,
-            expr_to_literal(exp, None, data, root, sender),
+            expr_to_literal(exp, true, None, data, root, sender),
             evaluate_condition(i1, ex1, ex2, data, root, sender),
         ),
         (exp_1, exp_2) => evaluate(
             infix,
-            expr_to_literal(exp_1, None, data, root, sender),
-            expr_to_literal(exp_2, None, data, root, sender),
+            expr_to_literal(exp_1, true, None, data, root, sender),
+            expr_to_literal(exp_2, true, None, data, root, sender),
         ),
     }
 }

diff --git a/csml_interpreter/src/interpreter/variable_handler.rs b/csml_interpreter/src/interpreter/variable_handler.rs
@@ -111,7 +111,7 @@ pub fn resolve_path(
     for (interval, node) in path.iter() {
         match node {
             PathState::ExprIndex(expr) => {
-                let lit = expr_to_literal(&expr, None, data, root, sender)?;
+                let lit = expr_to_literal(&expr, false, None, data, root, sender)?;
                 if let Ok(val) = Literal::get_value::<i64>(
                     &lit.primitive,
                     lit.interval,
@@ -307,6 +307,7 @@ pub fn get_literal_form_metadata(
 
 pub fn get_var(
     var: Identifier,
+    condition: bool, // TODO: find better method than this
     path: Option<&[(Interval, PathState)]>,
     data: &mut Data,
     root: &mut MessageData,
@@ -351,9 +352,15 @@ pub fn get_var(
                 Ok(new_literal)
             }
             Err(err) => {
-                // TODO: update error message and send warning
                 // if value does not exist in memory we create a null value and we apply all the path actions
-                let mut null = MSG::send_error_msg(&sender, root, Err(err));
+                // if we are not in a condition an error message is created and send
+                let mut null = match condition {
+                    true => PrimitiveNull::get_literal(err.position.interval),
+                    false => {
+                        println!("send error");
+                        MSG::send_error_msg(&sender, root, Err(err))
+                    }
+                };
 
                 let path = if let Some(p) = path {
                     Some(resolve_path(p, data, root, sender)?)
@@ -413,7 +420,7 @@ pub fn get_string_from_complex_string(
 
     //TODO: log error with span
     for elem in exprs.iter() {
-        match expr_to_literal(elem, None, data, root, sender) {
+        match expr_to_literal(elem, false, None, data, root, sender) {
             Ok(var) => new_string.push_str(&var.primitive.to_string()),
             Err(err) => {
                 return Err(err);

diff --git a/csml_interpreter/src/interpreter/variable_handler/expr_to_literal.rs b/csml_interpreter/src/interpreter/variable_handler/expr_to_literal.rs
@@ -77,19 +77,20 @@ fn normal_object_to_literal(
 
 pub fn expr_to_literal(
     expr: &Expr,
+    condition: bool,
     path: Option<&[(Interval, PathState)]>,
     data: &mut Data,
     root: &mut MessageData,
     sender: &Option<mpsc::Sender<MSG>>,
 ) -> Result<Literal, ErrorInfo> {
     match expr {
         Expr::ObjectExpr(ObjectType::As(name, var)) => {
-            let value = expr_to_literal(var, None, data, root, sender)?;
+            let value = expr_to_literal(var, false, None, data, root, sender)?;
             data.step_vars.insert(name.ident.to_owned(), value.clone());
             Ok(value)
         }
         Expr::PathExpr { literal, path } => {
-            expr_to_literal(literal, Some(path), data, root, sender)
+            expr_to_literal(literal, false, Some(path), data, root, sender)
         }
         Expr::ObjectExpr(ObjectType::Normal(Function {
             name,
@@ -106,7 +107,7 @@ pub fn expr_to_literal(
             for (key, value) in map.iter() {
                 object.insert(
                     key.to_owned(),
-                    expr_to_literal(&value, None, data, root, sender)?,
+                    expr_to_literal(&value, false, None, data, root, sender)?,
                 );
             }
             let mut literal = PrimitiveObject::get_literal(&object, start.to_owned());
@@ -120,7 +121,7 @@ pub fn expr_to_literal(
         Expr::VecExpr(vec, range) => {
             let mut array = vec![];
             for value in vec.iter() {
-                array.push(expr_to_literal(value, None, data, root, sender)?)
+                array.push(expr_to_literal(value, false, None, data, root, sender)?)
             }
             let mut literal = PrimitiveArray::get_literal(&array, range.start.to_owned());
             exec_path_literal(&mut literal, path, data, root, sender)
@@ -129,7 +130,14 @@ pub fn expr_to_literal(
             evaluate_condition(infix, exp_1, exp_2, data, root, sender)
         }
         Expr::LitExpr(literal) => exec_path_literal(&mut literal.clone(), path, data, root, sender),
-        Expr::IdentExpr(var, ..) => Ok(get_var(var.to_owned(), path, data, root, sender)?),
+        Expr::IdentExpr(var, ..) => Ok(get_var(
+            var.to_owned(),
+            condition,
+            path,
+            data,
+            root,
+            sender,
+        )?),
         e => Err(gen_error_info(
             Position::new(interval_from_expr(e)),
             ERROR_EXPR_TO_LITERAL.to_owned(),
@@ -163,7 +171,7 @@ pub fn resolve_fn_args(
                         };
                         named_args = true;
 
-                        let literal = expr_to_literal(var, None, data, root, sender)?;
+                        let literal = expr_to_literal(var, false, None, data, root, sender)?;
                         map.insert(name.ident.to_owned(), literal);
                     }
                     expr => {
@@ -174,7 +182,7 @@ pub fn resolve_fn_args(
                                 ERROR_EXPR_TO_LITERAL.to_owned(), // TODO: error mix of named args and anonymous args
                             ));
                         }
-                        let literal = expr_to_literal(expr, None, data, root, sender)?;
+                        let literal = expr_to_literal(expr, false, None, data, root, sender)?;
                         map.insert(format!("arg{}", index), literal);
                     }
                 }

diff --git a/csml_interpreter/src/parser/parse_string.rs b/csml_interpreter/src/parser/parse_string.rs
@@ -215,7 +215,7 @@ pub fn interpolate_string(
                     ERROR_PARSING.to_owned(),
                 ))
             } else {
-                expr_to_literal(&expr, None, data, root, sender)
+                expr_to_literal(&expr, false, None, data, root, sender)
             }
         }
         Err(e) => match e {