summaryrefslogtreecommitdiff
path: root/src/error
diff options
context:
space:
mode:
Diffstat (limited to 'src/error')
-rw-r--r--src/error/mod.rs48
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}`"),
+ }
}
}