Basic expression parsing

2025-05-30 13:33:45 +09:00
parent d5d21aa422
commit 1aceef1273
7 changed files with 197 additions and 35 deletions
--- a/src/Expression.cpp
+++ b/src/Expression.cpp
@@ -1,14 +1,95 @@
 #include "Expression.h"

-ExpressionInvalid Expression::Invalid = ExpressionInvalid();
+std::shared_ptr<Expression> Expression::Invalid = std::make_shared<Expression>(Expression::Kind::INVALID, Token::Invalid, nullptr, nullptr);

-std::string ExpressionInvalid::toString() {
-    return "Invalid";
+Expression::Expression(Kind kind, Token token, shared_ptr<Expression> left, shared_ptr<Expression> right) {
+    switch (kind) {
+        case LITERAL:
+            setupLiteral(token);
+            break;
+        case BINARY:
+            setupBinary(token, left, right);
+            break;
+        case INVALID:
+            break;
+    }
 }

-/*ExpressionInteger::ExpressionInteger(Token token) {
+void Expression::setupLiteral(Token token) {
+    bool isKindValid = token.isOneOf({Token::Kind::INTEGER});
+    if (!isKindValid)
+        return;
+
+    kind = LITERAL;
+    integer = stoi(token.getLexme());
 }

-std::string ExpressionInteger::toString() {
-    return "INTEGER";
-}*/
+void Expression::setupBinary(Token token, shared_ptr<Expression> left, shared_ptr<Expression> right) {
+    bool isKindValid = token.isOneOf({Token::Kind::PLUS, Token::Kind::MINUS, Token::Kind::STAR, Token::Kind::SLASH, Token::Kind::PERCENT});
+    bool isLeftValid = left != nullptr && left->getKind() != Kind::INVALID;
+    bool isRightValid = right != nullptr && right->getKind() != Kind::INVALID;
+
+    if (!isKindValid || !isLeftValid || !isRightValid)
+        return;
+
+    kind = BINARY;
+
+    switch (token.getKind()) {
+        case Token::Kind::PLUS:
+            operation = ADD;
+            break;
+        case Token::Kind::MINUS:
+            operation = SUB;
+            break;
+        case Token::Kind::STAR:
+            operation = MUL;
+            break;
+        case Token::Kind::SLASH:
+            operation = DIV;
+            break;
+        case Token::Kind::PERCENT:
+            operation = MOD;
+            break;
+        case Token::Kind::INVALID:
+            break;
+    }
+
+    this->left = left;
+    this->right = right;
+}
+
+Expression::Kind Expression::getKind() {
+    return kind;
+}
+
+bool Expression::operator==(Expression const& other) {
+    return kind == other.kind;
+}
+
+bool Expression::operator!=(Expression const& other) {
+    return kind != other.kind;
+}
+
+std::string Expression::toString() {
+    switch (kind) {
+        case LITERAL:
+            return to_string(integer);
+        case BINARY:
+            switch (operation) {
+                case ADD:
+                    return "<+ " + left->toString() + " " + right->toString() + ">";
+                case SUB:
+                    return "<- " + left->toString() + " " + right->toString() + ">";
+                case MUL:
+                    return "<* " + left->toString() + " " + right->toString() + ">";
+                case DIV:
+                    return "</ " + left->toString() + " " + right->toString() + ">";
+                case MOD:
+                    return "<% " + left->toString() + " " + right->toString() + ">";
+                case NONE:
+                    return "NONE";
+            }
+        case INVALID:
+            return "INVALID";
+    }
+}