Merge topic 'clang-format-source'

d9fd2f54 Revise C++ coding style using clang-format
82df6dea Empty commit at end of history preceding clang-format style transition
6a13f43f CONTRIBUTING: Add a section on coding style
bf451d9f Add a script to run clang-format on the entire source tree
1e90d78f Configure clang-format for CMake source tree
da60adc3 Tell Git to use a distinct conflict marker size in `.rst` files

1 files changed, 631 insertions, 833 deletions

diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index a55a3f3..cb1801f 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -31,140 +31,113 @@
 #include <unistd.h>
 #endif
 
-static bool requiresMocing(const std::string& text, std::string &macroName)
+static bool requiresMocing(const std::string& text, std::string& macroName)
 {
   // this simple check is much much faster than the regexp
-  if (strstr(text.c_str(), "Q_OBJECT") == NULL
-      && strstr(text.c_str(), "Q_GADGET") == NULL)
-    {
+  if (strstr(text.c_str(), "Q_OBJECT") == NULL &&
+      strstr(text.c_str(), "Q_GADGET") == NULL) {
     return false;
-    }
+  }
 
   cmsys::RegularExpression qObjectRegExp("[\n][ \t]*Q_OBJECT[^a-zA-Z0-9_]");
-  if (qObjectRegExp.find(text))
-    {
+  if (qObjectRegExp.find(text)) {
     macroName = "Q_OBJECT";
     return true;
-    }
+  }
   cmsys::RegularExpression qGadgetRegExp("[\n][ \t]*Q_GADGET[^a-zA-Z0-9_]");
-  if (qGadgetRegExp.find(text))
-    {
+  if (qGadgetRegExp.find(text)) {
     macroName = "Q_GADGET";
     return true;
-    }
+  }
   return false;
 }
 
-
-static std::string findMatchingHeader(const std::string& absPath,
-                                      const std::string& mocSubDir,
-                                      const std::string& basename,
-                              const std::vector<std::string>& headerExtensions)
+static std::string findMatchingHeader(
+  const std::string& absPath, const std::string& mocSubDir,
+  const std::string& basename,
+  const std::vector<std::string>& headerExtensions)
 {
   std::string header;
-  for(std::vector<std::string>::const_iterator ext = headerExtensions.begin();
-      ext != headerExtensions.end();
-      ++ext)
-    {
+  for (std::vector<std::string>::const_iterator ext = headerExtensions.begin();
+       ext != headerExtensions.end(); ++ext) {
     std::string sourceFilePath = absPath + basename + "." + (*ext);
-    if (cmsys::SystemTools::FileExists(sourceFilePath.c_str()))
-      {
+    if (cmsys::SystemTools::FileExists(sourceFilePath.c_str())) {
       header = sourceFilePath;
       break;
-      }
-    if (!mocSubDir.empty())
-      {
+    }
+    if (!mocSubDir.empty()) {
       sourceFilePath = mocSubDir + basename + "." + (*ext);
-      if (cmsys::SystemTools::FileExists(sourceFilePath.c_str()))
-        {
+      if (cmsys::SystemTools::FileExists(sourceFilePath.c_str())) {
         header = sourceFilePath;
         break;
-        }
       }
     }
+  }
 
   return header;
 }
 
-
 static std::string extractSubDir(const std::string& absPath,
                                  const std::string& currentMoc)
 {
   std::string subDir;
-  if (currentMoc.find_first_of('/') != std::string::npos)
-    {
-    subDir = absPath
-                  + cmsys::SystemTools::GetFilenamePath(currentMoc) + '/';
-    }
+  if (currentMoc.find_first_of('/') != std::string::npos) {
+    subDir = absPath + cmsys::SystemTools::GetFilenamePath(currentMoc) + '/';
+  }
   return subDir;
 }
 
 cmQtAutoGenerators::cmQtAutoGenerators()
-:Verbose(cmsys::SystemTools::GetEnv("VERBOSE") != 0)
-,ColorOutput(true)
-,RunMocFailed(false)
-,RunUicFailed(false)
-,RunRccFailed(false)
-,GenerateAll(false)
+  : Verbose(cmsys::SystemTools::GetEnv("VERBOSE") != 0)
+  , ColorOutput(true)
+  , RunMocFailed(false)
+  , RunUicFailed(false)
+  , RunRccFailed(false)
+  , GenerateAll(false)
 {
 
   std::string colorEnv = "";
   cmsys::SystemTools::GetEnv("COLOR", colorEnv);
-  if(!colorEnv.empty())
-    {
-    if(cmSystemTools::IsOn(colorEnv.c_str()))
-      {
+  if (!colorEnv.empty()) {
+    if (cmSystemTools::IsOn(colorEnv.c_str())) {
       this->ColorOutput = true;
-      }
-    else
-      {
+    } else {
       this->ColorOutput = false;
-      }
     }
+  }
 }
 
-void cmQtAutoGenerators::MergeUicOptions(std::vector<std::string> &opts,
-                         const std::vector<std::string> &fileOpts,
-                         bool isQt5)
+void cmQtAutoGenerators::MergeUicOptions(
+  std::vector<std::string>& opts, const std::vector<std::string>& fileOpts,
+  bool isQt5)
 {
-  static const char* valueOptions[] = {
-    "tr",
-    "translate",
-    "postfix",
-    "generator",
-    "include", // Since Qt 5.3
-    "g"
-  };
+  static const char* valueOptions[] = { "tr",      "translate",
+                                        "postfix", "generator",
+                                        "include", // Since Qt 5.3
+                                        "g" };
   std::vector<std::string> extraOpts;
-  for(std::vector<std::string>::const_iterator it = fileOpts.begin();
-      it != fileOpts.end(); ++it)
-    {
-    std::vector<std::string>::iterator existingIt
-                                  = std::find(opts.begin(), opts.end(), *it);
-    if (existingIt != opts.end())
-      {
-      const char *o = it->c_str();
-      if (*o == '-')
-        {
+  for (std::vector<std::string>::const_iterator it = fileOpts.begin();
+       it != fileOpts.end(); ++it) {
+    std::vector<std::string>::iterator existingIt =
+      std::find(opts.begin(), opts.end(), *it);
+    if (existingIt != opts.end()) {
+      const char* o = it->c_str();
+      if (*o == '-') {
         ++o;
-        }
-      if (isQt5 && *o == '-')
-        {
+      }
+      if (isQt5 && *o == '-') {
         ++o;
-        }
+      }
       if (std::find_if(cmArrayBegin(valueOptions), cmArrayEnd(valueOptions),
-                  cmStrCmp(*it)) != cmArrayEnd(valueOptions))
-        {
+                       cmStrCmp(*it)) != cmArrayEnd(valueOptions)) {
         assert(existingIt + 1 != opts.end());
         *(existingIt + 1) = *(it + 1);
         ++it;
-        }
       }
-    else
-      {
+    } else {
       extraOpts.push_back(*it);
-      }
     }
+  }
   opts.insert(opts.end(), extraOpts.begin(), extraOpts.end());
 }
 
@@ -190,160 +163,144 @@ bool cmQtAutoGenerators::Run(const std::string& targetDirectory,
 
   this->Init();
 
-  if (this->QtMajorVersion == "4" || this->QtMajorVersion == "5")
-    {
+  if (this->QtMajorVersion == "4" || this->QtMajorVersion == "5") {
     success = this->RunAutogen(mf.get());
-    }
+  }
 
   this->WriteOldMocDefinitionsFile(targetDirectory);
 
   return success;
 }
 
-bool cmQtAutoGenerators::ReadAutogenInfoFile(cmMakefile* makefile,
-                                      const std::string& targetDirectory,
-                                      const std::string& config)
+bool cmQtAutoGenerators::ReadAutogenInfoFile(
+  cmMakefile* makefile, const std::string& targetDirectory,
+  const std::string& config)
 {
-  std::string filename(
-      cmSystemTools::CollapseFullPath(targetDirectory));
+  std::string filename(cmSystemTools::CollapseFullPath(targetDirectory));
   cmSystemTools::ConvertToUnixSlashes(filename);
   filename += "/AutogenInfo.cmake";
 
-  if (!makefile->ReadListFile(filename.c_str()))
-    {
+  if (!makefile->ReadListFile(filename.c_str())) {
     cmSystemTools::Error("Error processing file: ", filename.c_str());
     return false;
-    }
+  }
 
   this->QtMajorVersion = makefile->GetSafeDefinition("AM_QT_VERSION_MAJOR");
-  if (this->QtMajorVersion == "")
-    {
-    this->QtMajorVersion = makefile->GetSafeDefinition(
-                                     "AM_Qt5Core_VERSION_MAJOR");
-    }
+  if (this->QtMajorVersion == "") {
+    this->QtMajorVersion =
+      makefile->GetSafeDefinition("AM_Qt5Core_VERSION_MAJOR");
+  }
   this->Sources = makefile->GetSafeDefinition("AM_SOURCES");
   {
-  std::string rccSources = makefile->GetSafeDefinition("AM_RCC_SOURCES");
-  cmSystemTools::ExpandListArgument(rccSources, this->RccSources);
+    std::string rccSources = makefile->GetSafeDefinition("AM_RCC_SOURCES");
+    cmSystemTools::ExpandListArgument(rccSources, this->RccSources);
   }
   this->SkipMoc = makefile->GetSafeDefinition("AM_SKIP_MOC");
   this->SkipUic = makefile->GetSafeDefinition("AM_SKIP_UIC");
   this->Headers = makefile->GetSafeDefinition("AM_HEADERS");
-  this->IncludeProjectDirsBefore = makefile->IsOn(
-                                "AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE");
+  this->IncludeProjectDirsBefore =
+    makefile->IsOn("AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE");
   this->Srcdir = makefile->GetSafeDefinition("AM_CMAKE_CURRENT_SOURCE_DIR");
   this->Builddir = makefile->GetSafeDefinition("AM_CMAKE_CURRENT_BINARY_DIR");
   this->MocExecutable = makefile->GetSafeDefinition("AM_QT_MOC_EXECUTABLE");
   this->UicExecutable = makefile->GetSafeDefinition("AM_QT_UIC_EXECUTABLE");
   this->RccExecutable = makefile->GetSafeDefinition("AM_QT_RCC_EXECUTABLE");
   {
-  std::string compileDefsPropOrig = "AM_MOC_COMPILE_DEFINITIONS";
-  std::string compileDefsProp = compileDefsPropOrig;
-  if(!config.empty())
-    {
-    compileDefsProp += "_";
-    compileDefsProp += config;
-    }
-  const char *compileDefs = makefile->GetDefinition(compileDefsProp);
-  this->MocCompileDefinitionsStr = compileDefs ? compileDefs
-                  : makefile->GetSafeDefinition(compileDefsPropOrig);
+    std::string compileDefsPropOrig = "AM_MOC_COMPILE_DEFINITIONS";
+    std::string compileDefsProp = compileDefsPropOrig;
+    if (!config.empty()) {
+      compileDefsProp += "_";
+      compileDefsProp += config;
+    }
+    const char* compileDefs = makefile->GetDefinition(compileDefsProp);
+    this->MocCompileDefinitionsStr = compileDefs
+      ? compileDefs
+      : makefile->GetSafeDefinition(compileDefsPropOrig);
   }
   {
-  std::string includesPropOrig = "AM_MOC_INCLUDES";
-  std::string includesProp = includesPropOrig;
-  if(!config.empty())
-    {
-    includesProp += "_";
-    includesProp += config;
-    }
-  const char *includes = makefile->GetDefinition(includesProp);
-  this->MocIncludesStr = includes ? includes
-                      : makefile->GetSafeDefinition(includesPropOrig);
+    std::string includesPropOrig = "AM_MOC_INCLUDES";
+    std::string includesProp = includesPropOrig;
+    if (!config.empty()) {
+      includesProp += "_";
+      includesProp += config;
+    }
+    const char* includes = makefile->GetDefinition(includesProp);
+    this->MocIncludesStr =
+      includes ? includes : makefile->GetSafeDefinition(includesPropOrig);
   }
   this->MocOptionsStr = makefile->GetSafeDefinition("AM_MOC_OPTIONS");
   this->ProjectBinaryDir = makefile->GetSafeDefinition("AM_CMAKE_BINARY_DIR");
   this->ProjectSourceDir = makefile->GetSafeDefinition("AM_CMAKE_SOURCE_DIR");
   this->TargetName = makefile->GetSafeDefinition("AM_TARGET_NAME");
-  this->OriginTargetName
-                      = makefile->GetSafeDefinition("AM_ORIGIN_TARGET_NAME");
+  this->OriginTargetName =
+    makefile->GetSafeDefinition("AM_ORIGIN_TARGET_NAME");
 
   {
-  const char *uicOptionsFiles
-                        = makefile->GetSafeDefinition("AM_UIC_OPTIONS_FILES");
-  std::string uicOptionsPropOrig = "AM_UIC_TARGET_OPTIONS";
-  std::string uicOptionsProp = uicOptionsPropOrig;
-  if(!config.empty())
-    {
-    uicOptionsProp += "_";
-    uicOptionsProp += config;
-    }
-  const char *uicTargetOptions
-                        = makefile->GetSafeDefinition(uicOptionsProp);
-  cmSystemTools::ExpandListArgument(
+    const char* uicOptionsFiles =
+      makefile->GetSafeDefinition("AM_UIC_OPTIONS_FILES");
+    std::string uicOptionsPropOrig = "AM_UIC_TARGET_OPTIONS";
+    std::string uicOptionsProp = uicOptionsPropOrig;
+    if (!config.empty()) {
+      uicOptionsProp += "_";
+      uicOptionsProp += config;
+    }
+    const char* uicTargetOptions = makefile->GetSafeDefinition(uicOptionsProp);
+    cmSystemTools::ExpandListArgument(
       uicTargetOptions ? uicTargetOptions
-                    : makefile->GetSafeDefinition(uicOptionsPropOrig),
-    this->UicTargetOptions);
-  const char *uicOptionsOptions
-                      = makefile->GetSafeDefinition("AM_UIC_OPTIONS_OPTIONS");
-  std::vector<std::string> uicFilesVec;
-  cmSystemTools::ExpandListArgument(uicOptionsFiles, uicFilesVec);
-  std::vector<std::string> uicOptionsVec;
-  cmSystemTools::ExpandListArgument(uicOptionsOptions, uicOptionsVec);
-  if (uicFilesVec.size() != uicOptionsVec.size())
-    {
-    return false;
+                       : makefile->GetSafeDefinition(uicOptionsPropOrig),
+      this->UicTargetOptions);
+    const char* uicOptionsOptions =
+      makefile->GetSafeDefinition("AM_UIC_OPTIONS_OPTIONS");
+    std::vector<std::string> uicFilesVec;
+    cmSystemTools::ExpandListArgument(uicOptionsFiles, uicFilesVec);
+    std::vector<std::string> uicOptionsVec;
+    cmSystemTools::ExpandListArgument(uicOptionsOptions, uicOptionsVec);
+    if (uicFilesVec.size() != uicOptionsVec.size()) {
+      return false;
     }
-  for (std::vector<std::string>::iterator fileIt = uicFilesVec.begin(),
+    for (std::vector<std::string>::iterator fileIt = uicFilesVec.begin(),
                                             optionIt = uicOptionsVec.begin();
-                                            fileIt != uicFilesVec.end();
-                                            ++fileIt, ++optionIt)
-    {
-    cmSystemTools::ReplaceString(*optionIt, "@list_sep@", ";");
-    this->UicOptions[*fileIt] = *optionIt;
+         fileIt != uicFilesVec.end(); ++fileIt, ++optionIt) {
+      cmSystemTools::ReplaceString(*optionIt, "@list_sep@", ";");
+      this->UicOptions[*fileIt] = *optionIt;
     }
   }
   {
-  const char *rccOptionsFiles
-                        = makefile->GetSafeDefinition("AM_RCC_OPTIONS_FILES");
-  const char *rccOptionsOptions
-                      = makefile->GetSafeDefinition("AM_RCC_OPTIONS_OPTIONS");
-  std::vector<std::string> rccFilesVec;
-  cmSystemTools::ExpandListArgument(rccOptionsFiles, rccFilesVec);
-  std::vector<std::string> rccOptionsVec;
-  cmSystemTools::ExpandListArgument(rccOptionsOptions, rccOptionsVec);
-  if (rccFilesVec.size() != rccOptionsVec.size())
-    {
-    return false;
+    const char* rccOptionsFiles =
+      makefile->GetSafeDefinition("AM_RCC_OPTIONS_FILES");
+    const char* rccOptionsOptions =
+      makefile->GetSafeDefinition("AM_RCC_OPTIONS_OPTIONS");
+    std::vector<std::string> rccFilesVec;
+    cmSystemTools::ExpandListArgument(rccOptionsFiles, rccFilesVec);
+    std::vector<std::string> rccOptionsVec;
+    cmSystemTools::ExpandListArgument(rccOptionsOptions, rccOptionsVec);
+    if (rccFilesVec.size() != rccOptionsVec.size()) {
+      return false;
     }
-  for (std::vector<std::string>::iterator fileIt = rccFilesVec.begin(),
+    for (std::vector<std::string>::iterator fileIt = rccFilesVec.begin(),
                                             optionIt = rccOptionsVec.begin();
-                                            fileIt != rccFilesVec.end();
-                                            ++fileIt, ++optionIt)
-    {
-    cmSystemTools::ReplaceString(*optionIt, "@list_sep@", ";");
-    this->RccOptions[*fileIt] = *optionIt;
+         fileIt != rccFilesVec.end(); ++fileIt, ++optionIt) {
+      cmSystemTools::ReplaceString(*optionIt, "@list_sep@", ";");
+      this->RccOptions[*fileIt] = *optionIt;
     }
 
-  const char *rccInputs = makefile->GetSafeDefinition("AM_RCC_INPUTS");
-  std::vector<std::string> rccInputLists;
-  cmSystemTools::ExpandListArgument(rccInputs, rccInputLists);
+    const char* rccInputs = makefile->GetSafeDefinition("AM_RCC_INPUTS");
+    std::vector<std::string> rccInputLists;
+    cmSystemTools::ExpandListArgument(rccInputs, rccInputLists);
 
-  if (this->RccSources.size() != rccInputLists.size())
-    {
-    cmSystemTools::Error("Error processing file: ", filename.c_str());
-    return false;
+    if (this->RccSources.size() != rccInputLists.size()) {
+      cmSystemTools::Error("Error processing file: ", filename.c_str());
+      return false;
     }
 
-  for (std::vector<std::string>::iterator fileIt = this->RccSources.begin(),
+    for (std::vector<std::string>::iterator fileIt = this->RccSources.begin(),
                                             inputIt = rccInputLists.begin();
-                                            fileIt != this->RccSources.end();
-                                            ++fileIt, ++inputIt)
-    {
-    cmSystemTools::ReplaceString(*inputIt, "@list_sep@", ";");
-    std::vector<std::string> rccInputFiles;
-    cmSystemTools::ExpandListArgument(*inputIt, rccInputFiles);
+         fileIt != this->RccSources.end(); ++fileIt, ++inputIt) {
+      cmSystemTools::ReplaceString(*inputIt, "@list_sep@", ";");
+      std::vector<std::string> rccInputFiles;
+      cmSystemTools::ExpandListArgument(*inputIt, rccInputFiles);
 
-    this->RccInputs[*fileIt] = rccInputFiles;
+      this->RccInputs[*fileIt] = rccInputFiles;
     }
   }
   this->CurrentCompileSettingsStr = this->MakeCompileSettingsString(makefile);
@@ -353,7 +310,6 @@ bool cmQtAutoGenerators::ReadAutogenInfoFile(cmMakefile* makefile,
   return true;
 }
 
-
 std::string cmQtAutoGenerators::MakeCompileSettingsString(cmMakefile* makefile)
 {
   std::string s;
@@ -370,44 +326,36 @@ std::string cmQtAutoGenerators::MakeCompileSettingsString(cmMakefile* makefile)
   return s;
 }
 
-
-bool cmQtAutoGenerators::ReadOldMocDefinitionsFile(cmMakefile* makefile,
-                                            const std::string& targetDirectory)
+bool cmQtAutoGenerators::ReadOldMocDefinitionsFile(
+  cmMakefile* makefile, const std::string& targetDirectory)
 {
-  std::string filename(
-      cmSystemTools::CollapseFullPath(targetDirectory));
+  std::string filename(cmSystemTools::CollapseFullPath(targetDirectory));
   cmSystemTools::ConvertToUnixSlashes(filename);
   filename += "/AutomocOldMocDefinitions.cmake";
 
-  if (makefile->ReadListFile(filename.c_str()))
-    {
+  if (makefile->ReadListFile(filename.c_str())) {
     this->OldCompileSettingsStr =
-                        makefile->GetSafeDefinition("AM_OLD_COMPILE_SETTINGS");
-    }
+      makefile->GetSafeDefinition("AM_OLD_COMPILE_SETTINGS");
+  }
   return true;
 }
 
-
-void
-cmQtAutoGenerators::WriteOldMocDefinitionsFile(
-                                            const std::string& targetDirectory)
+void cmQtAutoGenerators::WriteOldMocDefinitionsFile(
+  const std::string& targetDirectory)
 {
-  std::string filename(
-      cmSystemTools::CollapseFullPath(targetDirectory));
+  std::string filename(cmSystemTools::CollapseFullPath(targetDirectory));
   cmSystemTools::ConvertToUnixSlashes(filename);
   filename += "/AutomocOldMocDefinitions.cmake";
 
   cmsys::ofstream outfile;
-  outfile.open(filename.c_str(),
-               std::ios::trunc);
+  outfile.open(filename.c_str(), std::ios::trunc);
   outfile << "set(AM_OLD_COMPILE_SETTINGS "
-              << cmOutputConverter::EscapeForCMake(
-                 this->CurrentCompileSettingsStr) << ")\n";
+          << cmOutputConverter::EscapeForCMake(this->CurrentCompileSettingsStr)
+          << ")\n";
 
   outfile.close();
 }
 
-
 void cmQtAutoGenerators::Init()
 {
   this->TargetBuildSubDir = this->TargetName;
@@ -419,12 +367,10 @@ void cmQtAutoGenerators::Init()
 
   std::vector<std::string> cdefList;
   cmSystemTools::ExpandListArgument(this->MocCompileDefinitionsStr, cdefList);
-  for(std::vector<std::string>::const_iterator it = cdefList.begin();
-      it != cdefList.end();
-      ++it)
-    {
+  for (std::vector<std::string>::const_iterator it = cdefList.begin();
+       it != cdefList.end(); ++it) {
     this->MocDefinitions.push_back("-D" + (*it));
-    }
+  }
 
   cmSystemTools::ExpandListArgument(this->MocOptionsStr, this->MocOptions);
 
@@ -432,69 +378,55 @@ void cmQtAutoGenerators::Init()
   cmSystemTools::ExpandListArgument(this->MocIncludesStr, incPaths);
 
   std::set<std::string> frameworkPaths;
-  for(std::vector<std::string>::const_iterator it = incPaths.begin();
-      it != incPaths.end();
-      ++it)
-    {
-    const std::string &path = *it;
+  for (std::vector<std::string>::const_iterator it = incPaths.begin();
+       it != incPaths.end(); ++it) {
+    const std::string& path = *it;
     this->MocIncludes.push_back("-I" + path);
-    if (cmHasLiteralSuffix(path, ".framework/Headers"))
-      {
+    if (cmHasLiteralSuffix(path, ".framework/Headers")) {
       // Go up twice to get to the framework root
       std::vector<std::string> pathComponents;
       cmsys::SystemTools::SplitPath(path, pathComponents);
-      std::string frameworkPath =cmsys::SystemTools::JoinPath(
-                             pathComponents.begin(), pathComponents.end() - 2);
+      std::string frameworkPath = cmsys::SystemTools::JoinPath(
+        pathComponents.begin(), pathComponents.end() - 2);
       frameworkPaths.insert(frameworkPath);
-      }
     }
+  }
 
   for (std::set<std::string>::const_iterator it = frameworkPaths.begin();
-         it != frameworkPaths.end(); ++it)
-    {
+       it != frameworkPaths.end(); ++it) {
     this->MocIncludes.push_back("-F");
     this->MocIncludes.push_back(*it);
-    }
-
+  }
 
-    if (this->IncludeProjectDirsBefore)
-      {
-      const std::string binDir = "-I" + this->ProjectBinaryDir;
+  if (this->IncludeProjectDirsBefore) {
+    const std::string binDir = "-I" + this->ProjectBinaryDir;
 
-      const std::string srcDir = "-I" + this->ProjectSourceDir;
+    const std::string srcDir = "-I" + this->ProjectSourceDir;
 
-      std::list<std::string> sortedMocIncludes;
-      std::list<std::string>::iterator it = this->MocIncludes.begin();
-      while (it != this->MocIncludes.end())
-        {
-        if (cmsys::SystemTools::StringStartsWith(*it, binDir.c_str()))
-          {
-          sortedMocIncludes.push_back(*it);
-          it = this->MocIncludes.erase(it);
-          }
-        else
-          {
-          ++it;
-          }
-        }
-      it = this->MocIncludes.begin();
-      while (it != this->MocIncludes.end())
-        {
-        if (cmsys::SystemTools::StringStartsWith(*it, srcDir.c_str()))
-          {
-          sortedMocIncludes.push_back(*it);
-          it = this->MocIncludes.erase(it);
-          }
-        else
-          {
-          ++it;
-          }
-        }
-      sortedMocIncludes.insert(sortedMocIncludes.end(),
-                           this->MocIncludes.begin(), this->MocIncludes.end());
-      this->MocIncludes = sortedMocIncludes;
+    std::list<std::string> sortedMocIncludes;
+    std::list<std::string>::iterator it = this->MocIncludes.begin();
+    while (it != this->MocIncludes.end()) {
+      if (cmsys::SystemTools::StringStartsWith(*it, binDir.c_str())) {
+        sortedMocIncludes.push_back(*it);
+        it = this->MocIncludes.erase(it);
+      } else {
+        ++it;
+      }
     }
-
+    it = this->MocIncludes.begin();
+    while (it != this->MocIncludes.end()) {
+      if (cmsys::SystemTools::StringStartsWith(*it, srcDir.c_str())) {
+        sortedMocIncludes.push_back(*it);
+        it = this->MocIncludes.erase(it);
+      } else {
+        ++it;
+      }
+    }
+    sortedMocIncludes.insert(sortedMocIncludes.end(),
+                             this->MocIncludes.begin(),
+                             this->MocIncludes.end());
+    this->MocIncludes = sortedMocIncludes;
+  }
 }
 
 static std::string ReadAll(const std::string& filename)
@@ -508,11 +440,10 @@ static std::string ReadAll(const std::string& filename)
 
 bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile)
 {
-  if (!cmsys::SystemTools::FileExists(this->OutMocCppFilenameAbs.c_str())
-    || (this->OldCompileSettingsStr != this->CurrentCompileSettingsStr))
-    {
+  if (!cmsys::SystemTools::FileExists(this->OutMocCppFilenameAbs.c_str()) ||
+      (this->OldCompileSettingsStr != this->CurrentCompileSettingsStr)) {
     this->GenerateAll = true;
-    }
+  }
 
   // the program goes through all .cpp files to see which moc files are
   // included. It is not really interesting how the moc file is named, but
@@ -531,7 +462,7 @@ bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile)
   cmSystemTools::ExpandListArgument(this->Sources, sourceFiles);
 
   const std::vector<std::string>& headerExtensions =
-      makefile->GetCMakeInstance()->GetHeaderExtensions();
+    makefile->GetCMakeInstance()->GetHeaderExtensions();
 
   std::map<std::string, std::vector<std::string> > includedUis;
   std::map<std::string, std::vector<std::string> > skippedUis;
@@ -539,51 +470,40 @@ bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile)
   cmSystemTools::ExpandListArgument(this->SkipUic, uicSkipped);
 
   for (std::vector<std::string>::const_iterator it = sourceFiles.begin();
-       it != sourceFiles.end();
-       ++it)
-    {
-    const bool skipUic = std::find(uicSkipped.begin(), uicSkipped.end(), *it)
-        != uicSkipped.end();
-    std::map<std::string, std::vector<std::string> >& uiFiles
-                                          = skipUic ? skippedUis : includedUis;
-    const std::string &absFilename = *it;
-    if (this->Verbose)
-      {
+       it != sourceFiles.end(); ++it) {
+    const bool skipUic =
+      std::find(uicSkipped.begin(), uicSkipped.end(), *it) != uicSkipped.end();
+    std::map<std::string, std::vector<std::string> >& uiFiles =
+      skipUic ? skippedUis : includedUis;
+    const std::string& absFilename = *it;
+    if (this->Verbose) {
       std::stringstream err;
       err << "AUTOGEN: Checking " << absFilename << std::endl;
       this->LogInfo(err.str());
-      }
-    if (this->RelaxedMode)
-      {
-      this->ParseCppFile(absFilename, headerExtensions, includedMocs,
-                         uiFiles);
-      }
-    else
-      {
+    }
+    if (this->RelaxedMode) {
+      this->ParseCppFile(absFilename, headerExtensions, includedMocs, uiFiles);
+    } else {
       this->StrictParseCppFile(absFilename, headerExtensions, includedMocs,
                                uiFiles);
-      }
-    this->SearchHeadersForCppFile(absFilename, headerExtensions, headerFiles);
     }
+    this->SearchHeadersForCppFile(absFilename, headerExtensions, headerFiles);
+  }
 
   {
-  std::vector<std::string> mocSkipped;
-  cmSystemTools::ExpandListArgument(this->SkipMoc, mocSkipped);
-  for (std::vector<std::string>::const_iterator it = mocSkipped.begin();
-       it != mocSkipped.end();
-       ++it)
-    {
-    if (std::find(uicSkipped.begin(), uicSkipped.end(), *it)
-        != uicSkipped.end())
-      {
-      const std::string &absFilename = *it;
-      if (this->Verbose)
-        {
-        std::stringstream err;
-        err << "AUTOGEN: Checking " << absFilename << std::endl;
-        this->LogInfo(err.str());
+    std::vector<std::string> mocSkipped;
+    cmSystemTools::ExpandListArgument(this->SkipMoc, mocSkipped);
+    for (std::vector<std::string>::const_iterator it = mocSkipped.begin();
+         it != mocSkipped.end(); ++it) {
+      if (std::find(uicSkipped.begin(), uicSkipped.end(), *it) !=
+          uicSkipped.end()) {
+        const std::string& absFilename = *it;
+        if (this->Verbose) {
+          std::stringstream err;
+          err << "AUTOGEN: Checking " << absFilename << std::endl;
+          this->LogInfo(err.str());
         }
-      this->ParseForUic(absFilename, includedUis);
+        this->ParseForUic(absFilename, includedUis);
       }
     }
   }
@@ -596,70 +516,66 @@ bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile)
   std::map<std::string, std::string> notIncludedMocs;
   this->ParseHeaders(headerFiles, includedMocs, notIncludedMocs, includedUis);
 
-  if(!this->MocExecutable.empty())
-    {
-    this->GenerateMocFiles ( includedMocs, notIncludedMocs );
-    }
-  if(!this->UicExecutable.empty())
-    {
-    this->GenerateUiFiles ( includedUis );
-    }
-  if(!this->RccExecutable.empty())
-    {
+  if (!this->MocExecutable.empty()) {
+    this->GenerateMocFiles(includedMocs, notIncludedMocs);
+  }
+  if (!this->UicExecutable.empty()) {
+    this->GenerateUiFiles(includedUis);
+  }
+  if (!this->RccExecutable.empty()) {
     this->GenerateQrcFiles();
-    }
+  }
 
-  if (this->RunMocFailed)
-    {
-    std::stringstream err; err << "moc failed..." << std::endl;
+  if (this->RunMocFailed) {
+    std::stringstream err;
+    err << "moc failed..." << std::endl;
     this->LogError(err.str());
     return false;
-    }
-  if (this->RunUicFailed)
-    {
-    std::stringstream err; err << "uic failed..." << std::endl;
+  }
+  if (this->RunUicFailed) {
+    std::stringstream err;
+    err << "uic failed..." << std::endl;
     this->LogError(err.str());
     return false;
-    }
-  if (this->RunRccFailed)
-    {
-    std::stringstream err; err << "rcc failed..." << std::endl;
+  }
+  if (this->RunRccFailed) {
+    std::stringstream err;
+    err << "rcc failed..." << std::endl;
     this->LogError(err.str());
     return false;
-    }
+  }
 
   return true;
 }
 
-
-void cmQtAutoGenerators::ParseCppFile(const std::string& absFilename,
-                const std::vector<std::string>& headerExtensions,
-                std::map<std::string, std::string>& includedMocs,
-                std::map<std::string, std::vector<std::string> > &includedUis)
+void cmQtAutoGenerators::ParseCppFile(
+  const std::string& absFilename,
+  const std::vector<std::string>& headerExtensions,
+  std::map<std::string, std::string>& includedMocs,
+  std::map<std::string, std::vector<std::string> >& includedUis)
 {
   cmsys::RegularExpression mocIncludeRegExp(
-              "[\n][ \t]*#[ \t]*include[ \t]+"
-              "[\"<](([^ \">]+/)?moc_[^ \">/]+\\.cpp|[^ \">]+\\.moc)[\">]");
+    "[\n][ \t]*#[ \t]*include[ \t]+"
+    "[\"<](([^ \">]+/)?moc_[^ \">/]+\\.cpp|[^ \">]+\\.moc)[\">]");
 
   const std::string contentsString = ReadAll(absFilename);
-  if (contentsString.empty())
-    {
+  if (contentsString.empty()) {
     std::stringstream err;
     err << "AUTOGEN: warning: " << absFilename << ": file is empty\n"
         << std::endl;
     this->LogError(err.str());
     return;
-    }
+  }
   this->ParseForUic(absFilename, contentsString, includedUis);
-  if (this->MocExecutable.empty())
-    {
+  if (this->MocExecutable.empty()) {
     return;
-    }
+  }
 
   const std::string absPath = cmsys::SystemTools::GetFilenamePath(
-                   cmsys::SystemTools::GetRealPath(absFilename)) + '/';
-  const std::string scannedFileBasename = cmsys::SystemTools::
-                                  GetFilenameWithoutLastExtension(absFilename);
+                                cmsys::SystemTools::GetRealPath(absFilename)) +
+    '/';
+  const std::string scannedFileBasename =
+    cmsys::SystemTools::GetFilenameWithoutLastExtension(absFilename);
   std::string macroName;
   const bool requiresMoc = requiresMocing(contentsString, macroName);
   bool dotMocIncluded = false;
@@ -672,16 +588,14 @@ void cmQtAutoGenerators::ParseCppFile(const std::string& absFilename,
   // first a simple string check for "moc" is *much* faster than the regexp,
   // and if the string search already fails, we don't have to try the
   // expensive regexp
-  if ((strstr(contentsString.c_str(), "moc") != NULL)
-                                    && (mocIncludeRegExp.find(contentsString)))
-    {
+  if ((strstr(contentsString.c_str(), "moc") != NULL) &&
+      (mocIncludeRegExp.find(contentsString))) {
     // for every moc include in the file
-    do
-      {
+    do {
       const std::string currentMoc = mocIncludeRegExp.match(1);
 
-      std::string basename = cmsys::SystemTools::
-                                   GetFilenameWithoutLastExtension(currentMoc);
+      std::string basename =
+        cmsys::SystemTools::GetFilenameWithoutLastExtension(currentMoc);
       const bool moc_style = cmHasLiteralPrefix(basename, "moc_");
 
       // If the moc include is of the moc_foo.cpp style we expect
@@ -690,178 +604,160 @@ void cmQtAutoGenerators::ParseCppFile(const std::string& absFilename,
       // a Q_OBJECT macro in the current source file, if it contains the
       // macro we generate the moc file from the source file.
       // Q_OBJECT
-      if (moc_style)
-        {
+      if (moc_style) {
         // basename should be the part of the moc filename used for
         // finding the correct header, so we need to remove the moc_ part
         basename = basename.substr(4);
         std::string mocSubDir = extractSubDir(absPath, currentMoc);
-        std::string headerToMoc = findMatchingHeader(
-                               absPath, mocSubDir, basename, headerExtensions);
+        std::string headerToMoc =
+          findMatchingHeader(absPath, mocSubDir, basename, headerExtensions);
 
-        if (!headerToMoc.empty())
-          {
+        if (!headerToMoc.empty()) {
           includedMocs[headerToMoc] = currentMoc;
-          if (basename == scannedFileBasename)
-            {
+          if (basename == scannedFileBasename) {
             mocUnderscoreIncluded = true;
             ownMocUnderscoreFile = currentMoc;
             ownMocHeaderFile = headerToMoc;
-            }
           }
-        else
-          {
+        } else {
           std::stringstream err;
           err << "AUTOGEN: error: " << absFilename << ": The file "
               << "includes the moc file \"" << currentMoc << "\", "
-              << "but could not find header \"" << basename
-              << '{' << this->JoinExts(headerExtensions) << "}\" ";
-          if (mocSubDir.empty())
-            {
+              << "but could not find header \"" << basename << '{'
+              << this->JoinExts(headerExtensions) << "}\" ";
+          if (mocSubDir.empty()) {
             err << "in " << absPath << "\n" << std::endl;
-            }
-          else
-            {
-            err << "neither in " << absPath
-                << " nor in " << mocSubDir << "\n" << std::endl;
-            }
+          } else {
+            err << "neither in " << absPath << " nor in " << mocSubDir << "\n"
+                << std::endl;
+          }
           this->LogError(err.str());
           ::exit(EXIT_FAILURE);
-          }
         }
-      else
-        {
+      } else {
         std::string fileToMoc = absFilename;
-        if ((basename != scannedFileBasename) || (requiresMoc==false))
-          {
+        if ((basename != scannedFileBasename) || (requiresMoc == false)) {
           std::string mocSubDir = extractSubDir(absPath, currentMoc);
-          std::string headerToMoc = findMatchingHeader(
-                              absPath, mocSubDir, basename, headerExtensions);
-          if (!headerToMoc.empty())
-            {
+          std::string headerToMoc =
+            findMatchingHeader(absPath, mocSubDir, basename, headerExtensions);
+          if (!headerToMoc.empty()) {
             // this is for KDE4 compatibility:
             fileToMoc = headerToMoc;
-            if ((requiresMoc==false) &&(basename==scannedFileBasename))
-              {
+            if ((requiresMoc == false) && (basename == scannedFileBasename)) {
               std::stringstream err;
-              err << "AUTOGEN: warning: " << absFilename << ": The file "
-                     "includes the moc file \"" << currentMoc <<
-                     "\", but does not contain a " << macroName
+              err << "AUTOGEN: warning: " << absFilename
+                  << ": The file "
+                     "includes the moc file \""
+                  << currentMoc << "\", but does not contain a " << macroName
                   << " macro. Running moc on "
-                  << "\"" << headerToMoc << "\" ! Include \"moc_"
-                  << basename << ".cpp\" for a compatibility with "
+                  << "\"" << headerToMoc << "\" ! Include \"moc_" << basename
+                  << ".cpp\" for a compatibility with "
                      "strict mode (see CMAKE_AUTOMOC_RELAXED_MODE).\n"
                   << std::endl;
               this->LogError(err.str());
-              }
-            else
-              {
+            } else {
               std::stringstream err;
-              err << "AUTOGEN: warning: " << absFilename << ": The file "
-                     "includes the moc file \"" << currentMoc <<
-                     "\" instead of \"moc_" << basename << ".cpp\". "
+              err << "AUTOGEN: warning: " << absFilename
+                  << ": The file "
+                     "includes the moc file \""
+                  << currentMoc << "\" instead of \"moc_" << basename
+                  << ".cpp\". "
                      "Running moc on "
-                  << "\"" << headerToMoc << "\" ! Include \"moc_"
-                  << basename << ".cpp\" for compatibility with "
+                  << "\"" << headerToMoc << "\" ! Include \"moc_" << basename
+                  << ".cpp\" for compatibility with "
                      "strict mode (see CMAKE_AUTOMOC_RELAXED_MODE).\n"
                   << std::endl;
               this->LogError(err.str());
-              }
             }
-          else
-            {
+          } else {
             std::stringstream err;
-            err << "AUTOGEN: error: " << absFilename << ": The file "
-                   "includes the moc file \"" << currentMoc <<
-                   "\", which seems to be the moc file from a different "
+            err << "AUTOGEN: error: " << absFilename
+                << ": The file "
+                   "includes the moc file \""
+                << currentMoc
+                << "\", which seems to be the moc file from a different "
                    "source file. CMake also could not find a matching "
-                   "header.\n" << std::endl;
+                   "header.\n"
+                << std::endl;
             this->LogError(err.str());
             ::exit(EXIT_FAILURE);
-            }
           }
-        else
-          {
+        } else {
           dotMocIncluded = true;
           ownDotMocFile = currentMoc;
-          }
-        includedMocs[fileToMoc] = currentMoc;
         }
+        includedMocs[fileToMoc] = currentMoc;
+      }
       matchOffset += mocIncludeRegExp.end();
-      } while(mocIncludeRegExp.find(contentsString.c_str() + matchOffset));
-    }
+    } while (mocIncludeRegExp.find(contentsString.c_str() + matchOffset));
+  }
 
   // In this case, check whether the scanned file itself contains a Q_OBJECT.
   // If this is the case, the moc_foo.cpp should probably be generated from
   // foo.cpp instead of foo.h, because otherwise it won't build.
   // But warn, since this is not how it is supposed to be used.
-  if ((dotMocIncluded == false) && (requiresMoc == true))
-    {
-    if (mocUnderscoreIncluded == true)
-      {
+  if ((dotMocIncluded == false) && (requiresMoc == true)) {
+    if (mocUnderscoreIncluded == true) {
       // this is for KDE4 compatibility:
       std::stringstream err;
       err << "AUTOGEN: warning: " << absFilename << ": The file "
           << "contains a " << macroName << " macro, but does not "
-             "include "
+                                           "include "
           << "\"" << scannedFileBasename << ".moc\", but instead "
-             "includes "
-          << "\"" << ownMocUnderscoreFile  << "\". Running moc on "
+                                            "includes "
+          << "\"" << ownMocUnderscoreFile << "\". Running moc on "
           << "\"" << absFilename << "\" ! Better include \""
-          << scannedFileBasename << ".moc\" for compatibility with "
+          << scannedFileBasename
+          << ".moc\" for compatibility with "
              "strict mode (see CMAKE_AUTOMOC_RELAXED_MODE).\n"
           << std::endl;
       this->LogError(err.str());
 
       includedMocs[absFilename] = ownMocUnderscoreFile;
       includedMocs.erase(ownMocHeaderFile);
-      }
-    else
-      {
+    } else {
       // otherwise always error out since it will not compile:
       std::stringstream err;
       err << "AUTOGEN: error: " << absFilename << ": The file "
           << "contains a " << macroName << " macro, but does not "
-             "include "
+                                           "include "
           << "\"" << scannedFileBasename << ".moc\" !\n"
           << std::endl;
       this->LogError(err.str());
 
       ::exit(EXIT_FAILURE);
-      }
     }
-
+  }
 }
 
-
-void cmQtAutoGenerators::StrictParseCppFile(const std::string& absFilename,
-                const std::vector<std::string>& headerExtensions,
-                std::map<std::string, std::string>& includedMocs,
-                std::map<std::string, std::vector<std::string> >& includedUis)
+void cmQtAutoGenerators::StrictParseCppFile(
+  const std::string& absFilename,
+  const std::vector<std::string>& headerExtensions,
+  std::map<std::string, std::string>& includedMocs,
+  std::map<std::string, std::vector<std::string> >& includedUis)
 {
   cmsys::RegularExpression mocIncludeRegExp(
-              "[\n][ \t]*#[ \t]*include[ \t]+"
-              "[\"<](([^ \">]+/)?moc_[^ \">/]+\\.cpp|[^ \">]+\\.moc)[\">]");
+    "[\n][ \t]*#[ \t]*include[ \t]+"
+    "[\"<](([^ \">]+/)?moc_[^ \">/]+\\.cpp|[^ \">]+\\.moc)[\">]");
 
   const std::string contentsString = ReadAll(absFilename);
-  if (contentsString.empty())
-    {
+  if (contentsString.empty()) {
     std::stringstream err;
     err << "AUTOGEN: warning: " << absFilename << ": file is empty\n"
         << std::endl;
     this->LogError(err.str());
     return;
-    }
+  }
   this->ParseForUic(absFilename, contentsString, includedUis);
-  if (this->MocExecutable.empty())
-    {
+  if (this->MocExecutable.empty()) {
     return;
-    }
+  }
 
   const std::string absPath = cmsys::SystemTools::GetFilenamePath(
-                   cmsys::SystemTools::GetRealPath(absFilename)) + '/';
-  const std::string scannedFileBasename = cmsys::SystemTools::
-                                  GetFilenameWithoutLastExtension(absFilename);
+                                cmsys::SystemTools::GetRealPath(absFilename)) +
+    '/';
+  const std::string scannedFileBasename =
+    cmsys::SystemTools::GetFilenameWithoutLastExtension(absFilename);
 
   bool dotMocIncluded = false;
 
@@ -869,16 +765,14 @@ void cmQtAutoGenerators::StrictParseCppFile(const std::string& absFilename,
   // first a simple string check for "moc" is *much* faster than the regexp,
   // and if the string search already fails, we don't have to try the
   // expensive regexp
-  if ((strstr(contentsString.c_str(), "moc") != NULL)
-                                    && (mocIncludeRegExp.find(contentsString)))
-    {
+  if ((strstr(contentsString.c_str(), "moc") != NULL) &&
+      (mocIncludeRegExp.find(contentsString))) {
     // for every moc include in the file
-    do
-      {
+    do {
       const std::string currentMoc = mocIncludeRegExp.match(1);
 
-      std::string basename = cmsys::SystemTools::
-                                   GetFilenameWithoutLastExtension(currentMoc);
+      std::string basename =
+        cmsys::SystemTools::GetFilenameWithoutLastExtension(currentMoc);
       const bool mocUnderscoreStyle = cmHasLiteralPrefix(basename, "moc_");
 
       // If the moc include is of the moc_foo.cpp style we expect
@@ -886,68 +780,61 @@ void cmQtAutoGenerators::StrictParseCppFile(const std::string& absFilename,
       // If the moc include is of the foo.moc style we need to look for
       // a Q_OBJECT macro in the current source file, if it contains the
       // macro we generate the moc file from the source file.
-      if (mocUnderscoreStyle)
-        {
+      if (mocUnderscoreStyle) {
         // basename should be the part of the moc filename used for
         // finding the correct header, so we need to remove the moc_ part
         basename = basename.substr(4);
         std::string mocSubDir = extractSubDir(absPath, currentMoc);
-        std::string headerToMoc = findMatchingHeader(
-                               absPath, mocSubDir, basename, headerExtensions);
+        std::string headerToMoc =
+          findMatchingHeader(absPath, mocSubDir, basename, headerExtensions);
 
-        if (!headerToMoc.empty())
-          {
+        if (!headerToMoc.empty()) {
           includedMocs[headerToMoc] = currentMoc;
-          }
-        else
-          {
+        } else {
           std::stringstream err;
           err << "AUTOGEN: error: " << absFilename << " The file "
               << "includes the moc file \"" << currentMoc << "\", "
-              << "but could not find header \"" << basename
-              << '{' << this->JoinExts(headerExtensions) << "}\" ";
-          if (mocSubDir.empty())
-            {
+              << "but could not find header \"" << basename << '{'
+              << this->JoinExts(headerExtensions) << "}\" ";
+          if (mocSubDir.empty()) {
             err << "in " << absPath << "\n" << std::endl;
-            }
-          else
-            {
-            err << "neither in " << absPath
-                << " nor in " << mocSubDir << "\n" << std::endl;
-            }
+          } else {
+            err << "neither in " << absPath << " nor in " << mocSubDir << "\n"
+                << std::endl;
+          }
           this->LogError(err.str());
           ::exit(EXIT_FAILURE);
-          }
         }
-      else
-        {
-        if (basename != scannedFileBasename)
-          {
+      } else {
+        if (basename != scannedFileBasename) {
           std::stringstream err;
-          err << "AUTOGEN: error: " << absFilename << ": The file "
-                 "includes the moc file \"" << currentMoc <<
-                 "\", which seems to be the moc file from a different "
+          err << "AUTOGEN: error: " << absFilename
+              << ": The file "
+                 "includes the moc file \""
+              << currentMoc
+              << "\", which seems to be the moc file from a different "
                  "source file. This is not supported. "
-                 "Include \"" << scannedFileBasename << ".moc\" to run "
-                 "moc on this source file.\n" << std::endl;
+                 "Include \""
+              << scannedFileBasename << ".moc\" to run "
+                                        "moc on this source file.\n"
+              << std::endl;
           this->LogError(err.str());
           ::exit(EXIT_FAILURE);
-          }
+        }
         dotMocIncluded = true;
         includedMocs[absFilename] = currentMoc;
-        }
+      }
       matchOffset += mocIncludeRegExp.end();
-      } while(mocIncludeRegExp.find(contentsString.c_str() + matchOffset));
-    }
+    } while (mocIncludeRegExp.find(contentsString.c_str() + matchOffset));
+  }
 
   // In this case, check whether the scanned file itself contains a Q_OBJECT.
   // If this is the case, the moc_foo.cpp should probably be generated from
   // foo.cpp instead of foo.h, because otherwise it won't build.
   // But warn, since this is not how it is supposed to be used.
   std::string macroName;
-  if ((dotMocIncluded == false) && (requiresMocing(contentsString,
-                                                     macroName)))
-    {
+  if ((dotMocIncluded == false) &&
+      (requiresMocing(contentsString, macroName))) {
     // otherwise always error out since it will not compile:
     std::stringstream err;
     err << "AUTOGEN: error: " << absFilename << ": The file "
@@ -956,58 +843,50 @@ void cmQtAutoGenerators::StrictParseCppFile(const std::string& absFilename,
         << std::endl;
     this->LogError(err.str());
     ::exit(EXIT_FAILURE);
-    }
-
+  }
 }
 
-
-void cmQtAutoGenerators::ParseForUic(const std::string& absFilename,
-                std::map<std::string, std::vector<std::string> >& includedUis)
+void cmQtAutoGenerators::ParseForUic(
+  const std::string& absFilename,
+  std::map<std::string, std::vector<std::string> >& includedUis)
 {
-  if (this->UicExecutable.empty())
-    {
+  if (this->UicExecutable.empty()) {
     return;
-    }
+  }
   const std::string contentsString = ReadAll(absFilename);
-  if (contentsString.empty())
-    {
+  if (contentsString.empty()) {
     std::stringstream err;
     err << "AUTOGEN: warning: " << absFilename << ": file is empty\n"
         << std::endl;
     this->LogError(err.str());
     return;
-    }
+  }
   this->ParseForUic(absFilename, contentsString, includedUis);
 }
 
-
-void cmQtAutoGenerators::ParseForUic(const std::string& absFilename,
-                const std::string& contentsString,
-                std::map<std::string, std::vector<std::string> >& includedUis)
+void cmQtAutoGenerators::ParseForUic(
+  const std::string& absFilename, const std::string& contentsString,
+  std::map<std::string, std::vector<std::string> >& includedUis)
 {
-  if (this->UicExecutable.empty())
-    {
+  if (this->UicExecutable.empty()) {
     return;
-    }
+  }
   cmsys::RegularExpression uiIncludeRegExp(
-              "[\n][ \t]*#[ \t]*include[ \t]+"
-              "[\"<](([^ \">]+/)?ui_[^ \">/]+\\.h)[\">]");
+    "[\n][ \t]*#[ \t]*include[ \t]+"
+    "[\"<](([^ \">]+/)?ui_[^ \">/]+\\.h)[\">]");
 
   std::string::size_type matchOffset = 0;
 
-  const std::string realName =
-                   cmsys::SystemTools::GetRealPath(absFilename);
+  const std::string realName = cmsys::SystemTools::GetRealPath(absFilename);
 
   matchOffset = 0;
-  if ((strstr(contentsString.c_str(), "ui_") != NULL)
-                                    && (uiIncludeRegExp.find(contentsString)))
-    {
-    do
-      {
+  if ((strstr(contentsString.c_str(), "ui_") != NULL) &&
+      (uiIncludeRegExp.find(contentsString))) {
+    do {
       const std::string currentUi = uiIncludeRegExp.match(1);
 
-      std::string basename = cmsys::SystemTools::
-                                  GetFilenameWithoutLastExtension(currentUi);
+      std::string basename =
+        cmsys::SystemTools::GetFilenameWithoutLastExtension(currentUi);
 
       // basename should be the part of the ui filename used for
       // finding the correct header, so we need to remove the ui_ part
@@ -1016,235 +895,202 @@ void cmQtAutoGenerators::ParseForUic(const std::string& absFilename,
       includedUis[realName].push_back(basename);
 
       matchOffset += uiIncludeRegExp.end();
-      } while(uiIncludeRegExp.find(contentsString.c_str() + matchOffset));
-    }
+    } while (uiIncludeRegExp.find(contentsString.c_str() + matchOffset));
+  }
 }
 
-
-void
-cmQtAutoGenerators::SearchHeadersForCppFile(const std::string& absFilename,
-                              const std::vector<std::string>& headerExtensions,
-                              std::set<std::string>& absHeaders)
+void cmQtAutoGenerators::SearchHeadersForCppFile(
+  const std::string& absFilename,
+  const std::vector<std::string>& headerExtensions,
+  std::set<std::string>& absHeaders)
 {
   // search for header files and private header files we may need to moc:
   const std::string basename =
-              cmsys::SystemTools::GetFilenameWithoutLastExtension(absFilename);
+    cmsys::SystemTools::GetFilenameWithoutLastExtension(absFilename);
   const std::string absPath = cmsys::SystemTools::GetFilenamePath(
-                   cmsys::SystemTools::GetRealPath(absFilename)) + '/';
+                                cmsys::SystemTools::GetRealPath(absFilename)) +
+    '/';
 
-  for(std::vector<std::string>::const_iterator ext = headerExtensions.begin();
-      ext != headerExtensions.end();
-      ++ext)
-    {
+  for (std::vector<std::string>::const_iterator ext = headerExtensions.begin();
+       ext != headerExtensions.end(); ++ext) {
     const std::string headerName = absPath + basename + "." + (*ext);
-    if (cmsys::SystemTools::FileExists(headerName.c_str()))
-      {
+    if (cmsys::SystemTools::FileExists(headerName.c_str())) {
       absHeaders.insert(headerName);
       break;
-      }
     }
-  for(std::vector<std::string>::const_iterator ext = headerExtensions.begin();
-      ext != headerExtensions.end();
-      ++ext)
-    {
-    const std::string privateHeaderName = absPath+basename+"_p."+(*ext);
-    if (cmsys::SystemTools::FileExists(privateHeaderName.c_str()))
-      {
+  }
+  for (std::vector<std::string>::const_iterator ext = headerExtensions.begin();
+       ext != headerExtensions.end(); ++ext) {
+    const std::string privateHeaderName = absPath + basename + "_p." + (*ext);
+    if (cmsys::SystemTools::FileExists(privateHeaderName.c_str())) {
       absHeaders.insert(privateHeaderName);
       break;
-      }
     }
-
+  }
 }
 
-
-void cmQtAutoGenerators::ParseHeaders(const std::set<std::string>& absHeaders,
-                const std::map<std::string, std::string>& includedMocs,
-                std::map<std::string, std::string>& notIncludedMocs,
-                std::map<std::string, std::vector<std::string> >& includedUis)
+void cmQtAutoGenerators::ParseHeaders(
+  const std::set<std::string>& absHeaders,
+  const std::map<std::string, std::string>& includedMocs,
+  std::map<std::string, std::string>& notIncludedMocs,
+  std::map<std::string, std::vector<std::string> >& includedUis)
 {
-  for(std::set<std::string>::const_iterator hIt=absHeaders.begin();
-      hIt!=absHeaders.end();
-      ++hIt)
-    {
+  for (std::set<std::string>::const_iterator hIt = absHeaders.begin();
+       hIt != absHeaders.end(); ++hIt) {
     const std::string& headerName = *hIt;
     const std::string contents = ReadAll(headerName);
 
-    if (!this->MocExecutable.empty()
-        && includedMocs.find(headerName) == includedMocs.end())
-      {
-      if (this->Verbose)
-        {
+    if (!this->MocExecutable.empty() &&
+        includedMocs.find(headerName) == includedMocs.end()) {
+      if (this->Verbose) {
         std::stringstream err;
         err << "AUTOGEN: Checking " << headerName << std::endl;
         this->LogInfo(err.str());
-        }
+      }
 
       std::string macroName;
-      if (requiresMocing(contents, macroName))
-        {
-        const std::string parentDir = this->TargetBuildSubDir
-          + this->SourceRelativePath ( headerName );
-        const std::string basename = cmsys::SystemTools::
-          GetFilenameWithoutLastExtension(headerName);
+      if (requiresMocing(contents, macroName)) {
+        const std::string parentDir =
+          this->TargetBuildSubDir + this->SourceRelativePath(headerName);
+        const std::string basename =
+          cmsys::SystemTools::GetFilenameWithoutLastExtension(headerName);
         const std::string currentMoc = parentDir + "moc_" + basename + ".cpp";
         notIncludedMocs[headerName] = currentMoc;
-        }
       }
-    this->ParseForUic(headerName, contents, includedUis);
     }
+    this->ParseForUic(headerName, contents, includedUis);
+  }
 }
 
-
 bool cmQtAutoGenerators::GenerateMocFiles(
-                    const std::map<std::string, std::string>& includedMocs,
-                    const std::map<std::string, std::string>& notIncludedMocs )
+  const std::map<std::string, std::string>& includedMocs,
+  const std::map<std::string, std::string>& notIncludedMocs)
 {
   // look for name collisions
   {
     std::multimap<std::string, std::string> collisions;
     // Test merged map of included and notIncluded
-    std::map<std::string, std::string> mergedMocs ( includedMocs );
-    mergedMocs.insert ( notIncludedMocs.begin(), notIncludedMocs.end() );
-    if( this->NameCollisionTest ( mergedMocs, collisions ) )
-      {
+    std::map<std::string, std::string> mergedMocs(includedMocs);
+    mergedMocs.insert(notIncludedMocs.begin(), notIncludedMocs.end());
+    if (this->NameCollisionTest(mergedMocs, collisions)) {
       std::stringstream err;
-      err <<
-        "AUTOGEN: error: "
-        "The same moc file will be generated "
-        "from different sources." << std::endl <<
-        "To avoid this error either" << std::endl <<
-        "- rename the source files or" << std::endl <<
-        "- do not include the (moc_NAME.cpp|NAME.moc) file" << std::endl;
-      this->NameCollisionLog ( err.str(), collisions );
+      err << "AUTOGEN: error: "
+             "The same moc file will be generated "
+             "from different sources."
+          << std::endl
+          << "To avoid this error either" << std::endl
+          << "- rename the source files or" << std::endl
+          << "- do not include the (moc_NAME.cpp|NAME.moc) file" << std::endl;
+      this->NameCollisionLog(err.str(), collisions);
       ::exit(EXIT_FAILURE);
-      }
+    }
   }
 
   // generate moc files that are included by source files.
-  for(std::map<std::string, std::string>::const_iterator
-      it = includedMocs.begin(); it != includedMocs.end(); ++it)
-    {
-    if (!this->GenerateMoc(it->first, it->second))
-      {
-      if (this->RunMocFailed)
-        {
+  for (std::map<std::string, std::string>::const_iterator it =
+         includedMocs.begin();
+       it != includedMocs.end(); ++it) {
+    if (!this->GenerateMoc(it->first, it->second)) {
+      if (this->RunMocFailed) {
         return false;
-        }
       }
     }
+  }
 
   // generate moc files that are _not_ included by source files.
   bool automocCppChanged = false;
-  for(std::map<std::string, std::string>::const_iterator
-      it = notIncludedMocs.begin(); it != notIncludedMocs.end(); ++it)
-    {
-    if (this->GenerateMoc(it->first, it->second))
-      {
+  for (std::map<std::string, std::string>::const_iterator it =
+         notIncludedMocs.begin();
+       it != notIncludedMocs.end(); ++it) {
+    if (this->GenerateMoc(it->first, it->second)) {
       automocCppChanged = true;
-      }
-    else
-      {
-      if (this->RunMocFailed)
-        {
+    } else {
+      if (this->RunMocFailed) {
         return false;
-        }
       }
     }
+  }
 
   // compose _automoc.cpp content
   std::string automocSource;
-    {
+  {
     std::stringstream outStream;
     outStream << "/* This file is autogenerated, do not edit*/\n";
-    if( notIncludedMocs.empty() )
-      {
+    if (notIncludedMocs.empty()) {
       outStream << "enum some_compilers { need_more_than_nothing };\n";
-      }
-    else
-      {
-      for(std::map<std::string, std::string>::const_iterator
-          it = notIncludedMocs.begin();
-          it != notIncludedMocs.end();
-          ++it)
-        {
+    } else {
+      for (std::map<std::string, std::string>::const_iterator it =
+             notIncludedMocs.begin();
+           it != notIncludedMocs.end(); ++it) {
         outStream << "#include \"" << it->second << "\"\n";
-        }
       }
+    }
     outStream.flush();
     automocSource = outStream.str();
-    }
+  }
 
   // check if we even need to update _automoc.cpp
-  if (!automocCppChanged)
-    {
+  if (!automocCppChanged) {
     // compare contents of the _automoc.cpp file
     const std::string oldContents = ReadAll(this->OutMocCppFilenameAbs);
-    if (oldContents == automocSource)
-      {
+    if (oldContents == automocSource) {
       // nothing changed: don't touch the _automoc.cpp file
-      if (this->Verbose)
-        {
+      if (this->Verbose) {
         std::stringstream err;
-        err << "AUTOGEN: " << this->OutMocCppFilenameRel
-            << " still up to date" << std::endl;
+        err << "AUTOGEN: " << this->OutMocCppFilenameRel << " still up to date"
+            << std::endl;
         this->LogInfo(err.str());
-        }
-      return true;
       }
+      return true;
     }
+  }
 
   // actually write _automoc.cpp
-    {
+  {
     std::string msg = "Generating moc compilation ";
     msg += this->OutMocCppFilenameRel;
-    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue
-                                     |cmsysTerminal_Color_ForegroundBold,
+    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue |
+                                       cmsysTerminal_Color_ForegroundBold,
                                      msg.c_str(), true, this->ColorOutput);
-    }
-    {
+  }
+  {
     cmsys::ofstream outfile;
-    outfile.open(this->OutMocCppFilenameAbs.c_str(),
-                 std::ios::trunc);
+    outfile.open(this->OutMocCppFilenameAbs.c_str(), std::ios::trunc);
     outfile << automocSource;
     outfile.close();
-    }
+  }
 
   return true;
 }
 
-
 bool cmQtAutoGenerators::GenerateMoc(const std::string& sourceFile,
-                              const std::string& mocFileName)
+                                     const std::string& mocFileName)
 {
   const std::string mocFilePath = this->Builddir + mocFileName;
   int sourceNewerThanMoc = 0;
-  bool success = cmsys::SystemTools::FileTimeCompare(sourceFile,
-                                                     mocFilePath,
+  bool success = cmsys::SystemTools::FileTimeCompare(sourceFile, mocFilePath,
                                                      &sourceNewerThanMoc);
-  if (this->GenerateAll || !success || sourceNewerThanMoc >= 0)
-    {
+  if (this->GenerateAll || !success || sourceNewerThanMoc >= 0) {
     // make sure the directory for the resulting moc file exists
     std::string mocDir = mocFilePath.substr(0, mocFilePath.rfind('/'));
-    if (!cmsys::SystemTools::FileExists(mocDir.c_str(), false))
-      {
+    if (!cmsys::SystemTools::FileExists(mocDir.c_str(), false)) {
       cmsys::SystemTools::MakeDirectory(mocDir.c_str());
-      }
+    }
 
     std::string msg = "Generating moc source ";
     msg += mocFileName;
-    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue
-                                           |cmsysTerminal_Color_ForegroundBold,
+    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue |
+                                       cmsysTerminal_Color_ForegroundBold,
                                      msg.c_str(), true, this->ColorOutput);
 
     std::vector<std::string> command;
     command.push_back(this->MocExecutable);
-    command.insert(command.end(),
-                   this->MocIncludes.begin(), this->MocIncludes.end());
-    command.insert(command.end(),
-                   this->MocDefinitions.begin(), this->MocDefinitions.end());
-    command.insert(command.end(),
-                   this->MocOptions.begin(), this->MocOptions.end());
+    command.insert(command.end(), this->MocIncludes.begin(),
+                   this->MocIncludes.end());
+    command.insert(command.end(), this->MocDefinitions.begin(),
+                   this->MocDefinitions.end());
+    command.insert(command.end(), this->MocOptions.begin(),
+                   this->MocOptions.end());
 #ifdef _WIN32
     command.push_back("-DWIN32");
 #endif
@@ -1252,39 +1098,36 @@ bool cmQtAutoGenerators::GenerateMoc(const std::string& sourceFile,
     command.push_back(mocFilePath);
     command.push_back(sourceFile);
 
-    if (this->Verbose)
-      {
+    if (this->Verbose) {
       this->LogCommand(command);
-      }
+    }
 
     std::string output;
     int retVal = 0;
-    bool result = cmSystemTools::RunSingleCommand(command, &output, &output,
-                                                  &retVal);
-    if (!result || retVal)
-      {
+    bool result =
+      cmSystemTools::RunSingleCommand(command, &output, &output, &retVal);
+    if (!result || retVal) {
       std::stringstream err;
-      err << "AUTOGEN: error: process for " << mocFilePath <<" failed:\n"
+      err << "AUTOGEN: error: process for " << mocFilePath << " failed:\n"
           << output << std::endl;
       this->LogError(err.str());
       this->RunMocFailed = true;
       cmSystemTools::RemoveFile(mocFilePath);
-      }
-    return true;
     }
+    return true;
+  }
   return false;
 }
 
-
 bool cmQtAutoGenerators::GenerateUiFiles(
-      const std::map<std::string, std::vector<std::string> >& includedUis )
+  const std::map<std::string, std::vector<std::string> >& includedUis)
 {
   // single map with input / output names
   std::map<std::string, std::map<std::string, std::string> > uiGenMap;
   std::map<std::string, std::string> testMap;
-  for(std::map<std::string, std::vector<std::string> >::const_iterator
-      it = includedUis.begin(); it != includedUis.end(); ++it)
-    {
+  for (std::map<std::string, std::vector<std::string> >::const_iterator it =
+         includedUis.begin();
+       it != includedUis.end(); ++it) {
     // source file path
     std::string sourcePath = cmsys::SystemTools::GetFilenamePath(it->first);
     sourcePath += '/';
@@ -1292,118 +1135,106 @@ bool cmQtAutoGenerators::GenerateUiFiles(
     uiGenMap[it->first] = std::map<std::string, std::string>();
     std::map<std::string, std::string>& sourceMap = uiGenMap[it->first];
     for (std::vector<std::string>::const_iterator sit = it->second.begin();
-         sit != it->second.end();
-         ++sit)
-      {
-      const std::string & uiFileName = *sit;
+         sit != it->second.end(); ++sit) {
+      const std::string& uiFileName = *sit;
       const std::string uiInputFile = sourcePath + uiFileName + ".ui";
       const std::string uiOutputFile = "ui_" + uiFileName + ".h";
       sourceMap[uiInputFile] = uiOutputFile;
       testMap[uiInputFile] = uiOutputFile;
-      }
     }
+  }
 
   // look for name collisions
   {
     std::multimap<std::string, std::string> collisions;
-    if( this->NameCollisionTest ( testMap, collisions ) )
-      {
+    if (this->NameCollisionTest(testMap, collisions)) {
       std::stringstream err;
       err << "AUTOGEN: error: The same ui_NAME.h file will be generated "
-             "from different sources." << std::endl
+             "from different sources."
+          << std::endl
           << "To avoid this error rename the source files." << std::endl;
-      this->NameCollisionLog ( err.str(), collisions );
+      this->NameCollisionLog(err.str(), collisions);
       ::exit(EXIT_FAILURE);
-      }
+    }
   }
   testMap.clear();
 
   // generate ui files
-  for(std::map<std::string, std::map<std::string, std::string> >::
-      const_iterator it = uiGenMap.begin(); it != uiGenMap.end(); ++it)
-    {
-    for(std::map<std::string, std::string>::const_iterator
-        sit = it->second.begin();
-        sit != it->second.end();
-        ++sit)
-      {
-      if (!this->GenerateUi(it->first, sit->first, sit->second) )
-        {
-        if (this->RunUicFailed)
-          {
+  for (std::map<std::string,
+                std::map<std::string, std::string> >::const_iterator it =
+         uiGenMap.begin();
+       it != uiGenMap.end(); ++it) {
+    for (std::map<std::string, std::string>::const_iterator sit =
+           it->second.begin();
+         sit != it->second.end(); ++sit) {
+      if (!this->GenerateUi(it->first, sit->first, sit->second)) {
+        if (this->RunUicFailed) {
           return false;
-          }
         }
       }
     }
+  }
 
   return true;
 }
 
-
 bool cmQtAutoGenerators::GenerateUi(const std::string& realName,
                                     const std::string& uiInputFile,
                                     const std::string& uiOutputFile)
 {
-  if (!cmsys::SystemTools::FileExists(this->Builddir.c_str(), false))
-    {
+  if (!cmsys::SystemTools::FileExists(this->Builddir.c_str(), false)) {
     cmsys::SystemTools::MakeDirectory(this->Builddir.c_str());
-    }
+  }
 
   const ::std::string uiBuildFile = this->Builddir + uiOutputFile;
 
   int sourceNewerThanUi = 0;
-  bool success = cmsys::SystemTools::FileTimeCompare(uiInputFile,
-                                                     uiBuildFile,
+  bool success = cmsys::SystemTools::FileTimeCompare(uiInputFile, uiBuildFile,
                                                      &sourceNewerThanUi);
-  if (this->GenerateAll || !success || sourceNewerThanUi >= 0)
-    {
+  if (this->GenerateAll || !success || sourceNewerThanUi >= 0) {
     std::string msg = "Generating ui header ";
     msg += uiOutputFile;
-    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue
-                                          |cmsysTerminal_Color_ForegroundBold,
-                                      msg.c_str(), true, this->ColorOutput);
+    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue |
+                                       cmsysTerminal_Color_ForegroundBold,
+                                     msg.c_str(), true, this->ColorOutput);
 
     std::vector<std::string> command;
     command.push_back(this->UicExecutable);
 
     std::vector<std::string> opts = this->UicTargetOptions;
-    std::map<std::string, std::string>::const_iterator optionIt
-            = this->UicOptions.find(uiInputFile);
-    if (optionIt != this->UicOptions.end())
-      {
+    std::map<std::string, std::string>::const_iterator optionIt =
+      this->UicOptions.find(uiInputFile);
+    if (optionIt != this->UicOptions.end()) {
       std::vector<std::string> fileOpts;
       cmSystemTools::ExpandListArgument(optionIt->second, fileOpts);
       cmQtAutoGenerators::MergeUicOptions(opts, fileOpts,
                                           this->QtMajorVersion == "5");
-      }
+    }
     command.insert(command.end(), opts.begin(), opts.end());
 
     command.push_back("-o");
     command.push_back(uiBuildFile);
     command.push_back(uiInputFile);
 
-    if (this->Verbose)
-      {
+    if (this->Verbose) {
       this->LogCommand(command);
-      }
+    }
     std::string output;
     int retVal = 0;
-    bool result = cmSystemTools::RunSingleCommand(command, &output, &output,
-                                                  &retVal);
-    if (!result || retVal)
-      {
+    bool result =
+      cmSystemTools::RunSingleCommand(command, &output, &output, &retVal);
+    if (!result || retVal) {
       std::stringstream err;
-      err << "AUTOUIC: error: process for " << uiOutputFile <<
-             " needed by\n \"" << realName << "\"\nfailed:\n" << output
-          << std::endl;
+      err << "AUTOUIC: error: process for " << uiOutputFile
+          << " needed by\n \"" << realName << "\"\nfailed:\n"
+          << output << std::endl;
       this->LogError(err.str());
       this->RunUicFailed = true;
       cmSystemTools::RemoveFile(uiOutputFile);
       return false;
-      }
-    return true;
     }
+    return true;
+  }
   return false;
 }
 
@@ -1412,17 +1243,14 @@ bool cmQtAutoGenerators::InputFilesNewerThanQrc(const std::string& qrcFile,
 {
   std::vector<std::string> const& files = this->RccInputs[qrcFile];
   for (std::vector<std::string>::const_iterator it = files.begin();
-       it != files.end(); ++it)
-    {
+       it != files.end(); ++it) {
     int inputNewerThanQrc = 0;
-    bool success = cmsys::SystemTools::FileTimeCompare(*it,
-                                                      rccOutput,
-                                                      &inputNewerThanQrc);
-    if (!success || inputNewerThanQrc >= 0)
-      {
+    bool success =
+      cmsys::SystemTools::FileTimeCompare(*it, rccOutput, &inputNewerThanQrc);
+    if (!success || inputNewerThanQrc >= 0) {
       return true;
-      }
     }
+  }
   return false;
 }
 
@@ -1430,88 +1258,78 @@ bool cmQtAutoGenerators::GenerateQrcFiles()
 {
   // generate single map with input / output names
   std::map<std::string, std::string> qrcGenMap;
-  for(std::vector<std::string>::const_iterator si = this->RccSources.begin();
-      si != this->RccSources.end(); ++si)
-    {
+  for (std::vector<std::string>::const_iterator si = this->RccSources.begin();
+       si != this->RccSources.end(); ++si) {
     const std::string ext = cmsys::SystemTools::GetFilenameLastExtension(*si);
-    if (ext == ".qrc")
-      {
-      std::string basename = cmsys::SystemTools::
-        GetFilenameWithoutLastExtension(*si);
-      std::string qrcOutputFile = this->TargetBuildSubDir
-        + this->SourceRelativePath ( *si )
-        + "qrc_" + basename + ".cpp";
-      //std::string qrcOutputFile = "CMakeFiles/" + this->OriginTargetName
+    if (ext == ".qrc") {
+      std::string basename =
+        cmsys::SystemTools::GetFilenameWithoutLastExtension(*si);
+      std::string qrcOutputFile = this->TargetBuildSubDir +
+        this->SourceRelativePath(*si) + "qrc_" + basename + ".cpp";
+      // std::string qrcOutputFile = "CMakeFiles/" + this->OriginTargetName
       //                         + ".dir/qrc_" + basename + ".cpp";
       qrcGenMap[*si] = qrcOutputFile;
-      }
     }
+  }
 
   // look for name collisions
   {
     std::multimap<std::string, std::string> collisions;
-    if( this->NameCollisionTest ( qrcGenMap, collisions ) )
-      {
+    if (this->NameCollisionTest(qrcGenMap, collisions)) {
       std::stringstream err;
       err << "AUTOGEN: error: The same qrc_NAME.cpp file"
-             " will be generated from different sources." << std::endl
-          << "To avoid this error rename the source .qrc files."
-          << std::endl;
-      this->NameCollisionLog ( err.str(), collisions );
+             " will be generated from different sources."
+          << std::endl
+          << "To avoid this error rename the source .qrc files." << std::endl;
+      this->NameCollisionLog(err.str(), collisions);
       ::exit(EXIT_FAILURE);
-      }
+    }
   }
 
   // generate qrc files
-  for(std::map<std::string, std::string>::const_iterator
-      si = qrcGenMap.begin(); si != qrcGenMap.end(); ++si)
-    {
-    if (!this->GenerateQrc( si->first, si->second))
-      {
-      if (this->RunRccFailed)
-        {
+  for (std::map<std::string, std::string>::const_iterator si =
+         qrcGenMap.begin();
+       si != qrcGenMap.end(); ++si) {
+    if (!this->GenerateQrc(si->first, si->second)) {
+      if (this->RunRccFailed) {
         return false;
-        }
       }
     }
+  }
   return true;
 }
 
-bool cmQtAutoGenerators::GenerateQrc (
-  const std::string& qrcInputFile,
-  const std::string& qrcOutputFile )
+bool cmQtAutoGenerators::GenerateQrc(const std::string& qrcInputFile,
+                                     const std::string& qrcOutputFile)
 {
-  std::string relName = this->SourceRelativePath ( qrcInputFile );
+  std::string relName = this->SourceRelativePath(qrcInputFile);
   cmSystemTools::ReplaceString(relName, "/", "_");
   relName += cmsys::SystemTools::GetFilenameWithoutLastExtension(qrcInputFile);
 
   const ::std::string qrcBuildFile = this->Builddir + qrcOutputFile;
 
   int sourceNewerThanQrc = 0;
-  bool generateQrc = !cmsys::SystemTools::FileTimeCompare(qrcInputFile,
-                                                          qrcBuildFile,
-                                                          &sourceNewerThanQrc);
+  bool generateQrc = !cmsys::SystemTools::FileTimeCompare(
+    qrcInputFile, qrcBuildFile, &sourceNewerThanQrc);
   generateQrc = generateQrc || (sourceNewerThanQrc >= 0);
-  generateQrc = generateQrc || this->InputFilesNewerThanQrc(qrcInputFile,
-                                                            qrcBuildFile);
+  generateQrc =
+    generateQrc || this->InputFilesNewerThanQrc(qrcInputFile, qrcBuildFile);
 
-  if (this->GenerateAll || generateQrc)
-    {
+  if (this->GenerateAll || generateQrc) {
     std::string msg = "Generating qrc source ";
     msg += qrcOutputFile;
-    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue
-                                     |cmsysTerminal_Color_ForegroundBold,
+    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue |
+                                       cmsysTerminal_Color_ForegroundBold,
                                      msg.c_str(), true, this->ColorOutput);
 
     std::vector<std::string> command;
     command.push_back(this->RccExecutable);
 
-    std::map<std::string, std::string>::const_iterator optionIt
-      = this->RccOptions.find(qrcInputFile);
-    if (optionIt != this->RccOptions.end())
-      {
+    std::map<std::string, std::string>::const_iterator optionIt =
+      this->RccOptions.find(qrcInputFile);
+    if (optionIt != this->RccOptions.end()) {
       cmSystemTools::ExpandListArgument(optionIt->second, command);
-      }
+    }
 
     command.push_back("-name");
     command.push_back(relName);
@@ -1519,25 +1337,23 @@ bool cmQtAutoGenerators::GenerateQrc (
     command.push_back(qrcBuildFile);
     command.push_back(qrcInputFile);
 
-    if (this->Verbose)
-      {
+    if (this->Verbose) {
       this->LogCommand(command);
-      }
+    }
     std::string output;
     int retVal = 0;
-    bool result = cmSystemTools::RunSingleCommand(command, &output, &output,
-                                                  &retVal);
-    if (!result || retVal)
-      {
+    bool result =
+      cmSystemTools::RunSingleCommand(command, &output, &output, &retVal);
+    if (!result || retVal) {
       std::stringstream err;
-      err << "AUTORCC: error: process for " << qrcOutputFile <<
-             " failed:\n" << output << std::endl;
+      err << "AUTORCC: error: process for " << qrcOutputFile << " failed:\n"
+          << output << std::endl;
       this->LogError(err.str());
       this->RunRccFailed = true;
       cmSystemTools::RemoveFile(qrcBuildFile);
       return false;
-      }
     }
+  }
   return true;
 }
 
@@ -1547,44 +1363,40 @@ std::string cmQtAutoGenerators::SourceRelativePath(const std::string& filename)
 
   // Test if the file is child to any of the known directories
   {
-    std::string fileNameReal = cmsys::SystemTools::GetRealPath( filename );
+    std::string fileNameReal = cmsys::SystemTools::GetRealPath(filename);
     std::string parentDirectory;
-    bool match ( false );
+    bool match(false);
     {
       const ::std::string* testDirs[4];
       testDirs[0] = &(this->Srcdir);
       testDirs[1] = &(this->Builddir);
       testDirs[2] = &(this->ProjectSourceDir);
       testDirs[3] = &(this->ProjectBinaryDir);
-      for(int ii=0; ii != sizeof(testDirs)/sizeof(const ::std::string*); ++ii )
-        {
-        const ::std::string testDir = cmsys::SystemTools::GetRealPath(
-                                                          *(testDirs[ii]));
-        if (cmsys::SystemTools::IsSubDirectory(fileNameReal,
-                                               testDir) )
-          {
+      for (int ii = 0; ii != sizeof(testDirs) / sizeof(const ::std::string*);
+           ++ii) {
+        const ::std::string testDir =
+          cmsys::SystemTools::GetRealPath(*(testDirs[ii]));
+        if (cmsys::SystemTools::IsSubDirectory(fileNameReal, testDir)) {
           parentDirectory = testDir;
           match = true;
           break;
-          }
         }
+      }
     }
     // Use root as fallback parent directory
-    if ( !match )
-      {
+    if (!match) {
       cmsys::SystemTools::SplitPathRootComponent(fileNameReal,
                                                  &parentDirectory);
-      }
+    }
     pathRel = cmsys::SystemTools::RelativePath(
       parentDirectory, cmsys::SystemTools::GetParentDirectory(fileNameReal));
   }
 
   // Sanitize relative path
-  if (!pathRel.empty())
-    {
+  if (!pathRel.empty()) {
     pathRel += '/';
     cmSystemTools::ReplaceString(pathRel, "..", "__");
-    }
+  }
   return pathRel;
 }
 
@@ -1593,39 +1405,34 @@ std::string cmQtAutoGenerators::SourceRelativePath(const std::string& filename)
  * @return True if there were collisions
  */
 bool cmQtAutoGenerators::NameCollisionTest(
-                          const std::map<std::string, std::string >& genFiles,
-                          std::multimap<std::string, std::string>& collisions)
+  const std::map<std::string, std::string>& genFiles,
+  std::multimap<std::string, std::string>& collisions)
 {
   typedef std::map<std::string, std::string>::const_iterator Iter;
   typedef std::map<std::string, std::string>::value_type VType;
-  for(Iter ait = genFiles.begin(); ait != genFiles.end(); ++ait )
-    {
-    bool first_match ( true );
-    for (Iter bit = (++Iter(ait)); bit != genFiles.end(); ++bit)
-      {
-      if(ait->second == bit->second)
-        {
-        if (first_match)
-          {
-          if (collisions.find(ait->second) != collisions.end())
-            {
+  for (Iter ait = genFiles.begin(); ait != genFiles.end(); ++ait) {
+    bool first_match(true);
+    for (Iter bit = (++Iter(ait)); bit != genFiles.end(); ++bit) {
+      if (ait->second == bit->second) {
+        if (first_match) {
+          if (collisions.find(ait->second) != collisions.end()) {
             // We already know of this collision from before
             break;
-            }
+          }
           collisions.insert(VType(ait->second, ait->first));
           first_match = false;
-          }
-        collisions.insert(VType(bit->second, bit->first));
         }
+        collisions.insert(VType(bit->second, bit->first));
       }
     }
+  }
 
   return !collisions.empty();
 }
 
 void cmQtAutoGenerators::NameCollisionLog(
-                     const std::string& message,
-                     const std::multimap<std::string, std::string>& collisions)
+  const std::string& message,
+  const std::multimap<std::string, std::string>& collisions)
 {
   typedef std::multimap<std::string, std::string>::const_iterator Iter;
 
@@ -1633,10 +1440,9 @@ void cmQtAutoGenerators::NameCollisionLog(
   // Add message
   err << message;
   // Append collision list
-  for(Iter it = collisions.begin(); it != collisions.end(); ++it )
-    {
-      err << it->first << " : " << it->second << std::endl;
-    }
+  for (Iter it = collisions.begin(); it != collisions.end(); ++it) {
+    err << it->first << " : " << it->second << std::endl;
+  }
   this->LogError(err.str());
 }
 
@@ -1653,42 +1459,34 @@ void cmQtAutoGenerators::LogError(const std::string& message)
 void cmQtAutoGenerators::LogCommand(const std::vector<std::string>& command)
 {
   std::stringstream sbuf;
-  for(std::vector<std::string>::const_iterator cmdIt = command.begin();
-      cmdIt != command.end();
-      ++cmdIt)
-    {
-    if ( cmdIt != command.begin() )
-      {
+  for (std::vector<std::string>::const_iterator cmdIt = command.begin();
+       cmdIt != command.end(); ++cmdIt) {
+    if (cmdIt != command.begin()) {
       sbuf << " ";
-      }
-    sbuf << *cmdIt;
     }
-  if ( !sbuf.str().empty() )
-    {
+    sbuf << *cmdIt;
+  }
+  if (!sbuf.str().empty()) {
     sbuf << std::endl;
-    this->LogInfo ( sbuf.str() );
-    }
+    this->LogInfo(sbuf.str());
+  }
 }
 
 std::string cmQtAutoGenerators::JoinExts(const std::vector<std::string>& lst)
 {
-    if (lst.empty())
-      {
-      return "";
-      }
+  if (lst.empty()) {
+    return "";
+  }
 
-    std::string result;
-    std::string separator = ",";
-    for (std::vector<std::string>::const_iterator it = lst.begin();
-         it != lst.end();
-         ++it)
-      {
-      if(it != lst.begin())
-        {
-        result += separator;
-        }
-      result += '.' + (*it);
-      }
-    result.erase(result.end() - 1);
-    return result;
+  std::string result;
+  std::string separator = ",";
+  for (std::vector<std::string>::const_iterator it = lst.begin();
+       it != lst.end(); ++it) {
+    if (it != lst.begin()) {
+      result += separator;
+    }
+    result += '.' + (*it);
+  }
+  result.erase(result.end() - 1);
+  return result;
 }