/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying

   file LICENSE.rst or https://cmake.org/licensing for details.  */

#include "cmMakefileTargetGenerator.h"

#include <algorithm>

#include <array>

#include <cassert>

#include <cstdio>

#include <functional>

#include <iterator>

#include <sstream>

#include <unordered_map>

#include <unordered_set>

#include <utility>

#include <cm/memory>

#include <cm/optional>

#include <cm/string_view>

#include <cmext/algorithm>

#include <cmext/string_view>

#include "cm_codecvt_Encoding.hxx"

#include "cmComputeLinkInformation.h"

#include "cmCustomCommand.h"

#include "cmCustomCommandGenerator.h"

#include "cmFileSetMetadata.h"

#include "cmGenExContext.h"

#include "cmGeneratedFileStream.h"

#include "cmGeneratorExpression.h"

#include "cmGeneratorFileSet.h"

#include "cmGeneratorOptions.h"

#include "cmGeneratorTarget.h"

#include "cmGlobalUnixMakefileGenerator3.h"

#include "cmLinkLineComputer.h" // IWYU pragma: keep

#include "cmList.h"

#include "cmLocalCommonGenerator.h"

#include "cmLocalGenerator.h"

#include "cmLocalUnixMakefileGenerator3.h"

#include "cmMakefile.h"

#include "cmMakefileExecutableTargetGenerator.h"

#include "cmMakefileLibraryTargetGenerator.h"

#include "cmMakefileUtilityTargetGenerator.h"

#include "cmMessageType.h"

#include "cmOutputConverter.h"

#include "cmPolicies.h"

#include "cmRange.h"

#include "cmRulePlaceholderExpander.h"

#include "cmScriptGenerator.h"

#include "cmSourceFile.h"

#include "cmSourceFileLocationKind.h"

#include "cmState.h"

#include "cmStateDirectory.h"

#include "cmStateSnapshot.h"

#include "cmStateTypes.h"

#include "cmStringAlgorithms.h"

#include "cmSystemTools.h"

#include "cmTarget.h"

#include "cmValue.h"

#include "cmake.h"

cmMakefileTargetGenerator::cmMakefileTargetGenerator(cmGeneratorTarget* target)

  : cmCommonTargetGenerator(target)

{

  this->CustomCommandDriver = OnBuild;

  this->LocalGenerator =

    static_cast<cmLocalUnixMakefileGenerator3*>(target->GetLocalGenerator());

  this->GlobalGenerator = static_cast<cmGlobalUnixMakefileGenerator3*>(

    this->LocalGenerator->GetGlobalGenerator());

  cmake* cm = this->GlobalGenerator->GetCMakeInstance();

  this->NoRuleMessages = false;

  if (cmValue ruleStatus =

        cm->GetState()->GetGlobalProperty("RULE_MESSAGES")) {

    this->NoRuleMessages = ruleStatus.IsOff();

  }

  switch (this->GeneratorTarget->GetPolicyStatusCMP0113()) {

    case cmPolicies::WARN:

      CM_FALLTHROUGH;

    case cmPolicies::OLD:

      this->CMP0113New = false;

      break;

    case cmPolicies::NEW:

      this->CMP0113New = true;

      break;

  }

  this->MacOSXContentGenerator =

    cm::make_unique<MacOSXContentGeneratorType>(this);

}

cmMakefileTargetGenerator::~cmMakefileTargetGenerator() = default;

std::unique_ptr<cmMakefileTargetGenerator> cmMakefileTargetGenerator::New(

  cmGeneratorTarget* tgt)

{

  std::unique_ptr<cmMakefileTargetGenerator> result;

  switch (tgt->GetType()) {

    case cmStateEnums::EXECUTABLE:

      result = cm::make_unique<cmMakefileExecutableTargetGenerator>(tgt);

      break;

    case cmStateEnums::STATIC_LIBRARY:

    case cmStateEnums::SHARED_LIBRARY:

    case cmStateEnums::MODULE_LIBRARY:

    case cmStateEnums::OBJECT_LIBRARY:

      result = cm::make_unique<cmMakefileLibraryTargetGenerator>(tgt);

      break;

    case cmStateEnums::INTERFACE_LIBRARY:

    case cmStateEnums::UTILITY:

      result = cm::make_unique<cmMakefileUtilityTargetGenerator>(tgt);

      break;

    default:

      return result;

      // break; /* unreachable */

  }

  return result;

}

std::string const& cmMakefileTargetGenerator::GetConfigName() const

{

  auto const& configNames = this->LocalGenerator->GetConfigNames();

  assert(configNames.size() == 1);

  return configNames.front();

}

void cmMakefileTargetGenerator::GetDeviceLinkFlags(

  std::string& linkFlags, std::string const& linkLanguage)

{

  cmGeneratorTarget::DeviceLinkSetter setter(*this->GetGeneratorTarget());

  std::vector<std::string> linkOpts;

  this->GeneratorTarget->GetLinkOptions(linkOpts, this->GetConfigName(),

                                        linkLanguage);

  this->LocalGenerator->SetLinkScriptShell(

    this->GlobalGenerator->GetUseLinkScript());

  // LINK_OPTIONS are escaped.

  this->LocalGenerator->AppendCompileOptions(linkFlags, linkOpts);

  this->LocalGenerator->SetLinkScriptShell(false);

}

void cmMakefileTargetGenerator::GetTargetLinkFlags(

  std::string& flags, std::string const& linkLanguage)

{

  this->LocalGenerator->AddTargetPropertyLinkFlags(

    flags, this->GeneratorTarget, this->GetConfigName());

  std::vector<std::string> opts;

  this->GeneratorTarget->GetLinkOptions(opts, this->GetConfigName(),

                                        linkLanguage);

  this->LocalGenerator->SetLinkScriptShell(

    this->GlobalGenerator->GetUseLinkScript());

  // LINK_OPTIONS are escaped.

  this->LocalGenerator->AppendCompileOptions(flags, opts);

  this->LocalGenerator->SetLinkScriptShell(false);

  this->LocalGenerator->AppendLinkerTypeFlags(

    flags, this->GeneratorTarget, this->GetConfigName(), linkLanguage);

  this->LocalGenerator->AppendPositionIndependentLinkerFlags(

    flags, this->GeneratorTarget, this->GetConfigName(), linkLanguage);

  this->LocalGenerator->AppendWarningAsErrorLinkerFlags(

    flags, this->GeneratorTarget, linkLanguage);

  this->LocalGenerator->AppendDependencyInfoLinkerFlags(

    flags, this->GeneratorTarget, this->GetConfigName(), linkLanguage);

}

void cmMakefileTargetGenerator::CreateRuleFile()

{

  // Create a directory for this target.

  this->TargetBuildDirectoryFull =

    this->GeneratorTarget->GetSupportDirectory();

  this->TargetBuildDirectory = this->LocalGenerator->MaybeRelativeToCurBinDir(

    this->TargetBuildDirectoryFull);

  cmSystemTools::MakeDirectory(this->TargetBuildDirectoryFull);

  // Construct the rule file name.

  this->BuildFileName = cmStrCat(this->TargetBuildDirectory, "/build.make");

  this->BuildFileNameFull =

    cmStrCat(this->TargetBuildDirectoryFull, "/build.make");

  // Construct the rule file name.

  this->ProgressFileNameFull =

    cmStrCat(this->TargetBuildDirectoryFull, "/progress.make");

  // reset the progress count

  this->NumberOfProgressActions = 0;

  // Open the rule file.  This should be copy-if-different because the

  // rules may depend on this file itself.

  this->BuildFileStream = cm::make_unique<cmGeneratedFileStream>(

    this->BuildFileNameFull, false,

    this->GlobalGenerator->GetMakefileEncoding());

  if (!this->BuildFileStream) {

    return;

  }

  this->BuildFileStream->SetCopyIfDifferent(true);

  this->LocalGenerator->WriteDisclaimer(*this->BuildFileStream);

  if (this->GlobalGenerator->AllowDeleteOnError()) {

    std::vector<std::string> no_depends;

    std::vector<std::string> no_commands;

    this->LocalGenerator->WriteMakeRule(

      *this->BuildFileStream, "Delete rule output on recipe failure.",

      ".DELETE_ON_ERROR", no_depends, no_commands, false);

  }

  this->LocalGenerator->WriteSpecialTargetsTop(*this->BuildFileStream);

}

void cmMakefileTargetGenerator::WriteTargetBuildRules()

{

  cm::GenEx::Context context(this->LocalGenerator, this->GetConfigName());

  this->GeneratorTarget->CheckCxxModuleStatus(this->GetConfigName());

  // -- Write the custom commands for this target

  // Evaluates generator expressions and expands prop_value

  auto evaluatedFiles = [this](std::string const& prop_value) -> cmList {

    cmList files{ cmGeneratorExpression::Evaluate(

      prop_value, this->LocalGenerator, this->GetConfigName(),

      this->GeneratorTarget) };

    return files;

  };

  // Look for additional files registered for cleaning in this directory.

  if (cmValue prop_value =

        this->Makefile->GetProperty("ADDITIONAL_MAKE_CLEAN_FILES")) {

    auto const files = evaluatedFiles(*prop_value);

    this->CleanFiles.insert(files.begin(), files.end());

  }

  // Look for additional files registered for cleaning in this target.

  if (cmValue prop_value =

        this->GeneratorTarget->GetProperty("ADDITIONAL_CLEAN_FILES")) {

    auto const files = evaluatedFiles(*prop_value);

    // For relative path support

    std::string const& binaryDir =

      this->LocalGenerator->GetCurrentBinaryDirectory();

    for (std::string const& cfl : files) {

      this->CleanFiles.insert(cmSystemTools::CollapseFullPath(cfl, binaryDir));

    }

  }

  // Look for ISPC extra object files generated by this target

  auto const ispcAdditionalObjs =

    this->GeneratorTarget->GetGeneratedISPCObjects(this->GetConfigName());

  for (auto const& ispcObj : ispcAdditionalObjs) {

    this->CleanFiles.insert(

      this->LocalGenerator->MaybeRelativeToCurBinDir(ispcObj.second));

  }

  // add custom commands to the clean rules?

  bool const clean = this->Makefile->GetProperty("CLEAN_NO_CUSTOM").IsOff();

  // First generate the object rule files.  Save a list of all object

  // files for this target.

  std::vector<cmSourceFile const*> customCommands;

  this->GeneratorTarget->GetCustomCommands(customCommands,

                                           this->GetConfigName());

  std::vector<std::string> codegen_depends;

  codegen_depends.reserve(customCommands.size());

  for (cmSourceFile const* sf : customCommands) {

    if (this->CMP0113New &&

        !this->LocalGenerator->GetCommandsVisited(this->GeneratorTarget)

           .insert(sf)

           .second) {

      continue;

    }

    cmCustomCommandGenerator ccg(*sf->GetCustomCommand(),

                                 this->GetConfigName(), this->LocalGenerator);

    this->GenerateCustomRuleFile(ccg);

    if (clean) {

      std::vector<std::string> const& outputs = ccg.GetOutputs();

      for (std::string const& output : outputs) {

        this->CleanFiles.insert(

          this->LocalGenerator->MaybeRelativeToCurBinDir(output));

      }

      std::vector<std::string> const& byproducts = ccg.GetByproducts();

      for (std::string const& byproduct : byproducts) {

        this->CleanFiles.insert(

          this->LocalGenerator->MaybeRelativeToCurBinDir(byproduct));

      }

    }

    if (ccg.GetCC().GetCodegen()) {

      std::string const& output = ccg.GetOutputs().front();

      // We always attach the actual commands to the first output.

      codegen_depends.emplace_back(output);

    }

  }

  // Some make tools need a special dependency for an empty rule.

  if (codegen_depends.empty()) {

    std::string hack = this->GlobalGenerator->GetEmptyRuleHackDepends();

    if (!hack.empty()) {

      codegen_depends.emplace_back(std::move(hack));

    }

  }

  // Construct the codegen target.

  {

    std::string const codegenTarget = cmStrCat(

      this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget),

      "/codegen");

    // Write the rule.

    this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, nullptr,

                                        codegenTarget, codegen_depends, {},

                                        true);

  }

  // Add byproducts from build events to the clean rules

  if (clean) {

    std::vector<cmCustomCommand> buildEventCommands =

      this->GeneratorTarget->GetPreBuildCommands();

    cm::append(buildEventCommands,

               this->GeneratorTarget->GetPreLinkCommands());

    cm::append(buildEventCommands,

               this->GeneratorTarget->GetPostBuildCommands());

    for (auto const& be : buildEventCommands) {

      cmCustomCommandGenerator beg(be, this->GetConfigName(),

                                   this->LocalGenerator);

      std::vector<std::string> const& byproducts = beg.GetByproducts();

      for (std::string const& byproduct : byproducts) {

        this->CleanFiles.insert(

          this->LocalGenerator->MaybeRelativeToCurBinDir(byproduct));

      }

    }

  }

  std::vector<cmSourceFile const*> headerSources;

  this->GeneratorTarget->GetHeaderSources(headerSources,

                                          this->GetConfigName());

  this->OSXBundleGenerator->GenerateMacOSXContentStatements(

    headerSources, this->MacOSXContentGenerator.get(), this->GetConfigName());

  std::vector<cmSourceFile const*> extraSources;

  this->GeneratorTarget->GetExtraSources(extraSources, this->GetConfigName());

  this->OSXBundleGenerator->GenerateMacOSXContentStatements(

    extraSources, this->MacOSXContentGenerator.get(), this->GetConfigName());

  cmValue pchExtension = this->Makefile->GetDefinition("CMAKE_PCH_EXTENSION");

  std::vector<cmSourceFile const*> externalObjects;

  this->GeneratorTarget->GetExternalObjects(externalObjects,

                                            this->GetConfigName());

  for (cmSourceFile const* sf : externalObjects) {

    auto const& objectFileName = sf->GetFullPath();

    if (!cmHasSuffix(objectFileName, pchExtension)) {

      this->ExternalObjects.push_back(objectFileName);

    }

  }

  std::map<std::string, std::string> file_set_map;

  auto const* tgt = this->GeneratorTarget->Target;

  for (auto const* file_set : this->GeneratorTarget->GetAllFileSets()) {

    auto files = file_set->GetFiles(context, this->GeneratorTarget).first;

    for (auto const& it : files) {

      for (auto const& filename : it.second) {

        file_set_map[filename] = file_set->GetType();

      }

    }

  }

  std::vector<cmSourceFile const*> objectSources;

  this->GeneratorTarget->GetObjectSources(objectSources,

                                          this->GetConfigName());

  // validate that all languages requested are enabled.

  std::set<std::string> requiredLangs;

  if (this->HaveRequiredLanguages(objectSources, requiredLangs)) {

    for (cmSourceFile const* sf : objectSources) {

      // Generate this object file's rule file.

      this->WriteObjectRuleFiles(*sf);

    }

  }

  for (cmSourceFile const* sf : objectSources) {

    auto const& path = sf->GetFullPath();

    auto const it = file_set_map.find(path);

    if (it != file_set_map.end()) {

      auto const& file_set_type = it->second;

      if (file_set_type == cm::FileSetMetadata::CXX_MODULES) {

        if (sf->GetLanguage() != "CXX"_s) {

          this->Makefile->IssueMessage(

            MessageType::FATAL_ERROR,

            cmStrCat(

              "Target \"", tgt->GetName(), "\" contains the source\n  ", path,

              "\nin a file set of type \"", file_set_type,

              R"(" but the source is not classified as a "CXX" source.)"));

        }

      }

    }

  }

}

void cmMakefileTargetGenerator::WriteCommonCodeRules()

{

  char const* root = (this->Makefile->IsOn("CMAKE_MAKE_INCLUDE_FROM_ROOT")

                        ? "$(CMAKE_BINARY_DIR)/"

                        : "");

  // Include the dependencies for the target.

  std::string dependFileNameFull =

    cmStrCat(this->TargetBuildDirectoryFull, "/depend.make");

  *this->BuildFileStream

    << "# Include any dependencies generated for this target.\n"

    << this->GlobalGenerator->IncludeDirective << " " << root

    << cmSystemTools::ConvertToOutputPath(

         this->LocalGenerator->MaybeRelativeToTopBinDir(dependFileNameFull))

    << "\n";

  // Scan any custom commands to check if DEPFILE option is specified

  bool ccGenerateDeps = false;

  std::vector<cmSourceFile const*> customCommands;

  this->GeneratorTarget->GetCustomCommands(customCommands,

                                           this->GetConfigName());

  for (cmSourceFile const* sf : customCommands) {

    if (!sf->GetCustomCommand()->GetDepfile().empty()) {

      ccGenerateDeps = true;

      break;

    }

  }

  std::string depsUseCompiler = "CMAKE_DEPENDS_USE_COMPILER";

  bool compilerGenerateDeps =

    this->GlobalGenerator->SupportsCompilerDependencies() &&

    (!this->Makefile->IsDefinitionSet(depsUseCompiler) ||

     this->Makefile->IsOn(depsUseCompiler));

  bool linkerGenerateDeps =

    this->GeneratorTarget->HasLinkDependencyFile(this->GetConfigName());

  if (compilerGenerateDeps || linkerGenerateDeps || ccGenerateDeps) {

    std::string const compilerDependFile =

      cmStrCat(this->TargetBuildDirectoryFull, "/compiler_depend.make");

    *this->BuildFileStream << "# Include any dependencies generated by the "

                              "compiler for this target.\n"

                           << this->GlobalGenerator->IncludeDirective << " "

                           << root

                           << cmSystemTools::ConvertToOutputPath(

                                this->LocalGenerator->MaybeRelativeToTopBinDir(

                                  compilerDependFile))

                           << "\n\n";

    // Write an empty dependency file.

    cmGeneratedFileStream depFileStream(

      compilerDependFile, false, this->GlobalGenerator->GetMakefileEncoding());

    depFileStream << "# Empty compiler generated dependencies file for "

                  << this->GeneratorTarget->GetName() << ".\n"

                  << "# This may be replaced when dependencies are built.\n";

    // remove internal dependency file

    cmSystemTools::RemoveFile(

      cmStrCat(this->TargetBuildDirectoryFull, "/compiler_depend.internal"));

    std::string compilerDependTimestamp =

      cmStrCat(this->TargetBuildDirectoryFull, "/compiler_depend.ts");

    if (!cmSystemTools::FileExists(compilerDependTimestamp)) {

      // Write a dependency timestamp file.

      cmGeneratedFileStream timestampFileStream(

        compilerDependTimestamp, false,

        this->GlobalGenerator->GetMakefileEncoding());

      timestampFileStream

        << "# CMAKE generated file: DO NOT EDIT!\n"

        << "# Timestamp file for compiler generated dependencies "

           "management for "

        << this->GeneratorTarget->GetName() << ".\n";

    }

  }

  if (compilerGenerateDeps) {

    // deactivate no longer needed legacy dependency files

    // Write an empty dependency file.

    cmGeneratedFileStream legacyDepFileStream(

      dependFileNameFull, false, this->GlobalGenerator->GetMakefileEncoding());

    legacyDepFileStream

      << "# Empty dependencies file for " << this->GeneratorTarget->GetName()

      << ".\n"

      << "# This may be replaced when dependencies are built.\n";

    // remove internal dependency file

    cmSystemTools::RemoveFile(

      cmStrCat(this->TargetBuildDirectoryFull, "/depend.internal"));

  } else {

    // make sure the depend file exists

    if (!cmSystemTools::FileExists(dependFileNameFull)) {

      // Write an empty dependency file.

      cmGeneratedFileStream depFileStream(

        dependFileNameFull, false,

        this->GlobalGenerator->GetMakefileEncoding());

      depFileStream << "# Empty dependencies file for "

                    << this->GeneratorTarget->GetName() << ".\n"

                    << "# This may be replaced when dependencies are built.\n";

    }

  }

  if (!this->NoRuleMessages) {

    // Include the progress variables for the target.

    *this->BuildFileStream

      << "# Include the progress variables for this target.\n"

      << this->GlobalGenerator->IncludeDirective << " " << root

      << cmSystemTools::ConvertToOutputPath(

           this->LocalGenerator->MaybeRelativeToTopBinDir(

             this->ProgressFileNameFull))

      << "\n\n";

  }

  // Open the flags file.  This should be copy-if-different because the

  // rules may depend on this file itself.

  this->FlagFileNameFull =

    cmStrCat(this->TargetBuildDirectoryFull, "/flags.make");

  this->FlagFileStream = cm::make_unique<cmGeneratedFileStream>(

    this->FlagFileNameFull, false,

    this->GlobalGenerator->GetMakefileEncoding());

  if (!this->FlagFileStream) {

    return;

  }

  this->FlagFileStream->SetCopyIfDifferent(true);

  this->LocalGenerator->WriteDisclaimer(*this->FlagFileStream);

  // Include the flags for the target.

  *this->BuildFileStream

    << "# Include the compile flags for this target's objects.\n"

    << this->GlobalGenerator->IncludeDirective << " " << root

    << cmSystemTools::ConvertToOutputPath(

         this->LocalGenerator->MaybeRelativeToTopBinDir(

           this->FlagFileNameFull))

    << "\n\n";

}

void cmMakefileTargetGenerator::WriteTargetLanguageFlags()

{

  // write language flags for target

  std::set<std::string> languages;

  this->GeneratorTarget->GetLanguages(

    languages, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));

  // put the compiler in the rules.make file so that if it changes

  // things rebuild

  for (std::string const& language : languages) {

    std::string compiler = cmStrCat("CMAKE_", language, "_COMPILER");

    *this->FlagFileStream << "# compile " << language << " with "

                          << this->Makefile->GetSafeDefinition(compiler)

                          << "\n";

  }

  bool const escapeOctothorpe = this->GlobalGenerator->CanEscapeOctothorpe();

  for (std::string const& language : languages) {

    std::string defines = this->GetDefines(language, this->GetConfigName());

    std::string includes = this->GetIncludes(language, this->GetConfigName());

    if (escapeOctothorpe) {

      // Escape comment characters so they do not terminate assignment.

      cmSystemTools::ReplaceString(defines, "#", "\\#");

      cmSystemTools::ReplaceString(includes, "#", "\\#");

    }

    *this->FlagFileStream << language << "_DEFINES = " << defines << "\n\n";

    *this->FlagFileStream << language << "_INCLUDES = " << includes << "\n\n";

    std::vector<std::string> architectures =

      this->GeneratorTarget->GetAppleArchs(this->GetConfigName(), language);

    architectures.emplace_back();

    for (std::string const& arch : architectures) {

      std::string flags =

        this->GetFlags(language, this->GetConfigName(), arch);

      if (escapeOctothorpe) {

        cmSystemTools::ReplaceString(flags, "#", "\\#");

      }

      *this->FlagFileStream << language << "_FLAGS" << arch << " = " << flags

                            << "\n\n";

    }

  }

}

void cmMakefileTargetGenerator::MacOSXContentGeneratorType::operator()(

  cmSourceFile const& source, char const* pkgloc, std::string const& config)

{

  // Skip OS X content when not building a Framework or Bundle.

  if (!this->Generator->GetGeneratorTarget()->IsBundleOnApple()) {

    return;

  }

  std::string macdir =

    this->Generator->OSXBundleGenerator->InitMacOSXContentDirectory(pkgloc,

                                                                    config);

  // Get the input file location.

  std::string const& input = source.GetFullPath();

  // Get the output file location.

  std::string output =

    cmStrCat(macdir, '/', cmSystemTools::GetFilenameName(input));

  this->Generator->CleanFiles.insert(

    this->Generator->LocalGenerator->MaybeRelativeToCurBinDir(output));

  output = this->Generator->LocalGenerator->MaybeRelativeToTopBinDir(output);

  // Create a rule to copy the content into the bundle.

  std::vector<std::string> depends;

  std::vector<std::string> commands;

  depends.push_back(input);

  std::string copyEcho = cmStrCat("Copying OS X content ", output);

  this->Generator->LocalGenerator->AppendEcho(

    commands, copyEcho, cmLocalUnixMakefileGenerator3::EchoBuild);

  std::string copyCommand =

    cmStrCat(cmSystemTools::FileIsDirectory(input)

               ? "$(CMAKE_COMMAND) -E copy_directory "

               : "$(CMAKE_COMMAND) -E copy ",

             this->Generator->LocalGenerator->ConvertToOutputFormat(

               input, cmOutputConverter::SHELL),

             ' ',

             this->Generator->LocalGenerator->ConvertToOutputFormat(

               output, cmOutputConverter::SHELL));

  commands.push_back(std::move(copyCommand));

  this->Generator->LocalGenerator->WriteMakeRule(

    *this->Generator->BuildFileStream, nullptr, output, depends, commands,

    false);

  this->Generator->ExtraFiles.insert(output);

}

void cmMakefileTargetGenerator::WriteObjectRuleFiles(

  cmSourceFile const& source)

{

  // Identify the language of the source file.

  std::string const& lang = source.GetLanguage();

  if (lang.empty()) {

    // don't know anything about this file so skip it

    return;

  }

  // Use compiler to generate dependencies, if supported.

  bool const compilerGenerateDeps =

    this->GlobalGenerator->SupportsCompilerDependencies() &&

    this->Makefile

      ->GetDefinition(cmStrCat("CMAKE_", lang, "_DEPENDS_USE_COMPILER"))

      .IsOn();

  auto const scanner = compilerGenerateDeps ? cmDependencyScannerKind::Compiler

                                            : cmDependencyScannerKind::CMake;

  // Get the full path name of the object file.

  std::string const& objectName =

    this->GeneratorTarget->GetObjectName(&source);

  std::string const obj =

    cmStrCat(this->TargetBuildDirectory, '/', objectName);

  // Avoid generating duplicate rules.

  if (this->ObjectFiles.find(obj) == this->ObjectFiles.end()) {

    this->ObjectFiles.insert(obj);

  } else {

    std::ostringstream err;

    err << "Warning: Source file \"" << source.GetFullPath()

        << "\" is listed multiple times for target \""

        << this->GeneratorTarget->GetName() << "\".";

    cmSystemTools::Message(err.str(), "Warning");

    return;

  }

  // Create the directory containing the object file.  This may be a

  // subdirectory under the target's directory.

  {

    std::string const dir = cmSystemTools::GetFilenamePath(obj);

    cmSystemTools::MakeDirectory(this->LocalGenerator->ConvertToFullPath(dir));

  }

  // Save this in the target's list of object files.

  this->Objects.push_back(obj);

  this->CleanFiles.insert(obj);

  std::vector<std::string> depends;

  // The object file should be checked for dependency integrity.

  std::string objFullPath =

    cmStrCat(this->LocalGenerator->GetCurrentBinaryDirectory(), '/', obj);

  std::string const srcFullPath = source.GetFullPath();

  this->LocalGenerator->AddImplicitDepends(this->GeneratorTarget, lang,

                                           objFullPath, srcFullPath, scanner);

  this->LocalGenerator->AppendRuleDepend(depends,

                                         this->FlagFileNameFull.c_str());

  this->LocalGenerator->AppendRuleDepends(depends,

                                          this->FlagFileDepends[lang]);

  // generate the depend scanning rule

  this->WriteObjectDependRules(source, depends);

  std::string const config = this->GetConfigName();

  std::string const configUpper = cmSystemTools::UpperCase(config);

  // Add precompile headers dependencies

  std::vector<std::string> pchArchs =

    this->GeneratorTarget->GetPchArchs(config, lang);

  std::string filterArch;

  std::unordered_map<std::string, std::string> pchSources;

  for (std::string const& arch : pchArchs) {

    std::string const pchSource =

      this->GeneratorTarget->GetPchSource(config, lang, arch);

    if (pchSource == source.GetFullPath()) {

      filterArch = arch;

    }

    if (!pchSource.empty()) {

      pchSources.insert(std::make_pair(pchSource, arch));

    }

  }

  if (!pchSources.empty() && !source.GetProperty("SKIP_PRECOMPILE_HEADERS")) {

    for (std::string const& arch : pchArchs) {

      std::string const& pchHeader =

        this->GeneratorTarget->GetPchHeader(config, lang, arch);

      depends.push_back(pchHeader);

      if (pchSources.find(source.GetFullPath()) == pchSources.end()) {

        depends.push_back(

          this->GeneratorTarget->GetPchFile(config, lang, arch));

      }

      this->LocalGenerator->AddImplicitDepends(

        this->GeneratorTarget, lang, objFullPath, pchHeader, scanner);

    }

  }

  if (lang != "ISPC") {

    auto const& headers =

      this->GeneratorTarget->GetGeneratedISPCHeaders(config);

    if (!headers.empty()) {

      depends.insert(depends.end(), headers.begin(), headers.end());

    }

  }

  std::string relativeObj =

    cmStrCat(this->LocalGenerator->GetHomeRelativeOutputPath(), obj);

  // Write the build rule.

  // Build the set of compiler flags.

  std::string flags;

  // Explicitly add the explicit language flag before any other flag

  // so user flags can override it.

  this->GeneratorTarget->AddExplicitLanguageFlags(flags, source);

  // Add language-specific flags.

  std::string const langFlags =

    cmStrCat("$(", lang, "_FLAGS", filterArch, ')');

  this->LocalGenerator->AppendFlags(flags, langFlags);

  cmGeneratorExpressionInterpreter genexInterpreter(

    this->LocalGenerator, config, this->GeneratorTarget, lang);

  // Add Fortran format flags.

  if (lang == "Fortran") {

    this->AppendFortranFormatFlags(flags, source);

    this->AppendFortranPreprocessFlags(flags, source);

  }

  std::string ispcHeaderRelative;

  std::string ispcHeaderForShell;

  if (lang == "ISPC") {

    std::string ispcSource =

      cmSystemTools::GetFilenameWithoutLastExtension(objectName);

    ispcSource = cmSystemTools::GetFilenameWithoutLastExtension(ispcSource);

    cmValue const ispcSuffixProp =

      this->GeneratorTarget->GetProperty("ISPC_HEADER_SUFFIX");

    assert(ispcSuffixProp);

    std::string directory = this->GeneratorTarget->GetObjectDirectory(config);

    if (cmValue prop =

          this->GeneratorTarget->GetProperty("ISPC_HEADER_DIRECTORY")) {

      directory =

        cmStrCat(this->LocalGenerator->GetBinaryDirectory(), '/', *prop);

    }

    ispcHeaderRelative = cmStrCat(directory, '/', ispcSource, *ispcSuffixProp);

    ispcHeaderForShell = this->LocalGenerator->ConvertToOutputFormat(

      ispcHeaderRelative, cmOutputConverter::SHELL);

  }

  // Add flags from source file properties.

  std::string const COMPILE_FLAGS("COMPILE_FLAGS");

  if (cmValue cflags = source.GetProperty(COMPILE_FLAGS)) {

    std::string const& evaluatedFlags =

      genexInterpreter.Evaluate(*cflags, COMPILE_FLAGS);

    this->LocalGenerator->AppendFlags(flags, evaluatedFlags);

    *this->FlagFileStream << "# Custom flags: " << relativeObj

                          << "_FLAGS = " << evaluatedFlags << "\n"

                          << "\n";

  }

  std::string const COMPILE_OPTIONS("COMPILE_OPTIONS");

  if (cmValue coptions = source.GetProperty(COMPILE_OPTIONS)) {

    std::string const& evaluatedOptions =

      genexInterpreter.Evaluate(*coptions, COMPILE_OPTIONS);

    this->LocalGenerator->AppendCompileOptions(flags, evaluatedOptions);

    *this->FlagFileStream << "# Custom options: " << relativeObj

                          << "_OPTIONS = " << evaluatedOptions << "\n"

                          << "\n";

  }

  // Add precompile headers compile options.

  if (!pchSources.empty() && !source.GetProperty("SKIP_PRECOMPILE_HEADERS")) {

    std::string pchOptions;

    auto const pchIt = pchSources.find(source.GetFullPath());

    if (pchIt != pchSources.end()) {

      pchOptions = this->GeneratorTarget->GetPchCreateCompileOptions(

        config, lang, pchIt->second);

    } else {

      pchOptions =

        this->GeneratorTarget->GetPchUseCompileOptions(config, lang);

    }

    std::string const& evaluatedFlags =

      genexInterpreter.Evaluate(pchOptions, COMPILE_OPTIONS);

    this->LocalGenerator->AppendCompileOptions(flags, evaluatedFlags);

    *this->FlagFileStream << "# PCH options: " << relativeObj

                          << "_OPTIONS = " << evaluatedFlags << "\n"

                          << "\n";

  }

  // Add include directories from source file properties.

  std::vector<std::string> includes;

  std::string const INCLUDE_DIRECTORIES("INCLUDE_DIRECTORIES");

  if (cmValue cincludes = source.GetProperty(INCLUDE_DIRECTORIES)) {

    std::string const& evaluatedIncludes =

      genexInterpreter.Evaluate(*cincludes, INCLUDE_DIRECTORIES);

    this->LocalGenerator->AppendIncludeDirectories(includes, evaluatedIncludes,

                                                   source);

    *this->FlagFileStream << "# Custom include directories: " << relativeObj

                          << "_INCLUDE_DIRECTORIES = " << evaluatedIncludes

                          << "\n"

                          << "\n";

  }

  // Add language-specific defines.

  std::set<std::string> defines;

  // Add source-specific preprocessor definitions.

  std::string const COMPILE_DEFINITIONS("COMPILE_DEFINITIONS");

  if (cmValue compile_defs = source.GetProperty(COMPILE_DEFINITIONS)) {

    std::string const& evaluatedDefs =

      genexInterpreter.Evaluate(*compile_defs, COMPILE_DEFINITIONS);

    this->LocalGenerator->AppendDefines(defines, evaluatedDefs);

    *this->FlagFileStream << "# Custom defines: " << relativeObj

                          << "_DEFINES = " << evaluatedDefs << "\n"

                          << "\n";

  }

  std::string const defPropName =

    cmStrCat("COMPILE_DEFINITIONS_", configUpper);

  if (cmValue config_compile_defs = source.GetProperty(defPropName)) {

    std::string const& evaluatedDefs =

      genexInterpreter.Evaluate(*config_compile_defs, COMPILE_DEFINITIONS);

    this->LocalGenerator->AppendDefines(defines, evaluatedDefs);

    *this->FlagFileStream << "# Custom defines: " << relativeObj << "_DEFINES_"

                          << configUpper << " = " << evaluatedDefs << "\n"

                          << "\n";

  }

  // Get the output paths for source and object files.

  std::string const sourceFile = this->LocalGenerator->ConvertToOutputFormat(

    source.GetFullPath(), cmOutputConverter::SHELL);

  // Construct the build message.

  std::vector<std::string> no_depends;

  std::vector<std::string> commands;

  // add in a progress call if needed

  this->NumberOfProgressActions++;

  if (!this->NoRuleMessages) {

    cmLocalUnixMakefileGenerator3::EchoProgress progress;

    this->MakeEchoProgress(progress);

    std::string buildEcho =

      cmStrCat("Building ", lang, " object ", relativeObj);

    this->LocalGenerator->AppendEcho(commands, buildEcho,

                                     cmLocalUnixMakefileGenerator3::EchoBuild,

                                     &progress);

  }

  std::string targetOutPathReal;

  std::string targetOutPathPDB;

  std::string targetOutPathCompilePDB;

  {

    std::string targetFullPathReal;

    std::string targetFullPathPDB;

    std::string targetFullPathCompilePDB =

      this->ComputeTargetCompilePDB(this->GetConfigName());

    if (this->GeneratorTarget->GetType() == cmStateEnums::EXECUTABLE ||

        this->GeneratorTarget->GetType() == cmStateEnums::STATIC_LIBRARY ||

        this->GeneratorTarget->GetType() == cmStateEnums::SHARED_LIBRARY ||

        this->GeneratorTarget->GetType() == cmStateEnums::MODULE_LIBRARY) {

      targetFullPathReal = this->GeneratorTarget->GetFullPath(

        this->GetConfigName(), cmStateEnums::RuntimeBinaryArtifact, true);

      targetFullPathPDB = cmStrCat(

        this->GeneratorTarget->GetPDBDirectory(this->GetConfigName()), '/',

        this->GeneratorTarget->GetPDBName(this->GetConfigName()));

    }

    targetOutPathReal = this->LocalGenerator->ConvertToOutputFormat(

      this->LocalGenerator->MaybeRelativeToCurBinDir(targetFullPathReal),

      cmOutputConverter::SHELL);

    targetOutPathPDB = this->LocalGenerator->ConvertToOutputFormat(

      targetFullPathPDB, cmOutputConverter::SHELL);

    targetOutPathCompilePDB = this->LocalGenerator->ConvertToOutputFormat(

      this->LocalGenerator->MaybeRelativeToCurBinDir(targetFullPathCompilePDB),

      cmOutputConverter::SHELL);

    if (this->LocalGenerator->IsMinGWMake() &&

        cmHasSuffix(targetOutPathCompilePDB, '\\')) {

      // mingw32-make incorrectly interprets 'a\ b c' as 'a b' and 'c'