#include "Compiler.hpp"

namespace fk
{
  /*explicit*/ Compiler::Compiler()
  {
  }

  /*virtual*/ Compiler::~Compiler()
  {
  }

  std::shared_ptr<Program> Compiler::compile(std::shared_ptr<Node> node)
  {
    auto prog = std::make_shared<Program>();
    compile(node, prog);
    return prog;
  }

  void Compiler::compile(std::shared_ptr<Node> node,
                         std::shared_ptr<Program> prog)
  {
    switch (node->type())
      {
      case NODE_MODULE: {
        for (size_t i=0; i<node->size(); i++)
          {
            compile(node->child(i), prog);
            prog->add(OP_POP);
          }
      } break;

      case NODE_INT: {
        prog->load_const(std::make_shared<Constant>(TYPE_INT,
                                                    stoi(node->repr()),
                                                    node->loc()));
      } break;

      case NODE_FLOAT: {
        prog->load_const(std::make_shared<Constant>(TYPE_FLOAT,
                                                    stof(node->repr()),
                                                    node->loc()));
      } break;

      case NODE_BOOL: {
        prog->load_const(std::make_shared<Constant>(TYPE_BOOL,
                                                    node->repr() == "true",
                                                    node->loc()));
      } break;

      case NODE_STRING: {
        std::string str = node->repr();
        prog->load_const(std::make_shared<Constant>(TYPE_STRING,
                                                    str.substr(1, str.size() - 2),
                                                    node->loc()));
      } break;

      default: {
        std::stringstream ss;
        ss << "cannot compile expression '"
           << (NodeTypeStr[node->type()] + strlen("NODE_"))
           << "'";

        node->loc().error<compile_error>(LOG_ERROR, ss.str());
      } break;
      }
  }

}