Implement <= and >= operators for constant expressions

4 files changed, 32 insertions, 24 deletions

diff --git a/src/expression_evaluator.rs b/src/expression_evaluator.rs
deleted file mode 100644
index e69de29..0000000
--- a/src/expression_evaluator.rs
+++ /dev/null
diff --git a/src/parsers/bytecode.rs b/src/parsers/bytecode.rs
index 6cdfd3a..ed16e22 100644
--- a/src/parsers/bytecode.rs
+++ b/src/parsers/bytecode.rs
@@ -103,18 +103,20 @@ impl<'a> BytecodeGenerator<'a> {
                         push!(self.resolve_expression(expr))
                     }
                     AssembledExpressionToken::Operator(operator) => match operator {
-                        Operator::Equal       => { pop!(b); pop!(a); push!(truth!(a==b)) },
-                        Operator::NotEqual    => { pop!(b); pop!(a); push!(truth!(a!=b)) },
-                        Operator::LessThan    => { pop!(b); pop!(a); push!(truth!(a < b)) },
-                        Operator::GreaterThan => { pop!(b); pop!(a); push!(truth!(a > b)) },
-                        Operator::Add         => { pop!(b); pop!(a); push!(a + b) },
-                        Operator::Subtract    => { pop!(b); pop!(a); push!(a - b) },
-                        Operator::LeftShift   => { pop!(b); pop!(a); push!(a << b) },
-                        Operator::RightShift  => { pop!(b); pop!(a); push!(a >> b) },
-                        Operator::And         => { pop!(b); pop!(a); push!(a & b) },
-                        Operator::Or          => { pop!(b); pop!(a); push!(a | b) },
-                        Operator::Xor         => { pop!(b); pop!(a); push!(a ^ b) },
-                        Operator::Not         => {          pop!(a); push!(!a) },
+                        Operator::Equal            => { pop!(b); pop!(a); push!(truth!(a==b)) },
+                        Operator::NotEqual         => { pop!(b); pop!(a); push!(truth!(a!=b)) },
+                        Operator::LessThan         => { pop!(b); pop!(a); push!(truth!(a < b)) },
+                        Operator::GreaterThan      => { pop!(b); pop!(a); push!(truth!(a > b)) },
+                        Operator::LessThanEqual    => { pop!(b); pop!(a); push!(truth!(a <= b)) },
+                        Operator::GreaterThanEqual => { pop!(b); pop!(a); push!(truth!(a >= b)) },
+                        Operator::Add              => { pop!(b); pop!(a); push!(a + b) },
+                        Operator::Subtract         => { pop!(b); pop!(a); push!(a - b) },
+                        Operator::LeftShift        => { pop!(b); pop!(a); push!(a << b) },
+                        Operator::RightShift       => { pop!(b); pop!(a); push!(a >> b) },
+                        Operator::And              => { pop!(b); pop!(a); push!(a & b) },
+                        Operator::Or               => { pop!(b); pop!(a); push!(a | b) },
+                        Operator::Xor              => { pop!(b); pop!(a); push!(a ^ b) },
+                        Operator::Not              => {          pop!(a); push!(!a) },
                     }
                 }
             }
diff --git a/src/parsers/expression.rs b/src/parsers/expression.rs
index f902858..e938881 100644
--- a/src/parsers/expression.rs
+++ b/src/parsers/expression.rs
@@ -20,6 +20,8 @@ pub fn parse_constant_expression(mut t: Tokeniser, source: SourceSpan) -> Expres
             "!=" => TokenVar::Operator(Operator::NotEqual),
             "<" => TokenVar::Operator(Operator::LessThan),
             ">" => TokenVar::Operator(Operator::GreaterThan),
+            "<=" => TokenVar::Operator(Operator::LessThanEqual),
+            ">=" => TokenVar::Operator(Operator::GreaterThanEqual),
             "+" => TokenVar::Operator(Operator::Add),
             "-" => TokenVar::Operator(Operator::Subtract),
             "<<" => TokenVar::Operator(Operator::LeftShift),
diff --git a/src/tokens/expression.rs b/src/tokens/expression.rs
index ff2d82d..1d8a336 100644
--- a/src/tokens/expression.rs
+++ b/src/tokens/expression.rs
@@ -27,6 +27,8 @@ pub enum Operator {
     NotEqual,
     LessThan,
     GreaterThan,
+    LessThanEqual,
+    GreaterThanEqual,
     Add,
     Subtract,
     LeftShift,
@@ -49,18 +51,20 @@ impl std::fmt::Debug for Expression {
                 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         => "~",
+                    Operator::Equal            => "=",
+                    Operator::NotEqual         => "!=",
+                    Operator::LessThan         => "<",
+                    Operator::GreaterThan      => ">",
+                    Operator::LessThanEqual    => "<=",
+                    Operator::GreaterThanEqual => ">=",
+                    Operator::Add              => "+",
+                    Operator::Subtract         => "-",
+                    Operator::LeftShift        => "<<",
+                    Operator::RightShift       => ">>",
+                    Operator::And              => "&",
+                    Operator::Or               => "|",
+                    Operator::Xor              => "^",
+                    Operator::Not              => "~",
                 }
                 ExpressionTokenVariant::Error(_) => "<error>",
             };