Revise C++ coding style using clang-format

Run the `Utilities/Scripts/clang-format.bash` script to update
all our C++ code to a new style defined by `.clang-format`.
Use `clang-format` version 3.8.

* If you reached this commit for a line in `git blame`, re-run the blame
  operation starting at the parent of this commit to see older history
  for the content.

* See the parent commit for instructions to rebase a change across this
  style transition commit.

1 files changed, 1169 insertions, 1805 deletions

diff --git a/Source/cmFileCommand.cxx b/Source/cmFileCommand.cxx
index 6b6b913..5363a99 100644
--- a/Source/cmFileCommand.cxx
+++ b/Source/cmFileCommand.cxx
@@ -74,232 +74,169 @@ static mode_t mode_setgid = S_ISGID;
 static std::string fix_file_url_windows(const std::string& url)
 {
   std::string ret = url;
-  if(strncmp(url.c_str(), "file://", 7) == 0)
-    {
+  if (strncmp(url.c_str(), "file://", 7) == 0) {
     std::wstring wurl = cmsys::Encoding::ToWide(url);
-    if(!wurl.empty())
-      {
-      int mblen = WideCharToMultiByte(CP_ACP, 0, wurl.c_str(), -1,
-                                   NULL, 0, NULL, NULL);
-      if(mblen > 0)
-        {
+    if (!wurl.empty()) {
+      int mblen =
+        WideCharToMultiByte(CP_ACP, 0, wurl.c_str(), -1, NULL, 0, NULL, NULL);
+      if (mblen > 0) {
         std::vector<char> chars(mblen);
-        mblen = WideCharToMultiByte(CP_ACP, 0, wurl.c_str(), -1,
-                                   &chars[0], mblen, NULL, NULL);
-        if(mblen > 0)
-          {
+        mblen = WideCharToMultiByte(CP_ACP, 0, wurl.c_str(), -1, &chars[0],
+                                    mblen, NULL, NULL);
+        if (mblen > 0) {
           ret = &chars[0];
-          }
         }
       }
     }
+  }
   return ret;
 }
 #endif
 
 // cmLibraryCommand
-bool cmFileCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmFileCommand::InitialPass(std::vector<std::string> const& args,
+                                cmExecutionStatus&)
 {
-  if(args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("must be called with at least two arguments.");
     return false;
-    }
+  }
   std::string subCommand = args[0];
-  if ( subCommand == "WRITE" )
-    {
+  if (subCommand == "WRITE") {
     return this->HandleWriteCommand(args, false);
-    }
-  else if ( subCommand == "APPEND" )
-    {
+  } else if (subCommand == "APPEND") {
     return this->HandleWriteCommand(args, true);
-    }
-  else if ( subCommand == "DOWNLOAD" )
-    {
+  } else if (subCommand == "DOWNLOAD") {
     return this->HandleDownloadCommand(args);
-    }
-  else if ( subCommand == "UPLOAD" )
-    {
+  } else if (subCommand == "UPLOAD") {
     return this->HandleUploadCommand(args);
-    }
-  else if ( subCommand == "READ" )
-    {
+  } else if (subCommand == "READ") {
     return this->HandleReadCommand(args);
-    }
-  else if ( subCommand == "MD5" ||
-            subCommand == "SHA1" ||
-            subCommand == "SHA224" ||
-            subCommand == "SHA256" ||
-            subCommand == "SHA384" ||
-            subCommand == "SHA512" )
-    {
+  } else if (subCommand == "MD5" || subCommand == "SHA1" ||
+             subCommand == "SHA224" || subCommand == "SHA256" ||
+             subCommand == "SHA384" || subCommand == "SHA512") {
     return this->HandleHashCommand(args);
-    }
-  else if ( subCommand == "STRINGS" )
-    {
+  } else if (subCommand == "STRINGS") {
     return this->HandleStringsCommand(args);
-    }
-  else if ( subCommand == "GLOB" )
-    {
+  } else if (subCommand == "GLOB") {
     return this->HandleGlobCommand(args, false);
-    }
-  else if ( subCommand == "GLOB_RECURSE" )
-    {
+  } else if (subCommand == "GLOB_RECURSE") {
     return this->HandleGlobCommand(args, true);
-    }
-  else if ( subCommand == "MAKE_DIRECTORY" )
-    {
+  } else if (subCommand == "MAKE_DIRECTORY") {
     return this->HandleMakeDirectoryCommand(args);
-    }
-  else if ( subCommand == "RENAME" )
-    {
+  } else if (subCommand == "RENAME") {
     return this->HandleRename(args);
-    }
-  else if ( subCommand == "REMOVE" )
-    {
+  } else if (subCommand == "REMOVE") {
     return this->HandleRemove(args, false);
-    }
-  else if ( subCommand == "REMOVE_RECURSE" )
-    {
+  } else if (subCommand == "REMOVE_RECURSE") {
     return this->HandleRemove(args, true);
-    }
-  else if ( subCommand == "COPY" )
-    {
+  } else if (subCommand == "COPY") {
     return this->HandleCopyCommand(args);
-    }
-  else if ( subCommand == "INSTALL" )
-    {
+  } else if (subCommand == "INSTALL") {
     return this->HandleInstallCommand(args);
-    }
-  else if ( subCommand == "DIFFERENT" )
-    {
+  } else if (subCommand == "DIFFERENT") {
     return this->HandleDifferentCommand(args);
-    }
-  else if ( subCommand == "RPATH_CHANGE" || subCommand == "CHRPATH" )
-    {
+  } else if (subCommand == "RPATH_CHANGE" || subCommand == "CHRPATH") {
     return this->HandleRPathChangeCommand(args);
-    }
-  else if ( subCommand == "RPATH_CHECK" )
-    {
+  } else if (subCommand == "RPATH_CHECK") {
     return this->HandleRPathCheckCommand(args);
-    }
-  else if ( subCommand == "RPATH_REMOVE" )
-    {
+  } else if (subCommand == "RPATH_REMOVE") {
     return this->HandleRPathRemoveCommand(args);
-    }
-  else if ( subCommand == "RELATIVE_PATH" )
-    {
+  } else if (subCommand == "RELATIVE_PATH") {
     return this->HandleRelativePathCommand(args);
-    }
-  else if ( subCommand == "TO_CMAKE_PATH" )
-    {
+  } else if (subCommand == "TO_CMAKE_PATH") {
     return this->HandleCMakePathCommand(args, false);
-    }
-  else if ( subCommand == "TO_NATIVE_PATH" )
-    {
+  } else if (subCommand == "TO_NATIVE_PATH") {
     return this->HandleCMakePathCommand(args, true);
-    }
-  else if ( subCommand == "TIMESTAMP" )
-    {
+  } else if (subCommand == "TIMESTAMP") {
     return this->HandleTimestampCommand(args);
-    }
-  else if ( subCommand == "GENERATE" )
-    {
+  } else if (subCommand == "GENERATE") {
     return this->HandleGenerateCommand(args);
-    }
-  else if ( subCommand == "LOCK" )
-    {
+  } else if (subCommand == "LOCK") {
     return this->HandleLockCommand(args);
-    }
+  }
 
-  std::string e = "does not recognize sub-command "+subCommand;
+  std::string e = "does not recognize sub-command " + subCommand;
   this->SetError(e);
   return false;
 }
 
 bool cmFileCommand::HandleWriteCommand(std::vector<std::string> const& args,
-  bool append)
+                                       bool append)
 {
   std::vector<std::string>::const_iterator i = args.begin();
 
   i++; // Get rid of subcommand
 
   std::string fileName = *i;
-  if ( !cmsys::SystemTools::FileIsFullPath(i->c_str()) )
-    {
+  if (!cmsys::SystemTools::FileIsFullPath(i->c_str())) {
     fileName = this->Makefile->GetCurrentSourceDirectory();
     fileName += "/" + *i;
-    }
+  }
 
   i++;
 
-  if ( !this->Makefile->CanIWriteThisFile(fileName.c_str()) )
-    {
-    std::string e
-      = "attempted to write a file: " + fileName +
-      " into a source directory.";
+  if (!this->Makefile->CanIWriteThisFile(fileName.c_str())) {
+    std::string e =
+      "attempted to write a file: " + fileName + " into a source directory.";
     this->SetError(e);
     cmSystemTools::SetFatalErrorOccured();
     return false;
-    }
+  }
   std::string dir = cmSystemTools::GetFilenamePath(fileName);
   cmSystemTools::MakeDirectory(dir.c_str());
 
   mode_t mode = 0;
 
   // Set permissions to writable
-  if ( cmSystemTools::GetPermissions(fileName.c_str(), mode) )
-    {
+  if (cmSystemTools::GetPermissions(fileName.c_str(), mode)) {
     cmSystemTools::SetPermissions(fileName.c_str(),
-#if defined( _MSC_VER ) || defined( __MINGW32__ )
-      mode | S_IWRITE
+#if defined(_MSC_VER) || defined(__MINGW32__)
+                                  mode | S_IWRITE
 #else
-      mode | S_IWUSR | S_IWGRP
+                                  mode | S_IWUSR | S_IWGRP
 #endif
-    );
-    }
+                                  );
+  }
   // If GetPermissions fails, pretend like it is ok. File open will fail if
   // the file is not writable
-  cmsys::ofstream file(fileName.c_str(), append?std::ios::app: std::ios::out);
-  if ( !file )
-    {
+  cmsys::ofstream file(fileName.c_str(),
+                       append ? std::ios::app : std::ios::out);
+  if (!file) {
     std::string error = "failed to open for writing (";
     error += cmSystemTools::GetLastSystemError();
     error += "):\n  ";
     error += fileName;
     this->SetError(error);
     return false;
-    }
+  }
   std::string message = cmJoin(cmMakeRange(i, args.end()), std::string());
   file << message;
   file.close();
-  if(mode)
-    {
+  if (mode) {
     cmSystemTools::SetPermissions(fileName.c_str(), mode);
-    }
+  }
   return true;
 }
 
 bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
 {
-  if ( args.size() < 3 )
-    {
+  if (args.size() < 3) {
     this->SetError("READ must be called with at least two additional "
                    "arguments");
     return false;
-    }
+  }
 
   cmCommandArgumentsHelper argHelper;
   cmCommandArgumentGroup group;
 
-  cmCAString readArg    (&argHelper, "READ");
-  cmCAString fileNameArg    (&argHelper, 0);
-  cmCAString resultArg      (&argHelper, 0);
+  cmCAString readArg(&argHelper, "READ");
+  cmCAString fileNameArg(&argHelper, 0);
+  cmCAString resultArg(&argHelper, 0);
 
-  cmCAString offsetArg      (&argHelper, "OFFSET", &group);
-  cmCAString limitArg       (&argHelper, "LIMIT", &group);
-  cmCAEnabler hexOutputArg  (&argHelper, "HEX", &group);
+  cmCAString offsetArg(&argHelper, "OFFSET", &group);
+  cmCAString limitArg(&argHelper, "LIMIT", &group);
+  cmCAEnabler hexOutputArg(&argHelper, "HEX", &group);
   readArg.Follows(0);
   fileNameArg.Follows(&readArg);
   resultArg.Follows(&fileNameArg);
@@ -307,92 +244,78 @@ bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
   argHelper.Parse(&args, 0);
 
   std::string fileName = fileNameArg.GetString();
-  if ( !cmsys::SystemTools::FileIsFullPath(fileName.c_str()) )
-    {
+  if (!cmsys::SystemTools::FileIsFullPath(fileName.c_str())) {
     fileName = this->Makefile->GetCurrentSourceDirectory();
     fileName += "/" + fileNameArg.GetString();
-    }
+  }
 
   std::string variable = resultArg.GetString();
 
-  // Open the specified file.
+// Open the specified file.
 #if defined(_WIN32) || defined(__CYGWIN__)
-  cmsys::ifstream file(fileName.c_str(), std::ios::in |
-               (hexOutputArg.IsEnabled() ? std::ios::binary : std::ios::in));
+  cmsys::ifstream file(
+    fileName.c_str(), std::ios::in |
+      (hexOutputArg.IsEnabled() ? std::ios::binary : std::ios::in));
 #else
   cmsys::ifstream file(fileName.c_str(), std::ios::in);
 #endif
 
-  if ( !file )
-    {
+  if (!file) {
     std::string error = "failed to open for reading (";
     error += cmSystemTools::GetLastSystemError();
     error += "):\n  ";
     error += fileName;
     this->SetError(error);
     return false;
-    }
+  }
 
   // is there a limit?
   long sizeLimit = -1;
-  if (!limitArg.GetString().empty())
-    {
+  if (!limitArg.GetString().empty()) {
     sizeLimit = atoi(limitArg.GetCString());
-    }
+  }
 
   // is there an offset?
   long offset = 0;
-  if (!offsetArg.GetString().empty())
-    {
+  if (!offsetArg.GetString().empty()) {
     offset = atoi(offsetArg.GetCString());
-    }
+  }
 
   file.seekg(offset, std::ios::beg); // explicit ios::beg for IBM VisualAge 6
 
   std::string output;
 
-  if (hexOutputArg.IsEnabled())
-    {
+  if (hexOutputArg.IsEnabled()) {
     // Convert part of the file into hex code
     char c;
-    while((sizeLimit != 0) && (file.get(c)))
-      {
+    while ((sizeLimit != 0) && (file.get(c))) {
       char hex[4];
-      sprintf(hex, "%.2x", c&0xff);
+      sprintf(hex, "%.2x", c & 0xff);
       output += hex;
-      if (sizeLimit > 0)
-        {
+      if (sizeLimit > 0) {
         sizeLimit--;
-        }
       }
     }
-  else
-    {
+  } else {
     std::string line;
     bool has_newline = false;
-    while (sizeLimit != 0 &&
-          cmSystemTools::GetLineFromStream(file, line, &has_newline,
-                                            sizeLimit) )
-      {
-      if (sizeLimit > 0)
-        {
+    while (sizeLimit != 0 && cmSystemTools::GetLineFromStream(
+                               file, line, &has_newline, sizeLimit)) {
+      if (sizeLimit > 0) {
         sizeLimit = sizeLimit - static_cast<long>(line.size());
-        if (has_newline)
-          {
+        if (has_newline) {
           sizeLimit--;
-          }
-        if (sizeLimit < 0)
-          {
+        }
+        if (sizeLimit < 0) {
           sizeLimit = 0;
-          }
         }
+      }
       output += line;
-      if ( has_newline )
-        {
+      if (has_newline) {
         output += "\n";
-        }
       }
     }
+  }
   this->Makefile->AddDefinition(variable, output.c_str());
   return true;
 }
@@ -400,28 +323,25 @@ bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
 bool cmFileCommand::HandleHashCommand(std::vector<std::string> const& args)
 {
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-  if(args.size() != 3)
-    {
+  if (args.size() != 3) {
     std::ostringstream e;
     e << args[0] << " requires a file name and output variable";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   cmsys::auto_ptr<cmCryptoHash> hash(cmCryptoHash::New(args[0].c_str()));
-  if(hash.get())
-    {
+  if (hash.get()) {
     std::string out = hash->HashFile(args[1]);
-    if(!out.empty())
-      {
+    if (!out.empty()) {
       this->Makefile->AddDefinition(args[2], out.c_str());
       return true;
-      }
+    }
     std::ostringstream e;
-    e << args[0] << " failed to read file \"" << args[1] << "\": "
-      << cmSystemTools::GetLastSystemError();
+    e << args[0] << " failed to read file \"" << args[1]
+      << "\": " << cmSystemTools::GetLastSystemError();
     this->SetError(e.str());
-    }
+  }
   return false;
 #else
   std::ostringstream e;
@@ -433,33 +353,34 @@ bool cmFileCommand::HandleHashCommand(std::vector<std::string> const& args)
 
 bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
 {
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     this->SetError("STRINGS requires a file name and output variable");
     return false;
-    }
+  }
 
   // Get the file to read.
   std::string fileName = args[1];
-  if(!cmsys::SystemTools::FileIsFullPath(fileName.c_str()))
-    {
+  if (!cmsys::SystemTools::FileIsFullPath(fileName.c_str())) {
     fileName = this->Makefile->GetCurrentSourceDirectory();
     fileName += "/" + args[1];
-    }
+  }
 
   // Get the variable in which to store the results.
   std::string outVar = args[2];
 
   // Parse the options.
-  enum { arg_none,
-         arg_limit_input,
-         arg_limit_output,
-         arg_limit_count,
-         arg_length_minimum,
-         arg_length_maximum,
-         arg__maximum,
-         arg_regex,
-         arg_encoding };
+  enum
+  {
+    arg_none,
+    arg_limit_input,
+    arg_limit_output,
+    arg_limit_count,
+    arg_length_minimum,
+    arg_length_maximum,
+    arg__maximum,
+    arg_regex,
+    arg_encoding
+  };
   unsigned int minlen = 0;
   unsigned int maxlen = 0;
   int limit_input = -1;
@@ -469,396 +390,302 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
   bool have_regex = false;
   bool newline_consume = false;
   bool hex_conversion_enabled = true;
-  enum { encoding_none = cmsys::FStream::BOM_None,
-         encoding_utf8 = cmsys::FStream::BOM_UTF8,
-         encoding_utf16le = cmsys::FStream::BOM_UTF16LE,
-         encoding_utf16be = cmsys::FStream::BOM_UTF16BE,
-         encoding_utf32le = cmsys::FStream::BOM_UTF32LE,
-         encoding_utf32be = cmsys::FStream::BOM_UTF32BE};
+  enum
+  {
+    encoding_none = cmsys::FStream::BOM_None,
+    encoding_utf8 = cmsys::FStream::BOM_UTF8,
+    encoding_utf16le = cmsys::FStream::BOM_UTF16LE,
+    encoding_utf16be = cmsys::FStream::BOM_UTF16BE,
+    encoding_utf32le = cmsys::FStream::BOM_UTF32LE,
+    encoding_utf32be = cmsys::FStream::BOM_UTF32BE
+  };
   int encoding = encoding_none;
   int arg_mode = arg_none;
-  for(unsigned int i=3; i < args.size(); ++i)
-    {
-    if(args[i] == "LIMIT_INPUT")
-      {
+  for (unsigned int i = 3; i < args.size(); ++i) {
+    if (args[i] == "LIMIT_INPUT") {
       arg_mode = arg_limit_input;
-      }
-    else if(args[i] == "LIMIT_OUTPUT")
-      {
+    } else if (args[i] == "LIMIT_OUTPUT") {
       arg_mode = arg_limit_output;
-      }
-    else if(args[i] == "LIMIT_COUNT")
-      {
+    } else if (args[i] == "LIMIT_COUNT") {
       arg_mode = arg_limit_count;
-      }
-    else if(args[i] == "LENGTH_MINIMUM")
-      {
+    } else if (args[i] == "LENGTH_MINIMUM") {
       arg_mode = arg_length_minimum;
-      }
-    else if(args[i] == "LENGTH_MAXIMUM")
-      {
+    } else if (args[i] == "LENGTH_MAXIMUM") {
       arg_mode = arg_length_maximum;
-      }
-    else if(args[i] == "REGEX")
-      {
+    } else if (args[i] == "REGEX") {
       arg_mode = arg_regex;
-      }
-    else if(args[i] == "NEWLINE_CONSUME")
-      {
+    } else if (args[i] == "NEWLINE_CONSUME") {
       newline_consume = true;
       arg_mode = arg_none;
-      }
-    else if(args[i] == "NO_HEX_CONVERSION")
-      {
+    } else if (args[i] == "NO_HEX_CONVERSION") {
       hex_conversion_enabled = false;
       arg_mode = arg_none;
-      }
-    else if(args[i] == "ENCODING")
-      {
+    } else if (args[i] == "ENCODING") {
       arg_mode = arg_encoding;
-      }
-    else if(arg_mode == arg_limit_input)
-      {
-      if(sscanf(args[i].c_str(), "%d", &limit_input) != 1 ||
-         limit_input < 0)
-        {
+    } else if (arg_mode == arg_limit_input) {
+      if (sscanf(args[i].c_str(), "%d", &limit_input) != 1 ||
+          limit_input < 0) {
         std::ostringstream e;
-        e << "STRINGS option LIMIT_INPUT value \""
-          << args[i] << "\" is not an unsigned integer.";
+        e << "STRINGS option LIMIT_INPUT value \"" << args[i]
+          << "\" is not an unsigned integer.";
         this->SetError(e.str());
         return false;
-        }
-      arg_mode = arg_none;
       }
-    else if(arg_mode == arg_limit_output)
-      {
-      if(sscanf(args[i].c_str(), "%d", &limit_output) != 1 ||
-         limit_output < 0)
-        {
+      arg_mode = arg_none;
+    } else if (arg_mode == arg_limit_output) {
+      if (sscanf(args[i].c_str(), "%d", &limit_output) != 1 ||
+          limit_output < 0) {
         std::ostringstream e;
-        e << "STRINGS option LIMIT_OUTPUT value \""
-          << args[i] << "\" is not an unsigned integer.";
+        e << "STRINGS option LIMIT_OUTPUT value \"" << args[i]
+          << "\" is not an unsigned integer.";
         this->SetError(e.str());
         return false;
-        }
-      arg_mode = arg_none;
       }
-    else if(arg_mode == arg_limit_count)
-      {
+      arg_mode = arg_none;
+    } else if (arg_mode == arg_limit_count) {
       int count;
-      if(sscanf(args[i].c_str(), "%d", &count) != 1 || count < 0)
-        {
+      if (sscanf(args[i].c_str(), "%d", &count) != 1 || count < 0) {
         std::ostringstream e;
-        e << "STRINGS option LIMIT_COUNT value \""
-          << args[i] << "\" is not an unsigned integer.";
+        e << "STRINGS option LIMIT_COUNT value \"" << args[i]
+          << "\" is not an unsigned integer.";
         this->SetError(e.str());
         return false;
-        }
+      }
       limit_count = count;
       arg_mode = arg_none;
-      }
-    else if(arg_mode == arg_length_minimum)
-      {
+    } else if (arg_mode == arg_length_minimum) {
       int len;
-      if(sscanf(args[i].c_str(), "%d", &len) != 1 || len < 0)
-        {
+      if (sscanf(args[i].c_str(), "%d", &len) != 1 || len < 0) {
         std::ostringstream e;
-        e << "STRINGS option LENGTH_MINIMUM value \""
-          << args[i] << "\" is not an unsigned integer.";
+        e << "STRINGS option LENGTH_MINIMUM value \"" << args[i]
+          << "\" is not an unsigned integer.";
         this->SetError(e.str());
         return false;
-        }
+      }
       minlen = len;
       arg_mode = arg_none;
-      }
-    else if(arg_mode == arg_length_maximum)
-      {
+    } else if (arg_mode == arg_length_maximum) {
       int len;
-      if(sscanf(args[i].c_str(), "%d", &len) != 1 || len < 0)
-        {
+      if (sscanf(args[i].c_str(), "%d", &len) != 1 || len < 0) {
         std::ostringstream e;
-        e << "STRINGS option LENGTH_MAXIMUM value \""
-          << args[i] << "\" is not an unsigned integer.";
+        e << "STRINGS option LENGTH_MAXIMUM value \"" << args[i]
+          << "\" is not an unsigned integer.";
         this->SetError(e.str());
         return false;
-        }
+      }
       maxlen = len;
       arg_mode = arg_none;
-      }
-    else if(arg_mode == arg_regex)
-      {
-      if(!regex.compile(args[i].c_str()))
-        {
+    } else if (arg_mode == arg_regex) {
+      if (!regex.compile(args[i].c_str())) {
         std::ostringstream e;
-        e << "STRINGS option REGEX value \""
-          << args[i] << "\" could not be compiled.";
+        e << "STRINGS option REGEX value \"" << args[i]
+          << "\" could not be compiled.";
         this->SetError(e.str());
         return false;
-        }
+      }
       have_regex = true;
       arg_mode = arg_none;
-      }
-    else if(arg_mode == arg_encoding)
-      {
-      if(args[i] == "UTF-8")
-        {
+    } else if (arg_mode == arg_encoding) {
+      if (args[i] == "UTF-8") {
         encoding = encoding_utf8;
-        }
-      else if(args[i] == "UTF-16LE")
-        {
+      } else if (args[i] == "UTF-16LE") {
         encoding = encoding_utf16le;
-        }
-      else if(args[i] == "UTF-16BE")
-        {
+      } else if (args[i] == "UTF-16BE") {
         encoding = encoding_utf16be;
-        }
-      else if(args[i] == "UTF-32LE")
-        {
+      } else if (args[i] == "UTF-32LE") {
         encoding = encoding_utf32le;
-        }
-      else if(args[i] == "UTF-32BE")
-        {
+      } else if (args[i] == "UTF-32BE") {
         encoding = encoding_utf32be;
-        }
-      else
-        {
+      } else {
         std::ostringstream e;
-        e << "STRINGS option ENCODING \""
-          << args[i] << "\" not recognized.";
+        e << "STRINGS option ENCODING \"" << args[i] << "\" not recognized.";
         this->SetError(e.str());
         return false;
-        }
-      arg_mode = arg_none;
       }
-    else
-      {
+      arg_mode = arg_none;
+    } else {
       std::ostringstream e;
-      e << "STRINGS given unknown argument \""
-        << args[i] << "\"";
+      e << "STRINGS given unknown argument \"" << args[i] << "\"";
       this->SetError(e.str());
       return false;
-      }
     }
+  }
 
-  if (hex_conversion_enabled)
-    {
+  if (hex_conversion_enabled) {
     // TODO: should work without temp file, but just on a memory buffer
     std::string binaryFileName = this->Makefile->GetCurrentBinaryDirectory();
     binaryFileName += cmake::GetCMakeFilesDirectory();
     binaryFileName += "/FileCommandStringsBinaryFile";
-    if(cmHexFileConverter::TryConvert(fileName.c_str(),binaryFileName.c_str()))
-      {
+    if (cmHexFileConverter::TryConvert(fileName.c_str(),
+                                       binaryFileName.c_str())) {
       fileName = binaryFileName;
-      }
     }
+  }
 
-  // Open the specified file.
+// Open the specified file.
 #if defined(_WIN32) || defined(__CYGWIN__)
   cmsys::ifstream fin(fileName.c_str(), std::ios::in | std::ios::binary);
 #else
   cmsys::ifstream fin(fileName.c_str(), std::ios::in);
 #endif
-  if(!fin)
-    {
+  if (!fin) {
     std::ostringstream e;
     e << "STRINGS file \"" << fileName << "\" cannot be read.";
     this->SetError(e.str());
     return false;
-    }
+  }
 
-  //If BOM is found and encoding was not specified, use the BOM
+  // If BOM is found and encoding was not specified, use the BOM
   int bom_found = cmsys::FStream::ReadBOM(fin);
-  if(encoding == encoding_none && bom_found != cmsys::FStream::BOM_None)
-    {
+  if (encoding == encoding_none && bom_found != cmsys::FStream::BOM_None) {
     encoding = bom_found;
-    }
+  }
 
   unsigned int bytes_rem = 0;
-  if(encoding == encoding_utf16le || encoding == encoding_utf16be)
-    {
+  if (encoding == encoding_utf16le || encoding == encoding_utf16be) {
     bytes_rem = 1;
-    }
-  if(encoding == encoding_utf32le || encoding == encoding_utf32be)
-    {
+  }
+  if (encoding == encoding_utf32le || encoding == encoding_utf32be) {
     bytes_rem = 3;
-    }
+  }
 
   // Parse strings out of the file.
   int output_size = 0;
   std::vector<std::string> strings;
   std::string s;
-  while((!limit_count || strings.size() < limit_count) &&
-        (limit_input < 0 || static_cast<int>(fin.tellg()) < limit_input) &&
-        fin)
-    {
+  while ((!limit_count || strings.size() < limit_count) &&
+         (limit_input < 0 || static_cast<int>(fin.tellg()) < limit_input) &&
+         fin) {
     std::string current_str;
 
     int c = fin.get();
-    for(unsigned int i=0; i<bytes_rem; ++i)
-      {
+    for (unsigned int i = 0; i < bytes_rem; ++i) {
       int c1 = fin.get();
-      if(!fin)
-        {
+      if (!fin) {
         fin.putback(static_cast<char>(c1));
         break;
-        }
-      c = (c << 8) | c1;
       }
-    if(encoding == encoding_utf16le)
-      {
+      c = (c << 8) | c1;
+    }
+    if (encoding == encoding_utf16le) {
       c = ((c & 0xFF) << 8) | ((c & 0xFF00) >> 8);
-      }
-    else if(encoding == encoding_utf32le)
-      {
-       c = (((c & 0xFF) << 24) | ((c & 0xFF00) << 8) |
-          ((c & 0xFF0000) >> 8) | ((c & 0xFF000000) >> 24));
-      }
+    } else if (encoding == encoding_utf32le) {
+      c = (((c & 0xFF) << 24) | ((c & 0xFF00) << 8) | ((c & 0xFF0000) >> 8) |
+           ((c & 0xFF000000) >> 24));
+    }
 
-    if(c == '\r')
-      {
+    if (c == '\r') {
       // Ignore CR character to make output always have UNIX newlines.
       continue;
-      }
+    }
 
-    else if((c >= 0x20 && c < 0x7F) || c == '\t' ||
-            (c == '\n' && newline_consume))
-      {
+    else if ((c >= 0x20 && c < 0x7F) || c == '\t' ||
+             (c == '\n' && newline_consume)) {
       // This is an ASCII character that may be part of a string.
       // Cast added to avoid compiler warning. Cast is ok because
       // c is guaranteed to fit in char by the above if...
       current_str += static_cast<char>(c);
-      }
-    else if(encoding == encoding_utf8)
-      {
+    } else if (encoding == encoding_utf8) {
       // Check for UTF-8 encoded string (up to 4 octets)
-      static const unsigned char utf8_check_table[3][2] =
-        {
-          {0xE0, 0xC0},
-          {0xF0, 0xE0},
-          {0xF8, 0xF0},
-        };
+      static const unsigned char utf8_check_table[3][2] = {
+        { 0xE0, 0xC0 }, { 0xF0, 0xE0 }, { 0xF8, 0xF0 },
+      };
 
       // how many octets are there?
       unsigned int num_utf8_bytes = 0;
-      for(unsigned int j=0; num_utf8_bytes == 0 && j<3; j++)
-        {
-        if((c & utf8_check_table[j][0]) == utf8_check_table[j][1])
-          num_utf8_bytes = j+2;
-        }
+      for (unsigned int j = 0; num_utf8_bytes == 0 && j < 3; j++) {
+        if ((c & utf8_check_table[j][0]) == utf8_check_table[j][1])
+          num_utf8_bytes = j + 2;
+      }
 
       // get subsequent octets and check that they are valid
-      for(unsigned int j=0; j<num_utf8_bytes; j++)
-        {
-        if(j != 0)
-          {
+      for (unsigned int j = 0; j < num_utf8_bytes; j++) {
+        if (j != 0) {
           c = fin.get();
-          if(!fin || (c & 0xC0) != 0x80)
-            {
+          if (!fin || (c & 0xC0) != 0x80) {
             fin.putback(static_cast<char>(c));
             break;
-            }
           }
-        current_str += static_cast<char>(c);
         }
+        current_str += static_cast<char>(c);
+      }
 
       // if this was an invalid utf8 sequence, discard the data, and put
       // back subsequent characters
-      if((current_str.length() != num_utf8_bytes))
-        {
-        for(unsigned int j=0; j<current_str.size()-1; j++)
-          {
+      if ((current_str.length() != num_utf8_bytes)) {
+        for (unsigned int j = 0; j < current_str.size() - 1; j++) {
           c = current_str[current_str.size() - 1 - j];
           fin.putback(static_cast<char>(c));
-          }
-        current_str = "";
         }
+        current_str = "";
       }
+    }
 
-
-    if(c == '\n' && !newline_consume)
-      {
+    if (c == '\n' && !newline_consume) {
       // The current line has been terminated.  Check if the current
       // string matches the requirements.  The length may now be as
       // low as zero since blank lines are allowed.
-      if(s.length() >= minlen &&
-         (!have_regex || regex.find(s.c_str())))
-        {
+      if (s.length() >= minlen && (!have_regex || regex.find(s.c_str()))) {
         output_size += static_cast<int>(s.size()) + 1;
-        if(limit_output >= 0 && output_size >= limit_output)
-          {
+        if (limit_output >= 0 && output_size >= limit_output) {
           s = "";
           break;
-          }
-        strings.push_back(s);
         }
+        strings.push_back(s);
+      }
 
       // Reset the string to empty.
       s = "";
-      }
-    else if(current_str.empty())
-      {
+    } else if (current_str.empty()) {
       // A non-string character has been found.  Check if the current
       // string matches the requirements.  We require that the length
       // be at least one no matter what the user specified.
-      if(s.length() >= minlen && !s.empty() &&
-      (!have_regex || regex.find(s.c_str())))
-        {
+      if (s.length() >= minlen && !s.empty() &&
+          (!have_regex || regex.find(s.c_str()))) {
         output_size += static_cast<int>(s.size()) + 1;
-        if(limit_output >= 0 && output_size >= limit_output)
-          {
+        if (limit_output >= 0 && output_size >= limit_output) {
           s = "";
           break;
-          }
-        strings.push_back(s);
         }
+        strings.push_back(s);
+      }
 
       // Reset the string to empty.
       s = "";
-      }
-    else
-      {
+    } else {
       s += current_str;
-      }
-
+    }
 
-    if(maxlen > 0 && s.size() == maxlen)
-      {
+    if (maxlen > 0 && s.size() == maxlen) {
       // Terminate a string if the maximum length is reached.
-      if(s.length() >= minlen &&
-         (!have_regex || regex.find(s.c_str())))
-        {
+      if (s.length() >= minlen && (!have_regex || regex.find(s.c_str()))) {
         output_size += static_cast<int>(s.size()) + 1;
-        if(limit_output >= 0 && output_size >= limit_output)
-          {
+        if (limit_output >= 0 && output_size >= limit_output) {
           s = "";
           break;
-          }
-        strings.push_back(s);
         }
-      s = "";
+        strings.push_back(s);
       }
+      s = "";
     }
+  }
 
   // If there is a non-empty current string we have hit the end of the
   // input file or the input size limit.  Check if the current string
   // matches the requirements.
-  if((!limit_count || strings.size() < limit_count) &&
-     !s.empty() && s.length() >= minlen &&
-     (!have_regex || regex.find(s.c_str())))
-    {
+  if ((!limit_count || strings.size() < limit_count) && !s.empty() &&
+      s.length() >= minlen && (!have_regex || regex.find(s.c_str()))) {
     output_size += static_cast<int>(s.size()) + 1;
-    if(limit_output < 0 || output_size < limit_output)
-      {
+    if (limit_output < 0 || output_size < limit_output) {
       strings.push_back(s);
-      }
     }
+  }
 
   // Encode the result in a CMake list.
   const char* sep = "";
   std::string output;
-  for(std::vector<std::string>::const_iterator si = strings.begin();
-      si != strings.end(); ++si)
-    {
+  for (std::vector<std::string>::const_iterator si = strings.begin();
+       si != strings.end(); ++si) {
     // Separate the strings in the output to make it a list.
     output += sep;
     sep = ";";
@@ -866,15 +693,13 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
     // Store the string in the output, but escape semicolons to
     // make sure it is a list.
     std::string const& sr = *si;
-    for(unsigned int i=0; i < sr.size(); ++i)
-      {
-      if(sr[i] == ';')
-        {
+    for (unsigned int i = 0; i < sr.size(); ++i) {
+      if (sr[i] == ';') {
         output += '\\';
-        }
-      output += sr[i];
       }
+      output += sr[i];
     }
+  }
 
   // Save the output in a makefile variable.
   this->Makefile->AddDefinition(outVar, output.c_str());
@@ -882,7 +707,7 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
 }
 
 bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
-  bool recurse)
+                                      bool recurse)
 {
   // File commands has at least one argument
   assert(args.size() > 1);
@@ -899,10 +724,8 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
   bool explicitFollowSymlinks = false;
   cmPolicies::PolicyStatus status =
     this->Makefile->GetPolicyStatus(cmPolicies::CMP0009);
-  if(recurse)
-    {
-    switch(status)
-      {
+  if (recurse) {
+    switch (status) {
       case cmPolicies::REQUIRED_IF_USED:
       case cmPolicies::REQUIRED_ALWAYS:
       case cmPolicies::NEW:
@@ -912,154 +735,124 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
       case cmPolicies::WARN:
         g.RecurseThroughSymlinksOn();
         break;
-      }
     }
+  }
 
   std::string output = "";
   bool first = true;
-  for ( ; i != args.end(); ++i )
-    {
-    if( *i == "LIST_DIRECTORIES" )
-      {
+  for (; i != args.end(); ++i) {
+    if (*i == "LIST_DIRECTORIES") {
       ++i;
-      if(i != args.end())
-        {
-        if(cmSystemTools::IsOn(i->c_str()))
-          {
+      if (i != args.end()) {
+        if (cmSystemTools::IsOn(i->c_str())) {
           g.SetListDirs(true);
           g.SetRecurseListDirs(true);
-          }
-        else if(cmSystemTools::IsOff(i->c_str()))
-          {
+        } else if (cmSystemTools::IsOff(i->c_str())) {
           g.SetListDirs(false);
           g.SetRecurseListDirs(false);
-          }
-        else
-          {
+        } else {
           this->SetError("LIST_DIRECTORIES missing bool value.");
           return false;
-          }
         }
-      else
-        {
+      } else {
         this->SetError("LIST_DIRECTORIES missing bool value.");
         return false;
-        }
-      ++i;
       }
+      ++i;
+    }
 
-    if ( recurse && (*i == "FOLLOW_SYMLINKS") )
-      {
+    if (recurse && (*i == "FOLLOW_SYMLINKS")) {
       explicitFollowSymlinks = true;
       g.RecurseThroughSymlinksOn();
       ++i;
-      if ( i == args.end() )
-        {
+      if (i == args.end()) {
         this->SetError(
           "GLOB_RECURSE requires a glob expression after FOLLOW_SYMLINKS");
         return false;
-        }
       }
+    }
 
-    if ( *i == "RELATIVE" )
-      {
+    if (*i == "RELATIVE") {
       ++i; // skip RELATIVE
-      if ( i == args.end() )
-        {
+      if (i == args.end()) {
         this->SetError("GLOB requires a directory after the RELATIVE tag");
         return false;
-        }
+      }
       g.SetRelative(i->c_str());
       ++i;
-      if(i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("GLOB requires a glob expression after the directory");
         return false;
-        }
       }
+    }
 
     cmsys::Glob::GlobMessages globMessages;
-    if ( !cmsys::SystemTools::FileIsFullPath(i->c_str()) )
-      {
+    if (!cmsys::SystemTools::FileIsFullPath(i->c_str())) {
       std::string expr = this->Makefile->GetCurrentSourceDirectory();
       // Handle script mode
-      if (!expr.empty())
-        {
+      if (!expr.empty()) {
         expr += "/" + *i;
         g.FindFiles(expr, &globMessages);
-        }
-      else
-        {
+      } else {
         g.FindFiles(*i, &globMessages);
-        }
       }
-    else
-      {
+    } else {
       g.FindFiles(*i, &globMessages);
-      }
+    }
 
-    if(!globMessages.empty())
-      {
+    if (!globMessages.empty()) {
       bool shouldExit = false;
-      for(cmsys::Glob::GlobMessagesIterator it=globMessages.begin();
-        it != globMessages.end(); ++it)
-        {
-        if(it->type == cmsys::Glob::cyclicRecursion)
-          {
-          this->Makefile->IssueMessage(cmake::AUTHOR_WARNING,
-            "Cyclic recursion detected while globbing for '"
-            + *i + "':\n" + it->content);
-          }
-        else
-          {
-          this->Makefile->IssueMessage(cmake::FATAL_ERROR,
-            "Error has occurred while globbing for '"
-            + *i + "' - " + it->content);
+      for (cmsys::Glob::GlobMessagesIterator it = globMessages.begin();
+           it != globMessages.end(); ++it) {
+        if (it->type == cmsys::Glob::cyclicRecursion) {
+          this->Makefile->IssueMessage(
+            cmake::AUTHOR_WARNING,
+            "Cyclic recursion detected while globbing for '" + *i + "':\n" +
+              it->content);
+        } else {
+          this->Makefile->IssueMessage(
+            cmake::FATAL_ERROR, "Error has occurred while globbing for '" +
+              *i + "' - " + it->content);
           shouldExit = true;
-          }
-        }
-      if(shouldExit)
-        {
-          return false;
         }
       }
+      if (shouldExit) {
+        return false;
+      }
+    }
 
     std::vector<std::string>::size_type cc;
     std::vector<std::string>& files = g.GetFiles();
-    for ( cc = 0; cc < files.size(); cc ++ )
-      {
-      if ( !first )
-        {
+    for (cc = 0; cc < files.size(); cc++) {
+      if (!first) {
         output += ";";
-        }
+      }
       output += files[cc];
       first = false;
-      }
     }
+  }
 
-  if(recurse && !explicitFollowSymlinks)
-    {
-    switch (status)
-      {
+  if (recurse && !explicitFollowSymlinks) {
+    switch (status) {
       case cmPolicies::REQUIRED_IF_USED:
       case cmPolicies::REQUIRED_ALWAYS:
       case cmPolicies::NEW:
         // Correct behavior, yay!
         break;
       case cmPolicies::OLD:
-        // Probably not really the expected behavior, but the author explicitly
-        // asked for the old behavior... no warning.
+      // Probably not really the expected behavior, but the author explicitly
+      // asked for the old behavior... no warning.
       case cmPolicies::WARN:
         // Possibly unexpected old behavior *and* we actually traversed
         // symlinks without being explicitly asked to: warn the author.
-        if(g.GetFollowedSymlinkCount() != 0)
-          {
-          this->Makefile->IssueMessage(cmake::AUTHOR_WARNING,
+        if (g.GetFollowedSymlinkCount() != 0) {
+          this->Makefile->IssueMessage(
+            cmake::AUTHOR_WARNING,
             cmPolicies::GetPolicyWarning(cmPolicies::CMP0009));
-          }
+        }
         break;
-      }
     }
+  }
 
   this->Makefile->AddDefinition(variable, output.c_str());
   return true;
@@ -1076,35 +869,31 @@ bool cmFileCommand::HandleMakeDirectoryCommand(
   i++; // Get rid of subcommand
 
   std::string expr;
-  for ( ; i != args.end(); ++i )
-    {
+  for (; i != args.end(); ++i) {
     const std::string* cdir = &(*i);
-    if ( !cmsys::SystemTools::FileIsFullPath(i->c_str()) )
-      {
+    if (!cmsys::SystemTools::FileIsFullPath(i->c_str())) {
       expr = this->Makefile->GetCurrentSourceDirectory();
       expr += "/" + *i;
       cdir = &expr;
-      }
-    if ( !this->Makefile->CanIWriteThisFile(cdir->c_str()) )
-      {
-      std::string e = "attempted to create a directory: " + *cdir
-        + " into a source directory.";
+    }
+    if (!this->Makefile->CanIWriteThisFile(cdir->c_str())) {
+      std::string e = "attempted to create a directory: " + *cdir +
+        " into a source directory.";
       this->SetError(e);
       cmSystemTools::SetFatalErrorOccured();
       return false;
-      }
-    if ( !cmSystemTools::MakeDirectory(cdir->c_str()) )
-      {
+    }
+    if (!cmSystemTools::MakeDirectory(cdir->c_str())) {
       std::string error = "problem creating directory: " + *cdir;
       this->SetError(error);
       return false;
-      }
     }
+  }
   return true;
 }
 
-bool
-cmFileCommand::HandleDifferentCommand(std::vector<std::string> const& args)
+bool cmFileCommand::HandleDifferentCommand(
+  std::vector<std::string> const& args)
 {
   /*
     FILE(DIFFERENT <variable> FILES <lhs> <rhs>)
@@ -1114,51 +903,45 @@ cmFileCommand::HandleDifferentCommand(std::vector<std::string> const& args)
   const char* file_lhs = 0;
   const char* file_rhs = 0;
   const char* var = 0;
-  enum Doing { DoingNone, DoingVar, DoingFileLHS, DoingFileRHS };
+  enum Doing
+  {
+    DoingNone,
+    DoingVar,
+    DoingFileLHS,
+    DoingFileRHS
+  };
   Doing doing = DoingVar;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
-    if(args[i] == "FILES")
-      {
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "FILES") {
       doing = DoingFileLHS;
-      }
-    else if(doing == DoingVar)
-      {
+    } else if (doing == DoingVar) {
       var = args[i].c_str();
       doing = DoingNone;
-      }
-    else if(doing == DoingFileLHS)
-      {
+    } else if (doing == DoingFileLHS) {
       file_lhs = args[i].c_str();
       doing = DoingFileRHS;
-      }
-    else if(doing == DoingFileRHS)
-      {
+    } else if (doing == DoingFileRHS) {
       file_rhs = args[i].c_str();
       doing = DoingNone;
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "DIFFERENT given unknown argument " << args[i];
       this->SetError(e.str());
       return false;
-      }
     }
-  if(!var)
-    {
+  }
+  if (!var) {
     this->SetError("DIFFERENT not given result variable name.");
     return false;
-    }
-  if(!file_lhs || !file_rhs)
-    {
+  }
+  if (!file_lhs || !file_rhs) {
     this->SetError("DIFFERENT not given FILES option with two file names.");
     return false;
-    }
+  }
 
   // Compare the files.
   const char* result =
-    cmSystemTools::FilesDiffer(file_lhs, file_rhs)? "1" : "0";
+    cmSystemTools::FilesDiffer(file_lhs, file_rhs) ? "1" : "0";
   this->Makefile->AddDefinition(var, result);
   return true;
 }
@@ -1166,26 +949,26 @@ cmFileCommand::HandleDifferentCommand(std::vector<std::string> const& args)
 // File installation helper class.
 struct cmFileCopier
 {
-  cmFileCopier(cmFileCommand* command, const char* name = "COPY"):
-    FileCommand(command),
-    Makefile(command->GetMakefile()),
-    Name(name),
-    Always(false),
-    MatchlessFiles(true),
-    FilePermissions(0),
-    DirPermissions(0),
-    CurrentMatchRule(0),
-    UseGivenPermissionsFile(false),
-    UseGivenPermissionsDir(false),
-    UseSourcePermissions(true),
-    Doing(DoingNone)
-    {
-    }
+  cmFileCopier(cmFileCommand* command, const char* name = "COPY")
+    : FileCommand(command)
+    , Makefile(command->GetMakefile())
+    , Name(name)
+    , Always(false)
+    , MatchlessFiles(true)
+    , FilePermissions(0)
+    , DirPermissions(0)
+    , CurrentMatchRule(0)
+    , UseGivenPermissionsFile(false)
+    , UseGivenPermissionsDir(false)
+    , UseSourcePermissions(true)
+    , Doing(DoingNone)
+  {
+  }
   virtual ~cmFileCopier() {}
 
   bool Run(std::vector<std::string> const& args);
-protected:
 
+protected:
   cmFileCommand* FileCommand;
   cmMakefile* Makefile;
   const char* Name;
@@ -1204,7 +987,11 @@ protected:
   {
     bool Exclude;
     mode_t Permissions;
-    MatchProperties(): Exclude(false), Permissions(0) {}
+    MatchProperties()
+      : Exclude(false)
+      , Permissions(0)
+    {
+    }
   };
   struct MatchRule;
   friend struct MatchRule;
@@ -1213,15 +1000,18 @@ protected:
     cmsys::RegularExpression Regex;
     MatchProperties Properties;
     std::string RegexString;
-    MatchRule(std::string const& regex):
-      Regex(regex.c_str()), RegexString(regex) {}
+    MatchRule(std::string const& regex)
+      : Regex(regex.c_str())
+      , RegexString(regex)
+    {
+    }
   };
   std::vector<MatchRule> MatchRules;
 
   // Get the properties from rules matching this input file.
   MatchProperties CollectMatchProperties(const char* file)
-    {
-    // Match rules are case-insensitive on some platforms.
+  {
+// Match rules are case-insensitive on some platforms.
 #if defined(_WIN32) || defined(__APPLE__) || defined(__CYGWIN__)
     std::string lower = cmSystemTools::LowerCase(file);
     const char* file_to_match = lower.c_str();
@@ -1232,58 +1022,64 @@ protected:
     // Collect properties from all matching rules.
     bool matched = false;
     MatchProperties result;
-    for(std::vector<MatchRule>::iterator mr = this->MatchRules.begin();
-        mr != this->MatchRules.end(); ++mr)
-      {
-      if(mr->Regex.find(file_to_match))
-        {
+    for (std::vector<MatchRule>::iterator mr = this->MatchRules.begin();
+         mr != this->MatchRules.end(); ++mr) {
+      if (mr->Regex.find(file_to_match)) {
         matched = true;
         result.Exclude |= mr->Properties.Exclude;
         result.Permissions |= mr->Properties.Permissions;
-        }
       }
-    if(!matched && !this->MatchlessFiles)
-      {
+    }
+    if (!matched && !this->MatchlessFiles) {
       result.Exclude = !cmSystemTools::FileIsDirectory(file);
-      }
-    return result;
     }
+    return result;
+  }
 
   bool SetPermissions(const char* toFile, mode_t permissions)
-    {
-    if(permissions && !cmSystemTools::SetPermissions(toFile, permissions))
-      {
+  {
+    if (permissions && !cmSystemTools::SetPermissions(toFile, permissions)) {
       std::ostringstream e;
       e << this->Name << " cannot set permissions on \"" << toFile << "\"";
       this->FileCommand->SetError(e.str());
       return false;
-      }
-    return true;
     }
+    return true;
+  }
 
   // Translate an argument to a permissions bit.
   bool CheckPermissions(std::string const& arg, mode_t& permissions)
-    {
-    if(arg == "OWNER_READ")         { permissions |= mode_owner_read; }
-    else if(arg == "OWNER_WRITE")   { permissions |= mode_owner_write; }
-    else if(arg == "OWNER_EXECUTE") { permissions |= mode_owner_execute; }
-    else if(arg == "GROUP_READ")    { permissions |= mode_group_read; }
-    else if(arg == "GROUP_WRITE")   { permissions |= mode_group_write; }
-    else if(arg == "GROUP_EXECUTE") { permissions |= mode_group_execute; }
-    else if(arg == "WORLD_READ")    { permissions |= mode_world_read; }
-    else if(arg == "WORLD_WRITE")   { permissions |= mode_world_write; }
-    else if(arg == "WORLD_EXECUTE") { permissions |= mode_world_execute; }
-    else if(arg == "SETUID")        { permissions |= mode_setuid; }
-    else if(arg == "SETGID")        { permissions |= mode_setgid; }
-    else
-      {
+  {
+    if (arg == "OWNER_READ") {
+      permissions |= mode_owner_read;
+    } else if (arg == "OWNER_WRITE") {
+      permissions |= mode_owner_write;
+    } else if (arg == "OWNER_EXECUTE") {
+      permissions |= mode_owner_execute;
+    } else if (arg == "GROUP_READ") {
+      permissions |= mode_group_read;
+    } else if (arg == "GROUP_WRITE") {
+      permissions |= mode_group_write;
+    } else if (arg == "GROUP_EXECUTE") {
+      permissions |= mode_group_execute;
+    } else if (arg == "WORLD_READ") {
+      permissions |= mode_world_read;
+    } else if (arg == "WORLD_WRITE") {
+      permissions |= mode_world_write;
+    } else if (arg == "WORLD_EXECUTE") {
+      permissions |= mode_world_execute;
+    } else if (arg == "SETUID") {
+      permissions |= mode_setuid;
+    } else if (arg == "SETGID") {
+      permissions |= mode_setgid;
+    } else {
       std::ostringstream e;
       e << this->Name << " given invalid permission \"" << arg << "\".";
       this->FileCommand->SetError(e.str());
       return false;
-      }
-    return true;
     }
+    return true;
+  }
 
   bool InstallSymlink(const char* fromFile, const char* toFile);
   bool InstallFile(const char* fromFile, const char* toFile,
@@ -1292,7 +1088,9 @@ protected:
                         MatchProperties const& match_properties);
   virtual bool Install(const char* fromFile, const char* toFile);
   virtual std::string const& ToName(std::string const& fromName)
-    { return fromName; }
+  {
+    return fromName;
+  }
 
   enum Type
   {
@@ -1302,13 +1100,13 @@ protected:
   };
   virtual void ReportCopy(const char*, Type, bool) {}
   virtual bool ReportMissing(const char* fromFile)
-    {
+  {
     // The input file does not exist and installation is not optional.
     std::ostringstream e;
     e << this->Name << " cannot find \"" << fromFile << "\".";
     this->FileCommand->SetError(e.str());
     return false;
-    }
+  }
 
   MatchRule* CurrentMatchRule;
   bool UseGivenPermissionsFile;
@@ -1336,30 +1134,30 @@ protected:
   virtual bool CheckValue(std::string const& arg);
 
   void NotBeforeMatch(std::string const& arg)
-    {
+  {
     std::ostringstream e;
     e << "option " << arg << " may not appear before PATTERN or REGEX.";
     this->FileCommand->SetError(e.str());
     this->Doing = DoingError;
-    }
+  }
   void NotAfterMatch(std::string const& arg)
-    {
+  {
     std::ostringstream e;
     e << "option " << arg << " may not appear after PATTERN or REGEX.";
     this->FileCommand->SetError(e.str());
     this->Doing = DoingError;
-    }
+  }
   virtual void DefaultFilePermissions()
-    {
+  {
     // Use read/write permissions.
     this->FilePermissions = 0;
     this->FilePermissions |= mode_owner_read;
     this->FilePermissions |= mode_owner_write;
     this->FilePermissions |= mode_group_read;
     this->FilePermissions |= mode_world_read;
-    }
+  }
   virtual void DefaultDirectoryPermissions()
-    {
+  {
     // Use read/write/executable permissions.
     this->DirPermissions = 0;
     this->DirPermissions |= mode_owner_read;
@@ -1369,197 +1167,137 @@ protected:
     this->DirPermissions |= mode_group_execute;
     this->DirPermissions |= mode_world_read;
     this->DirPermissions |= mode_world_execute;
-    }
+  }
 };
 
 bool cmFileCopier::Parse(std::vector<std::string> const& args)
 {
   this->Doing = DoingFiles;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
+  for (unsigned int i = 1; i < args.size(); ++i) {
     // Check this argument.
-    if(!this->CheckKeyword(args[i]) &&
-       !this->CheckValue(args[i]))
-      {
+    if (!this->CheckKeyword(args[i]) && !this->CheckValue(args[i])) {
       std::ostringstream e;
       e << "called with unknown argument \"" << args[i] << "\".";
       this->FileCommand->SetError(e.str());
       return false;
-      }
+    }
 
     // Quit if an argument is invalid.
-    if(this->Doing == DoingError)
-      {
+    if (this->Doing == DoingError) {
       return false;
-      }
     }
+  }
 
   // Require a destination.
-  if(this->Destination.empty())
-    {
+  if (this->Destination.empty()) {
     std::ostringstream e;
     e << this->Name << " given no DESTINATION";
     this->FileCommand->SetError(e.str());
     return false;
-    }
+  }
 
   // If file permissions were not specified set default permissions.
-  if(!this->UseGivenPermissionsFile && !this->UseSourcePermissions)
-    {
+  if (!this->UseGivenPermissionsFile && !this->UseSourcePermissions) {
     this->DefaultFilePermissions();
-    }
+  }
 
   // If directory permissions were not specified set default permissions.
-  if(!this->UseGivenPermissionsDir && !this->UseSourcePermissions)
-    {
+  if (!this->UseGivenPermissionsDir && !this->UseSourcePermissions) {
     this->DefaultDirectoryPermissions();
-    }
+  }
 
   return true;
 }
 
 bool cmFileCopier::CheckKeyword(std::string const& arg)
 {
-  if(arg == "DESTINATION")
-    {
-    if(this->CurrentMatchRule)
-      {
+  if (arg == "DESTINATION") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingDestination;
-      }
     }
-  else if(arg == "PATTERN")
-    {
+  } else if (arg == "PATTERN") {
     this->Doing = DoingPattern;
-    }
-  else if(arg == "REGEX")
-    {
+  } else if (arg == "REGEX") {
     this->Doing = DoingRegex;
-    }
-  else if(arg == "EXCLUDE")
-    {
+  } else if (arg == "EXCLUDE") {
     // Add this property to the current match rule.
-    if(this->CurrentMatchRule)
-      {
+    if (this->CurrentMatchRule) {
       this->CurrentMatchRule->Properties.Exclude = true;
       this->Doing = DoingNone;
-      }
-    else
-      {
+    } else {
       this->NotBeforeMatch(arg);
-      }
     }
-  else if(arg == "PERMISSIONS")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "PERMISSIONS") {
+    if (this->CurrentMatchRule) {
       this->Doing = DoingPermissionsMatch;
-      }
-    else
-      {
+    } else {
       this->NotBeforeMatch(arg);
-      }
     }
-  else if(arg == "FILE_PERMISSIONS")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "FILE_PERMISSIONS") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingPermissionsFile;
       this->UseGivenPermissionsFile = true;
-      }
     }
-  else if(arg == "DIRECTORY_PERMISSIONS")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "DIRECTORY_PERMISSIONS") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingPermissionsDir;
       this->UseGivenPermissionsDir = true;
-      }
     }
-  else if(arg == "USE_SOURCE_PERMISSIONS")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "USE_SOURCE_PERMISSIONS") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingNone;
       this->UseSourcePermissions = true;
-      }
     }
-  else if(arg == "NO_SOURCE_PERMISSIONS")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "NO_SOURCE_PERMISSIONS") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingNone;
       this->UseSourcePermissions = false;
-      }
     }
-  else if(arg == "FILES_MATCHING")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "FILES_MATCHING") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingNone;
       this->MatchlessFiles = false;
-      }
     }
-  else
-    {
+  } else {
     return false;
-    }
+  }
   return true;
 }
 
 bool cmFileCopier::CheckValue(std::string const& arg)
 {
-  switch(this->Doing)
-    {
+  switch (this->Doing) {
     case DoingFiles:
-      if(arg.empty() || cmSystemTools::FileIsFullPath(arg.c_str()))
-        {
+      if (arg.empty() || cmSystemTools::FileIsFullPath(arg.c_str())) {
         this->Files.push_back(arg);
-        }
-      else
-        {
+      } else {
         std::string file = this->Makefile->GetCurrentSourceDirectory();
         file += "/" + arg;
         this->Files.push_back(file);
-        }
+      }
       break;
     case DoingDestination:
-      if(arg.empty() || cmSystemTools::FileIsFullPath(arg.c_str()))
-        {
+      if (arg.empty() || cmSystemTools::FileIsFullPath(arg.c_str())) {
         this->Destination = arg;
-        }
-      else
-        {
+      } else {
         this->Destination = this->Makefile->GetCurrentBinaryDirectory();
         this->Destination += "/" + arg;
-        }
+      }
       this->Doing = DoingNone;
       break;
-    case DoingPattern:
-      {
+    case DoingPattern: {
       // Convert the pattern to a regular expression.  Require a
       // leading slash and trailing end-of-string in the matched
       // string to make sure the pattern matches only whole file
@@ -1568,138 +1306,114 @@ bool cmFileCopier::CheckValue(std::string const& arg)
       regex += cmsys::Glob::PatternToRegex(arg, false);
       regex += "$";
       this->MatchRules.push_back(MatchRule(regex));
-      this->CurrentMatchRule = &*(this->MatchRules.end()-1);
-      if(this->CurrentMatchRule->Regex.is_valid())
-        {
+      this->CurrentMatchRule = &*(this->MatchRules.end() - 1);
+      if (this->CurrentMatchRule->Regex.is_valid()) {
         this->Doing = DoingNone;
-        }
-      else
-        {
+      } else {
         std::ostringstream e;
         e << "could not compile PATTERN \"" << arg << "\".";
         this->FileCommand->SetError(e.str());
         this->Doing = DoingError;
-        }
       }
-      break;
+    } break;
     case DoingRegex:
       this->MatchRules.push_back(MatchRule(arg));
-      this->CurrentMatchRule = &*(this->MatchRules.end()-1);
-      if(this->CurrentMatchRule->Regex.is_valid())
-        {
+      this->CurrentMatchRule = &*(this->MatchRules.end() - 1);
+      if (this->CurrentMatchRule->Regex.is_valid()) {
         this->Doing = DoingNone;
-        }
-      else
-        {
+      } else {
         std::ostringstream e;
         e << "could not compile REGEX \"" << arg << "\".";
         this->FileCommand->SetError(e.str());
         this->Doing = DoingError;
-        }
+      }
       break;
     case DoingPermissionsFile:
-      if(!this->CheckPermissions(arg, this->FilePermissions))
-        {
+      if (!this->CheckPermissions(arg, this->FilePermissions)) {
         this->Doing = DoingError;
-        }
+      }
       break;
     case DoingPermissionsDir:
-      if(!this->CheckPermissions(arg, this->DirPermissions))
-        {
+      if (!this->CheckPermissions(arg, this->DirPermissions)) {
         this->Doing = DoingError;
-        }
+      }
       break;
     case DoingPermissionsMatch:
-      if(!this->CheckPermissions(
-           arg, this->CurrentMatchRule->Properties.Permissions))
-        {
+      if (!this->CheckPermissions(
+            arg, this->CurrentMatchRule->Properties.Permissions)) {
         this->Doing = DoingError;
-        }
+      }
       break;
     default:
       return false;
-    }
+  }
   return true;
 }
 
 bool cmFileCopier::Run(std::vector<std::string> const& args)
 {
-  if(!this->Parse(args))
-    {
+  if (!this->Parse(args)) {
     return false;
-    }
+  }
 
   std::vector<std::string> const& files = this->Files;
-  for(std::vector<std::string>::size_type i = 0; i < files.size(); ++i)
-    {
+  for (std::vector<std::string>::size_type i = 0; i < files.size(); ++i) {
     // Split the input file into its directory and name components.
     std::vector<std::string> fromPathComponents;
     cmSystemTools::SplitPath(files[i], fromPathComponents);
-    std::string fromName = *(fromPathComponents.end()-1);
-    std::string fromDir = cmSystemTools::JoinPath(fromPathComponents.begin(),
-                                                  fromPathComponents.end()-1);
+    std::string fromName = *(fromPathComponents.end() - 1);
+    std::string fromDir = cmSystemTools::JoinPath(
+      fromPathComponents.begin(), fromPathComponents.end() - 1);
 
     // Compute the full path to the destination file.
     std::string toFile = this->Destination;
     std::string const& toName = this->ToName(fromName);
-    if(!toName.empty())
-      {
+    if (!toName.empty()) {
       toFile += "/";
       toFile += toName;
-      }
+    }
 
     // Construct the full path to the source file.  The file name may
     // have been changed above.
     std::string fromFile = fromDir;
-    if(!fromName.empty())
-      {
+    if (!fromName.empty()) {
       fromFile += "/";
       fromFile += fromName;
-      }
+    }
 
-    if(!this->Install(fromFile.c_str(), toFile.c_str()))
-      {
+    if (!this->Install(fromFile.c_str(), toFile.c_str())) {
       return false;
-      }
     }
+  }
   return true;
 }
 
 bool cmFileCopier::Install(const char* fromFile, const char* toFile)
 {
-  if(!*fromFile)
-    {
+  if (!*fromFile) {
     std::ostringstream e;
     e << "INSTALL encountered an empty string input file name.";
     this->FileCommand->SetError(e.str());
     return false;
-    }
+  }
 
   // Collect any properties matching this file name.
   MatchProperties match_properties = this->CollectMatchProperties(fromFile);
 
   // Skip the file if it is excluded.
-  if(match_properties.Exclude)
-    {
+  if (match_properties.Exclude) {
     return true;
-    }
+  }
 
-  if(cmSystemTools::SameFile(fromFile, toFile))
-    {
+  if (cmSystemTools::SameFile(fromFile, toFile)) {
     return true;
-    }
-  else if(cmSystemTools::FileIsSymlink(fromFile))
-    {
+  } else if (cmSystemTools::FileIsSymlink(fromFile)) {
     return this->InstallSymlink(fromFile, toFile);
-    }
-  else if(cmSystemTools::FileIsDirectory(fromFile))
-    {
+  } else if (cmSystemTools::FileIsDirectory(fromFile)) {
     return this->InstallDirectory(fromFile, toFile, match_properties);
-    }
-  else if(cmSystemTools::FileExists(fromFile))
-    {
+  } else if (cmSystemTools::FileExists(fromFile)) {
     return this->InstallFile(fromFile, toFile, match_properties);
-    }
+  }
   return this->ReportMissing(fromFile);
 }
 
@@ -1707,48 +1421,42 @@ bool cmFileCopier::InstallSymlink(const char* fromFile, const char* toFile)
 {
   // Read the original symlink.
   std::string symlinkTarget;
-  if(!cmSystemTools::ReadSymlink(fromFile, symlinkTarget))
-    {
+  if (!cmSystemTools::ReadSymlink(fromFile, symlinkTarget)) {
     std::ostringstream e;
     e << this->Name << " cannot read symlink \"" << fromFile
       << "\" to duplicate at \"" << toFile << "\".";
     this->FileCommand->SetError(e.str());
     return false;
-    }
+  }
 
   // Compare the symlink value to that at the destination if not
   // always installing.
   bool copy = true;
-  if(!this->Always)
-    {
+  if (!this->Always) {
     std::string oldSymlinkTarget;
-    if(cmSystemTools::ReadSymlink(toFile, oldSymlinkTarget))
-      {
-      if(symlinkTarget == oldSymlinkTarget)
-        {
+    if (cmSystemTools::ReadSymlink(toFile, oldSymlinkTarget)) {
+      if (symlinkTarget == oldSymlinkTarget) {
         copy = false;
-        }
       }
     }
+  }
 
   // Inform the user about this file installation.
   this->ReportCopy(toFile, TypeLink, copy);
 
-  if(copy)
-    {
+  if (copy) {
     // Remove the destination file so we can always create the symlink.
     cmSystemTools::RemoveFile(toFile);
 
     // Create the symlink.
-    if(!cmSystemTools::CreateSymlink(symlinkTarget, toFile))
-      {
+    if (!cmSystemTools::CreateSymlink(symlinkTarget, toFile)) {
       std::ostringstream e;
-      e << this->Name <<  " cannot duplicate symlink \"" << fromFile
+      e << this->Name << " cannot duplicate symlink \"" << fromFile
         << "\" at \"" << toFile << "\".";
       this->FileCommand->SetError(e.str());
       return false;
-      }
     }
+  }
 
   return true;
 }
@@ -1758,57 +1466,51 @@ bool cmFileCopier::InstallFile(const char* fromFile, const char* toFile,
 {
   // Determine whether we will copy the file.
   bool copy = true;
-  if(!this->Always)
-    {
+  if (!this->Always) {
     // If both files exist with the same time do not copy.
-    if(!this->FileTimes.FileTimesDiffer(fromFile, toFile))
-      {
+    if (!this->FileTimes.FileTimesDiffer(fromFile, toFile)) {
       copy = false;
-      }
     }
+  }
 
   // Inform the user about this file installation.
   this->ReportCopy(toFile, TypeFile, copy);
 
   // Copy the file.
-  if(copy && !cmSystemTools::CopyAFile(fromFile, toFile, true))
-    {
+  if (copy && !cmSystemTools::CopyAFile(fromFile, toFile, true)) {
     std::ostringstream e;
-    e << this->Name << " cannot copy file \"" << fromFile
-      << "\" to \"" << toFile << "\".";
+    e << this->Name << " cannot copy file \"" << fromFile << "\" to \""
+      << toFile << "\".";
     this->FileCommand->SetError(e.str());
     return false;
-    }
+  }
 
   // Set the file modification time of the destination file.
-  if(copy && !this->Always)
-    {
+  if (copy && !this->Always) {
     // Add write permission so we can set the file time.
     // Permissions are set unconditionally below anyway.
     mode_t perm = 0;
-    if(cmSystemTools::GetPermissions(toFile, perm))
-      {
+    if (cmSystemTools::GetPermissions(toFile, perm)) {
       cmSystemTools::SetPermissions(toFile, perm | mode_owner_write);
-      }
-    if (!cmSystemTools::CopyFileTime(fromFile, toFile))
-      {
+    }
+    if (!cmSystemTools::CopyFileTime(fromFile, toFile)) {
       std::ostringstream e;
-      e << this->Name << " cannot set modification time on \""
-        << toFile << "\"";
+      e << this->Name << " cannot set modification time on \"" << toFile
+        << "\"";
       this->FileCommand->SetError(e.str());
       return false;
-      }
     }
+  }
 
   // Set permissions of the destination file.
-  mode_t permissions = (match_properties.Permissions?
-                        match_properties.Permissions : this->FilePermissions);
-  if(!permissions)
-    {
+  mode_t permissions =
+    (match_properties.Permissions ? match_properties.Permissions
+                                  : this->FilePermissions);
+  if (!permissions) {
     // No permissions were explicitly provided but the user requested
     // that the source file permissions be used.
     cmSystemTools::GetPermissions(fromFile, permissions);
-    }
+  }
   return this->SetPermissions(toFile, permissions);
 }
 
@@ -1821,24 +1523,23 @@ bool cmFileCopier::InstallDirectory(const char* source,
                    !cmSystemTools::FileIsDirectory(destination));
 
   // Make sure the destination directory exists.
-  if(!cmSystemTools::MakeDirectory(destination))
-    {
+  if (!cmSystemTools::MakeDirectory(destination)) {
     std::ostringstream e;
-    e << this->Name << " cannot make directory \"" << destination << "\": "
-      << cmSystemTools::GetLastSystemError();
+    e << this->Name << " cannot make directory \"" << destination
+      << "\": " << cmSystemTools::GetLastSystemError();
     this->FileCommand->SetError(e.str());
     return false;
-    }
+  }
 
   // Compute the requested permissions for the destination directory.
-  mode_t permissions = (match_properties.Permissions?
-                        match_properties.Permissions : this->DirPermissions);
-  if(!permissions)
-    {
+  mode_t permissions =
+    (match_properties.Permissions ? match_properties.Permissions
+                                  : this->DirPermissions);
+  if (!permissions) {
     // No permissions were explicitly provided but the user requested
     // that the source directory permissions be used.
     cmSystemTools::GetPermissions(source, permissions);
-    }
+  }
 
   // Compute the set of permissions required on this directory to
   // recursively install files and subdirectories safely.
@@ -1850,46 +1551,38 @@ bool cmFileCopier::InstallDirectory(const char* source,
   // permissions temporarily during file installation.
   mode_t permissions_before = 0;
   mode_t permissions_after = 0;
-  if((permissions & required_permissions) == required_permissions)
-    {
+  if ((permissions & required_permissions) == required_permissions) {
     permissions_before = permissions;
-    }
-  else
-    {
+  } else {
     permissions_before = permissions | required_permissions;
     permissions_after = permissions;
-    }
+  }
 
   // Set the required permissions of the destination directory.
-  if(!this->SetPermissions(destination, permissions_before))
-    {
+  if (!this->SetPermissions(destination, permissions_before)) {
     return false;
-    }
+  }
 
   // Load the directory contents to traverse it recursively.
   cmsys::Directory dir;
-  if(source && *source)
-    {
+  if (source && *source) {
     dir.Load(source);
-    }
+  }
   unsigned long numFiles = static_cast<unsigned long>(dir.GetNumberOfFiles());
-  for(unsigned long fileNum = 0; fileNum < numFiles; ++fileNum)
-    {
-    if(!(strcmp(dir.GetFile(fileNum), ".") == 0 ||
-         strcmp(dir.GetFile(fileNum), "..") == 0))
-      {
+  for (unsigned long fileNum = 0; fileNum < numFiles; ++fileNum) {
+    if (!(strcmp(dir.GetFile(fileNum), ".") == 0 ||
+          strcmp(dir.GetFile(fileNum), "..") == 0)) {
       std::string fromPath = source;
       fromPath += "/";
       fromPath += dir.GetFile(fileNum);
       std::string toPath = destination;
       toPath += "/";
       toPath += dir.GetFile(fileNum);
-      if(!this->Install(fromPath.c_str(), toPath.c_str()))
-        {
+      if (!this->Install(fromPath.c_str(), toPath.c_str())) {
         return false;
-        }
       }
     }
+  }
 
   // Set the requested permissions of the destination directory.
   return this->SetPermissions(destination, permissions_after);
@@ -1901,17 +1594,17 @@ bool cmFileCommand::HandleCopyCommand(std::vector<std::string> const& args)
   return copier.Run(args);
 }
 
-struct cmFileInstaller: public cmFileCopier
+struct cmFileInstaller : public cmFileCopier
 {
-  cmFileInstaller(cmFileCommand* command):
-    cmFileCopier(command, "INSTALL"),
-    InstallType(cmInstallType_FILES),
-    Optional(false),
-    MessageAlways(false),
-    MessageLazy(false),
-    MessageNever(false),
-    DestDirLength(0)
-    {
+  cmFileInstaller(cmFileCommand* command)
+    : cmFileCopier(command, "INSTALL")
+    , InstallType(cmInstallType_FILES)
+    , Optional(false)
+    , MessageAlways(false)
+    , MessageLazy(false)
+    , MessageNever(false)
+    , DestDirLength(0)
+  {
     // Installation does not use source permissions by default.
     this->UseSourcePermissions = false;
     // Check whether to copy files always or only if they have changed.
@@ -1920,13 +1613,13 @@ struct cmFileInstaller: public cmFileCopier
     // Get the current manifest.
     this->Manifest =
       this->Makefile->GetSafeDefinition("CMAKE_INSTALL_MANIFEST_FILES");
-    }
+  }
   ~cmFileInstaller()
-    {
+  {
     // Save the updated install manifest.
     this->Makefile->AddDefinition("CMAKE_INSTALL_MANIFEST_FILES",
                                   this->Manifest.c_str());
-    }
+  }
 
 protected:
   cmInstallType InstallType;
@@ -1939,45 +1632,42 @@ protected:
 
   std::string Manifest;
   void ManifestAppend(std::string const& file)
-    {
-    if (!this->Manifest.empty())
-      {
+  {
+    if (!this->Manifest.empty()) {
       this->Manifest += ";";
-      }
-    this->Manifest += file.substr(this->DestDirLength);
     }
+    this->Manifest += file.substr(this->DestDirLength);
+  }
 
   virtual std::string const& ToName(std::string const& fromName)
-    { return this->Rename.empty()? fromName : this->Rename; }
+  {
+    return this->Rename.empty() ? fromName : this->Rename;
+  }
 
   virtual void ReportCopy(const char* toFile, Type type, bool copy)
-    {
-    if(!this->MessageNever && (copy || !this->MessageLazy))
-      {
-      std::string message = (copy? "Installing: " : "Up-to-date: ");
+  {
+    if (!this->MessageNever && (copy || !this->MessageLazy)) {
+      std::string message = (copy ? "Installing: " : "Up-to-date: ");
       message += toFile;
       this->Makefile->DisplayStatus(message.c_str(), -1);
-      }
-    if(type != TypeDir)
-      {
+    }
+    if (type != TypeDir) {
       // Add the file to the manifest.
       this->ManifestAppend(toFile);
-      }
     }
+  }
   virtual bool ReportMissing(const char* fromFile)
-    {
-    return (this->Optional ||
-            this->cmFileCopier::ReportMissing(fromFile));
-    }
+  {
+    return (this->Optional || this->cmFileCopier::ReportMissing(fromFile));
+  }
   virtual bool Install(const char* fromFile, const char* toFile)
-    {
+  {
     // Support installing from empty source to make a directory.
-    if(this->InstallType == cmInstallType_DIRECTORY && !*fromFile)
-      {
+    if (this->InstallType == cmInstallType_DIRECTORY && !*fromFile) {
       return this->InstallDirectory(fromFile, toFile, MatchProperties());
-      }
-    return this->cmFileCopier::Install(fromFile, toFile);
     }
+    return this->cmFileCopier::Install(fromFile, toFile);
+  }
 
   virtual bool Parse(std::vector<std::string> const& args);
   enum
@@ -1989,255 +1679,181 @@ protected:
   virtual bool CheckKeyword(std::string const& arg);
   virtual bool CheckValue(std::string const& arg);
   virtual void DefaultFilePermissions()
-    {
+  {
     this->cmFileCopier::DefaultFilePermissions();
     // Add execute permissions based on the target type.
-    switch(this->InstallType)
-      {
+    switch (this->InstallType) {
       case cmInstallType_SHARED_LIBRARY:
       case cmInstallType_MODULE_LIBRARY:
-        if(this->Makefile->IsOn("CMAKE_INSTALL_SO_NO_EXE"))
-          {
+        if (this->Makefile->IsOn("CMAKE_INSTALL_SO_NO_EXE")) {
           break;
-          }
+        }
       case cmInstallType_EXECUTABLE:
       case cmInstallType_PROGRAMS:
         this->FilePermissions |= mode_owner_execute;
         this->FilePermissions |= mode_group_execute;
         this->FilePermissions |= mode_world_execute;
         break;
-      default: break;
-      }
+      default:
+        break;
     }
+  }
   bool GetTargetTypeFromString(const std::string& stype);
   bool HandleInstallDestination();
 };
 
 bool cmFileInstaller::Parse(std::vector<std::string> const& args)
 {
-  if(!this->cmFileCopier::Parse(args))
-    {
+  if (!this->cmFileCopier::Parse(args)) {
     return false;
-    }
+  }
 
-  if(!this->Rename.empty())
-    {
-    if(this->InstallType != cmInstallType_FILES &&
-       this->InstallType != cmInstallType_PROGRAMS)
-      {
+  if (!this->Rename.empty()) {
+    if (this->InstallType != cmInstallType_FILES &&
+        this->InstallType != cmInstallType_PROGRAMS) {
       this->FileCommand->SetError("INSTALL option RENAME may be used "
                                   "only with FILES or PROGRAMS.");
       return false;
-      }
-    if(this->Files.size() > 1)
-      {
+    }
+    if (this->Files.size() > 1) {
       this->FileCommand->SetError("INSTALL option RENAME may be used "
                                   "only with one file.");
       return false;
-      }
     }
+  }
 
-  if(!this->HandleInstallDestination())
-    {
+  if (!this->HandleInstallDestination()) {
     return false;
-    }
+  }
 
-  if(((this->MessageAlways?1:0) +
-      (this->MessageLazy?1:0) +
-      (this->MessageNever?1:0)) > 1)
-    {
+  if (((this->MessageAlways ? 1 : 0) + (this->MessageLazy ? 1 : 0) +
+       (this->MessageNever ? 1 : 0)) > 1) {
     this->FileCommand->SetError("INSTALL options MESSAGE_ALWAYS, "
                                 "MESSAGE_LAZY, and MESSAGE_NEVER "
                                 "are mutually exclusive.");
     return false;
-    }
+  }
 
   return true;
 }
 
 bool cmFileInstaller::CheckKeyword(std::string const& arg)
 {
-  if(arg == "TYPE")
-    {
-    if(this->CurrentMatchRule)
-      {
+  if (arg == "TYPE") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingType;
-      }
     }
-  else if(arg == "FILES")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "FILES") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingFiles;
-      }
     }
-  else if(arg == "RENAME")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "RENAME") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingRename;
-      }
     }
-  else if(arg == "OPTIONAL")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "OPTIONAL") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingNone;
       this->Optional = true;
-      }
     }
-  else if(arg == "MESSAGE_ALWAYS")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "MESSAGE_ALWAYS") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingNone;
       this->MessageAlways = true;
-      }
     }
-  else if(arg == "MESSAGE_LAZY")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "MESSAGE_LAZY") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingNone;
       this->MessageLazy = true;
-      }
     }
-  else if(arg == "MESSAGE_NEVER")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "MESSAGE_NEVER") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingNone;
       this->MessageNever = true;
-      }
     }
-  else if(arg == "PERMISSIONS")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "PERMISSIONS") {
+    if (this->CurrentMatchRule) {
       this->Doing = DoingPermissionsMatch;
-      }
-    else
-      {
+    } else {
       // file(INSTALL) aliases PERMISSIONS to FILE_PERMISSIONS
       this->Doing = DoingPermissionsFile;
       this->UseGivenPermissionsFile = true;
-      }
     }
-  else if(arg == "DIR_PERMISSIONS")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "DIR_PERMISSIONS") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       // file(INSTALL) aliases DIR_PERMISSIONS to DIRECTORY_PERMISSIONS
       this->Doing = DoingPermissionsDir;
       this->UseGivenPermissionsDir = true;
-      }
     }
-  else if(arg == "COMPONENTS" || arg == "CONFIGURATIONS" ||
-          arg == "PROPERTIES")
-    {
+  } else if (arg == "COMPONENTS" || arg == "CONFIGURATIONS" ||
+             arg == "PROPERTIES") {
     std::ostringstream e;
     e << "INSTALL called with old-style " << arg << " argument.  "
       << "This script was generated with an older version of CMake.  "
       << "Re-run this cmake version on your build tree.";
     this->FileCommand->SetError(e.str());
     this->Doing = DoingError;
-    }
-  else
-    {
+  } else {
     return this->cmFileCopier::CheckKeyword(arg);
-    }
+  }
   return true;
 }
 
 bool cmFileInstaller::CheckValue(std::string const& arg)
 {
-  switch(this->Doing)
-    {
+  switch (this->Doing) {
     case DoingType:
-      if(!this->GetTargetTypeFromString(arg))
-        {
+      if (!this->GetTargetTypeFromString(arg)) {
         this->Doing = DoingError;
-        }
+      }
       break;
     case DoingRename:
       this->Rename = arg;
       break;
     default:
       return this->cmFileCopier::CheckValue(arg);
-    }
+  }
   return true;
 }
 
-bool cmFileInstaller
-::GetTargetTypeFromString(const std::string& stype)
+bool cmFileInstaller::GetTargetTypeFromString(const std::string& stype)
 {
-  if ( stype == "EXECUTABLE" )
-    {
+  if (stype == "EXECUTABLE") {
     this->InstallType = cmInstallType_EXECUTABLE;
-    }
-  else if ( stype == "FILE" )
-    {
+  } else if (stype == "FILE") {
     this->InstallType = cmInstallType_FILES;
-    }
-  else if ( stype == "PROGRAM" )
-    {
+  } else if (stype == "PROGRAM") {
     this->InstallType = cmInstallType_PROGRAMS;
-    }
-  else if ( stype == "STATIC_LIBRARY" )
-    {
+  } else if (stype == "STATIC_LIBRARY") {
     this->InstallType = cmInstallType_STATIC_LIBRARY;
-    }
-  else if ( stype == "SHARED_LIBRARY" )
-    {
+  } else if (stype == "SHARED_LIBRARY") {
     this->InstallType = cmInstallType_SHARED_LIBRARY;
-    }
-  else if ( stype == "MODULE" )
-    {
+  } else if (stype == "MODULE") {
     this->InstallType = cmInstallType_MODULE_LIBRARY;
-    }
-  else if ( stype == "DIRECTORY" )
-    {
+  } else if (stype == "DIRECTORY") {
     this->InstallType = cmInstallType_DIRECTORY;
-    }
-  else
-    {
+  } else {
     std::ostringstream e;
     e << "Option TYPE given unknown value \"" << stype << "\".";
     this->FileCommand->SetError(e.str());
     return false;
-    }
+  }
   return true;
 }
 
@@ -2246,46 +1862,37 @@ bool cmFileInstaller::HandleInstallDestination()
   std::string& destination = this->Destination;
 
   // allow for / to be a valid destination
-  if ( destination.size() < 2 && destination != "/" )
-    {
+  if (destination.size() < 2 && destination != "/") {
     this->FileCommand->SetError("called with inappropriate arguments. "
-        "No DESTINATION provided or .");
+                                "No DESTINATION provided or .");
     return false;
-    }
+  }
 
   const char* destdir = cmSystemTools::GetEnv("DESTDIR");
-  if ( destdir && *destdir )
-    {
+  if (destdir && *destdir) {
     std::string sdestdir = destdir;
     cmSystemTools::ConvertToUnixSlashes(sdestdir);
     char ch1 = destination[0];
     char ch2 = destination[1];
     char ch3 = 0;
-    if ( destination.size() > 2 )
-      {
+    if (destination.size() > 2) {
       ch3 = destination[2];
-      }
+    }
     int skip = 0;
-    if ( ch1 != '/' )
-      {
+    if (ch1 != '/') {
       int relative = 0;
       if (((ch1 >= 'a' && ch1 <= 'z') || (ch1 >= 'A' && ch1 <= 'Z')) &&
-             ch2 == ':' )
-        {
+          ch2 == ':') {
         // Assume windows
         // let's do some destdir magic:
         skip = 2;
-        if ( ch3 != '/' )
-          {
+        if (ch3 != '/') {
           relative = 1;
-          }
         }
-      else
-        {
+      } else {
         relative = 1;
-        }
-      if ( relative )
-        {
+      }
+      if (relative) {
         // This is relative path on unix or windows. Since we are doing
         // destdir, this case does not make sense.
         this->FileCommand->SetError(
@@ -2293,124 +1900,105 @@ bool cmFileInstaller::HandleInstallDestination()
           "does not make sense when using DESTDIR. Specify "
           "absolute path or remove DESTDIR environment variable.");
         return false;
-        }
       }
-    else
-      {
-      if ( ch2 == '/' )
-        {
+    } else {
+      if (ch2 == '/') {
         // looks like a network path.
-        std::string message = "called with network path DESTINATION. This "
+        std::string message =
+          "called with network path DESTINATION. This "
           "does not make sense when using DESTDIR. Specify local "
           "absolute path or remove DESTDIR environment variable."
           "\nDESTINATION=\n";
         message += destination;
         this->FileCommand->SetError(message);
         return false;
-        }
       }
+    }
     destination = sdestdir + (destination.c_str() + skip);
     this->DestDirLength = int(sdestdir.size());
-    }
+  }
 
-  if(this->InstallType != cmInstallType_DIRECTORY)
-    {
-    if ( !cmSystemTools::FileExists(destination.c_str()) )
-      {
-      if ( !cmSystemTools::MakeDirectory(destination.c_str()) )
-        {
+  if (this->InstallType != cmInstallType_DIRECTORY) {
+    if (!cmSystemTools::FileExists(destination.c_str())) {
+      if (!cmSystemTools::MakeDirectory(destination.c_str())) {
         std::string errstring = "cannot create directory: " + destination +
           ". Maybe need administrative privileges.";
         this->FileCommand->SetError(errstring);
         return false;
-        }
       }
-    if ( !cmSystemTools::FileIsDirectory(destination) )
-      {
-      std::string errstring = "INSTALL destination: " + destination +
-        " is not a directory.";
+    }
+    if (!cmSystemTools::FileIsDirectory(destination)) {
+      std::string errstring =
+        "INSTALL destination: " + destination + " is not a directory.";
       this->FileCommand->SetError(errstring);
       return false;
-      }
     }
+  }
   return true;
 }
 
-bool
-cmFileCommand::HandleRPathChangeCommand(std::vector<std::string> const& args)
+bool cmFileCommand::HandleRPathChangeCommand(
+  std::vector<std::string> const& args)
 {
   // Evaluate arguments.
   const char* file = 0;
   const char* oldRPath = 0;
   const char* newRPath = 0;
-  enum Doing { DoingNone, DoingFile, DoingOld, DoingNew };
+  enum Doing
+  {
+    DoingNone,
+    DoingFile,
+    DoingOld,
+    DoingNew
+  };
   Doing doing = DoingNone;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
-    if(args[i] == "OLD_RPATH")
-      {
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "OLD_RPATH") {
       doing = DoingOld;
-      }
-    else if(args[i] == "NEW_RPATH")
-      {
+    } else if (args[i] == "NEW_RPATH") {
       doing = DoingNew;
-      }
-    else if(args[i] == "FILE")
-      {
+    } else if (args[i] == "FILE") {
       doing = DoingFile;
-      }
-    else if(doing == DoingFile)
-      {
+    } else if (doing == DoingFile) {
       file = args[i].c_str();
       doing = DoingNone;
-      }
-    else if(doing == DoingOld)
-      {
+    } else if (doing == DoingOld) {
       oldRPath = args[i].c_str();
       doing = DoingNone;
-      }
-    else if(doing == DoingNew)
-      {
+    } else if (doing == DoingNew) {
       newRPath = args[i].c_str();
       doing = DoingNone;
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "RPATH_CHANGE given unknown argument " << args[i];
       this->SetError(e.str());
       return false;
-      }
     }
-  if(!file)
-    {
+  }
+  if (!file) {
     this->SetError("RPATH_CHANGE not given FILE option.");
     return false;
-    }
-  if(!oldRPath)
-    {
+  }
+  if (!oldRPath) {
     this->SetError("RPATH_CHANGE not given OLD_RPATH option.");
     return false;
-    }
-  if(!newRPath)
-    {
+  }
+  if (!newRPath) {
     this->SetError("RPATH_CHANGE not given NEW_RPATH option.");
     return false;
-    }
-  if(!cmSystemTools::FileExists(file, true))
-    {
+  }
+  if (!cmSystemTools::FileExists(file, true)) {
     std::ostringstream e;
     e << "RPATH_CHANGE given FILE \"" << file << "\" that does not exist.";
     this->SetError(e.str());
     return false;
-    }
+  }
   bool success = true;
   cmSystemToolsFileTime* ft = cmSystemTools::FileTimeNew();
   bool have_ft = cmSystemTools::FileTimeGet(file, ft);
   std::string emsg;
   bool changed;
-  if(!cmSystemTools::ChangeRPath(file, oldRPath, newRPath, &emsg, &changed))
-    {
+  if (!cmSystemTools::ChangeRPath(file, oldRPath, newRPath, &emsg, &changed)) {
     std::ostringstream e;
     /* clang-format off */
     e << "RPATH_CHANGE could not write new RPATH:\n"
@@ -2421,72 +2009,64 @@ cmFileCommand::HandleRPathChangeCommand(std::vector<std::string> const& args)
     /* clang-format on */
     this->SetError(e.str());
     success = false;
-    }
-  if(success)
-    {
-    if(changed)
-      {
+  }
+  if (success) {
+    if (changed) {
       std::string message = "Set runtime path of \"";
       message += file;
       message += "\" to \"";
       message += newRPath;
       message += "\"";
       this->Makefile->DisplayStatus(message.c_str(), -1);
-      }
-    if(have_ft)
-      {
+    }
+    if (have_ft) {
       cmSystemTools::FileTimeSet(file, ft);
-      }
     }
+  }
   cmSystemTools::FileTimeDelete(ft);
   return success;
 }
 
-bool
-cmFileCommand::HandleRPathRemoveCommand(std::vector<std::string> const& args)
+bool cmFileCommand::HandleRPathRemoveCommand(
+  std::vector<std::string> const& args)
 {
   // Evaluate arguments.
   const char* file = 0;
-  enum Doing { DoingNone, DoingFile };
+  enum Doing
+  {
+    DoingNone,
+    DoingFile
+  };
   Doing doing = DoingNone;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
-    if(args[i] == "FILE")
-      {
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "FILE") {
       doing = DoingFile;
-      }
-    else if(doing == DoingFile)
-      {
+    } else if (doing == DoingFile) {
       file = args[i].c_str();
       doing = DoingNone;
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "RPATH_REMOVE given unknown argument " << args[i];
       this->SetError(e.str());
       return false;
-      }
     }
-  if(!file)
-    {
+  }
+  if (!file) {
     this->SetError("RPATH_REMOVE not given FILE option.");
     return false;
-    }
-  if(!cmSystemTools::FileExists(file, true))
-    {
+  }
+  if (!cmSystemTools::FileExists(file, true)) {
     std::ostringstream e;
     e << "RPATH_REMOVE given FILE \"" << file << "\" that does not exist.";
     this->SetError(e.str());
     return false;
-    }
+  }
   bool success = true;
   cmSystemToolsFileTime* ft = cmSystemTools::FileTimeNew();
   bool have_ft = cmSystemTools::FileTimeGet(file, ft);
   std::string emsg;
   bool removed;
-  if(!cmSystemTools::RemoveRPath(file, &emsg, &removed))
-    {
+  if (!cmSystemTools::RemoveRPath(file, &emsg, &removed)) {
     std::ostringstream e;
     /* clang-format off */
     e << "RPATH_REMOVE could not remove RPATH from file:\n"
@@ -2495,80 +2075,69 @@ cmFileCommand::HandleRPathRemoveCommand(std::vector<std::string> const& args)
     /* clang-format on */
     this->SetError(e.str());
     success = false;
-    }
-  if(success)
-    {
-    if(removed)
-      {
+  }
+  if (success) {
+    if (removed) {
       std::string message = "Removed runtime path from \"";
       message += file;
       message += "\"";
       this->Makefile->DisplayStatus(message.c_str(), -1);
-      }
-    if(have_ft)
-      {
+    }
+    if (have_ft) {
       cmSystemTools::FileTimeSet(file, ft);
-      }
     }
+  }
   cmSystemTools::FileTimeDelete(ft);
   return success;
 }
 
-bool
-cmFileCommand::HandleRPathCheckCommand(std::vector<std::string> const& args)
+bool cmFileCommand::HandleRPathCheckCommand(
+  std::vector<std::string> const& args)
 {
   // Evaluate arguments.
   const char* file = 0;
   const char* rpath = 0;
-  enum Doing { DoingNone, DoingFile, DoingRPath };
+  enum Doing
+  {
+    DoingNone,
+    DoingFile,
+    DoingRPath
+  };
   Doing doing = DoingNone;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
-    if(args[i] == "RPATH")
-      {
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "RPATH") {
       doing = DoingRPath;
-      }
-    else if(args[i] == "FILE")
-      {
+    } else if (args[i] == "FILE") {
       doing = DoingFile;
-      }
-    else if(doing == DoingFile)
-      {
+    } else if (doing == DoingFile) {
       file = args[i].c_str();
       doing = DoingNone;
-      }
-    else if(doing == DoingRPath)
-      {
+    } else if (doing == DoingRPath) {
       rpath = args[i].c_str();
       doing = DoingNone;
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "RPATH_CHECK given unknown argument " << args[i];
       this->SetError(e.str());
       return false;
-      }
     }
-  if(!file)
-    {
+  }
+  if (!file) {
     this->SetError("RPATH_CHECK not given FILE option.");
     return false;
-    }
-  if(!rpath)
-    {
+  }
+  if (!rpath) {
     this->SetError("RPATH_CHECK not given RPATH option.");
     return false;
-    }
+  }
 
   // If the file exists but does not have the desired RPath then
   // delete it.  This is used during installation to re-install a file
   // if its RPath will change.
-  if(cmSystemTools::FileExists(file, true) &&
-     !cmSystemTools::CheckRPath(file, rpath))
-    {
+  if (cmSystemTools::FileExists(file, true) &&
+      !cmSystemTools::CheckRPath(file, rpath)) {
     cmSystemTools::RemoveFile(file);
-    }
+  }
 
   return true;
 }
@@ -2582,65 +2151,55 @@ bool cmFileCommand::HandleInstallCommand(std::vector<std::string> const& args)
 bool cmFileCommand::HandleRelativePathCommand(
   std::vector<std::string> const& args)
 {
-  if(args.size() != 4 )
-    {
+  if (args.size() != 4) {
     this->SetError("RELATIVE_PATH called with incorrect number of arguments");
     return false;
-    }
+  }
 
   const std::string& outVar = args[1];
   const std::string& directoryName = args[2];
   const std::string& fileName = args[3];
 
-  if(!cmSystemTools::FileIsFullPath(directoryName.c_str()))
-    {
+  if (!cmSystemTools::FileIsFullPath(directoryName.c_str())) {
     std::string errstring =
-      "RELATIVE_PATH must be passed a full path to the directory: "
-      + directoryName;
+      "RELATIVE_PATH must be passed a full path to the directory: " +
+      directoryName;
     this->SetError(errstring);
     return false;
-    }
-  if(!cmSystemTools::FileIsFullPath(fileName.c_str()))
-    {
+  }
+  if (!cmSystemTools::FileIsFullPath(fileName.c_str())) {
     std::string errstring =
-      "RELATIVE_PATH must be passed a full path to the file: "
-      + fileName;
+      "RELATIVE_PATH must be passed a full path to the file: " + fileName;
     this->SetError(errstring);
     return false;
-    }
+  }
 
-  std::string res = cmSystemTools::RelativePath(directoryName.c_str(),
-                                                fileName.c_str());
-  this->Makefile->AddDefinition(outVar,
-    res.c_str());
+  std::string res =
+    cmSystemTools::RelativePath(directoryName.c_str(), fileName.c_str());
+  this->Makefile->AddDefinition(outVar, res.c_str());
   return true;
 }
 
-
 bool cmFileCommand::HandleRename(std::vector<std::string> const& args)
 {
-  if(args.size() != 3)
-    {
+  if (args.size() != 3) {
     this->SetError("RENAME given incorrect number of arguments.");
     return false;
-    }
+  }
 
   // Compute full path for old and new names.
   std::string oldname = args[1];
-  if(!cmsys::SystemTools::FileIsFullPath(oldname.c_str()))
-    {
+  if (!cmsys::SystemTools::FileIsFullPath(oldname.c_str())) {
     oldname = this->Makefile->GetCurrentSourceDirectory();
     oldname += "/" + args[1];
-    }
+  }
   std::string newname = args[2];
-  if(!cmsys::SystemTools::FileIsFullPath(newname.c_str()))
-    {
+  if (!cmsys::SystemTools::FileIsFullPath(newname.c_str())) {
     newname = this->Makefile->GetCurrentSourceDirectory();
     newname += "/" + args[2];
-    }
+  }
 
-  if(!cmSystemTools::RenameFile(oldname.c_str(), newname.c_str()))
-    {
+  if (!cmSystemTools::RenameFile(oldname.c_str(), newname.c_str())) {
     std::string err = cmSystemTools::GetLastSystemError();
     std::ostringstream e;
     /* clang-format off */
@@ -2652,11 +2211,10 @@ bool cmFileCommand::HandleRename(std::vector<std::string> const& args)
     /* clang-format on */
     this->SetError(e.str());
     return false;
-    }
+  }
   return true;
 }
 
-
 bool cmFileCommand::HandleRemove(std::vector<std::string> const& args,
                                  bool recurse)
 {
@@ -2665,79 +2223,64 @@ bool cmFileCommand::HandleRemove(std::vector<std::string> const& args,
   std::vector<std::string>::const_iterator i = args.begin();
 
   i++; // Get rid of subcommand
-  for(;i != args.end(); ++i)
-    {
+  for (; i != args.end(); ++i) {
     std::string fileName = *i;
-    if(!cmsys::SystemTools::FileIsFullPath(fileName.c_str()))
-      {
+    if (!cmsys::SystemTools::FileIsFullPath(fileName.c_str())) {
       fileName = this->Makefile->GetCurrentSourceDirectory();
       fileName += "/" + *i;
-      }
+    }
 
-    if(cmSystemTools::FileIsDirectory(fileName) &&
-       !cmSystemTools::FileIsSymlink(fileName) && recurse)
-      {
+    if (cmSystemTools::FileIsDirectory(fileName) &&
+        !cmSystemTools::FileIsSymlink(fileName) && recurse) {
       cmSystemTools::RemoveADirectory(fileName);
-      }
-    else
-      {
+    } else {
       cmSystemTools::RemoveFile(fileName);
-      }
     }
+  }
   return true;
 }
 
-bool cmFileCommand::HandleCMakePathCommand(std::vector<std::string>
-                                           const& args,
-                                           bool nativePath)
+bool cmFileCommand::HandleCMakePathCommand(
+  std::vector<std::string> const& args, bool nativePath)
 {
   std::vector<std::string>::const_iterator i = args.begin();
-  if(args.size() != 3)
-    {
+  if (args.size() != 3) {
     this->SetError("FILE([TO_CMAKE_PATH|TO_NATIVE_PATH] path result) must be "
-      "called with exactly three arguments.");
+                   "called with exactly three arguments.");
     return false;
-    }
+  }
   i++; // Get rid of subcommand
 #if defined(_WIN32) && !defined(__CYGWIN__)
   char pathSep = ';';
 #else
   char pathSep = ':';
 #endif
-  std::vector<cmsys::String> path = cmSystemTools::SplitString(*i,
-                                                             pathSep);
+  std::vector<cmsys::String> path = cmSystemTools::SplitString(*i, pathSep);
   i++;
-  const char* var =  i->c_str();
+  const char* var = i->c_str();
   std::string value;
-  for(std::vector<cmsys::String>::iterator j = path.begin();
-      j != path.end(); ++j)
-    {
-    if(j != path.begin())
-      {
+  for (std::vector<cmsys::String>::iterator j = path.begin(); j != path.end();
+       ++j) {
+    if (j != path.begin()) {
       value += ";";
-      }
-    if(!nativePath)
-      {
+    }
+    if (!nativePath) {
       cmSystemTools::ConvertToUnixSlashes(*j);
-      }
-    else
-      {
+    } else {
       *j = cmSystemTools::ConvertToOutputPath(j->c_str());
       // remove double quotes in the path
       cmsys::String& s = *j;
 
-      if(s.size() > 1 && s[0] == '\"' && s[s.size()-1] == '\"')
-        {
-        s = s.substr(1,s.size()-2);
-        }
+      if (s.size() > 1 && s[0] == '\"' && s[s.size() - 1] == '\"') {
+        s = s.substr(1, s.size() - 2);
       }
-    value += *j;
     }
+    value += *j;
+  }
   this->Makefile->AddDefinition(var, value.c_str());
   return true;
 }
 
-
 #if defined(CMAKE_BUILD_WITH_CMAKE)
 
 // Stuff for curl download/upload
@@ -2745,212 +2288,181 @@ typedef std::vector<char> cmFileCommandVectorOfChar;
 
 namespace {
 
-  size_t
-  cmWriteToFileCallback(void *ptr, size_t size, size_t nmemb,
-                        void *data)
-    {
-    int realsize = (int)(size * nmemb);
-    cmsys::ofstream* fout = static_cast<cmsys::ofstream*>(data);
-    const char* chPtr = static_cast<char*>(ptr);
-    fout->write(chPtr, realsize);
-    return realsize;
-    }
-
-
-  size_t
-  cmWriteToMemoryCallback(void *ptr, size_t size, size_t nmemb,
-                          void *data)
-    {
-    int realsize = (int)(size * nmemb);
-    cmFileCommandVectorOfChar *vec
-      = static_cast<cmFileCommandVectorOfChar*>(data);
-    const char* chPtr = static_cast<char*>(ptr);
-    vec->insert(vec->end(), chPtr, chPtr + realsize);
-    return realsize;
-    }
-
+size_t cmWriteToFileCallback(void* ptr, size_t size, size_t nmemb, void* data)
+{
+  int realsize = (int)(size * nmemb);
+  cmsys::ofstream* fout = static_cast<cmsys::ofstream*>(data);
+  const char* chPtr = static_cast<char*>(ptr);
+  fout->write(chPtr, realsize);
+  return realsize;
+}
 
-  static size_t
-  cmFileCommandCurlDebugCallback(CURL *, curl_infotype type, char *chPtr,
-                                 size_t size, void *data)
-    {
-    cmFileCommandVectorOfChar *vec
-      = static_cast<cmFileCommandVectorOfChar*>(data);
-    switch(type)
-      {
-      case CURLINFO_TEXT:
-      case CURLINFO_HEADER_IN:
-      case CURLINFO_HEADER_OUT:
-        vec->insert(vec->end(), chPtr, chPtr + size);
-        break;
-      case CURLINFO_DATA_IN:
-      case CURLINFO_DATA_OUT:
-      case CURLINFO_SSL_DATA_IN:
-      case CURLINFO_SSL_DATA_OUT:
-        {
-        char buf[128];
-        int n = sprintf(buf, "[%" KWIML_INT_PRIu64 " bytes data]\n",
-                        static_cast<KWIML_INT_uint64_t>(size));
-        if (n > 0)
-          {
-          vec->insert(vec->end(), buf, buf + n);
-          }
-        }
-        break;
-      default:
-        break;
-      }
-    return 0;
-    }
+size_t cmWriteToMemoryCallback(void* ptr, size_t size, size_t nmemb,
+                               void* data)
+{
+  int realsize = (int)(size * nmemb);
+  cmFileCommandVectorOfChar* vec =
+    static_cast<cmFileCommandVectorOfChar*>(data);
+  const char* chPtr = static_cast<char*>(ptr);
+  vec->insert(vec->end(), chPtr, chPtr + realsize);
+  return realsize;
+}
 
+static size_t cmFileCommandCurlDebugCallback(CURL*, curl_infotype type,
+                                             char* chPtr, size_t size,
+                                             void* data)
+{
+  cmFileCommandVectorOfChar* vec =
+    static_cast<cmFileCommandVectorOfChar*>(data);
+  switch (type) {
+    case CURLINFO_TEXT:
+    case CURLINFO_HEADER_IN:
+    case CURLINFO_HEADER_OUT:
+      vec->insert(vec->end(), chPtr, chPtr + size);
+      break;
+    case CURLINFO_DATA_IN:
+    case CURLINFO_DATA_OUT:
+    case CURLINFO_SSL_DATA_IN:
+    case CURLINFO_SSL_DATA_OUT: {
+      char buf[128];
+      int n = sprintf(buf, "[%" KWIML_INT_PRIu64 " bytes data]\n",
+                      static_cast<KWIML_INT_uint64_t>(size));
+      if (n > 0) {
+        vec->insert(vec->end(), buf, buf + n);
+      }
+    } break;
+    default:
+      break;
+  }
+  return 0;
+}
 
-  class cURLProgressHelper
+class cURLProgressHelper
+{
+public:
+  cURLProgressHelper(cmFileCommand* fc, const char* text)
   {
-  public:
-    cURLProgressHelper(cmFileCommand *fc, const char *text)
-      {
-      this->CurrentPercentage = -1;
-      this->FileCommand = fc;
-      this->Text = text;
-      }
-
-    bool UpdatePercentage(double value, double total, std::string &status)
-      {
-      int OldPercentage = this->CurrentPercentage;
-
-      if (total > 0.0)
-        {
-        this->CurrentPercentage = static_cast<int>(value/total*100.0 + 0.5);
-        if(this->CurrentPercentage > 100)
-          {
-          // Avoid extra progress reports for unexpected data beyond total.
-          this->CurrentPercentage = 100;
-          }
-        }
-
-      bool updated = (OldPercentage != this->CurrentPercentage);
+    this->CurrentPercentage = -1;
+    this->FileCommand = fc;
+    this->Text = text;
+  }
 
-      if (updated)
-        {
-        std::ostringstream oss;
-        oss << "[" << this->Text << " " << this->CurrentPercentage
-            << "% complete]";
-        status = oss.str();
-        }
+  bool UpdatePercentage(double value, double total, std::string& status)
+  {
+    int OldPercentage = this->CurrentPercentage;
 
-      return updated;
+    if (total > 0.0) {
+      this->CurrentPercentage = static_cast<int>(value / total * 100.0 + 0.5);
+      if (this->CurrentPercentage > 100) {
+        // Avoid extra progress reports for unexpected data beyond total.
+        this->CurrentPercentage = 100;
       }
+    }
 
-    cmFileCommand *GetFileCommand()
-      {
-      return this->FileCommand;
-      }
+    bool updated = (OldPercentage != this->CurrentPercentage);
 
-  private:
-    int CurrentPercentage;
-    cmFileCommand *FileCommand;
-    std::string Text;
-  };
+    if (updated) {
+      std::ostringstream oss;
+      oss << "[" << this->Text << " " << this->CurrentPercentage
+          << "% complete]";
+      status = oss.str();
+    }
 
+    return updated;
+  }
 
-  static int
-  cmFileDownloadProgressCallback(void *clientp,
-                                 double dltotal, double dlnow,
-                                 double ultotal, double ulnow)
-    {
-    cURLProgressHelper *helper =
-      reinterpret_cast<cURLProgressHelper *>(clientp);
+  cmFileCommand* GetFileCommand() { return this->FileCommand; }
 
-    static_cast<void>(ultotal);
-    static_cast<void>(ulnow);
+private:
+  int CurrentPercentage;
+  cmFileCommand* FileCommand;
+  std::string Text;
+};
 
-    std::string status;
-    if (helper->UpdatePercentage(dlnow, dltotal, status))
-      {
-      cmFileCommand *fc = helper->GetFileCommand();
-      cmMakefile *mf = fc->GetMakefile();
-      mf->DisplayStatus(status.c_str(), -1);
-      }
+static int cmFileDownloadProgressCallback(void* clientp, double dltotal,
+                                          double dlnow, double ultotal,
+                                          double ulnow)
+{
+  cURLProgressHelper* helper = reinterpret_cast<cURLProgressHelper*>(clientp);
 
-    return 0;
-    }
+  static_cast<void>(ultotal);
+  static_cast<void>(ulnow);
 
+  std::string status;
+  if (helper->UpdatePercentage(dlnow, dltotal, status)) {
+    cmFileCommand* fc = helper->GetFileCommand();
+    cmMakefile* mf = fc->GetMakefile();
+    mf->DisplayStatus(status.c_str(), -1);
+  }
 
-  static int
-  cmFileUploadProgressCallback(void *clientp,
-                               double dltotal, double dlnow,
-                               double ultotal, double ulnow)
-    {
-    cURLProgressHelper *helper =
-    reinterpret_cast<cURLProgressHelper *>(clientp);
+  return 0;
+}
+
+static int cmFileUploadProgressCallback(void* clientp, double dltotal,
+                                        double dlnow, double ultotal,
+                                        double ulnow)
+{
+  cURLProgressHelper* helper = reinterpret_cast<cURLProgressHelper*>(clientp);
 
-    static_cast<void>(dltotal);
-    static_cast<void>(dlnow);
+  static_cast<void>(dltotal);
+  static_cast<void>(dlnow);
 
-    std::string status;
-    if (helper->UpdatePercentage(ulnow, ultotal, status))
-      {
-      cmFileCommand *fc = helper->GetFileCommand();
-      cmMakefile *mf = fc->GetMakefile();
-      mf->DisplayStatus(status.c_str(), -1);
-      }
+  std::string status;
+  if (helper->UpdatePercentage(ulnow, ultotal, status)) {
+    cmFileCommand* fc = helper->GetFileCommand();
+    cmMakefile* mf = fc->GetMakefile();
+    mf->DisplayStatus(status.c_str(), -1);
+  }
 
-    return 0;
-    }
+  return 0;
+}
 }
-
 
 namespace {
 
-  class cURLEasyGuard
+class cURLEasyGuard
+{
+public:
+  cURLEasyGuard(CURL* easy)
+    : Easy(easy)
   {
-  public:
-    cURLEasyGuard(CURL * easy)
-      : Easy(easy)
-      {}
-
-    ~cURLEasyGuard(void)
-      {
-        if (this->Easy)
-          {
-          ::curl_easy_cleanup(this->Easy);
-          }
-      }
+  }
 
-    inline void release(void)
-      {
-        this->Easy = 0;
-        return;
-      }
+  ~cURLEasyGuard(void)
+  {
+    if (this->Easy) {
+      ::curl_easy_cleanup(this->Easy);
+    }
+  }
 
-  private:
-    ::CURL * Easy;
-  };
+  inline void release(void)
+  {
+    this->Easy = 0;
+    return;
+  }
 
+private:
+  ::CURL* Easy;
+};
 }
 #endif
 
+#define check_curl_result(result, errstr)                                     \
+  if (result != CURLE_OK) {                                                   \
+    std::string e(errstr);                                                    \
+    e += ::curl_easy_strerror(result);                                        \
+    this->SetError(e);                                                        \
+    return false;                                                             \
+  }
 
-#define check_curl_result(result, errstr) \
-  if (result != CURLE_OK)                 \
-    {                                     \
-    std::string e(errstr);                \
-    e += ::curl_easy_strerror(result);    \
-    this->SetError(e);            \
-    return false;                         \
-    }
-
-
-bool
-cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
+bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
 {
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   std::vector<std::string>::const_iterator i = args.begin();
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     this->SetError("DOWNLOAD must be called with at least three arguments.");
     return false;
-    }
+  }
   ++i; // Get rid of subcommand
   std::string url = *i;
   ++i;
@@ -2968,183 +2480,140 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
   cmsys::auto_ptr<cmCryptoHash> hash;
   bool showProgress = false;
 
-  while(i != args.end())
-    {
-    if(*i == "TIMEOUT")
-      {
+  while (i != args.end()) {
+    if (*i == "TIMEOUT") {
       ++i;
-      if(i != args.end())
-        {
+      if (i != args.end()) {
         timeout = atol(i->c_str());
-        }
-      else
-        {
+      } else {
         this->SetError("DOWNLOAD missing time for TIMEOUT.");
         return false;
-        }
       }
-    else if(*i == "INACTIVITY_TIMEOUT")
-      {
+    } else if (*i == "INACTIVITY_TIMEOUT") {
       ++i;
-      if(i != args.end())
-        {
+      if (i != args.end()) {
         inactivity_timeout = atol(i->c_str());
-        }
-      else
-        {
+      } else {
         this->SetError("DOWNLOAD missing time for INACTIVITY_TIMEOUT.");
         return false;
-        }
       }
-    else if(*i == "LOG")
-      {
+    } else if (*i == "LOG") {
       ++i;
-      if( i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("DOWNLOAD missing VAR for LOG.");
         return false;
-        }
-      logVar = *i;
       }
-    else if(*i == "STATUS")
-      {
+      logVar = *i;
+    } else if (*i == "STATUS") {
       ++i;
-      if( i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("DOWNLOAD missing VAR for STATUS.");
         return false;
-        }
-      statusVar = *i;
       }
-    else if(*i == "TLS_VERIFY")
-      {
+      statusVar = *i;
+    } else if (*i == "TLS_VERIFY") {
       ++i;
-      if(i != args.end())
-        {
+      if (i != args.end()) {
         tls_verify = cmSystemTools::IsOn(i->c_str());
-        }
-      else
-        {
+      } else {
         this->SetError("TLS_VERIFY missing bool value.");
         return false;
-        }
       }
-    else if(*i == "TLS_CAINFO")
-      {
+    } else if (*i == "TLS_CAINFO") {
       ++i;
-      if(i != args.end())
-        {
+      if (i != args.end()) {
         cainfo = i->c_str();
-        }
-      else
-        {
+      } else {
         this->SetError("TLS_CAFILE missing file value.");
         return false;
-        }
       }
-    else if(*i == "EXPECTED_MD5")
-      {
+    } else if (*i == "EXPECTED_MD5") {
       ++i;
-      if( i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("DOWNLOAD missing sum value for EXPECTED_MD5.");
         return false;
-        }
+      }
       hash = cmsys::auto_ptr<cmCryptoHash>(cmCryptoHash::New("MD5"));
       hashMatchMSG = "MD5 sum";
       expectedHash = cmSystemTools::LowerCase(*i);
-      }
-    else if(*i == "SHOW_PROGRESS")
-      {
+    } else if (*i == "SHOW_PROGRESS") {
       showProgress = true;
-      }
-    else if(*i == "EXPECTED_HASH")
-      {
+    } else if (*i == "EXPECTED_HASH") {
       ++i;
-      if(i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("DOWNLOAD missing ALGO=value for EXPECTED_HASH.");
         return false;
-        }
+      }
       std::string::size_type pos = i->find("=");
-      if(pos == std::string::npos)
-        {
+      if (pos == std::string::npos) {
         std::string err =
           "DOWNLOAD EXPECTED_HASH expects ALGO=value but got: ";
         err += *i;
         this->SetError(err);
         return false;
-        }
+      }
       std::string algo = i->substr(0, pos);
-      expectedHash = cmSystemTools::LowerCase(i->substr(pos+1));
+      expectedHash = cmSystemTools::LowerCase(i->substr(pos + 1));
       hash = cmsys::auto_ptr<cmCryptoHash>(cmCryptoHash::New(algo.c_str()));
-      if(!hash.get())
-        {
+      if (!hash.get()) {
         std::string err = "DOWNLOAD EXPECTED_HASH given unknown ALGO: ";
         err += algo;
         this->SetError(err);
         return false;
-        }
-      hashMatchMSG = algo + " hash";
       }
-    ++i;
+      hashMatchMSG = algo + " hash";
     }
+    ++i;
+  }
   // If file exists already, and caller specified an expected md5 or sha,
   // and the existing file already has the expected hash, then simply
   // return.
   //
-  if(cmSystemTools::FileExists(file.c_str()) && hash.get())
-    {
+  if (cmSystemTools::FileExists(file.c_str()) && hash.get()) {
     std::string msg;
     std::string actualHash = hash->HashFile(file);
-    if(actualHash == expectedHash)
-      {
+    if (actualHash == expectedHash) {
       msg = "returning early; file already exists with expected ";
       msg += hashMatchMSG;
       msg += "\"";
-      if(!statusVar.empty())
-        {
+      if (!statusVar.empty()) {
         std::ostringstream result;
         result << (int)0 << ";\"" << msg;
-        this->Makefile->AddDefinition(statusVar,
-                                      result.str().c_str());
-        }
-      return true;
+        this->Makefile->AddDefinition(statusVar, result.str().c_str());
       }
+      return true;
     }
+  }
   // Make sure parent directory exists so we can write to the file
   // as we receive downloaded bits from curl...
   //
   std::string dir = cmSystemTools::GetFilenamePath(file);
-  if(!cmSystemTools::FileExists(dir.c_str()) &&
-     !cmSystemTools::MakeDirectory(dir.c_str()))
-    {
-    std::string errstring = "DOWNLOAD error: cannot create directory '"
-      + dir + "' - Specify file by full path name and verify that you "
+  if (!cmSystemTools::FileExists(dir.c_str()) &&
+      !cmSystemTools::MakeDirectory(dir.c_str())) {
+    std::string errstring = "DOWNLOAD error: cannot create directory '" + dir +
+      "' - Specify file by full path name and verify that you "
       "have directory creation and file write privileges.";
     this->SetError(errstring);
     return false;
-    }
+  }
 
   cmsys::ofstream fout(file.c_str(), std::ios::binary);
-  if(!fout)
-    {
+  if (!fout) {
     this->SetError("DOWNLOAD cannot open file for write.");
     return false;
-    }
+  }
 
 #if defined(_WIN32) && defined(CMAKE_ENCODING_UTF8)
   url = fix_file_url_windows(url);
 #endif
 
-  ::CURL *curl;
+  ::CURL* curl;
   ::curl_global_init(CURL_GLOBAL_DEFAULT);
   curl = ::curl_easy_init();
-  if(!curl)
-    {
+  if (!curl) {
     this->SetError("DOWNLOAD error initializing curl.");
     return false;
-    }
+  }
 
   cURLEasyGuard g_curl(curl);
   ::CURLcode res = ::curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
@@ -3157,8 +2626,7 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
   res = ::curl_easy_setopt(curl, CURLOPT_USERAGENT, "curl/" LIBCURL_VERSION);
   check_curl_result(res, "DOWNLOAD cannot set user agent option: ");
 
-  res = ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
-                           cmWriteToFileCallback);
+  res = ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, cmWriteToFileCallback);
   check_curl_result(res, "DOWNLOAD cannot set write function: ");
 
   res = ::curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION,
@@ -3166,54 +2634,47 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
   check_curl_result(res, "DOWNLOAD cannot set debug function: ");
 
   // check to see if TLS verification is requested
-  if(tls_verify)
-    {
+  if (tls_verify) {
     res = ::curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1);
     check_curl_result(res, "Unable to set TLS/SSL Verify on: ");
-    }
-  else
-    {
+  } else {
     res = ::curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
     check_curl_result(res, "Unable to set TLS/SSL Verify off: ");
-    }
+  }
   // check to see if a CAINFO file has been specified
   // command arg comes first
   std::string const& cainfo_err = cmCurlSetCAInfo(curl, cainfo);
-  if (!cainfo_err.empty())
-    {
+  if (!cainfo_err.empty()) {
     this->SetError(cainfo_err);
     return false;
-    }
+  }
 
   cmFileCommandVectorOfChar chunkDebug;
 
-  res = ::curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&fout);
+  res = ::curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&fout);
   check_curl_result(res, "DOWNLOAD cannot set write data: ");
 
-  res = ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void *)&chunkDebug);
+  res = ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void*)&chunkDebug);
   check_curl_result(res, "DOWNLOAD cannot set debug data: ");
 
   res = ::curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
   check_curl_result(res, "DOWNLOAD cannot set follow-redirect option: ");
 
-  if(!logVar.empty())
-    {
+  if (!logVar.empty()) {
     res = ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
     check_curl_result(res, "DOWNLOAD cannot set verbose: ");
-    }
+  }
 
-  if(timeout > 0)
-    {
-    res = ::curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout );
+  if (timeout > 0) {
+    res = ::curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);
     check_curl_result(res, "DOWNLOAD cannot set timeout: ");
-    }
+  }
 
-  if(inactivity_timeout > 0)
-    {
+  if (inactivity_timeout > 0) {
     // Give up if there is no progress for a long time.
     ::curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 1);
     ::curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, inactivity_timeout);
-    }
+  }
 
   // Need the progress helper's scope to last through the duration of
   // the curl_easy_perform call... so this object is declared at function
@@ -3222,19 +2683,18 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
   //
   cURLProgressHelper helper(this, "download");
 
-  if(showProgress)
-    {
+  if (showProgress) {
     res = ::curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
     check_curl_result(res, "DOWNLOAD cannot set noprogress value: ");
 
-    res = ::curl_easy_setopt(curl,
-      CURLOPT_PROGRESSFUNCTION, cmFileDownloadProgressCallback);
+    res = ::curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION,
+                             cmFileDownloadProgressCallback);
     check_curl_result(res, "DOWNLOAD cannot set progress function: ");
 
-    res = ::curl_easy_setopt(curl,
-      CURLOPT_PROGRESSDATA, reinterpret_cast<void*>(&helper));
+    res = ::curl_easy_setopt(curl, CURLOPT_PROGRESSDATA,
+                             reinterpret_cast<void*>(&helper));
     check_curl_result(res, "DOWNLOAD cannot set progress data: ");
-    }
+  }
 
   res = ::curl_easy_perform(curl);
 
@@ -3242,13 +2702,11 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
   g_curl.release();
   ::curl_easy_cleanup(curl);
 
-  if(!statusVar.empty())
-    {
+  if (!statusVar.empty()) {
     std::ostringstream result;
     result << (int)res << ";\"" << ::curl_easy_strerror(res) << "\"";
-    this->Makefile->AddDefinition(statusVar,
-                                  result.str().c_str());
-    }
+    this->Makefile->AddDefinition(statusVar, result.str().c_str());
+  }
 
   ::curl_global_cleanup();
 
@@ -3259,44 +2717,38 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
 
   // Verify MD5 sum if requested:
   //
-  if (hash.get())
-    {
+  if (hash.get()) {
     std::string actualHash = hash->HashFile(file);
-    if (actualHash.empty())
-      {
+    if (actualHash.empty()) {
       this->SetError("DOWNLOAD cannot compute hash on downloaded file");
       return false;
-      }
+    }
 
-    if (expectedHash != actualHash)
-      {
+    if (expectedHash != actualHash) {
       std::ostringstream oss;
       oss << "DOWNLOAD HASH mismatch" << std::endl
-        << "  for file: [" << file << "]" << std::endl
-        << "    expected hash: [" << expectedHash << "]" << std::endl
-        << "      actual hash: [" << actualHash << "]" << std::endl
-        << "           status: [" << (int)res << ";\""
-          << ::curl_easy_strerror(res) << "\"]" << std::endl
-        ;
-
-      if(!statusVar.empty() && res == 0)
-        {
+          << "  for file: [" << file << "]" << std::endl
+          << "    expected hash: [" << expectedHash << "]" << std::endl
+          << "      actual hash: [" << actualHash << "]" << std::endl
+          << "           status: [" << (int)res << ";\""
+          << ::curl_easy_strerror(res) << "\"]" << std::endl;
+
+      if (!statusVar.empty() && res == 0) {
         std::string status = "1;HASH mismatch: "
-          "expected: " + expectedHash +
-          " actual: " + actualHash;
+                             "expected: " +
+          expectedHash + " actual: " + actualHash;
         this->Makefile->AddDefinition(statusVar, status.c_str());
-        }
+      }
 
       this->SetError(oss.str());
       return false;
-      }
     }
+  }
 
-  if (!logVar.empty())
-    {
+  if (!logVar.empty()) {
     chunkDebug.push_back(0);
     this->Makefile->AddDefinition(logVar, &*chunkDebug.begin());
-    }
+  }
 
   return true;
 #else
@@ -3305,16 +2757,13 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
 #endif
 }
 
-
-bool
-cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
+bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
 {
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     this->SetError("UPLOAD must be called with at least three arguments.");
     return false;
-    }
+  }
   std::vector<std::string>::const_iterator i = args.begin();
   ++i;
   std::string filename = *i;
@@ -3328,72 +2777,53 @@ cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
   std::string statusVar;
   bool showProgress = false;
 
-  while(i != args.end())
-    {
-    if(*i == "TIMEOUT")
-      {
+  while (i != args.end()) {
+    if (*i == "TIMEOUT") {
       ++i;
-      if(i != args.end())
-        {
+      if (i != args.end()) {
         timeout = atol(i->c_str());
-        }
-      else
-        {
+      } else {
         this->SetError("UPLOAD missing time for TIMEOUT.");
         return false;
-        }
       }
-    else if(*i == "INACTIVITY_TIMEOUT")
-      {
+    } else if (*i == "INACTIVITY_TIMEOUT") {
       ++i;
-      if(i != args.end())
-        {
+      if (i != args.end()) {
         inactivity_timeout = atol(i->c_str());
-        }
-      else
-        {
+      } else {
         this->SetError("UPLOAD missing time for INACTIVITY_TIMEOUT.");
         return false;
-        }
       }
-    else if(*i == "LOG")
-      {
+    } else if (*i == "LOG") {
       ++i;
-      if( i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("UPLOAD missing VAR for LOG.");
         return false;
-        }
-      logVar = *i;
       }
-    else if(*i == "STATUS")
-      {
+      logVar = *i;
+    } else if (*i == "STATUS") {
       ++i;
-      if( i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("UPLOAD missing VAR for STATUS.");
         return false;
-        }
-      statusVar = *i;
       }
-    else if(*i == "SHOW_PROGRESS")
-      {
+      statusVar = *i;
+    } else if (*i == "SHOW_PROGRESS") {
       showProgress = true;
-      }
+    }
 
     ++i;
-    }
+  }
 
   // Open file for reading:
   //
-  FILE *fin = cmsys::SystemTools::Fopen(filename, "rb");
-  if(!fin)
-    {
+  FILE* fin = cmsys::SystemTools::Fopen(filename, "rb");
+  if (!fin) {
     std::string errStr = "UPLOAD cannot open file '";
     errStr += filename + "' for reading.";
     this->SetError(errStr);
     return false;
-    }
+  }
 
   unsigned long file_size = cmsys::SystemTools::FileLength(filename);
 
@@ -3401,15 +2831,14 @@ cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
   url = fix_file_url_windows(url);
 #endif
 
-  ::CURL *curl;
+  ::CURL* curl;
   ::curl_global_init(CURL_GLOBAL_DEFAULT);
   curl = ::curl_easy_init();
-  if(!curl)
-    {
+  if (!curl) {
     this->SetError("UPLOAD error initializing curl.");
     fclose(fin);
     return false;
-    }
+  }
 
   cURLEasyGuard g_curl(curl);
 
@@ -3424,8 +2853,8 @@ cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
   res = ::curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
   check_curl_result(res, "UPLOAD cannot set url: ");
 
-  res = ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
-                           cmWriteToMemoryCallback);
+  res =
+    ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, cmWriteToMemoryCallback);
   check_curl_result(res, "UPLOAD cannot set write function: ");
 
   res = ::curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION,
@@ -3435,33 +2864,30 @@ cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
   cmFileCommandVectorOfChar chunkResponse;
   cmFileCommandVectorOfChar chunkDebug;
 
-  res = ::curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunkResponse);
+  res = ::curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&chunkResponse);
   check_curl_result(res, "UPLOAD cannot set write data: ");
 
-  res = ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void *)&chunkDebug);
+  res = ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void*)&chunkDebug);
   check_curl_result(res, "UPLOAD cannot set debug data: ");
 
   res = ::curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
   check_curl_result(res, "UPLOAD cannot set follow-redirect option: ");
 
-  if(!logVar.empty())
-    {
+  if (!logVar.empty()) {
     res = ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
     check_curl_result(res, "UPLOAD cannot set verbose: ");
-    }
+  }
 
-  if(timeout > 0)
-    {
-    res = ::curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout );
+  if (timeout > 0) {
+    res = ::curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);
     check_curl_result(res, "UPLOAD cannot set timeout: ");
-    }
+  }
 
-  if(inactivity_timeout > 0)
-    {
+  if (inactivity_timeout > 0) {
     // Give up if there is no progress for a long time.
     ::curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 1);
     ::curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, inactivity_timeout);
-    }
+  }
 
   // Need the progress helper's scope to last through the duration of
   // the curl_easy_perform call... so this object is declared at function
@@ -3470,27 +2896,26 @@ cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
   //
   cURLProgressHelper helper(this, "upload");
 
-  if(showProgress)
-    {
+  if (showProgress) {
     res = ::curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
     check_curl_result(res, "UPLOAD cannot set noprogress value: ");
 
-    res = ::curl_easy_setopt(curl,
-      CURLOPT_PROGRESSFUNCTION, cmFileUploadProgressCallback);
+    res = ::curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION,
+                             cmFileUploadProgressCallback);
     check_curl_result(res, "UPLOAD cannot set progress function: ");
 
-    res = ::curl_easy_setopt(curl,
-      CURLOPT_PROGRESSDATA, reinterpret_cast<void*>(&helper));
+    res = ::curl_easy_setopt(curl, CURLOPT_PROGRESSDATA,
+                             reinterpret_cast<void*>(&helper));
     check_curl_result(res, "UPLOAD cannot set progress data: ");
-    }
+  }
 
   // now specify which file to upload
   res = ::curl_easy_setopt(curl, CURLOPT_INFILE, fin);
   check_curl_result(res, "UPLOAD cannot set input file: ");
 
   // and give the size of the upload (optional)
-  res = ::curl_easy_setopt(curl,
-    CURLOPT_INFILESIZE, static_cast<long>(file_size));
+  res =
+    ::curl_easy_setopt(curl, CURLOPT_INFILESIZE, static_cast<long>(file_size));
   check_curl_result(res, "UPLOAD cannot set input file size: ");
 
   res = ::curl_easy_perform(curl);
@@ -3499,41 +2924,36 @@ cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
   g_curl.release();
   ::curl_easy_cleanup(curl);
 
-  if(!statusVar.empty())
-    {
+  if (!statusVar.empty()) {
     std::ostringstream result;
     result << (int)res << ";\"" << ::curl_easy_strerror(res) << "\"";
-    this->Makefile->AddDefinition(statusVar,
-                                  result.str().c_str());
-    }
+    this->Makefile->AddDefinition(statusVar, result.str().c_str());
+  }
 
   ::curl_global_cleanup();
 
   fclose(fin);
   fin = NULL;
 
-  if(!logVar.empty())
-    {
+  if (!logVar.empty()) {
     std::string log;
 
-    if(!chunkResponse.empty())
-      {
+    if (!chunkResponse.empty()) {
       chunkResponse.push_back(0);
       log += "Response:\n";
       log += &*chunkResponse.begin();
       log += "\n";
-      }
+    }
 
-    if(!chunkDebug.empty())
-      {
+    if (!chunkDebug.empty()) {
       chunkDebug.push_back(0);
       log += "Debug:\n";
       log += &*chunkDebug.begin();
       log += "\n";
-      }
+    }
 
     this->Makefile->AddDefinition(logVar, log.c_str());
-    }
+  }
 
   return true;
 #else
@@ -3542,81 +2962,72 @@ cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
 #endif
 }
 
-void cmFileCommand::AddEvaluationFile(const std::string &inputName,
-                                      const std::string &outputExpr,
-                                      const std::string &condition,
-                                      bool inputIsContent
-                                     )
+void cmFileCommand::AddEvaluationFile(const std::string& inputName,
+                                      const std::string& outputExpr,
+                                      const std::string& condition,
+                                      bool inputIsContent)
 {
   cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
 
   cmGeneratorExpression outputGe(lfbt);
-  cmsys::auto_ptr<cmCompiledGeneratorExpression> outputCge
-                                                = outputGe.Parse(outputExpr);
+  cmsys::auto_ptr<cmCompiledGeneratorExpression> outputCge =
+    outputGe.Parse(outputExpr);
 
   cmGeneratorExpression conditionGe(lfbt);
-  cmsys::auto_ptr<cmCompiledGeneratorExpression> conditionCge
-                                              = conditionGe.Parse(condition);
+  cmsys::auto_ptr<cmCompiledGeneratorExpression> conditionCge =
+    conditionGe.Parse(condition);
 
-  this->Makefile->AddEvaluationFile(inputName, outputCge,
-                                    conditionCge, inputIsContent);
+  this->Makefile->AddEvaluationFile(inputName, outputCge, conditionCge,
+                                    inputIsContent);
 }
 
-bool cmFileCommand::HandleGenerateCommand(
-  std::vector<std::string> const& args)
+bool cmFileCommand::HandleGenerateCommand(std::vector<std::string> const& args)
 {
-  if (args.size() < 5)
-    {
+  if (args.size() < 5) {
     this->SetError("Incorrect arguments to GENERATE subcommand.");
     return false;
-    }
-  if (args[1] != "OUTPUT")
-    {
+  }
+  if (args[1] != "OUTPUT") {
     this->SetError("Incorrect arguments to GENERATE subcommand.");
     return false;
-    }
+  }
   std::string condition;
-  if (args.size() > 5)
-    {
-    if (args[5] != "CONDITION")
-      {
+  if (args.size() > 5) {
+    if (args[5] != "CONDITION") {
       this->SetError("Incorrect arguments to GENERATE subcommand.");
       return false;
-      }
-    if (args.size() != 7)
-      {
+    }
+    if (args.size() != 7) {
       this->SetError("Incorrect arguments to GENERATE subcommand.");
       return false;
-      }
+    }
     condition = args[6];
-    if (condition.empty())
-      {
+    if (condition.empty()) {
       this->SetError("CONDITION of sub-command GENERATE must not be empty if "
-        "specified.");
+                     "specified.");
       return false;
-      }
     }
+  }
   std::string output = args[2];
   const bool inputIsContent = args[3] != "INPUT";
-  if (inputIsContent && args[3] != "CONTENT")
-    {
+  if (inputIsContent && args[3] != "CONTENT") {
     this->SetError("Incorrect arguments to GENERATE subcommand.");
     return false;
-    }
+  }
   std::string input = args[4];
 
   this->AddEvaluationFile(input, output, condition, inputIsContent);
   return true;
 }
 
-bool cmFileCommand::HandleLockCommand(
-  std::vector<std::string> const& args)
+bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args)
 {
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   // Default values
   bool directory = false;
   bool release = false;
-  enum Guard {
+  enum Guard
+  {
     GUARD_FUNCTION,
     GUARD_FILE,
     GUARD_PROCESS
@@ -3626,148 +3037,111 @@ bool cmFileCommand::HandleLockCommand(
   unsigned long timeout = static_cast<unsigned long>(-1);
 
   // Parse arguments
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     this->Makefile->IssueMessage(
-        cmake::FATAL_ERROR,
-        "sub-command LOCK requires at least two arguments.");
+      cmake::FATAL_ERROR, "sub-command LOCK requires at least two arguments.");
     return false;
-    }
+  }
 
   std::string path = args[1];
-  for (unsigned i = 2; i < args.size(); ++i)
-    {
-    if (args[i] == "DIRECTORY")
-      {
+  for (unsigned i = 2; i < args.size(); ++i) {
+    if (args[i] == "DIRECTORY") {
       directory = true;
-      }
-    else if (args[i] == "RELEASE")
-      {
+    } else if (args[i] == "RELEASE") {
       release = true;
-      }
-    else if (args[i] == "GUARD")
-      {
+    } else if (args[i] == "GUARD") {
       ++i;
       const char* merr = "expected FUNCTION, FILE or PROCESS after GUARD";
-      if (i >= args.size())
-        {
+      if (i >= args.size()) {
         this->Makefile->IssueMessage(cmake::FATAL_ERROR, merr);
         return false;
-        }
-      else
-        {
-        if (args[i] == "FUNCTION")
-          {
+      } else {
+        if (args[i] == "FUNCTION") {
           guard = GUARD_FUNCTION;
-          }
-        else if (args[i] == "FILE")
-          {
+        } else if (args[i] == "FILE") {
           guard = GUARD_FILE;
-          }
-        else if (args[i] == "PROCESS")
-          {
+        } else if (args[i] == "PROCESS") {
           guard = GUARD_PROCESS;
-          }
-        else
-          {
+        } else {
           std::ostringstream e;
           e << merr << ", but got:\n  \"" << args[i] << "\".";
           this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
           return false;
-          }
         }
       }
-    else if (args[i] == "RESULT_VARIABLE")
-      {
+    } else if (args[i] == "RESULT_VARIABLE") {
       ++i;
-      if (i >= args.size())
-        {
+      if (i >= args.size()) {
         this->Makefile->IssueMessage(
-            cmake::FATAL_ERROR,
-            "expected variable name after RESULT_VARIABLE");
+          cmake::FATAL_ERROR, "expected variable name after RESULT_VARIABLE");
         return false;
-        }
-      resultVariable = args[i];
       }
-    else if (args[i] == "TIMEOUT")
-      {
+      resultVariable = args[i];
+    } else if (args[i] == "TIMEOUT") {
       ++i;
-      if (i >= args.size())
-        {
-        this->Makefile->IssueMessage(
-            cmake::FATAL_ERROR,
-            "expected timeout value after TIMEOUT");
+      if (i >= args.size()) {
+        this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+                                     "expected timeout value after TIMEOUT");
         return false;
-        }
+      }
       long scanned;
-      if(!cmSystemTools::StringToLong(args[i].c_str(), &scanned)
-         || scanned < 0)
-        {
+      if (!cmSystemTools::StringToLong(args[i].c_str(), &scanned) ||
+          scanned < 0) {
         std::ostringstream e;
         e << "TIMEOUT value \"" << args[i] << "\" is not an unsigned integer.";
         this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
         return false;
-        }
-      timeout = static_cast<unsigned long>(scanned);
       }
-    else
-      {
+      timeout = static_cast<unsigned long>(scanned);
+    } else {
       std::ostringstream e;
       e << "expected DIRECTORY, RELEASE, GUARD, RESULT_VARIABLE or TIMEOUT\n";
       e << "but got: \"" << args[i] << "\".";
       this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
       return false;
-      }
     }
+  }
 
-  if (directory)
-    {
+  if (directory) {
     path += "/cmake.lock";
-    }
+  }
 
-  if (!cmsys::SystemTools::FileIsFullPath(path))
-    {
+  if (!cmsys::SystemTools::FileIsFullPath(path)) {
     path = this->Makefile->GetCurrentSourceDirectory() + ("/" + path);
-    }
+  }
 
   // Unify path (remove '//', '/../', ...)
   path = cmSystemTools::CollapseFullPath(path);
 
   // Create file and directories if needed
   std::string parentDir = cmSystemTools::GetParentDirectory(path);
-  if (!cmSystemTools::MakeDirectory(parentDir))
-    {
+  if (!cmSystemTools::MakeDirectory(parentDir)) {
     std::ostringstream e;
     e << "directory\n  \"" << parentDir << "\"\ncreation failed ";
     e << "(check permissions).";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
     cmSystemTools::SetFatalErrorOccured();
     return false;
-    }
-  FILE *file = cmsys::SystemTools::Fopen(path, "w");
-  if (!file)
-    {
+  }
+  FILE* file = cmsys::SystemTools::Fopen(path, "w");
+  if (!file) {
     std::ostringstream e;
     e << "file\n  \"" << path << "\"\ncreation failed (check permissions).";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
     cmSystemTools::SetFatalErrorOccured();
     return false;
-    }
+  }
   fclose(file);
 
   // Actual lock/unlock
-  cmFileLockPool& lockPool = this->Makefile->GetGlobalGenerator()
-                                           ->GetFileLockPool();
+  cmFileLockPool& lockPool =
+    this->Makefile->GetGlobalGenerator()->GetFileLockPool();
 
   cmFileLockResult fileLockResult(cmFileLockResult::MakeOk());
-  if (release)
-    {
+  if (release) {
     fileLockResult = lockPool.Release(path);
-    }
-  else
-    {
-    switch (guard)
-      {
+  } else {
+    switch (guard) {
       case GUARD_FUNCTION:
         fileLockResult = lockPool.LockFunctionScope(path, timeout);
         break;
@@ -3780,24 +3154,22 @@ bool cmFileCommand::HandleLockCommand(
       default:
         cmSystemTools::SetFatalErrorOccured();
         return false;
-      }
     }
+  }
 
   const std::string result = fileLockResult.GetOutputMessage();
 
-  if (resultVariable.empty() && !fileLockResult.IsOk())
-    {
+  if (resultVariable.empty() && !fileLockResult.IsOk()) {
     std::ostringstream e;
     e << "error locking file\n  \"" << path << "\"\n" << result << ".";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
     cmSystemTools::SetFatalErrorOccured();
     return false;
-    }
+  }
 
-  if (!resultVariable.empty())
-    {
+  if (!resultVariable.empty()) {
     this->Makefile->AddDefinition(resultVariable, result.c_str());
-    }
+  }
 
   return true;
 #else
@@ -3810,16 +3182,13 @@ bool cmFileCommand::HandleLockCommand(
 bool cmFileCommand::HandleTimestampCommand(
   std::vector<std::string> const& args)
 {
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     this->SetError("sub-command TIMESTAMP requires at least two arguments.");
     return false;
-    }
-  else if(args.size() > 5)
-    {
+  } else if (args.size() > 5) {
     this->SetError("sub-command TIMESTAMP takes at most four arguments.");
     return false;
-    }
+  }
 
   unsigned int argsIndex = 1;
 
@@ -3828,30 +3197,25 @@ bool cmFileCommand::HandleTimestampCommand(
   const std::string& outputVariable = args[argsIndex++];
 
   std::string formatString;
-  if(args.size() > argsIndex && args[argsIndex] != "UTC")
-    {
+  if (args.size() > argsIndex && args[argsIndex] != "UTC") {
     formatString = args[argsIndex++];
-    }
+  }
 
   bool utcFlag = false;
-  if(args.size() > argsIndex)
-    {
-    if(args[argsIndex] == "UTC")
-      {
+  if (args.size() > argsIndex) {
+    if (args[argsIndex] == "UTC") {
       utcFlag = true;
-      }
-    else
-      {
+    } else {
       std::string e = " TIMESTAMP sub-command does not recognize option " +
-          args[argsIndex] + ".";
+        args[argsIndex] + ".";
       this->SetError(e);
       return false;
-      }
     }
+  }
 
   cmTimestamp timestamp;
-  std::string result = timestamp.FileModificationTime(
-    filename.c_str(), formatString, utcFlag);
+  std::string result =
+    timestamp.FileModificationTime(filename.c_str(), formatString, utcFlag);
   this->Makefile->AddDefinition(outputVariable, result.c_str());
 
   return true;