diff --git a/include/ast/BinaryOpNode.h b/include/ast/BinaryOpNode.h
index 3b62e9bb74baceda4413112229a5617a16c54f84..d085dd9264f17dada98709530cf74e14dfe4995f 100644
--- a/include/ast/BinaryOpNode.h
+++ b/include/ast/BinaryOpNode.h
@@ -6,40 +6,11 @@
#include "ast/ExpressionNode.h"
#include "ast/LiteralNode.h"
+#include "token/Token.h"
namespace funk
{
-/**
- * @brief Enumeration of all supported binary operators in the Funk language.
- * This enum defines both arithmetic and logical binary operations.
- */
-enum class BinaryOp
-{
- PLUS, ///< Addition operator (+)
- MINUS, ///< Subtraction operator (-)
- MULTIPLY, ///< Multiplication operator (*)
- DIVIDE, ///< Division operator (/)
- MODULO, ///< Modulo operator (%)
- POWER, ///< Power operator (^)
-
- EQUAL, ///< Equality operator (==)
- NOT_EQUAL, ///< Inequality operator (!=)
- LESS, ///< Less than operator (<)
- LESS_EQUAL, ///< Less than or equal operator (<=)
- GREATER, ///< Greater than operator (>)
- GREATER_EQUAL, ///< Greater than or equal operator (>=)
- AND, ///< Logical AND operator (&&)
- OR, ///< Logical OR operator (||)
-};
-
-/**
- * @brief Converts a binary operator to a string representation.
- * @param op The binary operator
- * @return String representation of the operator
- */
-String op_to_s(BinaryOp op);
-
/**
* @brief Class representing a binary operation in the Funk AST.
*
@@ -56,7 +27,7 @@ public:
* @param op The binary operator to apply
* @param right The right-hand side expression
*/
- BinaryOpNode(ExpressionNode* left, BinaryOp op, ExpressionNode* right);
+ BinaryOpNode(ExpressionNode* left, const Token& op, ExpressionNode* right);
/**
* @brief Virtual destructor for proper cleanup of resources.
@@ -85,7 +56,7 @@ public:
* @brief Gets the binary operator used in this operation.
* @return The binary operator
*/
- BinaryOp get_op() const;
+ Token get_op() const;
/**
* @brief Gets the left-hand side expression of the binary operation.
@@ -100,7 +71,7 @@ public:
ExpressionNode* get_right() const;
private:
- BinaryOp op; ///< The binary operator
+ Token op; ///< The binary operator
ExpressionNode* left; ///< The left-hand side expression
ExpressionNode* right; ///< The right-hand side expression
};
diff --git a/include/ast/UnaryOpNode.h b/include/ast/UnaryOpNode.h
index 3255594b337c5d8c3a6180621dd9fb92450fb7e8..04da111694fcfbd22684bd48cc286fcc2b64b6ab 100644
--- a/include/ast/UnaryOpNode.h
+++ b/include/ast/UnaryOpNode.h
@@ -6,26 +6,11 @@
#include "ast/ExpressionNode.h"
#include "ast/LiteralNode.h"
+#include "token/Token.h"
namespace funk
{
-/**
- * @brief Enumeration of all supported unary operators in the Funk language.
- */
-enum class UnaryOp
-{
- NEGATE, ///< Negation operator (-)
- NOT, ///< Logical NOT operator (!)
-};
-
-/**
- * @brief Converts a unary operator to a string representation.
- * @param op The unary operator
- * @return String representation of the operator
- */
-String op_to_s(UnaryOp op);
-
/**
* @brief Class representing a unary operation in the Funk AST.
*
@@ -40,7 +25,7 @@ public:
* @param op The unary operator to apply
* @param expr The expression to apply the operator to
*/
- UnaryOpNode(UnaryOp op, ExpressionNode* expr);
+ UnaryOpNode(const Token& op, ExpressionNode* expr);
/**
* @brief Virtual destructor for proper cleanup of resources.
@@ -69,7 +54,7 @@ public:
* @brief Gets the unary operator used in this operation.
* @return The unary operator
*/
- UnaryOp get_op() const;
+ Token get_op() const;
/**
* @brief Gets the expression that the operator is applied to.
@@ -78,8 +63,8 @@ public:
ExpressionNode* get_expr() const;
private:
- UnaryOp op; ///< The unary operator
+ Token op; ///< The unary operator
ExpressionNode* expr; ///< The expression to apply the operator to
};
-} // namespace funk
\ No newline at end of file
+} // namespace funk
diff --git a/include/parser/Parser.h b/include/parser/Parser.h
index 46e06eab937fbb2a43e8c2cb7d37bd20cea9d3e3..287b64a9154043a1500bbf7e3c212a610e927cf3 100644
--- a/include/parser/Parser.h
+++ b/include/parser/Parser.h
@@ -34,9 +34,6 @@ private:
bool check(TokenType type) const;
bool match(TokenType expected);
- BinaryOp to_binary_op(const Token& token) const;
- UnaryOp to_unary_op(const Token& token) const;
-
Node* parse_statement();
Node* parse_expression();
Node* parse_assignment();
diff --git a/source/ast/BinaryOpNode.cc b/source/ast/BinaryOpNode.cc
index 553cdd9a530c3a0d45c61c7a4f7fa68a0a11980e..bf79f2d289d34049e90f33b5174f4a90287e6ff7 100644
--- a/source/ast/BinaryOpNode.cc
+++ b/source/ast/BinaryOpNode.cc
@@ -3,8 +3,8 @@
namespace funk
{
-BinaryOpNode::BinaryOpNode(ExpressionNode* left, BinaryOp op, ExpressionNode* right) :
- ExpressionNode(left->get_location()), op(op), left(left), right(right)
+BinaryOpNode::BinaryOpNode(ExpressionNode* left, const Token& op, ExpressionNode* right) :
+ ExpressionNode(op.get_location()), op(op), left(left), right(right)
{
}
@@ -25,22 +25,22 @@ Node* BinaryOpNode::evaluate() const
try
{
- switch (op)
+ switch (op.get_type())
{
- case BinaryOp::PLUS: result = left_value + right_value; break;
- case BinaryOp::MINUS: result = left_value - right_value; break;
- case BinaryOp::MULTIPLY: result = left_value * right_value; break;
- case BinaryOp::DIVIDE: result = left_value / right_value; break;
- case BinaryOp::MODULO: result = left_value % right_value; break;
- case BinaryOp::POWER: result = pow(left_value, right_value); break;
- case BinaryOp::EQUAL: result = left_value == right_value; break;
- case BinaryOp::NOT_EQUAL: result = left_value != right_value; break;
- case BinaryOp::LESS: result = left_value < right_value; break;
- case BinaryOp::LESS_EQUAL: result = left_value <= right_value; break;
- case BinaryOp::GREATER: result = left_value > right_value; break;
- case BinaryOp::GREATER_EQUAL: result = left_value >= right_value; break;
- case BinaryOp::AND: result = left_value && right_value; break;
- case BinaryOp::OR: result = left_value || right_value; break;
+ case TokenType::PLUS: result = left_value + right_value; break;
+ case TokenType::MINUS: result = left_value - right_value; break;
+ case TokenType::MULTIPLY: result = left_value * right_value; break;
+ case TokenType::DIVIDE: result = left_value / right_value; break;
+ case TokenType::MODULO: result = left_value % right_value; break;
+ case TokenType::POWER: result = pow(left_value, right_value); break;
+ case TokenType::EQUAL: result = left_value == right_value; break;
+ case TokenType::NOT_EQUAL: result = left_value != right_value; break;
+ case TokenType::LESS: result = left_value < right_value; break;
+ case TokenType::LESS_EQUAL: result = left_value <= right_value; break;
+ case TokenType::GREATER: result = left_value > right_value; break;
+ case TokenType::GREATER_EQUAL: result = left_value >= right_value; break;
+ case TokenType::AND: result = left_value && right_value; break;
+ case TokenType::OR: result = left_value || right_value; break;
default: throw RuntimeError(location, "Invalid binary operator");
}
}
@@ -58,7 +58,7 @@ Node* BinaryOpNode::evaluate() const
String BinaryOpNode::to_s() const
{
- return "(" + left->to_s() + " " + op_to_s(op) + " " + right->to_s() + ")";
+ return "(" + left->to_s() + " " + token_type_to_s(op.get_type()) + " " + right->to_s() + ")";
}
NodeValue BinaryOpNode::get_value() const
@@ -69,7 +69,7 @@ NodeValue BinaryOpNode::get_value() const
return result->get_value();
}
-BinaryOp BinaryOpNode::get_op() const
+Token BinaryOpNode::get_op() const
{
return op;
}
@@ -84,26 +84,4 @@ ExpressionNode* BinaryOpNode::get_right() const
return right;
}
-String op_to_s(BinaryOp op)
-{
- switch (op)
- {
- case BinaryOp::PLUS: return "+";
- case BinaryOp::MINUS: return "-";
- case BinaryOp::MULTIPLY: return "*";
- case BinaryOp::DIVIDE: return "/";
- case BinaryOp::MODULO: return "%";
- case BinaryOp::POWER: return "^";
- case BinaryOp::EQUAL: return "==";
- case BinaryOp::NOT_EQUAL: return "!=";
- case BinaryOp::LESS: return "<";
- case BinaryOp::LESS_EQUAL: return "<=";
- case BinaryOp::GREATER: return ">";
- case BinaryOp::GREATER_EQUAL: return ">=";
- case BinaryOp::AND: return "&&";
- case BinaryOp::OR: return "||";
- default: return "UNKNOWN";
- }
-}
-
} // namespace funk
diff --git a/source/ast/UnaryOpNode.cc b/source/ast/UnaryOpNode.cc
index 830c959561d2f70e75c252290d9da3825c03b285..1eda4a94f0d5e332a9282f0346b981f6f47e8113 100644
--- a/source/ast/UnaryOpNode.cc
+++ b/source/ast/UnaryOpNode.cc
@@ -3,8 +3,8 @@
namespace funk
{
-UnaryOpNode::UnaryOpNode(UnaryOp op, ExpressionNode* expr) :
- ExpressionNode(expr->get_location()), op(op), expr(expr) {
+UnaryOpNode::UnaryOpNode(const Token& op, ExpressionNode* expr) :
+ ExpressionNode(op.get_location()), op(op), expr(expr) {
};
@@ -22,10 +22,10 @@ Node* UnaryOpNode::evaluate() const
try
{
- switch (op)
+ switch (op.get_type())
{
- case UnaryOp::NEGATE: result = -expr_value; break;
- case UnaryOp::NOT: result = !expr_value; break;
+ case TokenType::MINUS: result = -expr_value; break;
+ case TokenType::NOT: result = !expr_value; break;
default: throw RuntimeError(location, "Invalid unary operator");
}
}
@@ -43,7 +43,7 @@ Node* UnaryOpNode::evaluate() const
String UnaryOpNode::to_s() const
{
- return "(" + op_to_s(op) + expr->to_s() + ")";
+ return "(" + token_type_to_s(op.get_type()) + expr->to_s() + ")";
}
NodeValue UnaryOpNode::get_value() const
@@ -54,7 +54,7 @@ NodeValue UnaryOpNode::get_value() const
return result->get_value();
}
-UnaryOp UnaryOpNode::get_op() const
+Token UnaryOpNode::get_op() const
{
return op;
}
@@ -64,14 +64,4 @@ ExpressionNode* UnaryOpNode::get_expr() const
return expr;
}
-String op_to_s(UnaryOp op)
-{
- switch (op)
- {
- case UnaryOp::NEGATE: return "-";
- case UnaryOp::NOT: return "!";
- default: return "UNKNOWN";
- }
-}
-
-}; // namespace funk
\ No newline at end of file
+}; // namespace funk
diff --git a/source/parser/Parser.cc b/source/parser/Parser.cc
index c41db9220846074f97a00ac78a854d0c25ea02af..ae664d7382f19a7a2ad1fba5397848b63e9ccf63 100644
--- a/source/parser/Parser.cc
+++ b/source/parser/Parser.cc
@@ -57,40 +57,6 @@ bool Parser::match(TokenType expected)
return true;
}
-BinaryOp Parser::to_binary_op(const Token& token) const
-{
- switch (token.get_type())
- {
- case TokenType::PLUS: return BinaryOp::PLUS;
- case TokenType::MINUS: return BinaryOp::MINUS;
- case TokenType::MULTIPLY: return BinaryOp::MULTIPLY;
- case TokenType::DIVIDE: return BinaryOp::DIVIDE;
- case TokenType::MODULO: return BinaryOp::MODULO;
- case TokenType::POWER: return BinaryOp::POWER;
- case TokenType::EQUAL: return BinaryOp::EQUAL;
- case TokenType::NOT_EQUAL: return BinaryOp::NOT_EQUAL;
- case TokenType::LESS: return BinaryOp::LESS;
- case TokenType::LESS_EQUAL: return BinaryOp::LESS_EQUAL;
- case TokenType::GREATER: return BinaryOp::GREATER;
- case TokenType::GREATER_EQUAL: return BinaryOp::GREATER_EQUAL;
- case TokenType::AND: return BinaryOp::AND;
- case TokenType::OR: return BinaryOp::OR;
-
- default: throw SyntaxError(token.get_location(), "Invalid binary operator: " + token.get_lexeme());
- }
-}
-
-UnaryOp Parser::to_unary_op(const Token& token) const
-{
- switch (token.get_type())
- {
- case TokenType::MINUS: return UnaryOp::NEGATE;
- case TokenType::NOT: return UnaryOp::NOT;
-
- default: throw SyntaxError(token.get_location(), "Invalid unary operator: " + token.get_lexeme());
- }
-}
-
Node* Parser::parse_statement()
{
LOG_DEBUG("Parse statement");
@@ -120,7 +86,7 @@ Node* Parser::parse_logical_or()
{
Token op{peek_prev()};
ExpressionNode* right{dynamic_cast<ExpressionNode*>(parse_logical_and())};
- left = new BinaryOpNode(left, to_binary_op(op), right);
+ left = new BinaryOpNode(left, op, right);
}
return left;
@@ -135,7 +101,7 @@ Node* Parser::parse_logical_and()
{
Token op{peek_prev()};
ExpressionNode* right{dynamic_cast<ExpressionNode*>(parse_equality())};
- left = new BinaryOpNode(left, to_binary_op(op), right);
+ left = new BinaryOpNode(left, op, right);
}
return left;
@@ -150,7 +116,7 @@ Node* Parser::parse_equality()
{
Token op{peek_prev()};
ExpressionNode* right{dynamic_cast<ExpressionNode*>(parse_comparison())};
- left = new BinaryOpNode(left, to_binary_op(op), right);
+ left = new BinaryOpNode(left, op, right);
}
return left;
@@ -166,7 +132,7 @@ Node* Parser::parse_comparison()
{
Token op{peek_prev()};
ExpressionNode* right{dynamic_cast<ExpressionNode*>(parse_additive())};
- left = new BinaryOpNode(left, to_binary_op(op), right);
+ left = new BinaryOpNode(left, op, right);
}
return left;
@@ -181,7 +147,7 @@ Node* Parser::parse_additive()
{
Token op{peek_prev()};
ExpressionNode* right{dynamic_cast<ExpressionNode*>(parse_multiplicative())};
- left = new BinaryOpNode(left, to_binary_op(op), right);
+ left = new BinaryOpNode(left, op, right);
}
return left;
@@ -197,7 +163,7 @@ Node* Parser::parse_multiplicative()
{
Token op{peek_prev()};
ExpressionNode* right{dynamic_cast<ExpressionNode*>(parse_unary())};
- left = new BinaryOpNode(left, to_binary_op(op), right);
+ left = new BinaryOpNode(left, op, right);
}
return left;
@@ -210,7 +176,7 @@ Node* Parser::parse_unary()
{
Token op{peek_prev()};
ExpressionNode* right{dynamic_cast<ExpressionNode*>(parse_factor())};
- return new UnaryOpNode(to_unary_op(op), right);
+ return new UnaryOpNode(op, right);
}
return parse_factor();