bendns' repos / mindus
mindustry logic execution, map- and schematic- parsing and rendering
Diffstat (limited to 'lemu/src/executor/builder.rs')
-rw-r--r--lemu/src/executor/builder.rs159
1 files changed, 0 insertions, 159 deletions
diff --git a/lemu/src/executor/builder.rs b/lemu/src/executor/builder.rs
deleted file mode 100644
index 83bec1e..0000000
--- a/lemu/src/executor/builder.rs
+++ /dev/null
@@ -1,159 +0,0 @@
-use fimg::Image;
-use std::{collections::VecDeque, io::Write as Wr};
-
-use super::{
- BANK_SIZE, CELL_SIZE, Display, DisplayState, Drawing, Executor, ExecutorContext, Instruction,
- Limit, Memory, PInstr, UPInstr,
-};
-use crate::{
- code::Code,
- debug::info::DebugInfo,
- instructions::{DrawInstr, Instr},
- lexer::Token,
- memory::{LRegistry, LVar},
-};
-
-/// for internal use by [parser](crate::parser) only
-pub struct ExecutorBuilderInternal<'v, W: Wr> {
- displays: Box<[(Image<Vec<u8>, 4>, DisplayState)]>,
- pub(crate) program: Vec<UPInstr<'v>>,
- output: Option<W>,
- banks: Vec<f64>,
- cells: Vec<f64>,
- iteration_limit: Limit,
- instruction_limit: Limit,
- pub(crate) mem: Vec<LVar<'v>>,
- pub(crate) debug_info: DebugInfo<'v>,
-}
-
-impl<'s, W: Wr> ExecutorBuilderInternal<'s, W> {
- pub(crate) fn new(w: Option<W>, d: Vec<Image<Vec<u8>, 4>>) -> Self {
- Self {
- output: w,
- displays: d
- .into_iter()
- .map(|d| (d, DisplayState::default()))
- .collect(),
- program: vec![],
- banks: vec![],
- cells: vec![],
- iteration_limit: Limit::limited(1),
- instruction_limit: Limit::Unlimited,
- mem: Vec::with_capacity(64),
- debug_info: DebugInfo::default(),
- }
- }
-
- pub(crate) fn inslimit(&mut self, ilimit: Limit) -> &mut Self {
- self.instruction_limit = ilimit;
- self
- }
-
- pub(crate) fn itrlimit(&mut self, ilimit: Limit) -> &mut Self {
- self.iteration_limit = ilimit;
- self
- }
-
- pub(crate) fn jmp(&mut self) {
- self.program.push(UPInstr::UnfinishedJump);
- }
-
- pub(crate) fn code(&mut self, v: Box<[Token<'s>]>) {
- self.program.push(UPInstr::Code(v));
- }
-
- pub(crate) fn bank(&mut self, n: usize) -> Memory {
- assert!(n != 0);
- if n * BANK_SIZE > self.banks.len() {
- self.banks.resize(n * BANK_SIZE, 0.0);
- println!("resized");
- }
- Memory::Bank(((self.banks.len() - BANK_SIZE) / BANK_SIZE) as u8)
- }
-
- pub(crate) fn cell(&mut self, n: usize) -> Memory {
- assert!(n != 0);
- if n * CELL_SIZE > self.cells.len() {
- self.cells.resize(n * CELL_SIZE, 0.0);
- }
- Memory::Cell(((self.cells.len() - CELL_SIZE) / CELL_SIZE) as u8)
- }
-
- pub(crate) fn next(&self) -> Instruction {
- Instruction(self.program.len())
- }
-
- pub(crate) fn last(&self) -> Instruction {
- Instruction(self.program.len() - 1)
- }
-
- pub(crate) fn add(&mut self, i: impl Into<Instr>) {
- self.program.push(UPInstr::Instr(i.into()));
- }
-
- pub(crate) fn draw(&mut self, i: impl Into<DrawInstr>) {
- self.program.push(UPInstr::Draw(i.into()));
- }
-
- pub(crate) fn valid(&self, Instruction(i): Instruction) -> bool {
- self.program.len() > i
- }
-
- pub(crate) fn display(&mut self, n: usize) -> Result<Display, usize> {
- self.displays
- .get(n.checked_sub(1).ok_or(n)?)
- .map(|_| Display(n - 1))
- .ok_or(n)
- }
-
- pub(crate) fn finish(self) -> Executor<'s, W> {
- fn cst<const N: usize>(a: Vec<f64>) -> Box<[[f64; N]]> {
- let len = a.len();
- let ptr: *mut [f64] = Box::into_raw(a.into());
- let ptr: *mut [[f64; N]] =
- core::ptr::slice_from_raw_parts_mut(ptr.cast::<[f64; N]>(), len / N);
- unsafe { Box::from_raw(ptr) }
- }
- let program = Code::new(
- self.program
- .into_iter()
- .map(|v| match v {
- UPInstr::Instr(i) => PInstr::Instr(i),
- UPInstr::Draw(i) => PInstr::Draw(i),
- UPInstr::Comment(c) => PInstr::Comment(c),
- UPInstr::UnfinishedJump => panic!("all jumps should have finished"),
- UPInstr::Code(c) => PInstr::Code(c),
- })
- .collect::<Box<[PInstr]>>(),
- );
- let Self {
- instruction_limit,
- iteration_limit,
- displays,
- output,
- banks,
- debug_info,
- cells,
- mem,
- ..
- } = self;
- Executor {
- instruction_limit,
- iteration_limit,
- inner: ExecutorContext {
- cells: cst::<CELL_SIZE>(cells),
- banks: cst::<BANK_SIZE>(banks),
- memory: LRegistry(mem.into()),
- iterations: 0,
- display: Drawing {
- displays,
- buffer: VecDeque::new(),
- },
- output,
- },
- instructions_ran: 0,
- debug_info,
- program,
- }
- }
-}