Skip to content
Snippets Groups Projects
Commit 34d6a933 authored by Stéphane Del Pino's avatar Stéphane Del Pino
Browse files

Change increment decrement operators expression builder

One now use OperatorRepository
parent 39e8b549
No related branches found
No related tags found
1 merge request!70Feature/language reduce static
Showing
with 332 additions and 59 deletions
#include <language/ast/ASTNodeIncDecExpressionBuilder.hpp> #include <language/ast/ASTNodeIncDecExpressionBuilder.hpp>
#include <language/PEGGrammar.hpp> #include <language/PEGGrammar.hpp>
#include <language/node_processor/IncDecExpressionProcessor.hpp> #include <language/utils/IncDecOperatorMangler.hpp>
#include <language/utils/OperatorRepository.hpp>
#include <language/utils/ParseError.hpp> #include <language/utils/ParseError.hpp>
ASTNodeIncDecExpressionBuilder::ASTNodeIncDecExpressionBuilder(ASTNode& n) ASTNodeIncDecExpressionBuilder::ASTNodeIncDecExpressionBuilder(ASTNode& n)
{ {
auto set_inc_dec_operator_processor = [](ASTNode& n, const auto& operator_v) { const ASTNodeDataType& data_type = n.children[0]->m_data_type;
auto set_inc_dec_processor_for_value = [&](const ASTNodeDataType& data_type) {
using OperatorT = std::decay_t<decltype(operator_v)>;
switch (data_type) {
case ASTNodeDataType::unsigned_int_t: {
n.m_node_processor = std::make_unique<IncDecExpressionProcessor<OperatorT, uint64_t>>(n);
break;
}
case ASTNodeDataType::int_t: {
n.m_node_processor = std::make_unique<IncDecExpressionProcessor<OperatorT, int64_t>>(n);
break;
}
case ASTNodeDataType::double_t: {
n.m_node_processor = std::make_unique<IncDecExpressionProcessor<OperatorT, double>>(n);
break;
}
default: {
throw ParseError("unexpected error: undefined data type for unary operator", std::vector{n.begin()});
}
}
};
if (not n.children[0]->is_type<language::name>()) { if (not n.children[0]->is_type<language::name>()) {
if (n.children[0]->is_type<language::post_minusminus>() or n.children[0]->is_type<language::post_plusplus>() or std::ostringstream error_message;
n.children[0]->is_type<language::unary_minusminus>() or n.children[0]->is_type<language::unary_plusplus>()) { error_message << "invalid operand type. ++/-- operators only apply to variables";
throw ParseError("chaining ++ or -- operators is not allowed", std::vector{n.children[0]->begin()});
} else {
throw ParseError("invalid operand type for unary operator", std::vector{n.children[0]->begin()});
}
}
set_inc_dec_processor_for_value(n.m_data_type); throw ParseError(error_message.str(), std::vector{n.children[0]->begin()});
}; }
const std::string inc_dec_operator_name = [&] {
if (n.is_type<language::unary_minusminus>()) { if (n.is_type<language::unary_minusminus>()) {
set_inc_dec_operator_processor(n, language::unary_minusminus{}); return incDecOperatorMangler<language::unary_minusminus>(data_type);
} else if (n.is_type<language::unary_plusplus>()) { } else if (n.is_type<language::unary_plusplus>()) {
set_inc_dec_operator_processor(n, language::unary_plusplus{}); return incDecOperatorMangler<language::unary_plusplus>(data_type);
} else if (n.is_type<language::post_minusminus>()) { } else if (n.is_type<language::post_minusminus>()) {
set_inc_dec_operator_processor(n, language::post_minusminus{}); return incDecOperatorMangler<language::post_minusminus>(data_type);
} else if (n.is_type<language::post_plusplus>()) { } else if (n.is_type<language::post_plusplus>()) {
set_inc_dec_operator_processor(n, language::post_plusplus{}); return incDecOperatorMangler<language::post_plusplus>(data_type);
} else { } else {
throw ParseError("unexpected error: undefined increment/decrement operator", std::vector{n.begin()}); throw ParseError("unexpected error: undefined inc/dec operator", std::vector{n.begin()});
}
}();
const auto& optional_processor_builder =
OperatorRepository::instance().getIncDecProcessorBuilder(inc_dec_operator_name);
if (optional_processor_builder.has_value()) {
n.m_node_processor = optional_processor_builder.value()->getNodeProcessor(n);
} else {
std::ostringstream error_message;
error_message << "undefined affectation type: ";
error_message << rang::fgB::red << inc_dec_operator_name << rang::fg::reset;
throw ParseError(error_message.str(), std::vector{n.children[0]->begin()});
} }
} }
#include <language/ast/ASTNodeUnaryOperatorExpressionBuilder.hpp> #include <language/ast/ASTNodeUnaryOperatorExpressionBuilder.hpp>
#include <language/PEGGrammar.hpp> #include <language/PEGGrammar.hpp>
#include <language/node_processor/UnaryExpressionProcessor.hpp>
#include <language/utils/OperatorRepository.hpp> #include <language/utils/OperatorRepository.hpp>
#include <language/utils/ParseError.hpp> #include <language/utils/ParseError.hpp>
#include <language/utils/UnaryOperatorMangler.hpp> #include <language/utils/UnaryOperatorMangler.hpp>
......
#ifndef AFFECTATION_REGISTER_FOR_B_HPP #ifndef AFFECTATION_REGISTER_FOR_B_HPP
#define AFFECTATION_REGISTER_FOR_B_HPP #define AFFECTATION_REGISTER_FOR_B_HPP
#include <language/utils/OperatorRepository.hpp>
class AffectationRegisterForB class AffectationRegisterForB
{ {
public: public:
......
#ifndef AFFECTATION_REGISTER_FOR_N_HPP #ifndef AFFECTATION_REGISTER_FOR_N_HPP
#define AFFECTATION_REGISTER_FOR_N_HPP #define AFFECTATION_REGISTER_FOR_N_HPP
#include <language/utils/OperatorRepository.hpp>
class AffectationRegisterForN class AffectationRegisterForN
{ {
private: private:
......
#ifndef AFFECTATION_REGISTER_FOR_R_HPP #ifndef AFFECTATION_REGISTER_FOR_R_HPP
#define AFFECTATION_REGISTER_FOR_R_HPP #define AFFECTATION_REGISTER_FOR_R_HPP
#include <language/utils/OperatorRepository.hpp>
class AffectationRegisterForR class AffectationRegisterForR
{ {
private: private:
......
#ifndef AFFECTATION_REGISTER_FOR_R1_HPP #ifndef AFFECTATION_REGISTER_FOR_R1_HPP
#define AFFECTATION_REGISTER_FOR_R1_HPP #define AFFECTATION_REGISTER_FOR_R1_HPP
#include <language/utils/OperatorRepository.hpp>
class AffectationRegisterForR1 class AffectationRegisterForR1
{ {
private: private:
......
#ifndef AFFECTATION_REGISTER_FOR_R2_HPP #ifndef AFFECTATION_REGISTER_FOR_R2_HPP
#define AFFECTATION_REGISTER_FOR_R2_HPP #define AFFECTATION_REGISTER_FOR_R2_HPP
#include <language/utils/OperatorRepository.hpp>
class AffectationRegisterForR2 class AffectationRegisterForR2
{ {
private: private:
......
#ifndef AFFECTATION_REGISTER_FOR_R3_HPP #ifndef AFFECTATION_REGISTER_FOR_R3_HPP
#define AFFECTATION_REGISTER_FOR_R3_HPP #define AFFECTATION_REGISTER_FOR_R3_HPP
#include <language/utils/OperatorRepository.hpp>
class AffectationRegisterForR3 class AffectationRegisterForR3
{ {
private: private:
......
#ifndef AFFECTATION_REGISTER_FOR_STRING_HPP #ifndef AFFECTATION_REGISTER_FOR_STRING_HPP
#define AFFECTATION_REGISTER_FOR_STRING_HPP #define AFFECTATION_REGISTER_FOR_STRING_HPP
#include <language/utils/OperatorRepository.hpp>
class AffectationRegisterForString class AffectationRegisterForString
{ {
private: private:
......
#ifndef AFFECTATION_REGISTER_FOR_Z_HPP #ifndef AFFECTATION_REGISTER_FOR_Z_HPP
#define AFFECTATION_REGISTER_FOR_Z_HPP #define AFFECTATION_REGISTER_FOR_Z_HPP
#include <language/utils/OperatorRepository.hpp>
class AffectationRegisterForZ class AffectationRegisterForZ
{ {
private: private:
......
...@@ -15,6 +15,9 @@ add_library(PugsLanguageUtils ...@@ -15,6 +15,9 @@ add_library(PugsLanguageUtils
ASTPrinter.cpp ASTPrinter.cpp
DataVariant.cpp DataVariant.cpp
EmbeddedData.cpp EmbeddedData.cpp
IncDecOperatorRegisterForN.cpp
IncDecOperatorRegisterForR.cpp
IncDecOperatorRegisterForZ.cpp
OperatorRepository.cpp OperatorRepository.cpp
UnaryOperatorRegisterForB.cpp UnaryOperatorRegisterForB.cpp
UnaryOperatorRegisterForN.cpp UnaryOperatorRegisterForN.cpp
......
#ifndef I_INC_DEC_OPERATOR_PROCESSOR_BUILDER_HPP
#define I_INC_DEC_OPERATOR_PROCESSOR_BUILDER_HPP
class ASTNode;
class INodeProcessor;
#include <memory>
class IIncDecOperatorProcessorBuilder
{
public:
virtual std::unique_ptr<INodeProcessor> getNodeProcessor(ASTNode& node) const = 0;
virtual ~IIncDecOperatorProcessorBuilder() = default;
};
#endif // I_INC_DEC_OPERATOR_PROCESSOR_BUILDER_HPP
#ifndef INC_DEC_OPERATOR_MANGLER_HPP
#define INC_DEC_OPERATOR_MANGLER_HPP
#include <language/utils/ASTNodeDataType.hpp>
#include <utils/Exceptions.hpp>
#include <string>
namespace language
{
struct unary_minusminus;
struct unary_plusplus;
struct post_minusminus;
struct post_plusplus;
} // namespace language
template <typename IncDecOperatorT>
std::string
incDecOperatorMangler(const ASTNodeDataType& operand)
{
if constexpr (std::is_same_v<language::unary_minusminus, IncDecOperatorT>) {
return std::string{"-- "} + dataTypeName(operand);
} else if constexpr (std::is_same_v<language::post_minusminus, IncDecOperatorT>) {
return dataTypeName(operand) + " --";
} else if constexpr (std::is_same_v<language::unary_plusplus, IncDecOperatorT>) {
return std::string{"++ "} + dataTypeName(operand);
} else if constexpr (std::is_same_v<language::post_plusplus, IncDecOperatorT>) {
return dataTypeName(operand) + " ++";
} else {
static_assert(std::is_same_v<language::unary_minusminus, IncDecOperatorT>, "undefined inc/dec operator");
}
}
#endif // INC_DEC_OPERATOR_MANGLER_HPP
#ifndef INC_DEC_OPERATOR_PROCESSOR_BUILDER_HPP
#define INC_DEC_OPERATOR_PROCESSOR_BUILDER_HPP
#include <algebra/TinyVector.hpp>
#include <language/PEGGrammar.hpp>
#include <language/node_processor/IncDecExpressionProcessor.hpp>
#include <language/utils/IIncDecOperatorProcessorBuilder.hpp>
#include <type_traits>
template <typename OperatorT, typename DataT>
class IncDecOperatorProcessorBuilder final : public IIncDecOperatorProcessorBuilder
{
public:
IncDecOperatorProcessorBuilder() = default;
std::unique_ptr<INodeProcessor>
getNodeProcessor(ASTNode& node) const
{
return std::make_unique<IncDecExpressionProcessor<OperatorT, DataT>>(node);
}
};
#endif // INC_DEC_OPERATOR_PROCESSOR_BUILDER_HPP
#include <language/utils/IncDecOperatorRegisterForN.hpp>
#include <language/utils/IncDecOperatorProcessorBuilder.hpp>
#include <language/utils/OperatorRepository.hpp>
void
IncDecOperatorRegisterForN::_register_unary_minusminus()
{
OperatorRepository& repository = OperatorRepository::instance();
auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
repository.addIncDecOperator<language::unary_minusminus>(N, std::make_shared<IncDecOperatorProcessorBuilder<
language::unary_minusminus, uint64_t>>());
}
void
IncDecOperatorRegisterForN::_register_unary_plusplus()
{
OperatorRepository& repository = OperatorRepository::instance();
auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
repository.addIncDecOperator<
language::unary_plusplus>(N,
std::make_shared<IncDecOperatorProcessorBuilder<language::unary_plusplus, uint64_t>>());
}
void
IncDecOperatorRegisterForN::_register_post_minusminus()
{
OperatorRepository& repository = OperatorRepository::instance();
auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
repository.addIncDecOperator<
language::post_minusminus>(N,
std::make_shared<IncDecOperatorProcessorBuilder<language::post_minusminus, uint64_t>>());
}
void
IncDecOperatorRegisterForN::_register_post_plusplus()
{
OperatorRepository& repository = OperatorRepository::instance();
auto N = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
repository.addIncDecOperator<
language::post_plusplus>(N, std::make_shared<IncDecOperatorProcessorBuilder<language::post_plusplus, uint64_t>>());
}
IncDecOperatorRegisterForN::IncDecOperatorRegisterForN()
{
this->_register_unary_minusminus();
this->_register_unary_plusplus();
this->_register_post_minusminus();
this->_register_post_plusplus();
}
#ifndef INC_DEC_OPERATOR_REGISTER_FOR_N_HPP
#define INC_DEC_OPERATOR_REGISTER_FOR_N_HPP
class IncDecOperatorRegisterForN
{
private:
void _register_unary_minusminus();
void _register_unary_plusplus();
void _register_post_minusminus();
void _register_post_plusplus();
public:
IncDecOperatorRegisterForN();
};
#endif // INC_DEC_OPERATOR_REGISTER_FOR_N_HPP
#include <language/utils/IncDecOperatorRegisterForR.hpp>
#include <language/utils/IncDecOperatorProcessorBuilder.hpp>
#include <language/utils/OperatorRepository.hpp>
void
IncDecOperatorRegisterForR::_register_unary_minusminus()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
repository.addIncDecOperator<language::unary_minusminus>(R, std::make_shared<IncDecOperatorProcessorBuilder<
language::unary_minusminus, double_t>>());
}
void
IncDecOperatorRegisterForR::_register_unary_plusplus()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
repository.addIncDecOperator<
language::unary_plusplus>(R,
std::make_shared<IncDecOperatorProcessorBuilder<language::unary_plusplus, double_t>>());
}
void
IncDecOperatorRegisterForR::_register_post_minusminus()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
repository.addIncDecOperator<
language::post_minusminus>(R,
std::make_shared<IncDecOperatorProcessorBuilder<language::post_minusminus, double_t>>());
}
void
IncDecOperatorRegisterForR::_register_post_plusplus()
{
OperatorRepository& repository = OperatorRepository::instance();
auto R = ASTNodeDataType::build<ASTNodeDataType::double_t>();
repository.addIncDecOperator<
language::post_plusplus>(R, std::make_shared<IncDecOperatorProcessorBuilder<language::post_plusplus, double_t>>());
}
IncDecOperatorRegisterForR::IncDecOperatorRegisterForR()
{
this->_register_unary_minusminus();
this->_register_unary_plusplus();
this->_register_post_minusminus();
this->_register_post_plusplus();
}
#ifndef INC_DEC_OPERATOR_REGISTER_FOR_R_HPP
#define INC_DEC_OPERATOR_REGISTER_FOR_R_HPP
class IncDecOperatorRegisterForR
{
private:
void _register_unary_minusminus();
void _register_unary_plusplus();
void _register_post_minusminus();
void _register_post_plusplus();
public:
IncDecOperatorRegisterForR();
};
#endif // INC_DEC_OPERATOR_REGISTER_FOR_Z_HPP
#include <language/utils/IncDecOperatorRegisterForZ.hpp>
#include <language/utils/IncDecOperatorProcessorBuilder.hpp>
#include <language/utils/OperatorRepository.hpp>
void
IncDecOperatorRegisterForZ::_register_unary_minusminus()
{
OperatorRepository& repository = OperatorRepository::instance();
auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
repository.addIncDecOperator<language::unary_minusminus>(Z, std::make_shared<IncDecOperatorProcessorBuilder<
language::unary_minusminus, int64_t>>());
}
void
IncDecOperatorRegisterForZ::_register_unary_plusplus()
{
OperatorRepository& repository = OperatorRepository::instance();
auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
repository.addIncDecOperator<
language::unary_plusplus>(Z, std::make_shared<IncDecOperatorProcessorBuilder<language::unary_plusplus, int64_t>>());
}
void
IncDecOperatorRegisterForZ::_register_post_minusminus()
{
OperatorRepository& repository = OperatorRepository::instance();
auto N = ASTNodeDataType::build<ASTNodeDataType::int_t>();
repository.addIncDecOperator<
language::post_minusminus>(N,
std::make_shared<IncDecOperatorProcessorBuilder<language::post_minusminus, int64_t>>());
}
void
IncDecOperatorRegisterForZ::_register_post_plusplus()
{
OperatorRepository& repository = OperatorRepository::instance();
auto Z = ASTNodeDataType::build<ASTNodeDataType::int_t>();
repository.addIncDecOperator<
language::post_plusplus>(Z, std::make_shared<IncDecOperatorProcessorBuilder<language::post_plusplus, int64_t>>());
}
IncDecOperatorRegisterForZ::IncDecOperatorRegisterForZ()
{
this->_register_unary_minusminus();
this->_register_unary_plusplus();
this->_register_post_minusminus();
this->_register_post_plusplus();
}
#ifndef INC_DEC_OPERATOR_REGISTER_FOR_Z_HPP
#define INC_DEC_OPERATOR_REGISTER_FOR_Z_HPP
class IncDecOperatorRegisterForZ
{
private:
void _register_unary_minusminus();
void _register_unary_plusplus();
void _register_post_minusminus();
void _register_post_plusplus();
public:
IncDecOperatorRegisterForZ();
};
#endif // INC_DEC_OPERATOR_REGISTER_FOR_Z_HPP
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment