2.4.4/_vuo_compiler_8hh_source.html

#pragma once


#include "VuoCompilerCompatibility.hh"

#include "VuoFileUtilities.hh"

#include "VuoLinkerInputs.hh"

#include "VuoModuleCompilerResults.hh"


class VuoCompilerComposition;

class VuoCompilerDelegate;

class VuoCompilerEnvironment;

class VuoCompilerIssues;

class VuoCompilerModule;

class VuoCompilerNodeClass;

class VuoCompilerType;

class VuoDirectedAcyclicGraph;

class VuoDirectedAcyclicNetwork;

class VuoModuleCompiler;

class VuoNode;

class VuoNodeSet;

class VuoPublishedPort;

class VuoRunner;

class VuoRunningCompositionLibraries;


class VuoCompiler

{

public:


    enum Optimization

    {

        Optimization_ModuleCaches,

        Optimization_ExistingModuleCaches,

        Optimization_NoModuleCaches

    };


private:

    static set<VuoCompiler *> allCompilers;

    static dispatch_queue_t environmentQueue;

    static map<string, vector< vector<VuoCompilerEnvironment *> > > sharedEnvironments;

    static map<string, map<string, vector<VuoCompilerEnvironment *> > > environmentsForCompositionFamily;

    vector< vector<VuoCompilerEnvironment *> > environments;

    VuoCompilerEnvironment *generatedEnvironment;

    string lastCompositionBaseDir;

    bool shouldLoadAllModules;

    bool hasLoadedAllModules;

    dispatch_queue_t modulesToLoadQueue;

    static map<VuoCompilerEnvironment *, map<string, pair<VuoCompilerModule *, dispatch_group_t>>> invalidatedModulesAwaitingRecompilation;

    static map<VuoCompilerEnvironment *, set<VuoCompilerModule *>> addedModulesAwaitingReification;

    static map<VuoCompilerEnvironment *, set<pair<VuoCompilerModule *, VuoCompilerModule *>>> modifiedModulesAwaitingReification;

    dispatch_group_t modulesLoading;

    dispatch_group_t moduleSourceCompilersExist;

    static dispatch_group_t moduleSourceCompilersExistGlobally;

    dispatch_group_t moduleCacheBuilding;

    VuoDirectedAcyclicNetwork *dependencyGraph;

    VuoDirectedAcyclicNetwork *compositionDependencyGraph;

    static string vuoFrameworkInProgressPath;

    string clangPath;

    string target;

    string requestedTarget;

    bool isVerbose;

    string dependencyOutputPath;

    bool _shouldShowSplashWindow;

    VuoCompilerDelegate *delegate;

    dispatch_queue_t delegateQueue;


    void applyToInstalledEnvironments(std::function<void(VuoCompilerEnvironment *)> doForEnvironment);

    void applyToAllEnvironments(std::function<void(VuoCompilerEnvironment *)> doForEnvironment);

    VuoCompilerEnvironment * environmentAtBroaderScope(VuoCompilerEnvironment *envA, VuoCompilerEnvironment *envB);

    VuoCompilerEnvironment * generatedEnvironmentAtSameScopeAs(VuoCompilerEnvironment *env);


    static void reset(void);

    VuoDirectedAcyclicNetwork * makeDependencyNetwork(const vector< vector<VuoCompilerEnvironment *> > &environments, VuoDirectedAcyclicGraph * (^graphForEnvironment)(VuoCompilerEnvironment *));

    VuoCompilerModule * loadModuleIfNeeded(const string &moduleKey);

    void loadModulesIfNeeded(const set<string> &moduleKeys = set<string>());

    set<dispatch_group_t> loadModulesAndSources(const set<string> &modulesAddedKeys, const set<string> &modulesModifiedKeys, const set<string> &modulesRemovedKeys, const set<string> &sourcesAddedKeys, const set<string> &sourcesModifiedKeys, const set<string> &sourcesRemovedKeys, bool willLoadAllModules, bool shouldRecompileSourcesIfUnchanged, VuoCompilerEnvironment *currentEnvironment, VuoCompilerIssues *issuesForCurrentEnvironment, std::function<void(void)> moduleLoadedCallback, const string &moduleAddedOrModifiedSourceCode);

    void findDependentModulesAndSources(map<VuoCompilerEnvironment *, set<string> > &changedModules, const vector<VuoDirectedAcyclicNetwork *> &searchDependencyGraphs, VuoDirectedAcyclicGraph *currentEnvironmentDependencyGraph, bool includeIndirectDependents, map<VuoCompilerEnvironment *, set<string> > &modulesDepOnChangedModules_this, map<VuoCompilerEnvironment *, set<string> > &modulesDepOnChangedModules_other, map<VuoCompilerEnvironment *, set<string> > &sourcesDepOnChangedModules_this, map<VuoCompilerEnvironment *, set<string> > &sourcesDepOnChangedModules_other);

    void loadedModules(map<string, VuoCompilerModule *> modulesAdded, map<string, pair<VuoCompilerModule *, VuoCompilerModule *> > modulesModified, map<string, VuoCompilerModule *> modulesRemoved, VuoCompilerIssues *issues, void *delegateData, VuoCompilerEnvironment *currentEnvironment);

    bool reifyPortTypes(VuoCompilerNodeClass *nodeClass, std::function<VuoCompilerType *(const string &)> lookUpType);

    void reifyGenericPortTypes(VuoCompilerComposition *composition);

    void reifyGenericPortTypes(VuoNode *node);

    Module * compileCompositionToModule(VuoCompilerComposition *composition, const string &moduleKey, bool isTopLevelComposition, VuoCompilerIssues *issues);

    void linkCompositionToCreateExecutableOrDynamicLibrary(string compiledCompositionPath, string linkedCompositionPath, Optimization optimization, bool isDylib, const vector<string> &rPaths, bool shouldAdHocCodeSign = true);

    set<string> getDependenciesForComposition(const string &compiledCompositionPath);

    set<string> getDependenciesForComposition(const set<string> &directDependencies, bool checkCompatibility);

    static string getLibraryPath(const string &dependency, vector<string> librarySearchPaths);

    void makeModuleCachesAvailable(bool shouldUseExistingBuiltInCaches, bool shouldUseExistingOtherCaches, const string &target = "");

    vector<shared_ptr<VuoModuleCacheRevision>> useCurrentModuleCaches(Optimization optimization);

    void link(string outputPath, const VuoLinkerInputs &linkerInputs, bool isDylib, const vector<string> &rPaths, bool shouldAdHocCodeSign = true, VuoCompilerIssues *issues = nullptr);

    static void adHocCodeSign(string path);

    static Module *readModuleFromBitcode(VuoFileUtilities::File *inputFile, string arch);

    static Module *readModuleFromBitcodeData(char *inputData, size_t inputDataBytes, string arch, set<string> &availableArchs, string &error);

    static void verifyModule(Module *module, VuoCompilerIssues *issues);

    static void writeModuleToBitcode(Module *module, string target, string outputPath, VuoCompilerIssues *issues);

    VuoNode * createPublishedNode(const string &nodeClassName, const vector<VuoPublishedPort *> &publishedPorts);

    static void setTargetForModule(Module *module, string target);

    static string getProcessTarget(void);

    VuoCompilerModule * getModule(const string &moduleKey);

    vector<string> getRunPathSearchPaths(VuoCompilerEnvironment *narrowestScope);

    static vector<string> getCoreVuoDependencies(void);

    static string getRuntimeMainDependency(void);

    static string getRuntimeDependency(void);

    void addModuleSearchPath(string path);

    string getClangPath(void);

    void setClangPath(const string &clangPath);

    string getCompositionStubPath(void);


    friend class VuoCompilerEnvironment;

    friend class VuoLinkerInputs;

    friend class VuoModuleCache;

    friend class TestCompilerDelegate;

    friend class TestCompilingAndLinking;

    friend class TestCompositionExecution;

    friend class TestEventDropping;

    friend class TestModuleLoading;

    friend class TestModuleCaches;

    friend class TestNodes;

    friend class TestSubcompositions;

    friend class TestVuoCompiler;

    friend class TestVuoCompilerBitcodeGenerator;

    friend class TestVuoCompilerCompatibility;

    friend class TestVuoCompilerModule;

    friend class TestVuoIsfModuleCompiler;


public:

    VuoCompiler(const string &compositionPath = "", string target = "");

    ~VuoCompiler(void);

    void setDelegate(VuoCompilerDelegate *delegate);

    void setCompositionPath(const string &compositionPath);

    static Module *readModuleFromBitcode(string inputPath, string arch);

    static void destroyModule(VuoCompilerModule *module);

    static void destroyLlvmModule(Module *module);

    void compileComposition(VuoCompilerComposition *composition, string outputPath, bool isTopLevelComposition, VuoCompilerIssues *issues);

    void compileComposition(string inputPath, string outputPath, bool isTopLevelComposition, VuoCompilerIssues *issues);

    void compileCompositionString(const string &compositionString, string outputPath, bool isTopLevelComposition, VuoCompilerIssues *issues);

    VuoModuleCompiler * createModuleCompiler(const string &moduleKey, const string &inputPath, const map<string, string> &typeNameReplacements = {});

    VuoModuleCompilerResults compileModuleInMemory(const string &inputPath, const string &overriddenSourceCode = "", const map<string, string> &typeNameReplacements = {});

    void compileModule(const string &inputPath, const string &outputPath);

    void generateHeaderForModule(const string &inputPath, const string &outputPath);

    void linkCompositionToCreateExecutable(string inputPath, string outputPath, Optimization optimization, string rPath="", bool shouldAdHocCodeSign = true);

    void linkCompositionToCreateDynamicLibrary(string inputPath, string outputPath, Optimization optimization, bool shouldAdHocCodeSign = true);

    void linkCompositionToCreateDynamicLibraries(string compiledCompositionPath, string linkedCompositionPath, VuoRunningCompositionLibraries *runningCompositionLibraries);

    set<string> getDirectDependenciesForComposition(VuoCompilerComposition *composition);

    set<string> getDependenciesForComposition(VuoCompilerComposition *composition);

    set<string> getDylibDependencyPathsForComposition(VuoCompilerComposition *composition);

    VuoCompilerCompatibility getCompatibilityOfDependencies(const set<string> &dependencies);

    void prepareModuleCaches(void);

    static void generateBuiltInModuleCache(string vuoFrameworkPath, string target, bool onlyGenerateModules);

    string getTarget(void);

    string getArch(void);

    static string getTargetArch(string target);

    void setLoadAllModules(bool shouldLoadAllModules);

    VuoNode * createNode(VuoCompilerNodeClass *nodeClass, string title="", double x=0, double y=0);

    VuoNode * createNode(VuoCompilerNodeClass *nodeClass, VuoNode *nodeToCopyMetadataFrom);

    VuoNode * createPublishedInputNode(vector<VuoPublishedPort *> publishedInputPorts);

    VuoNode * createPublishedOutputNode(vector<VuoPublishedPort *> publishedOutputPorts);

    void installNodeClassAtCompositionLocalScope(const string &sourcePath);

    void uninstallNodeClassAtCompositionLocalScope(const string &sourcePath);

    void overrideInstalledNodeClass(const string &sourcePath, const string &sourceCode);

    void revertOverriddenNodeClass(const string &sourcePath);

    VuoCompilerNodeClass * getNodeClass(const string &nodeClassName);

    map<string, VuoCompilerNodeClass *> getNodeClasses(void);

    VuoCompilerType * getType(const string &typeName);

    map<string, VuoCompilerType *> getTypes(void);

    VuoCompilerModule * getLibraryModule(const string &libraryModuleName);

    map<string, VuoCompilerModule *> getLibraryModules();

    map<string, VuoNodeSet *> getNodeSets();

    VuoNodeSet * getNodeSetForName(const string &name);

    void listNodeClasses(const string &format = "");

    static string getVuoFrameworkPath(void);

    static string getModuleKeyForPath(string path);

    bool isCompositionLocalModule(string moduleKey);

    string getCompositionLocalModulesPath(void);

    string getCompositionLocalPath(void);

    void addHeaderSearchPath(const string &path);

    void addLibrarySearchPath(const string &path);

    void addFrameworkSearchPath(const string &path);

    void setVerbose(bool isVerbose);

    void setShouldPotentiallyShowSplashWindow(bool potentiallyShow);

    void setDependencyOutput(const string &path);

    bool shouldShowSplashWindow();

    string getCompositionLoaderPath(void);

    void print(void);


    static VuoRunner * newSeparateProcessRunnerFromCompositionFile(string compositionFilePath, VuoCompilerIssues *issues);

    static VuoRunner * newSeparateProcessRunnerFromCompositionString(string composition, string processName, string workingDirectory, VuoCompilerIssues *issues);

    static VuoRunner * newCurrentProcessRunnerFromCompositionFile(string compositionFilePath, VuoCompilerIssues *issues);

    static VuoRunner * newCurrentProcessRunnerFromCompositionString(string composition, string workingDirectory, VuoCompilerIssues *issues);


    static llvm::LLVMContext *globalLLVMContext;


private:

    void *p;

#ifdef VUO_PRO

#include "../compiler/pro/VuoCompiler_Pro.hh"

#endif

};