pushr 0.4.1

Pushr is a Rust based interpreter for Push programs.
Documentation 
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use crate::push::configuration::PushConfiguration;
use crate::push::graph::Graph;
use crate::push::index::Index;
use crate::push::item::Item;
use crate::push::stack::PushStack;
use crate::push::buffer::{PushBuffer, BufferType};
use crate::push::io::{PushMessage};
use crate::push::vector::{BoolVector, FloatVector, IntVector};
use std::collections::HashMap;
use std::fmt;

pub const BOOL_STACK_ID: i32 = 1;
pub const BOOL_VECTOR_STACK_ID: i32 = 2;
pub const CODE_STACK_ID: i32 = 3;
pub const EXEC_STACK_ID: i32 = 4;
pub const FLOAT_STACK_ID: i32 = 5;
pub const FLOAT_VECTOR_STACK_ID: i32 = 6;
pub const INDEX_STACK_ID: i32 = 7;
pub const INPUT_STACK_ID: i32 = 8;
pub const INT_STACK_ID: i32 = 9;
pub const INT_VECTOR_STACK_ID: i32 = 10;
pub const NAME_STACK_ID: i32 = 11;
pub const OUTPUT_STACK_ID: i32 = 12;


pub const INPUT_BUFFER_SIZE: usize = 10;
pub const OUTPUT_BUFFER_SIZE: usize = 3;
pub const GRAPH_BUFFER_SIZE: usize = 100;


pub struct PushState {
    // Scalar Types
    pub bool_stack: PushStack<bool>,
    pub code_stack: PushStack<Item>, // Change this to reference for speedup
    pub exec_stack: PushStack<Item>,
    pub float_stack: PushStack<f32>,
    pub index_stack: PushStack<Index>,
    pub int_stack: PushStack<i32>,
    pub name_stack: PushStack<String>,

    // Vector Types
    pub bool_vector_stack: PushStack<BoolVector>,
    pub float_vector_stack: PushStack<FloatVector>,
    pub int_vector_stack: PushStack<IntVector>,

    // IO
    pub input_stack: PushBuffer<PushMessage>,
    pub output_stack: PushBuffer<PushMessage>,

    // Graph
    pub graph_stack: PushBuffer<Graph>,

    // Bindings
    pub name_bindings: HashMap<String, Item>,

    pub configuration: PushConfiguration,
    pub quote_name: bool,
    pub send_name: bool,
}

impl PushState {
    pub fn new() -> Self {
        Self {
            bool_stack: PushStack::new(),
            code_stack: PushStack::new(),
            exec_stack: PushStack::new(),
            float_stack: PushStack::new(),
            index_stack: PushStack::new(),
            int_stack: PushStack::new(),
            name_stack: PushStack::new(),
            bool_vector_stack: PushStack::new(),
            float_vector_stack: PushStack::new(),
            int_vector_stack: PushStack::new(),
            input_stack: PushBuffer::new(BufferType::Queue, INPUT_BUFFER_SIZE),
            output_stack: PushBuffer::new(BufferType::Queue, OUTPUT_BUFFER_SIZE),
            graph_stack: PushBuffer::new(BufferType::Stack, GRAPH_BUFFER_SIZE),
            name_bindings: HashMap::new(),
            configuration: PushConfiguration::new(),
            quote_name: false,
            send_name: false,
        }
    }

    /// Returns total size of stacks without IO stacks.
    pub fn size(&self) -> usize {
        self.bool_stack.size()
            + self.float_stack.size()
            + self.int_stack.size()
            + self.name_stack.size()
            + self.code_stack.size()
            + self.exec_stack.size()
            + self.bool_vector_stack.size()
            + self.float_vector_stack.size()
            + self.int_vector_stack.size()
    }
}

impl fmt::Display for PushState {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut nb = "".to_string();
        let mut sorted: Vec<_> = self.name_bindings.iter().collect();
        sorted.sort_by_key(|a| a.0);

        for (key, value) in &sorted {
            nb += &format!("{} => {}\n ", key, value)[..];
        }
        write!(
            f,
            "> BOOL  : \n{}\n> CODE  : \n{}\n> EXEC  : \n{}\n> FLOAT : \n{}\n> GRAPH : \n{}\n> INDEX : \n{}\n> INT   : \n{}\n> BVEC  : \n{}\n> FVEC  : \n{}\n> IVEC  : \n{}\n> NAME  : \n{}\n> IDS   : \n{}\n",
            self.bool_stack.to_string(),
            self.code_stack.to_string(),
            self.exec_stack.to_string(),
            self.float_stack.to_string(),
            self.graph_stack.to_string(),
            self.index_stack.to_string(),
            self.int_stack.to_string(),
            self.bool_vector_stack.to_string(),
            self.float_vector_stack.to_string(),
            self.int_vector_stack.to_string(),
            self.name_stack.to_string(),
            nb,
        )
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn push_state_prints_name_bindings_in_alphabetical_order() {
        let mut test_state = PushState::new();
        test_state.name_bindings.insert(
            "Var2".to_string(),
            Item::instruction("INTVECTOR.BOOLINDEX".to_string()),
        );
        test_state
            .name_bindings
            .insert("Var1".to_string(), Item::bool(true));
        assert_eq!(test_state.to_string(), "> BOOL  : \n\n> CODE  : \n\n> EXEC  : \n\n> FLOAT : \n\n> GRAPH : \n\n> INDEX : \n\n> INT   : \n\n> BVEC  : \n\n> FVEC  : \n\n> IVEC  : \n\n> NAME  : \n\n> IDS   : \nVar1 => TRUE\n Var2 => INTVECTOR.BOOLINDEX\n \n")
    }
}