diff --git a/.clang-format b/.clang-format index 1271d76..b64883b 100755 --- a/.clang-format +++ b/.clang-format @@ -57,7 +57,7 @@ BreakArrays: false IncludeBlocks: Regroup SortIncludes: true -ReflowComments: false +ReflowComments: Always KeepEmptyLinesAtTheStartOfBlocks: true DerivePointerAlignment: false diff --git a/CMakeLists.txt b/CMakeLists.txt index 00f2199..0902bfe 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,5 +6,18 @@ enable_testing() find_package(GTest REQUIRED) +find_package(Doxygen) + add_subdirectory(furlang) -add_subdirectory(furc) \ No newline at end of file +add_subdirectory(furc) + +if(DOXYGEN_FOUND) + set(DOXYGEN_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/docs) + set(DOXYGEN_SHOW_ENUM_VALUES YES) + set(DOXYGEN_HIDE_UNDOC_NAMESPACES NO) + set(DOXYGEN_HIDE_UNDOC_RELATIONS NO) + set(DOXYGEN_FILE_PATTERNS "*.hpp") + doxygen_add_docs(doxygen_doc ${CMAKE_SOURCE_DIR}/furc/ ${CMAKE_SOURCE_DIR}/furlang/ + ALL WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + COMMENT "Generating API documentation with Doxygen") +endif() \ No newline at end of file diff --git a/furc/include/furc/ast/declaration.hpp b/furc/include/furc/ast/declaration.hpp index 6d602fa..c1da233 100644 --- a/furc/include/furc/ast/declaration.hpp +++ b/furc/include/furc/ast/declaration.hpp @@ -8,30 +8,69 @@ namespace furc { namespace ast { +/** + * @brief Declaration node type. + */ enum class declaration_node_t { - FunctionDeclaration, - FunctionDefinition, + Func, /**< Function declaration. */ + FuncDef, /**< Function definition. */ }; +/** + * @brief Declaration AST node interface. + */ class declaration_node : public statement_node { public: + /** + * @brief Returns this node's category. + * + * @return node_t::Declaration. + */ node_t category() const override { return node_t::Declaration; } - statement_node_t statement_type() const override { return statement_node_t::Declaration; } + /** + * @brief Returns this node's statement type. + * + * @return statement_node_t::Declaration. + */ + statement_node_t statement_type() const final { return statement_node_t::Declaration; } + /** + * @brief Returns this node's declaration type. + * + * @return The declaration type. + */ virtual declaration_node_t declaration_type() const = 0; protected: bool equal(const node& rhs) const override; }; +/** + * @brief Function declaration AST node. + */ class function_declaration_node : public declaration_node { public: + /** + * @brief Construct a new function declaration node object from name token. + * + * @param name Name of the function. + */ function_declaration_node(front::token name) - : m_name(name) {} + : p_name(name) {} public: - declaration_node_t declaration_type() const override { return declaration_node_t::FunctionDeclaration; } + /** + * @brief Returns this node's declaration type. + * + * @return declaration_node_t::FunctionDeclaration. + */ + declaration_node_t declaration_type() const override { return declaration_node_t::Func; } - front::token name() const { return m_name; } + /** + * @brief Returns function's name. + * + * @return Name of the function. + */ + front::token name() const { return p_name; } public: void accept(visitor& visitor) const override; @@ -39,16 +78,38 @@ public: protected: bool equal(const node& rhs) const override; protected: - front::token m_name; + /** + * @brief Name of the function. + */ + front::token p_name; }; +/** + * @brief Function definition AST node. + */ class function_definition_node final : public function_declaration_node { public: + /** + * @brief Construct a new function definition node object from name and body. + * + * @param name Name of the function. + * @param body Body of the function. + */ function_definition_node(front::token name, body_h&& body) : function_declaration_node(name), m_body(std::move(body)) {} public: - declaration_node_t declaration_type() const override { return declaration_node_t::FunctionDefinition; } + /** + * @brief Returns this node's declaration type. + * + * @return declaration_node_t::FunctionDefinition. + */ + declaration_node_t declaration_type() const override { return declaration_node_t::FuncDef; } + /** + * @brief Returns function's body. + * + * @return Body of the function. + */ const body_h& body() const { return m_body; } public: void accept(visitor& visitor) const override; diff --git a/furc/include/furc/ast/expression.hpp b/furc/include/furc/ast/expression.hpp index 4deb83d..a7d7ab9 100644 --- a/furc/include/furc/ast/expression.hpp +++ b/furc/include/furc/ast/expression.hpp @@ -7,34 +7,78 @@ namespace furc { namespace ast { +/** + * @brief Expression node type. + */ enum class expression_node_t { - Literal, - VarRead, - VarAssign, - Unaryop, - Binop, - Paren, + Literal, /**< Literal */ + VarRead, /**< Variable read expression */ + Unaryop, /**< Unary operation expression */ + Binop, /**< Binary operation expression */ + VarAssign, /**< Variable assignment expression */ }; +/** + * @brief Expression AST node. + */ class expression_node : public statement_node { public: + /** + * @brief Returns this node's category. + * + * @return node_t::Expression. + */ node_t category() const override { return node_t::Expression; } + /** + * @brief Returns this node's statement type. + * + * @return statement_node_t::Expression. + */ statement_node_t statement_type() const override { return statement_node_t::Expression; } + /** + * @brief Returns this node's expression type. + * + * @return The expression type. + */ virtual expression_node_t expression_type() const = 0; protected: bool equal(const node& rhs) const override; }; +/** + * @brief Var read expression AST node. + */ class var_read_expression_node final : public expression_node { public: + /** + * @brief Construct a new var read expression node object from a name handle. + * + * @param name Handle to the name. + */ var_read_expression_node(handle&& name) : m_name(std::move(name)) {} + /** + * @brief Returns the variable's name. + * + * @return Name of the variable. + */ const handle& get_name() const { return m_name; } - handle&& move_name() { return std::move(m_name); } + + /** + * @brief Returns the variable's name. + * + * @return Name of the variable. + */ + handle&& move_name() { return std::move(m_name); } public: + /** + * @brief Returns this node's expression type. + * + * @return expression_node_t::VarRead. + */ expression_node_t expression_type() const override { return expression_node_t::VarRead; } public: void accept(visitor& visitor) const override; @@ -46,27 +90,72 @@ private: handle m_name; }; +/** + * @brief Unary operation node type. + */ enum class unaryop_expression_node_t { - Positive, - Negative, - PrefixIncrement, - PostfixIncrement, - PrefixDecrement, - PostfixDecrement, + Positive, /**< Positive (unary plus) */ + Negative, /**< Negative (unary minus) */ + PrefixIncrement, /**< Prefix increment */ + PostfixIncrement, /**< Postfix increment */ + PrefixDecrement, /**< Prefix decrement */ + PostfixDecrement, /**< Postfix decrement */ }; +/** + * @brief Unary operation expression AST node. + */ class unaryop_expression_node final : public expression_node { public: + /** + * @brief Construct a new unaryop expression node object from type and expression node handle. + * + * @param type Operation type. + * @param node Handle to the inner expression node. + */ unaryop_expression_node(unaryop_expression_node_t type, expression_node_h&& node) : m_type(type), m_node(std::move(node)) {} + /** + * @brief Sets this node's inner expression. + * + * @param node New node handle. + */ void set_node(expression_node_h&& node) { m_node = std::move(node); } + /** + * @brief Returns the type of this node's operation. + * + * @return The operation type. + */ unaryop_expression_node_t type() const { return m_type; } - const expression_node_h& get_node() const { return m_node; } - expression_node_h& get_node() { return m_node; } - expression_node_h&& move_node() { return std::move(m_node); } + + /** + * @brief Returns this node's inner expression. + * + * @return The inner expression. + */ + const expression_node_h& get_node() const { return m_node; } + + /** + * @brief Returns this node's inner expression. + * + * @return The inner expression. + */ + expression_node_h& get_node() { return m_node; } + + /** + * @brief Moves this node's inner expression. + * + * @return The moved inner expression. + */ + expression_node_h&& move_node() { return std::move(m_node); } public: + /** + * @brief Returns this node's expression type. + * + * @return expression_node_t::Unaryop. + */ expression_node_t expression_type() const override { return expression_node_t::Unaryop; } public: void accept(visitor& visitor) const override; @@ -76,37 +165,91 @@ protected: bool equal(const node& rhs) const override; private: unaryop_expression_node_t m_type; - expression_node_h m_node; + expression_node_h m_node; /**< The inner expression. */ }; +/** + * @brief Binary operation expression node type. + */ enum class binop_expression_node_t { - None = 0, - Add, - Sub, - Mul, - Div, - Mod, + None = 0, /**< None */ + Add, /**< Addition */ + Sub, /**< Subtraction */ + Mul, /**< Multiplication */ + Div, /**< Division */ + Mod, /**< Modulo */ - Equal, - NotEqual, - LessThan, - GreaterThan, - LessEqual, - GreaterEqual, + Equal, /**< Equality */ + NotEqual, /**< Inequality */ + LessThan, /**< Less */ + GreaterThan, /**< Greater */ + LessEqual, /**< Less or equal */ + GreaterEqual, /**< Greater or equal */ }; +/** + * @brief Binary operation expression AST node. + */ class binop_expression_node final : public expression_node { public: + /** + * @brief Construct a new binary operation expression AST node. + * + * @param type Binary operation type. + * @param lhs Left-hand-side expression. + * @param rhs Right-hand-side expression. + */ binop_expression_node(binop_expression_node_t type, expression_node_h&& lhs, expression_node_h&& rhs) : m_type(type), m_lhs(std::move(lhs)), m_rhs(std::move(rhs)) {} - binop_expression_node_t type() const { return m_type; }; + /** + * @brief Returns this node's binary operation type. + * + * @return The binary operation type. + */ + binop_expression_node_t type() const { return m_type; }; + + /** + * @brief Returns this node's left-hand-side expression. + * + * @return The left-hand-side expression. + */ const expression_node_h& lhs() const { return m_lhs; }; - expression_node_h& lhs() { return m_lhs; }; - expression_node_h&& move_lhs() { return std::move(m_lhs); }; + + /** + * @brief Returns this node's left-hand-side expression. + * + * @return The left-hand-side expression. + */ + expression_node_h& lhs() { return m_lhs; }; + + /** + * @brief Moves this node's left-hand-side expression. + * + * @return The moved left-hand-side expression. + */ + expression_node_h&& move_lhs() { return std::move(m_lhs); }; + + /** + * @brief Returns this node's right-hand-side expression. + * + * @return The right-hand-side expression. + */ const expression_node_h& rhs() const { return m_rhs; }; - expression_node_h& rhs() { return m_rhs; }; - expression_node_h&& move_rhs() { return std::move(m_rhs); }; + + /** + * @brief Returns this node's right-hand-side expression. + * + * @return The right-hand-side expression. + */ + expression_node_h& rhs() { return m_rhs; }; + + /** + * @brief Moves this node's right-hand-side expression. + * + * @return The moved right-hand-side expression. + */ + expression_node_h&& move_rhs() { return std::move(m_rhs); }; public: expression_node_t expression_type() const override { return expression_node_t::Binop; } public: @@ -121,18 +264,56 @@ private: expression_node_h m_rhs; }; +/** + * @brief Variable assignment expression AST node. + */ class var_assign_expression_node final : public expression_node { public: + /** + * @brief Construct a new variable assignment expression AST node. + * + * @param lhs Left-hand-side expression handle. + * @param rhs Right-hand-side expression handle. + */ var_assign_expression_node(expression_node_h&& lhs, expression_node_h&& rhs) : m_compound(binop_expression_node_t::None), m_lhs(std::move(lhs)), m_rhs(std::move(rhs)) {} + /** + * @brief Construct a new compound variable assignment expression AST node. + * + * @param compound Compound operation type. + * @param lhs Left-hand-side expression handle. + * @param rhs Right-hand-side expression handle. + */ var_assign_expression_node(binop_expression_node_t compound, expression_node_h&& lhs, expression_node_h&& rhs) : m_compound(compound), m_lhs(std::move(lhs)), m_rhs(std::move(rhs)) {} - binop_expression_node_t compound() const { return m_compound; } + /** + * @brief Returns this node's compound operation type. + * + * @return The compound operation type. + */ + binop_expression_node_t compound() const { return m_compound; } + + /** + * @brief Returns this node's left-hand-side expression. + * + * @return The left-hand-side expression. + */ const expression_node_h& lhs() const { return m_lhs; } + + /** + * @brief Returns this node's right-hand-side expression. + * + * @return The right-hand-side expression. + */ const expression_node_h& rhs() const { return m_rhs; } public: + /** + * @brief Returns this node's expression type. + * + * @return expression_node_t::VarAssign. + */ expression_node_t expression_type() const override { return expression_node_t::VarAssign; } public: void accept(visitor& visitor) const override; diff --git a/furc/include/furc/ast/fwd.hpp b/furc/include/furc/ast/fwd.hpp index 33fa45d..a99a64b 100644 --- a/furc/include/furc/ast/fwd.hpp +++ b/furc/include/furc/ast/fwd.hpp @@ -7,63 +7,201 @@ #include namespace furc { + +/** + * @brief Abstract Syntax Tree definitions. + */ namespace ast { class node; +/** + * @brief Alias for handle to node. + * + * @tparam T AST node type. + */ template using node_handle = handle; class literal_node; + +/** + * @brief Alias for handle to literal_node. + * @see literal_node + */ using literal_node_h = node_handle; + class expression_node; + +/** + * @brief Alias for handle to expression_node. + * @see expression_node + */ using expression_node_h = node_handle; + class declaration_node; + +/** + * @brief Alias for handle to declaration_node. + * @see declaration_node + */ using declaration_node_h = node_handle; + class statement_node; + +/** + * @brief Alias for handle to statement_node. + * @see statement_node + */ using statement_node_h = node_handle; + class program_node; + +/** + * @brief Alias for handle to program_node. + * @see program_node + */ using program_node_h = node_handle; class string_literal_node; + +/** + * @brief Alias for handle to string_literal_node. + * @see string_literal_node + */ using string_literal_node_h = node_handle; + class integer_literal_node; + +/** + * @brief Alias for handle to integer_literal_node. + * @see integer_literal_node + */ using integer_literal_node_h = node_handle; class var_read_expression_node; + +/** + * @brief Alias for handle to var_read_expression_node. + * @see var_read_expression_node + */ using var_read_expression_node_h = node_handle; + class unaryop_expression_node; + +/** + * @brief Alias for handle to unaryop_expression_node. + * @see unaryop_expression_node + */ using unaryop_expression_node_h = node_handle; + class binop_expression_node; + +/** + * @brief Alias for handle to binop_expression_node. + * @see binop_expression_node + */ using binop_expression_node_h = node_handle; + class var_assign_expression_node; + +/** + * @brief Alias for handle to var_assign_expression_node. + * @see var_assign_expression_node + */ using var_assign_expression_node_h = node_handle; +/** + * @brief List of statements. + */ struct body { - location begin, end; + /** + * @brief Location of the opening curly. + */ + location begin; + + /** + * @brief Location of the closing curly. + */ + location end; + + /** + * @brief List of statements. + */ std::vector statements; + /** + * @brief Compares two bodies for equality. + * + * @param rhs Body to compare against. + * @return true if the bodies are equal. + */ bool operator==(const body& rhs) const { return begin == rhs.begin && end == rhs.end && statements == rhs.statements; } + /** + * @brief Compares two bodies for inequality. + * + * @param rhs Body to compare against. + * @return true if the bodies are not equal. + */ bool operator!=(const body& rhs) const { return !this->operator==(rhs); } - friend std::ostream& operator<<(std::ostream&, const body&); + /** + * @brief Prints a body to an output stream. + * + * @param os Output stream. + * @param body Body to print. + * @return The output stream. + */ + friend std::ostream& operator<<(std::ostream& os, const body& body); }; +/** + * @brief Alias for handle to body. + * @see body + */ using body_h = handle; class function_declaration_node; + +/** + * @brief Alias for handle to function_declaration_node. + * @see function_declaration_node + */ using function_declaration_node_h = node_handle; + class function_definition_node; + +/** + * @brief Alias for handle to function_definition_node. + * @see function_definition_node + */ using function_definition_node_h = node_handle; class return_statement_node; + +/** + * @brief Alias for handle to return_statement_node. + * @see return_statement_node + */ using return_statement_node_h = node_handle; + class if_statement_node; + +/** + * @brief Alias for handle to if_statement_node. + * @see if_statement_node + */ using if_statement_node_h = node_handle; + class compound_statement_node; + +/** + * @brief Alias for handle to compound_statement_node. + * @see compound_statement_node + */ using compound_statement_node_h = node_handle; } // namespace ast diff --git a/furc/include/furc/ast/literal.hpp b/furc/include/furc/ast/literal.hpp index 7e82b1f..bf03f97 100644 --- a/furc/include/furc/ast/literal.hpp +++ b/furc/include/furc/ast/literal.hpp @@ -8,29 +8,68 @@ namespace furc { namespace ast { +/** + * @brief Literal node type. + */ enum class literal_node_t { - String, - Integer + String, /**< String literal. */ + Integer, /**< Integer literal. */ }; +/** + * @brief Literal AST node. + */ class literal_node : public expression_node { public: + /** + * @brief Returns this node's category. + * + * @return node_t::Literal. + */ node_t category() const override { return node_t::Literal; } + /** + * @brief Returns this node's expression type. + * + * @return expression_node_t::Literal. + */ expression_node_t expression_type() const override { return expression_node_t::Literal; } + /** + * @brief Returns this node's literal type. + * + * @return The literal type. + */ virtual literal_node_t literal_type() const = 0; protected: bool equal(const node& rhs) const override; }; +/** + * @brief String literal AST node. + */ class string_literal_node final : public literal_node { public: + /** + * @brief Construct a new string literal node object from a handle. + * + * @param value A handle to value. + */ string_literal_node(handle&& value) : m_value(std::move(value)) {} public: + /** + * @brief Returns this node's literal type. + * + * @return literal_node_t::String. + */ literal_node_t literal_type() const override { return literal_node_t::String; } + /** + * @brief Returns this node's value. + * + * @return A handle to the value. + */ const handle& value() const { return m_value; } public: void accept(visitor& visitor) const override; @@ -42,15 +81,39 @@ private: handle m_value; }; +/** + * @brief Integer literal AST node. + */ class integer_literal_node final : public literal_node { public: + /** + * @brief Construct a new integer literal node object from a handle. + * + * @param value A handle to the value. + */ integer_literal_node(handle&& value) : m_value(std::move(value)) {} public: + /** + * @brief Returns this node's literal type. + * + * @return literal_node_t::Integer. + */ literal_node_t literal_type() const override { return literal_node_t::Integer; } + /** + * @brief Returns this node's value. + * + * @return A handle to the value. + */ const handle& value() const { return m_value; } + /** + * @brief Compares this node with an integer token for equality. + * + * @param integer Integer token to compare against. + * @return true if the integer token is equal to this node. + */ bool operator==(front::integer_token integer) const { return m_value == integer; } public: void accept(visitor& visitor) const override; diff --git a/furc/include/furc/ast/node.hpp b/furc/include/furc/ast/node.hpp index c3568a4..9a50947 100644 --- a/furc/include/furc/ast/node.hpp +++ b/furc/include/furc/ast/node.hpp @@ -7,14 +7,24 @@ namespace furc { namespace ast { +/** + * @brief Node category. + */ enum class node_t { - Literal, - Expression, - Statement, - Declaration, - Program, + Literal, /**< Literal. */ + Expression, /**< Expression. */ + Statement, /**< Statement. */ + Declaration, /**< Declaration. */ + Program, /**< Program. */ }; +/** + * @brief Prints a node type (category) to an output stream. + * + * @param os Output stream. + * @param type Type to print. + * @return The output stream. + */ static inline std::ostream& operator<<(std::ostream& os, node_t type) { switch (type) { case node_t::Literal: return os << "literal"; @@ -23,29 +33,98 @@ static inline std::ostream& operator<<(std::ostream& os, node_t type) { case node_t::Declaration: return os << "declaration"; case node_t::Program: return os << "program"; } + return os; } +/** + * @brief AST node interface. + */ class node { public: node() = default; virtual ~node() = default; - node(node&&) = default; - node(const node&) = delete; - node& operator=(node&&) = default; - node& operator=(const node&) = delete; + /** + * @brief Move constructor. + * + * Constructs a node by transferring the state of another node. + * + * @param other Node to move from. + */ + node(node&& other) = default; + node(const node&) = delete; + + /** + * @brief Move constructor. + * + * Constructs a node by transferring the state of another node. + * + * @param other Node to move from. + */ + node& operator=(node&& other) = default; + node& operator=(const node&) = delete; public: + /** + * @brief Returns the category of this AST node. + * @see node_t + * + * @return The node category. + */ virtual node_t category() const = 0; public: + /** + * @brief Compares two nodes for equality. + * + * Nodes are equal if they have the same category and + * their derived-class-specific contents are equal. + * + * @param rhs Node to compare against. + * @return true if the nodes are equal. + */ bool operator==(const node& rhs) const { return category() == rhs.category() && equal(rhs); } + + /** + * @brief Compares two nodes for inequality. + * + * @param rhs Node to compare against. + * @return true if the nodes are not equal. + */ bool operator!=(const node& rhs) const { return !this->operator==(rhs); } public: + /** + * @brief Accepts a visitor. + * + * Dispatches to the visitor overload corresponding to the concrete node type. + * + * @param visitor Visitor instance. + */ virtual void accept(visitor& visitor) const = 0; + /** + * @brief Prints a node to an output stream. + * + * @param os Output stream. + * @return The output stream. + */ virtual std::ostream& print(std::ostream& os) const = 0; + /** + * @brief Prints a node to an output stream. + * + * Equivalent to calling node.print(os). + * + * @param os Output stream. + * @param node Node to print. + * @return The output stream. + */ friend std::ostream& operator<<(std::ostream& os, const node& node) { return node.print(os); } protected: + /** + * @brief Compares two nodes for equality. + * + * @param rhs Node to compare against. + * @return true if nodes are equal. + */ virtual bool equal(const node& rhs) const = 0; }; diff --git a/furc/include/furc/ast/program.hpp b/furc/include/furc/ast/program.hpp index 89ce195..cbc5c2d 100644 --- a/furc/include/furc/ast/program.hpp +++ b/furc/include/furc/ast/program.hpp @@ -9,14 +9,27 @@ namespace furc { namespace ast { +/** + * @brief Program AST node. + */ class program_node final : public node { public: program_node() = default; node_t category() const override { return node_t::Program; } public: + /** + * @brief Adds a declaration to this program. + * + * @param declaration Declaration to add. + */ void push(node_handle&& declaration) { m_declarations.push_back(std::move(declaration)); } + /** + * @brief Returns a list of declarations of this program. + * + * @return The list of this program's declarations. + */ const std::vector>& declarations() const { return m_declarations; } public: void accept(visitor& visitor) const override; diff --git a/furc/include/furc/ast/statement.hpp b/furc/include/furc/ast/statement.hpp index 7f8b9f3..34d37ee 100644 --- a/furc/include/furc/ast/statement.hpp +++ b/furc/include/furc/ast/statement.hpp @@ -6,32 +6,66 @@ namespace furc { namespace ast { +/** + * @brief Statement node type. + */ enum class statement_node_t { - Expression, - Declaration, - Return, - If, - Compound, + Expression, /**< Expression */ + Declaration, /**< Declaration */ + Return, /**< Return statement */ + If, /**< If statement */ + Compound, /**< Compound statement */ }; +/** + * @brief Statement AST node. + */ class statement_node : public node { public: + /** + * @brief Returns this node's category. + * + * @return node_t::Statement. + */ node_t category() const override { return node_t::Statement; } + /** + * @brief Returns this node's statement type. + * + * @return The statement type. + */ virtual statement_node_t statement_type() const = 0; protected: bool equal(const node& rhs) const override; }; +/** + * @brief Return statement AST node. + */ class return_statement_node final : public statement_node { public: return_statement_node() = default; + /** + * @brief Construct a new return statement AST node. + * + * @param value Return value handle. + */ return_statement_node(expression_node_h&& value) : m_value(std::move(value)) {} public: + /** + * @brief Returns this node's return value handle. + * + * @return The return value handle. + */ expression_node_h value() const { return m_value; } public: + /** + * @brief Returns this node's statement type. + * + * @return statement_node_t::Return. + */ statement_node_t statement_type() const override { return statement_node_t::Return; } public: void accept(visitor& visitor) const override; @@ -40,21 +74,59 @@ public: protected: bool equal(const node& rhs) const override; private: - expression_node_h m_value; + expression_node_h m_value; /**< Return value handle. */ }; +/** + * @brief If statement AST node. + */ class if_statement_node final : public statement_node { public: + /** + * @brief Construct a new if statement AST node. + * + * @param cond Condition expression handle. + * @param then Then statement handle. + */ if_statement_node(expression_node_h&& cond, statement_node_h&& then) : m_cond(std::move(cond)), m_then(std::move(then)) {} + /** + * @brief Construct a new if statement AST node. + * + * @param cond Condition expression handle. + * @param then Then statement handle. + * @param elze Else statement handle. + */ if_statement_node(expression_node_h&& cond, statement_node_h&& then, statement_node_h&& elze) : m_cond(std::move(cond)), m_then(std::move(then)), m_else(std::move(elze)) {} public: - expression_node_h cond() const { return m_cond; } + /** + * @brief Returns this node's condition expression handle. + * + * @return The condition expression handle. + */ + expression_node_h cond() const { return m_cond; } + + /** + * @brief Returns this node's then statement handle. + * + * @return The then statement handle. + */ const statement_node_h& then() const { return m_then; } + + /** + * @brief Returns this node's else statement handle. + * + * @return The else statement handle. + */ const statement_node_h& elze() const { return m_else; } public: + /** + * @brief Returns this node's statement type. + * + * @return statement_node_t::If. + */ statement_node_t statement_type() const override { return statement_node_t::If; } public: void accept(visitor& visitor) const override; @@ -63,18 +135,36 @@ public: protected: bool equal(const node& rhs) const override; private: - expression_node_h m_cond; - statement_node_h m_then; - statement_node_h m_else; + expression_node_h m_cond; /**< The condition expression handle */ + statement_node_h m_then; /**< The then statement handle */ + statement_node_h m_else; /**< The else statement handle */ }; +/** + * @brief Compound statement AST node. + */ class compound_statement_node final : public statement_node { public: + /** + * @brief Construct a new compound statement AST node. + * + * @param body Body handle. + */ compound_statement_node(body_h&& body) : m_body(std::move(body)) {} public: + /** + * @brief Returns this node's body handle. + * + * @return The body handle. + */ const body_h& body() const { return m_body; } public: + /** + * @brief Returns this node's statement type. + * + * @return statement_node_t::Compound. + */ statement_node_t statement_type() const override { return statement_node_t::Compound; } public: void accept(visitor& visitor) const override; @@ -83,7 +173,7 @@ public: protected: bool equal(const node& rhs) const override; private: - body_h m_body; + body_h m_body; /**< The body handle. */ }; } // namespace ast diff --git a/furc/include/furc/ast/visitor.hpp b/furc/include/furc/ast/visitor.hpp index 745dd94..5e9c57d 100644 --- a/furc/include/furc/ast/visitor.hpp +++ b/furc/include/furc/ast/visitor.hpp @@ -6,28 +6,127 @@ namespace furc { namespace ast { +/** + * @brief Visitor pattern class for AST nodes. + */ class visitor { public: visitor() = default; virtual ~visitor() = default; - visitor(visitor&&) = default; - visitor& operator=(visitor&&) = default; - visitor(const visitor&) = default; + /** + * @brief Move constructor. + */ + visitor(visitor&&) = default; + + /** + * @brief Move constructor. + */ + visitor& operator=(visitor&&) = default; + + /** + * @brief Copy constructor. + */ + visitor(const visitor&) = default; + + /** + * @brief Copy constructor. + */ visitor& operator=(const visitor&) = default; public: - virtual void visit(const string_literal_node&) {} - virtual void visit(const integer_literal_node&) {} - virtual void visit(const var_read_expression_node&) {} - virtual void visit(const unaryop_expression_node&) {} - virtual void visit(const binop_expression_node&) {} - virtual void visit(const var_assign_expression_node&) {} - virtual void visit(const function_declaration_node&) {} - virtual void visit(const function_definition_node&) {} - virtual void visit(const return_statement_node&) {} - virtual void visit(const if_statement_node&) {} - virtual void visit(const compound_statement_node&) {} + /** + * @brief Visit a string_literal_node. + * @see string_literal_node + * + * @param node Node. + */ + virtual void visit(const string_literal_node& node) {} + /** + * @brief Visit a integer_literal_node. + * @see integer_literal_node + * + * @param node Node. + */ + virtual void visit(const integer_literal_node& node) {} + + /** + * @brief Visit a var_read_expression_node. + * @see var_read_expression_node + * + * @param node Node. + */ + virtual void visit(const var_read_expression_node& node) {} + + /** + * @brief Visit a unaryop_expression_node. + * @see unaryop_expression_node + * + * @param node Node. + */ + virtual void visit(const unaryop_expression_node& node) {} + + /** + * @brief Visit a binop_expression_node. + * @see binop_expression_node + * + * @param node Node. + */ + virtual void visit(const binop_expression_node& node) {} + + /** + * @brief Visit a var_assign_expression_node. + * @see var_assign_expression_node + * + * @param node Node. + */ + virtual void visit(const var_assign_expression_node& node) {} + + /** + * @brief Visit a function_declaration_node. + * @see function_declaration_node + * + * @param node Node. + */ + virtual void visit(const function_declaration_node& node) {} + + /** + * @brief Visit a function_definition_node. + * @see function_definition_node + * + * @param node Node. + */ + virtual void visit(const function_definition_node& node) {} + + /** + * @brief Visit a return_statement_node. + * @see return_statement_node + * + * @param node Node. + */ + virtual void visit(const return_statement_node& node) {} + + /** + * @brief Visit a if_statement_node. + * @see if_statement_node + * + * @param node Node. + */ + virtual void visit(const if_statement_node& node) {} + + /** + * @brief Visit a compound_statement_node. + * @see compound_statement_node + * + * @param node Node. + */ + virtual void visit(const compound_statement_node& node) {} + + /** + * @brief Visit a node handle with an error. + * + * @param handle Node handle. + */ virtual void visit_error(const node_handle& handle) {} }; diff --git a/furc/include/furc/diag.hpp b/furc/include/furc/diag.hpp index 59e15de..efe204b 100644 --- a/furc/include/furc/diag.hpp +++ b/furc/include/furc/diag.hpp @@ -6,15 +6,30 @@ namespace furc { +/** + * @brief A location in file. + */ struct location { - std::string_view filename; - std::size_t line = 0; - std::size_t column = 0; + std::string_view filename; /**< File's name */ + std::size_t line = 0; /**< Line */ + std::size_t column = 0; /**< Column */ + /** + * @brief Compare two locations for equality. + * + * @param rhs Location to compare against. + * @return true if the locations are equal. + */ bool operator==(const location& rhs) const { return filename == rhs.filename && line == rhs.line && column == rhs.column; } + /** + * @brief Compare two locations for inequality. + * + * @param rhs Location to compare against. + * @return true if the locations are not equal. + */ bool operator!=(const location& rhs) const { return !this->operator==(rhs); } }; diff --git a/furc/include/furc/front/lexer.hpp b/furc/include/furc/front/lexer.hpp index d111c16..b976f5f 100644 --- a/furc/include/furc/front/lexer.hpp +++ b/furc/include/furc/front/lexer.hpp @@ -6,19 +6,50 @@ namespace furc { namespace front { +/** + * @brief Lexer. + * + * Furlang's lazy tokenizer. + */ class lexer { public: lexer() = default; + + /** + * @brief Construct a new lexer. + * + * @param filename Filename for debugging. + * @param content Content. + */ lexer(std::string_view filename, std::string_view content); ~lexer() = default; - lexer(lexer&&) = default; - lexer(const lexer&) = delete; - lexer& operator=(lexer&&) = default; + /** + * @brief Move constructor. + */ + lexer(lexer&&) = default; + + lexer(const lexer&) = delete; + + /** + * @brief Move constructor. + */ + lexer& operator=(lexer&&) = default; + lexer& operator=(const lexer&) = delete; public: + /** + * @brief Returns a handle to next token. + * + * @return The token handle. + */ token_handle<> next_token(); + /** + * @brief Checks whether the cursor is at the EOF. + * + * @return true if the cursor is at the EOF. + */ bool empty() const { return m_cursor >= m_content.size(); } private: void next(); diff --git a/furc/include/furc/front/parser.hpp b/furc/include/furc/front/parser.hpp index a2ce903..2f9f160 100644 --- a/furc/include/furc/front/parser.hpp +++ b/furc/include/furc/front/parser.hpp @@ -10,18 +10,50 @@ namespace furc { namespace front { -class parser { +/** + * @brief Parser. + * + * Furlang's parser. + */ +class parser final { public: + /** + * @brief Construct a new parser from content. + * + * @param filename Filename for debugging. + * @param content Content. + */ parser(std::string_view filename, std::string_view content); + + /** + * @brief Construct a new parser from file. + * + * Constructs a lexer with content read from file passed through \p filename. + * + * @param filename Name of the file. + */ parser(std::string_view filename); ~parser() = default; - parser(parser&&) = default; - parser(const parser&) = delete; - parser& operator=(parser&&) = default; + /** + * @brief Move constructor. + */ + parser(parser&&) = default; + + parser(const parser&) = delete; + + /** + * @brief Move constructor. + */ + parser& operator=(parser&&) = default; + parser& operator=(const parser&) = delete; public: - // parser owns the arena :3c + /** + * @brief Returns a parsed program. + * + * @return Handle to an AST node of the program. + */ ast::program_node_h parse() &; private: ast::declaration_node_h parse_declaration(); diff --git a/furc/include/furc/front/token.hpp b/furc/include/furc/front/token.hpp index ea70ad9..16663b4 100644 --- a/furc/include/furc/front/token.hpp +++ b/furc/include/furc/front/token.hpp @@ -10,44 +10,48 @@ namespace furc { namespace front { +/** + * @brief Token type. + */ enum class token_t { - None, - Identifier, - String, - Keyword, - Integer, - LParen, - RParen, - LBrace, - RBrace, - LBracket, - RBracket, - Semicolon, - Colon, - Comma, - Dot, + None, /**< None */ + Identifier, /**< Identifier */ + String, /**< String */ + Keyword, /**< Keyword */ + Integer, /**< Integer */ - Plus, - Minus, - Star, - Slash, - Percent, - DPlus, - DMinus, + LParen, /**< `(` */ + RParen, /**< `)` */ + LBrace, /**< `{` */ + RBrace, /**< `}` */ + LBracket, /**< `[` */ + RBracket, /**< `]` */ + Semicolon, /**< `;` */ + Colon, /**< `:` */ + Comma, /**< `,` */ + Dot, /**< `.` */ - Eq, - PlusEq, - MinusEq, - StarEq, - SlashEq, - PercentEq, + Plus, /**< `+` */ + Minus, /**< `-` */ + Star, /**< `*` */ + Slash, /**< `/` */ + Percent, /**< `%` */ + DPlus, /**< `++` */ + DMinus, /**< `--` */ - DEq, - NotEq, - LessThan, - GreaterThan, - LessEq, - GreaterEq, + Eq, /**< `=` */ + PlusEq, /**< `+=` */ + MinusEq, /**< `-=` */ + StarEq, /**< `*=` */ + SlashEq, /**< `/=` */ + PercentEq, /**< `%=` */ + + DEq, /**< `==` */ + NotEq, /**< `!=` */ + LessThan, /**< `<` */ + GreaterThan, /**< `>` */ + LessEq, /**< `<=` */ + GreaterEq, /**< `>=` */ }; static inline std::ostream& operator<<(std::ostream& os, token_t type) { @@ -130,12 +134,15 @@ static inline std::string operator+(const std::string& str, token_t type) { return str; } +/** + * @brief Keyword token. + */ enum class keyword_token { - None, - Func, - Return, - If, - Else, + None, /**< None */ + Func, /**< `func` */ + Return, /**< `return` */ + If, /**< `if` */ + Else, /**< `else` */ }; static inline std::ostream& operator<<(std::ostream& os, keyword_token keyword) { @@ -160,43 +167,130 @@ static inline std::string operator+(const std::string& str, keyword_token keywor return str; } -using integer_token = std::uint64_t; +using integer_token = std::uint64_t; /**< Integer token. */ +/** + * @brief Token. + */ struct token { - token_t type = token_t::None; + token_t type = token_t::None; /**< Token type. */ + /** + * @brief Token's value. + */ union value { - std::nullptr_t null; - std::string_view string; - keyword_token keyword; - integer_token integer; + /** + * @brief Null value. For token_t::None, token_t::Plus, token_t::Minus, etc. + * @see token_t::None + */ + std::nullptr_t null; + /** + * @brief String value. For token_t::Identifier and token_t::String. + * @see token_t::Identifier + * @see token_t::String + */ + std::string_view string; + + /** + * @brief Keyword value. For token_t::Keyword. + * @see token_t::Keyword. + */ + keyword_token keyword; + + /** + * @brief Integer value. For token_t::Integer. + * @see token_t::Integer + */ + integer_token integer; + + /** + * @brief Construct a new null value. + * + * @param value Null value. + */ value(std::nullptr_t value = nullptr) : null(value) {} + /** + * @brief Construct a new string value. + * + * @param value The string. + */ value(std::string_view value) : string(value) {} + /** + * @brief Construct a new keyword value. + * + * @param value The keyword. + */ value(keyword_token value) : keyword(value) {} + /** + * @brief Construct a new integer value. + * + * @param value The integer. + */ value(integer_token value) : integer(value) {} - } value; + } value; /**< Token value. */ token() = default; - token(token_t type, std::string_view value = {}) + /** + * @brief Construct a new null token. + * + * @param type Token's type. + */ + token(token_t type) + : type(type) {} + + /** + * @brief Construct a new string token. + * + * @param type Token's type. + * @param value String value. + */ + token(token_t type, std::string_view value) : type(type), value(value) {} - token(keyword_token keyword, std::string_view value = {}) + /** + * @brief Construct a new keyword token. + * + * @param keyword Keyword value. + */ + token(keyword_token keyword) : type(token_t::Keyword), value(keyword) {} + /** + * @brief Construct a new integer token. + * + * @param integer Integer value. + */ token(integer_token integer) : type(token_t::Integer), value(integer) {} - union value* operator->() { return &value; } + /** + * @brief Returns pointer to this token's value. + * + * @return Pointer to the token's value. + */ + union value* operator->() { return &value; } + + /** + * @brief Returns constant pointer to this token's value. + * + * @return Pointer to the token's value. + */ const union value* operator->() const { return &value; } + /** + * @brief Compares two tokens for equality. + * + * @param rhs Token to compare against. + * @return true if the tokens are equal. + */ bool operator==(const token& rhs) const { if (type != rhs.type) return false; switch (type) { @@ -220,7 +314,7 @@ static inline std::ostream& operator<<(std::ostream& os, const token& token) { } template -using token_handle = handle; +using token_handle = handle; /**< Alias to handle of token. */ } // namespace front } // namespace furc diff --git a/furc/src/ast.cpp b/furc/src/ast.cpp index 38bba4c..c8662be 100644 --- a/furc/src/ast.cpp +++ b/furc/src/ast.cpp @@ -143,11 +143,11 @@ void function_declaration_node::accept(visitor& visitor) const { } std::ostream& function_declaration_node::print(std::ostream& os) const { - return os << "function " << m_name->string << " declaration"; + return os << "function " << p_name->string << " declaration"; } bool function_declaration_node::equal(const node& rhs) const { - return declaration_node::equal(rhs) && m_name == reinterpret_cast(rhs).m_name; + return declaration_node::equal(rhs) && p_name == reinterpret_cast(rhs).p_name; } void function_definition_node::accept(visitor& visitor) const { @@ -160,7 +160,7 @@ std::ostream& function_definition_node::print(std::ostream& os) const { if (m_body.present()) { for (const auto& entry : m_body->statements) os << '\n' << entry; - return os << '\n' << m_body->end << ": " << m_name->string << " end"; + return os << '\n' << m_body->end << ": " << p_name->string << " end"; } return os << m_body.error(); // error } diff --git a/furc/src/front/lexer.cpp b/furc/src/front/lexer.cpp index 09d5c70..b0bae2b 100644 --- a/furc/src/front/lexer.cpp +++ b/furc/src/front/lexer.cpp @@ -94,7 +94,7 @@ token_handle<> lexer::next_token() { { "else", keyword_token::Else }, }; - if (auto it = s_keywords.find(value); it != s_keywords.end()) return { location, it->second, value }; + if (auto it = s_keywords.find(value); it != s_keywords.end()) return { location, it->second }; return { location, token_t::Identifier, value }; } diff --git a/furc/test/parser.cpp b/furc/test/parser.cpp index ece6334..c9978d3 100644 --- a/furc/test/parser.cpp +++ b/furc/test/parser.cpp @@ -22,7 +22,7 @@ TEST(Parser, EmptyFunctions) { { auto first = program->declarations()[0]; EXPECT_TRUE(first.present()); - EXPECT_EQ(first->declaration_type(), declaration_node_t::FunctionDefinition); + EXPECT_EQ(first->declaration_type(), declaration_node_t::FuncDef); function_definition_node_h funcDef = first; EXPECT_EQ(funcDef->name()->string, "main"); EXPECT_EQ(funcDef->body()->statements.size(), 0); @@ -30,7 +30,7 @@ TEST(Parser, EmptyFunctions) { { auto second = program->declarations()[1]; EXPECT_TRUE(second.present()); - EXPECT_EQ(second->declaration_type(), declaration_node_t::FunctionDeclaration); + EXPECT_EQ(second->declaration_type(), declaration_node_t::Func); function_declaration_node_h funcDecl = second; EXPECT_EQ(funcDecl->name()->string, "foo"); } @@ -47,7 +47,7 @@ TEST(Parser, Literals) { { auto test1 = program->declarations()[0]; EXPECT_TRUE(test1.present()); - EXPECT_EQ(test1->declaration_type(), declaration_node_t::FunctionDefinition); + EXPECT_EQ(test1->declaration_type(), declaration_node_t::FuncDef); function_definition_node_h funcDef = test1; EXPECT_EQ(funcDef->name()->string, "test1"); EXPECT_EQ(funcDef->body()->statements.size(), 1); @@ -57,7 +57,7 @@ TEST(Parser, Literals) { { auto test2 = program->declarations()[1]; EXPECT_TRUE(test2.present()); - EXPECT_EQ(test2->declaration_type(), declaration_node_t::FunctionDefinition); + EXPECT_EQ(test2->declaration_type(), declaration_node_t::FuncDef); function_definition_node_h funcDecl = test2; EXPECT_EQ(funcDecl->name()->string, "test2"); } @@ -87,7 +87,7 @@ TEST(Parser, OperatorPrecedence_AddMul) { EXPECT_EQ(program->declarations().size(), 1); auto func = program->declarations()[0]; EXPECT_TRUE(func.present()); - EXPECT_EQ(func->declaration_type(), declaration_node_t::FunctionDefinition); + EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef); function_definition_node_h funcDef = func; EXPECT_EQ(funcDef->name()->string, "main"); EXPECT_EQ(funcDef->body()->statements.size(), 1); @@ -115,7 +115,7 @@ TEST(Parser, OperatorPrecedence_Complex) { EXPECT_EQ(program->declarations().size(), 1); auto func = program->declarations()[0]; EXPECT_TRUE(func.present()); - EXPECT_EQ(func->declaration_type(), declaration_node_t::FunctionDefinition); + EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef); function_definition_node_h funcDef = func; EXPECT_EQ(funcDef->name()->string, "main"); EXPECT_EQ(funcDef->body()->statements.size(), 1); @@ -153,7 +153,7 @@ TEST(Parser, UnaryOperator_Simple) { EXPECT_EQ(program->declarations().size(), 1); auto func = program->declarations()[0]; EXPECT_TRUE(func.present()); - EXPECT_EQ(func->declaration_type(), declaration_node_t::FunctionDefinition); + EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef); function_definition_node_h funcDef = func; EXPECT_EQ(funcDef->name()->string, "main"); EXPECT_EQ(funcDef->body()->statements.size(), 1); @@ -175,7 +175,7 @@ TEST(Parser, UnaryOperator_PrePost) { EXPECT_EQ(program->declarations().size(), 1); auto func = program->declarations()[0]; EXPECT_TRUE(func.present()); - EXPECT_EQ(func->declaration_type(), declaration_node_t::FunctionDefinition); + EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef); function_definition_node_h funcDef = func; EXPECT_EQ(funcDef->name()->string, "main"); EXPECT_EQ(funcDef->body()->statements.size(), 1); @@ -200,7 +200,7 @@ TEST(Parser, Paren) { EXPECT_EQ(program->declarations().size(), 1); auto func = program->declarations()[0]; EXPECT_TRUE(func.present()); - EXPECT_EQ(func->declaration_type(), declaration_node_t::FunctionDefinition); + EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef); function_definition_node_h funcDef = func; EXPECT_EQ(funcDef->name()->string, "main"); EXPECT_EQ(funcDef->body()->statements.size(), 1); @@ -226,7 +226,7 @@ TEST(Parser, Assignment) { EXPECT_EQ(program->declarations().size(), 1); auto func = program->declarations()[0]; EXPECT_TRUE(func.present()); - EXPECT_EQ(func->declaration_type(), declaration_node_t::FunctionDefinition); + EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef); function_definition_node_h funcDef = func; EXPECT_EQ(funcDef->name()->string, "main"); EXPECT_EQ(funcDef->body()->statements.size(), 1); @@ -255,7 +255,7 @@ TEST(Parser, CompoundAssignment) { EXPECT_EQ(program->declarations().size(), 1); auto func = program->declarations()[0]; EXPECT_TRUE(func.present()); - EXPECT_EQ(func->declaration_type(), declaration_node_t::FunctionDefinition); + EXPECT_EQ(func->declaration_type(), declaration_node_t::FuncDef); function_definition_node_h funcDef = func; EXPECT_EQ(funcDef->name()->string, "main"); EXPECT_EQ(funcDef->body()->statements.size(), 1); diff --git a/furlang/include/furlang/arena.hpp b/furlang/include/furlang/arena.hpp index a0111ee..ef87d97 100644 --- a/furlang/include/furlang/arena.hpp +++ b/furlang/include/furlang/arena.hpp @@ -8,6 +8,9 @@ namespace furlang { +/** + * @brief An arena (region) allocator implementation. + */ class arena { private: struct region { @@ -23,14 +26,35 @@ private: std::size_t free() const { return capacity - used; } }; public: + /** + * @brief Construct a new arena. + * + * @param minCapacity Minimal capacity of a single region in words. + */ arena(std::size_t minCapacity = 4 * 1024ULL); ~arena(); + /** + * @brief Move constructor + */ arena(arena&& other) noexcept; + arena(const arena&) = delete; + + /** + * @brief Move constructor + */ arena& operator=(arena&& other) noexcept; + arena& operator=(const arena&) = delete; public: + /** + * @brief Allocates and default constructs objects. + * + * @tparam T Type of the objects. + * @param count How many objects to allocate. + * @return A pointer to the allocated objects. + */ template >> T* allocate(std::size_t count) { T* allocated = reinterpret_cast(allocate(sizeof(T), count)); @@ -40,6 +64,13 @@ public: return allocated; } + /** + * @brief Allocates and constructs an object. + * + * @tparam T Type of the object. + * @param args Arguments passed to the object's constructor. + * @return A pointer to the allocated object. + */ template >> T* allocate(Args&&... args) { T* allocated = reinterpret_cast(allocate(sizeof(T), 1)); @@ -47,12 +78,25 @@ public: return allocated; } + /** + * @brief Allocates and constructs an object. + * + * @tparam T Type of the object. + * @param args Arguments passed to the object's constructor. + * @return A shared pointer to the allocated object. + */ template std::shared_ptr allocate_shared(Args&&... args) { T* allocated = allocate(std::forward(args)...); return std::shared_ptr(allocated, [](T* object) { object->~T(); }); } + /** + * @brief Resets the arena. + * + * Resets occupied size of regions. Using previously allocated pointers after calling this function is + * undefined-behaviour. + */ void reset(); private: void* allocate(std::size_t size, std::size_t count); diff --git a/furlang/include/furlang/furlang.hpp b/furlang/include/furlang/furlang.hpp new file mode 100644 index 0000000..47d6cfd --- /dev/null +++ b/furlang/include/furlang/furlang.hpp @@ -0,0 +1,11 @@ +#ifndef FURLANG_HPP +#define FURLANG_HPP + +#include "furlang/result.hpp" // IWYU pragma: export + +/** + * @brief The common furlang library. + */ +namespace furlang {} + +#endif // FURLANG_HPP \ No newline at end of file diff --git a/furlang/include/furlang/ir/block.hpp b/furlang/include/furlang/ir/block.hpp index 6b0c8c1..289249b 100644 --- a/furlang/include/furlang/ir/block.hpp +++ b/furlang/include/furlang/ir/block.hpp @@ -10,13 +10,26 @@ namespace furlang { namespace ir { -// https://en.wikipedia.org/wiki/Basic_block +/** + * @brief Basic block. + * + * A basic block of IR instructions. https://en.wikipedia.org/wiki/Basic_block + */ class block { public: - using value_type = std::unique_ptr; + using value_type = std::unique_ptr; /**< Value type */ public: block() = default; public: + /** + * @brief Emplaces a new instruction. + * + * Emplaces a new instruction, if exit instruction hasn't been emplaced in this block yet. + * + * @tparam T Type of the instruction to emplace. + * @param args Arguments to call the constructor with. + * @return true if the instruction has been emplaced successfully. + */ template >> bool emplace(Args&&... args) { if (has_exit()) return false; @@ -29,11 +42,39 @@ public: return true; } - std::vector& instructions() { return m_instructions; } + /** + * @brief Returns this block's instructions. + * + * @return The instructions. + */ + std::vector& instructions() { return m_instructions; } + + /** + * @brief Returns this block's instructions. + * + * @return The instructions. + */ const std::vector& instructions() const { return m_instructions; } - bool has_exit() const { return m_exit != nullptr; } - value_type& exit() { return m_exit; } + /** + * @brief Checks whether an exit instruction has been emplaced in this block yet. + * + * @return true if the exit instruction has been emplaced. + */ + bool has_exit() const { return m_exit != nullptr; } + + /** + * @brief Returns this block's exit instruction. + * + * @return The exit instruction. + */ + value_type& exit() { return m_exit; } + + /** + * @brief Returns this block's exit instruction. + * + * @return The exit instruction. + */ const value_type& exit() const { return m_exit; } private: std::vector m_instructions; diff --git a/furlang/include/furlang/ir/function.hpp b/furlang/include/furlang/ir/function.hpp index 733d634..4835c18 100644 --- a/furlang/include/furlang/ir/function.hpp +++ b/furlang/include/furlang/ir/function.hpp @@ -9,20 +9,51 @@ namespace furlang { namespace ir { +/** + * @brief IR function. + * + * Consists of a name and blocks. + * @see block + */ class function { public: - using value_type = std::shared_ptr; + using value_type = std::shared_ptr; /**< Value type. */ public: + /** + * @brief Construct a new IR function. + * + * @param name Name to copy. + */ function(const std::string& name) : m_name(name) {} + /** + * @brief Construct a new IR function. + * + * @param name Name to move. + */ function(std::string&& name) : m_name(std::move(name)) {} public: + /** + * @brief Returns this function's name. + * + * @return The name. + */ const std::string& name() const { return m_name; } + /** + * @brief Pushes and returns a new IR block. + * + * @return The new IR block. + */ value_type push() { return m_blocks.emplace_back(std::make_shared()); } + /** + * @brief Returns this function's IR blocks. + * + * @return The IR blocks. + */ const std::vector& blocks() const { return m_blocks; } private: std::string m_name; diff --git a/furlang/include/furlang/ir/instruction.hpp b/furlang/include/furlang/ir/instruction.hpp index fed51f0..668c730 100644 --- a/furlang/include/furlang/ir/instruction.hpp +++ b/furlang/include/furlang/ir/instruction.hpp @@ -10,16 +10,25 @@ namespace furlang { namespace ir { +/** + * @brief IR instruction type. + */ enum class instruction_t { - Alloca, - Assign, - BinaryOp, - Call, - Branch, - BranchCond, - Return, + Alloca, /**< Unused */ + Assign, /**< Assign */ + BinaryOp, /**< Binary operation */ + Call, /**< Call */ + Branch, /**< Branch */ + BranchCond, /**< Conditional branch */ + Return, /**< Return */ }; +/** + * @brief Checks if an instruction type exits. + * + * @param type Instruction type. + * @return true if the instruction type exits. + */ static inline bool is_exit_instruction(instruction_t type) { switch (type) { case instruction_t::Branch: @@ -29,54 +38,137 @@ static inline bool is_exit_instruction(instruction_t type) { } } +/** + * @brief IR instruction + */ class instruction { public: instruction() = default; virtual ~instruction() = default; - instruction(instruction&&) = default; - instruction& operator=(instruction&&) = default; - instruction(const instruction&) = delete; + /** + * @brief Move constructor + */ + instruction(instruction&&) = default; + + /** + * @brief Move constructor + */ + instruction& operator=(instruction&&) = default; + + instruction(const instruction&) = delete; + instruction& operator=(const instruction&) = delete; public: + /** + * @brief Returns this instruction's type. + * + * @return The type. + */ virtual instruction_t type() const = 0; public: + /** + * @brief Prints an instruction to an output stream. + * + * Equivalent to calling instruction.print(os). + * + * @param os Output stream. + * @param instruction Instruction to print. + * @return The output stream. + */ friend std::ostream& operator<<(std::ostream& os, const instruction& instruction) { return instruction.print(os); } protected: + /** + * @brief Prints this instruction to an output stream. + * + * @param os Output stream. + * @return The output stream. + */ virtual std::ostream& print(std::ostream& os) const = 0; }; +/** + * @brief Alloca instruction + */ class alloca_instruction final : public instruction { public: alloca_instruction() {} ~alloca_instruction() override = default; - alloca_instruction(alloca_instruction&&) = default; - alloca_instruction& operator=(alloca_instruction&&) = default; - alloca_instruction(const alloca_instruction&) = delete; + /** + * @brief Move constructor + */ + alloca_instruction(alloca_instruction&&) = default; + + /** + * @brief Move constructor + */ + alloca_instruction& operator=(alloca_instruction&&) = default; + + alloca_instruction(const alloca_instruction&) = delete; + alloca_instruction& operator=(const alloca_instruction&) = delete; public: + /** + * @brief Returns this instruction's type. + * + * @return instruction_t::Alloca. + */ instruction_t type() const override { return instruction_t::Alloca; } protected: std::ostream& print(std::ostream& os) const override { return os << "alloca"; } }; +/** + * @brief Assign instruction + */ class assign_instruction final : public instruction { public: + /** + * @brief Construct a new assign instruction. + * + * @param src Source operand. + * @param dst Destination operand. + */ assign_instruction(operand&& src, operand&& dst) : m_source(std::move(src)), m_destination(std::move(dst)) {} ~assign_instruction() override = default; - assign_instruction(assign_instruction&&) = default; - assign_instruction& operator=(assign_instruction&&) = default; - assign_instruction(const assign_instruction&) = delete; + /** + * @brief Move constructor + */ + assign_instruction(assign_instruction&&) = default; + + /** + * @brief Move constructor + */ + assign_instruction& operator=(assign_instruction&&) = default; + + assign_instruction(const assign_instruction&) = delete; + assign_instruction& operator=(const assign_instruction&) = delete; public: + /** + * @brief Returns this instruction's type. + * + * @return instruction_t::Assign. + */ instruction_t type() const override { return instruction_t::Assign; } + /** + * @brief Returns this instruction's source. + * + * @return The source. + */ const operand& source() const { return m_source; } + + /** + * @brief Returns this instruction's destination. + * + * @return The destination. + */ const operand& destination() const { return m_destination; } private: operand m_source; @@ -87,19 +179,22 @@ protected: } }; +/** + * @brief Binary operation instruction type + */ enum class binary_op_instruction_t { - Add, - Sub, - Mul, - Div, - Mod, + Add, /**< Addition */ + Sub, /**< Subtraction */ + Mul, /**< Multiplication */ + Div, /**< Division */ + Mod, /**< Modulo */ - Eq, - NotEq, - LessThan, - GreaterThan, - LessEq, - GreaterEq, + Eq, /**< Equal */ + NotEq, /**< Not equal */ + LessThan, /**< Less than */ + GreaterThan, /**< Greater than */ + LessEq, /**< Less or equal */ + GreaterEq, /**< Greater or equal */ }; static inline std::ostream& operator<<(std::ostream& os, binary_op_instruction_t type) { @@ -119,103 +214,242 @@ static inline std::ostream& operator<<(std::ostream& os, binary_op_instruction_t return os; } +/** + * @brief Binary operation instruction + */ class binary_op_instruction final : public instruction { public: + /** + * @brief Construct a new binary operation instruction. + * + * @param type Operation type. + * @param lhs Left-hand-side operand. + * @param rhs Right-hand-side operand. + * @param dst Destination operand. + */ binary_op_instruction(binary_op_instruction_t type, operand&& lhs, operand&& rhs, operand&& dst) : m_type(type), m_lhs(std::move(lhs)), m_rhs(std::move(rhs)), m_dst(std::move(dst)) {} ~binary_op_instruction() override = default; - binary_op_instruction(binary_op_instruction&&) = default; - binary_op_instruction& operator=(binary_op_instruction&&) = default; - binary_op_instruction(const binary_op_instruction&) = delete; + /** + * @brief Move constructor + */ + binary_op_instruction(binary_op_instruction&&) = default; + + /** + * @brief Move constructor + */ + binary_op_instruction& operator=(binary_op_instruction&&) = default; + + binary_op_instruction(const binary_op_instruction&) = delete; + binary_op_instruction& operator=(const binary_op_instruction&) = delete; public: + /** + * @brief Returns this instruction's type. + * + * @return instruction_t::BinaryOp. + */ instruction_t type() const override { return instruction_t::BinaryOp; } + /** + * @brief Returns this instruction's operation type. + * + * @return The operation type. + */ binary_op_instruction_t op_type() const { return m_type; } - const operand& lhs() const { return m_lhs; } - const operand& rhs() const { return m_rhs; } - const operand& dst() const { return m_dst; } + + /** + * @brief Returns this instruction's left-hand-side operand. + * + * @return The operand. + */ + const operand& lhs() const { return m_lhs; } + + /** + * @brief Returns this instruction's right-hand-side operand. + * + * @return The operand. + */ + const operand& rhs() const { return m_rhs; } + + /** + * @brief Returns this instruction's destination operand. + * + * @return The operand. + */ + const operand& dst() const { return m_dst; } private: binary_op_instruction_t m_type; - operand m_lhs; - operand m_rhs; - operand m_dst; + operand m_lhs /**< Left-hand-side operand */; + operand m_rhs /**< Right-hand-side operand */; + operand m_dst /**< Destination operand */; protected: std::ostream& print(std::ostream& os) const override { return os << "binop(" << m_type << ") " << m_lhs << ", " << m_rhs << ", " << m_dst; } }; -using block_index = std::uint64_t; +using block_index = std::uint64_t; /**< IR block index alias */ +/** + * @brief Branch instruction + */ class branch_instruction final : public instruction { public: + /** + * @brief Construct a new branch instruction. + * + * @param block Destination block index. + */ branch_instruction(block_index block) : m_block(block) {} ~branch_instruction() override = default; - branch_instruction(branch_instruction&&) = default; - branch_instruction& operator=(branch_instruction&&) = default; - branch_instruction(const branch_instruction&) = delete; + /** + * @brief Move constructor. + */ + branch_instruction(branch_instruction&&) = default; + + /** + * @brief Move constructor. + */ + branch_instruction& operator=(branch_instruction&&) = default; + + branch_instruction(const branch_instruction&) = delete; + branch_instruction& operator=(const branch_instruction&) = delete; public: + /** + * @brief Returns this instruction's type. + * + * @return instruction_t::Branch. + */ instruction_t type() const override { return instruction_t::Branch; } + /** + * @brief Returns this instruction's destination block index. + * + * @return The destination block index. + */ block_index block() const { return m_block; } private: - block_index m_block; + block_index m_block; /**< Destination block index. */ protected: std::ostream& print(std::ostream& os) const override { return os << "branch #" << m_block; } }; +/** + * @brief Conditional branch instruction + */ class branch_cond_instruction final : public instruction { public: + /** + * @brief Construct a new conditional branch instruction. + * + * @param condition Condition operand. + * @param ifBlock Destination block index. + * @param elseBlock Else block index. + */ branch_cond_instruction(operand&& condition, block_index ifBlock, block_index elseBlock) : m_condition(std::move(condition)), m_ifBlock(ifBlock), m_elseBlock(elseBlock) {} ~branch_cond_instruction() override = default; - branch_cond_instruction(branch_cond_instruction&&) = default; - branch_cond_instruction& operator=(branch_cond_instruction&&) = default; - branch_cond_instruction(const branch_cond_instruction&) = delete; + /** + * @brief Move constructor. + */ + branch_cond_instruction(branch_cond_instruction&&) = default; + + /** + * @brief Move constructor. + */ + branch_cond_instruction& operator=(branch_cond_instruction&&) = default; + + branch_cond_instruction(const branch_cond_instruction&) = delete; + branch_cond_instruction& operator=(const branch_cond_instruction&) = delete; public: instruction_t type() const override { return instruction_t::BranchCond; } + /** + * @brief Returns this instruction's condition operand. + * + * @return The operand. + */ const operand& condition() const { return m_condition; } - block_index if_block() const { return m_ifBlock; } - block_index else_block() const { return m_elseBlock; } + + /** + * @brief Returns this instruction's destination block index. + * + * @return The destination block index. + */ + block_index if_block() const { return m_ifBlock; } + + /** + * @brief Returns this instruction's else block index. + * + * @return The else block index. + */ + block_index else_block() const { return m_elseBlock; } private: - operand m_condition; - block_index m_ifBlock; - block_index m_elseBlock; + operand m_condition /**< Condition operand. */; + block_index m_ifBlock /**< Destination block index. */; + block_index m_elseBlock /**< Else block index. */; protected: std::ostream& print(std::ostream& os) const override { return os << "branch_cond " << m_condition << ", #" << m_ifBlock << ", #" << m_elseBlock; } }; +/** + * @brief Return instruction + */ class return_instruction final : public instruction { public: - return_instruction() {} + return_instruction() = default; + + /** + * @brief Construct a new return instruction. + * + * @param value Return value operand. + */ return_instruction(operand&& value) : m_value(std::move(value)) {} ~return_instruction() override = default; - return_instruction(return_instruction&&) = default; - return_instruction& operator=(return_instruction&&) = default; - return_instruction(const return_instruction&) = delete; + /** + * @brief Move constructor. + */ + return_instruction(return_instruction&&) = default; + + /** + * @brief Move constructor. + */ + return_instruction& operator=(return_instruction&&) = default; + + return_instruction(const return_instruction&) = delete; + return_instruction& operator=(const return_instruction&) = delete; public: + /** + * @brief Returns this instruction's type. + * + * @return instruction_t::Return. + */ instruction_t type() const override { return instruction_t::Return; } + /** + * @brief Returns this instruction's return value operand. + * + * @return The operand. + */ const std::optional& value() const { return m_value; } private: - std::optional m_value; + std::optional m_value; /**< The return value operand. */ protected: std::ostream& print(std::ostream& os) const override { os << "return"; diff --git a/furlang/include/furlang/ir/module.hpp b/furlang/include/furlang/ir/module.hpp index 1176a82..90e2a3f 100644 --- a/furlang/include/furlang/ir/module.hpp +++ b/furlang/include/furlang/ir/module.hpp @@ -9,18 +9,38 @@ namespace furlang { namespace ir { +/** + * @brief IR module + */ class module { public: - using value_type = std::unique_ptr; + using value_type = std::unique_ptr; /**< Value type. */ public: module() = default; public: + /** + * @brief Pushes and returns a new IR function. + * + * @param args Arguments to call the constructor with. + * @return The new IR function. + */ template value_type& push(Args&&... args) { return m_functions.emplace_back(std::forward(args)...); } - std::vector& functions() { return m_functions; } + /** + * @brief Returns this module's functions. + * + * @return The functions. + */ + std::vector& functions() { return m_functions; } + + /** + * @brief Returns this module's functions. + * + * @return The functions. + */ const std::vector& functions() const { return m_functions; } private: std::vector m_functions; diff --git a/furlang/include/furlang/ir/operand.hpp b/furlang/include/furlang/ir/operand.hpp index 4baf57b..dff75f3 100644 --- a/furlang/include/furlang/ir/operand.hpp +++ b/furlang/include/furlang/ir/operand.hpp @@ -8,19 +8,41 @@ namespace furlang { namespace ir { +/** + * @brief Operand type + */ enum class operand_t { - None, - Register, - Variable, - Integer, - String, + None, /**< None */ + Register, /**< Register */ + Variable, /**< Variable */ + Integer, /**< Integer */ + String, /**< String */ }; +/** + * @brief Register operand alias. + * @see operand_t::Register + */ using register_operand = std::uint32_t; +/** + * @brief Variable operand alias. + * @see operand_t::Variable + */ using variable_operand = std::string; -using integer_operand = std::uint64_t; -using string_operand = std::string; +/** + * @brief Integer operand alias. + * @see operand_t::Integer + */ +using integer_operand = std::uint64_t; +/** + * @brief String operand alias. + * @see operand_t::String + */ +using string_operand = std::string; +/** + * @brief IR operand + */ class operand { public: ~operand() { @@ -29,6 +51,9 @@ public: } } + /** + * @brief Move constructor. + */ operand(operand&& other) noexcept : m_type(other.m_type) { switch (m_type) { @@ -49,6 +74,9 @@ public: other.m_value.destroy(other.m_type); } + /** + * @brief Move constructor. + */ operand& operator=(operand&& other) noexcept { if (this == &other) return *this; m_type = other.m_type; @@ -74,6 +102,12 @@ public: operand(const operand&) = delete; operand& operator=(const operand&) = delete; public: + /** + * @brief Construct a new register operand. + * + * @param value Value of the new register operand. + * @return The register operand. + */ static operand new_reg(register_operand value) { operand operand; operand.m_type = operand_t::Register; @@ -81,6 +115,12 @@ public: return operand; } + /** + * @brief Construct a new variable operand. + * + * @param value Value of the new variable operand. + * @return The variable operand. + */ template static operand new_variable(T&& value) { operand operand; @@ -89,6 +129,12 @@ public: return operand; } + /** + * @brief Construct a new integer operand. + * + * @param value Value of the new integer operand. + * @return The integer operand. + */ static operand new_integer(integer_operand value) { operand operand; operand.m_type = operand_t::Integer; @@ -96,6 +142,12 @@ public: return operand; } + /** + * @brief Construct a new string operand. + * + * @param value Value of the new string operand. + * @return The string operand. + */ template static operand new_string(T&& value) { operand operand; @@ -104,11 +156,34 @@ public: return operand; } public: + /** + * @brief Returns this operand's type. + * + * @return The operand type. + */ operand_t type() const { return m_type; } + /** + * @brief Returns this operand's register value. + * + * @return The register value. + */ register_operand reg() const { return m_value.reg; } - integer_operand integer() const { return m_value.integer; } + + /** + * @brief Returns this operand's integer value. + * + * @return The integer value. + */ + integer_operand integer() const { return m_value.integer; } public: + /** + * @brief Prints an operand to an output stream. + * + * @param os Output stream. + * @param operand Operand to print. + * @return The output stream. + */ friend std::ostream& operator<<(std::ostream& os, const operand& operand) { switch (operand.m_type) { case operand_t::None: return os << "none"; diff --git a/furlang/include/furlang/result.hpp b/furlang/include/furlang/result.hpp index 03948ff..88940d3 100644 --- a/furlang/include/furlang/result.hpp +++ b/furlang/include/furlang/result.hpp @@ -6,45 +6,101 @@ namespace furlang { +/** + * @brief Bad result access exception. + */ class bad_result_access : public std::exception { public: bad_result_access() = default; ~bad_result_access() override = default; - bad_result_access(bad_result_access&&) noexcept = default; + /** + * @brief Move constructor. + */ + bad_result_access(bad_result_access&&) noexcept = default; + + /** + * @brief Move constructor. + */ bad_result_access& operator=(bad_result_access&&) noexcept = default; - bad_result_access(const bad_result_access&) = default; - bad_result_access& operator=(const bad_result_access&) = default; + + /** + * @brief Copy constructor. + */ + bad_result_access(const bad_result_access&) = default; + + /** + * @brief Copy constructor. + */ + bad_result_access& operator=(const bad_result_access&) = default; public: + /** + * @brief Returns a C-style string describing the cause of the error. + * + * @return The cause of the error. + */ const char* what() const noexcept override { return "bad result access"; } }; +/** + * @brief Result. + * + * Result stores either value or error. + * + * @tparam R Value type. + * @tparam E Error type. + */ template class result { public: - using value_type = std::remove_reference_t; - using value_reference = value_type&; - using value_const_reference = const value_type&; - using value_pointer = value_type*; - using value_const_pointer = const value_type*; - using error_type = std::remove_reference_t; - using error_reference = error_type&; - using error_const_reference = const error_type&; + using value_type = std::remove_reference_t; /**< Value type. */ + using value_reference = value_type&; /**< Value reference type. */ + using value_const_reference = const value_type&; /**< Value const reference type. */ + using value_pointer = value_type*; /**< Value pointer type. */ + using value_const_pointer = const value_type*; /**< Value const pointer type. */ + using error_type = std::remove_reference_t; /**< Error type. */ + using error_reference = error_type&; /**< Error reference type. */ + using error_const_reference = const error_type&; /**< Error const reference type. */ public: + /** + * @brief Construct a new result. + * + * @param value Value to copy. + */ result(const value_type& value) { new (&m_value.result) value_type(value); } + /** + * @brief Construct a new result. + * + * @param value Value to move. + */ result(value_type&& value) { new (&m_value.result) value_type(std::move(value)); } + /** + * @brief Construct a new result. + * + * @param args Variadic arguments to construct the value with. + */ template result(Args&&... args) { new (&m_value.result) value_type(std::forward(args)...); } + /** + * @brief Construct a new error result. + * + * @param error Error to copy. + */ explicit result(const error_type& error) : m_error(true) { new (&m_value.error) error_type(error); } + /** + * @brief Construct a new error result. + * + * @param error Error to move. + */ explicit result(error_type&& error) : m_error(true) { new (&m_value.error) error_type(std::move(error)); @@ -58,6 +114,9 @@ public: } } + /** + * @brief Move constructor. + */ result(result&& other) noexcept : m_error(other.m_error) { if (m_error) { @@ -67,6 +126,9 @@ public: } } + /** + * @brief Move constructor. + */ result& operator=(result&& other) noexcept { if (this == &other) return *this; m_error = other.m_error; @@ -78,6 +140,9 @@ public: return *this; } + /** + * @brief Copy constructor. + */ result(const result& other) : m_error(other.m_error) { if (m_error) { @@ -87,6 +152,9 @@ public: } } + /** + * @brief Copy constructor. + */ result& operator=(const result& other) { if (this == &other) return *this; m_error = other.m_error; @@ -98,60 +166,156 @@ public: return *this; } public: - operator bool() const { return !m_error; } + /** + * @brief Checks if this result contains a value. + * + * @return true if contains a value. + */ + operator bool() const { return !m_error; } + + /** + * @brief Checks if this result contains an error. + * + * @return true if contains an error. + */ bool operator!() const { return m_error; } + /** + * @brief Compares two results for equality. + * + * @param rhs Result to compare against. + * @return true if the results are equal. + */ bool operator==(const result& rhs) const { return m_error == rhs.m_error && m_error ? m_value.error == rhs.m_value.error : m_value.result == rhs.m_value.result; } + /** + * @brief Compares two results for inequality. + * + * @param rhs Result to compare against. + * @return true if the results are not equal. + */ bool operator!=(const result& rhs) const { return !this->operator==(rhs); } - value_reference operator*() { return value(); } + /** + * @brief Returns a reference to value. + * + * @return Reference to the value. + */ + value_reference operator*() { return value(); } + + /** + * @brief Returns a reference to value. + * + * @return Const reference to the value. + */ value_const_reference operator*() const { return value(); } - value_pointer operator->() { return &value(); } + /** + * @brief Returns a pointer to value. + * + * @return Pointer to the value. + */ + value_pointer operator->() { return &value(); } + + /** + * @brief Returns a pointer to value. + * + * @return Const pointer to the value. + */ value_const_pointer operator->() const { return &value(); } public: + /** + * @brief Checks if this result has a value. + * + * @return true if has a value. + */ bool has_value() const { return !m_error; } + + /** + * @brief Checks if this result has an error. + * + * @return true if has an error. + */ bool has_error() const { return m_error; } + /** + * @brief Returns a reference to value. + * + * @return Reference to the value. + */ value_reference value() { if (m_error) throw bad_result_access(); return m_value.result; } + /** + * @brief Returns a reference to value. + * + * @return Const reference to the value. + */ value_const_reference value() const { if (m_error) throw bad_result_access(); return m_value.result; } + /** + * @brief Returns a reference to error. + * + * @return Reference to the error. + */ error_reference error() { if (!m_error) throw bad_result_access(); return m_value.error; } + /** + * @brief Returns a reference to error. + * + * @return Const reference to the error. + */ error_const_reference error() const { if (!m_error) throw bad_result_access(); return m_value.error; } public: + /** + * @brief Sets this results value. + * + * @param value Value to copy. + */ void set_value(const value_type& value) { if (m_error) m_value.error.~error_type(); new (&m_value.result) value_type(value); } + /** + * @brief Sets this results value. + * + * @param value Value to move. + */ void set_value(value_type&& value) { if (m_error) m_value.error.~error_type(); new (&m_value.result) value_type(std::move(value)); } + /** + * @brief Sets this results error. + * + * @param error Error to copy. + */ void set_error(const error_type& error) { if (!m_error) m_value.result.~value_type(); new (&m_value.error) error_type(error); } + /** + * @brief Sets this results error. + * + * @param error Error to move. + */ void set_error(error_type&& error) { if (!m_error) m_value.result.~value_type(); new (&m_value.error) error_type(std::move(error));