Clang-format and whitespace cleanup of source code

This patch contains the clang-format and cleanup of the entire code base. Some
of clang-formats changes made the code look worse in places. A best effort was
made to resolve the bulk of these problems, but many remain. Most of the
problems were mangling line-breaks and tabbing of comments.

Patch by Terry Wilmarth

Differential Revision: https://reviews.llvm.org/D32659

llvm-svn: 302929

1 files changed, 171 insertions, 189 deletions

diff --git a/openmp/runtime/src/kmp_io.cpp b/openmp/runtime/src/kmp_io.cpp
index 88a2c15377c..61ac1ca9af5 100644
--- a/openmp/runtime/src/kmp_io.cpp
+++ b/openmp/runtime/src/kmp_io.cpp
@@ -13,236 +13,218 @@
 //===----------------------------------------------------------------------===//
 
 
+#include <stdarg.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stddef.h>
-#include <stdarg.h>
 #include <string.h>
 #ifndef __ABSOFT_WIN
-# include <sys/types.h>
+#include <sys/types.h>
 #endif
 
-#include "kmp_os.h"
+#include "kmp.h" // KMP_GTID_DNE, __kmp_debug_buf, etc
+#include "kmp_io.h"
 #include "kmp_lock.h"
+#include "kmp_os.h"
 #include "kmp_str.h"
-#include "kmp_io.h"
-#include "kmp.h" // KMP_GTID_DNE, __kmp_debug_buf, etc
 
 #if KMP_OS_WINDOWS
-# pragma warning( push )
-# pragma warning( disable: 271 310 )
-# include <windows.h>
-# pragma warning( pop )
+#pragma warning(push)
+#pragma warning(disable : 271 310)
+#include <windows.h>
+#pragma warning(pop)
 #endif
 
 /* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */
 
-kmp_bootstrap_lock_t __kmp_stdio_lock   = KMP_BOOTSTRAP_LOCK_INITIALIZER( __kmp_stdio_lock   ); /* Control stdio functions */
-kmp_bootstrap_lock_t __kmp_console_lock = KMP_BOOTSTRAP_LOCK_INITIALIZER( __kmp_console_lock ); /* Control console initialization */
+kmp_bootstrap_lock_t __kmp_stdio_lock = KMP_BOOTSTRAP_LOCK_INITIALIZER(
+    __kmp_stdio_lock); /* Control stdio functions */
+kmp_bootstrap_lock_t __kmp_console_lock = KMP_BOOTSTRAP_LOCK_INITIALIZER(
+    __kmp_console_lock); /* Control console initialization */
 
 #if KMP_OS_WINDOWS
 
-    # ifdef KMP_DEBUG
-    /* __kmp_stdout is used only for dev build */
-    static HANDLE    __kmp_stdout = NULL;
-    # endif
-    static HANDLE        __kmp_stderr = NULL;
-    static int           __kmp_console_exists = FALSE;
-    static kmp_str_buf_t __kmp_console_buf;
-
-    static int
-    is_console( void )
-    {
-        char buffer[ 128 ];
-        DWORD rc  = 0;
-        DWORD err = 0;
-        // Try to get console title.
-        SetLastError( 0 );
-            // GetConsoleTitle does not reset last error in case of success or short buffer,
-            // so we need to clear it explicitly.
-        rc = GetConsoleTitle( buffer, sizeof( buffer ) );
-        if ( rc == 0 ) {
-            // rc == 0 means getting console title failed. Let us find out why.
-            err = GetLastError();
-            // err == 0 means buffer too short (we suppose console exists).
-            // In Window applications we usually have err == 6 (invalid handle).
-        }; // if
-        return rc > 0 || err == 0;
-    }
-
-    void
-    __kmp_close_console( void )
-    {
-        /* wait until user presses return before closing window */
-        /* TODO only close if a window was opened */
-        if( __kmp_console_exists ) {
-            #ifdef KMP_DEBUG
-            /* standard out is used only in dev build */
-            __kmp_stdout = NULL;
-            #endif
-            __kmp_stderr = NULL;
-            __kmp_str_buf_free( &__kmp_console_buf );
-            __kmp_console_exists = FALSE;
-        }
-    }
+#ifdef KMP_DEBUG
+/* __kmp_stdout is used only for dev build */
+static HANDLE __kmp_stdout = NULL;
+#endif
+static HANDLE __kmp_stderr = NULL;
+static int __kmp_console_exists = FALSE;
+static kmp_str_buf_t __kmp_console_buf;
+
+static int is_console(void) {
+  char buffer[128];
+  DWORD rc = 0;
+  DWORD err = 0;
+  // Try to get console title.
+  SetLastError(0);
+  // GetConsoleTitle does not reset last error in case of success or short
+  // buffer, so we need to clear it explicitly.
+  rc = GetConsoleTitle(buffer, sizeof(buffer));
+  if (rc == 0) {
+    // rc == 0 means getting console title failed. Let us find out why.
+    err = GetLastError();
+    // err == 0 means buffer too short (we suppose console exists).
+    // In Window applications we usually have err == 6 (invalid handle).
+  }; // if
+  return rc > 0 || err == 0;
+}
 
-    /* For windows, call this before stdout, stderr, or stdin are used.
-     * It opens a console window and starts processing */
-    static void
-    __kmp_redirect_output( void )
-    {
-        __kmp_acquire_bootstrap_lock( &__kmp_console_lock );
+void __kmp_close_console(void) {
+  /* wait until user presses return before closing window */
+  /* TODO only close if a window was opened */
+  if (__kmp_console_exists) {
+#ifdef KMP_DEBUG
+    /* standard out is used only in dev build */
+    __kmp_stdout = NULL;
+#endif
+    __kmp_stderr = NULL;
+    __kmp_str_buf_free(&__kmp_console_buf);
+    __kmp_console_exists = FALSE;
+  }
+}
 
-        if( ! __kmp_console_exists ) {
-            #ifdef KMP_DEBUG
-            /* standard out is used only in dev build */
-            HANDLE ho;
-            #endif
-            HANDLE he;
+/* For windows, call this before stdout, stderr, or stdin are used.
+   It opens a console window and starts processing */
+static void __kmp_redirect_output(void) {
+  __kmp_acquire_bootstrap_lock(&__kmp_console_lock);
 
-            __kmp_str_buf_init( &__kmp_console_buf );
+  if (!__kmp_console_exists) {
+#ifdef KMP_DEBUG
+    /* standard out is used only in dev build */
+    HANDLE ho;
+#endif
+    HANDLE he;
 
-            AllocConsole();
-            // We do not check the result of AllocConsole because
-            //  1. the call is harmless
-            //  2. it is not clear how to communicate failue
-            //  3. we will detect failure later when we get handle(s)
+    __kmp_str_buf_init(&__kmp_console_buf);
 
-            #ifdef KMP_DEBUG
-                ho = GetStdHandle( STD_OUTPUT_HANDLE );
-                if ( ho == INVALID_HANDLE_VALUE || ho == NULL ) {
+    AllocConsole();
+// We do not check the result of AllocConsole because
+//  1. the call is harmless
+//  2. it is not clear how to communicate failue
+//  3. we will detect failure later when we get handle(s)
 
-                    DWORD  err = GetLastError();
-                    // TODO: output error somehow (maybe message box)
-                    __kmp_stdout = NULL;
+#ifdef KMP_DEBUG
+    ho = GetStdHandle(STD_OUTPUT_HANDLE);
+    if (ho == INVALID_HANDLE_VALUE || ho == NULL) {
 
-                } else {
+      DWORD err = GetLastError();
+      // TODO: output error somehow (maybe message box)
+      __kmp_stdout = NULL;
 
-                    __kmp_stdout = ho; // temporary code, need new global for ho
+    } else {
 
-                }
-            #endif
-            he = GetStdHandle( STD_ERROR_HANDLE );
-            if ( he == INVALID_HANDLE_VALUE || he == NULL ) {
+      __kmp_stdout = ho; // temporary code, need new global for ho
+    }
+#endif
+    he = GetStdHandle(STD_ERROR_HANDLE);
+    if (he == INVALID_HANDLE_VALUE || he == NULL) {
 
-                DWORD  err = GetLastError();
-                // TODO: output error somehow (maybe message box)
-                __kmp_stderr = NULL;
+      DWORD err = GetLastError();
+      // TODO: output error somehow (maybe message box)
+      __kmp_stderr = NULL;
 
-            } else {
+    } else {
 
-                __kmp_stderr = he; // temporary code, need new global
-            }
-            __kmp_console_exists = TRUE;
-        }
-        __kmp_release_bootstrap_lock( &__kmp_console_lock );
+      __kmp_stderr = he; // temporary code, need new global
     }
+    __kmp_console_exists = TRUE;
+  }
+  __kmp_release_bootstrap_lock(&__kmp_console_lock);
+}
 
 #else
-    #define       __kmp_stderr     (stderr)
+#define __kmp_stderr (stderr)
 #endif /* KMP_OS_WINDOWS */
 
-void
-__kmp_vprintf( enum kmp_io __kmp_io, char const * format, va_list ap )
-{
-    #if KMP_OS_WINDOWS
-        if( !__kmp_console_exists ) {
-            __kmp_redirect_output();
-        }
-            if( ! __kmp_stderr && __kmp_io == kmp_err ) {
-            return;
-        }
-        #ifdef KMP_DEBUG
-            if( ! __kmp_stdout && __kmp_io == kmp_out ) {
-                return;
-            }
-        #endif
-    #endif /* KMP_OS_WINDOWS */
-
-    if ( __kmp_debug_buf && __kmp_debug_buffer != NULL ) {
-
-        int dc = ( __kmp_debug_buf_atomic ?
-                   KMP_TEST_THEN_INC32( & __kmp_debug_count) : __kmp_debug_count++ )
-                   % __kmp_debug_buf_lines;
-        char *db = & __kmp_debug_buffer[ dc * __kmp_debug_buf_chars ];
-        int chars = 0;
-
-        #ifdef KMP_DEBUG_PIDS
-            chars = KMP_SNPRINTF( db, __kmp_debug_buf_chars, "pid=%d: ", (kmp_int32)getpid() );
-        #endif
-        chars += KMP_VSNPRINTF( db, __kmp_debug_buf_chars, format, ap );
-
-        if ( chars + 1 > __kmp_debug_buf_chars ) {
-            if ( chars + 1 > __kmp_debug_buf_warn_chars ) {
-                #if KMP_OS_WINDOWS
-                    DWORD count;
-                    __kmp_str_buf_print( &__kmp_console_buf,
-                        "OMP warning: Debugging buffer overflow; increase KMP_DEBUG_BUF_CHARS to %d\n",
-                        chars + 1 );
-                    WriteFile( __kmp_stderr, __kmp_console_buf.str, __kmp_console_buf.used, &count, NULL );
-                    __kmp_str_buf_clear( &__kmp_console_buf );
-                #else
-                    fprintf( __kmp_stderr,
-                         "OMP warning: Debugging buffer overflow; increase KMP_DEBUG_BUF_CHARS to %d\n",
-                         chars + 1 );
-                    fflush( __kmp_stderr );
-                #endif
-                __kmp_debug_buf_warn_chars = chars + 1;
-            }
-            /* terminate string if overflow occurred */
-            db[ __kmp_debug_buf_chars - 2 ] = '\n';
-            db[ __kmp_debug_buf_chars - 1 ] = '\0';
-        }
-    } else {
-        #if KMP_OS_WINDOWS
-            DWORD count;
-            #ifdef KMP_DEBUG_PIDS
-                __kmp_str_buf_print( &__kmp_console_buf, "pid=%d: ",
-                  (kmp_int32)getpid() );
-            #endif
-            __kmp_str_buf_vprint( &__kmp_console_buf, format, ap );
-            WriteFile(
-                __kmp_stderr,
-                __kmp_console_buf.str,
-                __kmp_console_buf.used,
-                &count,
-                NULL
-            );
-            __kmp_str_buf_clear( &__kmp_console_buf );
-        #else
-            #ifdef KMP_DEBUG_PIDS
-                fprintf( __kmp_stderr, "pid=%d: ", (kmp_int32)getpid() );
-            #endif
-            vfprintf( __kmp_stderr, format, ap );
-            fflush( __kmp_stderr );
-        #endif
+void __kmp_vprintf(enum kmp_io __kmp_io, char const *format, va_list ap) {
+#if KMP_OS_WINDOWS
+  if (!__kmp_console_exists) {
+    __kmp_redirect_output();
+  }
+  if (!__kmp_stderr && __kmp_io == kmp_err) {
+    return;
+  }
+#ifdef KMP_DEBUG
+  if (!__kmp_stdout && __kmp_io == kmp_out) {
+    return;
+  }
+#endif
+#endif /* KMP_OS_WINDOWS */
+
+  if (__kmp_debug_buf && __kmp_debug_buffer != NULL) {
+
+    int dc = (__kmp_debug_buf_atomic ? KMP_TEST_THEN_INC32(&__kmp_debug_count)
+                                     : __kmp_debug_count++) %
+             __kmp_debug_buf_lines;
+    char *db = &__kmp_debug_buffer[dc * __kmp_debug_buf_chars];
+    int chars = 0;
+
+#ifdef KMP_DEBUG_PIDS
+    chars = KMP_SNPRINTF(db, __kmp_debug_buf_chars, "pid=%d: ",
+                         (kmp_int32)getpid());
+#endif
+    chars += KMP_VSNPRINTF(db, __kmp_debug_buf_chars, format, ap);
+
+    if (chars + 1 > __kmp_debug_buf_chars) {
+      if (chars + 1 > __kmp_debug_buf_warn_chars) {
+#if KMP_OS_WINDOWS
+        DWORD count;
+        __kmp_str_buf_print(&__kmp_console_buf, "OMP warning: Debugging buffer "
+                                                "overflow; increase "
+                                                "KMP_DEBUG_BUF_CHARS to %d\n",
+                            chars + 1);
+        WriteFile(__kmp_stderr, __kmp_console_buf.str, __kmp_console_buf.used,
+                  &count, NULL);
+        __kmp_str_buf_clear(&__kmp_console_buf);
+#else
+        fprintf(__kmp_stderr, "OMP warning: Debugging buffer overflow; "
+                              "increase KMP_DEBUG_BUF_CHARS to %d\n",
+                chars + 1);
+        fflush(__kmp_stderr);
+#endif
+        __kmp_debug_buf_warn_chars = chars + 1;
+      }
+      /* terminate string if overflow occurred */
+      db[__kmp_debug_buf_chars - 2] = '\n';
+      db[__kmp_debug_buf_chars - 1] = '\0';
     }
+  } else {
+#if KMP_OS_WINDOWS
+    DWORD count;
+#ifdef KMP_DEBUG_PIDS
+    __kmp_str_buf_print(&__kmp_console_buf, "pid=%d: ", (kmp_int32)getpid());
+#endif
+    __kmp_str_buf_vprint(&__kmp_console_buf, format, ap);
+    WriteFile(__kmp_stderr, __kmp_console_buf.str, __kmp_console_buf.used,
+              &count, NULL);
+    __kmp_str_buf_clear(&__kmp_console_buf);
+#else
+#ifdef KMP_DEBUG_PIDS
+    fprintf(__kmp_stderr, "pid=%d: ", (kmp_int32)getpid());
+#endif
+    vfprintf(__kmp_stderr, format, ap);
+    fflush(__kmp_stderr);
+#endif
+  }
 }
 
-void
-__kmp_printf( char const * format, ... )
-{
-    va_list ap;
-    va_start( ap, format );
+void __kmp_printf(char const *format, ...) {
+  va_list ap;
+  va_start(ap, format);
 
-    __kmp_acquire_bootstrap_lock( & __kmp_stdio_lock );
-    __kmp_vprintf( kmp_err, format, ap );
-    __kmp_release_bootstrap_lock( & __kmp_stdio_lock );
+  __kmp_acquire_bootstrap_lock(&__kmp_stdio_lock);
+  __kmp_vprintf(kmp_err, format, ap);
+  __kmp_release_bootstrap_lock(&__kmp_stdio_lock);
 
-    va_end( ap );
+  va_end(ap);
 }
 
-void
-__kmp_printf_no_lock( char const * format, ... )
-{
-    va_list ap;
-    va_start( ap, format );
+void __kmp_printf_no_lock(char const *format, ...) {
+  va_list ap;
+  va_start(ap, format);
 
-    __kmp_vprintf( kmp_err, format, ap );
+  __kmp_vprintf(kmp_err, format, ap);
 
-    va_end( ap );
+  va_end(ap);
 }
-
-/* ------------------------------------------------------------------------ */
-/* ------------------------------------------------------------------------ */