Allowed multiple search directories and libs, refactoring & cmdline opts

Author: Neko-Box-Coder

DefaultYAMLs/DefaultScriptInfo.yaml

@@ -56,12 +56,10 @@ Dependencies:
         # Properties for searching the library binary for the profile
         "g++":
             # The library name to be searched for when linking against the script
-            SearchLibraryName: lib1
+            SearchLibraryNames: ["lib1"]
 
             # The path (relative to the dependency folder) to be searched for the dependency binaries
-            # TODO: Maybe rename this to SearchDirectories
-            # TODO: Make this a list
-            SearchPath: ./build
+            SearchDirectories: ["./build"]
 
     # (Optional) List of setup commands for the supported platforms
     Setup:

DefaultYAMLs/ScriptInfoSchema.json

@@ -147,18 +147,20 @@
                                 "type": "object",
                                 "properties": 
                                 {
-                                    "SearchLibraryName": 
+                                    "SearchLibraryNames": 
                                     {
-                                        "type": "string",
+                                        "type": "array",
+                                        "items": { "type":"string" },
                                         "description": "The library name to be searched for when linking against the script"
                                     },
-                                    "SearchPath": 
+                                    "SearchDirectories": 
                                     {
-                                        "type": "string",
+                                        "type": "array",
+                                        "items": { "type":"string" },
                                         "description": "The path to be searched for the dependency. {BuildType} will be replaced accordingly"
                                     }
                                 },
-                                "required": ["SearchLibraryName", "SearchPath"],
+                                "required": ["SearchLibraryNames", "SearchDirectories"],
                                 "additionalProperties": false,
                                 "description": "Properties for searching the library binary for the profile"
                             }

External/ssLogger

@@ -7,9 +7,22 @@
 
 namespace runcpp2 
 {
+    bool CompileScript( const std::string& scriptPath, 
+                        const ScriptInfo& scriptInfo,
+                        const CompilerProfile& profile,
+                        std::string& outScriptObjectFilePath);
+    
+    bool LinkScript(    const std::string& scriptPath, 
+                        const ScriptInfo& scriptInfo,
+                        const CompilerProfile& profile,
+                        const std::string& scriptObjectFilePath,
+                        const std::vector<std::string>& copiedDependenciesBinariesNames);
+    
+    
     bool CompileAndLinkScript(  const std::string& scriptPath, 
                                 const ScriptInfo& scriptInfo,
-                                const CompilerProfile& profile);
+                                const CompilerProfile& profile,
+                                const std::vector<std::string>& copiedDependenciesBinariesNames);
 }
 
 #endif

Include/runcpp2/CompilingLinking.hpp

@@ -9,8 +9,8 @@ namespace runcpp2
     class DependencySearchProperty
     {
         public:
-            std::string SearchLibraryName;
-            std::string SearchPath;
+            std::vector<std::string> SearchLibraryNames;
+            std::vector<std::string> SearchDirectories;
 
             bool ParseYAML_Node(YAML::Node& node);
             std::string ToString(std::string indentation) const;

Include/runcpp2/Data/DependencySearchProperty.hpp

@@ -3,7 +3,9 @@
 
 #include "runcpp2/Data/DependencyInfo.hpp"
 #include "runcpp2/Data/ScriptInfo.hpp"
+#include "runcpp2/Data/CompilerProfile.hpp"
 #include <vector>
+
 namespace runcpp2
 {
     bool IsDependencyAvailableForThisPlatform(const DependencyInfo& dependency);
@@ -32,6 +34,16 @@ namespace runcpp2
                                     bool resetDependencies,
                                     std::vector<std::string>& outDependenciesLocalCopiesPaths,
                                     std::vector<std::string>& outDependenciesSourcePaths);
+
+    bool GetDependencyBinariesExtensionsToCopy( const DependencyInfo& dependencyInfo,
+                                                const CompilerProfile& profile,
+                                                std::vector<std::string>& outExtensionsToCopy);
+
+    bool CopyDependenciesBinaries(  const std::string& scriptPath, 
+                                    const ScriptInfo& scriptInfo,
+                                    const std::vector<std::string>& dependenciesCopiesPaths,
+                                    const CompilerProfile& profile,
+                                    std::vector<std::string>& outCopiedBinariesNames);
 }
 
 #endif

Include/runcpp2/DependenciesSetupHelper.hpp

@@ -9,19 +9,22 @@
 
 namespace runcpp2
 {
-    bool CreateRuncpp2ScriptDirectory(const std::string& scriptPath);
+    enum class CmdOptions
+    {
+        NONE,
+        SETUP,
+        COUNT
+    };
 
-    bool CopyDependenciesBinaries(  const std::string& scriptPath, 
-                                    const ScriptInfo& scriptInfo,
-                                    const std::vector<std::string>& dependenciesCopiesPaths,
-                                    const CompilerProfile& profile);
+    bool CreateRuncpp2ScriptDirectory(const std::string& scriptPath);
 
     //--------------------------------------------
     //Running
     //--------------------------------------------
     bool RunScript( const std::string& scriptPath, 
                     const std::vector<CompilerProfile>& profiles,
                     const std::string& configPreferredProfile,
+                    const std::unordered_map<CmdOptions, std::string> currentOptions,
                     const std::vector<std::string>& runArgs);
 
 

Include/runcpp2/runcpp2.hpp

@@ -1,6 +1,6 @@
 ## 🏃‍♂️ runcpp2
 
-A cross-platform tool that can let you run any cpp file as a script, just like python!
+A cross-platform tool that can let you run any c++ file as a script, just like python!
 
 Run c++ files anytime, anywhere.
 

README.md

@@ -6,9 +6,11 @@
 #include "runcpp2/StringUtil.hpp"
 #include "ssLogger/ssLog.hpp"
 
-bool runcpp2::CompileAndLinkScript( const std::string& scriptPath, 
-                                    const ScriptInfo& scriptInfo,
-                                    const CompilerProfile& profile)
+
+bool runcpp2::CompileScript(const std::string& scriptPath, 
+                            const ScriptInfo& scriptInfo,
+                            const CompilerProfile& profile,
+                            std::string& outScriptObjectFilePath)
 {
     std::string scriptDirectory = ghc::filesystem::path(scriptPath).parent_path().string();
     std::string scriptName = ghc::filesystem::path(scriptPath).stem().string();
@@ -115,10 +117,10 @@ bool runcpp2::CompileAndLinkScript( const std::string& scriptPath,
         return false;
     }
 
-    std::string objectFileName = Internal::ProcessPath( runcpp2ScriptDir + "/" + 
+    std::string objectFilePath = Internal::ProcessPath( runcpp2ScriptDir + "/" + 
                                                         scriptName + "." + objectFileExt);
 
-    compileCommand.replace(foundIndex, objectFileSubstitution.size(), objectFileName);
+    compileCommand.replace(foundIndex, objectFileSubstitution.size(), objectFilePath);
 
     //Compile the script
     ssLOG_INFO("running compile command: " << compileCommand);
@@ -172,11 +174,24 @@ bool runcpp2::CompileAndLinkScript( const std::string& scriptPath,
         return false;
     }
 
+    outScriptObjectFilePath = objectFilePath;
+    return true;
+}
+
+bool runcpp2::LinkScript(   const std::string& scriptPath, 
+                            const ScriptInfo& scriptInfo,
+                            const CompilerProfile& profile,
+                            const std::string& scriptObjectFilePath,
+                            const std::vector<std::string>& copiedDependenciesBinariesNames)
+{
+    std::string scriptName = ghc::filesystem::path(scriptPath).stem().string();
+    
     //Link the script to the dependencies
     std::string linkCommand = profile.Linker.Executable + " ";
     std::string currentOutputPart = profile.Linker.LinkerArgs.OutputPart;
     const std::string linkFlagsSubstitution = "{LinkFlags}";
     const std::string outputFileSubstitution = "{OutputFile}";
+    const std::string objectFileSubstitution = "{ObjectFile}";
 
     std::string linkFlags = profile.Linker.DefaultLinkFlags;
     std::string outputName = scriptName;
@@ -208,7 +223,7 @@ bool runcpp2::CompileAndLinkScript( const std::string& scriptPath,
     }
 
     //Replace for {LinkFlags} for output part
-    foundIndex = currentOutputPart.find(linkFlagsSubstitution);
+    std::size_t foundIndex = currentOutputPart.find(linkFlagsSubstitution);
     if(foundIndex == std::string::npos)
     {
         ssLOG_ERROR("'" + linkFlagsSubstitution + "' missing in LinkerArgs");
@@ -233,7 +248,7 @@ bool runcpp2::CompileAndLinkScript( const std::string& scriptPath,
         return false;
     }
 
-    currentOutputPart.replace(foundIndex, objectFileSubstitution.size(), objectFileName);
+    currentOutputPart.replace(foundIndex, objectFileSubstitution.size(), scriptObjectFilePath);
     Internal::Trim(currentOutputPart);
     linkCommand += currentOutputPart;
 
@@ -248,27 +263,23 @@ bool runcpp2::CompileAndLinkScript( const std::string& scriptPath,
         return false;
     }
 
-    for(int i = 0; i < scriptInfo.Dependencies.size(); ++i)
+    for(int i = 0; i < copiedDependenciesBinariesNames.size(); ++i)
     {
-        if(scriptInfo.Dependencies.at(i).LibraryType == DependencyLibraryType::HEADER)
-            continue;
-        
-        std::string dependencyName = scriptInfo .Dependencies
-                                                .at(i)
-                                                .SearchProperties
-                                                .at(profile.Name)
-                                                .SearchLibraryName;
-        
         std::string currentDependencyPart = dependencyPart;
-        currentDependencyPart.replace(foundIndex, dependencySubstitution.size(), dependencyName);
+        currentDependencyPart.replace(  foundIndex, 
+                                        dependencySubstitution.size(), 
+                                        copiedDependenciesBinariesNames[i]);
+        
         linkCommand += " " + currentDependencyPart;
     }
 
+    std::string scriptDirectory = ghc::filesystem::path(scriptPath).parent_path().string();
+    std::string runcpp2ScriptDir = Internal::ProcessPath(scriptDirectory + "/.runcpp2");
     linkCommand = "cd " + runcpp2ScriptDir + " && " + linkCommand;
 
     //Do Linking
     System2CommandInfo linkCommandInfo;
-    result = System2Run(linkCommand.c_str(), &linkCommandInfo);
+    SYSTEM2_RESULT result = System2Run(linkCommand.c_str(), &linkCommandInfo);
 
     ssLOG_INFO("running link command: " << linkCommand);
 
@@ -278,20 +289,21 @@ bool runcpp2::CompileAndLinkScript( const std::string& scriptPath,
         return false;
     }
 
-    output.clear();
+    std::string output;
+    
+    //output.clear();
     do
     {
         uint32_t byteRead = 0;
-        
-        output.resize(output.size() + 4096);
+        char tempBuffer[4096];
 
         result = System2ReadFromOutput( &linkCommandInfo, 
-                                        output.data() + output.size() - 4096, 
+                                        tempBuffer, 
                                         4096 - 1, 
                                         &byteRead);
 
-        output.resize(output.size() - 4096 + byteRead + 1);
-        output.back() = '\0';
+        tempBuffer[byteRead] = '\0';
+        output += tempBuffer;
     }
     while(result == SYSTEM2_RESULT_READ_NOT_FINISHED);
 
@@ -303,7 +315,7 @@ bool runcpp2::CompileAndLinkScript( const std::string& scriptPath,
 
     ssLOG_DEBUG("Link Output: \n" << output.data());
 
-    statusCode = 0;
+    int statusCode = 0;
     result = System2GetCommandReturnValueSync(&linkCommandInfo, &statusCode);
 
     if(result != SYSTEM2_RESULT_SUCCESS)
@@ -318,6 +330,32 @@ bool runcpp2::CompileAndLinkScript( const std::string& scriptPath,
         return false;
     }
 
+    return true;
+}
+
+
+bool runcpp2::CompileAndLinkScript( const std::string& scriptPath, 
+                                    const ScriptInfo& scriptInfo,
+                                    const CompilerProfile& profile,
+                                    const std::vector<std::string>& copiedDependenciesBinariesNames)
+{
+    std::string scriptObjectFilePath;
+
+    if(!CompileScript(scriptPath, scriptInfo, profile, scriptObjectFilePath))
+    {
+        ssLOG_ERROR("CompileScript failed");
+        return false;
+    }
+    
+    if(!LinkScript( scriptPath, 
+                    scriptInfo,
+                    profile,
+                    scriptObjectFilePath,
+                    copiedDependenciesBinariesNames))
+    {
+        ssLOG_ERROR("LinkScript failed");
+        return false;
+    }
 
     return true;
 }

Src/runcpp2/CompilingLinking.cpp

@@ -17,8 +17,8 @@ namespace runcpp2
 
         std::vector<Internal::NodeRequirement> requirements =
         {
-            Internal::NodeRequirement("SearchLibraryName", YAML::NodeType::Scalar, true, false),
-            Internal::NodeRequirement("SearchPath", YAML::NodeType::Scalar, true, false)
+            Internal::NodeRequirement("SearchLibraryNames", YAML::NodeType::Sequence, true, false),
+            Internal::NodeRequirement("SearchDirectories", YAML::NodeType::Sequence, true, false)
         };
 
         if(!Internal::CheckNodeRequirements(node, requirements))
@@ -27,8 +27,12 @@ namespace runcpp2
             return false;
         }
 
-        SearchLibraryName = node["SearchLibraryName"].as<std::string>();
-        SearchPath = node["SearchPath"].as<std::string>();
+        for(int i = 0; i < node["SearchLibraryNames"].size(); ++i)
+            SearchLibraryNames.push_back(node["SearchLibraryNames"][i].as<std::string>());
+        
+        for(int i = 0; i < node["SearchDirectories"].size(); ++i)
+            SearchDirectories.push_back(node["SearchDirectories"][i].as<std::string>());
+        
         return true;
 
         INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(false);
@@ -37,8 +41,15 @@ namespace runcpp2
     std::string DependencySearchProperty::ToString(std::string indentation) const
     {
         std::string out;
-        out += indentation + "SearchLibraryName: " + SearchLibraryName + "\n";
-        out += indentation + "SearchPath: " + SearchPath + "\n";
+        out += indentation + "SearchLibraryName: \n";
+        
+        for(int i = 0; i < SearchLibraryNames.size(); ++i)
+            out += indentation + "-   " + SearchLibraryNames[i] + "\n";
+        
+        out += indentation + "SearchDirectories: \n";
+        
+        for(int i = 0; i < SearchDirectories.size(); ++i)
+            out += indentation + "-   " + SearchDirectories[i] + "\n";
 
         return out;
     }