Struct BrainfuckReader 

pub struct BrainfuckReader { /* private fields */ }

A simple Brainfuck interpreter.

The interpreter maintains:

• the program codes as a String,
• a customizable capacity memory tape initialized to zeros (30,000 cells by default),
• a data pointer indexing into that tape.

Implementations

impl BrainfuckReader

pub fn new(code: String) -> Self

Create a new interpreter from Brainfuck code.

The memory tape is initialized to 30,000 zeroed cells.

pub fn new_with_memory(code: String, memory_size: usize) -> Self

Create a new interpreter from Brainfuck code but with a custom memory size.

pub fn set_output_sink<F>(&mut self, sink: F)

where F: Fn(&[u8]) + Send + Sync + 'static,

Provide an output sink. When set, ‘.’ sends bytes to this sink instead of stdout. The sink receives a slice of bytes; for Brainfuck, it will be a single-byte slice per ‘.’.

pub fn set_input_provider<F>(&mut self, provider: F)

where F: Fn() -> Option<u8> + Send + Sync + 'static,

Provide an input provider. When set, ‘,’ reads from this provider instead of stdin. Returning None indicates EOF (cell is set to 0).

pub fn set_tape_observer<F>(&mut self, window_size: usize, observer: F)

where F: Fn(usize, usize, &[u8]) + Send + Sync + 'static,

Provide a tape observer and desired window size.

pub fn run(&mut self) -> Result<(), BrainfuckReaderError>

Execute the Brainfuck program until completion.

Returns Ok(()) on success or a BrainfuckReaderError on failure.

pub fn run_debug(&mut self) -> Result<(), BrainfuckReaderError>

Debug-run the Brainfuck program, printing a step-by-step table of operations instead of producing I/O side effects. The interpreter state (pointer, memory) advances exactly as it would during a real run, but:

• ‘.’ does not print the character; we log the action instead
• ‘,’ does not read from stdin; we simulate EOF and set the cell to 0 and log

pub fn run_with_control( &mut self, step_control: StepControl, ) -> Result<(), BrainfuckReaderError>

Execute with cooperative cancellation and optional step limit.

pub fn run_debug_with_control( &mut self, step_control: StepControl, ) -> Result<(), BrainfuckReaderError>

Debug-run with cooperative cancellation and optional step limit.