diff --git a/src/language/ASTNode.hpp b/src/language/ASTNode.hpp index 4b1886a660b97e658675e8620c513716a6d490cb..80f47e696d2e50ce8fcdb40131326cd9770d8ce9 100644 --- a/src/language/ASTNode.hpp +++ b/src/language/ASTNode.hpp @@ -66,9 +66,6 @@ class SymbolTable; struct ASTNode : public parse_tree::basic_node<ASTNode> { - using DataType = language::DataType; - using DataVariant = language::DataVariant; - std::shared_ptr<SymbolTable> m_symbol_table; std::unique_ptr<INodeProcessor> m_node_processor; @@ -82,8 +79,8 @@ struct ASTNode : public parse_tree::basic_node<ASTNode> } } - DataType m_data_type{DataType::undefined_t}; - DataVariant m_value; + ASTNodeDataType m_data_type{ASTNodeDataType::undefined_t}; + ASTNodeDataVariant m_value; }; #endif // AST_NODE_HPP diff --git a/src/language/ASTNodeAffectationExpressionBuilder.cpp b/src/language/ASTNodeAffectationExpressionBuilder.cpp index 498ca65add907a9ed0d83c4c5c0904398c680246..d6aefe532085e3240b3d24525c492b795159c3a2 100644 --- a/src/language/ASTNodeAffectationExpressionBuilder.cpp +++ b/src/language/ASTNodeAffectationExpressionBuilder.cpp @@ -100,7 +100,7 @@ class AffectationProcessor final : public INodeProcessor { private: ASTNode& m_node; - DataVariant* p_value{nullptr}; + ASTNodeDataVariant* p_value{nullptr}; static inline const bool _is_defined{[] { if constexpr (std::is_same_v<OperatorT, language::bit_andeq_op> or @@ -152,7 +152,7 @@ class AffectationToStringProcessor final : public INodeProcessor { private: ASTNode& m_node; - DataVariant* p_value{nullptr}; + ASTNodeDataVariant* p_value{nullptr}; static inline const bool _is_defined{[] { if constexpr (std::is_same_v<OperatorT, language::bit_andeq_op> or @@ -202,23 +202,23 @@ class AffectationToStringProcessor final : public INodeProcessor ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode& n) { auto set_affectation_processor = [](ASTNode& n, const auto& operator_v) { - auto set_affectation_processor_for_data = [&](const auto& value, const DataType& data_type) { + auto set_affectation_processor_for_data = [&](const auto& value, const ASTNodeDataType& data_type) { using OperatorT = std::decay_t<decltype(operator_v)>; using ValueT = std::decay_t<decltype(value)>; switch (data_type) { - case DataType::bool_t: { + case ASTNodeDataType::bool_t: { n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, bool>>(n); break; } - case DataType::unsigned_int_t: { + case ASTNodeDataType::unsigned_int_t: { n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, uint64_t>>(n); break; } - case DataType::int_t: { + case ASTNodeDataType::int_t: { n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, int64_t>>(n); break; } - case DataType::double_t: { + case ASTNodeDataType::double_t: { n.m_node_processor = std::make_unique<AffectationProcessor<OperatorT, ValueT, double>>(n); break; } @@ -228,28 +228,28 @@ ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode } }; - auto set_affectation_processor_for_string_data = [&](const DataType& data_type) { + auto set_affectation_processor_for_string_data = [&](const ASTNodeDataType& data_type) { using OperatorT = std::decay_t<decltype(operator_v)>; if constexpr (std::is_same_v<OperatorT, language::eq_op> or std::is_same_v<OperatorT, language::pluseq_op>) { switch (data_type) { - case DataType::bool_t: { + case ASTNodeDataType::bool_t: { n.m_node_processor = std::make_unique<AffectationToStringProcessor<OperatorT, bool>>(n); break; } - case DataType::unsigned_int_t: { + case ASTNodeDataType::unsigned_int_t: { n.m_node_processor = std::make_unique<AffectationToStringProcessor<OperatorT, uint64_t>>(n); break; } - case DataType::int_t: { + case ASTNodeDataType::int_t: { n.m_node_processor = std::make_unique<AffectationToStringProcessor<OperatorT, int64_t>>(n); break; } - case DataType::double_t: { + case ASTNodeDataType::double_t: { n.m_node_processor = std::make_unique<AffectationToStringProcessor<OperatorT, double>>(n); break; } - case DataType::string_t: { + case ASTNodeDataType::string_t: { n.m_node_processor = std::make_unique<AffectationToStringProcessor<OperatorT, std::string>>(n); break; } @@ -262,26 +262,26 @@ ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode } }; - auto set_affectation_processor_for_value = [&](const DataType& value_type) { - const DataType data_type = n.children[1]->m_data_type; + auto set_affectation_processor_for_value = [&](const ASTNodeDataType& value_type) { + const ASTNodeDataType data_type = n.children[1]->m_data_type; switch (value_type) { - case DataType::bool_t: { + case ASTNodeDataType::bool_t: { set_affectation_processor_for_data(bool{}, data_type); break; } - case DataType::unsigned_int_t: { + case ASTNodeDataType::unsigned_int_t: { set_affectation_processor_for_data(uint64_t{}, data_type); break; } - case DataType::int_t: { + case ASTNodeDataType::int_t: { set_affectation_processor_for_data(int64_t{}, data_type); break; } - case DataType::double_t: { + case ASTNodeDataType::double_t: { set_affectation_processor_for_data(double{}, data_type); break; } - case DataType::string_t: { + case ASTNodeDataType::string_t: { set_affectation_processor_for_string_data(data_type); break; } diff --git a/src/language/ASTNodeBinaryOperatorExpressionBuilder.cpp b/src/language/ASTNodeBinaryOperatorExpressionBuilder.cpp index ab3fe55db391f1605aaae5f4d80390acb127f1fe..8d710ac11005f59b3fc37862f5d9c7eac2fd996c 100644 --- a/src/language/ASTNodeBinaryOperatorExpressionBuilder.cpp +++ b/src/language/ASTNodeBinaryOperatorExpressionBuilder.cpp @@ -180,7 +180,7 @@ class BinaryExpressionProcessor final : public INodeProcessor ASTNode& m_node; PUGS_INLINE auto - eval(const DataVariant& a, const DataVariant& b, DataVariant& value) + eval(const ASTNodeDataVariant& a, const ASTNodeDataVariant& b, ASTNodeDataVariant& value) { // Add 'signed' when necessary to avoid signed/unsigned comparison warnings if constexpr ((not(std::is_same_v<A_DataT, bool> or std::is_same_v<B_DataT, bool>)) and @@ -242,23 +242,23 @@ class BinaryExpressionProcessor final : public INodeProcessor ASTNodeBinaryOperatorExpressionBuilder::ASTNodeBinaryOperatorExpressionBuilder(ASTNode& n) { auto set_binary_operator_processor = [](ASTNode& n, const auto& operator_v) { - auto set_binary_operator_processor_for_data_b = [&](const auto data_a, const DataType& data_type_b) { + auto set_binary_operator_processor_for_data_b = [&](const auto data_a, const ASTNodeDataType& data_type_b) { using OperatorT = std::decay_t<decltype(operator_v)>; using DataTA = std::decay_t<decltype(data_a)>; switch (data_type_b) { - case DataType::bool_t: { + case ASTNodeDataType::bool_t: { n.m_node_processor = std::make_unique<BinaryExpressionProcessor<OperatorT, DataTA, bool>>(n); break; } - case DataType::unsigned_int_t: { + case ASTNodeDataType::unsigned_int_t: { n.m_node_processor = std::make_unique<BinaryExpressionProcessor<OperatorT, DataTA, uint64_t>>(n); break; } - case DataType::int_t: { + case ASTNodeDataType::int_t: { n.m_node_processor = std::make_unique<BinaryExpressionProcessor<OperatorT, DataTA, int64_t>>(n); break; } - case DataType::double_t: { + case ASTNodeDataType::double_t: { n.m_node_processor = std::make_unique<BinaryExpressionProcessor<OperatorT, DataTA, double>>(n); break; } @@ -268,22 +268,22 @@ ASTNodeBinaryOperatorExpressionBuilder::ASTNodeBinaryOperatorExpressionBuilder(A } }; - auto set_binary_operator_processor_for_data_a = [&](const DataType& data_type_a) { - const DataType data_type_b = n.children[1]->m_data_type; + auto set_binary_operator_processor_for_data_a = [&](const ASTNodeDataType& data_type_a) { + const ASTNodeDataType data_type_b = n.children[1]->m_data_type; switch (data_type_a) { - case DataType::bool_t: { + case ASTNodeDataType::bool_t: { set_binary_operator_processor_for_data_b(bool{}, data_type_b); break; } - case DataType::unsigned_int_t: { + case ASTNodeDataType::unsigned_int_t: { set_binary_operator_processor_for_data_b(uint64_t{}, data_type_b); break; } - case DataType::int_t: { + case ASTNodeDataType::int_t: { set_binary_operator_processor_for_data_b(int64_t{}, data_type_b); break; } - case DataType::double_t: { + case ASTNodeDataType::double_t: { set_binary_operator_processor_for_data_b(double{}, data_type_b); break; } diff --git a/src/language/ASTNodeDataType.cpp b/src/language/ASTNodeDataType.cpp index e5552d8db03fb52fa78a705cbcf4c6975fbe3e70..a6287f4c2c9c7d177554a9edc155b9d0ee958ecf 100644 --- a/src/language/ASTNodeDataType.cpp +++ b/src/language/ASTNodeDataType.cpp @@ -1,51 +1,47 @@ #include <ASTNodeDataType.hpp> -namespace language -{ std::string -dataTypeName(const DataType& data_type) +dataTypeName(const ASTNodeDataType& data_type) { std::string name; switch (data_type) { - case DataType::undefined_t: + case ASTNodeDataType::undefined_t: name = "undefined"; break; - case DataType::bool_t: + case ASTNodeDataType::bool_t: name = "B"; break; - case DataType::unsigned_int_t: + case ASTNodeDataType::unsigned_int_t: name = "N"; break; - case DataType::int_t: + case ASTNodeDataType::int_t: name = "Z"; break; - case DataType::double_t: + case ASTNodeDataType::double_t: name = "R"; break; - case DataType::string_t: + case ASTNodeDataType::string_t: name = "string"; break; - case DataType::typename_t: + case ASTNodeDataType::typename_t: name = "typename"; break; - case DataType::void_t: + case ASTNodeDataType::void_t: name = "void"; break; } return name; } -DataType -dataTypePromotion(const DataType& data_type_1, const DataType& data_type_2) +ASTNodeDataType +dataTypePromotion(const ASTNodeDataType& data_type_1, const ASTNodeDataType& data_type_2) { if (data_type_1 == data_type_2) { return data_type_1; - } else if ((std::max(data_type_1, data_type_2) <= DataType::double_t) and - (std::min(data_type_1, data_type_2) >= DataType::bool_t)) { + } else if ((std::max(data_type_1, data_type_2) <= ASTNodeDataType::double_t) and + (std::min(data_type_1, data_type_2) >= ASTNodeDataType::bool_t)) { return std::max(data_type_1, data_type_2); } else { - return DataType::undefined_t; + return ASTNodeDataType::undefined_t; } } - -} // namespace language diff --git a/src/language/ASTNodeDataType.hpp b/src/language/ASTNodeDataType.hpp index 605f42524074cb9e35241c0407cc4f986dec2255..91714da952304e77f6a50291221d14a8fba2f615 100644 --- a/src/language/ASTNodeDataType.hpp +++ b/src/language/ASTNodeDataType.hpp @@ -4,9 +4,7 @@ #include <string> #include <variant> -namespace language -{ -enum class DataType +enum class ASTNodeDataType { undefined_t = -1, bool_t = 0, @@ -18,12 +16,10 @@ enum class DataType void_t = 9999 }; -std::string dataTypeName(const DataType& data_type); - -DataType dataTypePromotion(const DataType& data_type_1, const DataType& data_type_2); +std::string dataTypeName(const ASTNodeDataType& data_type); -using DataVariant = std::variant<std::monostate, bool, uint64_t, int64_t, double, std::string>; +ASTNodeDataType dataTypePromotion(const ASTNodeDataType& data_type_1, const ASTNodeDataType& data_type_2); -} // namespace language +using ASTNodeDataVariant = std::variant<std::monostate, bool, uint64_t, int64_t, double, std::string>; #endif // AST_NODE_DATATYPE_HPP diff --git a/src/language/ASTNodeExpressionBuilder.cpp b/src/language/ASTNodeExpressionBuilder.cpp index d97f15b9f1d7d347643272857c6e0445a09b66a4..fd6d3fca68b6abd1f25c8b7b0061f8cc11705d2c 100644 --- a/src/language/ASTNodeExpressionBuilder.cpp +++ b/src/language/ASTNodeExpressionBuilder.cpp @@ -187,7 +187,7 @@ class ForStatement final : public INodeProcessor class NameExpression final : public INodeProcessor { ASTNode& m_node; - DataVariant* p_value{nullptr}; + ASTNodeDataVariant* p_value{nullptr}; public: NameExpression(ASTNode& node) : m_node{node} diff --git a/src/language/ASTNodeIncDecExpressionBuilder.cpp b/src/language/ASTNodeIncDecExpressionBuilder.cpp index 6cc21aa29e9f88be315b8595604723fbf6a2d7f1..fac93f761edadd0b5dc1bf8424a048d47ef554a6 100644 --- a/src/language/ASTNodeIncDecExpressionBuilder.cpp +++ b/src/language/ASTNodeIncDecExpressionBuilder.cpp @@ -55,7 +55,7 @@ template <typename IncDecOpT, typename ValueT, typename DataT> class IncDecExpressionProcessor final : public INodeProcessor { ASTNode& m_node; - DataVariant* p_value{nullptr}; + ASTNodeDataVariant* p_value{nullptr}; static inline const bool _is_defined{[] { if constexpr (std::is_same_v<IncDecOpT, language::unary_minusminus> or @@ -93,23 +93,23 @@ class IncDecExpressionProcessor final : public INodeProcessor ASTNodeIncDecExpressionBuilder::ASTNodeIncDecExpressionBuilder(ASTNode& n) { auto set_inc_dec_operator_processor = [](ASTNode& n, const auto& operator_v) { - auto set_inc_dec_operator_processor_for_data = [&](const auto& value, const DataType& data_type) { + auto set_inc_dec_operator_processor_for_data = [&](const auto& value, const ASTNodeDataType& data_type) { using OperatorT = std::decay_t<decltype(operator_v)>; using ValueT = std::decay_t<decltype(value)>; switch (data_type) { - case DataType::bool_t: { + case ASTNodeDataType::bool_t: { n.m_node_processor = std::make_unique<IncDecExpressionProcessor<OperatorT, ValueT, bool>>(n); break; } - case DataType::unsigned_int_t: { + case ASTNodeDataType::unsigned_int_t: { n.m_node_processor = std::make_unique<IncDecExpressionProcessor<OperatorT, ValueT, uint64_t>>(n); break; } - case DataType::int_t: { + case ASTNodeDataType::int_t: { n.m_node_processor = std::make_unique<IncDecExpressionProcessor<OperatorT, ValueT, int64_t>>(n); break; } - case DataType::double_t: { + case ASTNodeDataType::double_t: { n.m_node_processor = std::make_unique<IncDecExpressionProcessor<OperatorT, ValueT, double>>(n); break; } @@ -119,22 +119,22 @@ ASTNodeIncDecExpressionBuilder::ASTNodeIncDecExpressionBuilder(ASTNode& n) } }; - auto set_inc_dec_processor_for_value = [&](const DataType& value_type) { - const DataType data_type = n.children[0]->m_data_type; + auto set_inc_dec_processor_for_value = [&](const ASTNodeDataType& value_type) { + const ASTNodeDataType data_type = n.children[0]->m_data_type; switch (value_type) { - case DataType::bool_t: { + case ASTNodeDataType::bool_t: { set_inc_dec_operator_processor_for_data(bool{}, data_type); break; } - case DataType::unsigned_int_t: { + case ASTNodeDataType::unsigned_int_t: { set_inc_dec_operator_processor_for_data(uint64_t{}, data_type); break; } - case DataType::int_t: { + case ASTNodeDataType::int_t: { set_inc_dec_operator_processor_for_data(int64_t{}, data_type); break; } - case DataType::double_t: { + case ASTNodeDataType::double_t: { set_inc_dec_operator_processor_for_data(double{}, data_type); break; } diff --git a/src/language/ASTNodeUnaryOperatorExpressionBuilder.cpp b/src/language/ASTNodeUnaryOperatorExpressionBuilder.cpp index 491079f573930dcc5d48bbf0991cb323512ffeeb..60160b95e697213388f8c06efb672d53f9f0f25e 100644 --- a/src/language/ASTNodeUnaryOperatorExpressionBuilder.cpp +++ b/src/language/ASTNodeUnaryOperatorExpressionBuilder.cpp @@ -36,7 +36,7 @@ class UnaryExpressionProcessor final : public INodeProcessor public: PUGS_INLINE ValueT - eval(const DataVariant& a) + eval(const ASTNodeDataVariant& a) { return UnaryOp<UnaryOpT>().eval(std::get<DataT>(a)); } @@ -55,23 +55,23 @@ class UnaryExpressionProcessor final : public INodeProcessor ASTNodeUnaryOperatorExpressionBuilder::ASTNodeUnaryOperatorExpressionBuilder(ASTNode& n) { auto set_unary_operator_processor = [](ASTNode& n, const auto& operator_v) { - auto set_unary_operator_processor_for_data = [&](const auto& value, const DataType& data_type) { + auto set_unary_operator_processor_for_data = [&](const auto& value, const ASTNodeDataType& data_type) { using OperatorT = std::decay_t<decltype(operator_v)>; using ValueT = std::decay_t<decltype(value)>; switch (data_type) { - case DataType::bool_t: { + case ASTNodeDataType::bool_t: { n.m_node_processor = std::make_unique<UnaryExpressionProcessor<OperatorT, ValueT, bool>>(n); break; } - case DataType::unsigned_int_t: { + case ASTNodeDataType::unsigned_int_t: { n.m_node_processor = std::make_unique<UnaryExpressionProcessor<OperatorT, ValueT, uint64_t>>(n); break; } - case DataType::int_t: { + case ASTNodeDataType::int_t: { n.m_node_processor = std::make_unique<UnaryExpressionProcessor<OperatorT, ValueT, int64_t>>(n); break; } - case DataType::double_t: { + case ASTNodeDataType::double_t: { n.m_node_processor = std::make_unique<UnaryExpressionProcessor<OperatorT, ValueT, double>>(n); break; } @@ -81,22 +81,22 @@ ASTNodeUnaryOperatorExpressionBuilder::ASTNodeUnaryOperatorExpressionBuilder(AST } }; - auto set_unary_operator_processor_for_value = [&](const DataType& value_type) { - const DataType data_type = n.children[0]->m_data_type; + auto set_unary_operator_processor_for_value = [&](const ASTNodeDataType& value_type) { + const ASTNodeDataType data_type = n.children[0]->m_data_type; switch (value_type) { - case DataType::bool_t: { + case ASTNodeDataType::bool_t: { set_unary_operator_processor_for_data(bool{}, data_type); break; } - case DataType::unsigned_int_t: { + case ASTNodeDataType::unsigned_int_t: { set_unary_operator_processor_for_data(uint64_t{}, data_type); break; } - case DataType::int_t: { + case ASTNodeDataType::int_t: { set_unary_operator_processor_for_data(int64_t{}, data_type); break; } - case DataType::double_t: { + case ASTNodeDataType::double_t: { set_unary_operator_processor_for_data(double{}, data_type); break; } diff --git a/src/language/ASTPrinter.cpp b/src/language/ASTPrinter.cpp index aab87af9ead8c199a2cf6f3ad270044e3d025d9c..3f5b7344aaeb979becfa81875db39257bb85636b 100644 --- a/src/language/ASTPrinter.cpp +++ b/src/language/ASTPrinter.cpp @@ -3,8 +3,6 @@ #include <PEGGrammar.hpp> -namespace language -{ void ASTPrinter::_print(std::ostream& os, const ASTNode& node) const { @@ -105,4 +103,3 @@ ASTPrinter::ASTPrinter(const ASTNode& node, Format format, std::initializer_list m_info |= static_cast<InfoBaseType>(i); } } -} // namespace language diff --git a/src/language/ASTPrinter.hpp b/src/language/ASTPrinter.hpp index 4d731c840db934f4249101c5a0cd002ae961876c..464a67435c88a028254f8b52c59bb6f4005b4e2f 100644 --- a/src/language/ASTPrinter.hpp +++ b/src/language/ASTPrinter.hpp @@ -3,8 +3,6 @@ #include <ASTNode.hpp> -namespace language -{ class ASTPrinter { public: @@ -56,5 +54,5 @@ class ASTPrinter ~ASTPrinter() = default; }; -} // namespace language + #endif // AST_PRINTER_HPP diff --git a/src/language/PugsParser.cpp b/src/language/PugsParser.cpp index d2d3c89102289daca1680926edf11d16eee70d9d..fcd2261c291207a8e7c2f8c7e606fa09e196b9dc 100644 --- a/src/language/PugsParser.cpp +++ b/src/language/PugsParser.cpp @@ -138,37 +138,37 @@ build_node_data_types(ASTNode& n) build_node_data_types(*child); } } - n.m_data_type = DataType::void_t; + n.m_data_type = ASTNodeDataType::void_t; } else { if (n.has_content()) { if (n.is<language::true_kw>() or n.is<language::false_kw>() or n.is<language::do_kw>()) { - n.m_data_type = DataType::bool_t; + n.m_data_type = ASTNodeDataType::bool_t; } else if (n.is<language::real>()) { - n.m_data_type = DataType::double_t; + n.m_data_type = ASTNodeDataType::double_t; } else if (n.is<language::integer>()) { - n.m_data_type = DataType::int_t; + n.m_data_type = ASTNodeDataType::int_t; } else if (n.is<language::literal>()) { - n.m_data_type = DataType::string_t; + n.m_data_type = ASTNodeDataType::string_t; } else if (n.is<language::cout_kw>() or n.is<language::cerr_kw>() or n.is<language::clog_kw>()) { - n.m_data_type = DataType::void_t; + n.m_data_type = ASTNodeDataType::void_t; } else if (n.is<language::declaration>()) { auto& type_node = *(n.children[0]); - DataType data_type{DataType::undefined_t}; + ASTNodeDataType data_type{ASTNodeDataType::undefined_t}; if (type_node.is<language::B_set>()) { - data_type = DataType::bool_t; + data_type = ASTNodeDataType::bool_t; } else if (type_node.is<language::Z_set>()) { - data_type = DataType::int_t; + data_type = ASTNodeDataType::int_t; } else if (type_node.is<language::N_set>()) { - data_type = DataType::unsigned_int_t; + data_type = ASTNodeDataType::unsigned_int_t; } else if (type_node.is<language::R_set>()) { - data_type = DataType::double_t; + data_type = ASTNodeDataType::double_t; } else if (type_node.is<language::string_type>()) { - data_type = DataType::string_t; + data_type = ASTNodeDataType::string_t; } - if (data_type == DataType::undefined_t) { + if (data_type == ASTNodeDataType::undefined_t) { throw parse_error("unexpected error: invalid datatype", type_node.begin()); } - type_node.m_data_type = DataType::void_t; + type_node.m_data_type = ASTNodeDataType::void_t; n.children[1]->m_data_type = data_type; const std::string& symbol = n.children[1]->string(); @@ -191,23 +191,24 @@ build_node_data_types(ASTNode& n) } if (n.is<language::break_kw>() or n.is<language::continue_kw>()) { - n.m_data_type = DataType::void_t; + n.m_data_type = ASTNodeDataType::void_t; } else if (n.is<language::eq_op>() or n.is<language::multiplyeq_op>() or n.is<language::divideeq_op>() or n.is<language::pluseq_op>() or n.is<language::minuseq_op>() or n.is<language::bit_andeq_op>() or n.is<language::bit_xoreq_op>() or n.is<language::bit_oreq_op>()) { n.m_data_type = n.children[0]->m_data_type; } else if (n.is<language::for_statement>()) { - n.m_data_type = DataType::void_t; + n.m_data_type = ASTNodeDataType::void_t; } else if (n.is<language::for_post>() or n.is<language::for_init>() or n.is<language::for_statement_bloc>()) { - n.m_data_type = DataType::void_t; + n.m_data_type = ASTNodeDataType::void_t; } else if (n.is<language::for_test>()) { - n.m_data_type = DataType::bool_t; + n.m_data_type = ASTNodeDataType::bool_t; } else if (n.is<language::statement_bloc>()) { - n.m_data_type = DataType::void_t; + n.m_data_type = ASTNodeDataType::void_t; } else if (n.is<language::if_statement>() or n.is<language::while_statement>()) { - n.m_data_type = DataType::void_t; - if ((n.children[0]->m_data_type > DataType::double_t) or (n.children[0]->m_data_type < DataType::bool_t)) { - const DataType type_0 = n.children[0]->m_data_type; + n.m_data_type = ASTNodeDataType::void_t; + if ((n.children[0]->m_data_type > ASTNodeDataType::double_t) or + (n.children[0]->m_data_type < ASTNodeDataType::bool_t)) { + const ASTNodeDataType type_0 = n.children[0]->m_data_type; std::ostringstream message; message << "Cannot convert data type to boolean value\n" << "note: incompatible operand '" << n.children[0]->string() << " of type ' (" << dataTypeName(type_0) @@ -215,9 +216,10 @@ build_node_data_types(ASTNode& n) throw parse_error(message.str(), n.children[0]->begin()); } } else if (n.is<language::do_while_statement>()) { - n.m_data_type = DataType::void_t; - if ((n.children[1]->m_data_type > DataType::double_t) or (n.children[1]->m_data_type < DataType::bool_t)) { - const DataType type_0 = n.children[1]->m_data_type; + n.m_data_type = ASTNodeDataType::void_t; + if ((n.children[1]->m_data_type > ASTNodeDataType::double_t) or + (n.children[1]->m_data_type < ASTNodeDataType::bool_t)) { + const ASTNodeDataType type_0 = n.children[1]->m_data_type; std::ostringstream message; message << "Cannot convert data type to boolean value\n" << "note: incompatible operand '" << n.children[1]->string() << " of type ' (" << dataTypeName(type_0) @@ -228,17 +230,17 @@ build_node_data_types(ASTNode& n) n.is<language::greater_op>() or n.is<language::greater_or_eq_op>() or n.is<language::eqeq_op>() or n.is<language::not_eq_op>() or n.is<language::and_op>() or n.is<language::or_op>() or n.is<language::xor_op>() or n.is<language::bitand_op>() or n.is<language::bitor_op>()) { - n.m_data_type = DataType::bool_t; + n.m_data_type = ASTNodeDataType::bool_t; } else if (n.is<language::unary_minus>() or n.is<language::unary_plus>() or n.is<language::unary_plusplus>() or n.is<language::unary_minusminus>()) { n.m_data_type = n.children[0]->m_data_type; } else if (n.is<language::plus_op>() or n.is<language::minus_op>() or n.is<language::multiply_op>() or n.is<language::divide_op>()) { - const DataType type_0 = n.children[0]->m_data_type; - const DataType type_1 = n.children[1]->m_data_type; + const ASTNodeDataType type_0 = n.children[0]->m_data_type; + const ASTNodeDataType type_1 = n.children[1]->m_data_type; n.m_data_type = dataTypePromotion(type_0, type_1); - if (n.m_data_type == DataType::undefined_t) { + if (n.m_data_type == ASTNodeDataType::undefined_t) { std::ostringstream message; message << "undefined binary operator\n" << "note: incompatible operand types " << n.children[0]->string() << " (" << dataTypeName(type_0) @@ -254,7 +256,7 @@ void build_node_data_types(ASTNode& n) { Assert(n.is_root()); - n.m_data_type = DataType::void_t; + n.m_data_type = ASTNodeDataType::void_t; internal::build_node_data_types(n); std::cout << " - build node data types\n"; @@ -265,7 +267,7 @@ namespace internal void check_node_data_types(const ASTNode& n) { - if (n.m_data_type == DataType::undefined_t) { + if (n.m_data_type == ASTNodeDataType::undefined_t) { throw parse_error("unexpected error: undefined datatype for AST node for " + n.name(), n.begin()); } @@ -295,7 +297,7 @@ build_node_values(ASTNode& n, std::shared_ptr<SymbolTable>& symbol_table) build_node_values(*child, bloc_symbol_table); } } - n.m_data_type = DataType::void_t; + n.m_data_type = ASTNodeDataType::void_t; } else { for (auto& child : n.children) { build_node_values(*child, symbol_table); @@ -332,7 +334,7 @@ void build_node_values(ASTNode& n) { Assert(n.is_root()); - n.m_data_type = DataType::void_t; + n.m_data_type = ASTNodeDataType::void_t; std::shared_ptr symbol_table = std::make_shared<SymbolTable>(); internal::build_node_values(n, symbol_table); std::cout << " - build node data types\n"; @@ -436,7 +438,7 @@ parser(const std::string& filename) language::build_node_type(*root_node); - std::cout << language::ASTPrinter{*root_node} << '\n'; + std::cout << ASTPrinter{*root_node} << '\n'; ExecUntilBreakOrContinue exec_all; root_node->execute(exec_all); diff --git a/src/language/SymbolTable.hpp b/src/language/SymbolTable.hpp index 3cfd66a5b392a852ca752de777a99a09d3bf46dd..e86bd1e45c5eaedce0cba80a6581bd4f25688b0a 100644 --- a/src/language/SymbolTable.hpp +++ b/src/language/SymbolTable.hpp @@ -9,12 +9,9 @@ class SymbolTable class Attributes { private: - using DataType = language::DataType; - using DataVariant = language::DataVariant; - bool m_is_initialized{false}; - DataType m_data_type{DataType::undefined_t}; - DataVariant m_value; + ASTNodeDataType m_data_type{ASTNodeDataType::undefined_t}; + ASTNodeDataVariant m_value; public: auto& @@ -41,14 +38,14 @@ class SymbolTable m_is_initialized = true; } - const DataType& + const ASTNodeDataType& dataType() const { return m_data_type; } void - setDataType(const DataType& data_type) + setDataType(const ASTNodeDataType& data_type) { m_data_type = data_type; } diff --git a/tests/test_ASTBuilder.cpp b/tests/test_ASTBuilder.cpp index 1aef598c1180da9593046c77873e9d512976af07..40bb550f33a2a0ea2242a9725cba303f75634cae 100644 --- a/tests/test_ASTBuilder.cpp +++ b/tests/test_ASTBuilder.cpp @@ -8,7 +8,6 @@ { \ static_assert(std::is_same_v<std::decay_t<decltype(data)>, std::string_view>); \ static_assert(std::is_same_v<std::decay_t<decltype(expected_output)>, std::string_view>); \ - using namespace language; \ \ string_input input{data, "test.pgs"}; \ auto ast = ASTBuilder::build(input); \ @@ -591,7 +590,6 @@ clog << "log " << l << "\n"; 1+; // syntax error )"; - using namespace language; string_input input{data, "test.pgs"}; REQUIRE_THROWS_AS(ASTBuilder::build(input), parse_error);