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
|
mod encoding;
mod heap;
mod value;
use encoding::{Arg, Op};
use heap::Heap;
use std::error::Error;
use std::ffi::OsString;
use std::io::{stderr, Write};
use value::Value;
struct State {
i: usize,
heap: Heap,
}
impl State {
fn read_arg(&self, a: Arg) -> Value {
match a {
Arg::Local(l) => self.heap.locals[usize::from(l)],
Arg::Const(c) => c,
}
}
fn op(&mut self, op: Op) -> Result<(), Box<dyn Error>> {
match op {
Op::Alloc(op) => {
let Some(i) = self.read_arg(op.size).to_int() else {
return Err(Box::from("alloc needs an int"));
};
self.heap.locals[usize::from(op.out)] = Value::from_pointer(self.heap.alloc(i)?);
}
Op::Call => {
let Some(i) = self.heap.locals[0].to_int() else {
return Err(Box::from("call needs an int"));
};
self.i = usize::try_from(i)?;
}
Op::Poke(op) => {
let Some(p) = self.heap.locals[usize::from(op.ptr)].to_pointer() else {
return Err(Box::from("poke needs a pointer"));
};
self.heap.poke(p + op.offset, self.read_arg(op.val))?;
}
Op::Peek(op) => {
let Some(p) = self.read_arg(op.val).to_pointer() else {
return Err(Box::from("peek needs a pointer"));
};
self.heap.locals[usize::from(op.out)] = self.heap.peek(p + op.offset)?;
}
Op::Shuf(op) => {
self.heap.locals[usize::from(op.out)] = self.read_arg(op.val);
}
Op::Exit(op) => {
let Some(i) = self.read_arg(op.val).to_int() else {
std::process::exit(255);
};
std::process::exit(i as i32);
}
Op::Add(op) => {
let Some(v1) = self.read_arg(op.val1).to_int() else {
return Err(Box::from("add needs an int"));
};
let Some(v2) = self.read_arg(op.val2).to_int() else {
return Err(Box::from("add needs an int"));
};
self.heap.locals[usize::from(op.out)] = Value::from_int(v1.wrapping_add(v2));
}
Op::Sub(op) => {
let Some(v1) = self.read_arg(op.val1).to_int() else {
return Err(Box::from("sub needs an int"));
};
let Some(v2) = self.read_arg(op.val2).to_int() else {
return Err(Box::from("sub needs an int"));
};
self.heap.locals[usize::from(op.out)] = Value::from_int(v1.wrapping_sub(v2));
}
Op::Mul(op) => {
let Some(v1) = self.read_arg(op.val1).to_int() else {
return Err(Box::from("mul needs an int"));
};
let Some(v2) = self.read_arg(op.val2).to_int() else {
return Err(Box::from("mul needs an int"));
};
self.heap.locals[usize::from(op.out)] = Value::from_int(v1.wrapping_mul(v2));
}
Op::Div(op) => {
let Some(v1) = self.read_arg(op.val1).to_int() else {
return Err(Box::from("div needs an int"));
};
let Some(v2) = self.read_arg(op.val2).to_int() else {
return Err(Box::from("div needs an int"));
};
let Some(res) = v1.checked_div(v2) else {
return Err(Box::from("division by zero"));
};
self.heap.locals[usize::from(op.out)] = Value::from_int(res);
}
}
Ok(())
}
}
fn run() -> Result<(), Box<dyn Error>> {
let args: Vec<OsString> = std::env::args_os().collect();
if args.len() != 2 {
return Err(Box::from("usage: bytecode <file>"));
}
let prog = std::fs::read(&args[1])?;
let mut st = State {
i: 0,
heap: Heap::new(),
};
loop {
let (n, op) = Op::parse(&prog[st.i..])?;
st.i += n;
st.op(op)?;
}
}
fn main() {
if let Err(err) = run() {
let _ = writeln!(stderr(), "FAIL: {}", err);
std::process::exit(255);
}
}
|
