1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use super::Val;
use crate::error;
use crate::lang::Error;
use std::collections::HashMap;
use std::convert::TryFrom;

type Result<T> = std::result::Result<T, Error>;

/// ## Variable memory

#[derive(Debug, Default)]
pub struct Var {
    vars: HashMap<String, Val>,
}

impl Var {
    pub fn new() -> Var {
        Var::default()
    }

    pub fn clear(&mut self) {
        self.vars.clear()
    }

    pub fn is_string(var_name: &str) -> bool {
        var_name.ends_with('$')
    }

    pub fn remove(&mut self, var_name: &str) -> Option<Val> {
        self.vars.remove(var_name)
    }

    pub fn fetch(&self, var_name: &str) -> Val {
        match self.vars.get(var_name) {
            Some(val) => val.clone(),
            None => {
                if var_name.ends_with('$') {
                    Val::String("".to_string())
                } else if var_name.ends_with('!') {
                    Val::Single(0.0)
                } else if var_name.ends_with('#') {
                    Val::Double(0.0)
                } else if var_name.ends_with('%') {
                    Val::Integer(0)
                } else {
                    Val::Single(0.0)
                }
            }
        }
    }

    pub fn store(&mut self, var_name: &str, value: Val) -> Result<()> {
        if self.vars.len() > u16::max_value() as usize {
            return Err(error!(OutOfMemory));
        }
        if var_name.ends_with('$') {
            self.insert_string(var_name, value)
        } else if var_name.ends_with('!') {
            self.insert_single(var_name, value)
        } else if var_name.ends_with('#') {
            self.insert_double(var_name, value)
        } else if var_name.ends_with('%') {
            self.insert_integer(var_name, value)
        } else {
            self.insert_single(var_name, value)
        }
    }

    fn insert_val(&mut self, var_name: &str, value: Val) {
        match self.vars.get_mut(var_name) {
            Some(var) => *var = value,
            None => {
                self.vars.insert(var_name.to_string(), value);
            }
        };
    }

    fn insert_string(&mut self, var_name: &str, value: Val) -> Result<()> {
        match &value {
            Val::String(s) => {
                if s.chars().count() > 255 {
                    return Err(error!(OutOfStringSpace; "MAXIMUM STRING LENGTH IS 255"));
                }
                self.insert_val(var_name, value);
                Ok(())
            }
            _ => Err(error!(TypeMismatch)),
        }
    }

    fn insert_integer(&mut self, var_name: &str, value: Val) -> Result<()> {
        match value {
            Val::Integer(_) => self.insert_val(var_name, value),
            _ => self.insert_val(var_name, Val::Integer(i16::try_from(value)?)),
        }
        Ok(())
    }

    fn insert_single(&mut self, var_name: &str, value: Val) -> Result<()> {
        match value {
            Val::Single(_) => self.insert_val(var_name, value),
            _ => self.insert_val(var_name, Val::Single(f32::try_from(value)?)),
        }
        Ok(())
    }

    fn insert_double(&mut self, var_name: &str, value: Val) -> Result<()> {
        match value {
            Val::Double(_) => self.insert_val(var_name, value),
            _ => self.insert_val(var_name, Val::Double(f64::try_from(value)?)),
        }
        Ok(())
    }
}