1 files changed, 35 insertions, 13 deletions
diff --git a/src/error/mod.rs b/src/error/mod.rs
index b6c1e24..e561072 100644
--- a/src/error/mod.rs
+++ b/src/error/mod.rs
@@ -19,6 +19,7 @@
 // fero General Public License along with Pollex.
 // If not, see <https://www.gnu.org/licenses/>.
 
+use alloc::string::String;
 use core::fmt::{Display, Formatter};
 
 /// Wrapping of [`core::result::Result`].
@@ -27,42 +28,63 @@ pub type Result<T> = core::result::Result<T, Error>;
 /// A crate error.
 #[derive(Clone, Debug)]
 pub enum Error {
+	/// The given flag is currently not support.
+	///
+	/// Some Thumb instructions require the S flag to be on, for example.
+	/// These yield this error if encoded with the S flag is off.
+	IllegalFlag { reason: &'static str },
+
 	/// The given immediate cannot be encoded.
-	IllegalImmediate,
+	IllegalImmediate { reason: &'static str },
 
 	/// The given instruction cannot be encoded.
 	///
 	/// Even valid instructions are not valid in *every* case.
 	/// For example, most shifter operands and instruction predicates are **not** allowed in a Thumb context (with exceptions).
-	IllegalInstruction,
+	IllegalInstruction { reason: &'static str },
 
 	/// The given instruction predicate cannot be encoded.
-	IllegalPredicate,
+	IllegalPredicate { reason: &'static str },
 
 	/// The given register can currently not be used.
-	IllegalRegister,
+	IllegalRegister { reason: &'static str },
+
+	/// The given shifter operand cannot be encoded.
+	IllegalShifter { reason: &'static str },
+
+	/// The provided opcode could not be decoded.
+	InvalidOpcode,
+
+	/// Mnemonic is not known.
+	UnknownMnemonic(String),
 
 	/// Register name is not known.
-	UnknownRegister,
+	UnknownRegister(String),
 }
 
 impl Display for Error {
 	fn fmt(&self, f: &mut Formatter) -> core::fmt::Result {
 		use Error::*;
 
-		let message = match *self {
-			IllegalImmediate => "illegal immediate value",
+		match *self {
+			IllegalFlag { reason } => write!(f, "illegal flag value: {reason}"),
+
+			IllegalImmediate { reason } => write!(f, "illegal immediate value: {reason}"),
+
+			IllegalInstruction { reason } => write!(f, "illegal instruction: {reason}"),
+
+			IllegalPredicate { reason } => write!(f, "illegal instruction predicate: {reason}"),
 
-			IllegalInstruction => "illegal instruction",
+			IllegalRegister { reason } => write!(f, "register not permitted here: {reason}"),
 
-			IllegalPredicate => "illegal instruction predicate",
+			IllegalShifter { reason } => write!(f, "shifter operand not permitted here: {reason}"),
 
-			IllegalRegister => "register not permitted here",
+			InvalidOpcode => write!(f, "invalid opcode"),
 
-			UnknownRegister => "unknown register",
-		};
+			UnknownMnemonic(ref s) => write!(f, "unknown mnemonic `{s}`"),
 
-		f.write_str(message)
+			UnknownRegister(ref s) => write!(f, "unknown register `{s}`"),
+		}
 	}
 }