path: root/backend/ninja/Ninja.cpp

#include <cstring>
#include "Ninja.hpp"
#include "../../include/FileUtil.hpp"
#include "../../include/Exec.hpp"
#include "../../include/PkgConfig.hpp"
#include "../../include/GlobalLib.hpp"

using namespace std;
using namespace sibs;

namespace backend
{
    string join(const vector<string> &list, const char *joinStr)
    {
        if(list.empty()) return "";
        string result;
        long stringSize = 0;
        long joinStrLen = strlen(joinStr);
        int i = 0;
        for(const string &str : list)
        {
            stringSize += str.size();
            if(!str.empty() && i > 0)
                stringSize += joinStrLen;
            ++i;
        }

        result.reserve(stringSize);

        i = 0;
        for(const string &str : list)
        {
            if(i > 0);
                result += joinStr;
            result += str;
            ++i;
        }

        return move(result);
    }

    Ninja::Ninja(LibraryType _libraryType) :
        libraryType(_libraryType)
    {

    }

    void Ninja::addSourceFile(const char *filepath)
    {
        if(filepath && !containsSourceFile(filepath))
            sourceFiles.emplace_back(filepath);
    }

    const std::vector<std::string>& Ninja::getSourceFiles() const
    {
        return sourceFiles;
    }

    bool Ninja::containsSourceFile(const char *filepath) const
    {
        for(const string &sourceFile : sourceFiles)
        {
            if(sourceFile == filepath)
                return true;
        }
        return false;
    }

    Result<bool> validatePkgConfigPackageVersionExists(const Dependency &dependency)
    {
        Result<bool> dependencyValidationResult = PkgConfig::validatePackageExists(dependency.name);
        if(dependencyValidationResult.isErr())
            return Result<bool>::Err(dependencyValidationResult.getErrMsg());

        Result<bool> dependencyVersionValidationResult = PkgConfig::validatePackageVersionAtLeast(dependency.name, dependency.version);
        if(dependencyVersionValidationResult.isErr())
            return Result<bool>::Err(dependencyVersionValidationResult.getErrMsg());

        return Result<bool>::Ok(true);
    }

    // TODO: First check if pkg-config is installed. If it's not, only check dependencies that exists in the dependencies sub directory.
    // If pkg-config is installed and dependency is not installed, check in dependencies sub directory.
    Result<bool> Ninja::getLinkerFlags(const vector<Dependency> &dependencies, LinkerFlagCallbackFunc staticLinkerFlagCallbackFunc, LinkerFlagCallbackFunc dynamicLinkerFlagCallback) const
    {
        if(dependencies.empty()) return Result<bool>::Ok(true);

        string globalLibDir = getHomeDir();
        globalLibDir += "/.sibs/lib";
        Result<bool> createGlobalLibDirResult = createDirectoryRecursive(globalLibDir.c_str());
        if(createGlobalLibDirResult.isErr())
            return createGlobalLibDirResult;

        vector<Dependency> pkgConfigDependencies;
        vector<Dependency> globalLibDependencies;
        for(const Dependency &dependency : dependencies)
        {
            Result<bool> pkgConfigDependencyValidation = validatePkgConfigPackageVersionExists(dependency);
            if(pkgConfigDependencyValidation.isOk())
            {
                pkgConfigDependencies.push_back(dependency);
            }
            else
            {
                globalLibDependencies.push_back(dependency);
            }
        }

        Result<string> pkgConfigLinkerFlagsResult = PkgConfig::getDynamicLibsLinkerFlags(pkgConfigDependencies);
        if(pkgConfigLinkerFlagsResult.isErr())
        {
            printf("%s, using global lib...\n", pkgConfigLinkerFlagsResult.getErrMsg().c_str());
            globalLibDependencies.reserve(globalLibDependencies.size() + pkgConfigDependencies.size());
            for(const Dependency &pkgConfigDependency : pkgConfigDependencies)
            {
                globalLibDependencies.push_back(pkgConfigDependency);
            }
            pkgConfigDependencies.clear();
        }
        else
        {
            if(!pkgConfigLinkerFlagsResult.unwrap().empty())
                dynamicLinkerFlagCallback(pkgConfigLinkerFlagsResult.unwrap());
        }

        for(const Dependency &globalLibDependency : globalLibDependencies)
        {
            printf("Dependency %s is missing from pkg-config, trying global lib\n", globalLibDependency.name.c_str());
            Result<string> globalLibLinkerFlagsResult = GlobalLib::getLibsLinkerFlags(globalLibDir, globalLibDependency.name, globalLibDependency.version, staticLinkerFlagCallbackFunc, dynamicLinkerFlagCallback);
            if(globalLibLinkerFlagsResult.isErr())
            {
                if(globalLibLinkerFlagsResult.getErrorCode() == GlobalLib::DependencyError::DEPENDENCY_NOT_FOUND || globalLibLinkerFlagsResult.getErrorCode() == GlobalLib::DependencyError::DEPENDENCY_VERSION_NO_MATCH)
                {
                    printf("Dependency not found in global lib, trying to download from github\n");
                    // TODO: Download several dependencies at the same time by adding them to a list
                    // and then iterate them and download them all using several threads.

                    // TODO: If return error is invalid url, then the message should be converted to
                    // invalid package name/version. A check should be done if it is the name or version
                    // that is invalid.
                    Result<bool> downloadDependencyResult = GlobalLib::downloadDependency(globalLibDependency);
                    if(downloadDependencyResult.isErr())
                        return downloadDependencyResult;

                    globalLibLinkerFlagsResult = GlobalLib::getLibsLinkerFlags(globalLibDir, globalLibDependency.name, globalLibDependency.version, staticLinkerFlagCallbackFunc, dynamicLinkerFlagCallback);
                    if(globalLibLinkerFlagsResult.isErr())
                        return Result<bool>::Err(globalLibLinkerFlagsResult);
                }
                else
                {
                    return Result<bool>::Err(globalLibLinkerFlagsResult);
                }
            }
        }

        return Result<bool>::Ok(true);
    }

    Result<bool> Ninja::createBuildFile(const std::string &packageName, const vector<Dependency> &dependencies, const char *savePath, LinkerFlagCallbackFunc staticLinkerFlagCallbackFunc, LinkerFlagCallbackFunc dynamicLinkerFlagCallback)
    {
        // TODO: Do not quit here if no source files are provided. The source-less project could have dependencies
        if(sourceFiles.empty())
            return Result<bool>::Err("No source files provided");

        Result<bool> createBuildDirResult = createDirectoryRecursive(savePath);
        if(createBuildDirResult.isErr())
            return createBuildDirResult;

        string ninjaBuildFilePath = savePath;
        ninjaBuildFilePath += "/build.ninja";

        string result;
        result.reserve(16384);

        string globalLibDir = getHomeDir();
        globalLibDir += "/.sibs/lib";

        result += "globalLibDir = '-I";
        result += globalLibDir;
        result += "'\n\n";

        string buildJob;
        switch(libraryType)
        {
            case LibraryType::EXECUTABLE:
            {
                result += "rule cpp_COMPILER\n";
                result += "  command = ccache c++ $ARGS -c $in -o $out\n\n";

                result += "rule cpp_BUILD_EXEC\n";
                result += "  command = ccache c++ $ARGS -o $out $in $LINK_ARGS $aliasing\n\n";
                buildJob = "cpp_BUILD_EXEC";
                break;
            }
            case LibraryType::STATIC:
            {
                result += "rule cpp_COMPILER\n";
                result += "  command = ccache c++ $ARGS -c -fPIC $in -o $out\n\n";

                result += "rule cpp_BUILD_STATIC\n";
                result += "  command = ar rcs lib";
                result += packageName;
                result += ".a";
                result += " $in\n\n";
                buildJob = "cpp_BUILD_STATIC";
                break;
            }
            case LibraryType::DYNAMIC:
            {
                result += "rule cpp_COMPILER\n";
                result += "  command = ccache c++ $ARGS -c -fPIC $in -o $out\n\n";

                // --whole-archive
                result += "rule cpp_BUILD_DYNAMIC\n";
                result += "  command = ccache c++ $in -shared -o $out $LINK_ARGS $aliasing\n\n";
                buildJob = "cpp_BUILD_DYNAMIC";
                break;
            }
            default:
                assert(false);
                return Result<bool>::Err("Unexpected error");
        }

        vector<string> objectNames;
        objectNames.reserve(sourceFiles.size());
        for(const string &sourceFile : sourceFiles)
        {
            // TODO: Handle tests differently.
            // Maybe test directory should have project file and sub directories with project files
            // should be their own project?
            if(_tinydir_strncmp(sourceFile.c_str(), "tests", 5) == 0)
                continue;

            //string sourceFileEncoded = sourceFile;
            //replace(sourceFileEncoded, '/', '@');
            string objectName = packageName + "@exe/" + sourceFile + ".o";
            result += "build ";
            result += objectName;
            result += ": cpp_COMPILER ../../";
            result += sourceFile;
            result += "\n";
            result += "  ARGS = $globalLibDir '-I" + packageName + "@exe' '-I.' '-I..' '-fdiagnostics-color=always' '-pipe' '-D_FILE_OFFSET_BITS=64' '-Wall' '-Winvalid-pch' '-Wnon-virtual-dtor' '-O0' '-g'\n\n";
            objectNames.emplace_back(objectName);
        }

        string allLinkerFlags;
        if(!staticLinkerFlagCallbackFunc || libraryType == LibraryType::DYNAMIC)
        {
            staticLinkerFlagCallbackFunc = [&allLinkerFlags](const string &linkerFlag)
            {
                allLinkerFlags += " ";
                allLinkerFlags += linkerFlag;
            };
        }

        // TODO: If project contains no source files, then we shouldn't override this function
        dynamicLinkerFlagCallback = [&allLinkerFlags](const string &linkerFlag)
        {
            allLinkerFlags += " ";
            allLinkerFlags += linkerFlag;
        };

        switch(libraryType)
        {
            case LibraryType::EXECUTABLE:
            {
                Result<bool> linkerFlags = getLinkerFlags(dependencies, staticLinkerFlagCallbackFunc, dynamicLinkerFlagCallback);
                if(linkerFlags.isErr())
                    return Result<bool>::Err(linkerFlags.getErrMsg());

                result += "build ";
                result += packageName;
                result += ": " + buildJob + " ";
                result += join(objectNames, " ");
                result += "\n";
                result += "  LINK_ARGS = '-Wl,--no-undefined,--as-needed' ";
                if(!allLinkerFlags.empty())
                {
                    result += allLinkerFlags;
                }
                result += "\n\n";
                break;
            }
            case LibraryType::STATIC:
            {
                Result<bool> linkerFlags = getLinkerFlags(dependencies, staticLinkerFlagCallbackFunc, dynamicLinkerFlagCallback);
                if(linkerFlags.isErr())
                    return linkerFlags;

                result += "build ";
                result += packageName;
                result += ": " + buildJob + " ";
                result += join(objectNames, " ");
                result += "\n\n";
                break;
            }
            case LibraryType::DYNAMIC:
            {
                Result<bool> linkerFlags = getLinkerFlags(dependencies, staticLinkerFlagCallbackFunc, dynamicLinkerFlagCallback);
                if(linkerFlags.isErr())
                    return Result<bool>::Err(linkerFlags.getErrMsg());

                result += "build lib";
                result += packageName;
                result += ".so: " + buildJob + " ";
                result += join(objectNames, " ");
                result += "\n";
                result += "  LINK_ARGS = '-Wl,--no-undefined,--as-needed' ";
                if(!allLinkerFlags.empty())
                {
                    result += allLinkerFlags;
                    //result += " '-Wl,--no-whole-archive'";
                }
                result += "\n\n";
                break;
            }
            default:
                assert(false);
                return Result<bool>::Err("Unexpected error");
        }

        Result<bool> fileOverwriteResult = sibs::fileOverwrite(ninjaBuildFilePath.c_str(), sibs::StringView(result.data(), result.size()));
        if(fileOverwriteResult.isErr())
            return fileOverwriteResult;

        printf("Created ninja build file: %s\n", ninjaBuildFilePath.c_str());
        return Result<bool>::Ok(true);
    }

    Result<bool> Ninja::build(const char *buildFilePath)
    {
        string command = "ninja -C '";
        command += buildFilePath;
        command += "'";
        Result<ExecResult> execResult = exec(command.c_str());
        if(execResult.isOk())
        {
            if(execResult.unwrap().exitCode == 0)
            {
                printf("%s", execResult.unwrap().execStdout.c_str());
                return Result<bool>::Ok(true);
            }
            else
                return Result<bool>::Err(execResult.unwrap().execStdout);
        }
        else
            return Result<bool>::Err(execResult.getErrMsg());
    }
}