basic/mach/
var.rs

1use super::{Stack, Val};
2use crate::error;
3use crate::lang::Error;
4use std::collections::HashMap;
5use std::convert::TryFrom;
6use std::rc::Rc;
7
8type Result<T> = std::result::Result<T, Error>;
9
10/// ## Variable memory
11
12#[derive(Debug, Default)]
13pub struct Var {
14    vars: HashMap<Rc<str>, Val>,
15    dims: HashMap<Rc<str>, Vec<i16>>,
16    types: [VarType; 26],
17}
18
19#[derive(Debug, Clone, PartialEq)]
20enum VarType {
21    Integer,
22    Single,
23    Double,
24    String,
25}
26
27impl Default for VarType {
28    fn default() -> Self {
29        VarType::Single
30    }
31}
32
33impl Var {
34    pub fn new() -> Var {
35        Var::default()
36    }
37
38    pub fn clear(&mut self) {
39        self.vars.clear();
40        self.dims.clear();
41        self.types = Default::default();
42    }
43
44    pub fn defint(&mut self, from: Val, to: Val) -> Result<()> {
45        self.def(VarType::Integer, from, to)
46    }
47
48    pub fn defsng(&mut self, from: Val, to: Val) -> Result<()> {
49        self.def(VarType::Single, from, to)
50    }
51
52    pub fn defdbl(&mut self, from: Val, to: Val) -> Result<()> {
53        self.def(VarType::Double, from, to)
54    }
55
56    pub fn defstr(&mut self, from: Val, to: Val) -> Result<()> {
57        self.def(VarType::String, from, to)
58    }
59
60    fn def(&mut self, var_type: VarType, from: Val, to: Val) -> Result<()> {
61        let from = Rc::<str>::try_from(from)?;
62        let to = Rc::<str>::try_from(to)?;
63        if let Some(from) = from.chars().next() {
64            if let Some(to) = to.chars().next() {
65                for idx in (from as usize - 'A' as usize)..=(to as usize - 'A' as usize) {
66                    self.types[idx] = var_type.clone();
67                }
68                self.vars.retain(|k, v| {
69                    if !k.chars().last().unwrap_or('-').is_ascii_alphabetic() {
70                        true
71                    } else {
72                        match v {
73                            Val::Integer(_) => var_type == VarType::Integer,
74                            Val::Single(_) => var_type == VarType::Single,
75                            Val::Double(_) => var_type == VarType::Double,
76                            Val::String(_) => var_type == VarType::String,
77                            Val::Next(_) | Val::Return(_) => {
78                                debug_assert!(false);
79                                true
80                            }
81                        }
82                    }
83                });
84                return Ok(());
85            }
86        }
87        Err(error!(IllegalFunctionCall))
88    }
89
90    pub fn fetch(&self, var_name: &Rc<str>) -> Val {
91        match self.vars.get(var_name) {
92            Some(val) => val.clone(),
93            None => {
94                if var_name.ends_with('$') {
95                    Val::String("".into())
96                } else if var_name.ends_with('!') {
97                    Val::Single(0.0)
98                } else if var_name.ends_with('#') {
99                    Val::Double(0.0)
100                } else if var_name.ends_with('%') {
101                    Val::Integer(0)
102                } else {
103                    use VarType::*;
104                    if let Some(idx) = var_name.chars().next() {
105                        debug_assert!(idx >= 'A' && idx <= 'Z');
106                        match self.types[idx as usize - 'A' as usize] {
107                            Integer => Val::Integer(0),
108                            Single => Val::Single(0.0),
109                            Double => Val::Double(0.0),
110                            String => Val::String("".into()),
111                        }
112                    } else {
113                        debug_assert!(false);
114                        Val::Single(0.0)
115                    }
116                }
117            }
118        }
119    }
120
121    pub fn store_array(&mut self, var_name: &Rc<str>, arr: Stack<Val>, value: Val) -> Result<()> {
122        let key = self.build_array_key(var_name, arr)?;
123        self.store(&key, value)
124    }
125
126    pub fn fetch_array(&mut self, var_name: &Rc<str>, arr: Stack<Val>) -> Result<Val> {
127        let key = self.build_array_key(var_name, arr)?;
128        Ok(self.fetch(&key))
129    }
130
131    pub fn erase_array(&mut self, var_name: &Rc<str>) -> Result<()> {
132        if self.dims.remove(var_name).is_none() {
133            return Err(error!(IllegalFunctionCall; "ARRAY NOT DIMENSIONED"));
134        }
135        let mut pattern = var_name.to_string();
136        pattern.push(',');
137        self.vars.retain(|k, _| !k.starts_with(&pattern));
138        Ok(())
139    }
140
141    pub fn dimension_array(&mut self, var_name: &Rc<str>, arr: Stack<Val>) -> Result<()> {
142        if self.dims.contains_key(var_name) {
143            return Err(error!(RedimensionedArray));
144        }
145        let vi = self.vec_val_to_vec_i16(arr)?;
146        self.dims.insert(var_name.clone(), vi);
147        Ok(())
148    }
149
150    fn build_array_key(&mut self, var_name: &Rc<str>, arr: Stack<Val>) -> Result<Rc<str>> {
151        let requested = self.vec_val_to_vec_i16(arr)?;
152        let dimensioned = match self.dims.get(var_name) {
153            Some(vec_num) => vec_num,
154            None => self
155                .dims
156                .entry(var_name.clone())
157                .or_insert_with(|| vec![10; requested.len()]),
158        };
159        if dimensioned.len() != requested.len() {
160            return Err(error!(SubscriptOutOfRange));
161        }
162        for (r, d) in requested.iter().zip(dimensioned) {
163            if r > d {
164                return Err(error!(SubscriptOutOfRange));
165            }
166        }
167        let mut s: String = format!("{}", var_name);
168        s.push_str(
169            &requested
170                .iter()
171                .map(|r| format!(",{}", r))
172                .collect::<String>(),
173        );
174        s.push_str(&format!(",{}", var_name));
175        Ok(s.into())
176    }
177
178    fn vec_val_to_vec_i16(&self, mut arr: Stack<Val>) -> Result<Vec<i16>> {
179        let mut vec_i16: Vec<i16> = vec![];
180        for val in arr.drain(..) {
181            match i16::try_from(val) {
182                Ok(num) => {
183                    if num < 0 {
184                        return Err(error!(SubscriptOutOfRange));
185                    }
186                    vec_i16.push(num)
187                }
188                Err(e) => return Err(e),
189            }
190        }
191        Ok(vec_i16)
192    }
193
194    pub fn store(&mut self, var_name: &Rc<str>, value: Val) -> Result<()> {
195        if self.vars.len() > u16::max_value() as usize {
196            return Err(error!(OutOfMemory));
197        }
198        if var_name.ends_with('!') {
199            self.insert_single(var_name, value)
200        } else if var_name.ends_with('#') {
201            self.insert_double(var_name, value)
202        } else if var_name.ends_with('%') {
203            self.insert_integer(var_name, value)
204        } else if var_name.ends_with('$') {
205            self.insert_string(var_name, value)
206        } else if let Some(idx) = var_name.chars().next() {
207            debug_assert!(idx >= 'A' && idx <= 'Z');
208            use VarType::*;
209            match self.types[idx as usize - 'A' as usize] {
210                Integer => self.insert_integer(var_name, value),
211                Single => self.insert_single(var_name, value),
212                Double => self.insert_double(var_name, value),
213                String => self.insert_string(var_name, value),
214            }
215        } else {
216            debug_assert!(false);
217            Err(error!(InternalError))
218        }
219    }
220
221    fn update_val(&mut self, var_name: &Rc<str>, value: Val) {
222        if match &value {
223            Val::String(s) => s.is_empty(),
224            Val::Integer(n) => *n == 0,
225            Val::Single(n) => *n == 0.0,
226            Val::Double(n) => *n == 0.0,
227            Val::Return(_) | Val::Next(_) => false,
228        } {
229            self.vars.remove(var_name);
230        } else {
231            match self.vars.get_mut(var_name) {
232                Some(var) => *var = value,
233                None => {
234                    self.vars.insert(var_name.clone(), value);
235                }
236            };
237        }
238    }
239
240    fn insert_string(&mut self, var_name: &Rc<str>, value: Val) -> Result<()> {
241        match &value {
242            Val::String(s) => {
243                if s.chars().count() > 255 {
244                    return Err(error!(StringTooLong; "MAXIMUM STRING LENGTH IS 255"));
245                }
246                self.update_val(var_name, value);
247                Ok(())
248            }
249            _ => Err(error!(TypeMismatch)),
250        }
251    }
252
253    fn insert_integer(&mut self, var_name: &Rc<str>, value: Val) -> Result<()> {
254        match value {
255            Val::Integer(_) => self.update_val(var_name, value),
256            _ => self.update_val(var_name, Val::Integer(i16::try_from(value)?)),
257        }
258        Ok(())
259    }
260
261    fn insert_single(&mut self, var_name: &Rc<str>, value: Val) -> Result<()> {
262        match value {
263            Val::Single(_) => self.update_val(var_name, value),
264            _ => self.update_val(var_name, Val::Single(f32::try_from(value)?)),
265        }
266        Ok(())
267    }
268
269    fn insert_double(&mut self, var_name: &Rc<str>, value: Val) -> Result<()> {
270        match value {
271            Val::Double(_) => self.update_val(var_name, value),
272            _ => self.update_val(var_name, Val::Double(f64::try_from(value)?)),
273        }
274        Ok(())
275    }
276}
basic/mach/var.rs

basic/mach/
var.rs
