path: root/xmake.cpp

#include "xmake.h"

#include <algorithm>
#include <cstdlib>
#include <filesystem>
#include <iostream>
#include <iterator>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/process.hpp>

#include <fmt/format.h>

#include <libreichwein/file.h>
#include <libreichwein/stringhelper.h>

namespace fs = std::filesystem;
namespace bp = boost::process;
namespace pt = boost::property_tree;
using namespace std::string_literals;

namespace {
 const fs::path XMakefile{"XMakefile"};

 void usage()
 {
  std::cout << "Usage: xmake <target>" << std::endl;
 }

 fs::path get_target(const pt::ptree& ptree) {
  return ptree.get<std::string>("xmake.build.name");
 }
 
 std::vector<fs::path> get_sources(const pt::ptree& ptree) {
  std::vector<fs::path> sources;
  for (const pt::ptree::value_type &v: ptree.get_child("xmake.build")) {
   if (v.first == "source")
    sources.push_back(v.second.data());
  }
  return sources;
 }

 std::vector<fs::path> get_objects(const pt::ptree& ptree) {
  std::vector<fs::path> objects{get_sources(ptree)};
  for (auto &i: objects) {
   i.replace_extension("o");
  }
  return objects;
 }

 // both need to exist
 bool is_older(const fs::path& p, const fs::path& other) {
  auto t_p{fs::last_write_time(p)};
  auto t_other{fs::last_write_time(other)};
  return t_p < t_other;
 }

 // outdated according to dependency file list, non-recursively
 bool is_outdated(const fs::path& p, const std::vector<fs::path> &dependencies) {
  if (!fs::exists(p))
   return true;

  for (const auto& dep: dependencies) {
   if (!exists(dep) || is_older(p, dep)) {
    return true;
   }
  }

  return false;
 }

 std::vector<fs::path> dependencies_of(const fs::path& p, const std::unordered_map<fs::path, std::vector<fs::path>> &dependencies) {
  try {
   return dependencies.at(p);
  } catch (const std::out_of_range& ex) {
   return {}; // empty by default
  }
 }

 // outdated according to dependency tree, recursively
 bool is_outdated(const fs::path& p, const std::unordered_map<fs::path, std::vector<fs::path>> &dependencies) {
  if (!fs::exists(p))
   return true;

  std::vector<fs::path> deps{dependencies_of(p, dependencies)};
  for (const auto& dep: deps) {
   if (!exists(dep) || is_older(p, dep)) {
    return true;
   }

   if (is_outdated(dep, dependencies)) {
    return true;
   }
  }

  return false;
 }

 std::vector<fs::path> deps_from_depfile(const fs::path& path) {
  std::string depfile_content{Reichwein::File::getFile(path)};
  std::vector<std::string> parts {Reichwein::Stringhelper::split(depfile_content, ":\r\n")};
  if (parts.size() >= 2) {
   std::vector<std::string> deps {Reichwein::Stringhelper::split(parts[1], " ")};
   std::vector<fs::path> result;
   std::transform(deps.cbegin(), deps.cend(), std::back_inserter(result), [](const std::string& s){ return s; });
   return result;
  } else {
   throw std::runtime_error("Bad depfile contents: "s + path.string());
  }
 }

 // return contained dependencies
 // input: cpp
 std::vector<fs::path> make_depfile_from(const fs::path& p) {
  fs::path depfile{p};
  depfile.replace_extension("d");

  // check if depfile exists and if it contains up to date info
  if (!fs::exists(depfile) || is_outdated(depfile, deps_from_depfile(depfile))) {
   // actually create depfile
   int result{system(fmt::format("g++ -MM -MF {} -c {}", depfile.string(), p.string()).c_str())};
   if (result != 0) {
    throw std::runtime_error(fmt::format("Depfile {} can't be created", depfile.string()));
   }
  }

  return deps_from_depfile(depfile);
 }

 // type of file can be built from dependencies
 bool is_buildable_by_extension(const fs::path& p) {
  fs::path ext{p.extension()};
  return ext.empty() || ext == ".o";
 }

 // build 1 file
 void build(const fs::path& p, const std::unordered_map<fs::path, std::vector<fs::path>> &dependencies) {
  std::string command;

  if (p.extension() == ".o") {
    // compile
    fs::path cppfile{p};
    cppfile.replace_extension("cpp");
    command = fmt::format("g++ -std=c++17 -c {} -o {}", cppfile.string(), p.string());
  } else {
   // link
   command = "g++";
   std::vector<fs::path> objects{dependencies_of(p, dependencies)};
   for (auto &i: objects) {
    command += fmt::format(" {}", i.string());
   }
   command += " -lfmt -lreichwein";
   command += fmt::format(" -o {}", p.string());
  }

  std::cout << command << std::endl;
  int result{system(command.c_str())};
  if (result != 0) {
   throw std::runtime_error(fmt::format("Error {}", result));
  }
 }

 // build list of files
 // eats up input
 void build(std::unordered_set<fs::path>& buildlist, const std::unordered_map<fs::path, std::vector<fs::path>> &dependencies) {
  std::unordered_set<fs::path> activelist; // currently building
  std::unordered_set<fs::path> donelist; // build done

  if (buildlist.empty()) {
   std::cout << "Everything up to date." << std::endl;
  } else {
   std::cout << "Running commands: " << std::endl;
  }

  while (!buildlist.empty()) {
   // find file which can be built directly since its build dependencies are up to date
   // this holds for either any member of the set (e.g. at begin()), or any of its direct or indirect dependencies
   fs::path current {*buildlist.begin()};

   bool found_outdated{}; // outdated dependencies

   do {
    found_outdated = false;
    std::vector<fs::path> deps{dependencies_of(current, dependencies)};
    for (auto& i: deps) {
     if (activelist.find(i) == activelist.end() && is_outdated(i, dependencies)) {
      found_outdated = true;
      current = i;
      break;
     }
    }
   } while (found_outdated);

   buildlist.erase(current);

   activelist.insert(current);
   // TODO: build in background
   build(current, dependencies);
   activelist.erase(current);

   donelist.insert(current);
  }
 }

 // build everything according to specified configuration
 void build(const pt::ptree& ptree) {
  fs::path target{get_target(ptree)};
  std::vector<fs::path> objects{get_objects(ptree)};
  std::vector<fs::path> sources{get_sources(ptree)};

  std::cout << "Target: " << target << std::endl;

  std::cout << "Sources: " << std::endl;
  for (auto &i: sources) {
   std::cout << "  " << i << std::endl;
  }

  std::cout << "Calculating dependencies..." << std::endl;
  std::unordered_map<fs::path, std::vector<fs::path>> dependencies;
  dependencies.emplace(target, objects);
  for (const auto& p: sources) {
   fs::path p_obj{p};
   p_obj.replace_extension("o");
   std::vector<fs::path> deps {make_depfile_from(p)};
   dependencies.emplace(p_obj, deps);
  }

  // create build list by depth-first search
  std::cout << "Calculating build list..." << std::endl;
  std::unordered_set<fs::path> buildlist;
  std::stack<fs::path> container; // temporary container for search algorithm
  container.push(target);
  while (!container.empty()) {
   fs::path current{container.top()};
   container.pop();

   std::vector<fs::path> deps{dependencies_of(current, dependencies)};
   for (auto &i: deps) {
    container.push(i);
   }

   if (is_outdated(current, dependencies) && is_buildable_by_extension(current)) {
    buildlist.insert(current);
   }
  }

  std::cout << "Build list:" << std::endl;
  for (auto &i: buildlist) {
   std::cout << "  " << i << std::endl;
  }

  build(buildlist, dependencies);
 }

 void clean(const pt::ptree& ptree) {
  std::vector<fs::path> cleanlist{get_objects(ptree)};
  cleanlist.push_back(get_target(ptree));

  std::vector<std::string> commands;
  for (auto &i: cleanlist) {
   if (fs::exists(i)) {
    commands.push_back(fmt::format("rm -f {}", i.string()));
   }
   fs::path dep{i};
   dep.replace_extension("d");
   if (fs::exists(dep)) {
    commands.push_back(fmt::format("rm -f {}", dep.string()));
   }
  }

  std::cout << "Running commands: " << std::endl;
  for (auto &i: commands) {
   std::cout << i << std::endl;
   int result{system(i.c_str())};
   if (result != 0) {
    throw std::runtime_error(fmt::format("Error {}", result));
   }
  }
 }
}

int xmake(int argc, char* argv[])
{
 try {
  pt::ptree ptree;
  pt::read_xml(XMakefile, ptree, pt::xml_parser::no_comments | pt::xml_parser::trim_whitespace);

  std::string action{"default"};

  if (argc == 1) { // default action
  } else if (argc == 2) {
   action = argv[1];
  } else {
   std::cerr << "Invalid arguments." << std::endl;
   usage;
   exit(1);
  }

  if (action == "default"s || action == "build") { // build
   build(ptree);
  } else if (action == "clean") {
   clean(ptree);
  } else if (action == "install") {
   throw std::runtime_error("unimplemented");
  } else if (action == "rebuild") {
   throw std::runtime_error("unimplemented");
  } else if (action == "run") {
   throw std::runtime_error("unimplemented");
  } else {
   std::cerr << "Invalid action: " << action << std::endl;
   usage;
   exit(1);
  }

 } catch (const std::exception& ex) {
  std::cerr << "xmake: " << ex.what() << std::endl;
  return 1;
 }

 return 0;
}