1 files changed, 74 insertions, 0 deletions
diff --git a/src/tokens/expression.rs b/src/tokens/expression.rs
new file mode 100644
index 0000000..ff2d82d
--- /dev/null
+++ b/src/tokens/expression.rs
@@ -0,0 +1,74 @@
+use crate::*;
+
+
+#[derive(Clone)]
+pub struct Expression {
+    pub source: SourceSpan,
+    pub tokens: Vec<ExpressionToken>,
+}
+
+#[derive(Clone)]
+pub struct ExpressionToken {
+    pub source: SourceSpan,
+    pub variant: ExpressionTokenVariant,
+}
+
+#[derive(Clone)]
+pub enum ExpressionTokenVariant {
+    Invocation(String),
+    Literal(isize),
+    Operator(Operator),
+    Error(ExpressionParseError),
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum Operator {
+    Equal,
+    NotEqual,
+    LessThan,
+    GreaterThan,
+    Add,
+    Subtract,
+    LeftShift,
+    RightShift,
+    And,
+    Or,
+    Xor,
+    Not,
+}
+
+#[derive(Clone)]
+pub enum ExpressionParseError {
+    InvalidHexadecimalLiteral(String),
+}
+
+impl std::fmt::Debug for Expression {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        for (i, token) in self.tokens.iter().enumerate() {
+            let string = match &token.variant {
+                ExpressionTokenVariant::Invocation(name) => name,
+                ExpressionTokenVariant::Literal(value) => &value.to_string(),
+                ExpressionTokenVariant::Operator(operator) => match operator {
+                    Operator::Equal       => "=",
+                    Operator::NotEqual    => "!=",
+                    Operator::LessThan    => "<",
+                    Operator::GreaterThan => ">",
+                    Operator::Add         => "+",
+                    Operator::Subtract    => "-",
+                    Operator::LeftShift   => "<<",
+                    Operator::RightShift  => ">>",
+                    Operator::And         => "&",
+                    Operator::Or          => "|",
+                    Operator::Xor         => "^",
+                    Operator::Not         => "~",
+                }
+                ExpressionTokenVariant::Error(_) => "<error>",
+            };
+            match i {
+                0 => write!(f, "{string}")?,
+                _ => write!(f, " {string}")?,
+            }
+        }
+        return Ok(());
+    }
+}