garnish_lang_simple_data/
runtime.rs

1use std::convert::TryInto;
2use std::fmt::Debug;
3use std::hash::Hash;
4
5use garnish_lang_traits::{GarnishData, GarnishNumber};
6
7use crate::data::{NumberIterator, SimpleNumber, SizeIterator, parse_byte_list, parse_char_list, parse_simple_number};
8use crate::{
9    DataError, DataIndexIterator, GarnishDataType, Instruction, SimpleData, SimpleGarnishData, SimpleInstruction, SimpleStackFrame, symbol_value,
10};
11
12impl<T> GarnishData for SimpleGarnishData<T>
13where
14    T: Clone + PartialEq + Eq + PartialOrd + Debug + Hash,
15{
16    type Error = DataError;
17    type Symbol = u64;
18    type Byte = u8;
19    type Char = char;
20    type Number = SimpleNumber;
21    type Size = usize;
22    type SizeIterator = SizeIterator;
23    type NumberIterator = NumberIterator;
24    type InstructionIterator = SizeIterator;
25    type DataIndexIterator = SizeIterator;
26    type ValueIndexIterator = SizeIterator;
27    type RegisterIndexIterator = SizeIterator;
28    type JumpTableIndexIterator = SizeIterator;
29    type JumpPathIndexIterator = SizeIterator;
30    type ListIndexIterator = NumberIterator;
31    type ListItemIterator = DataIndexIterator;
32    type ConcatenationItemIterator = DataIndexIterator;
33
34    fn get_data_len(&self) -> usize {
35        self.data.len()
36    }
37
38    fn get_data_iter(&self) -> SizeIterator {
39        SizeIterator::new(0, self.data.len())
40    }
41
42    fn get_value_stack_len(&self) -> usize {
43        self.values.len()
44    }
45
46    fn push_value_stack(&mut self, addr: usize) -> Result<(), Self::Error> {
47        self.values.push(addr);
48        Ok(())
49    }
50
51    fn pop_value_stack(&mut self) -> Option<usize> {
52        self.values.pop()
53    }
54
55    fn get_value(&self, index: usize) -> Option<usize> {
56        self.values.get(index).cloned()
57    }
58
59    fn get_value_mut(&mut self, index: usize) -> Option<&mut usize> {
60        self.values.get_mut(index)
61    }
62
63    fn get_current_value(&self) -> Option<usize> {
64        self.values.last().cloned()
65    }
66
67    fn get_current_value_mut(&mut self) -> Option<&mut usize> {
68        self.values.last_mut()
69    }
70
71    fn get_value_iter(&self) -> Self::ValueIndexIterator {
72        SizeIterator::new(0, self.values.len())
73    }
74
75    fn get_data_type(&self, index: usize) -> Result<GarnishDataType, Self::Error> {
76        let d = self.get(index)?;
77
78        Ok(d.get_data_type())
79    }
80
81    fn get_number(&self, index: usize) -> Result<SimpleNumber, Self::Error> {
82        self.get(index)?.as_number()
83    }
84
85    fn get_type(&self, addr: Self::Size) -> Result<GarnishDataType, Self::Error> {
86        self.get(addr)?.as_type()
87    }
88
89    fn get_char(&self, index: Self::Size) -> Result<Self::Char, Self::Error> {
90        self.get(index)?.as_char()
91    }
92
93    fn get_byte(&self, addr: Self::Size) -> Result<Self::Byte, Self::Error> {
94        self.get(addr)?.as_byte()
95    }
96
97    fn get_symbol(&self, index: usize) -> Result<u64, Self::Error> {
98        self.get(index)?.as_symbol()
99    }
100
101    fn get_expression(&self, index: usize) -> Result<usize, Self::Error> {
102        self.get(index)?.as_expression()
103    }
104
105    fn get_external(&self, index: usize) -> Result<usize, Self::Error> {
106        self.get(index)?.as_external()
107    }
108
109    fn get_pair(&self, index: usize) -> Result<(usize, usize), Self::Error> {
110        self.get(index)?.as_pair()
111    }
112
113    fn get_concatenation(&self, index: usize) -> Result<(usize, usize), Self::Error> {
114        self.get(index)?.as_concatenation()
115    }
116
117    fn get_range(&self, addr: Self::Size) -> Result<(Self::Size, Self::Size), Self::Error> {
118        self.get(addr)?.as_range()
119    }
120
121    fn get_slice(&self, addr: Self::Size) -> Result<(Self::Size, Self::Size), Self::Error> {
122        self.get(addr)?.as_slice()
123    }
124
125    fn get_list_len(&self, index: usize) -> Result<usize, Self::Error> {
126        Ok(self.get(index)?.as_list()?.0.len())
127    }
128
129    fn get_list_item(&self, list_index: usize, item_index: SimpleNumber) -> Result<usize, Self::Error> {
130        match item_index {
131            SimpleNumber::Integer(item_index) => match self.get(list_index)?.as_list()?.0.get(item_index as usize) {
132                None => Err(format!("No list item at index {:?} for list at addr {:?}", item_index, list_index))?,
133                Some(v) => Ok(*v),
134            },
135            SimpleNumber::Float(_) => Err(DataError::from("Cannot index list with decimal value.".to_string())), // should return None
136        }
137    }
138
139    fn get_list_associations_len(&self, index: usize) -> Result<usize, Self::Error> {
140        Ok(self.get(index)?.as_list()?.1.len())
141    }
142
143    fn get_list_association(&self, list_index: usize, item_index: SimpleNumber) -> Result<usize, Self::Error> {
144        match item_index {
145            SimpleNumber::Integer(item_index) => match self.get(list_index)?.as_list()?.1.get(item_index as usize) {
146                None => Err(format!("No list item at index {:?} for list at addr {:?}", item_index, list_index))?,
147                Some(v) => Ok(*v),
148            },
149            SimpleNumber::Float(_) => Err(DataError::from("Cannot index list with decimal value.".to_string())), // should return None
150        }
151    }
152
153    fn get_list_item_with_symbol(&self, list_addr: usize, sym: u64) -> Result<Option<usize>, Self::Error> {
154        let associations_len = self.get_list_associations_len(list_addr)?;
155
156        if associations_len == 0 {
157            return Ok(None);
158        }
159
160        let mut i = sym as usize % associations_len;
161        let mut count = 0;
162
163        loop {
164            // check to make sure item has same symbol
165            let association_ref = self.get_list_association(list_addr, i.into())?;
166
167            // should have symbol on left
168            match self.get_data_type(association_ref)? {
169                GarnishDataType::Pair => {
170                    let (left, right) = self.get_pair(association_ref)?;
171
172                    let left_ref = left;
173
174                    match self.get_data_type(left_ref)? {
175                        GarnishDataType::Symbol => {
176                            let v = self.get_symbol(left_ref)?;
177
178                            if v == sym {
179                                // found match
180                                // insert pair right as value
181                                return Ok(Some(right));
182                            }
183                        }
184                        t => Err(format!("Association created with non-symbol type {:?} on pair left.", t))?,
185                    }
186                }
187                t => Err(format!("Association created with non-pair type {:?}.", t))?,
188            }
189
190            i += 1;
191            if i >= associations_len {
192                i = 0;
193            }
194
195            count += 1;
196            if count > associations_len {
197                return Ok(None);
198            }
199        }
200    }
201
202    fn get_list_items_iter(&self, list_addr: Self::Size) -> Self::ListIndexIterator {
203        self.get_list_len(list_addr)
204            .and_then(|len| Ok(NumberIterator::new(SimpleNumber::Integer(0), Self::size_to_number(len))))
205            .unwrap_or(NumberIterator::new(SimpleNumber::Integer(0), SimpleNumber::Integer(0)))
206    }
207
208    fn get_list_associations_iter(&self, list_addr: Self::Size) -> Self::ListIndexIterator {
209        self.get_list_associations_len(list_addr)
210            .and_then(|len| Ok(NumberIterator::new(SimpleNumber::Integer(0), Self::size_to_number(len))))
211            .unwrap_or(NumberIterator::new(SimpleNumber::Integer(0), SimpleNumber::Integer(0)))
212    }
213
214    fn get_char_list_len(&self, addr: Self::Size) -> Result<Self::Size, Self::Error> {
215        Ok(self.get(addr)?.as_char_list()?.len())
216    }
217
218    fn get_char_list_item(&self, addr: Self::Size, item_index: Self::Number) -> Result<Self::Char, Self::Error> {
219        match item_index {
220            SimpleNumber::Integer(item_index) => match self.get(addr)?.as_char_list()?.chars().nth(item_index as usize) {
221                None => Err(format!("No value at index {:?} for char list at {:?}", item_index, addr))?,
222                Some(c) => Ok(c),
223            },
224            SimpleNumber::Float(_) => Err(DataError::from("Cannot index char list with decimal value.".to_string())), // should return None
225        }
226    }
227
228    fn get_char_list_iter(&self, list_addr: Self::Size) -> Self::ListIndexIterator {
229        self.get_char_list_len(list_addr)
230            .and_then(|len| Ok(NumberIterator::new(SimpleNumber::Integer(0), Self::size_to_number(len))))
231            .unwrap_or(NumberIterator::new(SimpleNumber::Integer(0), SimpleNumber::Integer(0)))
232    }
233
234    fn get_byte_list_len(&self, addr: Self::Size) -> Result<Self::Size, Self::Error> {
235        Ok(self.get(addr)?.as_byte_list()?.len())
236    }
237
238    fn get_byte_list_item(&self, addr: Self::Size, item_index: Self::Number) -> Result<Self::Byte, Self::Error> {
239        match item_index {
240            SimpleNumber::Integer(item_index) => match self.get(addr)?.as_byte_list()?.get(item_index as usize) {
241                None => Err(format!("No value at index {:?} for byte list at {:?}", item_index, addr))?,
242                Some(c) => Ok(*c),
243            },
244            SimpleNumber::Float(_) => Err(DataError::from("Cannot index byte list with decimal value.".to_string())), // should return None
245        }
246    }
247
248    fn get_byte_list_iter(&self, list_addr: Self::Size) -> Self::ListIndexIterator {
249        self.get_byte_list_len(list_addr)
250            .and_then(|len| Ok(NumberIterator::new(SimpleNumber::Integer(0), Self::size_to_number(len))))
251            .unwrap_or(NumberIterator::new(SimpleNumber::Integer(0), SimpleNumber::Integer(0)))
252    }
253
254    fn get_symbol_list_len(&self, addr: Self::Size) -> Result<Self::Size, Self::Error> {
255        Ok(self.get(addr)?.as_symbol_list()?.len())
256    }
257
258    fn get_symbol_list_item(&self, addr: Self::Size, item_index: Self::Number) -> Result<Self::Symbol, Self::Error> {
259        match item_index {
260            SimpleNumber::Integer(item_index) => match self.get(addr)?.as_symbol_list()?.get(item_index as usize) {
261                None => Err(format!("No value at index {:?} for symbol list at {:?}", item_index, addr))?,
262                Some(c) => Ok(*c),
263            },
264            SimpleNumber::Float(_) => Err(DataError::from("Cannot index symbol list with decimal value.".to_string())), // should return None
265        }
266    }
267
268    fn get_symbol_list_iter(&self, list_addr: Self::Size) -> Self::ListIndexIterator {
269        self.get_symbol_list_len(list_addr)
270            .and_then(|len| Ok(NumberIterator::new(SimpleNumber::Integer(0), Self::size_to_number(len))))
271            .unwrap_or(NumberIterator::new(SimpleNumber::Integer(0), SimpleNumber::Integer(0)))
272    }
273
274    fn get_list_item_iter(&self, list_addr: Self::Size) -> Self::ListItemIterator {
275        match self.get_data().get(list_addr) {
276            Some(SimpleData::List(items, _)) => DataIndexIterator::new(items.clone()),
277            _ => DataIndexIterator::new(vec![]),
278        }
279    }
280
281    fn get_concatenation_iter(&self, addr: Self::Size) -> Self::ConcatenationItemIterator {
282        match self.get_data().get(addr) {
283            Some(SimpleData::Concatenation(left, right)) => DataIndexIterator::new(self.collect_concatenation_indices(*left, *right)),
284            _ => DataIndexIterator::new(vec![]),
285        }
286    }
287
288    fn get_slice_iter(&self, addr: Self::Size) -> Self::ListIndexIterator {
289        match self.get_data().get(addr) {
290            Some(SimpleData::Slice(_, range)) => match self.get_data().get(*range) {
291                Some(SimpleData::Range(start, end)) => match (self.get_data().get(*start), self.get_data().get(*end)) {
292                    (Some(SimpleData::Number(start)), Some(SimpleData::Number(end))) => end
293                        .clone()
294                        .plus(SimpleNumber::Integer(1))
295                        .and_then(|end| Some(NumberIterator::new(start.clone(), end)))
296                        .unwrap_or(NumberIterator::new(0.into(), 0.into())),
297                    _ => NumberIterator::new(0.into(), 0.into()),
298                },
299                _ => NumberIterator::new(0.into(), 0.into()),
300            },
301            _ => NumberIterator::new(0.into(), 0.into()),
302        }
303    }
304
305    fn get_list_slice_item_iter(&self, list_addr: Self::Size) -> Self::ListItemIterator {
306        match self.get_data().get(list_addr) {
307            Some(SimpleData::Slice(list, range)) => match (self.get_data().get(*list), self.get_data().get(*range)) {
308                (Some(SimpleData::List(items, _)), Some(SimpleData::Range(start, end))) => {
309                    match (self.get_data().get(*start), self.get_data().get(*end)) {
310                        (Some(SimpleData::Number(SimpleNumber::Integer(start))), Some(SimpleData::Number(SimpleNumber::Integer(end)))) => {
311                            DataIndexIterator::new(
312                                items
313                                    .iter()
314                                    .skip(*start as usize)
315                                    .take((end - start) as usize + 1)
316                                    .map(usize::clone)
317                                    .collect::<Vec<_>>(),
318                            )
319                        }
320                        _ => DataIndexIterator::new(vec![]),
321                    }
322                }
323                _ => DataIndexIterator::new(vec![]),
324            },
325            _ => DataIndexIterator::new(vec![]),
326        }
327    }
328
329    fn get_concatenation_slice_iter(&self, addr: Self::Size) -> Self::ConcatenationItemIterator {
330        match self.get_data().get(addr) {
331            Some(SimpleData::Slice(list, range)) => match (self.get_data().get(*list), self.get_data().get(*range)) {
332                (Some(SimpleData::Concatenation(left, right)), Some(SimpleData::Range(start, end))) => {
333                    match (self.get_data().get(*start), self.get_data().get(*end)) {
334                        (Some(SimpleData::Number(SimpleNumber::Integer(start))), Some(SimpleData::Number(SimpleNumber::Integer(end)))) => {
335                            DataIndexIterator::new(
336                                self.collect_concatenation_indices(*left, *right)
337                                    .iter()
338                                    .skip(*start as usize)
339                                    .take((end - start) as usize + 1)
340                                    .map(usize::clone)
341                                    .collect::<Vec<_>>(),
342                            )
343                        }
344                        _ => DataIndexIterator::new(vec![]),
345                    }
346                }
347                _ => DataIndexIterator::new(vec![]),
348            },
349            _ => DataIndexIterator::new(vec![]),
350        }
351    }
352
353    fn add_unit(&mut self) -> Result<usize, Self::Error> {
354        Ok(0)
355    }
356
357    fn add_true(&mut self) -> Result<usize, Self::Error> {
358        Ok(2)
359    }
360
361    fn add_false(&mut self) -> Result<usize, Self::Error> {
362        Ok(1)
363    }
364
365    fn add_number(&mut self, value: SimpleNumber) -> Result<usize, Self::Error> {
366        self.cache_add(SimpleData::Number(value))
367    }
368
369    fn add_type(&mut self, value: GarnishDataType) -> Result<Self::Size, Self::Error> {
370        self.cache_add(SimpleData::Type(value))
371    }
372
373    fn add_char(&mut self, value: Self::Char) -> Result<Self::Size, Self::Error> {
374        self.cache_add(SimpleData::Char(value))
375    }
376
377    fn add_byte(&mut self, value: Self::Byte) -> Result<Self::Size, Self::Error> {
378        self.cache_add(SimpleData::Byte(value))
379    }
380
381    fn add_symbol(&mut self, value: u64) -> Result<usize, Self::Error> {
382        self.cache_add(SimpleData::Symbol(value))
383    }
384
385    fn add_expression(&mut self, value: usize) -> Result<usize, Self::Error> {
386        self.cache_add(SimpleData::Expression(value))
387    }
388
389    fn add_external(&mut self, value: usize) -> Result<usize, Self::Error> {
390        self.cache_add(SimpleData::External(value))
391    }
392
393    fn add_pair(&mut self, value: (usize, usize)) -> Result<usize, Self::Error> {
394        self.data.push(SimpleData::Pair(value.0, value.1));
395        Ok(self.data.len() - 1)
396    }
397
398    fn add_concatenation(&mut self, left: Self::Size, right: Self::Size) -> Result<Self::Size, Self::Error> {
399        self.data.push(SimpleData::Concatenation(left, right));
400        Ok(self.data.len() - 1)
401    }
402
403    fn add_range(&mut self, start: Self::Size, end: Self::Size) -> Result<Self::Size, Self::Error> {
404        self.data.push(SimpleData::Range(start, end));
405        Ok(self.data.len() - 1)
406    }
407
408    fn add_slice(&mut self, list: Self::Size, range: Self::Size) -> Result<Self::Size, Self::Error> {
409        self.data.push(SimpleData::Slice(list, range));
410        Ok(self.data.len() - 1)
411    }
412
413    fn merge_to_symbol_list(&mut self, first: Self::Size, second: Self::Size) -> Result<Self::Size, Self::Error> {
414        match (self.get_data().get(first), self.get_data().get(second)) {
415            (Some(SimpleData::Symbol(sym1)), Some(SimpleData::Symbol(sym2))) => {
416                self.data.push(SimpleData::SymbolList(vec![*sym1, *sym2]));
417            }
418            (Some(SimpleData::SymbolList(list1)), Some(SimpleData::SymbolList(list2))) => {
419                self.data.push(SimpleData::SymbolList(list1.iter().chain(list2).map(|i| *i).collect()));
420            }
421            (Some(SimpleData::SymbolList(list)), Some(SimpleData::Symbol(sym))) => {
422                let mut new_list = list.clone();
423                new_list.push(*sym);
424                self.data.push(SimpleData::SymbolList(new_list));
425            }
426            (Some(SimpleData::Symbol(sym)), Some(SimpleData::SymbolList(list))) => {
427                let mut new_list = list.clone();
428                new_list.insert(0, *sym);
429                self.data.push(SimpleData::SymbolList(new_list));
430            }
431            (Some(t1), Some(t2)) => Err(format!("Cannot create symbol list from types: {:?} {:?}", t1, t2))?,
432            (None, None) => Err(format!(
433                "Failed to create symbol list. No data at either operand indices, {}, {}",
434                first, second
435            ))?,
436            (None, _) => Err(format!("Failed to create symbol list. No data at left operand index, {}", first))?,
437            (_, None) => Err(format!("Failed to create symbol list. No data at right operand index, {}", second))?,
438        }
439
440        Ok(self.data.len() - 1)
441    }
442
443    fn start_list(&mut self, _: usize) -> Result<(), Self::Error> {
444        self.current_list = Some((vec![], vec![]));
445        Ok(())
446    }
447
448    fn add_to_list(&mut self, addr: usize, is_associative: bool) -> Result<(), Self::Error> {
449        match &mut self.current_list {
450            None => Err("Not currently creating a list.".to_string())?,
451            Some((items, associations)) => {
452                items.push(addr);
453
454                if is_associative {
455                    associations.push(addr);
456                }
457
458                Ok(())
459            }
460        }
461    }
462
463    fn end_list(&mut self) -> Result<usize, Self::Error> {
464        match &mut self.current_list {
465            None => Err("Not currently creating a list.".to_string())?,
466            Some((items, associations)) => {
467                // reorder associative values by modulo value
468                let mut ordered = vec![0usize; associations.len()];
469                for index in 0..associations.len() {
470                    let item = associations[index];
471                    let mut i = item % associations.len();
472                    let mut count = 0;
473                    while ordered[i] != 0 {
474                        i += 1;
475                        if i >= associations.len() {
476                            i = 0;
477                        }
478
479                        count += 1;
480                        if count > associations.len() {
481                            Err("Could not place associative value".to_string())?;
482                        }
483                    }
484
485                    ordered[i] = item;
486                }
487
488                self.data.push(SimpleData::List(items.to_vec(), ordered));
489                Ok(self.data.len() - 1)
490            }
491        }
492    }
493
494    fn start_char_list(&mut self) -> Result<(), Self::Error> {
495        self.current_char_list = Some(String::new());
496        Ok(())
497    }
498
499    fn add_to_char_list(&mut self, c: Self::Char) -> Result<(), Self::Error> {
500        match &mut self.current_char_list {
501            None => Err("Attempting to add to unstarted char list.".to_string())?,
502            Some(s) => s.push(c),
503        }
504
505        Ok(())
506    }
507
508    fn end_char_list(&mut self) -> Result<Self::Size, Self::Error> {
509        let data = match &self.current_char_list {
510            None => Err("Attempting to end unstarted char list.".to_string())?,
511            Some(s) => SimpleData::CharList(s.clone()),
512        };
513
514        let addr = self.cache_add(data)?;
515
516        self.current_char_list = None;
517
518        Ok(addr)
519    }
520
521    fn start_byte_list(&mut self) -> Result<(), Self::Error> {
522        self.current_byte_list = Some(Vec::new());
523        Ok(())
524    }
525
526    fn add_to_byte_list(&mut self, c: Self::Byte) -> Result<(), Self::Error> {
527        match &mut self.current_byte_list {
528            None => Err("Attempting to add to unstarted byte list.".to_string())?,
529            Some(l) => l.push(c),
530        }
531
532        Ok(())
533    }
534
535    fn end_byte_list(&mut self) -> Result<Self::Size, Self::Error> {
536        let data = match &self.current_byte_list {
537            None => Err("Attempting to end unstarted byte list.".to_string())?,
538            Some(l) => SimpleData::ByteList(l.clone()),
539        };
540
541        let addr = self.cache_add(data)?;
542
543        self.current_byte_list = None;
544
545        Ok(addr)
546    }
547
548    fn get_register_len(&self) -> Self::Size {
549        self.register.len()
550    }
551
552    fn push_register(&mut self, addr: usize) -> Result<(), Self::Error> {
553        self.register.push(addr);
554        Ok(())
555    }
556
557    fn get_register(&self, addr: Self::Size) -> Option<Self::Size> {
558        self.register.get(addr).cloned()
559    }
560
561    fn pop_register(&mut self) -> Result<Option<Self::Size>, Self::Error> {
562        match self.register.pop() {
563            None => Ok(None),
564            Some(value) => match self.data.get(value) {
565                None => Err(format!("Register address ({}) has no data", value))?,
566                Some(data) => match data {
567                    SimpleData::StackFrame(_) => Err("Popped StackFrame from registers. Should only be done when popping jump path.".to_string())?,
568                    _ => Ok(Some(value)),
569                },
570            },
571        }
572    }
573
574    fn get_register_iter(&self) -> Self::RegisterIndexIterator {
575        SizeIterator::new(0, self.register.len())
576    }
577
578    fn get_instruction_len(&self) -> usize {
579        self.instructions.len()
580    }
581
582    fn push_instruction(&mut self, instruction: Instruction, data: Option<usize>) -> Result<usize, Self::Error> {
583        self.instructions.push(SimpleInstruction::new(instruction, data));
584        Ok(self.instructions.len() - 1)
585    }
586
587    fn get_instruction(&self, index: usize) -> Option<(Instruction, Option<usize>)> {
588        self.instructions.get(index).and_then(|i| Some((i.instruction, i.data)))
589    }
590
591    fn get_instruction_iter(&self) -> Self::InstructionIterator {
592        SizeIterator::new(0, self.instructions.len())
593    }
594
595    fn get_instruction_cursor(&self) -> usize {
596        self.instruction_cursor
597    }
598
599    fn set_instruction_cursor(&mut self, index: usize) -> Result<(), Self::Error> {
600        self.instruction_cursor = index;
601        Ok(())
602    }
603
604    fn get_jump_table_len(&self) -> usize {
605        self.expression_table.len()
606    }
607
608    fn push_jump_point(&mut self, index: usize) -> Result<(), Self::Error> {
609        self.expression_table.push(index);
610        Ok(())
611    }
612
613    fn get_jump_point(&self, index: usize) -> Option<usize> {
614        self.expression_table.get(index).cloned()
615    }
616
617    fn get_jump_point_mut(&mut self, index: usize) -> Option<&mut usize> {
618        self.expression_table.get_mut(index)
619    }
620
621    fn get_jump_table_iter(&self) -> Self::JumpTableIndexIterator {
622        SizeIterator::new(0, self.expression_table.len())
623    }
624
625    fn push_jump_path(&mut self, index: usize) -> Result<(), Self::Error> {
626        let r = self.add_stack_frame(SimpleStackFrame::new(index))?;
627        self.push_register(r)
628    }
629
630    fn pop_jump_path(&mut self) -> Option<usize> {
631        while let Some(item) = self.register.pop() {
632            match self.data.get(item) {
633                None => return None, // should probably be error
634                Some(data) => match data {
635                    SimpleData::StackFrame(frame) => return Some(frame.return_addr()),
636                    _ => (),
637                },
638            }
639        }
640
641        None
642    }
643
644    fn get_jump_path_iter(&self) -> Self::JumpPathIndexIterator {
645        unimplemented!() // not sure whether this function is needed currently unused by core
646    }
647
648    //
649    // Casting
650    //
651
652    fn size_to_number(from: Self::Size) -> Self::Number {
653        from.into()
654    }
655
656    fn number_to_size(from: Self::Number) -> Option<Self::Size> {
657        Some(from.into())
658    }
659
660    fn number_to_char(from: Self::Number) -> Option<Self::Char> {
661        match from {
662            SimpleNumber::Integer(v) => match (v as u8).try_into() {
663                Ok(c) => Some(c),
664                Err(_) => None,
665            },
666            SimpleNumber::Float(_) => None,
667        }
668    }
669
670    fn number_to_byte(from: Self::Number) -> Option<Self::Byte> {
671        match from {
672            SimpleNumber::Integer(v) => match v.try_into() {
673                Ok(b) => Some(b),
674                Err(_) => None,
675            },
676            SimpleNumber::Float(_) => None,
677        }
678    }
679
680    fn char_to_number(from: Self::Char) -> Option<Self::Number> {
681        Some((from as i32).into())
682    }
683
684    fn char_to_byte(from: Self::Char) -> Option<Self::Byte> {
685        Some(from as u8)
686    }
687
688    fn byte_to_number(from: Self::Byte) -> Option<Self::Number> {
689        Some((from as i32).into())
690    }
691
692    fn byte_to_char(from: Self::Byte) -> Option<Self::Char> {
693        Some(from.into())
694    }
695
696    //
697    // Add Conversions
698    //
699
700    fn add_char_list_from(&mut self, from: Self::Size) -> Result<Self::Size, Self::Error> {
701        self.start_char_list()?;
702        self.add_to_current_char_list(from, 0)?;
703        self.end_char_list()
704    }
705
706    fn add_byte_list_from(&mut self, from: Self::Size) -> Result<Self::Size, Self::Error> {
707        match self.get_data_type(from)? {
708            GarnishDataType::Unit => {
709                self.start_byte_list()?;
710                self.end_byte_list()
711            }
712            t => Err(DataError::from(format!("No cast to ByteList available for {:?}", t))),
713        }
714    }
715
716    fn add_symbol_from(&mut self, from: Self::Size) -> Result<Self::Size, Self::Error> {
717        let addr = self.add_char_list_from(from)?;
718        match self.data.get(addr) {
719            None => Err(DataError::from("No data after creating char list".to_string())),
720            Some(data) => match data {
721                SimpleData::CharList(s) => {
722                    let v = symbol_value(s);
723                    self.cache_add(SimpleData::Symbol(v))
724                }
725                t => Err(DataError::from(format!("Found {:?} instead of CharList after creating a CharList.", t))),
726            },
727        }
728    }
729
730    fn add_byte_from(&mut self, from: Self::Size) -> Result<Self::Size, Self::Error> {
731        match self.get_data_type(from)? {
732            GarnishDataType::CharList => {
733                let len = self.get_char_list_len(from)?;
734                let mut s = String::new();
735                for i in 0..len {
736                    let c = self.get_char_list_item(from, i.into())?;
737                    s.push(c);
738                }
739
740                match s.parse::<u8>() {
741                    Ok(v) => self.add_byte(v),
742                    Err(_) => self.add_unit(),
743                }
744            }
745            _ => self.add_unit(),
746        }
747    }
748
749    fn add_number_from(&mut self, from: Self::Size) -> Result<Self::Size, Self::Error> {
750        match self.get_data_type(from)? {
751            GarnishDataType::CharList => {
752                let len = self.get_char_list_len(from)?;
753                let mut s = String::new();
754                for i in 0..len {
755                    let c = self.get_char_list_item(from, i.into())?;
756                    s.push(c);
757                }
758
759                match s.parse::<i32>() {
760                    Ok(v) => self.add_number(v.into()),
761                    Err(_) => self.add_unit(),
762                }
763            }
764            _ => self.add_unit(),
765        }
766    }
767
768    //
769    // Parsing
770    //
771
772    fn parse_number(from: &str) -> Result<Self::Number, Self::Error> {
773        parse_simple_number(from)
774    }
775
776    fn parse_symbol(from: &str) -> Result<Self::Symbol, Self::Error> {
777        Ok(symbol_value(from.trim_matches(':')))
778    }
779
780    fn parse_char(from: &str) -> Result<Self::Char, Self::Error> {
781        let l = parse_char_list(from)?;
782        if l.len() == 1 {
783            Ok(l.chars().nth(0).unwrap())
784        } else {
785            Err(DataError::from(format!("Could not parse char from {:?}", from)))
786        }
787    }
788
789    fn parse_byte(from: &str) -> Result<Self::Byte, Self::Error> {
790        let l = parse_byte_list(from)?;
791        if l.len() == 1 {
792            Ok(l[0])
793        } else {
794            Err(DataError::from(format!("Could not parse byte from {:?}", from)))
795        }
796    }
797
798    fn parse_char_list(from: &str) -> Result<Vec<Self::Char>, Self::Error> {
799        Ok(parse_char_list(from)?.chars().collect())
800    }
801
802    fn parse_byte_list(from: &str) -> Result<Vec<Self::Byte>, Self::Error> {
803        parse_byte_list(from)
804    }
805
806    // overrides
807
808    fn parse_add_symbol(&mut self, from: &str) -> Result<Self::Size, Self::Error> {
809        let sym = Self::parse_symbol(from)?;
810        self.data.insert_symbol(sym, from.to_string());
811        self.add_symbol(sym)
812    }
813
814    // iterator factories
815
816    fn make_size_iterator_range(min: Self::Size, max: Self::Size) -> Self::SizeIterator {
817        SizeIterator::new(min, max)
818    }
819
820    fn make_number_iterator_range(min: Self::Number, max: Self::Number) -> Self::NumberIterator {
821        NumberIterator::new(min, max)
822    }
823}
824
825#[cfg(test)]
826mod tests {
827    use garnish_lang_traits::GarnishData;
828
829    use crate::{GarnishDataType, Instruction, SimpleGarnishData, SimpleNumber};
830
831    #[test]
832    fn type_of() {
833        let mut runtime = SimpleGarnishData::new();
834        runtime.add_number(10.into()).unwrap();
835
836        assert_eq!(runtime.get_data_type(3).unwrap(), GarnishDataType::Number);
837    }
838
839    #[test]
840    fn add_instruction() {
841        let mut runtime = SimpleGarnishData::new();
842
843        runtime.push_instruction(Instruction::Put, Some(0)).unwrap();
844
845        assert_eq!(runtime.get_instructions().len(), 1);
846    }
847
848    #[test]
849    fn get_instruction() {
850        let mut runtime = SimpleGarnishData::new();
851
852        runtime.push_instruction(Instruction::Put, None).unwrap();
853
854        assert_eq!(runtime.get_instruction(0).unwrap().0, Instruction::Put);
855    }
856
857    #[test]
858    fn get_current_instruction() {
859        let mut runtime = SimpleGarnishData::new();
860
861        runtime.push_instruction(Instruction::Put, None).unwrap();
862
863        runtime.set_instruction_cursor(0).unwrap();
864
865        assert_eq!(runtime.get_current_instruction().unwrap().0, Instruction::Put);
866    }
867
868    #[test]
869    fn set_instruction_cursor() {
870        let mut runtime = SimpleGarnishData::new();
871
872        runtime.push_instruction(Instruction::Put, None).unwrap();
873        runtime.push_instruction(Instruction::Put, None).unwrap();
874        runtime.push_instruction(Instruction::Add, None).unwrap();
875
876        runtime.set_instruction_cursor(2).unwrap();
877
878        assert_eq!(runtime.get_current_instruction().unwrap().0, Instruction::Add);
879    }
880
881    #[test]
882    fn pop_jump_path_clears_registers_to_current_frame() {
883        let mut data = SimpleGarnishData::new();
884
885        let data_addr = data.add_number(SimpleNumber::Integer(10)).unwrap(); // 3
886
887        data.push_register(data_addr).unwrap();
888        data.push_register(data_addr).unwrap();
889        data.push_jump_path(10).unwrap();
890        data.push_register(data_addr).unwrap();
891        data.push_register(data_addr).unwrap();
892        data.push_register(data_addr).unwrap();
893        data.push_jump_path(20).unwrap();
894        data.push_register(data_addr).unwrap();
895        data.push_register(data_addr).unwrap();
896
897        assert_eq!(data.register.len(), 9);
898
899        let r = data.pop_jump_path();
900        assert_eq!(r, Some(20));
901        assert_eq!(data.register.len(), 6);
902
903        let r = data.pop_jump_path();
904        assert_eq!(r, Some(10));
905        assert_eq!(data.register.len(), 2);
906
907        let r = data.pop_jump_path();
908        assert_eq!(r, None);
909
910        assert_eq!(data.register.len(), 0);
911    }
912
913    #[test]
914    fn pop_register_of_stack_frame_gives_error() {
915        let mut data = SimpleGarnishData::new();
916
917        let data_addr = data.add_number(SimpleNumber::Integer(10)).unwrap(); // 3
918
919        data.push_register(data_addr).unwrap();
920        data.push_register(data_addr).unwrap();
921        data.push_jump_path(10).unwrap();
922
923        let result = data.pop_register();
924
925        assert!(result.is_err());
926    }
927}
928
929#[cfg(test)]
930mod add_data {
931    mod parsing {
932        use crate::SimpleDataRuntimeNC;
933        use garnish_lang_traits::GarnishData;
934
935        #[test]
936        fn symbols_are_stripped_of_colon() {
937            let s1 = SimpleDataRuntimeNC::parse_symbol(":my_symbol").unwrap();
938            let s2 = SimpleDataRuntimeNC::parse_symbol("my_symbol").unwrap();
939
940            assert_eq!(s1, s2);
941        }
942    }
943    mod symbol_list {
944        use crate::{SimpleDataRuntimeNC, SimpleGarnishData};
945        use garnish_lang_traits::{GarnishData, GarnishDataType};
946
947        fn s1() -> u64 {
948            SimpleDataRuntimeNC::parse_symbol("symbol_one").unwrap()
949        }
950
951        fn s2() -> u64 {
952            SimpleDataRuntimeNC::parse_symbol("symbol_two").unwrap()
953        }
954
955        fn s3() -> u64 {
956            SimpleDataRuntimeNC::parse_symbol("symbol_three").unwrap()
957        }
958
959        fn s4() -> u64 {
960            SimpleDataRuntimeNC::parse_symbol("symbol_four").unwrap()
961        }
962
963        #[test]
964        fn add_symbol_list_with_symbol_symbol() {
965            let mut runtime = SimpleGarnishData::new();
966            let sym1 = runtime.add_symbol(s1()).unwrap();
967            let sym2 = runtime.add_symbol(s2()).unwrap();
968
969            let sym_list = runtime.merge_to_symbol_list(sym1, sym2).unwrap();
970
971            assert_eq!(runtime.get_data_type(sym_list).unwrap(), GarnishDataType::SymbolList);
972            let data = runtime.get_data().get(sym_list).unwrap().as_symbol_list().unwrap();
973
974            assert_eq!(data, vec![s1(), s2()]);
975        }
976
977        #[test]
978        fn add_symbol_list_with_symbol_list_symbol() {
979            let mut runtime = SimpleGarnishData::new();
980            let sym1 = runtime.add_symbol(s1()).unwrap();
981            let sym2 = runtime.add_symbol(s2()).unwrap();
982            let sym3 = runtime.add_symbol(s3()).unwrap();
983
984            let sym_list1 = runtime.merge_to_symbol_list(sym1, sym2).unwrap();
985
986            let sym_list2 = runtime.merge_to_symbol_list(sym_list1, sym3).unwrap();
987
988            assert_eq!(runtime.get_data_type(sym_list2).unwrap(), GarnishDataType::SymbolList);
989            let data = runtime.get_data().get(sym_list2).unwrap().as_symbol_list().unwrap();
990
991            assert_eq!(data, vec![s1(), s2(), s3()]);
992        }
993
994        #[test]
995        fn add_symbol_list_with_symbol_symbol_list() {
996            let mut runtime = SimpleGarnishData::new();
997            let sym1 = runtime.add_symbol(s1()).unwrap();
998            let sym2 = runtime.add_symbol(s2()).unwrap();
999            let sym3 = runtime.add_symbol(s3()).unwrap();
1000
1001            let sym_list1 = runtime.merge_to_symbol_list(sym1, sym2).unwrap();
1002
1003            let sym_list2 = runtime.merge_to_symbol_list(sym3, sym_list1).unwrap();
1004
1005            assert_eq!(runtime.get_data_type(sym_list2).unwrap(), GarnishDataType::SymbolList);
1006            let data = runtime.get_data().get(sym_list2).unwrap().as_symbol_list().unwrap();
1007
1008            assert_eq!(data, vec![s3(), s1(), s2()]);
1009        }
1010
1011        #[test]
1012        fn add_symbol_list_with_symbol_list_symbol_list() {
1013            let mut runtime = SimpleGarnishData::new();
1014            let sym1 = runtime.add_symbol(s1()).unwrap();
1015            let sym2 = runtime.add_symbol(s2()).unwrap();
1016            let sym3 = runtime.add_symbol(s3()).unwrap();
1017            let sym4 = runtime.add_symbol(s4()).unwrap();
1018
1019            let sym_list1 = runtime.merge_to_symbol_list(sym1, sym2).unwrap();
1020
1021            let sym_list2 = runtime.merge_to_symbol_list(sym3, sym4).unwrap();
1022
1023            let sym_list3 = runtime.merge_to_symbol_list(sym_list1, sym_list2).unwrap();
1024
1025            assert_eq!(runtime.get_data_type(sym_list3).unwrap(), GarnishDataType::SymbolList);
1026            let data = runtime.get_data().get(sym_list3).unwrap().as_symbol_list().unwrap();
1027
1028            assert_eq!(data, vec![s1(), s2(), s3(), s4()]);
1029        }
1030
1031        #[test]
1032        fn add_symbol_list_with_number_symbol() {
1033            let mut runtime = SimpleGarnishData::new();
1034            let sym1 = runtime.add_number(10.into()).unwrap();
1035            let sym2 = runtime.add_symbol(s2()).unwrap();
1036
1037            let sym_list = runtime.merge_to_symbol_list(sym1, sym2);
1038
1039            assert!(sym_list.is_err());
1040        }
1041
1042        #[test]
1043        fn add_symbol_list_with_symbol_number() {
1044            let mut runtime = SimpleGarnishData::new();
1045            let sym1 = runtime.add_symbol(s1()).unwrap();
1046            let sym2 = runtime.add_number(10.into()).unwrap();
1047
1048            let sym_list = runtime.merge_to_symbol_list(sym1, sym2);
1049
1050            assert!(sym_list.is_err());
1051        }
1052
1053        #[test]
1054        fn add_symbol_list_with_number_number() {
1055            let mut runtime = SimpleGarnishData::new();
1056            let sym1 = runtime.add_number(10.into()).unwrap();
1057            let sym2 = runtime.add_number(10.into()).unwrap();
1058
1059            let sym_list = runtime.merge_to_symbol_list(sym1, sym2);
1060
1061            assert!(sym_list.is_err());
1062        }
1063
1064        #[test]
1065        fn add_symbol_list_with_invalid_first_index() {
1066            let mut runtime = SimpleGarnishData::new();
1067            let sym2 = runtime.add_number(10.into()).unwrap();
1068
1069            let sym_list = runtime.merge_to_symbol_list(100, sym2);
1070
1071            assert!(sym_list.is_err());
1072        }
1073
1074        #[test]
1075        fn add_symbol_list_with_invalid_second_index() {
1076            let mut runtime = SimpleGarnishData::new();
1077            let sym1 = runtime.add_number(10.into()).unwrap();
1078
1079            let sym_list = runtime.merge_to_symbol_list(sym1, 200);
1080
1081            assert!(sym_list.is_err());
1082        }
1083
1084        #[test]
1085        fn add_symbol_list_with_invalid_indices() {
1086            let mut runtime = SimpleGarnishData::new();
1087
1088            let sym_list = runtime.merge_to_symbol_list(100, 200);
1089
1090            assert!(sym_list.is_err());
1091        }
1092    }
1093}
1094
1095#[cfg(test)]
1096mod iterators {
1097    use crate::{SimpleData, SimpleGarnishData};
1098    use garnish_lang_traits::GarnishData;
1099
1100    #[test]
1101    fn list_item_iterator() {
1102        let mut data = SimpleGarnishData::new();
1103        let list_index = data.get_data().len();
1104        data.get_data_mut().push(SimpleData::List(vec![100, 200, 300, 400, 500], vec![]));
1105
1106        let mut iter = data.get_list_item_iter(list_index);
1107
1108        assert_eq!(iter.next(), 100.into());
1109        assert_eq!(iter.next(), 200.into());
1110        assert_eq!(iter.next(), 300.into());
1111        assert_eq!(iter.next(), 400.into());
1112        assert_eq!(iter.next(), 500.into());
1113    }
1114
1115    #[test]
1116    fn list_item_iterator_not_list() {
1117        let mut data = SimpleGarnishData::new();
1118        let num1 = data.add_number(10.into()).unwrap();
1119
1120        let mut iter = data.get_list_item_iter(num1);
1121
1122        assert_eq!(iter.next(), None);
1123    }
1124
1125    #[test]
1126    fn concatenation_item_iterator() {
1127        let mut data = SimpleGarnishData::new();
1128        let num1 = data.add_number(10.into()).unwrap();
1129        let num2 = data.add_number(10.into()).unwrap();
1130        let num3 = data.add_number(10.into()).unwrap();
1131        let list_index = data.get_data().len();
1132        data.get_data_mut().push(SimpleData::List(vec![num1, num2, num3], vec![]));
1133        let con1 = data.add_concatenation(list_index, 2).unwrap();
1134        let con2 = data.add_concatenation(con1, 1).unwrap();
1135        let con3 = data.add_concatenation(con2, 2).unwrap();
1136
1137        let mut iter = data.get_concatenation_iter(con3);
1138
1139        assert_eq!(iter.next(), num1.into());
1140        assert_eq!(iter.next(), num2.into());
1141        assert_eq!(iter.next(), num3.into());
1142        assert_eq!(iter.next(), 2.into());
1143        assert_eq!(iter.next(), 1.into());
1144        assert_eq!(iter.next(), 2.into());
1145    }
1146
1147    #[test]
1148    fn concatenation_item_iterator_not_concatenation() {
1149        let mut data = SimpleGarnishData::new();
1150        let num1 = data.add_number(10.into()).unwrap();
1151
1152        let mut iter = data.get_concatenation_iter(num1);
1153
1154        assert_eq!(iter.next(), None);
1155    }
1156
1157    #[test]
1158    fn slice_iterator() {
1159        let mut data = SimpleGarnishData::new();
1160        let s1 = data.get_data().len();
1161        data.get_data_mut().push(SimpleData::CharList("Iterators".to_string()));
1162        let num1 = data.add_number(2.into()).unwrap();
1163        let num2 = data.add_number(5.into()).unwrap();
1164        let range = data.add_range(num1, num2).unwrap();
1165        let slice = data.add_slice(s1, range).unwrap();
1166
1167        let mut iter = data.get_slice_iter(slice);
1168
1169        assert_eq!(iter.next(), Some(2.into()));
1170        assert_eq!(iter.next(), Some(3.into()));
1171        assert_eq!(iter.next(), Some(4.into()));
1172        assert_eq!(iter.next(), Some(5.into()));
1173        assert_eq!(iter.next(), None);
1174    }
1175
1176    #[test]
1177    fn slice_iterator_not_slice() {
1178        let mut data = SimpleGarnishData::new();
1179
1180        data.get_data_mut().push(SimpleData::CharList("Iterators".to_string()));
1181        let num1 = data.add_number(2.into()).unwrap();
1182        let num2 = data.add_number(5.into()).unwrap();
1183        let range = data.add_range(num1, num2).unwrap();
1184
1185        let mut iter = data.get_slice_iter(range);
1186
1187        assert_eq!(iter.next(), None);
1188    }
1189
1190    #[test]
1191    fn slice_iterator_no_range_in_slice() {
1192        let mut data = SimpleGarnishData::new();
1193        let s1 = data.get_data().len();
1194        data.get_data_mut().push(SimpleData::CharList("Iterators".to_string()));
1195        let num1 = data.add_number(2.into()).unwrap();
1196        let slice = data.add_slice(s1, num1).unwrap();
1197
1198        let mut iter = data.get_slice_iter(slice);
1199
1200        assert_eq!(iter.next(), None);
1201    }
1202
1203    #[test]
1204    fn slice_iterator_range_start_not_number() {
1205        let mut data = SimpleGarnishData::new();
1206        let s1 = data.get_data().len();
1207        data.get_data_mut().push(SimpleData::CharList("Iterators".to_string()));
1208        let num1 = data.add_byte(2).unwrap();
1209        let num2 = data.add_number(5.into()).unwrap();
1210        let range = data.add_range(num1, num2).unwrap();
1211        let slice = data.add_slice(s1, range).unwrap();
1212
1213        let mut iter = data.get_slice_iter(slice);
1214
1215        assert_eq!(iter.next(), None);
1216    }
1217
1218    #[test]
1219    fn slice_iterator_range_end_not_number() {
1220        let mut data = SimpleGarnishData::new();
1221        let s1 = data.get_data().len();
1222        data.get_data_mut().push(SimpleData::CharList("Iterators".to_string()));
1223        let num1 = data.add_number(2.into()).unwrap();
1224        let num2 = data.add_byte(5).unwrap();
1225        let range = data.add_range(num1, num2).unwrap();
1226        let slice = data.add_slice(s1, range).unwrap();
1227
1228        let mut iter = data.get_slice_iter(slice);
1229
1230        assert_eq!(iter.next(), None);
1231    }
1232
1233    #[test]
1234    fn list_slice_iterator() {
1235        let mut data = SimpleGarnishData::new();
1236        let list_index = data.get_data().len();
1237        data.get_data_mut().push(SimpleData::List(vec![100, 200, 300, 400, 500], vec![]));
1238        let num1 = data.add_number(1.into()).unwrap();
1239        let num2 = data.add_number(3.into()).unwrap();
1240        let range = data.add_range(num1, num2).unwrap();
1241        let slice = data.add_slice(list_index, range).unwrap();
1242
1243        let mut iter = data.get_list_slice_item_iter(slice);
1244
1245        assert_eq!(iter.next(), Some(200));
1246        assert_eq!(iter.next(), Some(300));
1247        assert_eq!(iter.next(), Some(400));
1248        assert_eq!(iter.next(), None);
1249    }
1250
1251    #[test]
1252    fn list_slice_iterator_not_slice() {
1253        let mut data = SimpleGarnishData::new();
1254
1255        let num1 = data.add_number(1.into()).unwrap();
1256        let num2 = data.add_number(3.into()).unwrap();
1257        let range = data.add_range(num1, num2).unwrap();
1258
1259        let mut iter = data.get_list_slice_item_iter(range);
1260
1261        assert_eq!(iter.next(), None);
1262    }
1263
1264    #[test]
1265    fn list_slice_iterator_no_range() {
1266        let mut data = SimpleGarnishData::new();
1267        let list_index = data.get_data().len();
1268        data.get_data_mut().push(SimpleData::List(vec![100, 200, 300, 400, 500], vec![]));
1269        let num2 = data.add_number(3.into()).unwrap();
1270        let slice = data.add_slice(list_index, num2).unwrap();
1271
1272        let mut iter = data.get_list_slice_item_iter(slice);
1273
1274        assert_eq!(iter.next(), None);
1275    }
1276
1277    #[test]
1278    fn list_slice_iterator_no_list() {
1279        let mut data = SimpleGarnishData::new();
1280
1281        let num1 = data.add_number(1.into()).unwrap();
1282        let num2 = data.add_number(3.into()).unwrap();
1283        let range = data.add_range(num1, num2).unwrap();
1284        let slice = data.add_slice(num1, range).unwrap();
1285
1286        let mut iter = data.get_list_slice_item_iter(slice);
1287
1288        assert_eq!(iter.next(), None);
1289    }
1290
1291    #[test]
1292    fn list_slice_iterator_start_not_number() {
1293        let mut data = SimpleGarnishData::new();
1294        let list_index = data.get_data().len();
1295        data.get_data_mut().push(SimpleData::List(vec![100, 200, 300, 400, 500], vec![]));
1296        let num1 = data.add_byte(1.into()).unwrap();
1297        let num2 = data.add_number(3.into()).unwrap();
1298        let range = data.add_range(num1, num2).unwrap();
1299        let slice = data.add_slice(list_index, range).unwrap();
1300
1301        let mut iter = data.get_list_slice_item_iter(slice);
1302
1303        assert_eq!(iter.next(), None);
1304    }
1305
1306    #[test]
1307    fn list_slice_iterator_end_not_number() {
1308        let mut data = SimpleGarnishData::new();
1309        let list_index = data.get_data().len();
1310        data.get_data_mut().push(SimpleData::List(vec![100, 200, 300, 400, 500], vec![]));
1311        let num1 = data.add_number(1.into()).unwrap();
1312        let num2 = data.add_byte(3.into()).unwrap();
1313        let range = data.add_range(num1, num2).unwrap();
1314        let slice = data.add_slice(list_index, range).unwrap();
1315
1316        let mut iter = data.get_list_slice_item_iter(slice);
1317
1318        assert_eq!(iter.next(), None);
1319    }
1320
1321    #[test]
1322    fn concatenation_slice_iterator() {
1323        let mut data = SimpleGarnishData::new();
1324
1325        let num1 = data.add_number(10.into()).unwrap();
1326        let num2 = data.add_number(10.into()).unwrap();
1327        let num3 = data.add_number(10.into()).unwrap();
1328        let list_index = data.get_data().len();
1329        data.get_data_mut().push(SimpleData::List(vec![num1, num2, num3], vec![]));
1330        let con1 = data.add_concatenation(list_index, 2).unwrap();
1331        let con2 = data.add_concatenation(con1, 1).unwrap();
1332        let con3 = data.add_concatenation(con2, 2).unwrap();
1333
1334        let start = data.add_number(2.into()).unwrap();
1335        let end = data.add_number(5.into()).unwrap();
1336        let range = data.add_range(start, end).unwrap();
1337        let slice = data.add_slice(con3, range).unwrap();
1338
1339        let mut iter = data.get_concatenation_slice_iter(slice);
1340
1341        assert_eq!(iter.next(), num3.into());
1342        assert_eq!(iter.next(), 2.into());
1343        assert_eq!(iter.next(), 1.into());
1344        assert_eq!(iter.next(), 2.into());
1345        assert_eq!(iter.next(), None);
1346    }
1347
1348    #[test]
1349    fn concatenation_slice_iterator_not_slice() {
1350        let mut data = SimpleGarnishData::new();
1351
1352        let start = data.add_number(2.into()).unwrap();
1353        let end = data.add_number(5.into()).unwrap();
1354        let range = data.add_range(start, end).unwrap();
1355
1356        let mut iter = data.get_concatenation_slice_iter(range);
1357
1358        assert_eq!(iter.next(), None);
1359    }
1360
1361    #[test]
1362    fn concatenation_slice_iterator_no_range() {
1363        let mut data = SimpleGarnishData::new();
1364
1365        let num1 = data.add_number(10.into()).unwrap();
1366        let num2 = data.add_number(10.into()).unwrap();
1367        let num3 = data.add_number(10.into()).unwrap();
1368        let list_index = data.get_data().len();
1369        data.get_data_mut().push(SimpleData::List(vec![num1, num2, num3], vec![]));
1370        let con1 = data.add_concatenation(list_index, 2).unwrap();
1371        let con2 = data.add_concatenation(con1, 1).unwrap();
1372        let con3 = data.add_concatenation(con2, 2).unwrap();
1373
1374        let start = data.add_number(2.into()).unwrap();
1375        let slice = data.add_slice(con3, start).unwrap();
1376
1377        let mut iter = data.get_concatenation_slice_iter(slice);
1378
1379        assert_eq!(iter.next(), None);
1380    }
1381
1382    #[test]
1383    fn concatenation_slice_iterator_no_concatenation() {
1384        let mut data = SimpleGarnishData::new();
1385
1386        let start = data.add_number(2.into()).unwrap();
1387        let end = data.add_number(5.into()).unwrap();
1388        let range = data.add_range(start, end).unwrap();
1389        let slice = data.add_slice(start, range).unwrap();
1390
1391        let mut iter = data.get_concatenation_slice_iter(slice);
1392
1393        assert_eq!(iter.next(), None);
1394    }
1395
1396    #[test]
1397    fn concatenation_slice_iterator_start_not_number() {
1398        let mut data = SimpleGarnishData::new();
1399
1400        let num1 = data.add_number(10.into()).unwrap();
1401        let num2 = data.add_number(10.into()).unwrap();
1402        let num3 = data.add_number(10.into()).unwrap();
1403        let list_index = data.get_data().len();
1404        data.get_data_mut().push(SimpleData::List(vec![num1, num2, num3], vec![]));
1405        let con1 = data.add_concatenation(list_index, 2).unwrap();
1406        let con2 = data.add_concatenation(con1, 1).unwrap();
1407        let con3 = data.add_concatenation(con2, 2).unwrap();
1408
1409        let start = data.add_byte(2.into()).unwrap();
1410        let end = data.add_number(5.into()).unwrap();
1411        let range = data.add_range(start, end).unwrap();
1412        let slice = data.add_slice(con3, range).unwrap();
1413
1414        let mut iter = data.get_concatenation_slice_iter(slice);
1415
1416        assert_eq!(iter.next(), None);
1417    }
1418
1419    #[test]
1420    fn concatenation_slice_iterator_end_not_number() {
1421        let mut data = SimpleGarnishData::new();
1422
1423        let num1 = data.add_number(10.into()).unwrap();
1424        let num2 = data.add_number(10.into()).unwrap();
1425        let num3 = data.add_number(10.into()).unwrap();
1426        let list_index = data.get_data().len();
1427        data.get_data_mut().push(SimpleData::List(vec![num1, num2, num3], vec![]));
1428        let con1 = data.add_concatenation(list_index, 2).unwrap();
1429        let con2 = data.add_concatenation(con1, 1).unwrap();
1430        let con3 = data.add_concatenation(con2, 2).unwrap();
1431
1432        let start = data.add_number(2.into()).unwrap();
1433        let end = data.add_byte(5.into()).unwrap();
1434        let range = data.add_range(start, end).unwrap();
1435        let slice = data.add_slice(con3, range).unwrap();
1436
1437        let mut iter = data.get_concatenation_slice_iter(slice);
1438
1439        assert_eq!(iter.next(), None);
1440    }
1441}
garnish_lang_simple_data/runtime.rs

garnish_lang_simple_data/
runtime.rs
