he_eval/
he_eval.rs

1extern crate hexagon_e;
2
3use std::fs::File;
4use std::io::Read;
5use std::env;
6use std::cell::Cell;
7
8use hexagon_e::environment::Environment;
9use hexagon_e::tape::Tape;
10use hexagon_e::error::ExecuteResult;
11//use hexagon_e::module::Opcode;
12
13struct ResourceHolder {
14    mem: Vec<u8>,
15    slots: Vec<i64>,
16    stack: Vec<Cell<i64>>,
17    call_stack: Vec<Cell<i64>>
18}
19
20struct ExecutionEnv<'a> {
21    mem: &'a mut Vec<u8>,
22    slots: &'a mut Vec<i64>,
23    stack: Tape<'a, Cell<i64>>,
24    call_stack: Tape<'a, Cell<i64>>,
25}
26
27impl<'a> ExecutionEnv<'a> {
28    fn new(rh: &'a mut ResourceHolder) -> ExecutionEnv<'a> {
29        ExecutionEnv {
30            mem: &mut rh.mem,
31            slots: &mut rh.slots,
32            stack: Tape::from(rh.stack.as_slice()),
33            call_stack: Tape::from(rh.call_stack.as_slice())
34        }
35    }
36}
37
38impl<'a> Environment for ExecutionEnv<'a> {
39    fn get_memory(&self) -> &[u8] {
40        &self.mem
41    }
42
43    fn get_memory_mut(&mut self) -> &mut [u8] {
44        &mut self.mem
45    }
46
47    fn get_slots(&self) -> &[i64] {
48        &self.slots
49    }
50
51    fn get_slots_mut(&mut self) -> &mut [i64] {
52        &mut self.slots
53    }
54
55    fn reset_slots(&mut self, len: usize) -> ExecuteResult<()> {
56        *self.slots = vec! [ 0; len ];
57        Ok(())
58    }
59
60    fn grow_memory(&mut self, len_inc: usize) -> ExecuteResult<()> {
61        self.mem.extend((0..len_inc).map(|_| 0));
62        Ok(())
63    }
64
65    fn get_stack(&self) -> &Tape<Cell<i64>> {
66        &self.stack
67    }
68
69    fn get_call_stack(&self) -> &Tape<Cell<i64>> {
70        &self.call_stack
71    }
72
73/*
74    fn trace_opcode(&self, op: &Opcode) {
75        println!("{:?}", op);
76    }
77
78    fn trace_call(&self, target: usize, n_locals: usize) {
79        println!("call {} (n_locals = {})", target, n_locals);
80    }*/
81/*
82    fn trace_load(&self, offset: usize, addr: usize, val: u64) {
83        println!("load {} + {} -> {}", offset, addr, val);
84    }
85
86    fn trace_mem_init(&self, start: usize, data: &[u8]) {
87        println!("mem_init {}, len = {}", start, data.len());
88        if data.len() < 1024 {
89            println!("data = {:?}", data);
90        }
91    }
92*/
93}
94
95fn main() {
96    let mut f = File::open(env::args()
97        .nth(1)
98        .expect("Path expected")
99    ).expect("Unable to open code file");
100
101    let mut code: Vec<u8> = Vec::new();
102    f.read_to_end(&mut code).unwrap();
103
104    let module = hexagon_e::module::Module::from_raw(&code).unwrap();
105
106    let mut rh = ResourceHolder {
107        mem: vec! [ 0; 1048576 ],
108        slots: vec! [ 0; 65536 ],
109        stack: vec! [ Cell::new(0); 1024 ],
110        call_stack: vec! [ Cell::new(0); 1024 ]
111    };
112    let env = ExecutionEnv::new(&mut rh);
113
114    let mut vm = hexagon_e::vm::VirtualMachine::new(&module, env);
115    vm.run_memory_initializers().unwrap();
116    vm.run().unwrap();
117}
he_eval/he_eval.rs

he_eval/
he_eval.rs
