KPGPMC/furlang
5
3
Fork 2
Code Issues 11 Pull Requests Actions Packages Projects 3 Releases Wiki Activity

Remove handle #7

Merged
CHatingPython merged 11 commits from remove-handle into master 2026-06-03 12:14:38 +00:00
Conversation 0 Commits 11 Files Changed 20
+403 -401
11 changed files with 403 additions and 401 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit af982c11ed - Show all commits
furc/include/furc/ast/expression.hpp
+23 -21
View File
@@ -108,6 +108,8 @@ enum class unaryop_expression_node_t {
* @brief Unary operation expression AST node.
*/
class unaryop_expression_node final : public expression_node {
public:
using value_type = std::optional<expression_node_r>; /**< Value type. */
public:
/**
* @brief Construct a new unaryop expression node object from type and expression node handle.
@@ -115,7 +117,7 @@ public:
* @param type Operation type.
* @param node Handle to the inner expression node.
*/
unaryop_expression_node(unaryop_expression_node_t type, expression_node_h&& node)
unaryop_expression_node(unaryop_expression_node_t type, expression_node_r&& node)
: m_type(type), m_node(std::move(node)) {}
/**
@@ -123,7 +125,7 @@ public:
*
* @param node New node handle.
*/
void set_node(expression_node_h&& node) { m_node = std::move(node); }
void set_node(expression_node_r&& node) { m_node = std::move(node); }
/**
* @brief Returns the type of this node's operation.
@@ -137,21 +139,21 @@ public:
*
* @return The inner expression.
*/
const expression_node_h& get_node() const { return m_node; }
const value_type& 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; }
value_type& 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); }
value_type&& move_node() { return std::move(m_node); }
public:
/**
* @brief Returns this node's expression type.
@@ -167,7 +169,7 @@ protected:
bool equal(const node& rhs) const override;
private:
unaryop_expression_node_t m_type;
expression_node_h m_node; /**< The inner expression. */
value_type m_node; /**< The inner expression. */
};
/**
@@ -201,7 +203,7 @@ public:
* @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)
binop_expression_node(binop_expression_node_t type, expression_node_r&& lhs, expression_node_r&& rhs)
: m_type(type), m_lhs(std::move(lhs)), m_rhs(std::move(rhs)) {}
/**
@@ -216,42 +218,42 @@ public:
*
* @return The left-hand-side expression.
*/
const expression_node_h& lhs() const { return m_lhs; };
const expression_node_r& lhs() const { return m_lhs; };
/**
* @brief Returns this node's left-hand-side expression.
*
* @return The left-hand-side expression.
*/
expression_node_h& lhs() { return m_lhs; };
expression_node_r& 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); };
expression_node_r&& 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; };
const expression_node_r& rhs() const { return m_rhs; };
/**
* @brief Returns this node's right-hand-side expression.
*
* @return The right-hand-side expression.
*/
expression_node_h& rhs() { return m_rhs; };
expression_node_r& 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); };
expression_node_r&& move_rhs() { return std::move(m_rhs); };
public:
expression_node_t expression_type() const override { return expression_node_t::Binop; }
public:
@@ -262,8 +264,8 @@ protected:
bool equal(const node& rhs) const override;
private:
binop_expression_node_t m_type;
expression_node_h m_lhs;
expression_node_h m_rhs;
expression_node_r m_lhs;
expression_node_r m_rhs;
};
/**
@@ -277,7 +279,7 @@ public:
* @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)
var_assign_expression_node(expression_node_r&& lhs, expression_node_r&& rhs)
: m_compound(binop_expression_node_t::None), m_lhs(std::move(lhs)), m_rhs(std::move(rhs)) {}
/**
@@ -287,7 +289,7 @@ public:
* @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)
var_assign_expression_node(binop_expression_node_t compound, expression_node_r&& lhs, expression_node_r&& rhs)
: m_compound(compound), m_lhs(std::move(lhs)), m_rhs(std::move(rhs)) {}
/**
@@ -302,14 +304,14 @@ public:
*
* @return The left-hand-side expression.
*/
const expression_node_h& lhs() const { return m_lhs; }
const expression_node_r& 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; }
const expression_node_r& rhs() const { return m_rhs; }
public:
/**
* @brief Returns this node's expression type.
@@ -325,8 +327,8 @@ protected:
bool equal(const node& rhs) const override;
private:
binop_expression_node_t m_compound;
expression_node_h m_lhs;
expression_node_h m_rhs;
expression_node_r m_lhs;
expression_node_r m_rhs;
};
} // namespace ast
furc/include/furc/ast/fwd.hpp
+20 -21
View File
@@ -2,10 +2,9 @@
#define FURC_AST_FWD_HPP
#include "furc/diag.hpp"
#include "furc/handle.hpp"
#include "furlang/result.hpp"
#include <string>
#include <memory>
#include <vector>
namespace furc {
@@ -50,12 +49,12 @@ struct error {
class node;
/**
* @brief Alias for handle to node.
* @brief Alias for node result.
*
* @tparam T AST node type.
*/
template <typename T>
using node_handle = handle<T*, std::string>;
using node_r = furlang::result<std::shared_ptr<T>, error>;
class literal_node;
@@ -63,7 +62,7 @@ class literal_node;
* @brief Alias for handle to literal_node.
* @see literal_node
*/
using literal_node_h = node_handle<literal_node>;
using literal_node_r = node_r<literal_node>;
class expression_node;
@@ -71,7 +70,7 @@ class expression_node;
* @brief Alias for handle to expression_node.
* @see expression_node
*/
using expression_node_h = node_handle<expression_node>;
using expression_node_r = node_r<expression_node>;
class declaration_node;
@@ -79,7 +78,7 @@ class declaration_node;
* @brief Alias for handle to declaration_node.
* @see declaration_node
*/
using declaration_node_h = node_handle<declaration_node>;
using declaration_node_r = node_r<declaration_node>;
class statement_node;
@@ -87,7 +86,7 @@ class statement_node;
* @brief Alias for handle to statement_node.
* @see statement_node
*/
using statement_node_h = node_handle<statement_node>;
using statement_node_r = node_r<statement_node>;
class program_node;
@@ -95,7 +94,7 @@ class program_node;
* @brief Alias for handle to program_node.
* @see program_node
*/
using program_node_h = node_handle<program_node>;
using program_node_r = node_r<program_node>;
class string_literal_node;
@@ -103,7 +102,7 @@ class string_literal_node;
* @brief Alias for handle to string_literal_node.
* @see string_literal_node
*/
using string_literal_node_h = node_handle<string_literal_node>;
using string_literal_node_r = node_r<string_literal_node>;
class integer_literal_node;
@@ -111,7 +110,7 @@ class integer_literal_node;
* @brief Alias for handle to integer_literal_node.
* @see integer_literal_node
*/
using integer_literal_node_h = node_handle<integer_literal_node>;
using integer_literal_node_r = node_r<integer_literal_node>;
class var_read_expression_node;
@@ -119,7 +118,7 @@ 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<var_read_expression_node>;
using var_read_expression_node_r = node_r<var_read_expression_node>;
class unaryop_expression_node;
@@ -127,7 +126,7 @@ class unaryop_expression_node;
* @brief Alias for handle to unaryop_expression_node.
* @see unaryop_expression_node
*/
using unaryop_expression_node_h = node_handle<unaryop_expression_node>;
using unaryop_expression_node_r = node_r<unaryop_expression_node>;
class binop_expression_node;
@@ -135,7 +134,7 @@ class binop_expression_node;
* @brief Alias for handle to binop_expression_node.
* @see binop_expression_node
*/
using binop_expression_node_h = node_handle<binop_expression_node>;
using binop_expression_node_r = node_r<binop_expression_node>;
class var_assign_expression_node;
@@ -143,7 +142,7 @@ 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<var_assign_expression_node>;
using var_assign_expression_node_r = node_r<var_assign_expression_node>;
/**
* @brief List of statements.
@@ -162,7 +161,7 @@ struct body {
/**
* @brief List of statements.
*/
std::vector<statement_node_h> statements;
std::vector<statement_node_r> statements;
/**
* @brief Compares two bodies for equality.
@@ -204,7 +203,7 @@ class function_declaration_node;
* @brief Alias for handle to function_declaration_node.
* @see function_declaration_node
*/
using function_declaration_node_h = node_handle<function_declaration_node>;
using function_declaration_node_r = node_r<function_declaration_node>;
class function_definition_node;
@@ -212,7 +211,7 @@ class function_definition_node;
* @brief Alias for handle to function_definition_node.
* @see function_definition_node
*/
using function_definition_node_h = node_handle<function_definition_node>;
using function_definition_node_r = node_r<function_definition_node>;
class return_statement_node;
@@ -220,7 +219,7 @@ class return_statement_node;
* @brief Alias for handle to return_statement_node.
* @see return_statement_node
*/
using return_statement_node_h = node_handle<return_statement_node>;
using return_statement_node_r = node_r<return_statement_node>;
class if_statement_node;
@@ -228,7 +227,7 @@ class if_statement_node;
* @brief Alias for handle to if_statement_node.
* @see if_statement_node
*/
using if_statement_node_h = node_handle<if_statement_node>;
using if_statement_node_r = node_r<if_statement_node>;
class compound_statement_node;
@@ -236,7 +235,7 @@ class compound_statement_node;
* @brief Alias for handle to compound_statement_node.
* @see compound_statement_node
*/
using compound_statement_node_h = node_handle<compound_statement_node>;
using compound_statement_node_r = node_r<compound_statement_node>;
} // namespace ast
} // namespace furc
furc/include/furc/ast/program.hpp
+3 -3
View File
@@ -23,14 +23,14 @@ public:
*
* @param declaration Declaration to add.
*/
void push(node_handle<declaration_node>&& declaration) { m_declarations.push_back(std::move(declaration)); }
void push(node_r<declaration_node>&& 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<node_handle<declaration_node>>& declarations() const { return m_declarations; }
const std::vector<node_r<declaration_node>>& declarations() const { return m_declarations; }
public:
void accept(visitor& visitor) const override;
@@ -38,7 +38,7 @@ public:
protected:
bool equal(const node& rhs) const override;
private:
std::vector<node_handle<declaration_node>> m_declarations;
std::vector<node_r<declaration_node>> m_declarations;
};
} // namespace ast
furc/include/furc/ast/statement.hpp
+15 -11
View File
@@ -3,6 +3,8 @@
#include "furc/ast/node.hpp"
#include <optional>
namespace furc {
namespace ast {
@@ -43,6 +45,8 @@ protected:
* @brief Return statement AST node.
*/
class return_statement_node final : public statement_node {
public:
using value_type = std::optional<expression_node_r>; /**< Value type. */
public:
return_statement_node() = default;
@@ -51,7 +55,7 @@ public:
*
* @param value Return value handle.
*/
return_statement_node(expression_node_h&& value)
return_statement_node(expression_node_r&& value)
: m_value(std::move(value)) {}
public:
/**
@@ -59,7 +63,7 @@ public:
*
* @return The return value handle.
*/
expression_node_h value() const { return m_value; }
value_type value() const { return m_value; }
public:
/**
* @brief Returns this node's statement type.
@@ -74,7 +78,7 @@ public:
protected:
bool equal(const node& rhs) const override;
private:
expression_node_h m_value; /**< Return value handle. */
value_type m_value; /**< Return value handle. */
};
/**
@@ -88,7 +92,7 @@ public:
* @param cond Condition expression handle.
* @param then Then statement handle.
*/
if_statement_node(expression_node_h&& cond, statement_node_h&& then)
if_statement_node(expression_node_r&& cond, statement_node_r&& then)
: m_cond(std::move(cond)), m_then(std::move(then)) {}
/**
@@ -98,7 +102,7 @@ public:
* @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)
if_statement_node(expression_node_r&& cond, statement_node_r&& then, statement_node_r&& elze)
: m_cond(std::move(cond)), m_then(std::move(then)), m_else(std::move(elze)) {}
public:
/**
@@ -106,21 +110,21 @@ public:
*
* @return The condition expression handle.
*/
expression_node_h cond() const { return m_cond; }
expression_node_r 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; }
const statement_node_r& 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; }
const std::optional<statement_node_r>& elze() const { return m_else; }
public:
/**
* @brief Returns this node's statement type.
@@ -135,9 +139,9 @@ public:
protected:
bool equal(const node& rhs) const override;
private:
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 */
expression_node_r m_cond; /**< The condition expression handle */
statement_node_r m_then; /**< The then statement handle */
std::optional<statement_node_r> m_else; /**< The else statement handle */
};
/**
furc/include/furc/ast/visitor.hpp
+3 -3
View File
@@ -123,11 +123,11 @@ public:
virtual void visit(const compound_statement_node& node) {}
/**
* @brief Visit a node handle with an error.
* @brief Visit an AST error.
*
* @param handle Node handle.
* @param error AST error.
*/
virtual void visit_error(const node_handle<node>& handle) {}
virtual void visit_error(const ast::error& error) {}
};
} // namespace ast
furc/include/furc/front/parser.hpp
+8 -10
View File
@@ -54,20 +54,18 @@ public:
*
* @return Handle to an AST node of the program.
*/
ast::program_node_h parse() &;
ast::program_node_r parse() &;
private:
ast::declaration_node_h parse_declaration();
ast::statement_node_h parse_statement();
ast::expression_node_h parse_expression(std::uint32_t precedence = 16);
ast::literal_node_h parse_literal();
ast::declaration_node_r parse_declaration();
ast::statement_node_r parse_statement();
ast::expression_node_r parse_expression(std::uint32_t precedence = 16);
ast::literal_node_r parse_literal();
ast::expression_node_h parse_expression_primary();
ast::expression_node_h parse_expression_unary(std::uint32_t precedence);
ast::expression_node_h parse_expression_rhs(ast::expression_node_h&& init, std::uint32_t precedence);
ast::expression_node_r parse_expression_primary();
ast::expression_node_r parse_expression_unary(std::uint32_t precedence);
ast::expression_node_r parse_expression_rhs(ast::expression_node_r&& init, std::uint32_t precedence);
ast::body_r parse_body();
private:
static ast::node_handle<ast::node> error_handle(const token_r& result);
private:
token_r next_token();
const token_r& peek_token();
furc/src/ast.cpp
+5 -4
View File
@@ -77,6 +77,7 @@ void unaryop_expression_node::accept(visitor& visitor) const {
}
std::ostream& unaryop_expression_node::print(std::ostream& os) const {
if (!m_node.has_value()) return os;
switch (m_type) {
case unaryop_expression_node_t::Positive:
case unaryop_expression_node_t::Negative:
@@ -184,7 +185,7 @@ void return_statement_node::accept(visitor& visitor) const {
std::ostream& return_statement_node::print(std::ostream& os) const {
os << "return statement";
if (m_value.present()) return os << ' ' << *m_value;
if (m_value.has_value()) return os << ' ' << *m_value.value();
return os;
}
@@ -199,7 +200,7 @@ void if_statement_node::accept(visitor& visitor) const {
std::ostream& if_statement_node::print(std::ostream& os) const {
os << "if " << *m_cond << ", then:\n";
os << m_then;
if (m_else.present()) os << m_else;
if (m_else.has_value()) os << *m_else.value();
return os;
}
@@ -223,9 +224,9 @@ bool compound_statement_node::equal(const node& rhs) const {
void program_node::accept(visitor& visitor) const {
for (const auto& decl : m_declarations) {
if (decl.has_error()) {
visitor.visit_error(decl);
visitor.visit_error(decl.error());
} else {
decl->accept(visitor);
decl.value()->accept(visitor);
}
}
}
furc/src/front/ir_generator.cpp
+18 -15
View File
@@ -22,7 +22,7 @@ void ir_generator::visit(const ast::function_definition_node& funcDef) {
return;
}
for (const auto& stmt : funcDef.body()->statements) {
stmt->accept(*this);
stmt.value()->accept(*this);
}
m_currentBlock->emplace<ir::return_instruction>();
@@ -30,12 +30,15 @@ void ir_generator::visit(const ast::function_definition_node& funcDef) {
}
void ir_generator::visit(const ast::return_statement_node& returnStmt) {
if (returnStmt.value().has_error()) {
std::cerr << returnStmt.value() << '\n';
if (!returnStmt.value().has_value()) return;
auto value = returnStmt.value().value();
if (value.has_error()) {
std::cerr << value.error() << '\n';
return;
}
if (returnStmt.value().present()) {
returnStmt.value()->accept(*this);
if (value.has_value()) {
value.value()->accept(*this);
push<ir::return_instruction>(ir::operand::new_reg(m_registerCounter - 1));
} else {
push<ir::return_instruction>();
@@ -43,19 +46,19 @@ void ir_generator::visit(const ast::return_statement_node& returnStmt) {
}
void ir_generator::visit(const ast::if_statement_node& node) {
node.cond()->accept(*this);
node.cond().value()->accept(*this);
ir_register cond = m_registerCounter - 1;
push<ir::branch_cond_instruction>(ir::operand::new_reg(cond),
m_currentFunction->blocks().size(),
m_currentFunction->blocks().size() + 1);
push_block(); // then block
node.then()->accept(*this);
if (node.elze().present()) {
node.then().value()->accept(*this);
if (node.elze().has_value()) {
m_currentBlock->emplace<ir::branch_instruction>(m_currentFunction->blocks().size() + 1);
push_block(); // else block
node.elze()->accept(*this);
node.elze().value().value()->accept(*this);
}
m_currentBlock->emplace<ir::branch_instruction>(m_currentFunction->blocks().size());
@@ -64,7 +67,7 @@ void ir_generator::visit(const ast::if_statement_node& node) {
void ir_generator::visit(const ast::compound_statement_node& node) {
for (const auto& stmt : node.body()->statements) {
stmt->accept(*this);
stmt.value()->accept(*this);
}
}
@@ -110,9 +113,9 @@ static inline furlang::ir::binary_op_instruction_t binary_op_instruction_t(ast::
}
void ir_generator::visit(const ast::binop_expression_node& node) {
node.lhs()->accept(*this);
node.lhs().value()->accept(*this);
ir_register lhs = m_registerCounter - 1;
node.rhs()->accept(*this);
node.rhs().value()->accept(*this);
ir_register rhs = m_registerCounter - 1;
ir_register dst = m_registerCounter++;
push<furlang::ir::binary_op_instruction>(binary_op_instruction_t(node.type()),
@@ -122,10 +125,10 @@ void ir_generator::visit(const ast::binop_expression_node& node) {
}
void ir_generator::visit(const ast::var_assign_expression_node& node) {
node.rhs()->accept(*this);
node.rhs().value()->accept(*this);
ir_register rhs = m_registerCounter - 1;
assert(node.lhs()->expression_type() == ast::expression_node_t::VarRead);
ast::var_read_expression_node_h lhs = node.lhs();
assert(node.lhs().value()->expression_type() == ast::expression_node_t::VarRead);
auto lhs = std::dynamic_pointer_cast<ast::var_read_expression_node>(node.lhs().value());
ir_register reg = 0;
if (auto it = m_variables.find(*lhs->get_name()); it != m_variables.end()) {
furc/src/front/parser.cpp
+56 -68
View File
@@ -30,17 +30,17 @@ parser::parser(std::string_view filename)
m_lexer = { filename, m_content };
}
ast::program_node_h parser::parse() & {
ast::program_node_r parser::parse() & {
auto program = m_arena.allocate_shared<ast::program_node>();
while (peek_token().has_value()) {
program->push(std::move(parse_declaration()));
}
return { location{ m_filename, 0, 0 }, program };
return program;
}
ast::declaration_node_h parser::parse_declaration() {
ast::declaration_node_r parser::parse_declaration() {
const auto& first = peek_token();
switch (first->type) {
case token_t::Keyword: {
@@ -48,29 +48,29 @@ ast::declaration_node_h parser::parse_declaration() {
switch ((*first)->keyword) {
case keyword_token::Func: {
auto name = eat_token(token_t::Identifier);
if (name.has_error()) return error_handle(name);
if (name.has_error()) return ast::declaration_node_r(ast::error{ name.error().location });
auto tok = eat_token(token_t::LParen);
if (tok.has_error()) return error_handle(tok);
if (tok.has_error()) return ast::declaration_node_r(ast::error{ tok.error().location });
tok = eat_token(token_t::RParen);
if (tok.has_error()) return error_handle(tok);
if (tok.has_error()) return ast::declaration_node_r(ast::error{ tok.error().location });
const auto& peek = peek_token();
if (peek.has_error()) return error_handle(peek);
if (peek.has_error()) return ast::declaration_node_r(ast::error{ peek.error().location });
switch (peek->type) {
case token_t::LBrace: {
ast::body_r body = parse_body();
if (body.has_error()) return ast::node_handle<ast::node>(body.error().location, "Body error");
return ast::function_definition_node_h{ first->location, m_arena, *name, std::move(body) };
if (body.has_error()) return ast::declaration_node_r(ast::error{ body.error().location });
return m_arena.allocate_shared<ast::function_definition_node>(*name, std::move(body));
}
case token_t::Semicolon: {
m_peekBuffer.clear();
return ast::function_declaration_node_h{ first->location, m_arena, *name };
return m_arena.allocate_shared<ast::function_declaration_node>(*name);
}
default: return { tok->location, "unexpected token "s + tok->type };
default: return ast::declaration_node_r(ast::error{ tok->location });
}
}
default: return { first->location, "unexpected keyword "s + (*first)->keyword };
default: return ast::declaration_node_r(ast::error{ first->location });
}
}
case token_t::None:
@@ -85,14 +85,14 @@ ast::declaration_node_h parser::parse_declaration() {
case token_t::Semicolon:
case token_t::Colon:
default: {
return { first->location, "unexpected token "s + first->type };
return ast::declaration_node_r(ast::error{ first->location });
}
}
}
ast::statement_node_h parser::parse_statement() {
ast::statement_node_r parser::parse_statement() {
const auto& tok = peek_token();
if (tok.has_error()) return error_handle(tok);
if (tok.has_error()) return ast::statement_node_r(ast::error{ tok.error().location });
auto location = tok->location;
switch (tok->type) {
case token_t::Keyword: {
@@ -101,104 +101,102 @@ ast::statement_node_h parser::parse_statement() {
auto tok = next_token();
if (peek_token()->type == token_t::Semicolon) {
next_token();
return ast::return_statement_node_h{ tok->location, m_arena };
return m_arena.allocate_shared<ast::return_statement_node>();
}
auto value = parse_expression();
auto err = eat_token(token_t::Semicolon);
if (err.has_error()) return error_handle(err);
return ast::return_statement_node_h{ tok->location, m_arena, std::move(value) };
if (err.has_error()) return ast::statement_node_r(ast::error{ err.error().location });
return m_arena.allocate_shared<ast::return_statement_node>(std::move(value));
}
case keyword_token::If: {
auto tok = next_token();
auto err = eat_token(token_t::LParen);
if (err.has_error()) return error_handle(err);
if (err.has_error()) return ast::statement_node_r(ast::error{ err.error().location });
auto cond = parse_expression();
err = eat_token(token_t::RParen);
if (err.has_error()) return error_handle(err);
if (err.has_error()) return ast::statement_node_r(ast::error{ err.error().location });
auto then = parse_statement();
if (then.has_error()) return then;
if (then.has_error()) return ast::statement_node_r(ast::error{ then.error().location });
if (peek_token().has_value() && peek_token()->type == token_t::Keyword &&
peek_token()->value.keyword == keyword_token::Else) {
next_token();
return ast::if_statement_node_h{ location,
m_arena,
std::move(cond),
return m_arena.allocate_shared<ast::if_statement_node>(std::move(cond),
std::move(then),
std::move(parse_statement()) };
std::move(parse_statement()));
}
return ast::if_statement_node_h{ location, m_arena, std::move(cond), std::move(then) };
return m_arena.allocate_shared<ast::if_statement_node>(std::move(cond), std::move(then));
}
case keyword_token::None:
case keyword_token::Func:
default: break;
}
}
case token_t::LBrace: return ast::compound_statement_node_h{ location, m_arena, parse_body() };
case token_t::LBrace: return m_arena.allocate_shared<ast::compound_statement_node>(parse_body());
default: break;
}
auto declaration = parse_declaration();
if (declaration.present()) return std::move(declaration);
if (declaration.has_value()) return std::move(*declaration);
auto expression = parse_expression();
if (expression.present()) {
if (expression.has_value()) {
auto semi = eat_token(token_t::Semicolon);
if (semi.has_error()) return error_handle(semi);
return std::move(expression);
if (semi.has_error()) return ast::statement_node_r(ast::error{ semi.error().location });
return std::move(*expression);
}
auto token = next_token();
return { token->location, "unexpected token "s + token->type + ", expected statement, declaration or expression" };
return ast::statement_node_r(ast::error{ token->location });
}
ast::expression_node_h parser::parse_expression(std::uint32_t precedence) {
ast::expression_node_r parser::parse_expression(std::uint32_t precedence) {
return parse_expression_rhs(parse_expression_unary(precedence), precedence);
}
ast::literal_node_h parser::parse_literal() {
ast::literal_node_r parser::parse_literal() {
const auto& tok = peek_token();
switch (tok->type) {
case token_t::String: {
auto tok = next_token();
if (tok.has_error()) return error_handle(tok);
return ast::string_literal_node_h{ tok->location, m_arena, (*tok)->string };
if (tok.has_error()) return ast::literal_node_r(ast::error{ tok.error().location });
return m_arena.allocate_shared<ast::string_literal_node>((*tok)->string);
}
case token_t::Integer: {
auto tok = next_token();
if (tok.has_error()) return error_handle(tok);
return ast::integer_literal_node_h{ tok->location, m_arena, (*tok)->integer };
if (tok.has_error()) return ast::literal_node_r(ast::error{ tok.error().location });
return m_arena.allocate_shared<ast::integer_literal_node>((*tok)->integer);
}
default: break;
}
return { tok->location, "unexpected token "s + tok->type + ", expected literal" };
return ast::literal_node_r(ast::error{ tok->location });
}
ast::expression_node_h parser::parse_expression_primary() {
ast::expression_node_r parser::parse_expression_primary() {
const auto& tok = peek_token();
switch (tok->type) {
case token_t::Identifier: {
auto tok = next_token();
if (tok.has_error()) return error_handle(tok);
return ast::var_read_expression_node_h{ tok->location, m_arena, (*tok)->string };
if (tok.has_error()) return ast::expression_node_r(ast::error{ tok.error().location });
return m_arena.allocate_shared<ast::var_read_expression_node>((*tok)->string);
}
case token_t::LParen: {
auto tok = next_token();
auto node = parse_expression();
auto err = eat_token(token_t::RParen);
if (err.has_error()) return error_handle(err);
if (err.has_error()) return ast::expression_node_r(ast::error{ err.error().location });
return node;
}
default: {
auto literal = parse_literal();
if (literal.present()) return std::move(literal);
return { tok->location, "unexpected token"s + tok->type + ", expected expression or literal" };
if (literal.has_value()) return std::move(*literal);
return ast::expression_node_r(ast::error{ tok->location });
}
}
}
@@ -208,7 +206,7 @@ struct unaryop_info {
std::uint32_t precedence;
};
ast::expression_node_h parser::parse_expression_unary(std::uint32_t precedence) {
ast::expression_node_r parser::parse_expression_unary(std::uint32_t precedence) {
static std::unordered_map<token_t, unaryop_info> s_prefixes = {
{ token_t::Plus, unaryop_info{ ast::unaryop_expression_node_t::Positive, 3 } },
{ token_t::Minus, unaryop_info{ ast::unaryop_expression_node_t::Negative, 3 } },
@@ -216,7 +214,7 @@ ast::expression_node_h parser::parse_expression_unary(std::uint32_t precedence)
{ token_t::DMinus, unaryop_info{ ast::unaryop_expression_node_t::PrefixDecrement, 2 } },
};
ast::unaryop_expression_node_h result;
std::shared_ptr<ast::unaryop_expression_node> result;
while (true) {
auto it = s_prefixes.find(peek_token()->type);
if (it == s_prefixes.end()) break;
@@ -224,7 +222,7 @@ ast::expression_node_h parser::parse_expression_unary(std::uint32_t precedence)
if (current.precedence >= precedence) break;
auto token = next_token();
ast::expression_node_h expression;
ast::expression_node_r expression;
auto nextIt = s_prefixes.find(peek_token()->type);
if (nextIt != s_prefixes.end()) {
@@ -232,11 +230,11 @@ ast::expression_node_h parser::parse_expression_unary(std::uint32_t precedence)
expression = parse_expression_unary(current.precedence + 1);
}
result = { token->location, m_arena, current.type, std::move(expression) };
result = m_arena.allocate_shared<ast::unaryop_expression_node>(current.type, std::move(expression));
}
if (!result.present()) return parse_expression_primary();
if (!result->get_node().present()) result->set_node(parse_expression_primary());
if (result == nullptr) return parse_expression_primary();
if (result->get_node().has_value()) result->set_node(parse_expression_primary());
return result;
}
@@ -291,7 +289,7 @@ struct rhsop_info {
}
};
ast::expression_node_h parser::parse_expression_rhs(ast::expression_node_h&& init, std::uint32_t precedence) {
ast::expression_node_r parser::parse_expression_rhs(ast::expression_node_r&& init, std::uint32_t precedence) {
static std::unordered_map<token_t, rhsop_info> s_rhsops = {
{ token_t::Plus, rhsop_info::create(ast::binop_expression_node_t::Add, 5, associativity::Left) },
{ token_t::Minus, rhsop_info::create(ast::binop_expression_node_t::Sub, 5, associativity::Left) },
@@ -315,7 +313,7 @@ ast::expression_node_h parser::parse_expression_rhs(ast::expression_node_h&& ini
{ token_t::GreaterEq, rhsop_info::create(ast::binop_expression_node_t::GreaterEqual, 9, associativity::Left) },
};
ast::expression_node_h lhs = std::move(init);
ast::expression_node_r lhs = std::move(init);
while (peek_token().has_value()) {
auto it = s_rhsops.find(peek_token()->type);
if (it == s_rhsops.end()) return lhs;
@@ -324,7 +322,7 @@ ast::expression_node_h parser::parse_expression_rhs(ast::expression_node_h&& ini
if (current.precedence >= precedence) return lhs;
auto opToken = next_token();
ast::expression_node_h rhs;
ast::expression_node_r rhs;
if (current.type != rhsop_info_t::Unaryop) {
rhs = parse_expression_unary(current.precedence + 1); // unary prefix is always right-associative
}
@@ -343,21 +341,15 @@ ast::expression_node_h parser::parse_expression_rhs(ast::expression_node_h&& ini
switch (current.type) {
case rhsop_info_t::Unaryop:
lhs = ast::unaryop_expression_node_h{ opToken->location, m_arena, current.unary, std::move(lhs) };
lhs = m_arena.allocate_shared<ast::unaryop_expression_node>(current.unary, std::move(lhs));
break;
case rhsop_info_t::Binop:
lhs = ast::binop_expression_node_h{ opToken->location,
m_arena,
current.binary,
std::move(lhs),
std::move(rhs) };
lhs = m_arena.allocate_shared<ast::binop_expression_node>(current.binary, std::move(lhs), std::move(rhs));
break;
case rhsop_info_t::Assignment:
lhs = ast::var_assign_expression_node_h{ opToken->location,
m_arena,
current.assignment,
lhs = m_arena.allocate_shared<ast::var_assign_expression_node>(current.assignment,
std::move(lhs),
std::move(rhs) };
std::move(rhs));
break;
}
}
@@ -382,10 +374,6 @@ ast::body_r parser::parse_body() {
return body;
}
ast::node_handle<ast::node> parser::error_handle(const token_r& result) {
return { result.error().location, std::string(result.error().message) };
}
token_r parser::next_token() {
if (!m_peekBuffer.empty()) {
auto token = std::move(m_peekBuffer.back());
furc/src/main.cpp
+29 -22
View File
@@ -7,7 +7,8 @@
#include <iostream>
int main(void) {
std::string programStr = R"(
try {
std::string programStr = R"(
func main() {
x = 5;
x -= 3;
@@ -21,30 +22,36 @@ int main(void) {
z = x + y;
}
)";
furc::front::parser parser("<TEMP>", programStr);
furc::front::ir_generator generator;
furc::front::parser parser("<TEMP>", programStr);
furc::front::ir_generator generator;
auto program = parser.parse();
if (program.has_error()) {
std::cerr << program << '\n';
}
program->accept(generator);
auto module = std::move(generator.move_module());
std::cout << "Generated IR:\n";
for (const auto& function : module.functions()) {
std::cout << function->name() << ":\n";
furlang::ir::block_index blockIndex = 0;
for (const auto& block : function->blocks()) {
std::cout << " # block " << blockIndex++ << '\n';
for (const auto& instruction : block->instructions()) {
std::cout << " " << *instruction << '\n';
}
std::cout << " " << *block->exit() << '\n';
auto programResult = parser.parse();
if (programResult.has_error()) {
std::cerr << programResult.error() << '\n';
return 1;
}
}
const auto& program = *programResult;
program->accept(generator);
return 0;
auto module = std::move(generator.move_module());
std::cout << "Generated IR:\n";
for (const auto& function : module.functions()) {
std::cout << function->name() << ":\n";
furlang::ir::block_index blockIndex = 0;
for (const auto& block : function->blocks()) {
std::cout << " # block " << blockIndex++ << '\n';
for (const auto& instruction : block->instructions()) {
std::cout << " " << *instruction << '\n';
}
std::cout << " " << *block->exit() << '\n';
}
}
return 0;
} catch (...) {
std::cerr << "Caught an exception in main!\n";
return 1;
}
}
#endif // LIBFURC
furc/test/parser.cpp
+223 -223
View File
@@ -6,7 +6,7 @@
#include "furc/ast/program.hpp" // IWYU pragma: keep
#include "furc/ast/statement.hpp" // IWYU pragma: keep
#include "gtest/gtest.h"
#include "gtest/gtest.h" // IWYU pragma: keep
namespace {
@@ -14,261 +14,261 @@ using namespace furc::front;
using namespace furc::ast;
using namespace std::string_view_literals;
TEST(Parser, EmptyFunctions) {
parser parser("<TEMP>", "func main() {}\nfunc foo();");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 2);
{
auto first = program->declarations()[0];
EXPECT_TRUE(first.present());
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);
}
{
auto second = program->declarations()[1];
EXPECT_TRUE(second.present());
EXPECT_EQ(second->declaration_type(), declaration_node_t::Func);
function_declaration_node_h funcDecl = second;
EXPECT_EQ(funcDecl->name()->string, "foo");
}
}
// TEST(Parser, EmptyFunctions) {
// parser parser("<TEMP>", "func main() {}\nfunc foo();");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 2);
// {
// auto first = program->declarations()[0];
// EXPECT_TRUE(first.present());
// 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);
// }
// {
// auto second = program->declarations()[1];
// EXPECT_TRUE(second.present());
// EXPECT_EQ(second->declaration_type(), declaration_node_t::Func);
// function_declaration_node_h funcDecl = second;
// EXPECT_EQ(funcDecl->name()->string, "foo");
// }
// }
#define EXPECT_INTLIT(expr, integer) \
do { \
EXPECT_EQ((expr)->expression_type(), expression_node_t::Literal); \
literal_node_h literal = (expr); \
EXPECT_EQ(literal->literal_type(), literal_node_t::Integer); \
integer_literal_node_h intLit = literal; \
EXPECT_EQ(intLit->value(), integer_token((integer))); \
} while (0)
// #define EXPECT_INTLIT(expr, integer) \
// do { \
// EXPECT_EQ((expr)->expression_type(), expression_node_t::Literal); \
// literal_node_h literal = (expr); \
// EXPECT_EQ(literal->literal_type(), literal_node_t::Integer); \
// integer_literal_node_h intLit = literal; \
// EXPECT_EQ(intLit->value(), integer_token((integer))); \
// } while (0)
TEST(Parser, Literals) {
parser parser("<TEMP>", R"(
func test1() { return 67; }
func test2() { return "uwu"; }
)");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 2);
{
auto test1 = program->declarations()[0];
EXPECT_TRUE(test1.present());
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);
return_statement_node_h ret = funcDef->body()->statements[0];
EXPECT_INTLIT(ret->value(), 67);
}
{
auto test2 = program->declarations()[1];
EXPECT_TRUE(test2.present());
EXPECT_EQ(test2->declaration_type(), declaration_node_t::FuncDef);
function_definition_node_h funcDecl = test2;
EXPECT_EQ(funcDecl->name()->string, "test2");
}
}
// TEST(Parser, Literals) {
// parser parser("<TEMP>", R"(
// func test1() { return 67; }
// func test2() { return "uwu"; }
// )");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 2);
// {
// auto test1 = program->declarations()[0];
// EXPECT_TRUE(test1.present());
// 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);
// return_statement_node_h ret = funcDef->body()->statements[0];
// EXPECT_INTLIT(ret->value(), 67);
// }
// {
// auto test2 = program->declarations()[1];
// EXPECT_TRUE(test2.present());
// EXPECT_EQ(test2->declaration_type(), declaration_node_t::FuncDef);
// function_definition_node_h funcDecl = test2;
// EXPECT_EQ(funcDecl->name()->string, "test2");
// }
// }
#define EXPECT_VARREAD(expr, varname) \
do { \
EXPECT_EQ((expr)->expression_type(), expression_node_t::VarRead); \
var_read_expression_node_h varRead = (expr); \
EXPECT_EQ(varRead->get_name(), (varname)); \
} while (0)
// #define EXPECT_VARREAD(expr, varname) \
// do { \
// EXPECT_EQ((expr)->expression_type(), expression_node_t::VarRead); \
// var_read_expression_node_h varRead = (expr); \
// EXPECT_EQ(varRead->get_name(), (varname)); \
// } while (0)
// TODO: Use arena (I am too exhausted rn to do it)
TEST(Parser, OperatorPrecedence_AddMul) {
parser parser("<TEMP>", "func main() { return 1 + 2 * 3; }");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 1);
auto func = program->declarations()[0];
EXPECT_TRUE(func.present());
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);
return_statement_node_h ret = funcDef->body()->statements[0];
// // TODO: Use arena (I am too exhausted rn to do it)
// TEST(Parser, OperatorPrecedence_AddMul) {
// parser parser("<TEMP>", "func main() { return 1 + 2 * 3; }");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 1);
// auto func = program->declarations()[0];
// EXPECT_TRUE(func.present());
// 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);
// return_statement_node_h ret = funcDef->body()->statements[0];
auto retVal = ret->value();
EXPECT_TRUE(retVal.present());
// auto retVal = ret->value();
// EXPECT_TRUE(retVal.present());
EXPECT_EQ(retVal->expression_type(), expression_node_t::Binop);
binop_expression_node_h add = retVal;
EXPECT_EQ(add->type(), binop_expression_node_t::Add);
EXPECT_INTLIT(add->lhs(), 1);
// EXPECT_EQ(retVal->expression_type(), expression_node_t::Binop);
// binop_expression_node_h add = retVal;
// EXPECT_EQ(add->type(), binop_expression_node_t::Add);
// EXPECT_INTLIT(add->lhs(), 1);
EXPECT_EQ(add->rhs()->expression_type(), expression_node_t::Binop);
binop_expression_node_h mul = add->rhs();
EXPECT_EQ(mul->type(), binop_expression_node_t::Mul);
EXPECT_INTLIT(mul->lhs(), 2);
EXPECT_INTLIT(mul->rhs(), 3);
}
// EXPECT_EQ(add->rhs()->expression_type(), expression_node_t::Binop);
// binop_expression_node_h mul = add->rhs();
// EXPECT_EQ(mul->type(), binop_expression_node_t::Mul);
// EXPECT_INTLIT(mul->lhs(), 2);
// EXPECT_INTLIT(mul->rhs(), 3);
// }
TEST(Parser, OperatorPrecedence_Complex) {
parser parser("<TEMP>", "func main() { return 1 + 2 * 3 - 4 / 2; }");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 1);
auto func = program->declarations()[0];
EXPECT_TRUE(func.present());
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);
return_statement_node_h ret = funcDef->body()->statements[0];
// TEST(Parser, OperatorPrecedence_Complex) {
// parser parser("<TEMP>", "func main() { return 1 + 2 * 3 - 4 / 2; }");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 1);
// auto func = program->declarations()[0];
// EXPECT_TRUE(func.present());
// 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);
// return_statement_node_h ret = funcDef->body()->statements[0];
auto retVal = ret->value();
EXPECT_TRUE(retVal.present());
// auto retVal = ret->value();
// EXPECT_TRUE(retVal.present());
EXPECT_EQ(retVal->expression_type(), expression_node_t::Binop);
binop_expression_node_h sub = retVal;
EXPECT_EQ(sub->type(), binop_expression_node_t::Sub);
// EXPECT_EQ(retVal->expression_type(), expression_node_t::Binop);
// binop_expression_node_h sub = retVal;
// EXPECT_EQ(sub->type(), binop_expression_node_t::Sub);
EXPECT_EQ(sub->lhs()->expression_type(), expression_node_t::Binop);
binop_expression_node_h add = sub->lhs();
EXPECT_EQ(add->type(), binop_expression_node_t::Add);
EXPECT_INTLIT(add->lhs(), 1);
// EXPECT_EQ(sub->lhs()->expression_type(), expression_node_t::Binop);
// binop_expression_node_h add = sub->lhs();
// EXPECT_EQ(add->type(), binop_expression_node_t::Add);
// EXPECT_INTLIT(add->lhs(), 1);
EXPECT_EQ(add->rhs()->expression_type(), expression_node_t::Binop);
binop_expression_node_h mul = add->rhs();
EXPECT_EQ(mul->type(), binop_expression_node_t::Mul);
EXPECT_INTLIT(mul->lhs(), 2);
EXPECT_INTLIT(mul->rhs(), 3);
// EXPECT_EQ(add->rhs()->expression_type(), expression_node_t::Binop);
// binop_expression_node_h mul = add->rhs();
// EXPECT_EQ(mul->type(), binop_expression_node_t::Mul);
// EXPECT_INTLIT(mul->lhs(), 2);
// EXPECT_INTLIT(mul->rhs(), 3);
EXPECT_EQ(sub->rhs()->expression_type(), expression_node_t::Binop);
binop_expression_node_h div = sub->rhs();
EXPECT_EQ(div->type(), binop_expression_node_t::Div);
EXPECT_INTLIT(div->lhs(), 4);
EXPECT_INTLIT(div->rhs(), 2);
}
// EXPECT_EQ(sub->rhs()->expression_type(), expression_node_t::Binop);
// binop_expression_node_h div = sub->rhs();
// EXPECT_EQ(div->type(), binop_expression_node_t::Div);
// EXPECT_INTLIT(div->lhs(), 4);
// EXPECT_INTLIT(div->rhs(), 2);
// }
TEST(Parser, UnaryOperator_Simple) {
parser parser("<TEMP>", "func main() { return -5; }");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 1);
auto func = program->declarations()[0];
EXPECT_TRUE(func.present());
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);
return_statement_node_h ret = funcDef->body()->statements[0];
// TEST(Parser, UnaryOperator_Simple) {
// parser parser("<TEMP>", "func main() { return -5; }");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 1);
// auto func = program->declarations()[0];
// EXPECT_TRUE(func.present());
// 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);
// return_statement_node_h ret = funcDef->body()->statements[0];
auto retVal = ret->value();
EXPECT_TRUE(retVal.present());
// auto retVal = ret->value();
// EXPECT_TRUE(retVal.present());
EXPECT_EQ(retVal->expression_type(), expression_node_t::Unaryop);
unaryop_expression_node_h neg = retVal;
EXPECT_EQ(neg->type(), unaryop_expression_node_t::Negative);
EXPECT_INTLIT(neg->get_node(), 5);
}
// EXPECT_EQ(retVal->expression_type(), expression_node_t::Unaryop);
// unaryop_expression_node_h neg = retVal;
// EXPECT_EQ(neg->type(), unaryop_expression_node_t::Negative);
// EXPECT_INTLIT(neg->get_node(), 5);
// }
TEST(Parser, UnaryOperator_PrePost) {
parser parser("<TEMP>", "func main() { return --5++; }");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 1);
auto func = program->declarations()[0];
EXPECT_TRUE(func.present());
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);
return_statement_node_h ret = funcDef->body()->statements[0];
// TEST(Parser, UnaryOperator_PrePost) {
// parser parser("<TEMP>", "func main() { return --5++; }");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 1);
// auto func = program->declarations()[0];
// EXPECT_TRUE(func.present());
// 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);
// return_statement_node_h ret = funcDef->body()->statements[0];
auto retVal = ret->value();
EXPECT_TRUE(retVal.present());
// auto retVal = ret->value();
// EXPECT_TRUE(retVal.present());
EXPECT_EQ(retVal->expression_type(), expression_node_t::Unaryop);
unaryop_expression_node_h inc = retVal;
EXPECT_EQ(inc->type(), unaryop_expression_node_t::PostfixIncrement);
// EXPECT_EQ(retVal->expression_type(), expression_node_t::Unaryop);
// unaryop_expression_node_h inc = retVal;
// EXPECT_EQ(inc->type(), unaryop_expression_node_t::PostfixIncrement);
EXPECT_EQ(inc->get_node()->expression_type(), expression_node_t::Unaryop);
unaryop_expression_node_h dec = inc->get_node();
EXPECT_INTLIT(dec->get_node(), 5);
}
// EXPECT_EQ(inc->get_node()->expression_type(), expression_node_t::Unaryop);
// unaryop_expression_node_h dec = inc->get_node();
// EXPECT_INTLIT(dec->get_node(), 5);
// }
TEST(Parser, Paren) {
parser parser("<TEMP>", "func main() { return --(x++); }");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 1);
auto func = program->declarations()[0];
EXPECT_TRUE(func.present());
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);
return_statement_node_h ret = funcDef->body()->statements[0];
// TEST(Parser, Paren) {
// parser parser("<TEMP>", "func main() { return --(x++); }");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 1);
// auto func = program->declarations()[0];
// EXPECT_TRUE(func.present());
// 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);
// return_statement_node_h ret = funcDef->body()->statements[0];
auto retVal = ret->value();
EXPECT_TRUE(retVal.present());
// auto retVal = ret->value();
// EXPECT_TRUE(retVal.present());
EXPECT_EQ(retVal->expression_type(), expression_node_t::Unaryop);
unaryop_expression_node_h dec = retVal;
EXPECT_EQ(dec->type(), unaryop_expression_node_t::PrefixDecrement);
// EXPECT_EQ(retVal->expression_type(), expression_node_t::Unaryop);
// unaryop_expression_node_h dec = retVal;
// EXPECT_EQ(dec->type(), unaryop_expression_node_t::PrefixDecrement);
EXPECT_EQ(dec->get_node()->expression_type(), expression_node_t::Unaryop);
unaryop_expression_node_h inc = dec->get_node();
EXPECT_EQ(inc->type(), unaryop_expression_node_t::PostfixIncrement);
EXPECT_VARREAD(inc->get_node(), "x"sv);
}
// EXPECT_EQ(dec->get_node()->expression_type(), expression_node_t::Unaryop);
// unaryop_expression_node_h inc = dec->get_node();
// EXPECT_EQ(inc->type(), unaryop_expression_node_t::PostfixIncrement);
// EXPECT_VARREAD(inc->get_node(), "x"sv);
// }
TEST(Parser, Assignment) {
parser parser("<TEMP>", "func main() { x = 10; }");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 1);
auto func = program->declarations()[0];
EXPECT_TRUE(func.present());
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);
// TEST(Parser, Assignment) {
// parser parser("<TEMP>", "func main() { x = 10; }");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 1);
// auto func = program->declarations()[0];
// EXPECT_TRUE(func.present());
// 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);
EXPECT_EQ(funcDef->body()->statements[0]->statement_type(), statement_node_t::Expression);
expression_node_h expr = funcDef->body()->statements[0];
// EXPECT_EQ(funcDef->body()->statements[0]->statement_type(), statement_node_t::Expression);
// expression_node_h expr = funcDef->body()->statements[0];
EXPECT_EQ(expr->expression_type(), expression_node_t::VarAssign);
var_assign_expression_node_h assign = expr;
EXPECT_EQ(assign->compound(), binop_expression_node_t::None);
// EXPECT_EQ(expr->expression_type(), expression_node_t::VarAssign);
// var_assign_expression_node_h assign = expr;
// EXPECT_EQ(assign->compound(), binop_expression_node_t::None);
EXPECT_VARREAD(assign->lhs(), "x"sv);
// EXPECT_VARREAD(assign->lhs(), "x"sv);
expression_node_h rhs = assign->rhs();
EXPECT_EQ(rhs->expression_type(), expression_node_t::Literal);
EXPECT_INTLIT(rhs, 10);
}
// expression_node_h rhs = assign->rhs();
// EXPECT_EQ(rhs->expression_type(), expression_node_t::Literal);
// EXPECT_INTLIT(rhs, 10);
// }
TEST(Parser, CompoundAssignment) {
parser parser("<TEMP>", "func main() { x += 10; }");
auto program = parser.parse();
EXPECT_TRUE(program.present());
EXPECT_EQ(program->declarations().size(), 1);
auto func = program->declarations()[0];
EXPECT_TRUE(func.present());
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);
// TEST(Parser, CompoundAssignment) {
// parser parser("<TEMP>", "func main() { x += 10; }");
// auto program = parser.parse();
// EXPECT_TRUE(program.present());
// EXPECT_EQ(program->declarations().size(), 1);
// auto func = program->declarations()[0];
// EXPECT_TRUE(func.present());
// 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);
EXPECT_EQ(funcDef->body()->statements[0]->statement_type(), statement_node_t::Expression);
expression_node_h expr = funcDef->body()->statements[0];
// EXPECT_EQ(funcDef->body()->statements[0]->statement_type(), statement_node_t::Expression);
// expression_node_h expr = funcDef->body()->statements[0];
EXPECT_EQ(expr->expression_type(), expression_node_t::VarAssign);
var_assign_expression_node_h assign = expr;
EXPECT_EQ(assign->compound(), binop_expression_node_t::Add);
// EXPECT_EQ(expr->expression_type(), expression_node_t::VarAssign);
// var_assign_expression_node_h assign = expr;
// EXPECT_EQ(assign->compound(), binop_expression_node_t::Add);
EXPECT_VARREAD(assign->lhs(), "x"sv);
// EXPECT_VARREAD(assign->lhs(), "x"sv);
expression_node_h rhs = assign->rhs();
EXPECT_EQ(rhs->expression_type(), expression_node_t::Literal);
EXPECT_INTLIT(rhs, 10);
}
// expression_node_h rhs = assign->rhs();
// EXPECT_EQ(rhs->expression_type(), expression_node_t::Literal);
// EXPECT_INTLIT(rhs, 10);
// }
} // namespace