419 lines
11 KiB
Rust
419 lines
11 KiB
Rust
use std::convert::TryFrom;
|
|
use std::fmt::{Display, Formatter};
|
|
|
|
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
|
|
pub enum Opcode {
|
|
Nop,
|
|
Add,
|
|
Sub,
|
|
Mul,
|
|
Div,
|
|
Mod,
|
|
Copy,
|
|
And,
|
|
Or,
|
|
Xor,
|
|
Not,
|
|
Gt,
|
|
Lt,
|
|
Agt,
|
|
Alt,
|
|
Lshift,
|
|
Rshift,
|
|
Arshift,
|
|
Pop,
|
|
Dup,
|
|
Swap,
|
|
Pick,
|
|
Rot,
|
|
Jmp,
|
|
Jmpr,
|
|
Call,
|
|
Ret,
|
|
Brz,
|
|
Brnz,
|
|
Hlt,
|
|
Load,
|
|
Loadw,
|
|
Store,
|
|
Storew,
|
|
Setint,
|
|
Setiv,
|
|
Sdp,
|
|
Setsdp,
|
|
Pushr,
|
|
Popr,
|
|
Peekr,
|
|
Debug,
|
|
}
|
|
|
|
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
|
|
pub struct InvalidOpcode(pub u8);
|
|
|
|
impl Display for InvalidOpcode {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
write!(f, "Invalid opcode {:#02x}", self.0)
|
|
}
|
|
}
|
|
|
|
impl std::error::Error for InvalidOpcode {}
|
|
|
|
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
|
|
pub struct InvalidMnemonic<'a>(pub &'a str);
|
|
|
|
impl Display for Opcode {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
Opcode::Nop => {
|
|
write!(f, "nop")
|
|
}
|
|
Opcode::Add => {
|
|
write!(f, "add")
|
|
}
|
|
Opcode::Sub => {
|
|
write!(f, "sub")
|
|
}
|
|
Opcode::Mul => {
|
|
write!(f, "mul")
|
|
}
|
|
Opcode::Div => {
|
|
write!(f, "div")
|
|
}
|
|
Opcode::Mod => {
|
|
write!(f, "mod")
|
|
}
|
|
Opcode::Copy => {
|
|
write!(f, "copy")
|
|
}
|
|
Opcode::And => {
|
|
write!(f, "and")
|
|
}
|
|
Opcode::Or => {
|
|
write!(f, "or")
|
|
}
|
|
Opcode::Xor => {
|
|
write!(f, "xor")
|
|
}
|
|
Opcode::Not => {
|
|
write!(f, "not")
|
|
}
|
|
Opcode::Gt => {
|
|
write!(f, "gt")
|
|
}
|
|
Opcode::Lt => {
|
|
write!(f, "lt")
|
|
}
|
|
Opcode::Agt => {
|
|
write!(f, "agt")
|
|
}
|
|
Opcode::Alt => {
|
|
write!(f, "alt")
|
|
}
|
|
Opcode::Lshift => {
|
|
write!(f, "lshift")
|
|
}
|
|
Opcode::Rshift => {
|
|
write!(f, "rshift")
|
|
}
|
|
Opcode::Arshift => {
|
|
write!(f, "arshift")
|
|
}
|
|
Opcode::Pop => {
|
|
write!(f, "pop")
|
|
}
|
|
Opcode::Dup => {
|
|
write!(f, "dup")
|
|
}
|
|
Opcode::Swap => {
|
|
write!(f, "swap")
|
|
}
|
|
Opcode::Pick => {
|
|
write!(f, "pick")
|
|
}
|
|
Opcode::Rot => {
|
|
write!(f, "rot")
|
|
}
|
|
Opcode::Jmp => {
|
|
write!(f, "jmp")
|
|
}
|
|
Opcode::Jmpr => {
|
|
write!(f, "jmpr")
|
|
}
|
|
Opcode::Call => {
|
|
write!(f, "call")
|
|
}
|
|
Opcode::Ret => {
|
|
write!(f, "ret")
|
|
}
|
|
Opcode::Brz => {
|
|
write!(f, "brz")
|
|
}
|
|
Opcode::Brnz => {
|
|
write!(f, "brnz")
|
|
}
|
|
Opcode::Hlt => {
|
|
write!(f, "hlt")
|
|
}
|
|
Opcode::Load => {
|
|
write!(f, "load")
|
|
}
|
|
Opcode::Loadw => {
|
|
write!(f, "loadw")
|
|
}
|
|
Opcode::Store => {
|
|
write!(f, "store")
|
|
}
|
|
Opcode::Storew => {
|
|
write!(f, "storew")
|
|
}
|
|
Opcode::Setint => {
|
|
write!(f, "setint")
|
|
}
|
|
Opcode::Setiv => {
|
|
write!(f, "setiv")
|
|
}
|
|
Opcode::Sdp => {
|
|
write!(f, "sdp")
|
|
}
|
|
Opcode::Setsdp => {
|
|
write!(f, "setsdp")
|
|
}
|
|
Opcode::Pushr => {
|
|
write!(f, "pushr")
|
|
}
|
|
Opcode::Popr => {
|
|
write!(f, "popr")
|
|
}
|
|
Opcode::Peekr => {
|
|
write!(f, "peekr")
|
|
}
|
|
Opcode::Debug => {
|
|
write!(f, "debug")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TryFrom<u8> for Opcode {
|
|
type Error = InvalidOpcode;
|
|
|
|
fn try_from(value: u8) -> Result<Self, Self::Error> {
|
|
use Opcode::*;
|
|
Ok(match value {
|
|
0 => Nop,
|
|
1 => Add,
|
|
2 => Sub,
|
|
3 => Mul,
|
|
4 => Div,
|
|
5 => Mod,
|
|
6 => Copy,
|
|
7 => And,
|
|
8 => Or,
|
|
9 => Xor,
|
|
10 => Not,
|
|
11 => Gt,
|
|
12 => Lt,
|
|
13 => Agt,
|
|
14 => Alt,
|
|
15 => Lshift,
|
|
16 => Rshift,
|
|
17 => Arshift,
|
|
18 => Pop,
|
|
19 => Dup,
|
|
20 => Swap,
|
|
21 => Pick,
|
|
22 => Rot,
|
|
23 => Jmp,
|
|
24 => Jmpr,
|
|
25 => Call,
|
|
26 => Ret,
|
|
27 => Brz,
|
|
28 => Brnz,
|
|
29 => Hlt,
|
|
30 => Load,
|
|
31 => Loadw,
|
|
32 => Store,
|
|
33 => Storew,
|
|
34 => Setint,
|
|
35 => Setiv,
|
|
36 => Sdp,
|
|
37 => Setsdp,
|
|
38 => Pushr,
|
|
39 => Popr,
|
|
40 => Peekr,
|
|
41 => Debug,
|
|
other => return Err(InvalidOpcode(other)),
|
|
})
|
|
}
|
|
}
|
|
|
|
impl<'a> TryFrom<&'a str> for Opcode {
|
|
type Error = InvalidMnemonic<'a>;
|
|
|
|
fn try_from(value: &'a str) -> Result<Self, Self::Error> {
|
|
use Opcode::*;
|
|
Ok(match value {
|
|
"nop" | "push" => Nop,
|
|
"add" => Add,
|
|
"sub" => Sub,
|
|
"mul" => Mul,
|
|
"div" => Div,
|
|
"mod" => Mod,
|
|
"copy" => Copy,
|
|
"and" => And,
|
|
"or" => Or,
|
|
"xor" => Xor,
|
|
"not" => Not,
|
|
"gt" => Gt,
|
|
"lt" => Lt,
|
|
"agt" => Agt,
|
|
"alt" => Alt,
|
|
"lshift" => Lshift,
|
|
"rshift" => Rshift,
|
|
"arshift" => Arshift,
|
|
"pop" => Pop,
|
|
"dup" => Dup,
|
|
"swap" => Swap,
|
|
"pick" => Pick,
|
|
"rot" => Rot,
|
|
"jmp" => Jmp,
|
|
"jmpr" => Jmpr,
|
|
"call" => Call,
|
|
"ret" => Ret,
|
|
"brz" => Brz,
|
|
"brnz" => Brnz,
|
|
"hlt" => Hlt,
|
|
"load" => Load,
|
|
"loadw" => Loadw,
|
|
"store" => Store,
|
|
"storew" => Storew,
|
|
"setint" => Setint,
|
|
"setiv" => Setiv,
|
|
"sdp" => Sdp,
|
|
"setsdp" => Setsdp,
|
|
"pushr" => Pushr,
|
|
"popr" => Popr,
|
|
"peekr" => Peekr,
|
|
"debug" => Debug,
|
|
_ => return Err(InvalidMnemonic(value)),
|
|
})
|
|
}
|
|
}
|
|
|
|
impl From<Opcode> for u8 {
|
|
fn from(opcode: Opcode) -> Self {
|
|
match opcode {
|
|
Opcode::Nop => 0,
|
|
Opcode::Add => 1,
|
|
Opcode::Sub => 2,
|
|
Opcode::Mul => 3,
|
|
Opcode::Div => 4,
|
|
Opcode::Mod => 5,
|
|
Opcode::Copy => 6,
|
|
Opcode::And => 7,
|
|
Opcode::Or => 8,
|
|
Opcode::Xor => 9,
|
|
Opcode::Not => 10,
|
|
Opcode::Gt => 11,
|
|
Opcode::Lt => 12,
|
|
Opcode::Agt => 13,
|
|
Opcode::Alt => 14,
|
|
Opcode::Lshift => 15,
|
|
Opcode::Rshift => 16,
|
|
Opcode::Arshift => 17,
|
|
Opcode::Pop => 18,
|
|
Opcode::Dup => 19,
|
|
Opcode::Swap => 20,
|
|
Opcode::Pick => 21,
|
|
Opcode::Rot => 22,
|
|
Opcode::Jmp => 23,
|
|
Opcode::Jmpr => 24,
|
|
Opcode::Call => 25,
|
|
Opcode::Ret => 26,
|
|
Opcode::Brz => 27,
|
|
Opcode::Brnz => 28,
|
|
Opcode::Hlt => 29,
|
|
Opcode::Load => 30,
|
|
Opcode::Loadw => 31,
|
|
Opcode::Store => 32,
|
|
Opcode::Storew => 33,
|
|
Opcode::Setint => 34,
|
|
Opcode::Setiv => 35,
|
|
Opcode::Sdp => 36,
|
|
Opcode::Setsdp => 37,
|
|
Opcode::Pushr => 38,
|
|
Opcode::Popr => 39,
|
|
Opcode::Peekr => 40,
|
|
Opcode::Debug => 41,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Opcode {
|
|
/// The number of things required to be on the data stack for this opcode to function.
|
|
pub fn arity(self) -> usize {
|
|
use Opcode::*;
|
|
match self {
|
|
Nop | Ret | Hlt | Sdp | Popr | Peekr | Debug => 0,
|
|
|
|
Not | Pop | Dup | Jmp | Jmpr | Call | Load | Loadw | Setint | Pushr | Pick => 1,
|
|
|
|
Add | Sub | Mul | Div | Mod | And | Or | Xor | Gt | Lt | Agt | Alt | Lshift
|
|
| Rshift | Arshift | Swap | Brz | Brnz | Store | Storew | Setsdp | Setiv => 2,
|
|
|
|
Rot | Copy => 3,
|
|
}
|
|
}
|
|
|
|
/// The number of things required to be on the return stack for this opcode to function.
|
|
pub fn r_arity(self) -> usize {
|
|
use Opcode::*;
|
|
|
|
match self {
|
|
Peekr | Popr | Ret => 1,
|
|
|
|
Nop | Copy | Hlt | Sdp | Debug | Not | Pop | Dup | Jmp | Jmpr | Call | Load | Loadw
|
|
| Setint | Setiv | Pushr | Add | Sub | Mul | Div | Mod | And | Or | Xor | Gt | Lt
|
|
| Agt | Alt | Lshift | Rshift | Arshift | Swap | Brz | Brnz | Store | Storew
|
|
| Setsdp | Rot | Pick => 0,
|
|
}
|
|
}
|
|
|
|
/// The net change in stack usage (in cells) after executing this instruction. This is used to
|
|
/// tell whether this instruction will cause an overflow. Execution happens in three phases:
|
|
/// first the argument is pushed (which might trigger overflow); then the operands are popped
|
|
/// (which cannot overflow); then the result is pushed (which might overflow). This fn tells
|
|
/// you the number of result cells minus the number of operand cells, so, the delta in stack
|
|
/// usage for steps 2 and 3. Additionally, this fn counts data and return stack cells together,
|
|
/// so,
|
|
/// ```
|
|
/// # use vcore::opcodes::Opcode;
|
|
/// assert_eq!(Opcode::Pushr.net_stack(), 0)
|
|
/// ```
|
|
/// because moving a cell from data to return doesn't increase stack usage.
|
|
pub fn net_stack(self) -> i32 {
|
|
use Opcode::*;
|
|
|
|
match self {
|
|
Sdp => 2,
|
|
|
|
Peekr | Dup => 1,
|
|
|
|
Nop | Hlt | Debug | Not | Call | Load | Loadw | Pushr | Popr | Pick | Rot | Swap => 0,
|
|
|
|
Pop | Jmp | Jmpr | Add | Sub | Mul | Div | Mod | And | Or | Xor | Gt | Lt | Agt
|
|
| Alt | Lshift | Rshift | Arshift | Ret => -1,
|
|
|
|
Setint | Store | Storew | Setsdp | Setiv | Brz | Brnz => -2,
|
|
|
|
Copy => -3,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_decode() {
|
|
assert_eq!(Opcode::try_from(18), Ok(Opcode::Pop));
|
|
//assert_eq!(str::fmt("{}", Opcode::try_from(136).unwrap_err()), Err(InvalidOpcode(136)));
|
|
}
|