reqlang_expr/
vm.rs

1//! The virtual machine and associated types
2
3use std::ops::Range;
4
5use crate::{
6    compiler::{
7        CompileTimeEnv, ExprByteCode,
8        lookup::{BUILTIN, PROMPT, SECRET, VAR},
9        opcode,
10    },
11    errors::{ExprError, ExprResult, RuntimeError},
12    prelude::lookup::{CLIENT_CTX, USER_BUILTIN},
13    value::Value,
14};
15
16#[derive(Debug, Clone, Default)]
17pub struct RuntimeEnv {
18    pub vars: Vec<String>,
19    pub prompts: Vec<String>,
20    pub secrets: Vec<String>,
21    pub client_context: Vec<Value>,
22}
23
24impl RuntimeEnv {
25    pub fn add_to_client_context(&mut self, index: usize, value: Value) {
26        if index < self.client_context.len() {
27            self.client_context[index] = value;
28        } else {
29            self.client_context.push(value);
30        }
31    }
32}
33
34#[derive(Debug)]
35pub struct Vm {
36    bytecode: Option<Box<ExprByteCode>>,
37    ip: usize,
38    stack: Vec<Value>,
39}
40
41impl Vm {
42    pub fn new() -> Self {
43        Self {
44            bytecode: None,
45            ip: 0,
46            stack: vec![],
47        }
48    }
49
50    pub fn interpret(
51        &mut self,
52        bytecode: Box<ExprByteCode>,
53        env: &CompileTimeEnv,
54        runtime_env: &RuntimeEnv,
55    ) -> ExprResult<Value> {
56        self.bytecode = Some(bytecode);
57        self.ip = 0;
58
59        let mut errs: Vec<(ExprError, Range<usize>)> = vec![];
60
61        while let Some(op_code) = self
62            .bytecode
63            .as_ref()
64            .and_then(|bc| bc.codes().get(self.ip))
65        {
66            if let Err(e) = self.interpret_op(env, runtime_env, *op_code) {
67                errs.extend(e);
68            }
69        }
70
71        if !errs.is_empty() {
72            return Err(errs.into());
73        }
74
75        self.stack_pop()
76    }
77
78    fn interpret_op(
79        &mut self,
80        env: &CompileTimeEnv,
81        runtime_env: &RuntimeEnv,
82        op_code: u8,
83    ) -> ExprResult<()> {
84        match op_code {
85            opcode::CALL => self.op_call(),
86            opcode::CONSTANT => self.op_constant(),
87            opcode::GET => self.op_get(env, runtime_env),
88            opcode::TRUE => self.op_true(),
89            opcode::FALSE => self.op_false(),
90            _ => panic!("Invalid OP code: {op_code}"),
91        }
92    }
93
94    fn op_call(&mut self) -> ExprResult<()> {
95        // Confirm the current op code is CALL
96        assert_eq!(opcode::CALL, self.read_u8(), "Expected CALL opcode");
97
98        let arg_count = self.read_u8() as usize;
99
100        let mut args: Vec<Value> = vec![];
101
102        for _ in 0..arg_count {
103            args.push(self.stack_pop()?);
104        }
105
106        args.reverse();
107
108        let value = self.stack_pop()?;
109
110        let builtin = value.get_func().func.clone();
111
112        let result = builtin(args);
113
114        self.stack_push(result);
115
116        Ok(())
117    }
118
119    fn op_get(&mut self, env: &CompileTimeEnv, runtime_env: &RuntimeEnv) -> ExprResult<()> {
120        assert_eq!(opcode::GET, self.read_u8(), "Expected GET opcode");
121        let get_lookup = self.read_u8();
122        let get_idx = self.read_u8() as usize;
123
124        match get_lookup {
125            BUILTIN => {
126                let value = env
127                    .get_builtin(get_idx)
128                    .unwrap_or_else(|| panic!("undefined builtin: {get_idx}"));
129                self.stack_push(Value::Fn(value.clone()));
130            }
131            USER_BUILTIN => {
132                let value = env
133                    .get_user_builtin(get_idx)
134                    .unwrap_or_else(|| panic!("undefined user builtin: {get_idx}"));
135                self.stack_push(Value::Fn(value.clone()));
136            }
137            VAR => {
138                let value = env
139                    .get_var(get_idx)
140                    .and_then(|_| runtime_env.vars.get(get_idx))
141                    .unwrap_or_else(|| panic!("undefined variable: {get_idx}"));
142
143                self.stack_push(Value::String(value.clone()));
144            }
145            PROMPT => {
146                let value = env
147                    .get_prompt(get_idx)
148                    .and_then(|_| runtime_env.prompts.get(get_idx))
149                    .unwrap_or_else(|| panic!("undefined prompt: {get_idx}"));
150
151                self.stack_push(Value::String(value.clone()));
152            }
153            SECRET => {
154                let value = env
155                    .get_secret(get_idx)
156                    .and_then(|_| runtime_env.secrets.get(get_idx))
157                    .unwrap_or_else(|| panic!("undefined secret: {get_idx}"));
158
159                self.stack_push(Value::String(value.clone()));
160            }
161            CLIENT_CTX => {
162                let value = env
163                    .get_client_context(get_idx)
164                    .and_then(|_| runtime_env.client_context.get(get_idx))
165                    .unwrap_or_else(|| panic!("undefined client context: {get_idx}"));
166
167                self.stack_push(value.clone());
168            }
169            _ => panic!("Invalid get lookup code: {}", get_lookup),
170        };
171
172        Ok(())
173    }
174
175    fn op_constant(&mut self) -> ExprResult<()> {
176        assert_eq!(opcode::CONSTANT, self.read_u8(), "Expected CONSTANT opcode");
177
178        let get_idx = self.read_u8() as usize;
179
180        let s = self
181            .bytecode
182            .as_ref()
183            .expect("should have bytecode")
184            .strings()
185            .get(get_idx)
186            .unwrap_or_else(|| panic!("undefined string: {}", get_idx));
187
188        self.stack_push(Value::String(s.clone()));
189
190        Ok(())
191    }
192
193    fn op_true(&mut self) -> ExprResult<()> {
194        assert_eq!(opcode::TRUE, self.read_u8(), "Expected TRUE opcode");
195
196        self.stack_push(Value::Bool(true));
197
198        Ok(())
199    }
200
201    fn op_false(&mut self) -> ExprResult<()> {
202        assert_eq!(opcode::FALSE, self.read_u8(), "Expected FALSE opcode");
203
204        self.stack_push(Value::Bool(false));
205
206        Ok(())
207    }
208
209    fn stack_push(&mut self, value: Value) {
210        self.stack.push(value);
211    }
212
213    fn stack_pop(&mut self) -> ExprResult<Value> {
214        if let Some(value) = self.stack.pop() {
215            return Ok(value);
216        };
217
218        Err(vec![(RuntimeError::EmptyStack.into(), 0..0)])
219    }
220
221    fn read_u8(&mut self) -> u8 {
222        let current_ip = self.ip as u8;
223
224        self.ip += 1;
225
226        *self
227            .bytecode
228            .as_ref()
229            .expect("should have bytecode")
230            .codes()
231            .get(current_ip as usize)
232            .expect("should have op in bytecode at {}")
233    }
234}
235
236#[cfg(test)]
237mod tests {
238    use super::*;
239
240    #[test]
241    #[should_panic(expected = "Invalid OP code: 99")]
242    fn test_invalid_opcode_99() {
243        let mut vm = Vm::new();
244
245        let bytecode = Box::new(ExprByteCode::new(vec![99], vec![])); // 99 as invalid opcode
246        let env = CompileTimeEnv::default();
247        let runtime_env = RuntimeEnv::default();
248
249        // Attempt to interpret the bytecode, expecting a panic due to invalid opcode 99
250        let _ = vm.interpret(bytecode, &env, &runtime_env);
251    }
252
253    #[test]
254    #[should_panic(expected = "Invalid get lookup code: 99")]
255    fn test_invalid_look_99() {
256        let mut vm = Vm::new();
257
258        let bytecode = Box::new(ExprByteCode::new(vec![opcode::GET, 99, 0], vec![])); // 99 as invalid opcode
259        let env = CompileTimeEnv::default();
260        let runtime_env = RuntimeEnv::default();
261
262        // Attempt to interpret the bytecode, expecting a panic due to invalid opcode 99
263        let _ = vm.interpret(bytecode, &env, &runtime_env);
264    }
265}
reqlang_expr/vm.rs

reqlang_expr/
vm.rs
