ASTNodeDataTypeBuilder.cpp

#include <ASTNodeDataTypeBuilder.hpp>

#include <PEGGrammar.hpp>
#include <PugsAssert.hpp>
#include <SymbolTable.hpp>

void
ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n)
{
  if (n.is<language::block>() or n.is<language::for_statement>()) {
    for (auto& child : n.children) {
      this->_buildNodeDataTypes(*child);
    }
    n.m_data_type = ASTNodeDataType::void_t;
  } else {
    if (n.has_content()) {
      if (n.is<language::true_kw>() or n.is<language::false_kw>()) {
        n.m_data_type = ASTNodeDataType::bool_t;
      } else if (n.is<language::real>()) {
        n.m_data_type = ASTNodeDataType::double_t;
      } else if (n.is<language::integer>()) {
        n.m_data_type = ASTNodeDataType::int_t;
      } else if (n.is<language::literal>()) {
        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 = ASTNodeDataType::void_t;
      } else if (n.is<language::declaration>()) {
        auto& type_node = *(n.children[0]);
        ASTNodeDataType data_type{ASTNodeDataType::undefined_t};
        if (type_node.is<language::B_set>()) {
          data_type = ASTNodeDataType::bool_t;
        } else if (type_node.is<language::Z_set>()) {
          data_type = ASTNodeDataType::int_t;
        } else if (type_node.is<language::N_set>()) {
          data_type = ASTNodeDataType::unsigned_int_t;
        } else if (type_node.is<language::R_set>()) {
          data_type = ASTNodeDataType::double_t;
        } else if (type_node.is<language::string_type>()) {
          data_type = ASTNodeDataType::string_t;
        }

        Assert(data_type != ASTNodeDataType::undefined_t);   // LCOV_EXCL_LINE

        type_node.m_data_type      = ASTNodeDataType::void_t;
        n.children[1]->m_data_type = data_type;
        const std::string& symbol  = n.children[1]->string();

        std::shared_ptr<SymbolTable>& symbol_table = n.m_symbol_table;

        auto [i_symbol, found] = symbol_table->find(symbol, n.children[1]->begin());
        Assert(found);
        i_symbol->second.setDataType(data_type);
        n.m_data_type = data_type;
      } else if (n.is<language::let_declaration>()) {
        n.children[0]->m_data_type = ASTNodeDataType::function_t;

        n.children[1]->children[0]->m_data_type = ASTNodeDataType::typename_t;
        n.children[1]->children[1]->m_data_type = ASTNodeDataType::typename_t;

        {   // Function data type
          const std::string& symbol = n.children[0]->string();

          std::shared_ptr<SymbolTable>& symbol_table = n.m_symbol_table;

          auto [i_symbol, found] = symbol_table->find(symbol, n.children[0]->begin());
          Assert(found);
          i_symbol->second.setDataType(n.children[0]->m_data_type);
        }
        auto& type_node = *(n.children[1]->children[0]);
        ASTNodeDataType data_type{ASTNodeDataType::undefined_t};
        if (type_node.is<language::B_set>()) {
          data_type = ASTNodeDataType::bool_t;
        } else if (type_node.is<language::Z_set>()) {
          data_type = ASTNodeDataType::int_t;
        } else if (type_node.is<language::N_set>()) {
          data_type = ASTNodeDataType::unsigned_int_t;
        } else if (type_node.is<language::R_set>()) {
          data_type = ASTNodeDataType::double_t;
        } else if (type_node.is<language::string_type>()) {
          data_type = ASTNodeDataType::string_t;
        }

        Assert(data_type != ASTNodeDataType::undefined_t);   // LCOV_EXCL_LINE

        n.children[2]->children[0]->m_data_type = data_type;
        const std::string& symbol               = n.children[2]->children[0]->string();

        std::shared_ptr<SymbolTable>& symbol_table = n.m_symbol_table;

        auto [i_symbol, found] = symbol_table->find(symbol, n.children[2]->children[0]->begin());
        Assert(found);
        i_symbol->second.setDataType(data_type);
        n.m_data_type = ASTNodeDataType::void_t;
      } else if (n.is<language::name>()) {
        std::shared_ptr<SymbolTable>& symbol_table = n.m_symbol_table;

        auto [i_symbol, found] = symbol_table->find(n.string(), n.begin());
        Assert(found);
        n.m_data_type = i_symbol->second.dataType();
      }
    }
    for (auto& child : n.children) {
      this->_buildNodeDataTypes(*child);
    }

    if (n.is<language::break_kw>() or n.is<language::continue_kw>()) {
      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>()) {
      n.m_data_type = n.children[0]->m_data_type;
    } else if (n.is<language::function_domain_mapping>() or n.is<language::function_definition>()) {
      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_block>()) {
      n.m_data_type = ASTNodeDataType::void_t;
    } else if (n.is<language::for_test>()) {
      n.m_data_type = ASTNodeDataType::bool_t;
    } else if (n.is<language::statement_block>()) {
      n.m_data_type = ASTNodeDataType::void_t;
    } else if (n.is<language::if_statement>() or n.is<language::while_statement>()) {
      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)
                << std::ends;
        throw parse_error(message.str(), n.children[0]->begin());
      }
    } else if (n.is<language::do_while_statement>()) {
      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)
                << std::ends;
        throw parse_error(message.str(), n.children[1]->begin());
      }
    } else if (n.is<language::unary_not>() or n.is<language::lesser_op>() or n.is<language::lesser_or_eq_op>() or
               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>()) {
      n.m_data_type = ASTNodeDataType::bool_t;
    } else if (n.is<language::unary_minus>()) {
      n.m_data_type = n.children[0]->m_data_type;
      if ((n.children[0]->m_data_type == ASTNodeDataType::unsigned_int_t) or
          (n.children[0]->m_data_type == ASTNodeDataType::bool_t)) {
        n.m_data_type = ASTNodeDataType::int_t;
      } else {
        n.m_data_type = n.children[0]->m_data_type;
      }
    } else if (n.is<language::unary_plusplus>() or n.is<language::unary_minusminus>() or
               n.is<language::post_plusplus>() or n.is<language::post_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 ASTNodeDataType type_0 = n.children[0]->m_data_type;
      const ASTNodeDataType type_1 = n.children[1]->m_data_type;
      if ((type_0 == ASTNodeDataType::bool_t) and (type_1 == ASTNodeDataType::bool_t)) {
        n.m_data_type = ASTNodeDataType::int_t;
      } else {
        n.m_data_type = dataTypePromotion(type_0, type_1);
      }
      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)
                << ") and " << n.children[1]->string() << " (" << dataTypeName(type_1) << ')' << std::ends;
        throw parse_error(message.str(), n.begin());
      }
    } else if (n.is<language::function_evaluation>()) {
      std::cout << rang::fgB::red << "returned type of function evaluation is incorrect" << rang::style::reset << "\n";
      n.m_data_type = ASTNodeDataType::double_t;
    }
  }
}

ASTNodeDataTypeBuilder::ASTNodeDataTypeBuilder(ASTNode& node)
{
  Assert(node.is_root());
  node.m_data_type = ASTNodeDataType::void_t;

  this->_buildNodeDataTypes(node);
  std::cout << " - build node data types\n";
}