VuoModuleCompiler.cc

Go to the documentation of this file.

 
#include "VuoModuleCompiler.hh"
 
#include "VuoCompilerIssue.hh"
#include "VuoFileUtilities.hh"
#include <dlfcn.h>
 
map<string, VuoModuleCompiler::Factory> *VuoModuleCompiler::factories;
 
void VuoModuleCompiler::loadAllModuleCompilers(void)
{
    factories = new map<string, VuoModuleCompiler::Factory>;
 
    vector<string> compilerPaths;
    string vuoFrameworkPath = VuoFileUtilities::getVuoFrameworkPath();
    if (vuoFrameworkPath.empty())
        compilerPaths.push_back(VUO_BUILD_DIR "/lib/libVuoCModuleCompiler.dylib");
    else
    {
        set<VuoFileUtilities::File *> files = VuoFileUtilities::findFilesInDirectory(vuoFrameworkPath + "/Helpers/ModuleCompiler", set<string>{"dylib"});
        for (VuoFileUtilities::File *file : files)
        {
            compilerPaths.push_back(file->path());
            delete file;
        }
    }
 
    for (const string &compilerPath : compilerPaths)
    {
        void *handle = dlopen(compilerPath.c_str(), RTLD_NOW);
        if (! handle)
            VUserLog("Warning: The module compiler '%s' couldn't be loaded : %s", compilerPath.c_str(), dlerror());
    }
}
 
void VuoModuleCompiler::registerModuleCompiler(string type, VuoModuleCompiler::Factory factory)
{
    auto existingFactory = factories->find(type);
    if (existingFactory != factories->end())
    {
        VUserLog("Warning: A VuoModuleCompiler for type '%s' is already registered.  Ignoring the duplicate.", type.c_str());
        return;
    }
 
    (*factories)[type] = factory;
}
 
VuoModuleCompiler * VuoModuleCompiler::newModuleCompiler(const string &type, const string &moduleKey, const string &sourcePath,
                                                         const VuoModuleCompilerSettings &settings,
                                                         std::function<VuoCompilerType *(const string &)> getVuoType)
{
    static once_flag once;
    std::call_once(once, []() {
        loadAllModuleCompilers();
    });
 
    auto factory = factories->find(type);
    if (factory != factories->end())
    {
        VuoModuleCompiler *moduleCompiler = factory->second(moduleKey, sourcePath, settings);
        if (moduleCompiler)
        {
            moduleCompiler->getVuoType = getVuoType;
            return moduleCompiler;
        }
    }
 
    return nullptr;
}
 
VuoModuleCompiler::VuoModuleCompiler(const string &moduleKey, const string &sourcePath, const VuoModuleCompilerSettings &settings) :
    moduleKey(moduleKey),
    sourcePath(sourcePath),
    settings(settings)
{
}
 
VuoModuleCompiler::~VuoModuleCompiler(void)
{
}
 
string VuoModuleCompiler::generateHeader(VuoCompilerIssues *issues)
{
    VuoCompilerIssue issue(VuoCompilerIssue::Error, "generating header", sourcePath, "", "This source file type doesn't use headers.");
    issue.setModuleKey(moduleKey);
    issues->append(issue);
 
    return "";
}
 
VuoCompilerType * VuoModuleCompiler::lookUpVuoType(const string &typeName)
{
    VuoCompilerType *type = getVuoType(typeName);
 
    if (type)
        vuoTypes[typeName] = type;
 
    return type;
}