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}`"),
+ }
 }
 }