ETISSInit.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
//
// This file is part of ETISS. It is licensed under the BSD 3-Clause License; you may not use this file except in
// compliance with the License. You should have received a copy of the license along with this project. If not, see the
// LICENSE file.
#include "etiss/ETISS.h"
#include "etiss/config.h"
 
#include <cstdlib>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
 
#include <boost/filesystem.hpp>
 
namespace etiss
{
 
std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems)
{
    std::stringstream ss(s);
    std::string item;
    while (std::getline(ss, item, delim))
    {
        elems.push_back(item);
    }
    return elems;
}
 
} // namespace etiss
 
static bool loadLibraryList(const std::string &path)
{
    std::string list_file = (path + "/list.txt");
    std::ifstream lcfg(list_file.c_str());
    if (!lcfg)
    {
        etiss::log(etiss::ERROR, std::string("Failed to open library list file: ") + list_file);
        return false;
    }
 
    bool ret = false;
    std::string line;
    while (std::getline(lcfg, line))
    {
        if (line.find(',') == std::string::npos)
        { // relative path
            if (etiss::loadLibrary(path, line))
                ret = true;
        }
        else
        { // absolute path
            std::vector<std::string> def;
            etiss::split(line, ',', def);
            if (def.size() == 3)
            {
                if (def[0] == def[2] && def[1].length() > 0 && def[2].length() > 0)
                {
                    if (etiss::loadLibrary(def[1], def[2]))
                        ret = true;
                }
                else
                {
                    etiss::log(etiss::ERROR, "Invalid line in plugin list file", line);
                }
            }
            else
            {
                etiss::log(etiss::ERROR, "Invalid line in plugin list file", line);
            }
        }
    }
    return ret;
}
 
static void findLibs(const boost::filesystem::path &path, std::vector<std::string> &libs)
{
    if (boost::filesystem::exists(path) && boost::filesystem::is_directory(path))
    {
        boost::filesystem::recursive_directory_iterator end_itr;
        for (boost::filesystem::recursive_directory_iterator itr(path); itr != end_itr; ++itr)
        {
            if (boost::filesystem::is_regular_file(itr->status()))
            {
                std::string name(itr->path().filename().string());
                if (name.compare(0, 3, "lib") == 0 && name.compare(name.length() - 3, 3, ".so") == 0)
                {
                    libs.push_back(itr->path().string());
                }
            }
        }
    }
}
 
bool etiss_preload_libraries = false;
 
void etiss::preloadLibraries()
{
 
    // only allow to execute preloadLibraries() ones
    if (etiss_preload_libraries)
    {
        return;
    }
    else
    {
        etiss_preload_libraries = true;
    }
 
    // load libraries
    loadLibraryList(installDir() + "/lib/plugins");
 
    // load libraries from user folder
    std::string etiss_path = etiss::cfg().get<std::string>("etiss_wd", ".");
    std::vector<std::string> lib_dirs{ std::string("ArchImpl"), std::string("JITImpl"), std::string("PluginImpl") };
    if (!etiss_path.empty())
    {
        std::vector<std::string> libs;
        for (auto itr = lib_dirs.begin(); itr != lib_dirs.end(); ++itr)
        {
            findLibs(boost::filesystem::path(etiss_path) / *itr, libs);
        }
        for (auto itr = libs.begin(); itr != libs.end(); ++itr)
        {
            size_t path_end = itr->rfind('/');
            etiss::loadLibrary(itr->substr(0, path_end), itr->substr(path_end + 4, itr->length() - path_end - 7));
        }
    }
}