-//! crate for [MLOG](https://mindustrygame.github.io/wiki/logic/0-introduction/#what-is-mindustry-logic) emulation.

-#![allow(clippy::redundant_closure_call)]

-// yeah so like well you see i kinda well kinda have to yes but sorta

-#![allow(clippy::fn_address_comparisons)]

-#![feature(generic_const_exprs, iter_array_chunks)]

-#![warn(

- clippy::multiple_unsafe_ops_per_block,

- clippy::missing_const_for_fn,

- clippy::redundant_pub_crate,

- clippy::missing_safety_doc,

- clippy::imprecise_flops,

- unsafe_op_in_unsafe_fn,

- clippy::dbg_macro,

- missing_docs

-)]

-pub(crate) mod code;

-mod debug;

-mod executor;

-mod instructions;

-mod lexer;

-mod memory;

-mod parser;

-

-use std::io::Write;

-

-pub use executor::{Executor, Output};

-use executor::{ExecutorBuilderInternal, Limit};

-use fimg::Image;

-pub use parser::Error;

-

-impl<W: Write + Default> Executor<'_, W> {

- /// Create a new [`ExecutorBuilder`]

- pub fn build() -> ExecutorBuilder<W> {

- ExecutorBuilder::default()

- }

-}

-impl<W: Write> Executor<'_, W> {

- /// Create a new [`ExecutorBuilder`] with a output.

- ///

- /// Output simply must impement [`Write`], so this can be set to stdout.

- /// Or simply set it to [`Vec<u8>`].

- pub fn with_output(w: W) -> ExecutorBuilder<W> {

- ExecutorBuilder {

- displays: Vec::new(),

- output: Some(w),

- instruction_limit: Limit::Unlimited,

- iteration_limit: Limit::limited(1),

- }

- }

-}

-

-/// Builder for a [`Executor`].

-/// ```

-/// # use lemu::Executor;

-/// let mut lex = Executor::with_output(std::io::stdout()).program(r#"print "hello world""#).expect("program ok");

-/// lex.run();

-/// ```

-pub struct ExecutorBuilder<W: Write> {

- output: Option<W>,

- displays: Vec<Image<Vec<u8>, 4>>,

- instruction_limit: Limit,

- iteration_limit: Limit,

-}

-

-impl<W: Write> Default for ExecutorBuilder<W> {

- fn default() -> Self {

- Self {

- output: None,

- displays: Vec::new(),

- instruction_limit: Limit::Unlimited,

- iteration_limit: Limit::limited(1),

- }

- }

-}

-

-impl<W: Write> ExecutorBuilder<W> {

- /// Limit the number of iterations.

- pub fn limit_iterations(self, n: usize) -> Self {

- Self {

- iteration_limit: Limit::limited(n),

- ..self

- }

- }

-

- /// Unlimit the number of iterations.

- pub fn unlimit_iterations(self) -> Self {

- Self {

- iteration_limit: Limit::Unlimited,

- ..self

- }

- }

-

- /// Unlimit the number of instructions.

- /// Make sure to limit the number of the iterations, else it will possibly run forever.

- pub fn unlimit_instructions(self) -> Self {

- Self {

- iteration_limit: Limit::Unlimited,

- ..self

- }

- }

-

- /// Limit the number of processed instructions.

- ///

- /// Use this if you want it to *definetly finish*.

- pub fn limit_instructions(self, n: usize) -> Self {

- Self {

- instruction_limit: Limit::limited(n),

- ..self

- }

- }

-

- /// Add a small (`80x80`) logic display.

- pub fn display(self) -> Self {

- let mut d = self.displays;

- d.push(Image::alloc(80, 80));

- Self {

- displays: d,

- ..self

- }

- }

-

- /// Add a large (`176x176`) logic display.

- pub fn large_display(self) -> Self {

- let mut d = self.displays;

- d.push(Image::alloc(176, 176));

- Self {

- displays: d,

- ..self

- }

- }

-

- /// Build the [`Executor`] with this code.

- ///

- /// # Errors

- ///

- /// errors if the code is malformed.

- pub fn program(self, program: &str) -> Result<Executor<'_, W>, Error<'_>> {

- let Self {

- output,

- displays,

- instruction_limit,

- iteration_limit,

- } = self;

- let mut executor = ExecutorBuilderInternal::new(output, displays);

- executor

- .inslimit(instruction_limit)

- .itrlimit(iteration_limit);

- // #[cfg(debug_assertions)]

- // lexer::print_stream(lexer::lex(program));

- parser::parse(lexer::lex(program), &mut executor)?;

- Ok(executor.finish())

- }

-}

-

-#[cfg(test)]

-mod test {

- use super::*;

-

- macro_rules! test {

- (run $fn:ident.mlog $($times:literal times)?;

- $(output = $to_be:literal $(;)?)?

- $(cell[$cell_n:literal][$cell_index:literal] = $what:literal $(;)?)?

- ) => {

- #[test]

- fn $fn() -> Result<(), Error<'static>> {

- let v = vec![];

- let mut lex = Executor::with_output(v)

- .unlimit_instructions()

- $(.limit_iterations($times))?

- .program(include_str!(concat!(stringify!($fn), ".mlog")))?;

- lex.run();

- let output = lex.output();

- $(assert_eq!(output.output.unwrap(), $to_be);)?

- $(assert_eq!(output.cells[$cell_n][$cell_index], $what);)?

- Ok(())

- }

- };

- }

-

- test!(run fib.mlog; output = b"12586269025");

- test!(run primes.mlog; output = b"2 | 3 | 5 | 7 | 11 | 13 | 17 | 19 | 23 | 29 | 31 | 37 | 41 | 43 | 47 | 53 | 59 | 61 | 67 | 71 | 73 | 79 | 83 | 89 | 97 | 101 | 103 | 107 | 109 | 113 | 127 | 131 | 137 | 139 | 149 | 151 | 157 | 163 | 167 | 173 | 179 | 181 | 191 | 193 | 197 | 199 | 211 | 223 | 227 | 229 | 233 | 239 | 241 | 251 | 257 | 263 | 269 | 271 | 277 | 281 | 283 | 293 | 307 | 311 | 313 | 317 | 331 | 337 | 347 | 349 | 353 | 359 | 367 | 373 | 379 | 383 | 389 | 397 | 401 | 409 | 419 | 421 | 431 | 433 | 439 | 443 | 449 | 457 | 461 | 463 | 467 | 479 | 487 | 491 | 499 | 503 | 509 | ");

- test!(run numbers.mlog; output = b"121212");

- test!(run celliterate.mlog 5 times; cell[0][0] = 5.0);

- test!(run hello.mlog; output = b"hello world");

-}