const std::string& scriptPath,

const std::vector<std::string>& runArgs,

int& returnStatus)

{

INTERNAL_RUNCPP2_SAFE_START();

ssLOG_FUNC_INFO();

std::vector<const char*> args;

for(size_t i = 0; i < runArgs.size(); ++i)

args.push_back(runArgs[i].c_str());

System2CommandInfo runCommandInfo = {};

SYSTEM2_RESULT result = System2RunSubprocess( executable.c_str(),

args.data(),

args.size(),

&runCommandInfo);

ssLOG_INFO("Running: " << executable.string());

for(size_t i = 0; i < runArgs.size(); ++i)

ssLOG_INFO("- " << runArgs[i]);

if(result != SYSTEM2_RESULT_SUCCESS)

{

ssLOG_ERROR("System2Run failed with result: " << result);

return false;

}

result = System2GetCommandReturnValueSync(&runCommandInfo, &returnStatus, false);

if(result != SYSTEM2_RESULT_SUCCESS)

{

ssLOG_ERROR("System2GetCommandReturnValueSync failed with result: " << result);

return false;

}

return true;

INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(false);

const ghc::filesystem::path& compiledSharedLibPath,

const std::vector<std::string>& runArgs,

int& returnStatus)

{

INTERNAL_RUNCPP2_SAFE_START();

ssLOG_FUNC_INFO();

std::error_code _;

if(!ghc::filesystem::exists(compiledSharedLibPath, _))

{

ssLOG_ERROR("Failed to find shared library: " << compiledSharedLibPath.string());

return false;

}

//Load it

std::unique_ptr<dylib> sharedLib;

try

{

ssLOG_INFO("Trying to run shared library: " << compiledSharedLibPath.string());

//TODO: We might want to use unicode instead for the path

#if defined(_WIN32)

std::string sharedLibDir = compiledSharedLibPath.parent_path().string();

if(SetDllDirectoryA(sharedLibDir.c_str()) == FALSE)

{

std::string lastError = runcpp2::GetWindowsError();

ssLOG_ERROR("Failed to set DLL directory: " << lastError);

return false;

}

#endif

sharedLib = std::unique_ptr<dylib>(new dylib( compiledSharedLibPath.string(),

dylib::no_filename_decorations));

}

catch(std::exception& e)

{

ssLOG_ERROR("Failed to load shared library " << compiledSharedLibPath.string() <<

" with exception: ");

ssLOG_ERROR(e.what());

return false;

}

//Get main as entry point

if(sharedLib->has_symbol("main") == false)

{

ssLOG_ERROR("The shared library does not have a main function");

return false;

}

int (*scriptFullMain)(int, const char**) = nullptr;

int (*scriptMain)() = nullptr;

try

{

scriptFullMain = sharedLib->get_function<int(int, const char**)>("main");

}

catch(const dylib::exception& ex)

{

ssLOG_DEBUG("Failed to get full main function from shared library: " << ex.what());

}

catch(...)

{

ssLOG_ERROR("Failed to get entry point function");

return false;

}

if(scriptFullMain == nullptr)

{

try

{

scriptMain = sharedLib->get_function<int()>("_main");

}

catch(const dylib::exception& ex)

{

ssLOG_DEBUG("Failed to get main function from shared library: " << ex.what());

}

catch(...)

{

ssLOG_ERROR("Failed to get entry point function");

return false;

}

}

if(scriptMain == nullptr && scriptFullMain == nullptr)

{

ssLOG_ERROR("Failed to load function");

return false;

}

//Run the entry point

try

{

if(scriptFullMain != nullptr)

{

std::vector<const char*> runArgsCStr(runArgs.size());

for(size_t i = 0; i < runArgs.size(); ++i)

runArgsCStr.at(i) = &runArgs.at(i).at(0);

returnStatus = scriptFullMain(runArgsCStr.size(), runArgsCStr.data());

}

else if(scriptMain != nullptr)

returnStatus = scriptMain();

}

catch(std::exception& e)

{

ssLOG_ERROR("Failed to run script main with exception: " << e.what());

return true;

}

catch(...)

{

ssLOG_ERROR("Unknown exception caught");

return true;

}

return true;

INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(false);

const std::vector<std::string>& filePaths,

std::vector<std::string>& outCopiedPaths)

{

ssLOG_FUNC_INFO();

INTERNAL_RUNCPP2_SAFE_START();

std::error_code e;

for (const std::string& srcPath : filePaths)

{

ghc::filesystem::path destPath = destDir / ghc::filesystem::path(srcPath).filename();

if(ghc::filesystem::exists(srcPath, e))

{

ghc::filesystem::copy(srcPath,

destPath,

ghc::filesystem::copy_options::update_existing,

e);

if(e)

{

ssLOG_ERROR("Failed to copy file from " << srcPath <<

" to " << destPath.string());

ssLOG_ERROR("Error: " << e.message());

return false;

}

ssLOG_INFO("Copied from " << srcPath << " to " << destPath.string());

outCopiedPaths.push_back(ProcessPath(destPath));

}

else

{

ssLOG_ERROR("File to copy not found: " << srcPath);

return false;

}

}

return true;

INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(false);

const Data::Profile& profile,

const std::string& workingDir,

const std::string& commandType)

{

ssLOG_FUNC_INFO();

INTERNAL_RUNCPP2_SAFE_START();

if(commands != nullptr)

{

const std::vector<std::string>* commandSteps =

runcpp2::GetValueFromProfileMap(profile, commands->CommandSteps);

if(commandSteps != nullptr)

{

for(const std::string& cmd : *commandSteps)

{

std::string output;

int returnCode = 0;

if(!runcpp2::RunCommand(cmd, true, workingDir, output, returnCode))

{

ssLOG_ERROR(commandType << " command failed: " << cmd <<

" with return code " << returnCode);

ssLOG_ERROR("Was trying to run: " << cmd);

ssLOG_ERROR("Output: \n" << output);

return PipelineResult::UNEXPECTED_FAILURE;

}

ssLOG_INFO(commandType << " command ran: \n" << cmd);

ssLOG_INFO(commandType << " command output: \n" << output);

}

}

}

return PipelineResult::SUCCESS;

INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(PipelineResult::UNEXPECTED_FAILURE);

const std::vector<Data::Profile>& profiles,

ghc::filesystem::path& outAbsoluteScriptPath,

ghc::filesystem::path& outScriptDirectory,

std::string& outScriptName)

{

ssLOG_FUNC_INFO();

INTERNAL_RUNCPP2_SAFE_START();

if(profiles.empty())

{

ssLOG_ERROR("No compiler profiles found");

return PipelineResult::EMPTY_PROFILES;

}

//Check if input file exists

std::error_code _;

if(!ghc::filesystem::exists(scriptPath, _))

{

ssLOG_ERROR("File does not exist: " << scriptPath);

return PipelineResult::INVALID_SCRIPT_PATH;

}

if(ghc::filesystem::is_directory(scriptPath, _))

{

ssLOG_ERROR("The input file must not be a directory: " << scriptPath);

return PipelineResult::INVALID_SCRIPT_PATH;

}

outAbsoluteScriptPath = ghc::filesystem::absolute(ghc::filesystem::canonical(scriptPath, _));

outScriptDirectory = outAbsoluteScriptPath.parent_path();

outScriptName = outAbsoluteScriptPath.stem().string();

ssLOG_DEBUG("scriptPath: " << scriptPath);

ssLOG_DEBUG("absoluteScriptPath: " << outAbsoluteScriptPath.string());

ssLOG_DEBUG("scriptDirectory: " << outScriptDirectory.string());

ssLOG_DEBUG("scriptName: " << outScriptName);

ssLOG_DEBUG("is_directory: " << ghc::filesystem::is_directory(outScriptDirectory));

return PipelineResult::SUCCESS;

INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(PipelineResult::UNEXPECTED_FAILURE);

const ghc::filesystem::path& scriptDirectory,

const std::string& scriptName,

const bool buildExecutable,

Data::ScriptInfo& outScriptInfo)

{

ssLOG_FUNC_INFO();

INTERNAL_RUNCPP2_SAFE_START();

//Check if there's script info as yaml file instead

std::error_code e;

std::string parsableInfo;

std::ifstream inputFile;

ghc::filesystem::path dedicatedYamlLoc =

scriptDirectory / ghc::filesystem::path(scriptName + ".yaml");

if(ghc::filesystem::exists(dedicatedYamlLoc, e))

{

//Record write time for yaml file for watch option

outScriptInfo.LastWriteTime = ghc::filesystem::last_write_time(dedicatedYamlLoc, e);

if(e)

{

ssLOG_ERROR("Failed to get last write time for: " << dedicatedYamlLoc);

return PipelineResult::INVALID_SCRIPT_INFO;

}

inputFile.open(dedicatedYamlLoc);

std::stringstream buffer;

buffer << inputFile.rdbuf();

parsableInfo = buffer.str();

}

else

{

//Record write time for script file for watch option

outScriptInfo.LastWriteTime = ghc::filesystem::last_write_time(absoluteScriptPath, e);

if(e)

{

ssLOG_ERROR("Failed to get last write time for: " << absoluteScriptPath);

return PipelineResult::INVALID_SCRIPT_INFO;

}

inputFile.open(absoluteScriptPath);

if (!inputFile)

{

ssLOG_ERROR("Failed to open file: " << absoluteScriptPath);

return PipelineResult::INVALID_SCRIPT_PATH;

}

std::stringstream buffer;

buffer << inputFile.rdbuf();

std::string source(buffer.str());

if(!GetParsableInfo(source, parsableInfo))

{

ssLOG_ERROR("An error has been encountered when parsing info: " << absoluteScriptPath);

return PipelineResult::INVALID_SCRIPT_INFO;

}

}

//Try to parse the runcpp2 info

if(!ParseScriptInfo(parsableInfo, outScriptInfo))

{

ssLOG_ERROR("Failed to parse info");

ssLOG_ERROR("Content trying to parse: " << "\n" << parsableInfo);

return PipelineResult::INVALID_SCRIPT_INFO;

}

if(!parsableInfo.empty())

{

ssLOG_DEBUG("Parsed script info YAML:");

ssLOG_DEBUG("\n" << outScriptInfo.ToString(""));

}

//Replace build type with internal executable type to trigger recompiling when switching to

//have or not have "--executable" option

if(outScriptInfo.CurrentBuildType == Data::BuildType::EXECUTABLE)

{

outScriptInfo.CurrentBuildType = buildExecutable ?

Data::BuildType::INTERNAL_EXECUTABLE_EXECUTABLE :

Data::BuildType::INTERNAL_EXECUTABLE_SHARED;

}

return PipelineResult::SUCCESS;

INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(PipelineResult::UNEXPECTED_FAILURE);

const Data::Profile& profile,

const ghc::filesystem::path& scriptDirectory,

const ghc::filesystem::path& buildDir,

const ghc::filesystem::path& absoluteScriptPath,

BuildsManager& buildsManager)

{

ssLOG_FUNC_INFO();

INTERNAL_RUNCPP2_SAFE_START();

const Data::ProfilesCommands* cleanupCommands =

runcpp2::GetValueFromPlatformMap(scriptInfo.Cleanup);

if(cleanupCommands != nullptr)

{

const std::vector<std::string>* commands =

runcpp2::GetValueFromProfileMap(profile, cleanupCommands->CommandSteps);

if(commands != nullptr)

{

for(const std::string& cmd : *commands)

{

std::string output;

int returnCode = 0;

if(!runcpp2::RunCommand(cmd, true, scriptDirectory, output, returnCode))

{

ssLOG_ERROR("Cleanup command failed: " << cmd <<

" with return code " << returnCode);

ssLOG_ERROR("Output: \n" << output);

return PipelineResult::UNEXPECTED_FAILURE;

}

ssLOG_INFO("Cleanup command ran: \n" << cmd);

ssLOG_INFO("Cleanup command output: \n" << output);

}

}

}

//Remove build directory

std::error_code e;

if(!ghc::filesystem::remove_all(buildDir, e))

{

ssLOG_ERROR("Failed to remove build directory: " << buildDir);

return PipelineResult::UNEXPECTED_FAILURE;

}

if(!buildsManager.RemoveBuildMapping(absoluteScriptPath))

{

ssLOG_ERROR("Failed to remove build mapping");

return PipelineResult::UNEXPECTED_FAILURE;

}

if(!buildsManager.SaveBuildsMappings())

{

ssLOG_ERROR("Failed to save build mappings");

return PipelineResult::UNEXPECTED_FAILURE;

}

return PipelineResult::SUCCESS;

INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(PipelineResult::UNEXPECTED_FAILURE);

const ghc::filesystem::path& absoluteScriptPath,

bool useLocalBuildDir,

BuildsManager& outBuildsManager,

ghc::filesystem::path& outBuildDir,

IncludeManager& outIncludeManager)

{

ssLOG_FUNC_INFO();

INTERNAL_RUNCPP2_SAFE_START();

//Create build directory

ghc::filesystem::path buildDirPath = useLocalBuildDir ?

ghc::filesystem::current_path() / ".runcpp2" :

configDir;

//Create a class that manages build folder

outBuildsManager = BuildsManager(buildDirPath);

if(!outBuildsManager.Initialize())

{

ssLOG_FATAL("Failed to initialize builds manager");

return PipelineResult::INVALID_BUILD_DIR;

}

bool createdBuildDir = false;

bool writeMapping = false;

if(!outBuildsManager.HasBuildMapping(absoluteScriptPath))

writeMapping = true;

if(outBuildsManager.GetBuildMapping(absoluteScriptPath, outBuildDir))

{

if(writeMapping && !outBuildsManager.SaveBuildsMappings())

ssLOG_FATAL("Failed to save builds mappings");

else

createdBuildDir = true;

}

if(!createdBuildDir)

{

ssLOG_FATAL("Failed to create local build directory for: " << absoluteScriptPath);

return PipelineResult::INVALID_BUILD_DIR;

}

outIncludeManager = IncludeManager();

if(!outIncludeManager.Initialize(outBuildDir))

{

ssLOG_FATAL("Failed to initialize include manager");

return PipelineResult::INVALID_BUILD_DIR;

}

return PipelineResult::SUCCESS;

INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(PipelineResult::UNEXPECTED_FAILURE);

const ghc::filesystem::path& scriptPath,

const ghc::filesystem::path& buildDir)

{

ssLOG_FUNC_INFO();

INTERNAL_RUNCPP2_SAFE_START();

//Resolve all the script info imports first before evaluating it

if(!ResolveImports(scriptInfo, scriptPath, buildDir))

{

ssLOG_ERROR("Failed to resolve imports");

return PipelineResult::UNEXPECTED_FAILURE;

}

return PipelineResult::SUCCESS;

INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(PipelineResult::UNEXPECTED_FAILURE);

const Data::ScriptInfo& scriptInfo,

const Data::Profile& profile,

const ghc::filesystem::path& absoluteScriptPath,

const Data::ScriptInfo* lastScriptInfo,

const int maxThreads,

bool& outAllRecompileNeeded,

bool& outRelinkNeeded,

std::vector<std::string>& outChangedDependencies)

{

ssLOG_FUNC_INFO();

INTERNAL_RUNCPP2_SAFE_START();

const ghc::filesystem::path scriptDirectory = absoluteScriptPath.parent_path();

ghc::filesystem::path lastScriptInfoFilePath = buildDir / "LastScriptInfo.yaml";

Data::ScriptInfo lastScriptInfoFromDisk;

std::error_code e;

//Run Setup commands if we don't have previous build

if(!ghc::filesystem::exists(lastScriptInfoFilePath, e))

{

const Data::ProfilesCommands* setupCommands =

runcpp2::GetValueFromPlatformMap(scriptInfo.Setup);

if(setupCommands != nullptr)

{

PipelineResult result = RunProfileCommands( setupCommands,

profile,

scriptDirectory.string(),

"Setup");

if(result != PipelineResult::SUCCESS)

return result;

}

}

//Compare script info in memory or from disk

const Data::ScriptInfo* lastInfo = lastScriptInfo;

if(lastInfo == nullptr && ghc::filesystem::exists(lastScriptInfoFilePath, e))

{

ssLOG_DEBUG("Last script info file exists: " << lastScriptInfoFilePath);

std::ifstream lastScriptInfoFile;

lastScriptInfoFile.open(lastScriptInfoFilePath);

std::stringstream lastScriptInfoBuffer;

lastScriptInfoBuffer << lastScriptInfoFile.rdbuf();

int currentThreadTargetLevel = ssLOG_GET_CURRENT_THREAD_TARGET_LEVEL();

ssLOG_SET_CURRENT_THREAD_TARGET_LEVEL(ssLOG_LEVEL_NONE);

do

{

if(!ParseScriptInfo(lastScriptInfoBuffer.str(), lastScriptInfoFromDisk))

break;

//Resolve imports for last script info

runcpp2::PipelineResult result = ResolveScriptImports( lastScriptInfoFromDisk,

absoluteScriptPath,

buildDir);

if(result != PipelineResult::SUCCESS)

break;

lastInfo = &lastScriptInfoFromDisk;

}

while(false);

ssLOG_SET_CURRENT_THREAD_TARGET_LEVEL(currentThreadTargetLevel);

if(lastInfo != nullptr)

ssLOG_INFO("Last script info parsed");

else

ssLOG_INFO("Failed to parse last script info");

}

//Check if the cached script info has changed

if(lastInfo != nullptr)

{

//Relink if there are any changes to the link flags

{

const Data::ProfilesFlagsOverride* lastLinkFlags =

runcpp2::GetValueFromPlatformMap(lastInfo->OverrideLinkFlags);

const Data::ProfilesFlagsOverride* currentLinkFlags =

runcpp2::GetValueFromPlatformMap(scriptInfo.OverrideLinkFlags);

outRelinkNeeded = (lastLinkFlags == nullptr) != (currentLinkFlags == nullptr) ||

(

lastLinkFlags != nullptr &&

currentLinkFlags != nullptr &&

!lastLinkFlags->Equals(*currentLinkFlags)

);

}

outAllRecompileNeeded = scriptInfo.IsAllCompiledCacheInvalidated(*lastInfo);

//Check dependencies

for(int i = 0; i < scriptInfo.Dependencies.size(); ++i)

{

if( lastInfo->Dependencies.size() <= i ||

!scriptInfo.Dependencies.at(i).Equals(lastInfo->Dependencies.at(i)))

{

outChangedDependencies.push_back(scriptInfo.Dependencies.at(i).Name);

}

}

if(outAllRecompileNeeded || outRelinkNeeded)

{

ssLOG_INFO( "Last script info is out of date, " <<

(outAllRecompileNeeded ? "recompiling..." : "relinking..."));

}

}

else

outAllRecompileNeeded = true;

ssLOG_DEBUG("recompileNeeded: " << outAllRecompileNeeded <<

", changedDependencies.size(): " << outChangedDependencies.size() <<

", relinkNeeded: " << outRelinkNeeded);

//Write to file if there's any changes to the current script info

if( !lastInfo ||

outAllRecompileNeeded ||

!outChangedDependencies.empty() ||

outRelinkNeeded ||

!scriptInfo.Equals(*lastInfo))

{

std::ofstream writeOutputFile(lastScriptInfoFilePath);

if(!writeOutputFile)

{

ssLOG_ERROR("Failed to open file: " << lastScriptInfoFilePath);

return PipelineResult::INVALID_BUILD_DIR;

}

writeOutputFile << scriptInfo.ToString("");

ssLOG_DEBUG("Wrote current script info to " << lastScriptInfoFilePath.string());

}

if(!lastInfo)

return PipelineResult::SUCCESS;

return PipelineResult::SUCCESS;

INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(PipelineResult::UNEXPECTED_FAILURE);

const Data::Profile& profile,

const ghc::filesystem::path& absoluteScriptPath,

const ghc::filesystem::path& buildDir,

const std::unordered_map<CmdOptions, std::string>& currentOptions,

const std::vector<std::string>& changedDependencies,

const int maxThreads,

std::vector<Data::DependencyInfo*>& outAvailableDependencies,

std::vector<std::string>& outGatheredBinariesPaths)

{

ssLOG_FUNC_INFO();

INTERNAL_RUNCPP2_SAFE_START();

for(int i = 0; i < scriptInfo.Dependencies.size(); ++i)

{

if(IsDependencyAvailableForThisPlatform(scriptInfo.Dependencies.at(i)))

outAvailableDependencies.push_back(&scriptInfo.Dependencies.at(i));

}

std::vector<std::string> dependenciesLocalCopiesPaths;

std::vector<std::string> dependenciesSourcePaths;

if(!GetDependenciesPaths( outAvailableDependencies,

dependenciesLocalCopiesPaths,

dependenciesSourcePaths,

absoluteScriptPath,

buildDir))

{

ssLOG_ERROR("Failed to get dependencies paths");

return PipelineResult::DEPENDENCIES_FAILED;

}

if(currentOptions.count(CmdOptions::RESET_DEPENDENCIES) > 0 || !changedDependencies.empty())

{

if(currentOptions.count(CmdOptions::BUILD_SOURCE_ONLY) > 0)

{

ssLOG_ERROR("Dependencies settings have changed or being reset explicitly.");

ssLOG_ERROR("Cannot just build source files only without building dependencies");

return PipelineResult::INVALID_OPTION;

}

std::string depsToReset = "all";

if(!changedDependencies.empty())

{

depsToReset = changedDependencies[0];

for(int i = 1; i < changedDependencies.size(); ++i)

depsToReset += "," + changedDependencies[i];

}

if(!CleanupDependencies(profile,

scriptInfo,

outAvailableDependencies,

dependenciesLocalCopiesPaths,

currentOptions.count(CmdOptions::RESET_DEPENDENCIES) > 0 ?

currentOptions.at(CmdOptions::RESET_DEPENDENCIES) :

depsToReset))

{

ssLOG_ERROR("Failed to cleanup dependencies");

return PipelineResult::DEPENDENCIES_FAILED;

}

}

if(currentOptions.count(CmdOptions::RESET_DEPENDENCIES) > 0)

return PipelineResult::SUCCESS;

if(!SetupDependenciesIfNeeded( profile,

buildDir,

scriptInfo,

outAvailableDependencies,

dependenciesLocalCopiesPaths,

dependenciesSourcePaths,

maxThreads))

{

ssLOG_ERROR("Failed to setup script dependencies");

return PipelineResult::DEPENDENCIES_FAILED;

}

//Sync local dependencies before building

if(!SyncLocalDependencies( outAvailableDependencies,

dependenciesSourcePaths,

dependenciesLocalCopiesPaths))

{

ssLOG_ERROR("Failed to sync local dependencies");

return PipelineResult::DEPENDENCIES_FAILED;

}

if(currentOptions.count(CmdOptions::BUILD_SOURCE_ONLY) == 0)

{

if(!BuildDependencies( profile,

scriptInfo,

outAvailableDependencies,

dependenciesLocalCopiesPaths,

maxThreads))

{

ssLOG_ERROR("Failed to build script dependencies. Maybe try resetting dependencies "

"with \"-rd all\" and run again?");

return PipelineResult::DEPENDENCIES_FAILED;

}

}

if(!GatherDependenciesBinaries( outAvailableDependencies,

dependenciesLocalCopiesPaths,

profile,

outGatheredBinariesPaths))

{

ssLOG_ERROR("Failed to gather dependencies binaries");

return PipelineResult::DEPENDENCIES_FAILED;

}

return PipelineResult::SUCCESS;

INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(PipelineResult::UNEXPECTED_FAILURE);

const std::vector<std::string>& gatheredBinariesPaths,

std::vector<std::string>& outLinkFilesPaths,

std::vector<std::string>& outFilesToCopyPaths)

{

ssLOG_FUNC_INFO();

INTERNAL_RUNCPP2_SAFE_START();

std::unordered_set<std::string> linkExtensions;

//Populate the set of link extensions

if(runcpp2::HasValueFromPlatformMap(filesTypes.StaticLinkFile.Extension))

linkExtensions.insert(*runcpp2::GetValueFromPlatformMap(filesTypes.StaticLinkFile.Extension));

if(runcpp2::HasValueFromPlatformMap(filesTypes.SharedLinkFile.Extension))

linkExtensions.insert(*runcpp2::GetValueFromPlatformMap(filesTypes.SharedLinkFile.Extension));

if(runcpp2::HasValueFromPlatformMap(filesTypes.ObjectLinkFile.Extension))

linkExtensions.insert(*runcpp2::GetValueFromPlatformMap(filesTypes.ObjectLinkFile.Extension));

//Separate the gathered files from dependencies into files to link and files to copy

for(int i = 0; i < gatheredBinariesPaths.size(); ++i)

{

ghc::filesystem::path filePath(gatheredBinariesPaths.at(i));

std::string extension = runcpp2::GetFileExtensionWithoutVersion(filePath);

//Check if the file is a link file based on its extension

if(linkExtensions.find(extension) != linkExtensions.end())

{

outLinkFilesPaths.push_back(gatheredBinariesPaths.at(i));

//Special case when SharedLinkFile and SharedLibraryFile share the same extension

if( runcpp2::HasValueFromPlatformMap(filesTypes.SharedLibraryFile.Extension) &&

*runcpp2::GetValueFromPlatformMap(filesTypes.SharedLibraryFile

.Extension) == extension)

{

outFilesToCopyPaths.push_back(gatheredBinariesPaths.at(i));

}

}

else

outFilesToCopyPaths.push_back(gatheredBinariesPaths.at(i));

}

ssLOG_INFO("Files to link:");

for(int i = 0; i < outLinkFilesPaths.size(); ++i)

ssLOG_INFO(" " << outLinkFilesPaths[i]);

ssLOG_INFO("Files to copy:");

for(int i = 0; i < outFilesToCopyPaths.size(); ++i)

ssLOG_INFO(" " << outFilesToCopyPaths[i]);

INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(void());

const Data::Profile& profile,

const ghc::filesystem::path& buildDir)

{

ssLOG_FUNC_INFO();

const Data::ProfilesCommands* preBuildCommands =

runcpp2::GetValueFromPlatformMap(scriptInfo.PreBuild);

return RunProfileCommands(preBuildCommands, profile, buildDir.string(), "PreBuild");

const Data::Profile& profile,

const ghc::filesystem::path& buildDir)

{

ssLOG_FUNC_INFO();

const Data::ProfilesCommands* postBuildCommands =

GetValueFromPlatformMap(scriptInfo.PostBuild);

return RunProfileCommands(postBuildCommands, profile, buildDir.string(), "PostBuild");

const ghc::filesystem::path& absoluteScriptPath,

const Data::ScriptInfo& scriptInfo,

const std::vector<std::string>& runArgs,

const std::unordered_map<CmdOptions, std::string>& currentOptions,

int& returnStatus)

{

ssLOG_FUNC_INFO();

INTERNAL_RUNCPP2_SAFE_START();

//Skip running if not executable

if( scriptInfo.CurrentBuildType != Data::BuildType::INTERNAL_EXECUTABLE_EXECUTABLE &&

scriptInfo.CurrentBuildType != Data::BuildType::INTERNAL_EXECUTABLE_SHARED)

{

ssLOG_INFO("Skipping run - output is not executable");

return PipelineResult::SUCCESS;

}

std::error_code e;

if(target.empty() || !ghc::filesystem::exists(target, e))

{

ssLOG_ERROR("Failed to find the compiled file to run");

return PipelineResult::COMPILE_LINK_FAILED;

}

//Prepare run arguments

std::vector<std::string> finalRunArgs;

finalRunArgs.push_back(target.string());

if(scriptInfo.PassScriptPath)

finalRunArgs.push_back(absoluteScriptPath);

//Add user provided arguments

for(size_t i = 0; i < runArgs.size(); ++i)

finalRunArgs.push_back(runArgs[i]);

if(scriptInfo.CurrentBuildType == Data::BuildType::INTERNAL_EXECUTABLE_EXECUTABLE)

{

//Running the script with modified args

if(!RunCompiledScript(target, absoluteScriptPath, finalRunArgs, returnStatus))

{

ssLOG_ERROR("Failed to run script");

return PipelineResult::RUN_SCRIPT_FAILED;

}

}

else

{

//Load the shared library and run it with modified args

if(!RunCompiledSharedLib(absoluteScriptPath, target, finalRunArgs, returnStatus))

{

ssLOG_ERROR("Failed to run script");

return PipelineResult::RUN_SCRIPT_FAILED;

}

}

return PipelineResult::SUCCESS;

INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(PipelineResult::UNEXPECTED_FAILURE);

const std::string& scriptName,

const Data::Profile& profile,

const std::unordered_map<CmdOptions, std::string>& currentOptions,

const Data::ScriptInfo& scriptInfo,

std::vector<ghc::filesystem::path>& outTargets,

ghc::filesystem::path* outRunnableTarget)

{

ssLOG_FUNC_INFO();

INTERNAL_RUNCPP2_SAFE_START();

std::error_code _;

outTargets.clear();

//Validate executable option against build type

if( currentOptions.count(CmdOptions::EXECUTABLE) > 0 &&

scriptInfo.CurrentBuildType != Data::BuildType::INTERNAL_EXECUTABLE_SHARED &&

scriptInfo.CurrentBuildType != Data::BuildType::INTERNAL_EXECUTABLE_EXECUTABLE)

{

ssLOG_ERROR("Cannot run as executable - script is configured for " <<

Data::BuildTypeToString(scriptInfo.CurrentBuildType) <<

" output. Please remove --executable flag or change build type to Executable");

return PipelineResult::INVALID_OPTION;

}

//Get all target paths

std::vector<bool> isRunnable;

if(!Data::BuildTypeHelper::GetPossibleOutputPaths( buildDir,

scriptName,

profile,

scriptInfo.CurrentBuildType,

outTargets,

isRunnable))

{

ssLOG_ERROR("Extension or prefix not found in compiler profile for build type: " <<

runcpp2::Data::BuildTypeToString(scriptInfo.CurrentBuildType));

return PipelineResult::INVALID_SCRIPT_INFO;

}

//Verify all targets exist

for(const ghc::filesystem::path& target : outTargets)

{

if(!ghc::filesystem::exists(target, _))

{

ssLOG_WARNING("Failed to find the compiled file: " << target.string());

continue;

//return PipelineResult::COMPILE_LINK_FAILED;

}

}

//If requested, find the runnable target

if(outRunnableTarget != nullptr)

{

for(size_t i = 0; i < outTargets.size(); ++i)

{

if(isRunnable.at(i))

{

*outRunnableTarget = outTargets.at(i);

break;

}

}

}

return PipelineResult::SUCCESS;

INTERNAL_RUNCPP2_SAFE_CATCH_RETURN(PipelineResult::UNEXPECTED_FAILURE);

const Data::ScriptInfo& scriptInfo,

const Data::Profile& currentProfile,

std::vector<ghc::filesystem::path>& outSourcePaths)