charm 0.0.1

ARM assembler & disassembler generated from the ARM exploration tools.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Error objects used by this crate.

use std::error;
use std::fmt;
use std::io::Error as IoError;

// ------------------------------------------------------------------------------------------------
// Global error types.
// ------------------------------------------------------------------------------------------------

/// Convenient `Result` type for errors.
pub type Result<T> = std::result::Result<T, Error>;

/// Error type used for all operations performed by Charm.
#[derive(Debug)]
pub enum Error {
    /// Decoder-related errors.
    Decoder(DecoderError),
    /// Encoder-related errors.
    Encoder(EncoderError),
    /// Operand-related errors.
    Operand(OperandError),
    /// I/O-related errors.
    Io(IoError),
    /// Fallback unknown error type.
    Unknown,
}

impl error::Error for Error {}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Error::Decoder(e) => write!(f, "[Decoder error] {}", e),
            Error::Encoder(e) => write!(f, "[Encoder error] {}", e),
            Error::Operand(e) => write!(f, "[Operand error] {}", e),
            Error::Io(e) => write!(f, "[IO error] {}", e),
            Error::Unknown => write!(f, "Unknown error occured"),
        }
    }
}

impl From<DecoderError> for Error {
    fn from(error: DecoderError) -> Self {
        Error::Decoder(error)
    }
}

impl From<EncoderError> for Error {
    fn from(error: EncoderError) -> Self {
        Error::Encoder(error)
    }
}

impl From<OperandError> for Error {
    fn from(error: OperandError) -> Self {
        Error::Operand(error)
    }
}

impl From<IoError> for Error {
    fn from(error: IoError) -> Self {
        Error::Io(error)
    }
}

// ------------------------------------------------------------------------------------------------
// Decoder error types.
// ------------------------------------------------------------------------------------------------

/// Decoder-related errors.
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
pub enum DecoderError {
    Unknown,
}

impl error::Error for DecoderError {}

impl fmt::Display for DecoderError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "Unknown error occured"),
        }
    }
}

// ------------------------------------------------------------------------------------------------
// Encoder error types.
// ------------------------------------------------------------------------------------------------

/// Encoder-related errors.
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
pub enum EncoderError {
    Unknown,
}

impl error::Error for EncoderError {}

impl fmt::Display for EncoderError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Unknown => write!(f, "Unknown error occured"),
        }
    }
}

// ------------------------------------------------------------------------------------------------
// Operand error types.
// ------------------------------------------------------------------------------------------------

/// Operand-related errors.
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
pub enum OperandError {
    RegisterOutOfRange(u32),
    MnemonicConditionOutOfRange(u32),
    ConditionOutOfRange(u32),
    AssemblerQualifierOutOfRange(u32),
    OperandIndexOutOfRange(usize, usize),
    Unknown,
}

impl error::Error for OperandError {}

impl fmt::Display for OperandError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::RegisterOutOfRange(value) => {
                write!(f, "Register index \"{value}\" out of bounds")
            }
            Self::MnemonicConditionOutOfRange(value) => {
                write!(f, "Mnemonic condition \"{value}\" out of bounds")
            }
            Self::ConditionOutOfRange(value) => {
                write!(f, "Condition \"{value}\" out of bounds")
            }
            Self::AssemblerQualifierOutOfRange(value) => {
                write!(f, "Assembler qualifier \"{value}\" out of bounds")
            }
            Self::OperandIndexOutOfRange(value, max) => {
                write!(
                    f,
                    "Operand index \"{value}\" out of bounds (maximum allowed is {max})"
                )
            }
            Self::Unknown => write!(f, "Unknown error occured"),
        }
    }
}