Basic parser

Signed-off-by: CHatingPython <chatingpython@gmail.com>

furc/include/furc/ast/declaration.hpp

@@ -0,0 +1,74 @@
+#ifndef FURC_AST_DECLARATION_HPP
+#define FURC_AST_DECLARATION_HPP
+
+#include "furc/ast/node.hpp"
+#include "furc/ast/statement.hpp"
+#include "furc/front/token.hpp"
+
+#include <ostream>
+#include <vector>
+
+namespace furc {
+namespace ast {
+
+enum class declaration_node_t {
+    Function,
+    Variable,
+};
+
+static inline std::ostream& operator<<(std::ostream& os, declaration_node_t type) {
+    switch (type) {
+    case declaration_node_t::Function: return os << "function";
+    case declaration_node_t::Variable: return os << "variable";
+    }
+}
+
+class declaration_node : public abstract_node<node_t::Declaration> {
+public:
+    virtual declaration_node_t type() const = 0;
+public:
+    virtual std::ostream& print(std::ostream& os) const = 0;
+
+    friend std::ostream& operator<<(std::ostream& os, const declaration_node& node) {
+        os << node.type() << " declaration";
+        return node.print(os);
+    }
+};
+
+struct function_body {
+    location                                 begin, end;
+    std::vector<node_handle<statement_node>> statements;
+};
+
+using function_body_handle = handle<ast::function_body>;
+
+class function_declarartion_node : public declaration_node {
+public:
+    function_declarartion_node(front::token name)
+      : m_name(name) {}
+
+    function_declarartion_node(front::token name, function_body&& body)
+      : m_name(name), m_body(std::move(body)) {}
+public:
+    declaration_node_t type() const override { return declaration_node_t::Function; }
+public:
+    std::ostream& print(std::ostream& os) const override {
+        os << ": " << m_name;
+        if (m_body.has_value()) {
+            os << '\n' << m_body->begin << ": begin:";
+            for (const auto& entry : m_body->statements) {
+                os << '\n' << entry;
+            }
+            os << '\n' << m_body->end << ": end";
+        }
+        return os;
+    }
+private:
+    front::token                 m_name;
+    std::optional<function_body> m_body;
+};
+
+} // namespace ast
+} // namespace furc
+
+#endif // FURC_AST_DECLARATION_HPP

furc/include/furc/ast/node.hpp

@@ -0,0 +1,44 @@
+#ifndef FURC_AST_NODE_HPP
+#define FURC_AST_NODE_HPP
+
+#include "furc/handle.hpp"
+
+#include <string>
+
+namespace furc {
+namespace ast {
+
+enum class node_t {
+    Literal,
+    Expression,
+    Statement,
+    Declaration,
+    Program,
+};
+
+class node {
+public:
+    node()          = default;
+    virtual ~node() = default;
+
+    node(node&&)                 = default;
+    node(const node&)            = delete;
+    node& operator=(node&&)      = default;
+    node& operator=(const node&) = delete;
+public:
+    virtual node_t category() const = 0;
+};
+
+template <node_t Category>
+class abstract_node : public node {
+public:
+    node_t category() const override { return Category; }
+};
+
+template <typename T, typename Error = std::string>
+using node_handle = handle<T*, Error>;
+
+} // namespace ast
+} // namespace furc
+
+#endif // FURC_AST_NODE_HPP

furc/include/furc/ast/program.hpp

@@ -0,0 +1,35 @@
+#ifndef FURC_AST_PROGRAM_HPP
+#define FURC_AST_PROGRAM_HPP
+
+#include "furc/ast/declaration.hpp"
+#include "furc/ast/node.hpp"
+
+#include <ostream>
+#include <vector>
+
+namespace furc {
+namespace ast {
+
+class program_node : public abstract_node<node_t::Program> {
+public:
+    program_node() {}
+public:
+    void push(node_handle<declaration_node>&& declaration) { m_declarations.push_back(std::move(declaration)); }
+
+    const std::vector<node_handle<declaration_node>>& declarations() const { return m_declarations; }
+public:
+    friend std::ostream& operator<<(std::ostream& os, const program_node& node) {
+        os << "program";
+        for (const auto& handle : node.m_declarations) {
+            os << '\n' << handle;
+        }
+        return os;
+    }
+private:
+    std::vector<node_handle<declaration_node>> m_declarations;
+};
+
+} // namespace ast
+} // namespace furc
+
+#endif // FURC_AST_PROGRAM_HPP

furc/include/furc/ast/statement.hpp

@@ -0,0 +1,60 @@
+#ifndef FURC_AST_STATEMENT_HPP
+#define FURC_AST_STATEMENT_HPP
+
+#include "furc/ast/node.hpp"
+
+#include <ostream>
+
+namespace furc {
+namespace ast {
+
+enum class statement_node_t {
+    Declaration,
+    Return,
+};
+
+static inline std::ostream& operator<<(std::ostream& os, statement_node_t type) {
+    switch (type) {
+    case statement_node_t::Declaration: return os << "declaration";
+    case statement_node_t::Return: return os << "return";
+    }
+}
+
+class statement_node : public abstract_node<node_t::Statement> {
+public:
+    virtual statement_node_t type() const = 0;
+public:
+    virtual std::ostream& print(std::ostream& os) const = 0;
+
+    friend std::ostream& operator<<(std::ostream& os, const statement_node& node) {
+        os << node.type() << " statement";
+        return node.print(os);
+    }
+};
+
+class declaration_node;
+class declaration_statement_node : public statement_node {
+public:
+    declaration_statement_node(declaration_node* declaration)
+      : m_declaration(declaration) {}
+public:
+    statement_node_t type() const override { return statement_node_t::Declaration; }
+
+    std::ostream& print(std::ostream& os) const override { return os; }
+private:
+    declaration_node* m_declaration = nullptr;
+};
+
+class return_statement_node : public statement_node {
+public:
+    return_statement_node() = default;
+public:
+    statement_node_t type() const override { return statement_node_t::Return; }
+
+    std::ostream& print(std::ostream& os) const override { return os; }
+};
+
+} // namespace ast
+} // namespace furc
+
+#endif // FURC_AST_STATEMENT_HPP