Merge topic 'use-algorithms'

bb9d71b4 Replace loops with algorithms. 4afe6c26 cmAlgorithms: Add cmReverseRange adaptor. a3a0a8c2 cmAlgorithms: Add cmFindNot algorithm. 8c74a41f cmRST: Replace two erase with a rotate and larger erase. 61fe1919 cmAlgorithms: Update concept requirement to FowardIterator 09d6125b cmAlgorithms: Move cmRotate out of 'implementation detail' namespace. 8ed6ecac cmRST: Move two algorithms beside each other. dfe49c20 cmRST: Use std::min where appropriate. 21b0654a cmGlobalGenerator: Convert set insert algorithm to vector algorithms. 416df93a Convert some raw loops to cmWrap. 37b88d34 cmAlgorithms: Add cmWrap. a2818093 Use cmJoin where possible. 76207b08 cmCacheManager: Replace loop with algorithm. 60c3bb73 cmGlobalGenerator: Replace loop with algorithm. 05fec779 cmTarget: Port loop to algorithm. 9c225767 cmGlobalGenerator: Replace set::insert algorithm with cmRemoveDuplicates. ...
2015-02-23 10:26:38 -05:00 · 2015-02-23 10:26:38 -05:00 · cc3611023d
commit cc3611023d
parent 15c409f467 bb9d71b4fe
18 changed files with 127 additions and 213 deletions
--- a/Source/cmAlgorithms.h
+++ b/Source/cmAlgorithms.h
@ -81,6 +81,16 @@ private:
  const std::string m_test;
 };

+template<typename FwdIt>
+FwdIt cmRotate(FwdIt first, FwdIt middle, FwdIt last)
+{
+  typename std::iterator_traits<FwdIt>::difference_type dist =
+      std::distance(middle, last);
+  std::rotate(first, middle, last);
+  std::advance(first, dist);
+  return first;
+}
+
 namespace ContainerAlgorithms {

 template<typename T>
@ -138,20 +148,10 @@ private:
  const_iterator End;
 };

-template<typename BiDirIt>
-BiDirIt Rotate(BiDirIt first, BiDirIt middle, BiDirIt last)
-{
-  typename std::iterator_traits<BiDirIt>::difference_type dist =
-      std::distance(first, middle);
-  std::rotate(first, middle, last);
-  std::advance(last, -dist);
-  return last;
-}
-
 template<typename Iter>
 Iter RemoveN(Iter i1, Iter i2, size_t n)
 {
-  return ContainerAlgorithms::Rotate(i1, i1 + n, i2);
+  return cmRotate(i1, i1 + n, i2);
 }

 template<typename Range>
@ -278,4 +278,36 @@ typename Range::const_iterator cmRemoveDuplicates(Range& r)
  return cmRemoveIndices(r, indices);
 }

+template<typename Range>
+std::string cmWrap(std::string prefix, Range const& r, std::string suffix,
+                   std::string sep)
+{
+  if (r.empty())
+    {
+    return std::string();
+    }
+  return prefix + cmJoin(r, (suffix + sep + prefix).c_str()) + suffix;
+}
+
+template<typename Range>
+std::string cmWrap(char prefix, Range const& r, char suffix, std::string sep)
+{
+  return cmWrap(std::string(1, prefix), r, std::string(1, suffix), sep);
+}
+
+template<typename Range, typename T>
+typename Range::const_iterator cmFindNot(Range const& r, T const& t)
+{
+  return std::find_if(r.begin(), r.end(),
+                      std::bind1st(std::not_equal_to<T>(), t));
+}
+
+template<typename Range>
+ContainerAlgorithms::Range<typename Range::const_reverse_iterator>
+cmReverseRange(Range const& range)
+{
+  return ContainerAlgorithms::Range<typename Range::const_reverse_iterator>(
+      range.rbegin(), range.rend());
+}
+
 #endif
--- a/Source/cmCTest.cxx
+++ b/Source/cmCTest.cxx
@ -2256,10 +2256,9 @@ int cmCTest::Run(std::vector<std::string> &args, std::string* output)
  bool SRArgumentSpecified = false;

  // copy the command line
-  for(size_t i=0; i < args.size(); ++i)
-    {
-    this->InitialCommandLineArguments.push_back(args[i]);
-    }
+  this->InitialCommandLineArguments.insert(
+      this->InitialCommandLineArguments.end(),
+      args.begin(), args.end());

  // process the command line arguments
  for(size_t i=1; i < args.size(); ++i)
--- a/Source/cmCacheManager.cxx
+++ b/Source/cmCacheManager.cxx
@ -186,11 +186,7 @@ void cmCacheManager::CleanCMakeFiles(const std::string& path)
  cmsys::Glob globIt;
  globIt.FindFiles(glob);
  std::vector<std::string> files = globIt.GetFiles();
-  for(std::vector<std::string>::iterator i = files.begin();
-      i != files.end(); ++i)
-    {
-    cmSystemTools::RemoveFile(*i);
-    }
+  std::for_each(files.begin(), files.end(), cmSystemTools::RemoveFile);
 }

 bool cmCacheManager::LoadCache(const std::string& path,
--- a/Source/cmComputeLinkDepends.cxx
+++ b/Source/cmComputeLinkDepends.cxx
@ -705,10 +705,7 @@ void cmComputeLinkDepends::DisplayConstraintGraph()
    {
    EdgeList const& nl = this->EntryConstraintGraph[i];
    e << "item " << i << " is [" << this->EntryList[i].Item << "]\n";
-    for(EdgeList::const_iterator j = nl.begin(); j != nl.end(); ++j)
-      {
-      e << "  item " << *j << " must follow it\n";
-      }
+    e << cmWrap("  item ", nl, " must follow it", "\n") << "\n";
    }
  fprintf(stderr, "%s\n", e.str().c_str());
 }
--- a/Source/cmCoreTryCompile.cxx
+++ b/Source/cmCoreTryCompile.cxx
@ -260,14 +260,10 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv)
        err << "Unknown extension \"" << ext << "\" for file\n"
            << "  " << *si << "\n"
            << "try_compile() works only for enabled languages.  "
-            << "Currently these are:\n ";
+            << "Currently these are:\n  ";
        std::vector<std::string> langs;
        gg->GetEnabledLanguages(langs);
-        for(std::vector<std::string>::iterator l = langs.begin();
-            l != langs.end(); ++l)
-          {
-          err << " " << *l;
-          }
+        err << cmJoin(langs, " ");
        err << "\nSee project() command to enable other languages.";
        this->Makefile->IssueMessage(cmake::FATAL_ERROR, err.str());
        return -1;
@ -373,12 +369,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv)
    // handle any compile flags we need to pass on
    if (!compileDefs.empty())
      {
-      fprintf(fout, "add_definitions( ");
-      for (size_t i = 0; i < compileDefs.size(); ++i)
-        {
-        fprintf(fout,"%s ",compileDefs[i].c_str());
-        }
-      fprintf(fout, ")\n");
+      fprintf(fout, "add_definitions(%s)\n", cmJoin(compileDefs, " ").c_str());
      }

    /* Use a random file name to avoid rapid creation and deletion
@ -692,11 +683,9 @@ void cmCoreTryCompile::FindOutputFile(const std::string& targetName)

  std::ostringstream emsg;
  emsg << "Unable to find the executable at any of:\n";
-  for (unsigned int i = 0; i < searchDirs.size(); ++i)
-    {
-    emsg << "  " << this->BinaryDirectory << searchDirs[i]
-         << tmpOutputFile << "\n";
-    }
+  emsg << cmWrap("  " + this->BinaryDirectory,
+                 searchDirs,
+                 tmpOutputFile, "\n") << "\n";
  this->FindErrorMessage = emsg.str();
  return;
 }
--- a/Source/cmFindBase.cxx
+++ b/Source/cmFindBase.cxx
@ -351,25 +351,12 @@ void cmFindBase::PrintFindStuff()
  std::cerr << "NoCMakeSystemPath " << this->NoCMakeSystemPath << "\n";
  std::cerr << "EnvironmentPath " << this->EnvironmentPath << "\n";
  std::cerr << "CMakePathName " << this->CMakePathName << "\n";
-  std::cerr << "Names  ";
-  for(unsigned int i =0; i < this->Names.size(); ++i)
-    {
-    std::cerr << this->Names[i] << " ";
-    }
-  std::cerr << "\n";
+  std::cerr << "Names  " << cmJoin(this->Names, " ") << "\n";
  std::cerr << "\n";
  std::cerr << "SearchPathSuffixes  ";
-  for(unsigned int i =0; i < this->SearchPathSuffixes.size(); ++i)
-    {
-    std::cerr << this->SearchPathSuffixes[i] << "\n";
-    }
-  std::cerr << "\n";
+  std::cerr << cmJoin(this->SearchPathSuffixes, "\n") << "\n";
  std::cerr << "SearchPaths\n";
-  for(std::vector<std::string>::const_iterator i = this->SearchPaths.begin();
-      i != this->SearchPaths.end(); ++i)
-    {
-    std::cerr << "[" << *i << "]\n";
-    }
+  std::cerr << cmWrap("[", this->SearchPaths, "]", "\n") << "\n";
 }

 bool cmFindBase::CheckForVariableInCache()
--- a/Source/cmFindPackageCommand.cxx
+++ b/Source/cmFindPackageCommand.cxx
@ -329,10 +329,7 @@ bool cmFindPackageCommand
    {
    std::ostringstream e;
    e << "called with components that are both required and optional:\n";
-    for(unsigned int i=0; i<doubledComponents.size(); ++i)
-      {
-      e << "  " << doubledComponents[i] << "\n";
-      }
+    e << cmWrap("  ", doubledComponents, "", "\n") << "\n";
    this->SetError(e.str());
    return false;
    }
@ -808,13 +805,8 @@ bool cmFindPackageCommand::HandlePackageMode()
          {
          e << "Could not find a package configuration file provided by \""
            << this->Name << "\"" << requestedVersionString
-            << " with any of the following names:\n";
-          for(std::vector<std::string>::const_iterator ci =
-                this->Configs.begin();
-              ci != this->Configs.end(); ++ci)
-            {
-            e << "  " << *ci << "\n";
-            }
+            << " with any of the following names:\n"
+            << cmWrap("  ", this->Configs, "", "\n") << "\n";
          }

        e << "Add the installation prefix of \"" << this->Name << "\" to "
--- a/Source/cmGeneratorTarget.cxx
+++ b/Source/cmGeneratorTarget.cxx
@ -528,23 +528,22 @@ cmGeneratorTarget::UseObjectLibraries(std::vector<std::string>& objs,
  std::vector<cmSourceFile const*> objectFiles;
  this->GetExternalObjects(objectFiles, config);
  std::vector<cmTarget*> objectLibraries;
-  std::set<cmTarget*> emitted;
  for(std::vector<cmSourceFile const*>::const_iterator
      it = objectFiles.begin(); it != objectFiles.end(); ++it)
    {
    std::string objLib = (*it)->GetObjectLibrary();
    if (cmTarget* tgt = this->Makefile->FindTargetToUse(objLib))
      {
-      if (emitted.insert(tgt).second)
-        {
-        objectLibraries.push_back(tgt);
-        }
+      objectLibraries.push_back(tgt);
      }
    }

+  std::vector<cmTarget*>::const_iterator end
+      = cmRemoveDuplicates(objectLibraries);
+
  for(std::vector<cmTarget*>::const_iterator
        ti = objectLibraries.begin();
-      ti != objectLibraries.end(); ++ti)
+      ti != end; ++ti)
    {
    cmTarget* objLib = *ti;
    cmGeneratorTarget* ogt =
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@ -2295,15 +2295,8 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets)
      std::ostringstream ostr;
      if (!componentsSet->empty())
        {
-        ostr << "Available install components are:";
-        std::set<std::string>::iterator it;
-        for (
-          it = componentsSet->begin();
-          it != componentsSet->end();
-          ++ it )
-          {
-          ostr << " \"" << *it << "\"";
-          }
+        ostr << "Available install components are: ";
+        ostr << cmWrap('"', *componentsSet, '"', " ");
        }
      else
        {
@ -2571,17 +2564,12 @@ bool cmGlobalGenerator::IsReservedTarget(std::string const& name)
    "test", "RUN_TESTS",
    "package", "PACKAGE",
    "package_source",
-    "ZERO_CHECK",
-    0
+    "ZERO_CHECK"
  };

-  for(const char** reservedTarget = reservedTargets;
-    *reservedTarget; ++reservedTarget)
-    {
-    if(name == *reservedTarget) return true;
-    }
-
-  return false;
+  return std::find(cmArrayBegin(reservedTargets),
+                   cmArrayEnd(reservedTargets), name)
+      != cmArrayEnd(reservedTargets);
 }

 void cmGlobalGenerator::SetExternalMakefileProjectGenerator(
@ -2937,14 +2925,11 @@ void cmGlobalGenerator::WriteSummary(cmTarget* target)
      {
      target->GetSourceFiles(sources, *ci);
      }
-    std::set<cmSourceFile*> emitted;
+    std::vector<cmSourceFile*>::const_iterator sourcesEnd
+        = cmRemoveDuplicates(sources);
    for(std::vector<cmSourceFile*>::const_iterator si = sources.begin();
-        si != sources.end(); ++si)
+        si != sourcesEnd; ++si)
      {
-      if (!emitted.insert(*si).second)
-        {
-        continue;
-        }
      Json::Value& lj_source = lj_sources.append(Json::objectValue);
      cmSourceFile* sf = *si;
      std::string const& sfp = sf->GetFullPath();
@ -3030,7 +3015,7 @@ void cmGlobalGenerator::AddEvaluationFile(const std::string &inputFile,
 //----------------------------------------------------------------------------
 void cmGlobalGenerator::ProcessEvaluationFiles()
 {
-  std::set<std::string> generatedFiles;
+  std::vector<std::string> generatedFiles;
  for(std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator
      li = this->EvaluationFiles.begin();
      li != this->EvaluationFiles.end();
@ -3042,16 +3027,24 @@ void cmGlobalGenerator::ProcessEvaluationFiles()
      return;
      }
    std::vector<std::string> files = (*li)->GetFiles();
-    for(std::vector<std::string>::const_iterator fi = files.begin();
-        fi != files.end(); ++fi)
+    std::sort(files.begin(), files.end());
+
+    std::vector<std::string> intersection;
+    std::set_intersection(files.begin(), files.end(),
+                          generatedFiles.begin(), generatedFiles.end(),
+                          std::back_inserter(intersection));
+    if (!intersection.empty())
      {
-      if (!generatedFiles.insert(*fi).second)
-        {
-        cmSystemTools::Error("File to be generated by multiple different "
-          "commands: ", fi->c_str());
-        return;
-        }
+      cmSystemTools::Error("Files to be generated by multiple different "
+        "commands: ", cmWrap('"', intersection, '"', " ").c_str());
+      return;
      }
+
+        generatedFiles.insert(generatedFiles.end(),
+                              files.begin(), files.end());
+    std::vector<std::string>::iterator newIt =
+        generatedFiles.end() - files.size();
+    std::inplace_merge(generatedFiles.begin(), newIt, generatedFiles.end());
    }
 }

--- a/Source/cmListCommand.cxx
+++ b/Source/cmListCommand.cxx
@ -390,8 +390,7 @@ bool cmListCommand
    return false;
    }

-  std::reverse(varArgsExpanded.begin(), varArgsExpanded.end());
-  std::string value = cmJoin(varArgsExpanded, ";");
+  std::string value = cmJoin(cmReverseRange(varArgsExpanded), ";");

  this->Makefile->AddDefinition(listName, value.c_str());
  return true;
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@ -2800,12 +2800,7 @@ std::string cmLocalGenerator::ConvertToOutputFormat(const std::string& source,
      }
    if(this->WindowsShell)
      {
-      std::string::size_type pos = 0;
-      while((pos = result.find('/', pos)) != std::string::npos)
-        {
-        result[pos] = '\\';
-        pos++;
-        }
+      std::replace(result.begin(), result.end(), '/', '\\');
      }
    result = this->EscapeForShell(result, true, false, output == WATCOMQUOTE);
    }
--- a/Source/cmLocalUnixMakefileGenerator3.cxx
+++ b/Source/cmLocalUnixMakefileGenerator3.cxx
@ -724,12 +724,7 @@ cmLocalUnixMakefileGenerator3
    }

  // Write the list of commands.
-  for(std::vector<std::string>::const_iterator i = commands.begin();
-      i != commands.end(); ++i)
-    {
-    replace = *i;
-    os << "\t" << replace << "\n";
-    }
+  os << cmWrap("\t", commands, "", "\n") << "\n";
  if(symbolic && !this->WatcomWMake)
    {
    os << ".PHONY : " << cmMakeSafe(tgt) << "\n";
@ -1330,13 +1325,7 @@ cmLocalUnixMakefileGenerator3
                      this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
    fout << "\n"
         << "# Per-language clean rules from dependency scanning.\n"
-         << "foreach(lang";
-    for(std::set<std::string>::const_iterator l = languages.begin();
-        l != languages.end(); ++l)
-      {
-      fout << " " << *l;
-      }
-    fout << ")\n"
+         << "foreach(lang " << cmJoin(languages, " ") << ")\n"
         << "  include(" << this->GetTargetDirectory(target)
         << "/cmake_clean_${lang}.cmake OPTIONAL)\n"
         << "endforeach()\n";
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@ -213,13 +213,7 @@ cmMakefile::~cmMakefile()
 void cmMakefile::PrintStringVector(const char* s,
                                   const std::vector<std::string>& v) const
 {
-  std::cout << s << ": ( \n";
-  for(std::vector<std::string>::const_iterator i = v.begin();
-      i != v.end(); ++i)
-    {
-    std::cout << *i << " ";
-    }
-  std::cout << " )\n";
+  std::cout << s << ": ( \n" << cmWrap('"', v, '"', " ") << ")\n";
 }

 void cmMakefile
@ -1340,22 +1334,11 @@ void cmMakefile::AddDefineFlag(const char* flag)
 void cmMakefile::AddDefineFlag(const char* flag, std::string& dflags)
 {
  // remove any \n\r
-  std::string ret = flag;
-  std::string::size_type pos = 0;
-  while((pos = ret.find('\n', pos)) != std::string::npos)
-    {
-    ret[pos] = ' ';
-    pos++;
-    }
-  pos = 0;
-  while((pos = ret.find('\r', pos)) != std::string::npos)
-    {
-    ret[pos] = ' ';
-    pos++;
-    }
-
-  dflags += " ";
-  dflags += ret;
+  std::string::size_type initSize = dflags.size();
+  dflags += std::string(" ") + flag;
+  std::string::iterator flagStart = dflags.begin() + initSize + 1;
+  std::replace(flagStart, dflags.end(), '\n', ' ');
+  std::replace(flagStart, dflags.end(), '\r', ' ');
 }


@ -1472,18 +1455,11 @@ bool cmMakefile::ParseDefineFlag(std::string const& def, bool remove)
      cmSystemTools::ExpandListArgument(cdefs, defs);

      // Recompose the list without the definition.
-      std::string ndefs;
-      const char* sep = "";
-      for(std::vector<std::string>::const_iterator di = defs.begin();
-          di != defs.end(); ++di)
-        {
-        if(*di != define)
-          {
-          ndefs += sep;
-          sep = ";";
-          ndefs += *di;
-          }
-        }
+      std::vector<std::string>::const_iterator defEnd =
+          std::remove(defs.begin(), defs.end(), define);
+      std::vector<std::string>::const_iterator defBegin =
+          defs.begin();
+      std::string ndefs = cmJoin(cmRange(defBegin, defEnd), ";");

      // Store the new list.
      this->SetProperty("COMPILE_DEFINITIONS", ndefs.c_str());
--- a/Source/cmRST.cxx
+++ b/Source/cmRST.cxx
@ -463,10 +463,7 @@ void cmRST::UnindentLines(std::vector<std::string>& lines)
      }

    // Truncate indentation to match that on this line.
-    if(line.size() < indentEnd)
-      {
-      indentEnd = line.size();
-      }
+    indentEnd = std::min(indentEnd, line.size());
    for(std::string::size_type j = 0; j != indentEnd; ++j)
      {
      if(line[j] != indentText[j])
@ -487,19 +484,16 @@ void cmRST::UnindentLines(std::vector<std::string>& lines)
      }
    }

-  // Drop leading blank lines.
-  size_t leadingEmpty = 0;
-  for(size_t i = 0; i < lines.size() && lines[i].empty(); ++i)
-    {
-    ++leadingEmpty;
-    }
-  lines.erase(lines.begin(), lines.begin()+leadingEmpty);
+  std::vector<std::string>::const_iterator it = lines.begin();
+  size_t leadingEmpty = std::distance(it, cmFindNot(lines, std::string()));

-  // Drop trailing blank lines.
-  size_t trailingEmpty = 0;
-  for(size_t i = lines.size(); i > 0 && lines[i-1].empty(); --i)
-    {
-    ++trailingEmpty;
-    }
-  lines.erase(lines.end()-trailingEmpty, lines.end());
+  std::vector<std::string>::const_reverse_iterator rit = lines.rbegin();
+  size_t trailingEmpty = std::distance(rit,
+                            cmFindNot(cmReverseRange(lines), std::string()));
+
+  std::vector<std::string>::iterator contentEnd
+      = cmRotate(lines.begin(),
+                 lines.begin() + leadingEmpty,
+                 lines.end() - trailingEmpty);
+  lines.erase(contentEnd, lines.end());
 }
--- a/Source/cmSystemTools.cxx
+++ b/Source/cmSystemTools.cxx
@ -835,7 +835,7 @@ cmSystemTools::PrintSingleCommand(std::vector<std::string> const& command)
    return std::string();
    }

-  return "\"" + cmJoin(command, "\" \"") + "\"";
+  return cmWrap('"', command, '"', " ");
 }

 bool cmSystemTools::DoesFileExistWithExtensions(
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@ -1542,12 +1542,9 @@ void cmTarget::DeleteDependencyForVS6( DependencyMap& depMap,
  if( map_itr != depMap.end() )
    {
    DependencyList& depList = map_itr->second;
-    DependencyList::iterator itr;
-    while( (itr = std::find(depList.begin(), depList.end(), dep)) !=
-           depList.end() )
-      {
-      depList.erase( itr );
-      }
+    DependencyList::iterator begin =
+        std::remove(depList.begin(), depList.end(), dep);
+    depList.erase(begin, depList.end());
    }
 }

--- a/Source/cmcmd.cxx
+++ b/Source/cmcmd.cxx
@ -213,27 +213,14 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args)
    // Echo string
    else if (args[1] == "echo" )
      {
-      unsigned int cc;
-      const char* space = "";
-      for ( cc = 2; cc < args.size(); cc ++ )
-        {
-        std::cout << space << args[cc];
-        space = " ";
-        }
-      std::cout << std::endl;
+      std::cout << cmJoin(cmRange(args).advance(2), " ") << std::endl;
      return 0;
      }

    // Echo string no new line
    else if (args[1] == "echo_append" )
      {
-      unsigned int cc;
-      const char* space = "";
-      for ( cc = 2; cc < args.size(); cc ++ )
-        {
-        std::cout << space << args[cc];
-        space = " ";
-        }
+      std::cout << cmJoin(cmRange(args).advance(2), " ");
      return 0;
      }

@ -463,9 +450,7 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args)
        return 1;
        }

-      std::string command = "\"";
-      command += cmJoin(cmRange(args).advance(3), "\" \"");
-      command += "\"";
+      std::string command = cmWrap('"', cmRange(args).advance(3), '"', " ");
      int retval = 0;
      int timeout = 0;
      if ( cmSystemTools::RunSingleCommand(command.c_str(), 0, &retval,
@ -1329,12 +1314,7 @@ bool cmcmd::RunCommand(const char* comment,
  if(verbose)
    {
    std::cout << comment << ":\n";
-    for(std::vector<std::string>::iterator i = command.begin();
-        i != command.end(); ++i)
-      {
-      std::cout << *i << " ";
-      }
-    std::cout << "\n";
+    std::cout << cmJoin(command, " ") << "\n";
    }
  std::string output;
  int retCode =0;
--- a/Tests/RunCMake/File_Generate/CommandConflict-stderr.txt
+++ b/Tests/RunCMake/File_Generate/CommandConflict-stderr.txt
@ -1 +1 @@
-CMake Error: File to be generated by multiple different commands: .*CommandConflict-build/output_.*.txt
+CMake Error: Files to be generated by multiple different commands: ".*CommandConflict-build/output_.*.txt"