use crate::value::Value;
use std::rc::Rc;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ArithOp {
Add,
Sub,
Mul,
Div,
IDiv,
Mod,
Pow,
BAnd,
BOr,
BXor,
Shl,
Shr,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum UnaryOp {
Neg,
Not,
Len,
BNot,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CmpOp {
Eq,
Ne,
Lt,
Le,
}
#[derive(Clone, Copy, Debug)]
pub enum Instr {
LoadK {
dst: u8,
k: u16,
},
LoadNil {
dst: u8,
n: u8,
},
LoadBool {
dst: u8,
b: bool,
},
Move {
dst: u8,
src: u8,
},
GetUpval {
dst: u8,
up: u8,
},
SetUpval {
up: u8,
src: u8,
},
GetIndex {
dst: u8,
obj: u8,
key: u8,
},
GetField {
dst: u8,
obj: u8,
k: u16,
},
SetIndex {
obj: u8,
key: u8,
src: u8,
},
SetField {
obj: u8,
k: u16,
src: u8,
},
NewTable {
dst: u8,
},
SetList {
obj: u8,
base: u8,
n: u8,
start: u32,
},
Arith {
op: ArithOp,
dst: u8,
lhs: u8,
rhs: u8,
},
Unary {
op: UnaryOp,
dst: u8,
src: u8,
},
Cmp {
op: CmpOp,
dst: u8,
lhs: u8,
rhs: u8,
},
Concat {
dst: u8,
base: u8,
n: u8,
},
Jump {
off: i32,
},
Test {
src: u8,
if_true: bool,
off: i32,
},
Call {
base: u8,
nargs: u8,
nres: u8,
},
TailCall {
base: u8,
nargs: u8,
},
Return {
base: u8,
n: u8,
},
Vararg {
dst: u8,
n: u8,
},
Closure {
dst: u8,
p: u16,
},
Close {
from: u8,
},
Tbc {
reg: u8,
name: u16,
},
ForPrep {
base: u8,
off: i32,
},
ForLoop {
base: u8,
off: i32,
},
TForLoop {
base: u8,
off: i32,
},
}
impl Instr {
#[must_use]
pub fn reg_high(self) -> u8 {
fn m(a: u8, b: u8) -> u8 {
a.max(b)
}
match self {
Instr::LoadK { dst, .. }
| Instr::LoadBool { dst, .. }
| Instr::GetUpval { dst, .. }
| Instr::NewTable { dst }
| Instr::Closure { dst, .. }
| Instr::Vararg { dst, .. } => dst.saturating_add(1),
Instr::LoadNil { dst, n } => dst.saturating_add(n),
Instr::Move { dst, src } | Instr::Unary { dst, src, .. } => {
m(dst, src).saturating_add(1)
}
Instr::SetUpval { src, .. } | Instr::Test { src, .. } => src.saturating_add(1),
Instr::GetIndex { dst, obj, key } => m(m(dst, obj), key).saturating_add(1),
Instr::GetField { dst, obj, .. } => m(dst, obj).saturating_add(1),
Instr::SetIndex { obj, key, src } => m(m(obj, key), src).saturating_add(1),
Instr::SetField { obj, src, .. } => m(obj, src).saturating_add(1),
Instr::SetList { obj, base, n, .. } => {
m(obj, base.saturating_add(n.max(1))).saturating_add(1)
}
Instr::Arith { dst, lhs, rhs, .. } | Instr::Cmp { dst, lhs, rhs, .. } => {
m(m(dst, lhs), rhs).saturating_add(1)
}
Instr::Concat { dst, base, n } => m(dst.saturating_add(1), base.saturating_add(n)),
Instr::Jump { .. } | Instr::Close { from: 255 } => 0,
Instr::Call { base, .. } | Instr::TailCall { base, .. } => base.saturating_add(1),
Instr::Return { base, n } => {
if n == 0 {
base.saturating_add(1)
} else {
base.saturating_add(n - 1).max(base.saturating_add(1))
}
}
Instr::Close { from } => from.saturating_add(1),
Instr::Tbc { reg, .. } => reg.saturating_add(1),
Instr::ForPrep { base, .. } | Instr::ForLoop { base, .. } => base.saturating_add(4),
Instr::TForLoop { base, .. } => base.saturating_add(5),
}
}
}
#[derive(Clone, Copy, Debug)]
pub enum UpvalDesc {
Local(u8),
Upval(u8),
}
pub struct Proto {
pub code: Vec<Instr>,
pub source: std::rc::Rc<str>,
pub lines: Vec<u32>,
pub consts: Vec<Value>,
pub protos: Vec<Rc<Proto>>,
pub upvals: Vec<UpvalDesc>,
pub upval_names: Vec<Box<str>>,
pub nparams: u8,
pub is_vararg: bool,
pub max_regs: u8,
pub reg_extent: Vec<u8>,
pub name: String,
pub linedefined: u32,
pub lastlinedefined: u32,
pub call_names: Vec<Option<(&'static str, Box<str>)>>,
}