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, 47 insertions, 43 deletions

diff --git a/Source/cmStandardIncludes.h b/Source/cmStandardIncludes.h
index f80586e..6669e5c 100644
--- a/Source/cmStandardIncludes.h
+++ b/Source/cmStandardIncludes.h
@@ -21,14 +21,13 @@
 #include <cmsys/Configure.hxx>
 
 #ifdef _MSC_VER
-#pragma warning ( disable : 4786 )
-#pragma warning ( disable : 4503 )
+#pragma warning(disable : 4786)
+#pragma warning(disable : 4503)
 #endif
 
-
 #ifdef __ICL
-#pragma warning ( disable : 985 )
-#pragma warning ( disable : 1572 ) /* floating-point equality test */
+#pragma warning(disable : 985)
+#pragma warning(disable : 1572) /* floating-point equality test */
 #endif
 
 // Provide fixed-size integer types.
@@ -53,36 +52,45 @@
 #include <stdlib.h>
 #include <string.h>
 
-#if defined( _MSC_VER )
+#if defined(_MSC_VER)
 typedef unsigned short mode_t;
 #else
-# include <sys/types.h>
+#include <sys/types.h>
 #endif
 
 // use this class to shrink the size of symbols in .o files
 // std::string is really basic_string<....lots of stuff....>
 // when combined with a map or set, the symbols can be > 2000 chars!
 #include <cmsys/String.hxx>
-//typedef cmsys::String std::string;
+// typedef cmsys::String std::string;
 
 /* Poison this operator to avoid common mistakes.  */
-extern void operator << (std::ostream&, const std::ostringstream&);
+extern void operator<<(std::ostream&, const std::ostringstream&);
 
 /** Standard documentation entry for cmDocumentation's formatting.  */
 struct cmDocumentationEntry
 {
   std::string Name;
   std::string Brief;
-  cmDocumentationEntry(){}
-  cmDocumentationEntry(const char *doc[2])
-  { if (doc[0]) this->Name = doc[0];
-  if (doc[1]) this->Brief = doc[1];}
-  cmDocumentationEntry(const char *n, const char *b)
-  { if (n) this->Name = n; if (b) this->Brief = b; }
+  cmDocumentationEntry() {}
+  cmDocumentationEntry(const char* doc[2])
+  {
+    if (doc[0])
+      this->Name = doc[0];
+    if (doc[1])
+      this->Brief = doc[1];
+  }
+  cmDocumentationEntry(const char* n, const char* b)
+  {
+    if (n)
+      this->Name = n;
+    if (b)
+      this->Brief = b;
+  }
 };
 
 /** Data structure to represent a single command line.  */
-class cmCustomCommandLine: public std::vector<std::string>
+class cmCustomCommandLine : public std::vector<std::string>
 {
 public:
   typedef std::vector<std::string> Superclass;
@@ -91,7 +99,7 @@ public:
 };
 
 /** Data structure to represent a list of command lines.  */
-class cmCustomCommandLines: public std::vector<cmCustomCommandLine>
+class cmCustomCommandLines : public std::vector<cmCustomCommandLine>
 {
 public:
   typedef std::vector<cmCustomCommandLine> Superclass;
@@ -101,32 +109,28 @@ public:
 
 // All subclasses of cmCommand or cmCTestGenericHandler should
 // invoke this macro.
-#define cmTypeMacro(thisClass,superclass) \
-virtual const char* GetNameOfClass() { return #thisClass; } \
-typedef superclass Superclass; \
-static bool IsTypeOf(const char *type) \
-{ \
-  if ( !strcmp(#thisClass,type) ) \
-    { \
-    return true; \
-    } \
-  return Superclass::IsTypeOf(type); \
-} \
-virtual bool IsA(const char *type) \
-{ \
-  return thisClass::IsTypeOf(type); \
-} \
-static thisClass* SafeDownCast(cmObject *c) \
-{ \
-  if ( c && c->IsA(#thisClass) ) \
-    { \
-    return static_cast<thisClass *>(c); \
-    } \
-  return 0;\
-} \
-class cmTypeMacro_UseTrailingSemicolon
-
-enum cmTargetLinkLibraryType {
+#define cmTypeMacro(thisClass, superclass)                                    \
+  virtual const char* GetNameOfClass() { return #thisClass; }                 \
+  typedef superclass Superclass;                                              \
+  static bool IsTypeOf(const char* type)                                      \
+  {                                                                           \
+    if (!strcmp(#thisClass, type)) {                                          \
+      return true;                                                            \
+    }                                                                         \
+    return Superclass::IsTypeOf(type);                                        \
+  }                                                                           \
+  virtual bool IsA(const char* type) { return thisClass::IsTypeOf(type); }    \
+  static thisClass* SafeDownCast(cmObject* c)                                 \
+  {                                                                           \
+    if (c && c->IsA(#thisClass)) {                                            \
+      return static_cast<thisClass*>(c);                                      \
+    }                                                                         \
+    return 0;                                                                 \
+  }                                                                           \
+  class cmTypeMacro_UseTrailingSemicolon
+
+enum cmTargetLinkLibraryType
+{
   GENERAL_LibraryType,
   DEBUG_LibraryType,
   OPTIMIZED_LibraryType