1 files changed, 63 insertions, 75 deletions

diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx
index d38dbcb..bad4112 100644
--- a/Source/cmNinjaTargetGenerator.cxx
+++ b/Source/cmNinjaTargetGenerator.cxx
@@ -8,6 +8,7 @@
 #include <assert.h>
 #include <iterator>
 #include <map>
+#include <memory> // IWYU pragma: keep
 #include <sstream>
 #include <string.h>
 
@@ -29,7 +30,6 @@
 #include "cmState.h"
 #include "cmStateTypes.h"
 #include "cmSystemTools.h"
-#include "cm_auto_ptr.hxx"
 #include "cmake.h"
 
 cmNinjaTargetGenerator* cmNinjaTargetGenerator::New(cmGeneratorTarget* target)
@@ -47,14 +47,14 @@ cmNinjaTargetGenerator* cmNinjaTargetGenerator::New(cmGeneratorTarget* target)
       return new cmNinjaUtilityTargetGenerator(target);
 
     default:
-      return CM_NULLPTR;
+      return nullptr;
   }
 }
 
 cmNinjaTargetGenerator::cmNinjaTargetGenerator(cmGeneratorTarget* target)
   : cmCommonTargetGenerator(target)
-  , MacOSXContentGenerator(CM_NULLPTR)
-  , OSXBundleGenerator(CM_NULLPTR)
+  , MacOSXContentGenerator(nullptr)
+  , OSXBundleGenerator(nullptr)
   , MacContentFolders()
   , LocalGenerator(
       static_cast<cmLocalNinjaGenerator*>(target->GetLocalGenerator()))
@@ -136,12 +136,11 @@ std::string cmNinjaTargetGenerator::ComputeFlagsForObject(
 
   // Add source file specific flags.
   if (const char* cflags = source->GetProperty("COMPILE_FLAGS")) {
-    std::string config = this->LocalGenerator->GetConfigName();
-    cmGeneratorExpression ge;
-    CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(cflags);
-    const char* evaluatedFlags = cge->Evaluate(this->LocalGenerator, config,
-                                               false, this->GeneratorTarget);
-    this->LocalGenerator->AppendFlags(flags, evaluatedFlags);
+    cmGeneratorExpressionInterpreter genexInterpreter(
+      this->LocalGenerator, this->GeneratorTarget,
+      this->LocalGenerator->GetConfigName());
+    this->LocalGenerator->AppendFlags(flags,
+                                      genexInterpreter.Evaluate(cflags));
   }
 
   return flags;
@@ -215,19 +214,16 @@ cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps() const
   if (cmGeneratorTarget::ModuleDefinitionInfo const* mdi =
         this->GeneratorTarget->GetModuleDefinitionInfo(
           this->GetConfigName())) {
-    for (std::vector<cmSourceFile const*>::const_iterator i =
-           mdi->Sources.begin();
-         i != mdi->Sources.end(); ++i) {
-      result.push_back(this->ConvertToNinjaPath((*i)->GetFullPath()));
+    for (cmSourceFile const* src : mdi->Sources) {
+      result.push_back(this->ConvertToNinjaPath(src->GetFullPath()));
     }
   }
 
   // Add a dependency on user-specified manifest files, if any.
   std::vector<cmSourceFile const*> manifest_srcs;
   this->GeneratorTarget->GetManifests(manifest_srcs, this->ConfigName);
-  for (std::vector<cmSourceFile const*>::iterator mi = manifest_srcs.begin();
-       mi != manifest_srcs.end(); ++mi) {
-    result.push_back(this->ConvertToNinjaPath((*mi)->GetFullPath()));
+  for (cmSourceFile const* manifest_src : manifest_srcs) {
+    result.push_back(this->ConvertToNinjaPath(manifest_src->GetFullPath()));
   }
 
   // Add user-specified dependencies.
@@ -428,7 +424,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
     // The explicit preprocessing step will handle dependency scanning.
   } else if (this->NeedDepTypeMSVC(lang)) {
     deptype = "msvc";
-    depfile = "";
+    depfile.clear();
     flags += " /showIncludes";
   } else if (mf->IsOn("CMAKE_NINJA_CMCLDEPS_" + lang)) {
     // For the MS resource compiler we need cmcldeps, but skip dependencies
@@ -441,7 +437,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
         : mf->GetSafeDefinition("CMAKE_CXX_COMPILER");
       cldeps = "\"";
       cldeps += cmSystemTools::GetCMClDepsCommand();
-      cldeps += "\" " + lang + " " + vars.Source + " \"$DEP_FILE\" $out \"";
+      cldeps += "\" " + lang + " " + vars.Source + " $DEP_FILE $out \"";
       cldeps += mf->GetSafeDefinition("CMAKE_CL_SHOWINCLUDES_PREFIX");
       cldeps += "\" \"" + cl + "\" ";
     }
@@ -466,7 +462,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
   vars.Flags = flags.c_str();
   vars.DependencyFile = depfile.c_str();
 
-  CM_AUTO_PTR<cmRulePlaceholderExpander> rulePlaceholderExpander(
+  std::unique_ptr<cmRulePlaceholderExpander> rulePlaceholderExpander(
     this->GetLocalGenerator()->CreateRulePlaceholderExpander());
 
   std::string const tdi = this->GetLocalGenerator()->ConvertToOutputFormat(
@@ -519,11 +515,10 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
     std::vector<std::string> ppCmds;
     cmSystemTools::ExpandListArgument(ppCmd, ppCmds);
 
-    for (std::vector<std::string>::iterator i = ppCmds.begin();
-         i != ppCmds.end(); ++i) {
-      *i = launcher + *i;
+    for (std::string& i : ppCmds) {
+      i = launcher + i;
       rulePlaceholderExpander->ExpandRuleVariables(this->GetLocalGenerator(),
-                                                   *i, ppVars);
+                                                   i, ppVars);
     }
 
     // Run CMake dependency scanner on preprocessed output.
@@ -557,17 +552,11 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
     // Write the rule for ninja dyndep file generation.
     std::vector<std::string> ddCmds;
 
-#ifdef _WIN32
-    // Windows command line length is limited -> use response file for dyndep
-    // rules
+    // Command line length is almost always limited -> use response file for
+    // dyndep rules
     std::string ddRspFile = "$out.rsp";
     std::string ddRspContent = "$in";
     std::string ddInput = "@" + ddRspFile;
-#else
-    std::string ddRspFile;
-    std::string ddRspContent;
-    std::string ddInput = "$in";
-#endif
 
     // Run CMake dependency scanner on preprocessed output.
     std::string const cmake = this->GetLocalGenerator()->ConvertToOutputFormat(
@@ -623,10 +612,13 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
     const char* tidy = this->GeneratorTarget->GetProperty(tidy_prop);
     std::string const cpplint_prop = lang + "_CPPLINT";
     const char* cpplint = this->GeneratorTarget->GetProperty(cpplint_prop);
-    if ((iwyu && *iwyu) || (tidy && *tidy) || (cpplint && *cpplint)) {
+    std::string const cppcheck_prop = lang + "_CPPCHECK";
+    const char* cppcheck = this->GeneratorTarget->GetProperty(cppcheck_prop);
+    if ((iwyu && *iwyu) || (tidy && *tidy) || (cpplint && *cpplint) ||
+        (cppcheck && *cppcheck)) {
       std::string run_iwyu = this->GetLocalGenerator()->ConvertToOutputFormat(
         cmSystemTools::GetCMakeCommand(), cmOutputConverter::SHELL);
-      run_iwyu += " -E __run_iwyu";
+      run_iwyu += " -E __run_co_compile";
       if (iwyu && *iwyu) {
         run_iwyu += " --iwyu=";
         run_iwyu += this->GetLocalGenerator()->EscapeForShell(iwyu);
@@ -639,7 +631,12 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
         run_iwyu += " --cpplint=";
         run_iwyu += this->GetLocalGenerator()->EscapeForShell(cpplint);
       }
-      if ((tidy && *tidy) || (cpplint && *cpplint)) {
+      if (cppcheck && *cppcheck) {
+        run_iwyu += " --cppcheck=";
+        run_iwyu += this->GetLocalGenerator()->EscapeForShell(cppcheck);
+      }
+      if ((tidy && *tidy) || (cpplint && *cpplint) ||
+          (cppcheck && *cppcheck)) {
         run_iwyu += " --source=$in";
       }
       run_iwyu += " -- ";
@@ -648,16 +645,15 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
   }
 
   // Maybe insert a compiler launcher like ccache or distcc
-  if (!compileCmds.empty() && (lang == "C" || lang == "CXX")) {
+  if (!compileCmds.empty() &&
+      (lang == "C" || lang == "CXX" || lang == "Fortran" || lang == "CUDA")) {
     std::string const clauncher_prop = lang + "_COMPILER_LAUNCHER";
     const char* clauncher = this->GeneratorTarget->GetProperty(clauncher_prop);
     if (clauncher && *clauncher) {
       std::vector<std::string> launcher_cmd;
       cmSystemTools::ExpandListArgument(clauncher, launcher_cmd, true);
-      for (std::vector<std::string>::iterator i = launcher_cmd.begin(),
-                                              e = launcher_cmd.end();
-           i != e; ++i) {
-        *i = this->LocalGenerator->EscapeForShell(*i);
+      for (std::string& i : launcher_cmd) {
+        i = this->LocalGenerator->EscapeForShell(i);
       }
       std::string const& run_launcher = cmJoin(launcher_cmd, " ") + " ";
       compileCmds.front().insert(0, run_launcher);
@@ -668,10 +664,9 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
     compileCmds.front().insert(0, cldeps);
   }
 
-  for (std::vector<std::string>::iterator i = compileCmds.begin();
-       i != compileCmds.end(); ++i) {
-    *i = launcher + *i;
-    rulePlaceholderExpander->ExpandRuleVariables(this->GetLocalGenerator(), *i,
+  for (std::string& i : compileCmds) {
+    i = launcher + i;
+    rulePlaceholderExpander->ExpandRuleVariables(this->GetLocalGenerator(), i,
                                                  vars);
   }
 
@@ -702,10 +697,8 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements()
   std::string config = this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
   std::vector<cmSourceFile const*> customCommands;
   this->GeneratorTarget->GetCustomCommands(customCommands, config);
-  for (std::vector<cmSourceFile const*>::const_iterator si =
-         customCommands.begin();
-       si != customCommands.end(); ++si) {
-    cmCustomCommand const* cc = (*si)->GetCustomCommand();
+  for (cmSourceFile const* sf : customCommands) {
+    cmCustomCommand const* cc = sf->GetCustomCommand();
     this->GetLocalGenerator()->AddCustomCommandTarget(
       cc, this->GetGeneratorTarget());
     // Record the custom commands for this target. The container is used
@@ -722,10 +715,8 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements()
     extraSources, this->MacOSXContentGenerator);
   std::vector<cmSourceFile const*> externalObjects;
   this->GeneratorTarget->GetExternalObjects(externalObjects, config);
-  for (std::vector<cmSourceFile const*>::const_iterator si =
-         externalObjects.begin();
-       si != externalObjects.end(); ++si) {
-    this->Objects.push_back(this->GetSourceFilePath(*si));
+  for (cmSourceFile const* sf : externalObjects) {
+    this->Objects.push_back(this->GetSourceFilePath(sf));
   }
 
   cmNinjaDeps orderOnlyDeps;
@@ -737,10 +728,7 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements()
                        this->ExtraFiles.end());
 
   // Add order-only dependencies on custom command outputs.
-  for (std::vector<cmCustomCommand const*>::const_iterator cci =
-         this->CustomCommands.begin();
-       cci != this->CustomCommands.end(); ++cci) {
-    cmCustomCommand const* cc = *cci;
+  for (cmCustomCommand const* cc : this->CustomCommands) {
     cmCustomCommandGenerator ccg(*cc, this->GetConfigName(),
                                  this->GetLocalGenerator());
     const std::vector<std::string>& ccoutputs = ccg.GetOutputs();
@@ -765,10 +753,8 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements()
   }
   std::vector<cmSourceFile const*> objectSources;
   this->GeneratorTarget->GetObjectSources(objectSources, config);
-  for (std::vector<cmSourceFile const*>::const_iterator si =
-         objectSources.begin();
-       si != objectSources.end(); ++si) {
-    this->WriteObjectBuildStatement(*si);
+  for (cmSourceFile const* sf : objectSources) {
+    this->WriteObjectBuildStatement(sf);
   }
 
   if (!this->DDIFiles.empty()) {
@@ -845,10 +831,9 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
   if (const char* objectDeps = source->GetProperty("OBJECT_DEPENDS")) {
     std::vector<std::string> depList;
     cmSystemTools::ExpandListArgument(objectDeps, depList);
-    for (std::vector<std::string>::iterator odi = depList.begin();
-         odi != depList.end(); ++odi) {
-      if (cmSystemTools::FileIsFullPath(*odi)) {
-        *odi = cmSystemTools::CollapseFullPath(*odi);
+    for (std::string& odi : depList) {
+      if (cmSystemTools::FileIsFullPath(odi)) {
+        odi = cmSystemTools::CollapseFullPath(odi);
       }
     }
     std::transform(depList.begin(), depList.end(),
@@ -896,9 +881,15 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
     // The actual compilation will now use the preprocessed source.
     explicitDeps.push_back(ppFileName);
 
-    // Preprocessing and compilation use the same flags.
+    // Preprocessing and compilation generally use the same flags.
     ppVars["FLAGS"] = vars["FLAGS"];
 
+    // In case compilation requires flags that are incompatible with
+    // preprocessing, include them here.
+    std::string const postFlag =
+      this->Makefile->GetSafeDefinition("CMAKE_Fortran_POSTPROCESS_FLAG");
+    this->LocalGenerator->AppendFlags(vars["FLAGS"], postFlag);
+
     // Move preprocessor definitions to the preprocessor build statement.
     std::swap(ppVars["DEFINES"], vars["DEFINES"]);
 
@@ -1010,19 +1001,17 @@ void cmNinjaTargetGenerator::WriteTargetDependInfo(std::string const& lang)
   std::vector<std::string> includes;
   this->LocalGenerator->GetIncludeDirectories(includes, this->GeneratorTarget,
                                               lang, this->GetConfigName());
-  for (std::vector<std::string>::iterator i = includes.begin();
-       i != includes.end(); ++i) {
+  for (std::string const& i : includes) {
     // Convert the include directories the same way we do for -I flags.
     // See upstream ninja issue 1251.
-    tdi_include_dirs.append(this->ConvertToNinjaPath(*i));
+    tdi_include_dirs.append(this->ConvertToNinjaPath(i));
   }
 
   Json::Value& tdi_linked_target_dirs = tdi["linked-target-dirs"] =
     Json::arrayValue;
   std::vector<std::string> linked = this->GetLinkedTargetDirectories();
-  for (std::vector<std::string>::iterator i = linked.begin();
-       i != linked.end(); ++i) {
-    tdi_linked_target_dirs.append(*i);
+  for (std::string const& l : linked) {
+    tdi_linked_target_dirs.append(l);
   }
 
   std::string const tdin = this->GetTargetDependInfoPath(lang);
@@ -1087,13 +1076,12 @@ void cmNinjaTargetGenerator::ExportObjectCompileCommand(
     cmSystemTools::ExpandListArgument(compileCmd, compileCmds);
   }
 
-  CM_AUTO_PTR<cmRulePlaceholderExpander> rulePlaceholderExpander(
+  std::unique_ptr<cmRulePlaceholderExpander> rulePlaceholderExpander(
     this->GetLocalGenerator()->CreateRulePlaceholderExpander());
 
-  for (std::vector<std::string>::iterator i = compileCmds.begin();
-       i != compileCmds.end(); ++i) {
+  for (std::string& i : compileCmds) {
     // no launcher for CMAKE_EXPORT_COMPILE_COMMANDS
-    rulePlaceholderExpander->ExpandRuleVariables(this->GetLocalGenerator(), *i,
+    rulePlaceholderExpander->ExpandRuleVariables(this->GetLocalGenerator(), i,
                                                  compileObjectVars);
   }