refactor pt.3

Rift-Org · Jul 12, 2024 · 97c0d93 · 97c0d93
1 parent 93dbf39
commit 97c0d93
Show file tree

Hide file tree

Showing 14 changed files with 296 additions and 396 deletions.
diff --git a/include/ast/decl.hh b/include/ast/decl.hh
@@ -41,7 +41,7 @@ namespace rift
         /// @class Decl
         /// @brief Declarations acceptor
         template <typename T>
-        class Decl: public Accept
+        class Decl
         {
             public:
                 virtual T accept(const Visitor &visitor) const = 0;
@@ -52,22 +52,22 @@ namespace rift
         class DeclStmt: public Decl
         {
             public:
-                DeclStmt(std::unique_ptr<Stmt> stmt) : stmt(std::move(stmt)) {};
+                DeclStmt(std::unique_ptr<Stmt<void>> stmt) : stmt(std::move(stmt)) {};
                 T accept(const Visitor &visitor) const override { return visitor.visit_decl_stmt(*this); }
 
-                std::unique_ptr<Stmt> stmt;
+                std::unique_ptr<Stmt<void>> stmt;
         };
 
         template <typename T>
         class DeclVar: public Decl
         {
             public:
                 DeclVar(const Token &identifier): identifier(identifier), expr(nullptr) {};
-                DeclVar(const Token &identifier, std::unique_ptr<Expr> expr): identifier(identifier), expr(std::move(expr)) {};
+                DeclVar(const Token &identifier, std::unique_ptr<Expr<Token>> expr): identifier(identifier), expr(std::move(expr)) {};
                 T accept(const Visitor &visitor) const override { return visitor.visit_decl_var(*this); }
 
                 const Token& identifier;
-                std::unique_ptr<Expr> expr;
+                std::unique_ptr<Expr<Token>> expr;
         };
 
         template <typename T>
@@ -78,7 +78,7 @@ namespace rift
                     Token name;
                     Tokens params;
                     Environment closure;
-                    std::unique_ptr<Block> blk;
+                    std::unique_ptr<Block<void>> blk;
                 } Func;
 
                 DeclFunc(): func(nullptr) {};

diff --git a/include/ast/eval.hh b/include/ast/eval.hh
@@ -30,18 +30,45 @@ namespace rift
 {
     namespace ast
     {
-        class Eval
+        class Eval : public ExprVisitor<Token>, StmtVisitor<Token>, 
+                            DeclVisitor<Token>, ProgramVisitor<Tokens>
         {
             public:
                 Eval();
                 ~Eval() = default;
 
+                // expressions
+                Token visit_assign(const Assign<Token>& expr) const override;
+                Token visit_binary(const Binary<Token>& expr) const override;
+                Token visit_grouping(const Grouping<Token>& expr) const override;
+                Token visit_literal(const Literal<Token>& expr) const override;
+                Token visit_var_expr(const VarExpr<Token>& expr) const override;
+                Token visit_unary(const Unary<Token>& expr) const override;
+                Token visit_ternary(const Ternary<Token>& expr) const override;
+                Token visit_call(const Call<Token>& expr) const override;
+
+                // statements
+                Token visit_expr_stmt(const StmtExpr<Token>& stmt) const override;
+                Token visit_print_stmt(const StmtPrint<Token>& stmt) const override;
+                Token visit_if_stmt(const StmtIf<Token>& stmt) const override;
+                Token visit_return_stmt(const StmtReturn<Token>& stmt) const override;
+                Token visit_block_stmt(const Block<Token>& block) const override;
+                Token visit_for_stmt(const For<Token>& decl) const override;
+
+                // declarations
+                Token visit_decl_stmt(const DeclStmt<Token>& decl) const override;
+                Token visit_decl_var(const DeclVar<Token>& decl) const override;
+                Token visit_decl_func(const DeclFunc<Token>& decl) const override;
+
+                // program
+                Tokens visit_program(const Program<Tokens>& prgm) const override;
+
                 /// @brief Evaluates the given *expr/stmt/decl*
-                std::vector<string> evaluate(const Program& expr, bool interactive);
+                std::vector<string> evaluate(const Program<Tokens>& expr, bool interactive);
 
-                /// @note resolving
-                static Token lookup(Expr* expr, std::string key);
-                void resolve(Expr* expr, int depth);
+                /// @note Resolver API
+                static Token lookup(Expr<Token>* expr, std::string key);
+                void resolve(Expr<Token>* expr, int depth);
 
             private:
                 std::unique_ptr<Visitor> visitor;

diff --git a/include/ast/expr.hh b/include/ast/expr.hh
@@ -126,7 +126,7 @@ namespace rift
                 Token name;
                 std::unique_ptr<Expr> value;
 
-                inline T accept(const ExprVisitor& visitor) const override { return visitor.visit_assign(*this); }
+                virtual inline T accept(const ExprVisitor& visitor) const override { return visitor.visit_assign(*this); }
         };
 
         /// @class Binary

diff --git a/include/ast/grmr.hh b/include/ast/grmr.hh
@@ -119,7 +119,6 @@ namespace rift
             Block
         )
 
-        using vec_prog = std::unique_ptr<std::vector<std::unique_ptr<Decl>>>;
         /// @class Visitor 
         /// @brief implementation of the statements and expressions
         class Visitor

diff --git a/include/ast/parser.hh b/include/ast/parser.hh
@@ -32,8 +32,6 @@ namespace rift
 {
     namespace ast
     {
-        class Stmt;
-
         /// @class Parser
         /// @brief The parser class is responsible for parsing the tokens generated by the scanner.
         class Parser : public Reader<Token>
@@ -87,27 +85,27 @@ namespace rift
                 /// @example return 1;
                 std::unique_ptr<Stmt<void>> statement_return();
                 /// @example { var x = 1; }
-                std::unique_ptr<Block<void>> statement_block();
+                std::unique_ptr<Stmt<void>> statement_block();
                 /// @example while(true) print("hi");
                 std::unique_ptr<Stmt<void>> statement_for();
 
 
                 /// @note rules in order of precedence <Decl>
                 /// @example var x = 1;
-                std::unique_ptr<DeclStmt> declaration_statement();
+                std::unique_ptr<Decl<Token>> declaration_statement();
                 /// @example mut x = 1; mut! x = 5;
-                std::unique_ptr<DeclVar> declaration_variable(bool mut);
+                std::unique_ptr<Decl<Token>> declaration_variable(bool mut);
                 /// @example func test() {}
-                std::unique_ptr<DeclFunc> declaration_func();
+                std::unique_ptr<Decl<Token>> declaration_func();
 
                 /// @brief returns any statements that might be executed 
                 std::unique_ptr<Stmt<void>> ret_stmt();
                 /// @brief returns any declarations that might be executed
-                vec_prog ret_decl();
+                Program::vec_t ret_decl();
 
 
                 /// @example func test() {}  or member.method()
-                std::unique_ptr<DeclFunc::Func> function(); 
+                std::unique_ptr<DeclFunc<Token>::Func> function(); 
                 /// @example 1, 2, 3
                 Tokens params();
                 /// @example 1+1, "str", a

diff --git a/include/ast/prgm.hh b/include/ast/prgm.hh
@@ -23,24 +23,28 @@ namespace rift
 {
     namespace ast
     {
-        class Stmt;
+        __DEFAULT_FORWARD_VA(
+            Program
+        )
 
-        class Program : public Accept<Tokens>
+        template <typename T>
+        class ProgramVisitor
+        {
+            virtual T visit_program(const Program<T>& prgm) const;
+        };
+        template <typename T>
+        class Program
         {
             public:
-                Program(vec_prog decls) : decls(std::move(decls)) {}
+                using vec_t = std::vector<std::unique_ptr<Decl<Token>>>;
+                Program(vec_t decls) : decls(std::move(decls)) {}
                 virtual ~Program() = default;
-                friend class Visitor;
-
-                Tokens accept(const Visitor &visitor) const override { return visitor.visit_program(*this); }
+                friend class Eval;
 
-                #pragma clang diagnostic push
-                #pragma clang diagnostic ignored "-Wunused-parameter"
-                std::string accept_printer(const Visitor& visitor) const override { return "unimplemented"; }
-                #pragma clang diagnostic pop
+                T accept(const Visitor &visitor) { return visitor.visit_program(*this); }
 
             protected:
-                vec_prog decls = nullptr;
+                vec_t decls = {};
         };
     }
 }
diff --git a/include/ast/printer.hh b/include/ast/printer.hh
@@ -19,6 +19,7 @@
 #include <ast/expr.hh>
 #include <ast/stmt.hh>
 #include <ast/decl.hh>
+#include <ast/prgm.hh>
 
 /// not in use now
 /// need futher re-evaluation
@@ -35,7 +36,8 @@ namespace rift
 
         /// @class Printer
         /// @brief This class is used to print the expression.
-        class Printer: public ExprVisitor<string>, public StmtVisitor<string>, public DeclVisitor<string>
+        class Printer: public ExprVisitor<string>, public StmtVisitor<string>, 
+                       public DeclVisitor<string>, public ProgramVisitor<string>
         {
             public:
                 using vec = std::vector<Expr<string>*>;
@@ -69,6 +71,9 @@ namespace rift
                 string visit_decl_stmt(const DeclStmt<string>& decl) const override;
                 string visit_decl_var(const DeclVar<string>& decl) const override;
                 string visit_decl_func(const DeclFunc<string>& decl) const override;
+
+                // program
+                string visit_program(const Program<string>& prgm) const override;
             protected:
 
                 /// @brief  Wraps the given expression in parentheses.