pseudo_interpreter/evaluator/functions/
eval_array.rs

1use crate::{
2    constants::error_handler::PseudoError,
3    evaluator::{EvalExpression, EvalResult},
4};
5
6use super::{
7    super::{Evaluator, Statement},
8    eval_statement::destruct_multi,
9};
10pub trait EvalArray {
11    fn eval_array(&mut self, statement: &Statement) -> Result<(), PseudoError>;
12}
13
14impl EvalArray for Evaluator {
15    fn eval_array(&mut self, statement: &Statement) -> Result<(), PseudoError> {
16        match statement {
17            Statement::AssignArray(var, _, values) => Ok({
18                let values = destruct_multi(values)?;
19                let mut arr_values = Vec::new();
20                for value in values.iter() {
21                    arr_values.push(self.evaluate_expr(value)?)
22                }
23                self.array_table.insert(var.clone(), arr_values);
24            }),
25            Statement::DeclareArray(var, size) => {
26                let size = self.evaluate_expr(size)?;
27                if let EvalResult::Number(size) = size {
28                    self.array_table
29                        .insert(var.clone(), vec![EvalResult::Null; size as usize]);
30                    Ok(())
31                } else {
32                    return Err(PseudoError::AssignmentError(
33                        "Invalid array size".to_string(),
34                    ));
35                }
36            }
37            Statement::AssignIndex(var, index, value) => {
38                let index = self.evaluate_expr(index)?;
39                let value = self.evaluate_expr(value)?;
40                if let Some(arr) = self.array_table.get_mut(var) {
41                    if let EvalResult::Number(index) = index {
42                        arr[index as usize] = value;
43                        Ok(())
44                    } else {
45                        return Err(PseudoError::ValueError("Invalid index".to_string()));
46                    }
47                } else {
48                    return Err(PseudoError::VariableError(format!(
49                        "undefined array: {}",
50                        var
51                    )));
52                }
53            }
54            _ => {
55                return Err(PseudoError::StatementError(
56                    "Invalid array statement".to_string(),
57                ))
58            }
59        }
60    }
61}