89 lines
2.4 KiB
Rust
89 lines
2.4 KiB
Rust
//! This module contains code for various types of errors that may occur when assembling a
|
|
//! set of source DSA files.
|
|
|
|
use std::fmt::{Debug, Display};
|
|
|
|
use crate::source::{source_info::SourceInfo, tokeniser::error::TokeniserError};
|
|
|
|
/// An error that may occur during the assembly of a set of source files.
|
|
#[derive(Debug)]
|
|
pub struct AssembleError {
|
|
/// Display implementation can handle when the source code information is shown or
|
|
/// not.
|
|
source_info: Option<SourceInfo>,
|
|
/// The type of assembly error that occurred.
|
|
kind: AssembleErrorKind,
|
|
}
|
|
|
|
impl AssembleError {
|
|
#[must_use]
|
|
pub const fn new_source_error(
|
|
source_info: SourceInfo,
|
|
kind: AssembleErrorKind,
|
|
) -> Self {
|
|
Self {
|
|
source_info: Some(source_info),
|
|
kind,
|
|
}
|
|
}
|
|
|
|
#[must_use]
|
|
pub const fn new_other_error(kind: AssembleErrorKind) -> Self {
|
|
Self {
|
|
source_info: None,
|
|
kind,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for AssembleError {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
if let Some(info) = &self.source_info {
|
|
write!(f, "at {info}")?;
|
|
}
|
|
|
|
write!(f, "{}", self.kind)?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// Marker trait.
|
|
impl std::error::Error for AssembleError {}
|
|
|
|
/// Different types of errors that may occur when assembling a set of input source files.
|
|
#[non_exhaustive]
|
|
#[derive(Debug)]
|
|
pub enum AssembleErrorKind {
|
|
/// Usually unexpected I/O errors. Not normally recoverable.
|
|
IO(std::io::Error),
|
|
/// Errors emitted from the [`Tokeniser`].
|
|
Tokenise(TokeniserError),
|
|
/// Returned for code where the functionality has not yet been implemented but we
|
|
/// don't want the program to panic.
|
|
Unimplemented(String),
|
|
}
|
|
|
|
impl Display for AssembleErrorKind {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
Self::Tokenise(why) => write!(f, "tokeniser error: {why}"),
|
|
Self::Unimplemented(why) => write!(f, "used unimplemented feature: {why}"),
|
|
Self::IO(why) => write!(f, "problem occurred with I/O: {why}"),
|
|
#[expect(unreachable_patterns)]
|
|
_ => write!(
|
|
f,
|
|
"unhandled error type in Display implementation! See error.rs!"
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<std::io::Error> for AssembleErrorKind {
|
|
fn from(err: std::io::Error) -> Self {
|
|
Self::IO(err)
|
|
}
|
|
}
|
|
|
|
pub mod conversions;
|