#[derive(Debug)]

pub enum PInstr<'s> {

Code(Box<[Token<'s>]>),

Comment(&'s str),

}

cells: Vec<f64>,

iteration_limit: Limit,

instruction_limit: Limit,

}

impl<'s, W: Wr> ExecutorBuilderInternal<'s, W> {

cells: vec![],

iteration_limit: Limit::limited(1),

instruction_limit: Limit::Unlimited,

}

}

Instruction(self.program.len() - 1)

}

self.program.push(UPInstr::Instr(i.into()));

}

self.program.push(UPInstr::Draw(i.into()));

}

inner: ExecutorContext {

cells: cst::<CELL_SIZE>(cells),

banks: cst::<BANK_SIZE>(banks),

counter: 0,

iterations: 0,

display: Drawing {

pub instructions_ran: usize,

}

pub enum UPInstr<'s> {

UnfinishedJump,

Code(Box<[Token<'s>]>),

Comment(&'s str),

}

pub displays: Box<[fimg::Image<Vec<u8>, 4>]>,

/// points to `Executor.program`

}

self.buffer.push_back(i);

}

}

// maximum of 128 elements, so can use ~60KB

pub cells: Box<[[f64; CELL_SIZE]]>, // screw world cells

// maximum of 127 elements, so can use ~500KB

pub banks: Box<[[f64; BANK_SIZE]]>,

pub counter: usize,

pub output: Option<W>,

/// Counter for the number of iterations we have run so far.

pub iterations: usize,

}

}

}

}

pub fn jump(&mut self, Instruction(n): Instruction) {

self.counter = n;

}

}

}

// SAFETY: yee

match unsafe { self.program.get_unchecked(self.inner.counter) } {

PInstr::Instr(i) => {

i.run(&mut self.inner)

}

PInstr::Draw(i) => {

if self.inner.counter >= self.program.len() {

self.inner.counter = 0;

self.inner.iterations += 1;

}

}

}

];

#[enum_dispatch]

&self,

mem: &mut LRegistry<'v>,

image: &mut Image<&mut [u8], 4>,

);

}

#[enum_dispatch(DrawInstruction)]

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

match self {

Self::Line(i) => write!(f, "{i}"),

}

}

}

macro_rules! u8 {

($v:ident) => {

LVar::Num(n) => n.round() as u8,

_ => return,

}

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

write!(f, "draw clear {} {} {}", self.r, self.g, self.b)

}

}

macro_rules! u8 {

($v:ident) => {

LVar::Num(n) => n.round() as u8,

_ => return,

}

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

write!(f, "draw color {} {} {} {}", self.r, self.g, self.b, self.a)

}

}

}

state.stroke = n;

}

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

write!(f, "draw stroke {}", self.size)

}

}

#[rustfmt::skip]

macro_rules! point {

($mem:ident@$point:expr) => {{

(a,b)

}}

}

($fn(a), $fn(b))

}};

}

}

&self,

mem: &mut LRegistry<'v>,

image: &mut Image<&mut [u8], 4>,

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

write!(

f,

}

}

}

&self,

mem: &mut LRegistry<'v>,

image: &mut Image<&mut [u8], 4>,

state: &mut DisplayState,

) {

let pos = map!(point!([email protected]), |n| n as u32);

image.filled_box(pos, width, height, state.col());

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

write!(

f,

}

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

write!(

f,

}

}

&self,

mem: &mut LRegistry<'v>,

image: &mut Image<&mut [u8], 4>,

state: &mut DisplayState,

) {

let pos = map!(point!([email protected]), |n| n as u32);

image.stroked_box(pos, width, height, state.stroke.round() as u32, state.col());

}

}

}

let to32 = |n| n as f32;

let (a, b, c) = (

map!(point!([email protected]), to32),

i.tri(a, b, c, state.col());

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

write!(

f,

}

}

}

&self,

mem: &mut LRegistry<'v>,

image: &mut Image<&mut [u8], 4>,

state: &mut DisplayState,

) {

if sides < 90 {

image.poly(

map!(point!([email protected]), |n| n as f32),

sides,

state.col(),

);

} else {

image.circle(

map!(point!([email protected]), |n: f64| n.round() as i32),

state.col(),

);

}

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

write!(

f,

}

}

}

&self,

mem: &mut LRegistry<'v>,

image: &mut Image<&mut [u8], 4>,

state: &mut DisplayState,

) {

if sides < 90 {

image.border_poly(

map!(point!([email protected]), |n| n as f32),

sides,

state.stroke as f32,

state.col(),

);

} else {

image.border_circle(

map!(point!([email protected]), |n: f64| n.round() as i32),

state.col(),

);

}

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

write!(

f,

}

}

pub struct Flush {

pub(crate) display: Display,

}

fn run<W: std::io::Write>(&self, exec: &mut ExecutorContext<'_, W>) -> Flow {

exec.flush(self.display);

Flow::Continue

impl Disp for Flush {

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

}

}

io::Write as Wr,

};

pub(crate) container: Memory,

}

if let Some(&n) = exec.mem(self.container).get(i) {

};

Flow::Continue

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

write!(f, "read {} {} {}", self.output, self.container, self.index)

}

}

pub(crate) container: Memory,

}

if let Some(a) = exec.mem(self.container).get_mut(i) {

*a = b;

}

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

write!(f, "write {} {} {}", self.set, self.container, self.index)

}

}

}

fn run<W: Wr>(&self, exec: &mut ExecutorContext<'_, W>) -> Flow {

if let Some(o) = &mut exec.output {

match v {

LVar::Num(n) => write!(o, "{n}"),

Flow::Continue

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

write!(f, "print {}", self.val)

}

use super::{

executor::{ExecutorContext, Instruction},

memory::{LAddress, LVar},

};

}

#[enum_dispatch]

}

#[enum_dispatch(LInstruction)]

DrawFlush(draw::Flush),

Stop(Stop),

End(End),

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

match self {

Self::Op2(i) => write!(f, "{i}"),

}

}

}

Flow::Continue

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

write!(f, "set {} {}", self.from, self.to)

}

}

use get_num;

}

Self {

op: op.get_fn(),

x,

out,

}

}

Flow::Continue

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

}

}

}

Self {

op: op.get_fn(),

a,

b,

}

}

Flow::Continue

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

}

}

pub struct End {}

fn run<W: Write>(&self, exec: &mut ExecutorContext<'_, W>) -> Flow {

exec.iterations += 1;

// SAFETY: if we exist, 0 exists.

unsafe { exec.jump(Instruction::new(0)) };

}

}

pub(crate) to: Instruction,

}

fn run<W: Write>(&self, exec: &mut ExecutorContext<'_, W>) -> Flow {

exec.jump(self.to);

Flow::Stay

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

}

}

pub(crate) to: Instruction,

}

Self {

op: op.get_fn(),

to,

a,

b,

}

}

exec.jump(self.to);

Flow::Stay

} else {

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

}

}

pub proglen: usize,

}

let i = n.round() as usize;

if i < self.proglen {

// SAFETY: just checked bounds

}

}

fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

write!(f, "set @counter {}", self.to)

}

}

pub struct Stop {}

fn run<W: Write>(&self, _: &mut ExecutorContext<'_, W>) -> Flow {

Flow::Exit

}

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

#![allow(clippy::redundant_closure_call)]

#![warn(

clippy::multiple_unsafe_ops_per_block,

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 hello.mlog; output = b"hello world");

}

}

}

impl LVar<'_> {

// get null

pub const fn null() -> LVar<'static> {

}

}

}

}

}

_priv: (),

}

fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

}

}

fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

}

}

}

/// cleared every loop

}

}

}

}

}

}

}

/// .display();

/// ```

NoDisplay(usize, Span),

}

impl Error<'_> {

write!(out, ", {}", op).unwrap();

}

out.write_char('}').unwrap();

e.note(cmt!("{help}: you may have meant {bold_green}{mat}{reset}"));

}

out

}

match self {

Self::UnexpectedEof => {

Self::ExpectedOp(t, s) => {

msg!("{error}: expected operator")

.label((s, cmt!("this was supposed to be a {bold_blue}operator{reset} (eg. {magenta}equal{reset})")));

e.note(cmt!("{help}: maybe you meant {bold_green}{mat}{reset}"));

}

}

Self::ExpectedInstr(t, s) => {

msg!("{error}: expected instruction")

.label((s, cmt!("this was supposed to be a {bold_blue}instruction{reset} (eg. {magenta}print{reset})")));

e.note(cmt!("{help}: maybe you meant {mat}"));

}

}

msg!("{error}: {bold_red}index{reset} {} out of bounds", index)

.label((s, cmt!("memory has only {magenta}{size}{reset} elements")));

}

};

e

}

use tokstr;

#[derive(Debug)]

Sometimes {

op: ConditionOp,

},

Always,

mut tokens: Lexer<'source>,

executor: &mut ExecutorBuilderInternal<'source, W>,

) -> Result<(), Error<'source>> {

// maps "start" to 0

let mut labels = Vec::new();

let mut unfinished_jumps = Vec::new();

return Err(Error::$e($($stuff,)+ tokens.span()))

};

}

macro_rules! nextline {

() => {

while let Some(tok) = tokens.next() && tok != Token::Newline { }

}

}};

}

macro_rules! take_ident {

($tok:expr) => {{

let tok = $tok;

($tok:expr) => {{

let tok = $tok;

if let Some(i) = tokstr!(tok) {

} else {

match tok {

t => Err(err!(ExpectedVar(t))),

}

}

($tok:expr) => {{

let tok = $tok;

if let Some(i) = tokstr!(tok) {

} else {

match tok {

t => Err(err!(ExpectedNum(t))),

}

}

let to = take_numvar!(tok!()?)?;

executor.add(DynJump { to, proglen: 0 });

} else {

let to = take_var!(tok!()?)?;

executor.add(Set { from, to });

}

let to = unsafe { Instruction::new(n) };

let op = tok!()?;

if op == Token::Always {

} else {

let op = op.try_into().map_err(|op| err!(ExpectedOp(op)))?;

let a = take_var!(tok!()?)?;

let b = take_var!(tok!()?)?;

}

} else {

yeet!(ExpectedJump(tok));

let set = take_numvar!(tok!()?)?;

let container = take_memory!();

let index = take_numvar!(tok!()?)?;

yeet!(IndexOutOfBounds(v.round() as usize, container.size()));

}

executor.add(Write {

let output = take_var!(tok!()?)?;

let container = take_memory!();

let index = take_numvar!(tok!()?)?;

yeet!(IndexOutOfBounds(v.round() as usize, container.size()));

}

executor.add(Read {

let g = col & 0x00ff_0000 >> 16;

let b = col & 0x0000_ff00 >> 8;

let a = col & 0x0000_00ff;

}

"stroke" => {

let size = take_numvar!(tok!()?)?;

}

Token::DrawFlush => {

let t = tok!();

let screen = take_ident!(t.clone())?;

let mut out = String::new();

for ch in screen.chars() {

yeet!(InvalidDisplayType(screen));

}

let n_span = tokens.span().start + screen.len()..tokens.span().end;

let display = executor

.display(screen_n)

.map_err(|n| Error::NoDisplay(n, n_span))?;

"effect" => {

let mut v = Vec::with_capacity(6);

v.push(Token::Ident("effect"));

v.push(tok);

}

executor.code(v.into_boxed_slice());

.ok_or_else(|| Error::LabelNotFound(label, s))?

.1;

executor.program[i.get()] = UPInstr::Instr(match j {

});

}

}

}

Ok(())

}