RuntimeLibrary.cc

Go to the documentation of this file.

#include "casm/system/RuntimeLibrary.hh"
 
#include <boost/algorithm/string.hpp>
#include <boost/filesystem.hpp>
#include <vector>
 
#include "casm/system/Popen.hh"
 
namespace CASM {
 
runtime_lib_compile_error::runtime_lib_compile_error(std::string _filename_base,
                                                     std::string _cmd,
                                                     std::string _result,
                                                     std::string _what)
    : std::runtime_error(_what),
      filename_base(_filename_base),
      cmd(_cmd),
      result(_result) {}
 
void runtime_lib_compile_error::print(std::ostream &sout) const {
  sout << "Error compiling: " << filename_base + ".cc" << std::endl;
  sout << "Attempted: " << cmd << std::endl;
  sout << result << std::endl;
  sout << what() << std::endl;
}
 
runtime_lib_shared_error::runtime_lib_shared_error(std::string _filename_base,
                                                   std::string _cmd,
                                                   std::string _result,
                                                   std::string _what)
    : std::runtime_error(_what),
      filename_base(_filename_base),
      cmd(_cmd),
      result(_result) {}
 
void runtime_lib_shared_error::print(std::ostream &sout) const {
  sout << "Error compiling shared object: " << filename_base + ".so"
       << std::endl;
  sout << "Attempted: " << cmd << std::endl;
  sout << result << std::endl;
  sout << what() << std::endl;
}
 
RuntimeLibrary::RuntimeLibrary(std::string filename_base,
                               std::string compile_options,
                               std::string so_options)
    : m_filename_base(filename_base),
      m_compile_options(compile_options),
      m_so_options(so_options),
      m_handle(nullptr) {
  // If the shared library doesn't exist
  if (!fs::exists(m_filename_base + ".so")) {
    // But the library source code does
    if (fs::exists(m_filename_base + ".cc")) {
      // Compile it
      _compile();
 
    } else {
      throw std::runtime_error(std::string("Error in RuntimeLibrary\n") +
                               "  Could not find '" + m_filename_base +
                               ".so' or '" + m_filename_base + ".cc'");
    }
  }
 
  // If the shared library exists
  if (fs::exists(m_filename_base + ".so")) {
    // Load the library with the Clexulator
    _load();
 
  } else {
    throw std::runtime_error(std::string("Error in Clexulator constructor\n") +
                             "  Did not find '" + m_filename_base + ".so'");
  }
}
 
RuntimeLibrary::~RuntimeLibrary() {
  if (m_handle != nullptr) {
    _close();
  }
}
 
void RuntimeLibrary::_compile() {
  // compile the source code into a dynamic library
  Popen p;
  std::string cmd = m_compile_options + " -o " + m_filename_base + ".o" +
                    " -c " + m_filename_base + ".cc";
  p.popen(cmd);
  if (p.exit_code()) {
    throw runtime_lib_compile_error(
        m_filename_base, cmd, p.gets(),
        "Can not compile " + m_filename_base + ".cc");
  }
 
  cmd = m_so_options + " -o " + m_filename_base + ".so" + " " +
        m_filename_base + ".o";
  p.popen(cmd);
  if (p.exit_code()) {
    throw runtime_lib_shared_error(
        m_filename_base, cmd, p.gets(),
        "Can not compile " + m_filename_base + ".cc");
  }
}
 
void RuntimeLibrary::_load() {
  m_handle = dlopen((m_filename_base + ".so").c_str(), RTLD_NOW);
  if (!m_handle) {
    fprintf(stderr, "dlopen failed: %s\n", dlerror());
    throw std::runtime_error(std::string("Cannot open library: ") +
                             m_filename_base + ".so");
  }
}
 
void RuntimeLibrary::_close() {
  // close
  if (m_handle != nullptr) {
    dlclose(m_handle);
    m_handle = nullptr;
  }
}
 
void RuntimeLibrary::rm() {
  _close();
  // rm
  Popen p;
  p.popen(std::string("rm -f ") + m_filename_base + ".cc " + m_filename_base +
          ".o " + m_filename_base + ".so");
}
 
namespace {
 
std::vector<std::string> _cxx_env() {
  return std::vector<std::string>{"CASM_CXX", "CXX"};
}
 
std::vector<std::string> _cxxflags_env() {
  return std::vector<std::string>{"CASM_CXXFLAGS"};
}
 
std::vector<std::string> _soflags_env() {
  return std::vector<std::string>{"CASM_SOFLAGS"};
}
 
// std::vector<std::string> _casm_env() {
//   return std::vector<std::string> {
//     "CASM_PREFIX"
//   };
// }
//
// std::vector<std::string> _boost_env() {
//   return std::vector<std::string> {
//     "CASM_BOOST_PREFIX"
//   };
// }
 
std::pair<std::string, std::string> _use_env(std::vector<std::string> var,
                                             std::string _default = "") {
  for (const auto &v : var) {
    char *_env = std::getenv(v.c_str());
    if (_env != nullptr) {
      return std::make_pair(std::string(_env), v);
    }
  }
  return std::make_pair(_default, "default");
}
 
fs::path find_executable(std::string name) {
  char *_env = std::getenv("PATH");
  std::vector<std::string> splt;
  boost::split(splt, _env, boost::is_any_of(":"), boost::token_compress_on);
 
  for (const auto &p : splt) {
    fs::path test{fs::path(p) / name};
    if (fs::exists(test)) {
      return test;
    }
  }
  return fs::path();
}
 
fs::path find_include(std::string executable_name, std::string include_name) {
  fs::path loc = find_executable(executable_name);
  if (loc.empty()) {
    return loc;
  }
  fs::path maybe_includedir = loc.parent_path().parent_path() / "include";
  if (fs::exists(maybe_includedir / include_name)) {
    return maybe_includedir / include_name;
  }
  return fs::path();
}
 
fs::path find_includedir(std::string executable_name,
                         std::string include_name) {
  return find_include(executable_name, include_name).parent_path();
}
 
fs::path find_lib(std::string executable_name, std::string lib_name) {
  fs::path loc = find_executable(executable_name);
  if (loc.empty()) {
    return loc;
  }
  fs::path maybe_prefix = loc.parent_path().parent_path();
 
  auto check_dir = [&](fs::path test_libdir) {
    std::vector<std::string> check{"dylib", "so"};
    for (const auto &s : check) {
      auto res = test_libdir / (lib_name + "." + s);
      if (fs::exists(res)) {
        return res;
      }
    }
    return fs::path();
  };
 
  auto check_names = [&](fs::path test_prefix) {
    std::vector<fs::path> check{"lib", "lib64", "lib/x86_64-linux-gnu"};
    for (const auto &s : check) {
      auto res = check_dir(test_prefix / s);
      if (!res.empty()) {
        return res;
      }
    }
    return fs::path();
  };
 
  return check_names(maybe_prefix);
}
 
fs::path find_libdir(std::string executable_name, std::string lib_name) {
  return find_lib(executable_name, lib_name).parent_path();
}
 
}  // namespace
 
std::pair<std::string, std::string> RuntimeLibrary::default_cxx() {
  return _use_env(_cxx_env(), "g++");
}
 
std::pair<std::string, std::string> RuntimeLibrary::default_cxxflags() {
  return _use_env(_cxxflags_env(), "-O3 -Wall -fPIC --std=c++17");
}
 
std::pair<std::string, std::string> RuntimeLibrary::default_soflags() {
  return _use_env(_soflags_env(), "-shared -lboost_system");
}
 
std::pair<fs::path, std::string> RuntimeLibrary::default_casm_includedir() {
  char *_env;
 
  // if CASM_INCLUDEDIR exists
  _env = std::getenv("CASM_INCLUDEDIR");
  if (_env != nullptr) {
    return std::make_pair(std::string(_env), "CASM_INCLUDEDIR");
  }
 
  // if CASM_PREFIX exists
  _env = std::getenv("CASM_PREFIX");
  if (_env != nullptr) {
    return std::make_pair(fs::path(_env) / "include", "CASM_PREFIX");
  }
 
  // relpath from ccasm
  fs::path _default = find_includedir("ccasm", "casm");
  if (!_default.empty()) {
    return std::make_pair(_default, "relpath");
  }
 
  // else
  return std::make_pair(fs::path("/not/found"), "notfound");
}
 
std::pair<fs::path, std::string> RuntimeLibrary::default_casm_libdir() {
  char *_env;
 
  // if CASM_INCLUDEDIR exists
  _env = std::getenv("CASM_LIBDIR");
  if (_env != nullptr) {
    return std::make_pair(std::string(_env), "CASM_LIBDIR");
  }
 
  // if CASM_PREFIX exists
  _env = std::getenv("CASM_PREFIX");
  if (_env != nullptr) {
    return std::make_pair(fs::path(_env) / "lib", "CASM_PREFIX");
  }
 
  // relpath from ccasm
  fs::path _default = find_libdir("ccasm", "libcasm");
  if (!_default.empty()) {
    return std::make_pair(_default, "relpath");
  }
 
  // else
  return std::make_pair(fs::path("/not/found"), "notfound");
}
 
std::pair<fs::path, std::string> RuntimeLibrary::default_boost_includedir() {
  char *_env;
 
  // if CASM_BOOST_INCLUDEDIR exists
  _env = std::getenv("CASM_BOOST_INCLUDEDIR");
  if (_env != nullptr) {
    return std::make_pair(std::string(_env), "CASM_BOOST_INCLUDEDIR");
  }
 
  // if CASM_BOOST_PREFIX exists
  _env = std::getenv("CASM_BOOST_PREFIX");
  if (_env != nullptr) {
    return std::make_pair(fs::path(_env) / "include", "CASM_BOOST_PREFIX");
  }
 
  // relpath from ccasm
  fs::path _default = find_includedir("ccasm", "boost");
  if (!_default.empty()) {
    return std::make_pair(_default, "relpath");
  }
 
  // else
  return std::make_pair(fs::path("/not/found"), "notfound");
}
 
std::pair<fs::path, std::string> RuntimeLibrary::default_boost_libdir() {
  char *_env;
 
  // if CASM_BOOST_INCLUDEDIR exists
  _env = std::getenv("CASM_BOOST_LIBDIR");
  if (_env != nullptr) {
    return std::make_pair(std::string(_env), "CASM_BOOST_LIBDIR");
  }
 
  // if CASM_BOOST_PREFIX exists
  _env = std::getenv("CASM_BOOST_PREFIX");
  if (_env != nullptr) {
    return std::make_pair(fs::path(_env) / "lib", "CASM_BOOST_PREFIX");
  }
 
  // relpath from ccasm
  fs::path _default = find_libdir("ccasm", "libboost_system");
  if (!_default.empty()) {
    return std::make_pair(_default, "relpath");
  }
 
  // else
  return std::make_pair(fs::path("/not/found"), "notfound");
}
 
std::string include_path(const fs::path &dir) {
  if (!dir.empty()) {
    return "-I" + dir.string();
  }
  return "";
};
 
std::string link_path(const fs::path &dir) {
  if (!dir.empty()) {
    return "-L" + dir.string();
  }
  return "";
};
 
}  // namespace CASM