Rewrite entire assembler

The language is now more general, the code is better structured, error
reporting is more detailed, and many new language features have
been implemented:
- conditional blocks
- first-class strings
- more expression operators
- binary literals
- negative values
- invocations in constant expressions

1 files changed, 87 insertions, 0 deletions

diff --git a/src/types/operator.rs b/src/types/operator.rs
new file mode 100644
index 0000000..a7e7b9b
--- /dev/null
+++ b/src/types/operator.rs
@@ -0,0 +1,87 @@
+#[derive(Clone, Copy)]
+pub enum Operator {
+    Equal,
+    NotEqual,
+    LessThan,
+    GreaterThan,
+    LessThanEqual,
+    GreaterThanEqual,
+    Add,
+    Subtract,
+    Multiply,
+    Divide,
+    Modulo,
+    Exponent,
+    LeftShift,
+    RightShift,
+    BitAnd,
+    BitOr,
+    BitXor,
+    BitNot,
+}
+
+impl Operator {
+    pub fn from_str(string: &str) -> Option<Self> {
+        match string {
+            "="     => Some(Operator::Equal),
+            "=="    => Some(Operator::Equal),
+            "<eq>"  => Some(Operator::Equal),
+            "!="    => Some(Operator::NotEqual),
+            "<neq>" => Some(Operator::NotEqual),
+            "<"     => Some(Operator::LessThan),
+            "<lth>" => Some(Operator::LessThan),
+            ">"     => Some(Operator::GreaterThan),
+            "<gth>" => Some(Operator::GreaterThan),
+            "<="    => Some(Operator::LessThanEqual),
+            "<leq>" => Some(Operator::LessThanEqual),
+            ">="    => Some(Operator::GreaterThanEqual),
+            "<geq>" => Some(Operator::GreaterThanEqual),
+            "+"     => Some(Operator::Add),
+            "<add>" => Some(Operator::Add),
+            "-"     => Some(Operator::Subtract),
+            "<sub>" => Some(Operator::Subtract),
+            "*"     => Some(Operator::Multiply),
+            "<mul>" => Some(Operator::Multiply),
+            "/"     => Some(Operator::Divide),
+            "<div>" => Some(Operator::Divide),
+            "<mod>" => Some(Operator::Modulo),
+            "**"    => Some(Operator::Exponent),
+            "<exp>" => Some(Operator::Exponent),
+            "<<"    => Some(Operator::LeftShift),
+            "<shl>" => Some(Operator::LeftShift),
+            ">>"    => Some(Operator::RightShift),
+            "<shr>" => Some(Operator::RightShift),
+            "<and>" => Some(Operator::BitAnd),
+            "<or>"  => Some(Operator::BitOr),
+            "<xor>" => Some(Operator::BitXor),
+            "<not>" => Some(Operator::BitNot),
+            _      => None,
+        }
+    }
+}
+
+impl std::fmt::Display for Operator {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        let string = match self {
+            Operator::Equal            => "<eq>",
+            Operator::NotEqual         => "<neq>",
+            Operator::LessThan         => "<lth>",
+            Operator::GreaterThan      => "<gth>",
+            Operator::LessThanEqual    => "<leq>",
+            Operator::GreaterThanEqual => "<geq>",
+            Operator::Add              => "<add>",
+            Operator::Subtract         => "<sub>",
+            Operator::Multiply         => "<mul>",
+            Operator::Divide           => "<div>",
+            Operator::Modulo           => "<mod>",
+            Operator::Exponent         => "<exp>",
+            Operator::LeftShift        => "<shl>",
+            Operator::RightShift       => "<shr>",
+            Operator::BitAnd           => "<and>",
+            Operator::BitOr            => "<or>",
+            Operator::BitXor           => "<xor>",
+            Operator::BitNot           => "<not>",
+        };
+        write!(f, "{string}")
+    }
+}