ETISS.h

Go to the documentation of this file.

 
#ifndef ETISS_INCLUDE_ETISS_H_
#define ETISS_INCLUDE_ETISS_H_
 
#include "etiss/config.h"
 
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <type_traits>
 
#include "etiss/CPUCore.h"
#include "etiss/Misc.h"
 
#include "etiss/LibraryInterface.h"
 
namespace etiss
{
 
std::set<std::string> listCPUArchs();
 
std::set<std::string> listJITs();
 
std::set<std::string> listPlugins();
 
void preloadLibraries();
 
std::shared_ptr<JIT> getJIT(std::string name,
                            std::map<std::string, std::string> options = std::map<std::string, std::string>());
 
std::shared_ptr<CPUArch> getCPUArch(std::string name,
                                    std::map<std::string, std::string> options = std::map<std::string, std::string>());
 
std::shared_ptr<Plugin> getPlugin(std::string name,
                                  std::map<std::string, std::string> options = std::map<std::string, std::string>());
 
bool loadLibrary(std::string path, std::string name);
 
void addLibrary(std::shared_ptr<etiss::LibraryInterface> libInterface);
 
std::set<std::string> listLibraries();
 
std::set<std::string> listLibraryPrefixes();
 
void initialize(std::vector<std::string>& args);
std::shared_ptr<etiss::JIT> getDefaultJIT();
 
void shutdown();
 
class Initializer
{
  private:
    template <typename T, typename... lisT>
    void toList(std::vector<std::string> &vec, T t, lisT... args)
    {
        vec.push_back(etiss::toString(t));
        toList(vec, args...);
    }
    void toList(std::vector<std::string> &vec, T t, lisT... args) {…}
 
    inline void toList(std::vector<std::string> &vec) {}
 
    void loadIni(std::list<std::string> *files);
 
    template <typename T, typename... lisT>
    void static_assertFirstParamNotArithmetic(T t, lisT... args)
    {
        static_assert(!std::is_arithmetic<T>::value, "This implementation of the Initializer constructor does not take "
                                                     "integral variables as first variadic parameter");
    }
    void static_assertFirstParamNotArithmetic(T t, lisT... args) {…}
 
    void static_assertFirstParamNotArithmetic(){};
 
  public:
    void loadIniPlugins(std::shared_ptr<etiss::CPUCore> cpu);
    void loadIniJIT(std::shared_ptr<etiss::CPUCore> cpu);
 
    template <typename argvT, typename... lisT>
    Initializer(int argc, argvT **argv, lisT... args_append)
    {
        // const and non const *argv[] are allowed. This assertion is
        // easier than duplicing the constructor.
        static_assert(std::is_same<const char, argvT>::value || std::is_same<char, argvT>::value,
                      "argv must be of type const char or char");
        std::vector<std::string> args;
        for (int i = 1; i < argc; i++)
        {
            args.push_back(std::string(argv[i]));
        }
        toList(args, args_append...);
        initialize(args);
    }
    Initializer(int argc, argvT **argv, lisT... args_append) {…}
 
    Initializer(std::list<std::string> *files, int argc, const char* argv[])
    {
        std::vector<std::string> args;
        for (int i = 1; i < argc; i++)
        {
            args.push_back(std::string(argv[i]));
        }
        loadIni(files);
        initialize(args);
    }
    Initializer(std::list<std::string> *files, int argc, const char* argv[]) {…}
 
    template <typename... listT>
    Initializer(listT... args)
    {
        // At the moment, it doesn't make sense to call this version of the
        // constructor with a number as first arguement (at compile-time!)
        static_assertFirstParamNotArithmetic(args...);
        std::vector<std::string> argv;
        toList(argv, args...);
        initialize(argv);
    }
    Initializer(listT... args) {…}
 
    template <typename argvT, typename... lisT>
    Initializer(std::list<std::string> *files, int argc, argvT **argv, lisT... args_append)
    {
        // const and non const *argv[] are allowed. This assertion is
        // easier than duplicing the constructor.
        static_assert(std::is_same<const char, argvT>::value || std::is_same<char, argvT>::value,
                      "argv must be of type const char or char");
        std::vector<std::string> args;
        for (int i = 1; i < argc; i++)
        {
            args.push_back(std::string(argv[i]));
        }
        toList(args, args_append...);
        loadIni(files);
        initialize(args);
    }
    Initializer(std::list<std::string> *files, int argc, argvT **argv, lisT... args_append) {…}
 
    template <typename... listT>
    Initializer(std::list<std::string> *files, listT... args)
    {
        // At the moment, it doesn't make sense to call this version of the
        // constructor with a number as first arguement (at compile-time!)
        static_assertFirstParamNotArithmetic(args...);
        std::vector<std::string> argv;
        toList(argv, args...);
        loadIni(files);
        initialize(argv);
    }
    Initializer(std::list<std::string> *files, listT... args) {…}
 
    ~Initializer();
};
class Initializer {…};
 
std::string errorMessage(etiss::int32 code, CPUArch *arch = 0);
 
 
void forceInitialization();
 
 
namespace py
{
void init();
void shutdown();
void console();
bool supported();
void runString(std::string s);
void run(std::function<void(void)> func);
void runEXT(std::function<void(void)> func);
} // namespace py
namespace py {…}
 
} // namespace etiss
 
#endif