/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing for details.  */
#include "cmGlobalUnixMakefileGenerator3.h"

#include <algorithm>
#include <functional>
#include <sstream>
#include <utility>

#include "cmDocumentationEntry.h"
#include "cmGeneratedFileStream.h"
#include "cmGeneratorTarget.h"
#include "cmGlobalGenerator.h"
#include "cmLocalGenerator.h"
#include "cmLocalUnixMakefileGenerator3.h"
#include "cmMakefile.h"
#include "cmMakefileTargetGenerator.h"
#include "cmOutputConverter.h"
#include "cmState.h"
#include "cmStateDirectory.h"
#include "cmStateTypes.h"
#include "cmSystemTools.h"
#include "cmTargetDepend.h"
#include "cmake.h"

cmGlobalUnixMakefileGenerator3::cmGlobalUnixMakefileGenerator3(cmake* cm)
: cmGlobalCommonGenerator(cm)
{
    // This type of makefile always requires unix style paths
    this->ForceUnixPaths      = true;
    this->FindMakeProgramFile = "CMakeUnixFindMake.cmake";
    this->ToolSupportsColor   = true;

#if defined(_WIN32) || defined(__VMS)
    this->UseLinkScript = false;
#else
    this->UseLinkScript = true;
#endif
    this->CommandDatabase = nullptr;

    this->IncludeDirective  = "include";
    this->DefineWindowsNULL = false;
    this->PassMakeflags     = false;
    this->UnixCD            = true;
}

void
cmGlobalUnixMakefileGenerator3::EnableLanguage(
    std::vector<std::string> const& languages, cmMakefile* mf, bool optional)
{
    this->cmGlobalGenerator::EnableLanguage(languages, mf, optional);
    for(std::string const& language : languages)
    {
        if(language == "NONE")
        {
            continue;
        }
        this->ResolveLanguageCompiler(language, mf, optional);
    }
}

///! Create a local generator appropriate to this Global Generator
cmLocalGenerator*
cmGlobalUnixMakefileGenerator3::CreateLocalGenerator(cmMakefile* mf)
{
    return new cmLocalUnixMakefileGenerator3(this, mf);
}

void
cmGlobalUnixMakefileGenerator3::GetDocumentation(cmDocumentationEntry& entry)
{
    entry.Name  = cmGlobalUnixMakefileGenerator3::GetActualName();
    entry.Brief = "Generates standard UNIX makefiles.";
}

std::string
cmGlobalUnixMakefileGenerator3::GetEditCacheCommand() const
{
    // If generating for an extra IDE, the edit_cache target cannot
    // launch a terminal-interactive tool, so always use cmake-gui.
    if(!this->GetExtraGeneratorName().empty())
    {
        return cmSystemTools::GetCMakeGUICommand();
    }

    // Use an internal cache entry to track the latest dialog used
    // to edit the cache, and use that for the edit_cache target.
    cmake*      cm               = this->GetCMakeInstance();
    std::string editCacheCommand = cm->GetCMakeEditCommand();
    if(!cm->GetCacheDefinition("CMAKE_EDIT_COMMAND") ||
       !editCacheCommand.empty())
    {
        if(editCacheCommand.empty())
        {
            editCacheCommand = cmSystemTools::GetCMakeCursesCommand();
        }
        if(editCacheCommand.empty())
        {
            editCacheCommand = cmSystemTools::GetCMakeGUICommand();
        }
        if(!editCacheCommand.empty())
        {
            cm->AddCacheEntry("CMAKE_EDIT_COMMAND", editCacheCommand.c_str(),
                              "Path to cache edit program executable.",
                              cmStateEnums::INTERNAL);
        }
    }
    const char* edit_cmd = cm->GetCacheDefinition("CMAKE_EDIT_COMMAND");
    return edit_cmd ? edit_cmd : "";
}

void
cmGlobalUnixMakefileGenerator3::ComputeTargetObjectDirectory(
    cmGeneratorTarget* gt) const
{
    // Compute full path to object file directory for this target.
    std::string dir;
    dir += gt->LocalGenerator->GetCurrentBinaryDirectory();
    dir += "/";
    dir += gt->LocalGenerator->GetTargetDirectory(gt);
    dir += "/";
    gt->ObjectDirectory = dir;
}

void
cmGlobalUnixMakefileGenerator3::Configure()
{
    // Initialize CMAKE_EDIT_COMMAND cache entry.
    this->GetEditCacheCommand();

    this->cmGlobalGenerator::Configure();
}

void
cmGlobalUnixMakefileGenerator3::Generate()
{
    // first do superclass method
    this->cmGlobalGenerator::Generate();

    // initialize progress
    unsigned long total = 0;
    for(auto const& pmi : this->ProgressMap)
    {
        total += pmi.second.NumberOfActions;
    }

    // write each target's progress.make this loop is done twice. Bascially the
    // Generate pass counts all the actions, the first loop below determines
    // how many actions have progress updates for each target and writes to
    // corrrect variable values for everything except the all targets. The
    // second loop actually writes out correct values for the all targets as
    // well. This is because the all targets require more information that is
    // computed in the first loop.
    unsigned long current = 0;
    for(auto& pmi : this->ProgressMap)
    {
        pmi.second.WriteProgressVariables(total, current);
    }
    for(cmLocalGenerator* lg : this->LocalGenerators)
    {
        std::string markFileName = lg->GetCurrentBinaryDirectory();
        markFileName += "/";
        markFileName += cmake::GetCMakeFilesDirectory();
        markFileName += "/progress.marks";
        cmGeneratedFileStream markFile(markFileName);
        markFile << this->CountProgressMarksInAll(lg) << "\n";
    }

    // write the main makefile
    this->WriteMainMakefile2();
    this->WriteMainCMakefile();

    if(this->CommandDatabase != nullptr)
    {
        *this->CommandDatabase << std::endl << "]";
        delete this->CommandDatabase;
        this->CommandDatabase = nullptr;
    }
}

void
cmGlobalUnixMakefileGenerator3::AddCXXCompileCommand(
    const std::string& sourceFile, const std::string& workingDirectory,
    const std::string& compileCommand)
{
    if(this->CommandDatabase == nullptr)
    {
        std::string commandDatabaseName =
            std::string(this->GetCMakeInstance()->GetHomeOutputDirectory()) +
            "/compile_commands.json";
        this->CommandDatabase = new cmGeneratedFileStream(commandDatabaseName);
        *this->CommandDatabase << "[" << std::endl;
    } else
    {
        *this->CommandDatabase << "," << std::endl;
    }
    *this->CommandDatabase << "{" << std::endl
                           << "  \"directory\": \""
                           << cmGlobalGenerator::EscapeJSON(workingDirectory)
                           << "\"," << std::endl
                           << "  \"command\": \""
                           << cmGlobalGenerator::EscapeJSON(compileCommand)
                           << "\"," << std::endl
                           << "  \"file\": \""
                           << cmGlobalGenerator::EscapeJSON(sourceFile) << "\""
                           << std::endl
                           << "}";
}

void
cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
{
    // Open the output file.  This should not be copy-if-different
    // because the check-build-system step compares the makefile time to
    // see if the build system must be regenerated.
    std::string makefileName =
        this->GetCMakeInstance()->GetHomeOutputDirectory();
    makefileName += cmake::GetCMakeFilesDirectory();
    makefileName += "/Makefile2";
    cmGeneratedFileStream makefileStream(makefileName, false,
                                         this->GetMakefileEncoding());
    if(!makefileStream)
    {
        return;
    }

    // get a local generator for some useful methods
    cmLocalUnixMakefileGenerator3* lg =
        static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[0]);

    // Write the do not edit header.
    lg->WriteDisclaimer(makefileStream);

    // Write the main entry point target.  This must be the VERY first
    // target so that make with no arguments will run it.
    // Just depend on the all target to drive the build.
    std::vector<std::string> depends;
    std::vector<std::string> no_commands;
    depends.push_back("all");

    // Write the rule.
    lg->WriteMakeRule(makefileStream,
                      "Default target executed when no arguments are "
                      "given to make.",
                      "default_target", depends, no_commands, true);

    depends.clear();

    // The all and preinstall rules might never have any dependencies
    // added to them.
    if(!this->EmptyRuleHackDepends.empty())
    {
        depends.push_back(this->EmptyRuleHackDepends);
    }

    // Write and empty all:
    lg->WriteMakeRule(makefileStream, "The main recursive all target", "all",
                      depends, no_commands, true);

    // Write an empty preinstall:
    lg->WriteMakeRule(makefileStream, "The main recursive preinstall target",
                      "preinstall", depends, no_commands, true);

    // Write an empty clean:
    lg->WriteMakeRule(makefileStream, "The main recursive clean target",
                      "clean", depends, no_commands, true);

    // Write out the "special" stuff
    lg->WriteSpecialTargetsTop(makefileStream);

    // write the target convenience rules
    for(cmLocalGenerator* localGen : this->LocalGenerators)
    {
        lg = static_cast<cmLocalUnixMakefileGenerator3*>(localGen);
        this->WriteConvenienceRules2(makefileStream, lg);
    }

    lg = static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[0]);
    lg->WriteSpecialTargetsBottom(makefileStream);
}

void
cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
{
    if(this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION"))
    {
        return;
    }

    // Open the output file.  This should not be copy-if-different
    // because the check-build-system step compares the makefile time to
    // see if the build system must be regenerated.
    std::string cmakefileName =
        this->GetCMakeInstance()->GetHomeOutputDirectory();
    cmakefileName += cmake::GetCMakeFilesDirectory();
    cmakefileName += "/Makefile.cmake";
    cmGeneratedFileStream cmakefileStream(cmakefileName);
    if(!cmakefileStream)
    {
        return;
    }

    std::string makefileName =
        this->GetCMakeInstance()->GetHomeOutputDirectory();
    makefileName += "/Makefile";

    // get a local generator for some useful methods
    cmLocalUnixMakefileGenerator3* lg =
        static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[0]);

    // Write the do not edit header.
    lg->WriteDisclaimer(cmakefileStream);

    // Save the generator name
    cmakefileStream << "# The generator used is:\n"
                    << "set(CMAKE_DEPENDS_GENERATOR \"" << this->GetName()
                    << "\")\n\n";

    // for each cmMakefile get its list of dependencies
    std::vector<std::string> lfiles;
    for(cmLocalGenerator* localGen : this->LocalGenerators)
    {
        lg = static_cast<cmLocalUnixMakefileGenerator3*>(localGen);

        // Get the list of files contributing to this generation step.
        lfiles.insert(lfiles.end(), lg->GetMakefile()->GetListFiles().begin(),
                      lg->GetMakefile()->GetListFiles().end());
    }

    cmake* cm = this->GetCMakeInstance();
    if(cm->DoWriteGlobVerifyTarget())
    {
        lfiles.push_back(cm->GetGlobVerifyScript());
        lfiles.push_back(cm->GetGlobVerifyStamp());
    }

    // Sort the list and remove duplicates.
    std::sort(lfiles.begin(), lfiles.end(), std::less<std::string>());
#if !defined(__VMS)  // The Compaq STL on VMS crashes, so accept duplicates.
    std::vector<std::string>::iterator new_end =
        std::unique(lfiles.begin(), lfiles.end());
    lfiles.erase(new_end, lfiles.end());
#endif

    // reset lg to the first makefile
    lg = static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[0]);

    std::string currentBinDir = lg->GetCurrentBinaryDirectory();
    // Save the list to the cmake file.
    cmakefileStream
        << "# The top level Makefile was generated from the following files:\n"
        << "set(CMAKE_MAKEFILE_DEPENDS\n"
        << "  \"CMakeCache.txt\"\n";
    for(std::string const& f : lfiles)
    {
        cmakefileStream << "  \"" << lg->ConvertToRelativePath(currentBinDir, f)
                        << "\"\n";
    }
    cmakefileStream << "  )\n\n";

    // Build the path to the cache check file.
    std::string check = this->GetCMakeInstance()->GetHomeOutputDirectory();
    check += cmake::GetCMakeFilesDirectory();
    check += "/cmake.check_cache";

    // Set the corresponding makefile in the cmake file.
    cmakefileStream << "# The corresponding makefile is:\n"
                    << "set(CMAKE_MAKEFILE_OUTPUTS\n"
                    << "  \""
                    << lg->ConvertToRelativePath(currentBinDir, makefileName)
                    << "\"\n"
                    << "  \"" << lg->ConvertToRelativePath(currentBinDir, check)
                    << "\"\n";
    cmakefileStream << "  )\n\n";

    const std::string binDir = lg->GetBinaryDirectory();

    // CMake must rerun if a byproduct is missing.
    {
        cmakefileStream << "# Byproducts of CMake generate step:\n"
                        << "set(CMAKE_MAKEFILE_PRODUCTS\n";
        const std::vector<std::string>& outfiles =
            lg->GetMakefile()->GetOutputFiles();
        for(std::string const& outfile : outfiles)
        {
            cmakefileStream << "  \""
                            << lg->ConvertToRelativePath(binDir, outfile)
                            << "\"\n";
        }

        // add in all the directory information files
        std::string tmpStr;
        for(cmLocalGenerator* localGen : this->LocalGenerators)
        {
            lg     = static_cast<cmLocalUnixMakefileGenerator3*>(localGen);
            tmpStr = lg->GetCurrentBinaryDirectory();
            tmpStr += cmake::GetCMakeFilesDirectory();
            tmpStr += "/CMakeDirectoryInformation.cmake";
            cmakefileStream << "  \""
                            << lg->ConvertToRelativePath(binDir, tmpStr)
                            << "\"\n";
        }
        cmakefileStream << "  )\n\n";
    }

    this->WriteMainCMakefileLanguageRules(cmakefileStream,
                                          this->LocalGenerators);
}

void
cmGlobalUnixMakefileGenerator3::WriteMainCMakefileLanguageRules(
    cmGeneratedFileStream&          cmakefileStream,
    std::vector<cmLocalGenerator*>& lGenerators)
{
    cmLocalUnixMakefileGenerator3* lg;

    // now list all the target info files
    cmakefileStream << "# Dependency information for all targets:\n";
    cmakefileStream << "set(CMAKE_DEPEND_INFO_FILES\n";
    for(cmLocalGenerator* lGenerator : lGenerators)
    {
        lg = static_cast<cmLocalUnixMakefileGenerator3*>(lGenerator);
        // for all of out targets
        const std::vector<cmGeneratorTarget*>& tgts = lg->GetGeneratorTargets();
        for(cmGeneratorTarget* tgt : tgts)
        {
            if((tgt->GetType() == cmStateEnums::EXECUTABLE) ||
               (tgt->GetType() == cmStateEnums::STATIC_LIBRARY) ||
               (tgt->GetType() == cmStateEnums::SHARED_LIBRARY) ||
               (tgt->GetType() == cmStateEnums::MODULE_LIBRARY) ||
               (tgt->GetType() == cmStateEnums::OBJECT_LIBRARY) ||
               (tgt->GetType() == cmStateEnums::UTILITY))
            {
                cmGeneratorTarget* gt    = tgt;
                std::string        tname = lg->GetRelativeTargetDirectory(gt);
                tname += "/DependInfo.cmake";
                cmSystemTools::ConvertToUnixSlashes(tname);
                cmakefileStream << "  \"" << tname << "\"\n";
            }
        }
    }
    cmakefileStream << "  )\n";
}

void
cmGlobalUnixMakefileGenerator3::WriteDirectoryRule2(
    std::ostream& ruleFileStream, cmLocalUnixMakefileGenerator3* lg,
    const char* pass, bool check_all, bool check_relink)
{
    // Get the relative path to the subdirectory from the top.
    std::string makeTarget = lg->GetCurrentBinaryDirectory();
    makeTarget += "/";
    makeTarget += pass;

    // The directory-level rule should depend on the target-level rules
    // for all targets in the directory.
    std::vector<std::string>               depends;
    const std::vector<cmGeneratorTarget*>& targets = lg->GetGeneratorTargets();
    for(cmGeneratorTarget* gtarget : targets)
    {
        int type = gtarget->GetType();
        if((type == cmStateEnums::EXECUTABLE) ||
           (type == cmStateEnums::STATIC_LIBRARY) ||
           (type == cmStateEnums::SHARED_LIBRARY) ||
           (type == cmStateEnums::MODULE_LIBRARY) ||
           (type == cmStateEnums::OBJECT_LIBRARY) ||
           (type == cmStateEnums::UTILITY))
        {
            // Add this to the list of depends rules in this directory.
            if((!check_all ||
                !gtarget->GetPropertyAsBool("EXCLUDE_FROM_ALL")) &&
               (!check_relink ||
                gtarget->NeedRelinkBeforeInstall(lg->GetConfigName())))
            {
                std::string tname = lg->GetRelativeTargetDirectory(gtarget);
                tname += "/";
                tname += pass;
                depends.push_back(std::move(tname));
            }
        }
    }

    // The directory-level rule should depend on the directory-level
    // rules of the subdirectories.
    std::vector<cmStateSnapshot> children =
        lg->GetStateSnapshot().GetChildren();
    for(cmStateSnapshot const& c : children)
    {
        std::string subdir = c.GetDirectory().GetCurrentBinary();
        subdir += "/";
        subdir += pass;
        depends.push_back(std::move(subdir));
    }

    // Work-around for makes that drop rules that have no dependencies
    // or commands.
    if(depends.empty() && !this->EmptyRuleHackDepends.empty())
    {
        depends.push_back(this->EmptyRuleHackDepends);
    }

    // Write the rule.
    std::string doc = "Convenience name for \"";
    doc += pass;
    doc += "\" pass in the directory.";
    std::vector<std::string> no_commands;
    lg->WriteMakeRule(ruleFileStream, doc.c_str(), makeTarget, depends,
                      no_commands, true);
}

void
cmGlobalUnixMakefileGenerator3::WriteDirectoryRules2(
    std::ostream& ruleFileStream, cmLocalUnixMakefileGenerator3* lg)
{
    // Only subdirectories need these rules.
    if(lg->IsRootMakefile())
    {
        return;
    }

    // Begin the directory-level rules section.
    std::string dir =
        cmSystemTools::ConvertToOutputPath(lg->ConvertToRelativePath(
            lg->GetBinaryDirectory(), lg->GetCurrentBinaryDirectory()));
    lg->WriteDivider(ruleFileStream);
    ruleFileStream << "# Directory level rules for directory " << dir << "\n\n";

    // Write directory-level rules for "all".
    this->WriteDirectoryRule2(ruleFileStream, lg, "all", true, false);

    // Write directory-level rules for "clean".
    this->WriteDirectoryRule2(ruleFileStream, lg, "clean", false, false);

    // Write directory-level rules for "preinstall".
    this->WriteDirectoryRule2(ruleFileStream, lg, "preinstall", true, true);
}

void
cmGlobalUnixMakefileGenerator3::GenerateBuildCommand(
    std::vector<std::string>& makeCommand, const std::string& makeProgram,
    const std::string& /*projectName*/, const std::string& /*projectDir*/,
    const std::string& targetName, const std::string& /*config*/, bool fast,
    int jobs, bool /*verbose*/, std::vector<std::string> const& makeOptions)
{
    cmMakefile* mf;
    if(!this->Makefiles.empty())
    {
        mf = this->Makefiles[0];
    } else
    {
        cmStateSnapshot snapshot = this->CMakeInstance->GetCurrentSnapshot();
        snapshot.GetDirectory().SetCurrentSource(
            this->CMakeInstance->GetHomeDirectory());
        snapshot.GetDirectory().SetCurrentBinary(
            this->CMakeInstance->GetHomeOutputDirectory());
        snapshot.SetDefaultDefinitions();
        mf = new cmMakefile(this, snapshot);
    }

    makeCommand.push_back(this->SelectMakeProgram(makeProgram));

    if(jobs != cmake::NO_BUILD_PARALLEL_LEVEL)
    {
        makeCommand.push_back("-j");
        if(jobs != cmake::DEFAULT_BUILD_PARALLEL_LEVEL)
        {
            makeCommand.push_back(std::to_string(jobs));
        }
    }

    makeCommand.insert(makeCommand.end(), makeOptions.begin(),
                       makeOptions.end());
    if(!targetName.empty())
    {
        std::string tname = targetName;
        if(fast)
        {
            tname += "/fast";
        }
        cmOutputConverter conv(mf->GetStateSnapshot());
        tname = conv.ConvertToRelativePath(mf->GetState()->GetBinaryDirectory(),
                                           tname);
        cmSystemTools::ConvertToOutputSlashes(tname);
        makeCommand.push_back(std::move(tname));
    }
    if(this->Makefiles.empty())
    {
        delete mf;
    }
}

void
cmGlobalUnixMakefileGenerator3::WriteConvenienceRules(
    std::ostream& ruleFileStream, std::set<std::string>& emitted)
{
    std::vector<std::string> depends;
    std::vector<std::string> commands;

    bool regenerate = !this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION");
    if(regenerate)
    {
        depends.push_back("cmake_check_build_system");
    }

    // write the target convenience rules
    for(cmLocalGenerator* localGen : this->LocalGenerators)
    {
        cmLocalUnixMakefileGenerator3* lg =
            static_cast<cmLocalUnixMakefileGenerator3*>(localGen);
        // for each target Generate the rule files for each target.
        const std::vector<cmGeneratorTarget*>& targets =
            lg->GetGeneratorTargets();
        for(cmGeneratorTarget* gtarget : targets)
        {
            // Don't emit the same rule twice (e.g. two targets with the same
            // simple name)
            int         type = gtarget->GetType();
            std::string name = gtarget->GetName();
            if(!name.empty() && emitted.insert(name).second &&
               // Handle user targets here.  Global targets are handled in
               // the local generator on a per-directory basis.
               ((type == cmStateEnums::EXECUTABLE) ||
                (type == cmStateEnums::STATIC_LIBRARY) ||
                (type == cmStateEnums::SHARED_LIBRARY) ||
                (type == cmStateEnums::MODULE_LIBRARY) ||
                (type == cmStateEnums::OBJECT_LIBRARY) ||
                (type == cmStateEnums::UTILITY)))
            {
                // Add a rule to build the target by name.
                lg->WriteDivider(ruleFileStream);
                ruleFileStream << "# Target rules for targets named " << name
                               << "\n\n";

                // Write the rule.
                commands.clear();
                std::string tmp = cmake::GetCMakeFilesDirectoryPostSlash();
                tmp += "Makefile2";
                commands.push_back(lg->GetRecursiveMakeCall(tmp.c_str(), name));
                depends.clear();
                if(regenerate)
                {
                    depends.push_back("cmake_check_build_system");
                }
                lg->WriteMakeRule(ruleFileStream, "Build rule for target.",
                                  name, depends, commands, true);

                // Add a fast rule to build the target
                std::string localName = lg->GetRelativeTargetDirectory(gtarget);
                std::string makefileName;
                makefileName = localName;
                makefileName += "/build.make";
                depends.clear();
                commands.clear();
                std::string makeTargetName = localName;
                makeTargetName += "/build";
                localName = name;
                localName += "/fast";
                commands.push_back(lg->GetRecursiveMakeCall(
                    makefileName.c_str(), makeTargetName));
                lg->WriteMakeRule(ruleFileStream, "fast build rule for target.",
                                  localName, depends, commands, true);

                // Add a local name for the rule to relink the target before
                // installation.
                if(gtarget->NeedRelinkBeforeInstall(lg->GetConfigName()))
                {
                    makeTargetName = lg->GetRelativeTargetDirectory(gtarget);
                    makeTargetName += "/preinstall";
                    localName = name;
                    localName += "/preinstall";
                    depends.clear();
                    commands.clear();
                    commands.push_back(lg->GetRecursiveMakeCall(
                        makefileName.c_str(), makeTargetName));
                    lg->WriteMakeRule(
                        ruleFileStream,
                        "Manual pre-install relink rule for target.", localName,
                        depends, commands, true);
                }
            }
        }
    }
}

void
cmGlobalUnixMakefileGenerator3::WriteConvenienceRules2(
    std::ostream& ruleFileStream, cmLocalUnixMakefileGenerator3* lg)
{
    std::vector<std::string> depends;
    std::vector<std::string> commands;
    std::string              localName;
    std::string              makeTargetName;

    // write the directory level rules for this local gen
    this->WriteDirectoryRules2(ruleFileStream, lg);

    bool regenerate = !this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION");
    if(regenerate)
    {
        depends.push_back("cmake_check_build_system");
    }

    // for each target Generate the rule files for each target.
    const std::vector<cmGeneratorTarget*>& targets = lg->GetGeneratorTargets();
    for(cmGeneratorTarget* gtarget : targets)
    {
        int         type = gtarget->GetType();
        std::string name = gtarget->GetName();
        if(!name.empty() && ((type == cmStateEnums::EXECUTABLE) ||
                             (type == cmStateEnums::STATIC_LIBRARY) ||
                             (type == cmStateEnums::SHARED_LIBRARY) ||
                             (type == cmStateEnums::MODULE_LIBRARY) ||
                             (type == cmStateEnums::OBJECT_LIBRARY) ||
                             (type == cmStateEnums::UTILITY)))
        {
            std::string makefileName;
            // Add a rule to build the target by name.
            localName    = lg->GetRelativeTargetDirectory(gtarget);
            makefileName = localName;
            makefileName += "/build.make";

            lg->WriteDivider(ruleFileStream);
            ruleFileStream << "# Target rules for target " << localName
                           << "\n\n";

            commands.clear();
            makeTargetName = localName;
            makeTargetName += "/depend";
            commands.push_back(
                lg->GetRecursiveMakeCall(makefileName.c_str(), makeTargetName));

            makeTargetName = localName;
            makeTargetName += "/build";
            commands.push_back(
                lg->GetRecursiveMakeCall(makefileName.c_str(), makeTargetName));

            // Write the rule.
            localName += "/all";
            depends.clear();

            cmLocalUnixMakefileGenerator3::EchoProgress progress;
            progress.Dir = lg->GetBinaryDirectory();
            progress.Dir += cmake::GetCMakeFilesDirectory();
            {
                std::ostringstream                progressArg;
                const char*                       sep = "";
                std::vector<unsigned long> const& progFiles =
                    this->ProgressMap[gtarget].Marks;
                for(unsigned long progFile : progFiles)
                {
                    progressArg << sep << progFile;
                    sep = ",";
                }
                progress.Arg = progressArg.str();
            }

            bool targetMessages = true;
            if(const char* tgtMsg =
                   this->GetCMakeInstance()->GetState()->GetGlobalProperty(
                       "TARGET_MESSAGES"))
            {
                targetMessages = cmSystemTools::IsOn(tgtMsg);
            }

            if(targetMessages)
            {
                lg->AppendEcho(commands, "Built target " + name,
                               cmLocalUnixMakefileGenerator3::EchoNormal,
                               &progress);
            }

            this->AppendGlobalTargetDepends(depends, gtarget);
            lg->WriteMakeRule(ruleFileStream, "All Build rule for target.",
                              localName, depends, commands, true);

            // add the all/all dependency
            if(!this->IsExcluded(this->LocalGenerators[0], gtarget))
            {
                depends.clear();
                depends.push_back(localName);
                commands.clear();
                lg->WriteMakeRule(ruleFileStream, "Include target in all.",
                                  "all", depends, commands, true);
            }

            // Write the rule.
            commands.clear();

            {
                // TODO: Convert the total progress count to a make variable.
                std::ostringstream progCmd;
                progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start ";
                // # in target
                progCmd << lg->ConvertToOutputFormat(
                    cmSystemTools::CollapseFullPath(progress.Dir),
                    cmOutputConverter::SHELL);
                //
                std::set<cmGeneratorTarget const*> emitted;
                progCmd << " "
                        << this->CountProgressMarksInTarget(gtarget, emitted);
                commands.push_back(progCmd.str());
            }
            std::string tmp = cmake::GetCMakeFilesDirectoryPostSlash();
            tmp += "Makefile2";
            commands.push_back(
                lg->GetRecursiveMakeCall(tmp.c_str(), localName));
            {
                std::ostringstream progCmd;
                progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start ";  // # 0
                progCmd << lg->ConvertToOutputFormat(
                    cmSystemTools::CollapseFullPath(progress.Dir),
                    cmOutputConverter::SHELL);
                progCmd << " 0";
                commands.push_back(progCmd.str());
            }
            depends.clear();
            if(regenerate)
            {
                depends.push_back("cmake_check_build_system");
            }
            localName = lg->GetRelativeTargetDirectory(gtarget);
            localName += "/rule";
            lg->WriteMakeRule(ruleFileStream,
                              "Build rule for subdir invocation for target.",
                              localName, depends, commands, true);

            // Add a target with the canonical name (no prefix, suffix or path).
            commands.clear();
            depends.clear();
            depends.push_back(localName);
            lg->WriteMakeRule(ruleFileStream, "Convenience name for target.",
                              name, depends, commands, true);

            // Add rules to prepare the target for installation.
            if(gtarget->NeedRelinkBeforeInstall(lg->GetConfigName()))
            {
                localName = lg->GetRelativeTargetDirectory(gtarget);
                localName += "/preinstall";
                depends.clear();
                commands.clear();
                commands.push_back(
                    lg->GetRecursiveMakeCall(makefileName.c_str(), localName));
                lg->WriteMakeRule(ruleFileStream,
                                  "Pre-install relink rule for target.",
                                  localName, depends, commands, true);

                if(!this->IsExcluded(this->LocalGenerators[0], gtarget))
                {
                    depends.clear();
                    depends.push_back(localName);
                    commands.clear();
                    lg->WriteMakeRule(ruleFileStream,
                                      "Prepare target for install.",
                                      "preinstall", depends, commands, true);
                }
            }

            // add the clean rule
            localName      = lg->GetRelativeTargetDirectory(gtarget);
            makeTargetName = localName;
            makeTargetName += "/clean";
            depends.clear();
            commands.clear();
            commands.push_back(
                lg->GetRecursiveMakeCall(makefileName.c_str(), makeTargetName));
            lg->WriteMakeRule(ruleFileStream, "clean rule for target.",
                              makeTargetName, depends, commands, true);
            commands.clear();
            depends.push_back(makeTargetName);
            lg->WriteMakeRule(ruleFileStream, "clean rule for target.", "clean",
                              depends, commands, true);
        }
    }
}

// Build a map that contains the set of targets used by each local
// generator directory level.
void
cmGlobalUnixMakefileGenerator3::InitializeProgressMarks()
{
    this->DirectoryTargetsMap.clear();
    // Loop over all targets in all local generators.
    for(cmLocalGenerator* lg : this->LocalGenerators)
    {
        const std::vector<cmGeneratorTarget*>& targets =
            lg->GetGeneratorTargets();
        for(cmGeneratorTarget* gt : targets)
        {
            cmLocalGenerator* tlg = gt->GetLocalGenerator();

            if(gt->GetType() == cmStateEnums::INTERFACE_LIBRARY ||
               gt->GetPropertyAsBool("EXCLUDE_FROM_ALL"))
            {
                continue;
            }

            cmStateSnapshot csnp = lg->GetStateSnapshot();
            cmStateSnapshot tsnp = tlg->GetStateSnapshot();

            // Consider the directory containing the target and all its
            // parents until something excludes the target.
            for(; csnp.IsValid() && !this->IsExcluded(csnp, tsnp);
                csnp = csnp.GetBuildsystemDirectoryParent())
            {
                // This local generator includes the target.
                std::set<cmGeneratorTarget const*>& targetSet =
                    this->DirectoryTargetsMap[csnp];
                targetSet.insert(gt);

                // Add dependencies of the included target.  An excluded
                // target may still be included if it is a dependency of a
                // non-excluded target.
                TargetDependSet const& tgtdeps =
                    this->GetTargetDirectDepends(gt);
                for(cmTargetDepend const& tgtdep : tgtdeps)
                {
                    targetSet.insert(tgtdep);
                }
            }
        }
    }
}

size_t
cmGlobalUnixMakefileGenerator3::CountProgressMarksInTarget(
    cmGeneratorTarget const*            target,
    std::set<cmGeneratorTarget const*>& emitted)
{
    size_t count = 0;
    if(emitted.insert(target).second)
    {
        count                          = this->ProgressMap[target].Marks.size();
        TargetDependSet const& depends = this->GetTargetDirectDepends(target);
        for(cmTargetDepend const& depend : depends)
        {
            if(depend->GetType() == cmStateEnums::INTERFACE_LIBRARY)
            {
                continue;
            }
            count += this->CountProgressMarksInTarget(depend, emitted);
        }
    }
    return count;
}

size_t
cmGlobalUnixMakefileGenerator3::CountProgressMarksInAll(cmLocalGenerator* lg)
{
    size_t                                    count = 0;
    std::set<cmGeneratorTarget const*>        emitted;
    std::set<cmGeneratorTarget const*> const& targets =
        this->DirectoryTargetsMap[lg->GetStateSnapshot()];
    for(cmGeneratorTarget const* target : targets)
    {
        count += this->CountProgressMarksInTarget(target, emitted);
    }
    return count;
}

void
cmGlobalUnixMakefileGenerator3::RecordTargetProgress(
    cmMakefileTargetGenerator* tg)
{
    TargetProgress& tp = this->ProgressMap[tg->GetGeneratorTarget()];
    tp.NumberOfActions = tg->GetNumberOfProgressActions();
    tp.VariableFile    = tg->GetProgressFileNameFull();
}

void
cmGlobalUnixMakefileGenerator3::TargetProgress::WriteProgressVariables(
    unsigned long total, unsigned long& current)
{
    cmGeneratedFileStream fout(this->VariableFile);
    for(unsigned long i = 1; i <= this->NumberOfActions; ++i)
    {
        fout << "CMAKE_PROGRESS_" << i << " = ";
        if(total <= 100)
        {
            unsigned long num = i + current;
            fout << num;
            this->Marks.push_back(num);
        } else if(((i + current) * 100) / total >
                  ((i - 1 + current) * 100) / total)
        {
            unsigned long num = ((i + current) * 100) / total;
            fout << num;
            this->Marks.push_back(num);
        }
        fout << "\n";
    }
    fout << "\n";
    current += this->NumberOfActions;
}

void
cmGlobalUnixMakefileGenerator3::AppendGlobalTargetDepends(
    std::vector<std::string>& depends, cmGeneratorTarget* target)
{
    TargetDependSet const& depends_set = this->GetTargetDirectDepends(target);
    for(cmTargetDepend const& i : depends_set)
    {
        // Create the target-level dependency.
        cmGeneratorTarget const* dep = i;
        if(dep->GetType() == cmStateEnums::INTERFACE_LIBRARY)
        {
            continue;
        }
        cmLocalUnixMakefileGenerator3* lg3 =
            static_cast<cmLocalUnixMakefileGenerator3*>(
                dep->GetLocalGenerator());
        std::string tgtName = lg3->GetRelativeTargetDirectory(
            const_cast<cmGeneratorTarget*>(dep));
        tgtName += "/all";
        depends.push_back(tgtName);
    }
}

void
cmGlobalUnixMakefileGenerator3::WriteHelpRule(std::ostream& ruleFileStream,
                                              cmLocalUnixMakefileGenerator3* lg)
{
    // add the help target
    std::string              path;
    std::vector<std::string> no_depends;
    std::vector<std::string> commands;
    lg->AppendEcho(commands, "The following are some of the valid targets "
                             "for this Makefile:");
    lg->AppendEcho(commands, "... all (the default if no target is provided)");
    lg->AppendEcho(commands, "... clean");
    if(!this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION"))
    {
        lg->AppendEcho(commands, "... depend");
    }

    // Keep track of targets already listed.
    std::set<std::string> emittedTargets;

    // for each local generator
    for(cmLocalGenerator* localGen : this->LocalGenerators)
    {
        cmLocalUnixMakefileGenerator3* lg2 =
            static_cast<cmLocalUnixMakefileGenerator3*>(localGen);
        // for the passed in makefile or if this is the top Makefile wripte out
        // the targets
        if(lg2 == lg || lg->IsRootMakefile())
        {
            // for each target Generate the rule files for each target.
            const std::vector<cmGeneratorTarget*>& targets =
                lg2->GetGeneratorTargets();
            for(cmGeneratorTarget* target : targets)
            {
                cmStateEnums::TargetType type = target->GetType();
                if((type == cmStateEnums::EXECUTABLE) ||
                   (type == cmStateEnums::STATIC_LIBRARY) ||
                   (type == cmStateEnums::SHARED_LIBRARY) ||
                   (type == cmStateEnums::MODULE_LIBRARY) ||
                   (type == cmStateEnums::OBJECT_LIBRARY) ||
                   (type == cmStateEnums::GLOBAL_TARGET) ||
                   (type == cmStateEnums::UTILITY))
                {
                    std::string const& name = target->GetName();
                    if(emittedTargets.insert(name).second)
                    {
                        path = "... ";
                        path += name;
                        lg->AppendEcho(commands, path);
                    }
                }
            }
        }
    }
    for(std::string const& o : lg->GetLocalHelp())
    {
        path = "... ";
        path += o;
        lg->AppendEcho(commands, path);
    }
    lg->WriteMakeRule(ruleFileStream, "Help Target", "help", no_depends,
                      commands, true);
    ruleFileStream << "\n\n";
}
