feat: split engine into crates

7 files changed, 59 insertions, 81 deletions

diff --git a/src/lexer.rs b/crates/brainf_lexer/src/lexer.rs
index 786c873..b95cd87 100644
--- a/src/lexer.rs
+++ b/crates/brainf_lexer/src/lexer.rs
@@ -1,40 +1,60 @@
-//! Lexer for Brainfuck
+//! Lexer implementation using logos.
+
+#![expect(clippy::indexing_slicing)]
+
+use logos::{Lexer, Logos};
 
 /// List of operator codes for the lexer
 /// Note: Any input symbol that is not in this list is a comment
-#[derive(Clone, Copy, Debug)]
-pub enum OperatorCode {
+
+fn loop_callback(lex: &Lexer<Token>) -> (usize, usize) {
+	let span = lex.span();
+
+	(span.start, span.len())
+}
+
+/// List of Tokens for the lexer
+/// Note: Any input symbol that is not in this list is a comment
+#[derive(Clone, Copy, Debug, Logos, PartialEq, Eq)]
+#[logos(skip r"[^<>+\-.,\[\]]+")]
+pub enum Token {
 	/// `>`
 	///
 	/// Increment the data pointer by one (to point to the next cell to the
 	/// right).
+	#[token(">")]
 	IncrementPointer,
 
 	/// `<`
 	///
 	/// Decrement the data pointer by one (to point to the next cell to the
 	/// left).
+	#[token("<")]
 	DecrementPointer,
 
 	/// `+`
 	///
 	/// Increment the byte at the data pointer by one.
+	#[token("+")]
 	IncrementByte,
 
 	/// `-`
 	///
 	/// Decrement the byte at the data pointer by one.
+	#[token("-")]
 	DecrementByte,
 
 	/// `.`
 	///
 	/// Output the byte at the data pointer.
+	#[token(".")]
 	OutputByte,
 
 	/// `,`
 	///
 	/// Accept one byte of input, storing its value in the byte at the data
 	/// pointer.
+	#[token(",")]
 	InputByte,
 
 	/// `[`
@@ -42,38 +62,14 @@ pub enum OperatorCode {
 	/// If the byte at the data pointer is zero, then instead of moving the
 	/// instruction pointer forward to the next command, jump it forward to the
 	/// command after the matching ] command.
-	StartLoop {
-		/// Offset of the bracket in the source.
-		offset: usize,
-	},
+	#[token("[", loop_callback)]
+	StartLoop((usize, usize)),
 
 	/// `]`
 	///
 	/// If the byte at the data pointer is nonzero, then instead of moving the
 	/// instruction pointer forward to the next command, jump it back to the
 	/// command after the matching [ command.
-	EndLoop {
-		/// Offset of the bracket in the source.
-		offset: usize,
-	},
-}
-
-/// Perform lexical analysis on the input brainfuck code
-#[must_use]
-pub fn lex(input: &str) -> Vec<OperatorCode> {
-	input
-		.char_indices()
-		.filter_map(|(i, symbol)| match symbol {
-			'>' => Some(OperatorCode::IncrementPointer),
-			'<' => Some(OperatorCode::DecrementPointer),
-			'+' => Some(OperatorCode::IncrementByte),
-			'-' => Some(OperatorCode::DecrementByte),
-			'.' => Some(OperatorCode::OutputByte),
-			',' => Some(OperatorCode::InputByte),
-			'[' => Some(OperatorCode::StartLoop { offset: i }),
-			']' => Some(OperatorCode::EndLoop { offset: i }),
-			// Any symbol that does not match one of the above is a comment
-			_ => None,
-		})
-		.collect()
+	#[token("]", loop_callback)]
+	EndLoop((usize, usize)),
 }
diff --git a/src/engine.rs b/crates/brainf_rs/src/engine.rs
index 3269dff..e60acaa 100644
--- a/src/engine.rs
+++ b/crates/brainf_rs/src/engine.rs
@@ -3,11 +3,7 @@
 //! This predominantly allows implementation of a [`u16`] executor.
 
 #[cfg(feature = "bigint-engine")]
-use std::io::Cursor;
-use std::io::Read;
-
-#[cfg(feature = "bigint-engine")]
-use byteorder::{BigEndian, ReadBytesExt};
+use byteorder::{NativeEndian, ReadBytesExt};
 use num_traits::{One, Unsigned, WrappingAdd, WrappingSub, Zero};
 use thiserror::Error;
 
@@ -55,11 +51,7 @@ impl Engine for executor::U8 {
 	type TapeInner = u8;
 
 	fn read_byte() -> Result<u8, Error> {
-		let mut input: [u8; 1] = [0; 1];
-
-		std::io::stdin().read_exact(&mut input)?;
-
-		Ok(input[0])
+		Ok(std::io::stdin().read_u8()?)
 	}
 
 	fn write_byte(byte: u8) -> Result<(), Error> {
@@ -74,13 +66,7 @@ impl Engine for executor::U16 {
 	type TapeInner = u16;
 
 	fn read_byte() -> Result<u16, Error> {
-		let mut input: [u8; 2] = [0; 2];
-
-		std::io::stdin().read_exact(&mut input)?;
-
-		let mut reader = Cursor::new(input);
-
-		Ok(reader.read_u16::<BigEndian>()?)
+		Ok(std::io::stdin().read_u16::<NativeEndian>()?)
 	}
 
 	fn write_byte(byte: u16) -> Result<(), Error> {
@@ -98,13 +84,7 @@ impl Engine for executor::U32 {
 	type TapeInner = u32;
 
 	fn read_byte() -> Result<u32, Error> {
-		let mut input: [u8; 4] = [0; 4];
-
-		std::io::stdin().read_exact(&mut input)?;
-
-		let mut reader = Cursor::new(input);
-
-		Ok(reader.read_u32::<BigEndian>()?)
+		Ok(std::io::stdin().read_u32::<NativeEndian>()?)
 	}
 
 	fn write_byte(byte: u32) -> Result<(), Error> {
diff --git a/src/executor.rs b/crates/brainf_rs/src/executor.rs
index c5fff93..c5fff93 100644
--- a/src/executor.rs
+++ b/crates/brainf_rs/src/executor.rs
diff --git a/src/lib.rs b/crates/brainf_rs/src/lib.rs
index 71c5a99..f5c8987 100644
--- a/src/lib.rs
+++ b/crates/brainf_rs/src/lib.rs
@@ -83,13 +83,12 @@ extern crate test;
 
 mod engine;
 pub mod executor;
-pub mod lexer;
 pub mod parser;
 #[cfg(feature = "utilities")]
 pub mod utility;
 
+pub use brainf_lexer::{lex, Token};
 pub use executor::{U16 as ExecutorU16, U32 as ExecutorU32, U8 as ExecutorU8};
-pub use lexer::{lex, OperatorCode};
 use miette::Diagnostic;
 pub use parser::{parse, Instruction};
 use thiserror::Error;
@@ -101,6 +100,10 @@ pub enum Error {
 	#[error(transparent)]
 	Io(#[from] std::io::Error),
 
+	/// Error occurred while lexing the input.
+	#[error(transparent)]
+	Lexer(#[from] brainf_lexer::Error),
+
 	/// An error that occurred while parsing Brainfuck code.
 	#[diagnostic(transparent)]
 	#[error(transparent)]
diff --git a/src/main.rs b/crates/brainf_rs/src/main.rs
index 13868a6..13868a6 100644
--- a/src/main.rs
+++ b/crates/brainf_rs/src/main.rs
diff --git a/src/parser.rs b/crates/brainf_rs/src/parser.rs
index e639516..c9b3246 100644
--- a/src/parser.rs
+++ b/crates/brainf_rs/src/parser.rs
@@ -1,11 +1,10 @@
 //! Parser implementation for Brainfuck. Parses operator codes into instruction
 //! sets.
 
+use brainf_lexer::Token;
 use miette::{Diagnostic, SourceSpan};
 use thiserror::Error;
 
-use crate::lexer::OperatorCode;
-
 /// Parsed instructions for Brainfuck.
 #[derive(Clone, Debug)]
 pub enum Instruction {
@@ -102,49 +101,49 @@ pub enum Error {
 /// This function will return an error if a loop is encountered with no
 /// beginning, a loop is encountered with no ending, or if the parser attempts
 /// to slice out of bounds.
-pub fn parse(src: &str, operator_codes: &[OperatorCode]) -> Result<Vec<Instruction>, Error> {
+pub fn parse(src: &str, tokens: &[Token]) -> Result<Vec<Instruction>, Error> {
 	let mut program: Vec<Instruction> = Vec::new();
 	let mut loop_stack: i32 = 0;
 	let mut loop_start = 0;
-	let mut loop_source_offset: usize = 0;
+	let mut loop_span: (usize, usize) = (0, 0);
 
-	operator_codes
+	tokens
 		.iter()
 		.enumerate()
 		.try_for_each(|(i, operator_code)| -> Result<(), Error> {
 			match (loop_stack, *operator_code) {
-				(0i32, OperatorCode::StartLoop { offset }) => {
+				(0i32, Token::StartLoop(span)) => {
 					loop_start = i;
-					loop_source_offset = offset;
+					loop_span = span;
 					loop_stack += 1i32;
 				}
 				(0i32, _) => {
 					if let Some(instruction) = match *operator_code {
-						OperatorCode::IncrementPointer => Some(Instruction::IncrementPointer),
-						OperatorCode::DecrementPointer => Some(Instruction::DecrementPointer),
-						OperatorCode::IncrementByte => Some(Instruction::IncrementByte),
-						OperatorCode::DecrementByte => Some(Instruction::DecrementByte),
-						OperatorCode::OutputByte => Some(Instruction::OutputByte),
-						OperatorCode::InputByte => Some(Instruction::InputByte),
-						OperatorCode::EndLoop { offset } => {
+						Token::IncrementPointer => Some(Instruction::IncrementPointer),
+						Token::DecrementPointer => Some(Instruction::DecrementPointer),
+						Token::IncrementByte => Some(Instruction::IncrementByte),
+						Token::DecrementByte => Some(Instruction::DecrementByte),
+						Token::OutputByte => Some(Instruction::OutputByte),
+						Token::InputByte => Some(Instruction::InputByte),
+						Token::EndLoop(span) => {
 							return Err(Error::LoopWithNoBeginning {
 								input: src.to_owned(),
-								loop_src: (offset, 1).into(),
+								loop_src: span.into(),
 							})
 						}
 						// We don't care about this variant as it is handled in a subsequent arm
-						OperatorCode::StartLoop { .. } => None,
+						Token::StartLoop { .. } => None,
 					} {
 						program.push(instruction);
 					}
 				}
-				(_, OperatorCode::StartLoop { .. }) => loop_stack += 1i32,
-				(_, OperatorCode::EndLoop { .. }) => {
+				(_, Token::StartLoop { .. }) => loop_stack += 1i32,
+				(_, Token::EndLoop { .. }) => {
 					loop_stack -= 1i32;
 					if loop_stack == 0i32 {
 						let loop_program = parse(
 							src,
-							match operator_codes.get(loop_start + 1..i) {
+							match tokens.get(loop_start + 1..i) {
 								Some(value) => value,
 								None => return Err(Error::SliceOutOfBounds(loop_start + 1..i)),
 							},
@@ -164,7 +163,7 @@ pub fn parse(src: &str, operator_codes: &[OperatorCode]) -> Result<Vec<Instructi
 	} else {
 		Err(Error::LoopWithNoEnding {
 			input: src.to_owned(),
-			loop_src: (loop_source_offset, 1).into(),
+			loop_src: loop_span.into(),
 		})
 	}
 }
diff --git a/src/utility.rs b/crates/brainf_rs/src/utility.rs
index 514343c..c83dd42 100644
--- a/src/utility.rs
+++ b/crates/brainf_rs/src/utility.rs
@@ -18,9 +18,9 @@ pub fn execute_from_file<E: Engine>(
 ) -> Result<(), Error> {
 	let input = fs_err::read_to_string(path.as_ref())?;
 
-	let operator_codes = lex(&input);
+	let tokens = lex(&input)?;
 
-	let instructions = parse(&input, &operator_codes)?;
+	let instructions = parse(&input, &tokens)?;
 
 	let mut data_pointer = 0;
 
@@ -38,9 +38,9 @@ pub fn execute_from_file<E: Engine>(
 /// execution fails. See documentation for [`crate::parser::parse`] and
 /// [`crate::executor::execute`].
 pub fn execute_from_str<E: Engine>(input: &str, tape: &mut [E::TapeInner]) -> Result<(), Error> {
-	let operator_codes = lex(input);
+	let tokens = lex(input)?;
 
-	let instructions = parse(input, &operator_codes)?;
+	let instructions = parse(input, &tokens)?;
 
 	let mut data_pointer = 0;