support the power (^) operator

It doesn't work with the unary minus currently (as is reflected in the
tests), it should have a higher precedence.

4 files changed, 40 insertions, 1 deletions

diff --git a/server/lexer/token_type.cpp b/server/lexer/token_type.cpp
index cafb403..6a42a3d 100644
--- a/server/lexer/token_type.cpp
+++ b/server/lexer/token_type.cpp
@@ -35,6 +35,7 @@ private:
             {Type::MINUS, "-"},
             {Type::ASTERISK, "*"},
             {Type::SLASH, "/"},
+            {Type::CARET, "^"},
             {Type::LEFT_PAREN, "("},
             {Type::RIGHT_PAREN, ")"},
             {Type::NUMBER, "number"},
diff --git a/server/lexer/token_type.hpp b/server/lexer/token_type.hpp
index fba2abb..2040d28 100644
--- a/server/lexer/token_type.hpp
+++ b/server/lexer/token_type.hpp
@@ -18,6 +18,7 @@ enum class Type {
     MINUS,
     ASTERISK,
     SLASH,
+    CARET,
     LEFT_PAREN,
     RIGHT_PAREN,
     NUMBER,
diff --git a/server/parser/operator.hpp b/server/parser/operator.hpp
index f1c24de..86b9eb1 100644
--- a/server/parser/operator.hpp
+++ b/server/parser/operator.hpp
@@ -10,6 +10,8 @@
 #include "../lexer/token.hpp"
 #include "../lexer/token_type.hpp"
 
+#include <cmath>
+
 namespace math::server::parser {
 
 class BinaryOp {
@@ -23,6 +25,7 @@ public:
             case Type::MINUS:
             case Type::ASTERISK:
             case Type::SLASH:
+            case Type::CARET:
                 return true;
 
             default:
@@ -49,25 +52,49 @@ public:
             case Type::SLASH:
                 return min_precedence() + 1;
 
+            case Type::CARET:
+                return min_precedence() + 2;
+
             default:
                 throw ParserError{"internal: undefined operator precedence"};
         }
     }
 
+    bool is_right_associative() const {
+        switch (m_type) {
+            case Type::CARET:
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    bool is_left_associative() const {
+        return !is_right_associative();
+    }
+
     double exec(double lhs, double rhs) const {
         switch (m_type) {
             case Type::PLUS:
                 return lhs + rhs;
+
             case Type::MINUS:
                 return lhs - rhs;
+
             case Type::ASTERISK:
                 return lhs * rhs;
+
             case Type::SLASH:
                 // Trapping the CPU would be better?
                 if (rhs == 0.) {
                     throw ParserError{"division by zero"};
                 }
                 return lhs / rhs;
+
+            case Type::CARET:
+                return std::pow(lhs, rhs);
+
             default:
                 throw ParserError{"internal: unsupported operator"};
         }
diff --git a/server/parser/parser.hpp b/server/parser/parser.hpp
index ac87fbe..596f84f 100644
--- a/server/parser/parser.hpp
+++ b/server/parser/parser.hpp
@@ -45,7 +45,17 @@ private:
             m_lexer.drop_token();
             auto rhs = exec_primary();
 
-            for (op = peek_operator(); op.has_value() && op->get_precedence() > lhs_op.get_precedence(); op = peek_operator()) {
+            for (op = peek_operator(); op.has_value(); op = peek_operator()) {
+                const auto op_prec = op->get_precedence();
+                const auto lhs_prec = lhs_op.get_precedence();
+                const auto ok_left_assoc = op->is_left_associative() && op_prec > lhs_prec;
+                const auto ok_right_assoc = op->is_right_associative() && op_prec == lhs_prec;
+                const auto ok = ok_left_assoc || ok_right_assoc;
+
+                if (!ok) {
+                    break;
+                }
+
                 rhs = exec_expr(rhs, op->get_precedence());
             }