use crate::expand::TexError;
use crate::ir::{Arith, Cmd, MsgOp, Num, Rel};
use fusevm::{Chunk, ChunkBuilder, Op, Value};
pub mod ops {
pub const TEXT: u16 = 4005;
pub const COLOR_PUSH: u16 = 4010;
pub const COLOR_POP: u16 = 4011;
pub const MSG_APPEND: u16 = 4000;
pub const MSG_FLUSH: u16 = 4001;
pub const FFI_COMPILE: u16 = 4003;
pub const FFI_CALL: u16 = 4004;
pub const ARITH_CHECKED: u16 = 4006;
pub const MSG_CLOSE: u16 = 4007;
pub const MSG_DIMEN: u16 = 4008;
pub const MSG_GLUE: u16 = 4009;
pub const MSG_MUGLUE: u16 = 4014;
pub const ERR_SITE: u16 = 4012;
pub const TRANSCRIPT_NOTICE: u16 = 4013;
pub const DBG_LINE: u16 = 4002;
pub const SCALE_DIMEN: u16 = 4015;
pub const MSG_ROMAN: u16 = 4016;
pub const MSG_REPORT: u16 = 4017;
pub const WRITE_FLUSH: u16 = 4018;
pub const LIST: u16 = 4100;
pub const LIST_SHOWBOX: u16 = 4101;
pub const LIST_SHOWLISTS: u16 = 4102;
pub const OUT_OPEN: u16 = 4200;
pub const OUT_WRITE: u16 = 4201;
pub const OUT_CLOSE: u16 = 4202;
pub const OUT_IS_OPEN: u16 = 4203;
pub const EXPR_STEP: u16 = 4019;
pub const EXPR_END: u16 = 4020;
pub const MSG_TAKE: u16 = 4021;
pub const ARITH_GLUE: u16 = 4022;
pub const ARITH_KEEP: u16 = 4023;
pub const ARITH_SETTLE: u16 = 4024;
}
pub const COUNT_SLOTS: u16 = 256;
pub const DIMEN_BASE: i64 = 256;
pub const SKIP_BASE: i64 = 512;
pub const SKIP_STRIDE: i64 = 4;
pub const MUSKIP_BASE: i64 = SKIP_BASE + 256 * SKIP_STRIDE;
pub struct Compiler {
b: ChunkBuilder,
debug: bool,
line: u32,
strings: rustc_hash::FxHashMap<String, u16>,
}
impl Compiler {
pub fn new() -> Self {
let mut b = ChunkBuilder::new();
b.set_builtin_argc_is_arity(true);
Self {
b,
debug: false,
line: 0,
strings: rustc_hash::FxHashMap::default(),
}
}
pub fn new_debug() -> Self {
Self {
debug: true,
..Self::new()
}
}
pub fn compile(mut self, cmds: &[Cmd]) -> Result<Chunk, TexError> {
for reg in 0..TOTAL_SLOTS {
let initial = crate::params::initial_value(i64::from(reg));
self.b.emit(Op::LoadInt(initial), self.line);
self.b.emit(Op::SetSlot(reg), self.line);
}
self.block(cmds)?;
Ok(self.b.build())
}
fn str_const(&mut self, s: &str) -> Result<u16, TexError> {
if let Some(&k) = self.strings.get(s) {
return Ok(k);
}
let Some(k) = self.b.try_add_constant(Value::Str(s.to_string().into())) else {
return Err(TexError(format!(
"This document has more than {} distinct strings, which is \
every constant a chunk can address",
ChunkBuilder::MAX_POOL
)));
};
self.strings.insert(s.to_string(), k);
Ok(k)
}
fn sub_chunk(&mut self, body: &[Cmd]) -> Result<i64, TexError> {
let mut sub = Compiler {
b: ChunkBuilder::new(),
debug: false,
line: self.line,
strings: rustc_hash::FxHashMap::default(),
};
sub.b.set_builtin_argc_is_arity(true);
sub.block(body)?;
Ok(i64::from(self.b.add_sub_chunk(sub.b.build())))
}
fn block(&mut self, cmds: &[Cmd]) -> Result<(), TexError> {
for c in cmds {
self.cmd(c)?;
}
Ok(())
}
fn cmd(&mut self, c: &Cmd) -> Result<(), TexError> {
match c {
Cmd::Line(n) => {
self.line = *n;
if self.debug {
self.b.emit(Op::CallBuiltin(ops::DBG_LINE, 0), self.line);
self.b.emit(Op::Pop, self.line);
}
}
Cmd::RustCompile(b64) => {
let k = self.str_const(b64)?;
self.b.emit(Op::LoadConst(k), self.line);
self.b.emit(Op::CallBuiltin(ops::FFI_COMPILE, 1), self.line);
self.b.emit(Op::Pop, self.line);
}
Cmd::SetCount(reg, n) => {
self.num(n)?;
self.b.emit(Op::SetSlot(slot(*reg)), self.line);
}
Cmd::Arith(op, reg, n) => {
self.b.emit(Op::GetSlot(slot(*reg)), self.line);
self.num(n)?;
match op {
Arith::Add => {
self.b.emit(Op::Add, self.line);
self.wrap_to_32_bits();
}
Arith::Mul | Arith::Div => {
let scaled = (DIMEN_BASE..i64::from(TOTAL_SLOTS)).contains(reg);
let which = match op {
Arith::Mul if scaled => 2,
Arith::Mul => 0,
_ => 1,
};
self.b.emit(Op::LoadInt(which), self.line);
self.b
.emit(Op::CallBuiltin(ops::ARITH_CHECKED, 3), self.line);
}
}
self.b.emit(Op::SetSlot(slot(*reg)), self.line);
}
Cmd::GlueArith(op, base, n) => {
let which = match op {
Arith::Mul => 2,
Arith::Div => 1,
Arith::Add => {
return Err(TexError("a glue \\advance is not a GlueArith".into()))
}
};
for part in 0..3 {
self.b.emit(Op::GetSlot(slot(base + part)), self.line);
self.num(n)?;
self.b.emit(Op::LoadInt(which), self.line);
self.b.emit(Op::CallBuiltin(ops::ARITH_GLUE, 3), self.line);
}
for part in (0..3).rev() {
self.b.emit(Op::GetSlot(slot(base + part)), self.line);
self.b.emit(Op::CallBuiltin(ops::ARITH_KEEP, 2), self.line);
self.b.emit(Op::SetSlot(slot(base + part)), self.line);
}
self.b
.emit(Op::CallBuiltin(ops::ARITH_SETTLE, 0), self.line);
self.b.emit(Op::Pop, self.line);
}
Cmd::List(op) => self.list_op(op)?,
Cmd::OutputRoutine(body) => {
let k = match body {
Some(body) => self.sub_chunk(body)?,
None => -1,
};
self.list_op(&crate::ir::list::ListOp::OutputRoutine(k))?;
}
Cmd::OutWhatsit { display, body } => {
let chunk = self.sub_chunk(body)?;
self.list_op(&crate::ir::list::ListOp::OutWhatsit {
display: display.clone(),
chunk,
})?;
}
Cmd::Text(t) => {
let k = self.str_const(t)?;
self.b.emit(Op::LoadConst(k), self.line);
self.b.emit(Op::CallBuiltin(ops::TEXT, 1), self.line);
self.b.emit(Op::Pop, self.line);
}
Cmd::FileClose => {
self.b.emit(Op::CallBuiltin(ops::MSG_CLOSE, 0), self.line);
self.b.emit(Op::Pop, self.line);
}
Cmd::ErrorSite(site) => {
let k = self.str_const(site)?;
self.b.emit(Op::LoadConst(k), self.line);
self.b.emit(Op::CallBuiltin(ops::ERR_SITE, 1), self.line);
self.b.emit(Op::Pop, self.line);
}
Cmd::TranscriptNotice { notes, glued } => {
let k = self.str_const(¬es.concat())?;
self.b.emit(Op::LoadConst(k), self.line);
self.b.emit(Op::LoadInt(i64::from(*glued)), self.line);
self.b
.emit(Op::CallBuiltin(ops::TRANSCRIPT_NOTICE, 2), self.line);
self.b.emit(Op::Pop, self.line);
}
Cmd::Color { rgb, body } => {
let (r, g, b) = *rgb;
for v in [r, g, b] {
let k = self.b.add_constant(Value::Str(format!("{v}").into()));
self.b.emit(Op::LoadConst(k), self.line);
}
self.b.emit(Op::CallBuiltin(ops::COLOR_PUSH, 3), self.line);
self.b.emit(Op::Pop, self.line);
self.block(body)?;
self.b.emit(Op::CallBuiltin(ops::COLOR_POP, 0), self.line);
self.b.emit(Op::Pop, self.line);
}
Cmd::Message(msg) => {
self.msg_ops(msg)?;
self.b.emit(Op::CallBuiltin(ops::MSG_FLUSH, 0), self.line);
self.b.emit(Op::Pop, self.line);
}
Cmd::Reports(msg) => self.msg_ops(msg)?,
Cmd::Write(msg) => {
self.msg_ops(msg)?;
self.b.emit(Op::CallBuiltin(ops::WRITE_FLUSH, 0), self.line);
self.b.emit(Op::Pop, self.line);
}
Cmd::OpenOut { stream, name } => {
self.b.emit(Op::LoadInt(*stream as i64), self.line);
let k = self.str_const(name)?;
self.b.emit(Op::LoadConst(k), self.line);
self.b.emit(Op::CallBuiltin(ops::OUT_OPEN, 2), self.line);
self.b.emit(Op::Pop, self.line);
}
Cmd::WriteOut {
stream,
file,
otherwise,
} => {
self.b.emit(Op::LoadInt(*stream as i64), self.line);
self.b.emit(Op::CallBuiltin(ops::OUT_IS_OPEN, 1), self.line);
let to_else = self.b.emit(Op::JumpIfFalse(0), self.line);
self.msg_ops(file)?;
self.b.emit(Op::LoadInt(*stream as i64), self.line);
self.b.emit(Op::CallBuiltin(ops::OUT_WRITE, 1), self.line);
self.b.emit(Op::Pop, self.line);
let over_else = self.b.emit(Op::Jump(0), self.line);
let else_at = self.b.current_pos();
self.b.patch_jump(to_else, else_at);
self.block(otherwise)?;
let end = self.b.current_pos();
self.b.patch_jump(over_else, end);
}
Cmd::Special(parts) => {
let code = crate::ir::list::ListOp::<Num>::Whatsit(String::new()).code();
self.b.emit(Op::LoadInt(code), self.line);
self.msg_ops(parts)?;
self.b.emit(Op::CallBuiltin(ops::MSG_TAKE, 0), self.line);
self.b.emit(Op::CallBuiltin(ops::LIST, 2), self.line);
self.b.emit(Op::Pop, self.line);
}
Cmd::CloseOut(stream) => {
self.b.emit(Op::LoadInt(*stream as i64), self.line);
self.b.emit(Op::CallBuiltin(ops::OUT_CLOSE, 1), self.line);
self.b.emit(Op::Pop, self.line);
}
Cmd::Group { saves, keeps, body } => {
for reg in saves {
self.b.emit(Op::GetSlot(slot(*reg)), self.line);
}
for (reg, scratch) in keeps {
self.b.emit(Op::GetSlot(slot(*reg)), self.line);
self.b.emit(Op::SetSlot(*scratch), self.line);
}
self.block(body)?;
for (reg, scratch) in keeps {
self.b.emit(Op::GetSlot(*scratch), self.line);
self.b.emit(Op::SetSlot(slot(*reg)), self.line);
}
for reg in saves.iter().rev() {
self.b.emit(Op::SetSlot(slot(*reg)), self.line);
}
}
Cmd::KeepGlobal { reg, into } => {
for scratch in into {
self.b.emit(Op::GetSlot(slot(*reg)), self.line);
self.b.emit(Op::SetSlot(*scratch), self.line);
}
}
Cmd::IfNum {
left,
rel,
right,
then_branch,
else_branch,
} => {
self.num(left)?;
self.num(right)?;
self.b.emit(
match rel {
Rel::Less => Op::NumLt,
Rel::Equal => Op::NumEq,
Rel::Greater => Op::NumGt,
},
self.line,
);
self.branch(then_branch, else_branch)?;
}
Cmd::Loop {
body,
left,
rel,
right,
} => {
let start = self.b.current_pos();
self.block(body)?;
self.num(left)?;
self.num(right)?;
self.b.emit(
match rel {
Rel::Less => Op::NumLt,
Rel::Equal => Op::NumEq,
Rel::Greater => Op::NumGt,
},
self.line,
);
let back = self.b.emit(Op::JumpIfTrue(0), self.line);
self.b.patch_jump(back, start);
}
Cmd::IfOdd {
value,
then_branch,
else_branch,
} => {
self.num(value)?;
self.b.emit(Op::LoadInt(2), self.line);
self.b.emit(Op::Mod, self.line);
self.b.emit(Op::LoadInt(0), self.line);
self.b.emit(Op::NumEq, self.line);
self.b.emit(Op::LogNot, self.line);
self.branch(then_branch, else_branch)?;
}
}
Ok(())
}
fn list_op(&mut self, op: &crate::ir::list::ListOp) -> Result<(), TexError> {
use crate::ir::list::Arg;
self.b.emit(Op::LoadInt(op.code()), self.line);
let mut args: Vec<Arg<'_, Num>> = Vec::new();
op.visit(&mut |a| args.push(a));
let argc = u8::try_from(args.len() + 1)
.map_err(|_| TexError(format!("a list action with {} arguments", args.len())))?;
for a in args {
match a {
Arg::Num(n) => self.num(n)?,
Arg::Int(v) => {
self.b.emit(Op::LoadInt(v), self.line);
}
Arg::Str(s) => {
let k = self.str_const(s)?;
self.b.emit(Op::LoadConst(k), self.line);
}
}
}
self.b.emit(Op::CallBuiltin(ops::LIST, argc), self.line);
self.b.emit(Op::Pop, self.line);
Ok(())
}
fn wrap_to_32_bits(&mut self) {
const SIGN_BIT: i64 = 1 << 31;
const MASK: i64 = 0xFFFF_FFFF;
self.b.emit(Op::LoadInt(SIGN_BIT), self.line);
self.b.emit(Op::Add, self.line);
self.b.emit(Op::LoadInt(MASK), self.line);
self.b.emit(Op::BitAnd, self.line);
self.b.emit(Op::LoadInt(SIGN_BIT), self.line);
self.b.emit(Op::Sub, self.line);
}
fn msg_ops(&mut self, msg: &[MsgOp]) -> Result<(), TexError> {
for m in msg {
match m {
MsgOp::Text(t) => {
let k = self.str_const(t)?;
self.b.emit(Op::LoadConst(k), self.line);
self.b.emit(Op::CallBuiltin(ops::MSG_APPEND, 1), self.line);
self.b.emit(Op::Pop, self.line);
}
MsgOp::Report(t) => {
let k = self.str_const(t)?;
self.b.emit(Op::LoadConst(k), self.line);
self.b.emit(Op::CallBuiltin(ops::MSG_REPORT, 1), self.line);
self.b.emit(Op::Pop, self.line);
}
MsgOp::ShowBox(n) => {
self.b.emit(Op::LoadInt(i64::from(*n)), self.line);
self.b
.emit(Op::CallBuiltin(ops::LIST_SHOWBOX, 1), self.line);
self.b.emit(Op::Pop, self.line);
}
MsgOp::ShowLists => {
self.b
.emit(Op::CallBuiltin(ops::LIST_SHOWLISTS, 0), self.line);
self.b.emit(Op::Pop, self.line);
}
MsgOp::Discard(n) => {
self.num(n)?;
self.b.emit(Op::Pop, self.line);
}
MsgOp::Number(n) => {
self.num(n)?;
self.b.emit(Op::CallBuiltin(ops::MSG_APPEND, 1), self.line);
self.b.emit(Op::Pop, self.line);
}
MsgOp::Glue(parts) => {
for n in parts.iter() {
self.num(n)?;
}
self.b.emit(Op::CallBuiltin(ops::MSG_GLUE, 4), self.line);
self.b.emit(Op::Pop, self.line);
}
MsgOp::MuGlue(parts) => {
for n in parts.iter() {
self.num(n)?;
}
self.b.emit(Op::CallBuiltin(ops::MSG_MUGLUE, 4), self.line);
self.b.emit(Op::Pop, self.line);
}
MsgOp::Dimen(n) => {
self.num(n)?;
self.b.emit(Op::CallBuiltin(ops::MSG_DIMEN, 1), self.line);
self.b.emit(Op::Pop, self.line);
}
MsgOp::Roman(n) => {
self.num(n)?;
self.b.emit(Op::CallBuiltin(ops::MSG_ROMAN, 1), self.line);
self.b.emit(Op::Pop, self.line);
}
MsgOp::If {
left,
rel,
right,
then_ops,
else_ops,
} => {
self.num(left)?;
self.num(right)?;
self.b.emit(
match rel {
Rel::Less => Op::NumLt,
Rel::Equal => Op::NumEq,
Rel::Greater => Op::NumGt,
},
self.line,
);
self.msg_branch(then_ops, else_ops)?;
}
MsgOp::IfOdd {
value,
then_ops,
else_ops,
} => {
self.num(value)?;
self.b.emit(Op::LoadInt(2), self.line);
self.b.emit(Op::Mod, self.line);
self.b.emit(Op::LoadInt(0), self.line);
self.b.emit(Op::NumEq, self.line);
self.b.emit(Op::LogNot, self.line);
self.msg_branch(then_ops, else_ops)?;
}
}
}
Ok(())
}
fn msg_branch(&mut self, then_ops: &[MsgOp], else_ops: &[MsgOp]) -> Result<(), TexError> {
let to_else = self.b.emit(Op::JumpIfFalse(0), self.line);
self.msg_ops(then_ops)?;
let over = self.b.emit(Op::Jump(0), self.line);
let at = self.b.current_pos();
self.b.patch_jump(to_else, at);
self.msg_ops(else_ops)?;
let end = self.b.current_pos();
self.b.patch_jump(over, end);
Ok(())
}
fn branch(&mut self, then_branch: &[Cmd], else_branch: &[Cmd]) -> Result<(), TexError> {
let to_else = self.b.emit(Op::JumpIfFalse(0), self.line);
self.block(then_branch)?;
let over_else = self.b.emit(Op::Jump(0), self.line);
let else_at = self.b.current_pos();
self.b.patch_jump(to_else, else_at);
self.block(else_branch)?;
let end = self.b.current_pos();
self.b.patch_jump(over_else, end);
Ok(())
}
fn num(&mut self, n: &Num) -> Result<(), TexError> {
match n {
Num::Literal(v) => {
self.b.emit(Op::LoadInt(*v), self.line);
}
Num::Count(reg) => {
self.b.emit(Op::GetSlot(slot(*reg)), self.line);
}
Num::Neg(reg) => {
self.b.emit(Op::LoadInt(0), self.line);
self.b.emit(Op::GetSlot(slot(*reg)), self.line);
self.b.emit(Op::Sub, self.line);
}
Num::Scaled { int, frac, reg } => {
self.b.emit(Op::GetSlot(slot(*reg)), self.line);
self.b.emit(Op::LoadInt(*int), self.line);
self.b.emit(Op::LoadInt(*frac), self.line);
self.b.emit(Op::CallBuiltin(ops::SCALE_DIMEN, 3), self.line);
}
Num::ByCount { factor, sign, unit } => {
self.num(unit)?;
self.b.emit(Op::GetSlot(slot(*factor)), self.line);
if *sign < 0 {
self.b.emit(Op::LoadInt(-1), self.line);
self.b.emit(Op::LoadInt(0), self.line);
self.b
.emit(Op::CallBuiltin(ops::ARITH_CHECKED, 3), self.line);
}
self.b.emit(Op::LoadInt(0), self.line);
self.b.emit(Op::CallBuiltin(ops::SCALE_DIMEN, 3), self.line);
}
Num::Expr { op, max, args } => {
for a in args {
self.num(a)?;
}
self.b.emit(Op::LoadInt(op.code()), self.line);
self.b.emit(Op::LoadInt(*max), self.line);
let argc = u8::try_from(args.len() + 2).unwrap_or(u8::MAX);
self.b
.emit(Op::CallBuiltin(ops::EXPR_STEP, argc), self.line);
}
Num::ExprEnd { value, report } => {
self.num(value)?;
let k = self.str_const(report)?;
self.b.emit(Op::LoadConst(k), self.line);
self.b.emit(Op::CallBuiltin(ops::EXPR_END, 2), self.line);
}
Num::Rust { name, args } => {
let k = self.str_const(name)?;
self.b.emit(Op::LoadConst(k), self.line);
for a in args {
self.num(a)?;
}
let argc = u8::try_from(args.len() + 1).unwrap_or(u8::MAX);
self.b.emit(Op::CallBuiltin(ops::FFI_CALL, argc), self.line);
}
}
Ok(())
}
}
fn slot(reg: i64) -> u16 {
u16::try_from(reg).unwrap_or(0).min(TOTAL_SLOTS - 1)
}
pub const TOTAL_SLOTS: u16 = HIGH_END as u16;
pub const DIMPAR_BASE: i64 = MUSKIP_BASE + 256 * SKIP_STRIDE;
pub const GLUEPAR_BASE: i64 = DIMPAR_BASE + crate::params::DIMEN_NAMES.len() as i64;
pub const MUGLUEPAR_BASE: i64 = GLUEPAR_BASE + crate::params::ORDINARY_GLUE as i64 * SKIP_STRIDE;
const MUGLUEPAR_END: i64 = MUGLUEPAR_BASE
+ (crate::params::GLUE_NAMES.len() - crate::params::ORDINARY_GLUE) as i64 * SKIP_STRIDE;
pub const LUAGLUEPAR_BASE: i64 = LUADIMPAR_BASE + crate::params::LUATEX_DIMEN_NAMES.len() as i64;
const LUAGLUEPAR_END: i64 =
LUAGLUEPAR_BASE + crate::params::LUATEX_GLUE_NAMES.len() as i64 * SKIP_STRIDE;
pub const BOXDIM_BASE: i64 = MUGLUEPAR_END;
pub const BOXKIND_BASE: i64 = BOXDIM_BASE + 3 * 256;
pub const INTERNAL_BASE: i64 = BOXKIND_BASE + 256;
const STOMACH_END: i64 = INTERNAL_BASE + crate::stomach::INTERNAL_SLOTS;
pub const LUADIMPAR_BASE: i64 = STOMACH_END;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum RegFile {
Count,
Dimen,
Skip,
MuSkip,
}
impl RegFile {
pub fn of_name(name: &str) -> Option<RegFile> {
match name {
"count" => Some(RegFile::Count),
"dimen" => Some(RegFile::Dimen),
"skip" => Some(RegFile::Skip),
"muskip" => Some(RegFile::MuSkip),
_ => None,
}
}
pub fn name(self) -> &'static str {
match self {
RegFile::Count => "count",
RegFile::Dimen => "dimen",
RegFile::Skip => "skip",
RegFile::MuSkip => "muskip",
}
}
pub fn stride(self) -> i64 {
match self {
RegFile::Count | RegFile::Dimen => 1,
RegFile::Skip | RegFile::MuSkip => SKIP_STRIDE,
}
}
pub fn low_base(self) -> i64 {
match self {
RegFile::Count => 0,
RegFile::Dimen => DIMEN_BASE,
RegFile::Skip => SKIP_BASE,
RegFile::MuSkip => MUSKIP_BASE,
}
}
pub fn high_pool(self) -> (i64, i64) {
match self {
RegFile::Count => (HIGH_COUNT_BASE, HIGH_COUNTS),
RegFile::Dimen => (HIGH_DIMEN_BASE, HIGH_DIMENS),
RegFile::Skip => (HIGH_SKIP_BASE, HIGH_SKIPS),
RegFile::MuSkip => (HIGH_MUSKIP_BASE, HIGH_MUSKIPS),
}
}
}
pub const HIGH_COUNT_BASE: i64 = LUAGLUEPAR_END;
pub const HIGH_COUNTS: i64 = 2048;
pub const HIGH_DIMEN_BASE: i64 = HIGH_COUNT_BASE + HIGH_COUNTS;
pub const HIGH_DIMENS: i64 = 1024;
pub const HIGH_SKIP_BASE: i64 = HIGH_DIMEN_BASE + HIGH_DIMENS;
pub const HIGH_SKIPS: i64 = 512;
pub const HIGH_MUSKIP_BASE: i64 = HIGH_SKIP_BASE + HIGH_SKIPS * SKIP_STRIDE;
pub const HIGH_MUSKIPS: i64 = 128;
const HIGH_END: i64 = HIGH_MUSKIP_BASE + HIGH_MUSKIPS * SKIP_STRIDE;
pub fn is_count_slot(slot: i64) -> bool {
(0..DIMEN_BASE).contains(&slot) || (HIGH_COUNT_BASE..HIGH_DIMEN_BASE).contains(&slot)
}
pub fn is_stomach_slot(slot: i64) -> bool {
(BOXDIM_BASE..STOMACH_END).contains(&slot)
}
pub fn is_glue_slot(slot: i64) -> bool {
(SKIP_BASE..DIMPAR_BASE).contains(&slot)
|| (GLUEPAR_BASE..MUGLUEPAR_END).contains(&slot)
|| (LUAGLUEPAR_BASE..LUAGLUEPAR_END).contains(&slot)
|| (HIGH_SKIP_BASE..HIGH_END).contains(&slot)
}
pub fn is_mu_slot(slot: i64) -> bool {
(MUSKIP_BASE..DIMPAR_BASE).contains(&slot)
|| (MUGLUEPAR_BASE..MUGLUEPAR_END).contains(&slot)
|| (HIGH_MUSKIP_BASE..HIGH_END).contains(&slot)
}
impl Default for Compiler {
fn default() -> Self {
Self::new()
}
}