439 lines
15 KiB
Rust
439 lines
15 KiB
Rust
//! A brainfuck interpreter capable of executing arbitrary code, with arbitrary inputs and outputs.
|
|
//!
|
|
//! If you just want to execute some simple brainfuck, check the [`interpret_with_io`] function.
|
|
//!
|
|
//! To construct the interpreter, use the [`from_ascii`] or [`from_ascii_with_input_buffer`] methods
|
|
//! (or their variants that take a maximum tape size). The latter grants access to
|
|
//! the method [`add_input`], which allows for the addition of input while the interpreter is running.
|
|
//!
|
|
//! [`from_ascii`]: Interpreter::from_ascii
|
|
//! [`from_ascii_with_input_buffer`]: Interpreter::from_ascii_with_input_buffer
|
|
//! [`add_input`]: Interpreter::add_input
|
|
//!
|
|
//! Finally, to run the interpreter, you can use the [`advance`], [`advance_until_io`], or [`interpret_with_output`] methods.
|
|
//!
|
|
//! [`advance`]: Interpreter::advance
|
|
//! [`advance_until_io`]: Interpreter::advance_until_io
|
|
//! [`interpret_with_output`]: Interpreter::interpret_with_output
|
|
|
|
#![deny(missing_docs)]
|
|
// Putting this here because we still don't use the entire capabilities of this module. ~~Alex
|
|
#![allow(dead_code)]
|
|
|
|
use std::{
|
|
collections::VecDeque,
|
|
error::Error,
|
|
fmt::Display,
|
|
io::{Read, Write},
|
|
};
|
|
|
|
// NOTE(Able): This is the brain fuck interface
|
|
|
|
/// The default limit for the tape size. This is the value used by methods that don't take it as a parameter
|
|
pub const DEFAULT_TAPE_SIZE_LIMIT: usize = 30_000;
|
|
|
|
/// Mappings from integers to BF instructions
|
|
pub const INSTRUCTION_MAPPINGS: &[u8] = b"[]+-,.<>";
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
/// A brainfuck interpreter. Read the [module level documentation](self) for more
|
|
pub struct Interpreter<'a, I> {
|
|
code: &'a [u8],
|
|
instr_ptr: usize,
|
|
tape: Vec<i8>,
|
|
data_ptr: usize,
|
|
tape_size_limit: usize,
|
|
input: I,
|
|
}
|
|
|
|
impl<'a> Interpreter<'a, InputBuffer> {
|
|
/// Construct an `Interpreter` from an ASCII string of code with an empty input buffer
|
|
/// This methods sets the tape size limit to [its default value](DEFAULT_TAPE_SIZE_LIMIT)
|
|
pub fn from_ascii_with_input_buffer(code: &'a [u8]) -> Self {
|
|
Self::from_ascii_with_input_buffer_and_tape_limit(code, DEFAULT_TAPE_SIZE_LIMIT)
|
|
}
|
|
|
|
/// Construct an `Interpreter` from an ASCII string of code with an empty input buffer,
|
|
/// setting the tape size limit to the specified value
|
|
pub fn from_ascii_with_input_buffer_and_tape_limit(
|
|
code: &'a [u8],
|
|
tape_size_limit: usize,
|
|
) -> Self {
|
|
Self {
|
|
code,
|
|
instr_ptr: 0,
|
|
tape: Vec::new(),
|
|
data_ptr: 0,
|
|
tape_size_limit,
|
|
input: InputBuffer(VecDeque::new()),
|
|
}
|
|
}
|
|
|
|
/// Add a byte to the input buffer of this interpreter
|
|
pub fn add_input(&mut self, input: i8) {
|
|
self.input.0.push_back(input);
|
|
}
|
|
}
|
|
|
|
impl<'a, I: BootlegRead> Interpreter<'a, I> {
|
|
/// Construct an interpreter from an ASCII string of code, a source of input bytes, and a tape size limit
|
|
pub fn from_ascii_with_tape_limit(code: &'a [u8], input: I, tape_size_limit: usize) -> Self {
|
|
Self {
|
|
code,
|
|
instr_ptr: 0,
|
|
tape: Vec::new(),
|
|
data_ptr: 0,
|
|
tape_size_limit,
|
|
input,
|
|
}
|
|
}
|
|
|
|
/// Constructs an interpreter from an ASCII string of code, a source of input bytes, and [the default tape size limit](DEFAULT_TAPE_SIZE_LIMIT)
|
|
pub fn from_ascii(code: &'a [u8], input: I) -> Self {
|
|
Self::from_ascii_with_tape_limit(code, input, DEFAULT_TAPE_SIZE_LIMIT)
|
|
}
|
|
|
|
/// Advance the interpreter by one instruction.
|
|
/// A return value of Ok(None) indicates succesful termination of the interpreter
|
|
pub fn advance(&mut self) -> Result<Option<Status>, ProgramError> {
|
|
let &opcode = match self.code.get(self.instr_ptr) {
|
|
Some(opcode) => opcode,
|
|
None => return Ok(None),
|
|
};
|
|
|
|
match opcode {
|
|
b'>' => self.data_ptr += 1,
|
|
|
|
b'<' => {
|
|
self.data_ptr = self
|
|
.data_ptr
|
|
.checked_sub(1)
|
|
.ok_or(ProgramError::DataPointerUnderflow)?;
|
|
}
|
|
|
|
b'+' => {
|
|
let val = self
|
|
.get_or_resize_tape_mut()
|
|
.ok_or(ProgramError::TapeSizeExceededLimit)?;
|
|
*val = val.wrapping_add(1)
|
|
}
|
|
|
|
b'-' => {
|
|
let val = self
|
|
.get_or_resize_tape_mut()
|
|
.ok_or(ProgramError::TapeSizeExceededLimit)?;
|
|
*val = val.wrapping_sub(1)
|
|
}
|
|
|
|
b'.' => {
|
|
self.instr_ptr += 1;
|
|
return Ok(Some(Status::Output(self.get_at_data_ptr())));
|
|
}
|
|
|
|
b',' => match self.input.bootleg_read() {
|
|
Ok(Some(num)) => {
|
|
let cell = self
|
|
.get_or_resize_tape_mut()
|
|
.ok_or(ProgramError::TapeSizeExceededLimit)?;
|
|
*cell = num;
|
|
}
|
|
Ok(None) => return Ok(Some(Status::NeedsInput)),
|
|
Err(_) => return Err(ProgramError::InputReadError),
|
|
},
|
|
|
|
b'[' => {
|
|
if self.get_at_data_ptr() == 0 {
|
|
self.instr_ptr = self
|
|
.get_matching_closing_bracket(self.instr_ptr)
|
|
.ok_or(ProgramError::UnmatchedOpeningBracket)?
|
|
//Instruction pointer will be incremented by 1 after the match
|
|
}
|
|
}
|
|
|
|
b']' => {
|
|
if self.get_at_data_ptr() != 0 {
|
|
self.instr_ptr = self
|
|
.get_matching_opening_bracket(self.instr_ptr)
|
|
.ok_or(ProgramError::UnmatchedClosingBracket)?
|
|
//Instruction pointer will be incremented by 1 after the match
|
|
}
|
|
}
|
|
|
|
_ => {} //brainfuck treats all characters it doesn't understand as comments
|
|
}
|
|
|
|
self.instr_ptr += 1;
|
|
|
|
Ok(Some(Status::Continue))
|
|
}
|
|
|
|
/// Advances the interpreter until the next IO operation. See [`advance`](Interpreter::advance)
|
|
pub fn advance_until_io(&mut self) -> Result<Option<IoStatus>, ProgramError> {
|
|
while let Some(status) = self.advance()? {
|
|
match status {
|
|
Status::NeedsInput => return Ok(Some(IoStatus::NeedsInput)),
|
|
Status::Output(out) => return Ok(Some(IoStatus::Output(out))),
|
|
Status::Continue => continue,
|
|
}
|
|
}
|
|
Ok(None)
|
|
}
|
|
|
|
/// Executes the interpreter until it halts, writing all return values to the provided `Write` type.
|
|
/// For more granular control, use [`advance`](Interpreter::advance)
|
|
pub fn interpret_with_output<O: Write>(&mut self, mut output: O) -> Result<(), InterpretError> {
|
|
while let Some(status) = self.advance_until_io()? {
|
|
match status {
|
|
IoStatus::NeedsInput => return Err(InterpretError::EndOfInput),
|
|
IoStatus::Output(out) => match output.write(&[out as u8]) {
|
|
Ok(0) => return Err(InterpretError::OutputBufferFull),
|
|
Ok(_) => continue,
|
|
Err(_) => return Err(InterpretError::OutputWriteError),
|
|
},
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn get_or_resize_tape_mut(&mut self) -> Option<&mut i8> {
|
|
if self.data_ptr > self.tape_size_limit {
|
|
return None;
|
|
}
|
|
if self.data_ptr >= self.tape.len() {
|
|
self.tape.resize(self.data_ptr + 1, 0);
|
|
}
|
|
Some(&mut self.tape[self.data_ptr])
|
|
}
|
|
|
|
fn get_at_data_ptr(&self) -> i8 {
|
|
//No need to resize the tape to read: if the tape doesn't extend that far already, it holds a value of 0
|
|
self.tape.get(self.data_ptr).copied().unwrap_or(0)
|
|
}
|
|
|
|
fn get_matching_closing_bracket(&mut self, opening: usize) -> Option<usize> {
|
|
self.code[opening..]
|
|
.iter()
|
|
.zip(opening..)
|
|
.scan(0, |counter, (char, index)| {
|
|
match char {
|
|
b'[' => *counter += 1,
|
|
b']' => *counter -= 1,
|
|
_ => {}
|
|
};
|
|
Some((*counter, index))
|
|
})
|
|
.find_map(|(counter, index)| (counter == 0).then_some(index))
|
|
}
|
|
|
|
fn get_matching_opening_bracket(&mut self, closing: usize) -> Option<usize> {
|
|
self.code[..closing + 1]
|
|
.iter()
|
|
.zip(0..closing + 1)
|
|
.rev()
|
|
.scan(0, |counter, (char, index)| {
|
|
match char {
|
|
b']' => *counter += 1,
|
|
b'[' => *counter -= 1,
|
|
_ => {}
|
|
};
|
|
Some((*counter, index))
|
|
})
|
|
.find_map(|(counter, index)| (counter == 0).then_some(index))
|
|
}
|
|
}
|
|
|
|
/// A convenience function for interpreting brainfuck code with a given input and output source.
|
|
/// For more information, consult [the module level documentation](self)
|
|
pub fn interpret_with_io<I: BootlegRead, O: Write>(
|
|
code: &[u8],
|
|
input: I,
|
|
output: O,
|
|
) -> Result<(), InterpretError> {
|
|
Interpreter::from_ascii(code, input).interpret_with_output(output)
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
///The result of advancing the interpreter by one step, assuming it didn't terminate
|
|
pub enum Status {
|
|
NeedsInput,
|
|
Output(i8),
|
|
Continue,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
/// The result of advancing the interpreter until the next IO operation, assuming it didn't terminate
|
|
pub enum IoStatus {
|
|
NeedsInput,
|
|
Output(i8),
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
/// An error that occurred while the interpreter was advancing
|
|
pub enum ProgramError {
|
|
DataPointerUnderflow,
|
|
InputReadError,
|
|
UnmatchedOpeningBracket,
|
|
UnmatchedClosingBracket,
|
|
TapeSizeExceededLimit,
|
|
}
|
|
|
|
impl Display for ProgramError {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
write!(
|
|
f,
|
|
"{}",
|
|
match self {
|
|
ProgramError::DataPointerUnderflow => "data pointer underflow",
|
|
ProgramError::InputReadError => "input read error",
|
|
ProgramError::UnmatchedOpeningBracket => "unmatched `[`",
|
|
ProgramError::UnmatchedClosingBracket => "unmatched `]`",
|
|
ProgramError::TapeSizeExceededLimit => "tape size exceeded",
|
|
}
|
|
)
|
|
}
|
|
}
|
|
impl Error for ProgramError {}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
/// An error that occurred while the interpreter was being run start-to-end all in one go
|
|
pub enum InterpretError {
|
|
ProgramError(ProgramError),
|
|
EndOfInput,
|
|
OutputBufferFull,
|
|
OutputWriteError,
|
|
}
|
|
|
|
impl Display for InterpretError {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
InterpretError::ProgramError(e) => write!(f, "program error: {}", e),
|
|
InterpretError::EndOfInput => write!(f, "unexpected end of input"),
|
|
InterpretError::OutputBufferFull => write!(f, "output buffer full"),
|
|
InterpretError::OutputWriteError => write!(f, "output write error"),
|
|
}
|
|
}
|
|
}
|
|
impl Error for InterpretError {}
|
|
|
|
impl From<ProgramError> for InterpretError {
|
|
fn from(e: ProgramError) -> Self {
|
|
InterpretError::ProgramError(e)
|
|
}
|
|
}
|
|
|
|
/// A bootlegged version of the standard library's read trait, so as to allow the interpreter to be generic over any `Read`
|
|
/// type, as well as over an input buffer.
|
|
pub trait BootlegRead {
|
|
type Error;
|
|
fn bootleg_read(&mut self) -> Result<Option<i8>, Self::Error>;
|
|
}
|
|
|
|
impl<T: Read> BootlegRead for T {
|
|
type Error = std::io::Error;
|
|
fn bootleg_read(&mut self) -> Result<Option<i8>, Self::Error> {
|
|
let mut buffer = [0];
|
|
match self.read(&mut buffer) {
|
|
Ok(0) => Ok(None),
|
|
Ok(_) => Ok(Some(buffer[0] as i8)),
|
|
Err(e) => Err(e),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A wrapper around a `VecDeque`, to be able to implement `BootlegRead` for it
|
|
struct InputBuffer(VecDeque<i8>);
|
|
impl BootlegRead for InputBuffer {
|
|
type Error = std::convert::Infallible;
|
|
fn bootleg_read(&mut self) -> Result<Option<i8>, Self::Error> {
|
|
Ok(self.0.pop_front())
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn adder() {
|
|
let mut interpreter = Interpreter {
|
|
code: b"[->+<]", //Source: https://en.wikipedia.org/wiki/Brainfuck
|
|
instr_ptr: 0,
|
|
tape: vec![10, 5],
|
|
data_ptr: 0,
|
|
tape_size_limit: DEFAULT_TAPE_SIZE_LIMIT,
|
|
input: std::io::empty(),
|
|
};
|
|
|
|
while let Some(status) = interpreter.advance_until_io().expect("Unexpected error") {
|
|
match status {
|
|
IoStatus::NeedsInput => panic!("Requested input in an IO-less program"),
|
|
IoStatus::Output(_) => panic!("Produced output in an IO-less program"),
|
|
}
|
|
}
|
|
|
|
assert_eq!(interpreter.tape, vec![0, 15]);
|
|
}
|
|
|
|
#[test]
|
|
fn hello_world() {
|
|
let mut interpreter = Interpreter::from_ascii(
|
|
b"++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.",
|
|
std::io::empty(),
|
|
);
|
|
|
|
let mut string = Vec::new();
|
|
interpreter
|
|
.interpret_with_output(&mut string)
|
|
.expect("Failed to write to output buffer");
|
|
assert_eq!(string, b"Hello World!\n");
|
|
}
|
|
|
|
#[test]
|
|
fn with_input_buffer() {
|
|
let mut interpreter = Interpreter::from_ascii_with_input_buffer(b"+++++.>,[-<->].");
|
|
let output = match interpreter
|
|
.advance_until_io()
|
|
.expect("Unexpected error")
|
|
.expect("Unexpected termination")
|
|
{
|
|
IoStatus::NeedsInput => panic!("Unexpected input request"),
|
|
IoStatus::Output(out) => out,
|
|
};
|
|
|
|
assert_eq!(
|
|
interpreter.advance_until_io(),
|
|
Ok(Some(IoStatus::NeedsInput))
|
|
);
|
|
|
|
interpreter.add_input(output);
|
|
|
|
assert_eq!(
|
|
interpreter.advance_until_io(),
|
|
Ok(Some(IoStatus::Output(0)))
|
|
);
|
|
assert_eq!(interpreter.advance_until_io(), Ok(None));
|
|
}
|
|
|
|
#[test]
|
|
fn hit_tape_size_limit() {
|
|
let mut interpreter =
|
|
Interpreter::from_ascii_with_tape_limit(b"+>+>+>+>+>", std::io::empty(), 1);
|
|
let result = interpreter.interpret_with_output(std::io::sink());
|
|
assert_eq!(
|
|
result,
|
|
Err(InterpretError::ProgramError(
|
|
ProgramError::TapeSizeExceededLimit
|
|
))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn positive_integer_overflow() {
|
|
interpret_with_io(b"+[+]", std::io::empty(), std::io::sink()).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn negative_integer_overflow() {
|
|
interpret_with_io(b"-", std::io::empty(), std::io::sink()).unwrap();
|
|
}
|
|
}
|