Formats the source and updates the gcc warning pragmas

1 files changed, 278 insertions, 409 deletions

diff --git a/src/H5FDhdfs.c b/src/H5FDhdfs.c
index 2c06420..6599b9b 100644
--- a/src/H5FDhdfs.c
+++ b/src/H5FDhdfs.c
@@ -23,13 +23,13 @@
 /* This source code file is part of the H5FD driver module */
 #include "H5FDdrvr_module.h"
 
-#include "H5private.h"      /* Generic Functions        */
-#include "H5Eprivate.h"     /* Error handling           */
-#include "H5FDprivate.h"    /* File drivers             */
-#include "H5FDhdfs.h"       /* hdfs file driver         */
-#include "H5FLprivate.h"    /* Free Lists               */
-#include "H5Iprivate.h"     /* IDs                      */
-#include "H5MMprivate.h"    /* Memory management        */
+#include "H5private.h"   /* Generic Functions        */
+#include "H5Eprivate.h"  /* Error handling           */
+#include "H5FDprivate.h" /* File drivers             */
+#include "H5FDhdfs.h"    /* hdfs file driver         */
+#include "H5FLprivate.h" /* Free Lists               */
+#include "H5Iprivate.h"  /* IDs                      */
+#include "H5MMprivate.h" /* Memory management        */
 
 #ifdef H5_HAVE_LIBHDFS
 #include "hdfs.h"
@@ -59,35 +59,32 @@ static hid_t H5FD_HDFS_g = 0;
  * 2^(10+(1*16)) = 2^26 = 64MB
  *     Reads of 64MB or greater fall in "overflow" bin[BIN_COUNT]
  */
-#define HDFS_STATS_BASE         2
-#define HDFS_STATS_INTERVAL     1
+#define HDFS_STATS_BASE        2
+#define HDFS_STATS_INTERVAL    1
 #define HDFS_STATS_START_POWER 10
 #define HDFS_STATS_BIN_COUNT   16 /* MUST BE GREATER THAN 0 */
 
-
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * Calculate `BASE ^ (START_POWER + (INTERVAL * bin_i))`
  * Stores result at `(unsigned long long *) out_ptr`.
  * Used in computing boundaries between stats bins.
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  */
-#define HDFS_STATS_POW(bin_i, out_ptr) {                       \
-    unsigned long long donotshadowresult = 1;                  \
-    unsigned           donotshadowindex  = 0;                  \
-    for (donotshadowindex = 0;                                 \
-         donotshadowindex < (((bin_i) * HDFS_STATS_INTERVAL) + \
-                              HDFS_STATS_START_POWER);         \
-         donotshadowindex++)                                   \
-    {                                                          \
-        donotshadowresult *= HDFS_STATS_BASE;                  \
-    }                                                          \
-    *(out_ptr) = donotshadowresult;                            \
-}
+#define HDFS_STATS_POW(bin_i, out_ptr)                                                                       \
+    {                                                                                                        \
+        unsigned long long donotshadowresult = 1;                                                            \
+        unsigned           donotshadowindex  = 0;                                                            \
+        for (donotshadowindex = 0;                                                                           \
+             donotshadowindex < (((bin_i)*HDFS_STATS_INTERVAL) + HDFS_STATS_START_POWER);                    \
+             donotshadowindex++) {                                                                           \
+            donotshadowresult *= HDFS_STATS_BASE;                                                            \
+        }                                                                                                    \
+        *(out_ptr) = donotshadowresult;                                                                      \
+    }
 
 /* array to hold pre-computed boundaries for stats bins */
 static unsigned long long hdfs_stats_boundaries[HDFS_STATS_BIN_COUNT];
 
-
 /***************************************************************************
  *
  * Structure: hdfs_statsbin
@@ -137,7 +134,6 @@ typedef struct {
  */
 #define HDFS_HDFST_MAGIC 0x1AD5DE84
 
-
 /***************************************************************************
  *
  * Structure: hdfs_t
@@ -180,13 +176,12 @@ typedef struct {
  ***************************************************************************
  */
 typedef struct {
-    unsigned long  magic;
-    hdfsFS         filesystem;
-    hdfsFileInfo  *fileinfo;
-    hdfsFile       file;
+    unsigned long magic;
+    hdfsFS        filesystem;
+    hdfsFileInfo *fileinfo;
+    hdfsFile      file;
 } hdfs_t;
 
-
 /*--------------------------------------------------------------------------
  * Function:   H5FD_hdfs_handle_open
  *
@@ -202,17 +197,13 @@ typedef struct {
  *--------------------------------------------------------------------------
  */
 static hdfs_t *
-H5FD_hdfs_handle_open(
-        const char    *path,
-        const char    *namenode_name,
-        const int32_t  namenode_port,
-        const char    *user_name,
-        const char    *kerberos_ticket_cache,
-        const int32_t  stream_buffer_size)
+H5FD_hdfs_handle_open(const char *path, const char *namenode_name, const int32_t namenode_port,
+                      const char *user_name, const char *kerberos_ticket_cache,
+                      const int32_t stream_buffer_size)
 {
     struct hdfsBuilder *builder   = NULL;
-    hdfs_t             *handle    = NULL;
-    hdfs_t             *ret_value = NULL;
+    hdfs_t *            handle    = NULL;
+    hdfs_t *            ret_value = NULL;
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -221,26 +212,21 @@ H5FD_hdfs_handle_open(
 #endif
 
     if (path == NULL || path[0] == '\0') {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "path cannot be null.\n")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "path cannot be null.\n")
     }
-    if (namenode_name == NULL /* || namenode_name[0] == '\0' */ ) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "namenode name cannot be null.\n")
+    if (namenode_name == NULL /* || namenode_name[0] == '\0' */) {
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "namenode name cannot be null.\n")
     }
     if (namenode_port < 0 || namenode_port > 65535) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "namenode port must be non-negative and <= 65535.\n")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "namenode port must be non-negative and <= 65535.\n")
     }
     if (stream_buffer_size < 0) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "buffer size must non-negative.\n")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "buffer size must non-negative.\n")
     }
 
     handle = (hdfs_t *)H5MM_malloc(sizeof(hdfs_t));
     if (handle == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_CANTALLOC, NULL,
-                    "could not malloc space for handle.\n")
+        HGOTO_ERROR(H5E_ARGS, H5E_CANTALLOC, NULL, "could not malloc space for handle.\n")
     }
 
     handle->magic      = (unsigned long)HDFS_HDFST_MAGIC;
@@ -250,8 +236,7 @@ H5FD_hdfs_handle_open(
 
     builder = hdfsNewBuilder();
     if (!builder) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "(hdfs) failed to create builder")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "(hdfs) failed to create builder")
     }
     hdfsBuilderSetNameNode(builder, namenode_name);
     hdfsBuilderSetNameNodePort(builder, (tPort)namenode_port);
@@ -264,24 +249,15 @@ H5FD_hdfs_handle_open(
     /* Call to `hdfsBuilderConnect` releases builder, regardless of success. */
     handle->filesystem = hdfsBuilderConnect(builder);
     if (!handle->filesystem) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "(hdfs) could not connect to default namenode")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "(hdfs) could not connect to default namenode")
     }
     handle->fileinfo = hdfsGetPathInfo(handle->filesystem, path);
     if (!handle->fileinfo) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "hdfsGetPathInfo failed")
-    }
-    handle->file = hdfsOpenFile(
-            handle->filesystem,
-            path,
-            O_RDONLY,
-            stream_buffer_size,
-            0,
-            0);
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "hdfsGetPathInfo failed")
+    }
+    handle->file = hdfsOpenFile(handle->filesystem, path, O_RDONLY, stream_buffer_size, 0, 0);
     if (!handle->file) {
-        HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, NULL,
-                    "(hdfs) could not open")
+        HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, NULL, "(hdfs) could not open")
     }
 
     ret_value = handle;
@@ -293,8 +269,7 @@ done:
         handle->magic++;
         if (handle->file != NULL) {
             if (FAIL == (hdfsCloseFile(handle->filesystem, handle->file))) {
-                HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL,
-                            "unable to close hdfs file handle")
+                HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "unable to close hdfs file handle")
             }
         }
         if (handle->fileinfo != NULL) {
@@ -302,8 +277,7 @@ done:
         }
         if (handle->filesystem != NULL) {
             if (FAIL == (hdfsDisconnect(handle->filesystem))) {
-                HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL,
-                            "unable to disconnect from hdfs")
+                HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "unable to disconnect from hdfs")
             }
         }
         H5MM_xfree(handle);
@@ -313,7 +287,6 @@ done:
 
 } /* H5FD_hdfs_handle_open() */
 
-
 /*--------------------------------------------------------------------------
  * Function:   H5FD_hdfs_handle_close
  *
@@ -341,19 +314,16 @@ H5FD_hdfs_handle_close(hdfs_t *handle)
 #endif
 
     if (handle == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "handle cannot be null.\n")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "handle cannot be null.\n")
     }
     if (handle->magic != HDFS_HDFST_MAGIC) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "handle has invalid magic.\n")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "handle has invalid magic.\n")
     }
 
     handle->magic++;
     if (handle->file != NULL) {
         if (FAIL == (hdfsCloseFile(handle->filesystem, handle->file))) {
-            HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL,
-                        "unable to close hdfs file handle")
+            HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to close hdfs file handle")
         }
     }
     if (handle->fileinfo != NULL) {
@@ -361,8 +331,7 @@ H5FD_hdfs_handle_close(hdfs_t *handle)
     }
     if (handle->filesystem != NULL) {
         if (FAIL == (hdfsDisconnect(handle->filesystem))) {
-            HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL,
-                        "unable to disconnect hdfs file system")
+            HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to disconnect hdfs file system")
         }
     }
 
@@ -375,7 +344,6 @@ done:
 
 #endif /* H5_HAVE_LIBHDFS */
 
-
 /***************************************************************************
  *
  * Structure: H5FD_hdfs_t
@@ -437,15 +405,15 @@ done:
  ***************************************************************************
  */
 typedef struct H5FD_hdfs_t {
-    H5FD_t            pub;
-    H5FD_hdfs_fapl_t  fa;
-    haddr_t           eoa;
+    H5FD_t           pub;
+    H5FD_hdfs_fapl_t fa;
+    haddr_t          eoa;
 #ifdef H5_HAVE_LIBHDFS
-    hdfs_t           *hdfs_handle;
+    hdfs_t *hdfs_handle;
 #endif
 #if HDFS_STATS
-    hdfs_statsbin     meta[HDFS_STATS_BIN_COUNT + 1];
-    hdfs_statsbin     raw[HDFS_STATS_BIN_COUNT + 1];
+    hdfs_statsbin meta[HDFS_STATS_BIN_COUNT + 1];
+    hdfs_statsbin raw[HDFS_STATS_BIN_COUNT + 1];
 #endif
 } H5FD_hdfs_t;
 
@@ -459,70 +427,67 @@ typedef struct H5FD_hdfs_t {
  *                  Only included if HDFS code should compile.
  *
  */
-#define MAXADDR (((haddr_t)1<<(8*sizeof(HDoff_t)-1))-1)
+#define MAXADDR (((haddr_t)1 << (8 * sizeof(HDoff_t) - 1)) - 1)
 #ifdef H5_HAVE_LIBHDFS
-#define ADDR_OVERFLOW(A)    (HADDR_UNDEF==(A) || ((A) & ~(haddr_t)MAXADDR))
+#define ADDR_OVERFLOW(A) (HADDR_UNDEF == (A) || ((A) & ~(haddr_t)MAXADDR))
 #endif /* H5_HAVE_LIBHDFS */
 
 /* Prototypes */
 static herr_t  H5FD_hdfs_term(void);
-static void   *H5FD_hdfs_fapl_get(H5FD_t *_file);
-static void   *H5FD_hdfs_fapl_copy(const void *_old_fa);
+static void *  H5FD_hdfs_fapl_get(H5FD_t *_file);
+static void *  H5FD_hdfs_fapl_copy(const void *_old_fa);
 static herr_t  H5FD_hdfs_fapl_free(void *_fa);
-static H5FD_t *H5FD_hdfs_open(const char *name, unsigned flags, hid_t fapl_id,
-                              haddr_t maxaddr);
+static H5FD_t *H5FD_hdfs_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr);
 static herr_t  H5FD_hdfs_close(H5FD_t *_file);
 static int     H5FD_hdfs_cmp(const H5FD_t *_f1, const H5FD_t *_f2);
 static herr_t  H5FD_hdfs_query(const H5FD_t *_f1, unsigned long *flags);
 static haddr_t H5FD_hdfs_get_eoa(const H5FD_t *_file, H5FD_mem_t type);
 static herr_t  H5FD_hdfs_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr);
 static haddr_t H5FD_hdfs_get_eof(const H5FD_t *_file, H5FD_mem_t type);
-static herr_t  H5FD_hdfs_get_handle(H5FD_t *_file, hid_t fapl,
-                                    void** file_handle);
-static herr_t  H5FD_hdfs_read(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id,
-                               haddr_t addr, size_t size, void *buf);
-static herr_t  H5FD_hdfs_write(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id,
-                               haddr_t addr, size_t size, const void *buf);
-static herr_t  H5FD_hdfs_truncate(H5FD_t *_file, hid_t dxpl_id,
-                                  hbool_t closing);
+static herr_t  H5FD_hdfs_get_handle(H5FD_t *_file, hid_t fapl, void **file_handle);
+static herr_t  H5FD_hdfs_read(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr, size_t size,
+                              void *buf);
+static herr_t  H5FD_hdfs_write(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr, size_t size,
+                               const void *buf);
+static herr_t  H5FD_hdfs_truncate(H5FD_t *_file, hid_t dxpl_id, hbool_t closing);
 static herr_t  H5FD_hdfs_lock(H5FD_t *_file, hbool_t rw);
 static herr_t  H5FD_hdfs_unlock(H5FD_t *_file);
-static herr_t  H5FD_hdfs_validate_config(const H5FD_hdfs_fapl_t * fa);
+static herr_t  H5FD_hdfs_validate_config(const H5FD_hdfs_fapl_t *fa);
 
 static const H5FD_class_t H5FD_hdfs_g = {
-    "hdfs",                     /* name                 */
-    MAXADDR,                    /* maxaddr              */
-    H5F_CLOSE_WEAK,             /* fc_degree            */
-    H5FD_hdfs_term,             /* terminate            */
-    NULL,                       /* sb_size              */
-    NULL,                       /* sb_encode            */
-    NULL,                       /* sb_decode            */
-    sizeof(H5FD_hdfs_fapl_t),   /* fapl_size            */
-    H5FD_hdfs_fapl_get,         /* fapl_get             */
-    H5FD_hdfs_fapl_copy,        /* fapl_copy            */
-    H5FD_hdfs_fapl_free,        /* fapl_free            */
-    0,                          /* dxpl_size            */
-    NULL,                       /* dxpl_copy            */
-    NULL,                       /* dxpl_free            */
-    H5FD_hdfs_open,             /* open                 */
-    H5FD_hdfs_close,            /* close                */
-    H5FD_hdfs_cmp,              /* cmp                  */
-    H5FD_hdfs_query,            /* query                */
-    NULL,                       /* get_type_map         */
-    NULL,                       /* alloc                */
-    NULL,                       /* free                 */
-    H5FD_hdfs_get_eoa,          /* get_eoa              */
-    H5FD_hdfs_set_eoa,          /* set_eoa              */
-    H5FD_hdfs_get_eof,          /* get_eof              */
-    H5FD_hdfs_get_handle,       /* get_handle           */
-    H5FD_hdfs_read,             /* read                 */
-    H5FD_hdfs_write,            /* write                */
-    NULL,                       /* flush                */
-    H5FD_hdfs_truncate,         /* truncate             */
-    H5FD_hdfs_lock,             /* lock                 */
-    H5FD_hdfs_unlock,           /* unlock               */
-    NULL,                       /* dedup                */
-    H5FD_FLMAP_DICHOTOMY        /* fl_map               */
+    "hdfs",                   /* name                 */
+    MAXADDR,                  /* maxaddr              */
+    H5F_CLOSE_WEAK,           /* fc_degree            */
+    H5FD_hdfs_term,           /* terminate            */
+    NULL,                     /* sb_size              */
+    NULL,                     /* sb_encode            */
+    NULL,                     /* sb_decode            */
+    sizeof(H5FD_hdfs_fapl_t), /* fapl_size            */
+    H5FD_hdfs_fapl_get,       /* fapl_get             */
+    H5FD_hdfs_fapl_copy,      /* fapl_copy            */
+    H5FD_hdfs_fapl_free,      /* fapl_free            */
+    0,                        /* dxpl_size            */
+    NULL,                     /* dxpl_copy            */
+    NULL,                     /* dxpl_free            */
+    H5FD_hdfs_open,           /* open                 */
+    H5FD_hdfs_close,          /* close                */
+    H5FD_hdfs_cmp,            /* cmp                  */
+    H5FD_hdfs_query,          /* query                */
+    NULL,                     /* get_type_map         */
+    NULL,                     /* alloc                */
+    NULL,                     /* free                 */
+    H5FD_hdfs_get_eoa,        /* get_eoa              */
+    H5FD_hdfs_set_eoa,        /* set_eoa              */
+    H5FD_hdfs_get_eof,        /* get_eof              */
+    H5FD_hdfs_get_handle,     /* get_handle           */
+    H5FD_hdfs_read,           /* read                 */
+    H5FD_hdfs_write,          /* write                */
+    NULL,                     /* flush                */
+    H5FD_hdfs_truncate,       /* truncate             */
+    H5FD_hdfs_lock,           /* lock                 */
+    H5FD_hdfs_unlock,         /* unlock               */
+    NULL,                     /* dedup                */
+    H5FD_FLMAP_DICHOTOMY      /* fl_map               */
 };
 
 #ifdef H5_HAVE_LIBHDFS
@@ -530,7 +495,6 @@ static const H5FD_class_t H5FD_hdfs_g = {
 H5FL_DEFINE_STATIC(H5FD_hdfs_t);
 #endif /* H5_HAVE_LIBHDFS */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD__init_package
  *
@@ -551,8 +515,7 @@ H5FD__init_package(void)
     FUNC_ENTER_STATIC
 
     if (H5FD_hdfs_init() < 0) {
-        HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL,
-                    "unable to initialize hdfs VFD")
+        HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "unable to initialize hdfs VFD")
     }
 
 done:
@@ -560,7 +523,6 @@ done:
 
 } /* H5FD__init_package() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_hdfs_init
  *
@@ -588,13 +550,13 @@ H5FD_hdfs_init(void)
     HDfprintf(stdout, "H5FD_hdfs_init() called.\n");
 #endif
 
-    if(H5I_VFL != H5I_get_type(H5FD_HDFS_g))
-        H5FD_HDFS_g = H5FD_register( &H5FD_hdfs_g, sizeof(H5FD_class_t), FALSE);
+    if (H5I_VFL != H5I_get_type(H5FD_HDFS_g))
+        H5FD_HDFS_g = H5FD_register(&H5FD_hdfs_g, sizeof(H5FD_class_t), FALSE);
 
 #if HDFS_STATS
     /* pre-compute statsbin boundaries
      */
-    for(bin_i = 0; bin_i < HDFS_STATS_BIN_COUNT; bin_i++) {
+    for (bin_i = 0; bin_i < HDFS_STATS_BIN_COUNT; bin_i++) {
         unsigned long long value = 0;
 
         HDFS_STATS_POW(bin_i, &value)
@@ -608,7 +570,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_hdfs_init() */
 
-
 /*---------------------------------------------------------------------------
  * Function:    H5FD_hdfs_term
  *
@@ -639,7 +600,6 @@ H5FD_hdfs_term(void)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5FD_hdfs_term() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5Pset_fapl_hdfs
  *
@@ -659,8 +619,7 @@ H5FD_hdfs_term(void)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Pset_fapl_hdfs(hid_t             fapl_id,
-                 H5FD_hdfs_fapl_t *fa)
+H5Pset_fapl_hdfs(hid_t fapl_id, H5FD_hdfs_fapl_t *fa)
 {
     H5P_genplist_t *plist     = NULL; /* Property list pointer */
     herr_t          ret_value = FAIL;
@@ -676,13 +635,11 @@ H5Pset_fapl_hdfs(hid_t             fapl_id,
 
     plist = H5P_object_verify(fapl_id, H5P_FILE_ACCESS);
     if (plist == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, \
-                    "not a file access property list")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access property list")
     }
 
     if (FAIL == H5FD_hdfs_validate_config(fa)) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "invalid hdfs config")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid hdfs config")
     }
 
     ret_value = H5P_set_driver(plist, H5FD_HDFS, (void *)fa);
@@ -692,7 +649,6 @@ done:
 
 } /* H5Pset_fapl_hdfs() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_hdfs_validate_config()
  *
@@ -716,7 +672,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_hdfs_validate_config(const H5FD_hdfs_fapl_t * fa)
+H5FD_hdfs_validate_config(const H5FD_hdfs_fapl_t *fa)
 {
     herr_t ret_value = SUCCEED;
 
@@ -724,18 +680,15 @@ H5FD_hdfs_validate_config(const H5FD_hdfs_fapl_t * fa)
 
     HDassert(fa != NULL);
 
-    if ( fa->version != H5FD__CURR_HDFS_FAPL_T_VERSION ) {
-         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                     "Unknown H5FD_hdfs_fapl_t version");
+    if (fa->version != H5FD__CURR_HDFS_FAPL_T_VERSION) {
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Unknown H5FD_hdfs_fapl_t version");
     }
 
-    if ( fa->namenode_port > 65535 ) {
-         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                     "Invalid namenode port number");
+    if (fa->namenode_port > 65535) {
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Invalid namenode port number");
     }
-    if ( fa->namenode_port < 0 ) {
-         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                     "Invalid namenode port number");
+    if (fa->namenode_port < 0) {
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Invalid namenode port number");
     }
 
 done:
@@ -743,7 +696,6 @@ done:
 
 } /* H5FD_hdfs_validate_config() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5Pget_fapl_hdfs
  *
@@ -762,11 +714,10 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Pget_fapl_hdfs(hid_t             fapl_id,
-                 H5FD_hdfs_fapl_t *fa_out)
+H5Pget_fapl_hdfs(hid_t fapl_id, H5FD_hdfs_fapl_t *fa_out)
 {
     const H5FD_hdfs_fapl_t *fa        = NULL;
-    H5P_genplist_t         *plist     = NULL;
+    H5P_genplist_t *        plist     = NULL;
     herr_t                  ret_value = SUCCEED;
 
     FUNC_ENTER_API(FAIL)
@@ -777,23 +728,19 @@ H5Pget_fapl_hdfs(hid_t             fapl_id,
 #endif
 
     if (fa_out == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "fa_out is NULL")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "fa_out is NULL")
     }
     plist = H5P_object_verify(fapl_id, H5P_FILE_ACCESS);
     if (plist == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL,
-                    "not a file access list")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access list")
     }
     if (H5FD_HDFS != H5P_peek_driver(plist)) {
-        HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL,
-                    "incorrect VFL driver")
+        HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "incorrect VFL driver")
     }
 
     fa = (const H5FD_hdfs_fapl_t *)H5P_peek_driver_info(plist);
     if (fa == NULL) {
-        HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL,
-                    "bad VFL driver info")
+        HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "bad VFL driver info")
     }
 
     /* Copy the hdfs fapl data out */
@@ -804,7 +751,6 @@ done:
 
 } /* H5Pget_fapl_hdfs() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_hdfs_fapl_get
  *
@@ -825,16 +771,15 @@ done:
 static void *
 H5FD_hdfs_fapl_get(H5FD_t *_file)
 {
-    H5FD_hdfs_t      *file      = (H5FD_hdfs_t*)_file;
+    H5FD_hdfs_t *     file      = (H5FD_hdfs_t *)_file;
     H5FD_hdfs_fapl_t *fa        = NULL;
-    void             *ret_value = NULL;
+    void *            ret_value = NULL;
 
     FUNC_ENTER_NOAPI_NOINIT
 
     fa = (H5FD_hdfs_fapl_t *)H5MM_calloc(sizeof(H5FD_hdfs_fapl_t));
     if (fa == NULL) {
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL,
-                    "memory allocation failed")
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
     }
 
     /* Copy the fields of the structure */
@@ -851,7 +796,6 @@ done:
 
 } /* H5FD_hdfs_fapl_get() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_hdfs_fapl_copy
  *
@@ -871,16 +815,15 @@ done:
 static void *
 H5FD_hdfs_fapl_copy(const void *_old_fa)
 {
-    const H5FD_hdfs_fapl_t *old_fa    = (const H5FD_hdfs_fapl_t*)_old_fa;
-    H5FD_hdfs_fapl_t       *new_fa    = NULL;
-    void                   *ret_value = NULL;
+    const H5FD_hdfs_fapl_t *old_fa    = (const H5FD_hdfs_fapl_t *)_old_fa;
+    H5FD_hdfs_fapl_t *      new_fa    = NULL;
+    void *                  ret_value = NULL;
 
     FUNC_ENTER_NOAPI_NOINIT
 
     new_fa = (H5FD_hdfs_fapl_t *)H5MM_malloc(sizeof(H5FD_hdfs_fapl_t));
     if (new_fa == NULL) {
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL,
-                    "memory allocation failed")
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
     }
 
     HDmemcpy(new_fa, old_fa, sizeof(H5FD_hdfs_fapl_t));
@@ -895,7 +838,6 @@ done:
 
 } /* H5FD_hdfs_fapl_copy() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_hdfs_fapl_free
  *
@@ -913,7 +855,7 @@ done:
 static herr_t
 H5FD_hdfs_fapl_free(void *_fa)
 {
-    H5FD_hdfs_fapl_t *fa = (H5FD_hdfs_fapl_t*)_fa;
+    H5FD_hdfs_fapl_t *fa = (H5FD_hdfs_fapl_t *)_fa;
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -963,15 +905,14 @@ hdfs_reset_stats(H5FD_hdfs_t *file)
 #endif
 
     if (file == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "file was null")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file was null")
     }
 
     for (i = 0; i <= HDFS_STATS_BIN_COUNT; i++) {
-        file->raw[i].bytes  = 0;
-        file->raw[i].count  = 0;
-        file->raw[i].min    = (unsigned long long)HDFS_STATS_STARTING_MIN;
-        file->raw[i].max    = 0;
+        file->raw[i].bytes = 0;
+        file->raw[i].count = 0;
+        file->raw[i].min   = (unsigned long long)HDFS_STATS_STARTING_MIN;
+        file->raw[i].max   = 0;
 
         file->meta[i].bytes = 0;
         file->meta[i].count = 0;
@@ -985,7 +926,6 @@ done:
 } /* hdfs_reset_stats */
 #endif /* HDFS_STATS */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD_hdfs_open()
@@ -1013,16 +953,12 @@ done:
  */
 #ifdef H5_HAVE_LIBHDFS
 static H5FD_t *
-H5FD_hdfs_open(
-        const char *path,
-        unsigned    flags,
-        hid_t       fapl_id,
-        haddr_t     maxaddr)
+H5FD_hdfs_open(const char *path, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
 {
-    H5FD_t           *ret_value = NULL;
-    H5FD_hdfs_t      *file      = NULL;
-    hdfs_t           *handle    = NULL;
-    H5FD_hdfs_fapl_t  fa;
+    H5FD_t *         ret_value = NULL;
+    H5FD_hdfs_t *    file      = NULL;
+    hdfs_t *         handle    = NULL;
+    H5FD_hdfs_fapl_t fa;
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -1035,41 +971,29 @@ H5FD_hdfs_open(
 
     /* Check arguments */
     if (!path || !*path) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "invalid file name")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid file name")
     }
     if (0 == maxaddr || HADDR_UNDEF == maxaddr) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, NULL,
-                    "bogus maxaddr")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, NULL, "bogus maxaddr")
     }
     if (ADDR_OVERFLOW(maxaddr)) {
-        HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, NULL,
-                    "bogus maxaddr")
+        HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, NULL, "bogus maxaddr")
     }
     if (flags != H5F_ACC_RDONLY) {
-        HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, NULL,
-                    "only Read-Only access allowed")
+        HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, NULL, "only Read-Only access allowed")
     }
     if (fapl_id == H5P_DEFAULT || fapl_id == H5P_FILE_ACCESS_DEFAULT) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "fapl cannot be H5P_DEFAULT")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "fapl cannot be H5P_DEFAULT")
     }
     if (FAIL == H5Pget_fapl_hdfs(fapl_id, &fa)) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "can't get property list")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "can't get property list")
     }
 
-    handle = H5FD_hdfs_handle_open(
-            path,
-            fa.namenode_name,
-            fa.namenode_port,
-            fa.user_name,
-            fa.kerberos_ticket_cache,
-            fa.stream_buffer_size);
+    handle = H5FD_hdfs_handle_open(path, fa.namenode_name, fa.namenode_port, fa.user_name,
+                                   fa.kerberos_ticket_cache, fa.stream_buffer_size);
 
     if (handle == NULL) {
-        HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, NULL,
-                    "could not open")
+        HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, NULL, "could not open")
     }
 
     HDassert(handle->magic == HDFS_HDFST_MAGIC);
@@ -1078,27 +1002,24 @@ H5FD_hdfs_open(
      */
     file = H5FL_CALLOC(H5FD_hdfs_t);
     if (file == NULL) {
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL,
-                    "unable to allocate file struct")
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "unable to allocate file struct")
     }
     file->hdfs_handle = handle;
     HDmemcpy(&(file->fa), &fa, sizeof(H5FD_hdfs_fapl_t));
 
 #if HDFS_STATS
     if (FAIL == hdfs_reset_stats(file)) {
-        HGOTO_ERROR(H5E_INTERNAL, H5E_UNINITIALIZED, NULL,
-                    "unable to reset file statistics")
+        HGOTO_ERROR(H5E_INTERNAL, H5E_UNINITIALIZED, NULL, "unable to reset file statistics")
     }
 #endif /* HDFS_STATS */
 
-    ret_value = (H5FD_t*)file;
+    ret_value = (H5FD_t *)file;
 
 done:
     if (ret_value == NULL) {
         if (handle != NULL) {
             if (FAIL == H5FD_hdfs_handle_close(handle)) {
-                HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL,
-                            "unable to close HDFS file handle")
+                HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "unable to close HDFS file handle")
             }
         }
         if (file != NULL) {
@@ -1113,18 +1034,14 @@ done:
 #else /* H5_HAVE_LIBHDFS not defined */
 
 static H5FD_t *
-H5FD_hdfs_open(
-        const char H5_ATTR_UNUSED *path,
-        unsigned   H5_ATTR_UNUSED  flags,
-        hid_t      H5_ATTR_UNUSED  fapl_id,
-        haddr_t    H5_ATTR_UNUSED  maxaddr)
+H5FD_hdfs_open(const char H5_ATTR_UNUSED *path, unsigned H5_ATTR_UNUSED flags, hid_t H5_ATTR_UNUSED fapl_id,
+               haddr_t H5_ATTR_UNUSED maxaddr)
 {
-    H5FD_t           *ret_value = NULL;
+    H5FD_t *ret_value = NULL;
 
     FUNC_ENTER_NOAPI_NOINIT
 
-    HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, NULL,
-                "Illegal open of unsupported virtual file (hdfs)");
+    HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, NULL, "Illegal open of unsupported virtual file (hdfs)");
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1192,44 +1109,38 @@ done:
  *----------------------------------------------------------------------------
  */
 static herr_t
-hdfs_fprint_stats(
-        FILE              *stream,
-        const H5FD_hdfs_t *file)
+hdfs_fprint_stats(FILE *stream, const H5FD_hdfs_t *file)
 {
     herr_t             ret_value    = SUCCEED;
-    parsed_url_t      *purl         = NULL;
+    parsed_url_t *     purl         = NULL;
     unsigned           i            = 0;
     unsigned long      count_meta   = 0;
     unsigned long      count_raw    = 0;
     double             average_meta = 0.0;
     double             average_raw  = 0.0;
-    unsigned long long min_meta  = (unsigned long long)HDFS_STATS_STARTING_MIN;
-    unsigned long long min_raw   = (unsigned long long)HDFS_STATS_STARTING_MIN;
+    unsigned long long min_meta     = (unsigned long long)HDFS_STATS_STARTING_MIN;
+    unsigned long long min_raw      = (unsigned long long)HDFS_STATS_STARTING_MIN;
     unsigned long long max_meta     = 0;
     unsigned long long max_raw      = 0;
     unsigned long long bytes_raw    = 0;
     unsigned long long bytes_meta   = 0;
     double             re_dub       = 0.0; /* re-usable double variable */
     unsigned           suffix_i     = 0;
-    const char         suffixes[]   = { ' ', 'K', 'M', 'G', 'T', 'P' };
+    const char         suffixes[]   = {' ', 'K', 'M', 'G', 'T', 'P'};
 
     FUNC_ENTER_NOAPI_NOINIT
 
     if (stream == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "file stream cannot be null" )
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file stream cannot be null")
     }
     if (file == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "file cannot be null")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file cannot be null")
     }
     if (file->hdfs_handle == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "hdfs handle cannot be null")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hdfs handle cannot be null")
     }
     if (file->hdfs_handle->magic != HDFS_HDFST_MAGIC) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "hdfs handle has invalid magic")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hdfs handle has invalid magic")
     }
 
     /*******************
@@ -1240,18 +1151,26 @@ hdfs_fprint_stats(
         const hdfs_statsbin *r = &file->raw[i];
         const hdfs_statsbin *m = &file->meta[i];
 
-        if (m->min < min_meta)  { min_meta = m->min; }
-        if (r->min < min_raw)   { min_raw  = r->min; }
-        if (m->max > max_meta)  { max_meta = m->max; }
-        if (r->max > max_raw)   { max_raw  = r->max; }
+        if (m->min < min_meta) {
+            min_meta = m->min;
+        }
+        if (r->min < min_raw) {
+            min_raw = r->min;
+        }
+        if (m->max > max_meta) {
+            max_meta = m->max;
+        }
+        if (r->max > max_raw) {
+            max_raw = r->max;
+        }
 
-        count_raw  += r->count;
+        count_raw += r->count;
         count_meta += m->count;
-        bytes_raw  += r->bytes;
+        bytes_raw += r->bytes;
         bytes_meta += m->bytes;
     }
-    if (count_raw  > 0) {
-        average_raw  = (double)bytes_raw / (double)count_raw;
+    if (count_raw > 0) {
+        average_raw = (double)bytes_raw / (double)count_raw;
     }
     if (count_meta > 0) {
         average_meta = (double)bytes_meta / (double)count_meta;
@@ -1261,10 +1180,10 @@ hdfs_fprint_stats(
      * PRINT OVERVIEW *
      ******************/
 
-    HDfprintf(stream, "TOTAL READS: %llu  (%llu meta, %llu raw)\n",
-              count_raw + count_meta, count_meta, count_raw);
-    HDfprintf(stream, "TOTAL BYTES: %llu  (%llu meta, %llu raw)\n",
-              bytes_raw + bytes_meta, bytes_meta, bytes_raw);
+    HDfprintf(stream, "TOTAL READS: %llu  (%llu meta, %llu raw)\n", count_raw + count_meta, count_meta,
+              count_raw);
+    HDfprintf(stream, "TOTAL BYTES: %llu  (%llu meta, %llu raw)\n", bytes_raw + bytes_meta, bytes_meta,
+              bytes_raw);
 
     if (count_raw + count_meta == 0) {
         goto done;
@@ -1278,7 +1197,8 @@ hdfs_fprint_stats(
     HDfprintf(stream, "  min ");
     if (count_meta == 0) {
         HDfprintf(stream, "   0.000  ");
-    } else {
+    }
+    else {
         re_dub = (double)min_meta;
         for (suffix_i = 0; re_dub >= 1024.0; suffix_i++) {
             re_dub /= 1024.0;
@@ -1289,7 +1209,8 @@ hdfs_fprint_stats(
 
     if (count_raw == 0) {
         HDfprintf(stream, "   0.000 \n");
-    } else {
+    }
+    else {
         re_dub = (double)min_raw;
         for (suffix_i = 0; re_dub >= 1024.0; suffix_i++) {
             re_dub /= 1024.0;
@@ -1332,10 +1253,8 @@ hdfs_fprint_stats(
      * PRINT INDIVIDUAL BIN STATS *
      ******************************/
 
-    HDfprintf(stream,
-        "BINS             # of reads      total bytes         average size\n");
-    HDfprintf(stream,
-        "    up-to      meta     raw     meta      raw       meta      raw\n");
+    HDfprintf(stream, "BINS             # of reads      total bytes         average size\n");
+    HDfprintf(stream, "    up-to      meta     raw     meta      raw       meta      raw\n");
 
     for (i = 0; i <= HDFS_STATS_BIN_COUNT; i++) {
         const hdfs_statsbin *m;
@@ -1359,9 +1278,10 @@ hdfs_fprint_stats(
         range_end = hdfs_stats_boundaries[i];
 
         if (i == HDFS_STATS_BIN_COUNT) {
-            range_end = hdfs_stats_boundaries[i-1];
+            range_end = hdfs_stats_boundaries[i - 1];
             HDfprintf(stream, ">");
-        } else {
+        }
+        else {
             HDfprintf(stream, " ");
         }
 
@@ -1403,16 +1323,14 @@ hdfs_fprint_stats(
         }
         HDassert(suffix_i < sizeof(suffixes));
 
-        HDfprintf(
-                stream,
-                " %8.3f%c %7d %7d %8.3f%c %8.3f%c %8.3f%c %8.3f%c\n",
-                re_dub, suffixes[suffix_i], /* bin ceiling      */
-                m->count,                   /* metadata reads   */
-                r->count,                   /* rawdata reads    */
-                bm_val, bm_suffix,          /* metadata bytes   */
-                br_val, br_suffix,          /* rawdata bytes    */
-                am_val, am_suffix,          /* metadata average */
-                ar_val, ar_suffix);         /* rawdata average  */
+        HDfprintf(stream, " %8.3f%c %7d %7d %8.3f%c %8.3f%c %8.3f%c %8.3f%c\n", re_dub,
+                  suffixes[suffix_i], /* bin ceiling      */
+                  m->count,           /* metadata reads   */
+                  r->count,           /* rawdata reads    */
+                  bm_val, bm_suffix,  /* metadata bytes   */
+                  br_val, br_suffix,  /* rawdata bytes    */
+                  am_val, am_suffix,  /* metadata average */
+                  ar_val, ar_suffix); /* rawdata average  */
         fflush(stream);
     }
 
@@ -1421,7 +1339,6 @@ done:
 } /* hdfs_fprint_stats */
 #endif /* HDFS_STATS */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD_hdfs_close()
@@ -1465,16 +1382,14 @@ H5FD_hdfs_close(H5FD_t *_file)
      */
     if (file->hdfs_handle != NULL) {
         if (FAIL == H5FD_hdfs_handle_close(file->hdfs_handle)) {
-            HGOTO_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL,
-                        "unable to close HDFS file handle")
+            HGOTO_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to close HDFS file handle")
         }
     }
 
 #if HDFS_STATS
     /* TODO: mechanism to re-target stats printout */
     if (FAIL == hdfs_fprint_stats(stdout, file)) {
-        HGOTO_ERROR(H5E_INTERNAL, H5E_ERROR, FAIL,
-                    "problem while writing file statistics")
+        HGOTO_ERROR(H5E_INTERNAL, H5E_ERROR, FAIL, "problem while writing file statistics")
     }
 #endif /* HDFS_STATS */
 
@@ -1491,12 +1406,11 @@ done:
 static herr_t
 H5FD_hdfs_close(H5FD_t H5_ATTR_UNUSED *_file)
 {
-    herr_t       ret_value = SUCCEED;
+    herr_t ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT
 
-    HGOTO_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL,
-                "Illegal close of unsupported Virtual File (hdfs)")
+    HGOTO_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "Illegal close of unsupported Virtual File (hdfs)")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1504,7 +1418,6 @@ done:
 
 #endif /* H5_HAVE_LIBHDFS */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD_hdfs_cmp()
@@ -1531,15 +1444,13 @@ done:
 #ifdef H5_HAVE_LIBHDFS
 
 static int
-H5FD_hdfs_cmp(
-        const H5FD_t *_f1,
-        const H5FD_t *_f2)
+H5FD_hdfs_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
 {
     int                ret_value = 0;
     const H5FD_hdfs_t *f1        = (const H5FD_hdfs_t *)_f1;
     const H5FD_hdfs_t *f2        = (const H5FD_hdfs_t *)_f2;
-    hdfsFileInfo      *finfo1    = NULL;
-    hdfsFileInfo      *finfo2    = NULL;
+    hdfsFileInfo *     finfo1    = NULL;
+    hdfsFileInfo *     finfo2    = NULL;
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -1557,16 +1468,36 @@ H5FD_hdfs_cmp(
     HDassert(finfo1 != NULL);
     HDassert(finfo2 != NULL);
 
-    if (finfo1->mKind        != finfo2->mKind)        { HGOTO_DONE(-1); }
-    if (finfo1->mName        != finfo2->mName)        { HGOTO_DONE(-1); }
-    if (finfo1->mLastMod     != finfo2->mLastMod)     { HGOTO_DONE(-1); }
-    if (finfo1->mSize        != finfo2->mSize)        { HGOTO_DONE(-1); }
-    if (finfo1->mReplication != finfo2->mReplication) { HGOTO_DONE(-1); }
-    if (finfo1->mBlockSize   != finfo2->mBlockSize)   { HGOTO_DONE(-1); }
-    if (strcmp(finfo1->mOwner, finfo2->mOwner))       { HGOTO_DONE(-1); }
-    if (strcmp(finfo1->mGroup, finfo2->mGroup))       { HGOTO_DONE(-1); }
-    if (finfo1->mPermissions != finfo2->mPermissions) { HGOTO_DONE(-1); }
-    if (finfo1->mLastAccess  != finfo2->mLastAccess)  { HGOTO_DONE(-1); }
+    if (finfo1->mKind != finfo2->mKind) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mName != finfo2->mName) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mLastMod != finfo2->mLastMod) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mSize != finfo2->mSize) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mReplication != finfo2->mReplication) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mBlockSize != finfo2->mBlockSize) {
+        HGOTO_DONE(-1);
+    }
+    if (strcmp(finfo1->mOwner, finfo2->mOwner)) {
+        HGOTO_DONE(-1);
+    }
+    if (strcmp(finfo1->mGroup, finfo2->mGroup)) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mPermissions != finfo2->mPermissions) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mLastAccess != finfo2->mLastAccess) {
+        HGOTO_DONE(-1);
+    }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1575,11 +1506,9 @@ done:
 #else /* H5_HAVE_LIBHDFS not defined */
 
 static int
-H5FD_hdfs_cmp(
-        const H5FD_t H5_ATTR_UNUSED *_f1,
-        const H5FD_t H5_ATTR_UNUSED *_f2)
+H5FD_hdfs_cmp(const H5FD_t H5_ATTR_UNUSED *_f1, const H5FD_t H5_ATTR_UNUSED *_f2)
 {
-    int                ret_value = 0;
+    int ret_value = 0;
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -1588,7 +1517,6 @@ H5FD_hdfs_cmp(
 
 #endif /* H5_HAVE_LIBHDFS */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_hdfs_query
  *
@@ -1609,9 +1537,7 @@ H5FD_hdfs_cmp(
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_hdfs_query(
-        const H5FD_t  H5_ATTR_UNUSED *_file,
-        unsigned long                *flags) /* out variable */
+H5FD_hdfs_query(const H5FD_t H5_ATTR_UNUSED *_file, unsigned long *flags) /* out variable */
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -1627,7 +1553,6 @@ H5FD_hdfs_query(
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* H5FD_hdfs_query() */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD_hdfs_get_eoa()
@@ -1652,9 +1577,7 @@ H5FD_hdfs_query(
 #ifdef H5_HAVE_LIBHDFS
 
 static haddr_t
-H5FD_hdfs_get_eoa(
-        const H5FD_t                *_file,
-        H5FD_mem_t   H5_ATTR_UNUSED  type)
+H5FD_hdfs_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 {
     const H5FD_hdfs_t *file = (const H5FD_hdfs_t *)_file;
 
@@ -1670,9 +1593,7 @@ H5FD_hdfs_get_eoa(
 #else /* H5_HAVE_LIBHDFS not defined */
 
 static haddr_t
-H5FD_hdfs_get_eoa(
-        const H5FD_t H5_ATTR_UNUSED *_file,
-        H5FD_mem_t   H5_ATTR_UNUSED  type)
+H5FD_hdfs_get_eoa(const H5FD_t H5_ATTR_UNUSED *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -1685,7 +1606,6 @@ H5FD_hdfs_get_eoa(
 
 #endif /* H5_HAVE_LIBHDFS */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD_hdfs_set_eoa()
@@ -1708,10 +1628,7 @@ H5FD_hdfs_get_eoa(
 #ifdef H5_HAVE_LIBHDFS
 
 static herr_t
-H5FD_hdfs_set_eoa(
-        H5FD_t                    *_file,
-        H5FD_mem_t H5_ATTR_UNUSED  type,
-        haddr_t                    addr)
+H5FD_hdfs_set_eoa(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t addr)
 {
     H5FD_hdfs_t *file = (H5FD_hdfs_t *)_file;
 
@@ -1729,10 +1646,7 @@ H5FD_hdfs_set_eoa(
 #else /* H5_HAVE_LIBHDFS not defined */
 
 static herr_t
-H5FD_hdfs_set_eoa(
-        H5FD_t     H5_ATTR_UNUSED *_file,
-        H5FD_mem_t H5_ATTR_UNUSED  type,
-        haddr_t    H5_ATTR_UNUSED  addr)
+H5FD_hdfs_set_eoa(H5FD_t H5_ATTR_UNUSED *_file, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t H5_ATTR_UNUSED addr)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -1745,7 +1659,6 @@ H5FD_hdfs_set_eoa(
 
 #endif /* H5_HAVE_LIBHDFS */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD_hdfs_get_eof()
@@ -1767,9 +1680,7 @@ H5FD_hdfs_set_eoa(
 #ifdef H5_HAVE_LIBHDFS
 
 static haddr_t
-H5FD_hdfs_get_eof(
-        const H5FD_t                *_file,
-        H5FD_mem_t   H5_ATTR_UNUSED  type)
+H5FD_hdfs_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 {
     const H5FD_hdfs_t *file = (const H5FD_hdfs_t *)_file;
 
@@ -1782,15 +1693,13 @@ H5FD_hdfs_get_eof(
     HDassert(file->hdfs_handle != NULL);
     HDassert(file->hdfs_handle->magic == HDFS_HDFST_MAGIC);
 
-    FUNC_LEAVE_NOAPI((size_t) file->hdfs_handle->fileinfo->mSize)
+    FUNC_LEAVE_NOAPI((size_t)file->hdfs_handle->fileinfo->mSize)
 } /* end H5FD_hdfs_get_eof() */
 
 #else /* H5_HAVE_LIBHDFS not defined */
 
 static haddr_t
-H5FD_hdfs_get_eof(
-        const H5FD_t H5_ATTR_UNUSED *_file,
-        H5FD_mem_t   H5_ATTR_UNUSED  type)
+H5FD_hdfs_get_eof(const H5FD_t H5_ATTR_UNUSED *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -1803,7 +1712,6 @@ H5FD_hdfs_get_eof(
 
 #endif /* H5_HAVE_LIBHDFS */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD_hdfs_get_handle()
@@ -1826,10 +1734,7 @@ H5FD_hdfs_get_eof(
 #ifdef H5_HAVE_LIBHDFS
 
 static herr_t
-H5FD_hdfs_get_handle(
-        H5FD_t                 *_file,
-        hid_t  H5_ATTR_UNUSED   fapl,
-        void                  **file_handle)
+H5FD_hdfs_get_handle(H5FD_t *_file, hid_t H5_ATTR_UNUSED fapl, void **file_handle)
 {
     herr_t       ret_value = SUCCEED;
     H5FD_hdfs_t *file      = (H5FD_hdfs_t *)_file;
@@ -1841,8 +1746,7 @@ H5FD_hdfs_get_handle(
 #endif /* HDFS_DEBUG */
 
     if (!file_handle) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "file handle not valid")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file handle not valid")
     }
 
     *file_handle = file->hdfs_handle;
@@ -1854,12 +1758,10 @@ done:
 #else /* H5_HAVE_LIBHDFS not defined */
 
 static herr_t
-H5FD_hdfs_get_handle(
-        H5FD_t H5_ATTR_UNUSED  *_file,
-        hid_t  H5_ATTR_UNUSED   fapl,
-        void   H5_ATTR_UNUSED **file_handle)
+H5FD_hdfs_get_handle(H5FD_t H5_ATTR_UNUSED *_file, hid_t H5_ATTR_UNUSED fapl,
+                     void H5_ATTR_UNUSED **file_handle)
 {
-    herr_t       ret_value = SUCCEED;
+    herr_t ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -1867,8 +1769,7 @@ H5FD_hdfs_get_handle(
     HDfprintf(stdout, "H5FD_hdfs_get_handle() called.\n");
 #endif /* HDFS_DEBUG */
 
-    HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL,
-                "Illegal get-handle of unsupported virtual file (hdfs)");
+    HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL, "Illegal get-handle of unsupported virtual file (hdfs)");
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1876,7 +1777,6 @@ done:
 
 #endif /* H5_HAVE_LIBHDFS */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD_hdfs_read()
@@ -1904,13 +1804,10 @@ done:
 #ifdef H5_HAVE_LIBHDFS
 
 static herr_t
-H5FD_hdfs_read(
-        H5FD_t                    *_file,
-        H5FD_mem_t H5_ATTR_UNUSED  type,
-        hid_t      H5_ATTR_UNUSED  dxpl_id,
-        haddr_t                    addr, /* start offset   */
-        size_t                     size, /* length of read */
-        void                      *buf)  /* out            */
+H5FD_hdfs_read(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_UNUSED dxpl_id,
+               haddr_t addr, /* start offset   */
+               size_t  size, /* length of read */
+               void *  buf)    /* out            */
 {
     herr_t       ret_value = SUCCEED;
     H5FD_hdfs_t *file      = (H5FD_hdfs_t *)_file;
@@ -1932,22 +1829,15 @@ H5FD_hdfs_read(
     HDassert(file->hdfs_handle->magic == HDFS_HDFST_MAGIC);
     HDassert(buf != NULL);
 
-    filesize = (size_t) file->hdfs_handle->fileinfo->mSize;
+    filesize = (size_t)file->hdfs_handle->fileinfo->mSize;
 
     if ((addr > filesize) || ((addr + size) > filesize)) {
-        HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL,
-                    "range exceeds file address")
+        HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "range exceeds file address")
     }
 
-    if (FAIL == hdfsPread(
-            file->hdfs_handle->filesystem,
-            file->hdfs_handle->file,
-            (tOffset)addr,
-            buf,
-            (tSize)size))
-    {
-        HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL,
-                    "unable to execute read")
+    if (FAIL ==
+        hdfsPread(file->hdfs_handle->filesystem, file->hdfs_handle->file, (tOffset)addr, buf, (tSize)size)) {
+        HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "unable to execute read")
     }
 
 #if HDFS_STATS
@@ -1959,9 +1849,7 @@ H5FD_hdfs_read(
             break;
         }
     }
-    bin = (type == H5FD_MEM_DRAW)
-        ? &file->raw[bin_i]
-        : &file->meta[bin_i];
+    bin = (type == H5FD_MEM_DRAW) ? &file->raw[bin_i] : &file->meta[bin_i];
 
     /* Store collected stats in appropriate bin
      */
@@ -1970,8 +1858,12 @@ H5FD_hdfs_read(
         bin->max = size;
     }
     else {
-        if (size < bin->min) { bin->min = size; }
-        if (size > bin->max) { bin->max = size; }
+        if (size < bin->min) {
+            bin->min = size;
+        }
+        if (size > bin->max) {
+            bin->max = size;
+        }
     }
     bin->count++;
     bin->bytes += (unsigned long long)size;
@@ -1985,15 +1877,10 @@ done:
 #else /* H5_HAVE_LIBHDFS not defined */
 
 static herr_t
-H5FD_hdfs_read(
-        H5FD_t     H5_ATTR_UNUSED *_file,
-        H5FD_mem_t H5_ATTR_UNUSED  type,
-        hid_t      H5_ATTR_UNUSED  dxpl_id,
-        haddr_t    H5_ATTR_UNUSED  addr,
-        size_t     H5_ATTR_UNUSED  size,
-        void       H5_ATTR_UNUSED *buf)
+H5FD_hdfs_read(H5FD_t H5_ATTR_UNUSED *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_UNUSED dxpl_id,
+               haddr_t H5_ATTR_UNUSED addr, size_t H5_ATTR_UNUSED size, void H5_ATTR_UNUSED *buf)
 {
-    herr_t       ret_value = SUCCEED;
+    herr_t ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -2001,8 +1888,7 @@ H5FD_hdfs_read(
     HDfprintf(stdout, "H5FD_hdfs_read() called.\n");
 #endif /* HDFS_DEBUG */
 
-    HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL,
-                "Illegal get-handle of unsupported virtual file (hdfs)");
+    HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL, "Illegal get-handle of unsupported virtual file (hdfs)");
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -2010,7 +1896,6 @@ done:
 
 #endif /* H5_HAVE_LIBHDFS */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD_hdfs_write()
@@ -2032,13 +1917,8 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_hdfs_write(
-        H5FD_t     H5_ATTR_UNUSED *_file,
-        H5FD_mem_t H5_ATTR_UNUSED  type,
-        hid_t      H5_ATTR_UNUSED  dxpl_id,
-        haddr_t    H5_ATTR_UNUSED  addr,
-        size_t     H5_ATTR_UNUSED  size,
-        const void H5_ATTR_UNUSED *buf)
+H5FD_hdfs_write(H5FD_t H5_ATTR_UNUSED *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_UNUSED dxpl_id,
+                haddr_t H5_ATTR_UNUSED addr, size_t H5_ATTR_UNUSED size, const void H5_ATTR_UNUSED *buf)
 {
     herr_t ret_value = FAIL;
 
@@ -2048,14 +1928,12 @@ H5FD_hdfs_write(
     HDfprintf(stdout, "H5FD_hdfs_write() called.\n");
 #endif
 
-    HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL,
-                "cannot write to read-only file.")
+    HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL, "cannot write to read-only file.")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5FD_hdfs_write() */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD_hdfs_truncate()
@@ -2079,10 +1957,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_hdfs_truncate(
-        H5FD_t  H5_ATTR_UNUSED *_file,
-        hid_t   H5_ATTR_UNUSED  dxpl_id,
-        hbool_t H5_ATTR_UNUSED  closing)
+H5FD_hdfs_truncate(H5FD_t H5_ATTR_UNUSED *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t H5_ATTR_UNUSED closing)
 {
     herr_t ret_value = SUCCEED;
 
@@ -2092,14 +1967,12 @@ H5FD_hdfs_truncate(
     HDfprintf(stdout, "H5FD_hdfs_truncate() called.\n");
 #endif
 
-    HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL,
-                "cannot truncate read-only file.")
+    HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL, "cannot truncate read-only file.")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_hdfs_truncate() */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD_hdfs_lock()
@@ -2124,15 +1997,12 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_hdfs_lock(
-        H5FD_t  H5_ATTR_UNUSED *_file,
-        hbool_t H5_ATTR_UNUSED  rw)
+H5FD_hdfs_lock(H5FD_t H5_ATTR_UNUSED *_file, hbool_t H5_ATTR_UNUSED rw)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5FD_hdfs_lock() */
 
-
 /*-------------------------------------------------------------------------
  *
  * Function: H5FD_hdfs_unlock()
@@ -2159,4 +2029,3 @@ H5FD_hdfs_unlock(H5FD_t H5_ATTR_UNUSED *_file)
     FUNC_ENTER_NOAPI_NOINIT_NOERR
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5FD_hdfs_unlock() */
-